GLchar = AnsiChar;
GLbitfield = Cardinal;
GLint = Integer;
+ GLintptr = GLint;
GLboolean = ByteBool;
GLsizei = Integer;
+ GLsizeiptr = GLsizei;
GLfloat = Single;
GLdouble = Double;
TGLvectori3 = array[0..2] of GLint;
TGLvectori4 = array[0..3] of GLint;
+ TGLvectorui2 = array[0..1] of GLuint;
+ TGLvectorui3 = array[0..2] of GLuint;
+ TGLvectorui4 = array[0..3] of GLuint;
+
TGLvectorf2 = array[0..1] of GLfloat;
TGLvectorf3 = array[0..2] of GLfloat;
TGLvectorf4 = array[0..3] of GLfloat;
TglBindBuffer = procedure(aTarget: GLenum; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglBindTexture = procedure(aTarget: GLenum; aTexture: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglBlendFunc = procedure(aSfactor: GLenum; aDfactor: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglBufferData = procedure(aTarget: GLenum; aSize: PGLsizei; const aData: PGLvoid; aUsage: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglBufferSubData = procedure(aTarget: GLenum; aOffset: PGLint; aSize: PGLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBufferData = procedure(aTarget: GLenum; aSize: GLsizeiptr; const aData: PGLvoid; aUsage: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBufferSubData = procedure(aTarget: GLenum; aOffset: GLintptr; aSize: GLsizeiptr; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglClear = procedure(aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglClearColorx = procedure(aRed: GLclampx; aGreen: GLclampx; aBlue: GLclampx; aAlpha: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglClearDepthx = procedure(aDepth: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglStencilMaskSeparate = procedure(aFace: GLenum; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglStencilOpSeparate = procedure(aFace: GLenum; aFail: GLenum; aZfail: GLenum; aZpass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform1f = procedure(aLocation: GLint; x: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform1fv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1fv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform1i = procedure(aLocation: GLint; x: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform1iv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1iv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform2f = procedure(aLocation: GLint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform2fv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2fv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform2i = procedure(aLocation: GLint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform2iv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2iv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform3f = procedure(aLocation: GLint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform3fv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3fv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglUniform3i = procedure(aLocation: GLint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform3iv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform4f = procedure(aLocation: GLint; x: GLfloat; y: GLfloat; z: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform4fv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform4i = procedure(aLocation: GLint; x: GLint; y: GLint; z: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglUniform4iv = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3iv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4f = procedure(aLocation: GLint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4fv = procedure(aLocation: GLint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4i = procedure(aLocation: GLint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4iv = procedure(aLocation: GLint; aCount: GLsizei; const v: 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}
TglVertexAttrib2fv = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttrib3f = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttrib3fv = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglVertexAttrib4f = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib4f = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttrib4fv = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttribPointer = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aStride: GLsizei; const aPtr: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; aMask: GLbitfield; aFilter: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglRenderbufferStorageMultisample = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglFramebufferTextureLayer = procedure(aTarget: GLenum; aAttachment: GLenum; aTexture: GLuint; aLevel: GLint; aLayer: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglMapBufferRange = function (aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei; aAccess: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglFlushMappedBufferRange = procedure(aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMapBufferRange = function (aTarget: GLenum; aOffset: GLintptr; aLength: GLsizeiptr; aAccess: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFlushMappedBufferRange = procedure(aTarget: GLenum; aOffset: GLintptr; aLength: GLsizeiptr); {$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}
TglGetIntegeriv = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglBeginTransformFeedback = procedure(aPrimitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglBindBufferRange = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint; aOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindBufferRange = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint; aOffset: GLintptr; aSize: GLsizeiptr); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglBindBufferBase = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglTransformFeedbackVaryings = procedure(aProgram: GLuint; aCount: GLsizei; const aVaryings: PPGLchar; aBufferMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetTransformFeedbackVarying = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLsizei; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttribIPointer = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetVertexAttribIiv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetVertexAttribIuiv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglVertexAttribI4i = procedure(aIndex: GLuint; x: GLint; y: GLint; z: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglVertexAttribI4ui = procedure(aIndex: GLuint; x: GLuint; y: GLuint; z: GLuint; aW: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4i = procedure(aIndex: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4ui = procedure(aIndex: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttribI4iv = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglVertexAttribI4uiv = procedure(aIndex: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetUniformuiv = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglClearBufferfv = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglClearBufferfi = procedure(aBuffer: GLenum; aDrawbuffer: GLint; aDepth: GLfloat; aStencil: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetStringi = function (aName: GLenum; aIndex: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TglCopyBufferSubData = procedure(aReadTarget: GLenum; aWriteTarget: GLenum; aReadOffset: PGLint; aWriteOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyBufferSubData = procedure(aReadTarget: GLenum; aWriteTarget: GLenum; aReadOffset: GLintptr; aWriteOffset: GLintptr; aSize: GLsizeiptr); {$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}
{ ============================================== 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}
+ TglDispatchComputeIndirect = procedure(aIndirect: GLintptr); {$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}
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}
+ TglDeleteProgramPipelines = procedure(n: GLsizei; const aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenProgramPipelines = procedure(n: GLsizei; aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglIsProgramPipeline = function (aPipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglGetProgramPipelineiv = procedure(aPipeline: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
TglProgramUniform1i = procedure(aProgram: GLuint; aLocation: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
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}
+ TglBindVertexBuffer = procedure(aBindingindex: GLuint; aBuffer: GLuint; aOffset: GLintptr; 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}
glVertexAttribBinding: TglVertexAttribBinding;
glVertexBindingDivisor: TglVertexBindingDivisor;
-{ ===================================================== EGL ========================================================== }
+{ =============================================== Extensions ========================================================= }
+{ GL_KHR_blend_equation_advanced }
+const
+ GL_MULTIPLY_KHR = $9294;
+ GL_SCREEN_KHR = $9295;
+ GL_OVERLAY_KHR = $9296;
+ GL_DARKEN_KHR = $9297;
+ GL_LIGHTEN_KHR = $9298;
+ GL_COLORDODGE_KHR = $9299;
+ GL_COLORBURN_KHR = $929A;
+ GL_HARDLIGHT_KHR = $929B;
+ GL_SOFTLIGHT_KHR = $929C;
+ GL_DIFFERENCE_KHR = $929E;
+ GL_EXCLUSION_KHR = $92A0;
+ GL_HSL_HUE_KHR = $92AD;
+ GL_HSL_SATURATION_KHR = $92AE;
+ GL_HSL_COLOR_KHR = $92AF;
+ GL_HSL_LUMINOSITY_KHR = $92B0;
type
- EGLint = Integer;
- EGLboolean = Cardinal;
- EGLenum = Cardinal;
- EGLConfig = Pointer;
- EGLContext = Pointer;
- EGLDisplay = Pointer;
- EGLSurface = Pointer;
- EGLClientBuffer = Pointer;
- EGLNativeDisplayType = Pointer;
- EGLNativePixmapType = Pointer;
- EGLNativeWindowType = packed record
- element: Cardinal;
- width: Integer;
- height: Integer;
- end;
-
- PEGLint = ^EGLint;
- PEGLboolean = ^EGLboolean;
- PEGLenum = ^EGLenum;
- PEGLConfig = ^EGLConfig;
- PEGLContext = ^EGLContext;
- PEGLDisplay = ^EGLDisplay;
- PEGLSurface = ^EGLSurface;
- PEGLClientBuffer = ^EGLClientBuffer;
- PEGLNativeDisplayType = ^EGLNativeDisplayType;
- PEGLNativePixmapType = ^EGLNativePixmapType;
- PEGLNativeWindowType = ^EGLNativeWindowType;
+ TglBlendBarrierKHR = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glBlendBarrierKHR: TglBlendBarrierKHR;
+{ GL_KHR_blend_equation_advanced_coherent }
const
- EGL_FALSE: EGLboolean = 0;
- EGL_TRUE: EGLboolean = 1;
+ GL_BLEND_ADVANCED_COHERENT_KHR = $9285;
- 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;
+{ GL_KHR_context_flush_control }
+const
+ GL_CONTEXT_RELEASE_BEHAVIOR_KHR = $82FB;
+ GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = $82FC;
- 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;
+{ GL_KHR_debug }
+const
+ GL_SAMPLER = $82E6;
+ GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR = $8242;
+ GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = $8243;
+ GL_DEBUG_CALLBACK_FUNCTION_KHR = $8244;
+ GL_DEBUG_CALLBACK_USER_PARAM_KHR = $8245;
+ GL_DEBUG_SOURCE_API_KHR = $8246;
+ GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = $8247;
+ GL_DEBUG_SOURCE_SHADER_COMPILER_KHR = $8248;
+ GL_DEBUG_SOURCE_THIRD_PARTY_KHR = $8249;
+ GL_DEBUG_SOURCE_APPLICATION_KHR = $824A;
+ GL_DEBUG_SOURCE_OTHER_KHR = $824B;
+ GL_DEBUG_TYPE_ERROR_KHR = $824C;
+ GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = $824D;
+ GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = $824E;
+ GL_DEBUG_TYPE_PORTABILITY_KHR = $824F;
+ GL_DEBUG_TYPE_PERFORMANCE_KHR = $8250;
+ GL_DEBUG_TYPE_OTHER_KHR = $8251;
+ GL_DEBUG_TYPE_MARKER_KHR = $8268;
+ GL_DEBUG_TYPE_PUSH_GROUP_KHR = $8269;
+ GL_DEBUG_TYPE_POP_GROUP_KHR = $826A;
+ GL_DEBUG_SEVERITY_NOTIFICATION_KHR = $826B;
+ GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = $826C;
+ GL_DEBUG_GROUP_STACK_DEPTH_KHR = $826D;
+ GL_BUFFER_KHR = $82E0;
+ GL_SHADER_KHR = $82E1;
+ GL_PROGRAM_KHR = $82E2;
+ GL_VERTEX_ARRAY_KHR = $8074;
+ GL_QUERY_KHR = $82E3;
+ GL_SAMPLER_KHR = $82E6;
+ GL_MAX_LABEL_LENGTH_KHR = $82E8;
+ GL_MAX_DEBUG_MESSAGE_LENGTH_KHR = $9143;
+ GL_MAX_DEBUG_LOGGED_MESSAGES_KHR = $9144;
+ GL_DEBUG_LOGGED_MESSAGES_KHR = $9145;
+ GL_DEBUG_SEVERITY_HIGH_KHR = $9146;
+ GL_DEBUG_SEVERITY_MEDIUM_KHR = $9147;
+ GL_DEBUG_SEVERITY_LOW_KHR = $9148;
+ GL_DEBUG_OUTPUT_KHR = $92E0;
+ GL_CONTEXT_FLAG_DEBUG_BIT_KHR = $00000002;
+ GL_STACK_OVERFLOW_KHR = $0503;
+ GL_STACK_UNDERFLOW_KHR = $0504;
+type
+ TglDebugProcKHR = procedure(aSource: GLenum; aType: GLenum; aId: GLuint; aSeverity: GLenum; aLength: GLsizei; const aMessage: PGLchar; const aUserParam: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDebugMessageControlKHR = procedure(aSource: GLenum; aType: GLenum; aSeverity: GLenum; aCount: GLsizei; const aIds: PGLuint; aEnabled: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDebugMessageInsertKHR = procedure(aSource: GLenum; aType: GLenum; aId: GLuint; aSeverity: GLenum; aLength: GLsizei; const aBuf: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDebugMessageCallbackKHR = procedure(aCallback: TglDebugProcKHR; const aUserParam: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetDebugMessageLogKHR = function (aCount: GLuint; aBufSize: GLsizei; aSources: PGLenum; aTypes: PGLenum; aIds: PGLuint; aSeverities: PGLenum; aLengths: PGLsizei; aMessageLog: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPushDebugGroupKHR = procedure(aSource: GLenum; aId: GLuint; aLength: GLsizei; const aMessage: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPopDebugGroupKHR = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglObjectLabelKHR = procedure(aIdentifier: GLenum; aName: GLuint; aLength: GLsizei; const aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetObjectLabelKHR = procedure(aIdentifier: GLenum; aName: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglObjectPtrLabelKHR = procedure(const aPtr: Pointer; aLength: GLsizei; const aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetObjectPtrLabelKHR = procedure(const aPtr: Pointer; aBufSize: GLsizei; aLength: PGLsizei; aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPointervKHR = procedure(aPname: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDebugMessageControlKHR: TglDebugMessageControlKHR;
+ glDebugMessageInsertKHR: TglDebugMessageInsertKHR;
+ glDebugMessageCallbackKHR: TglDebugMessageCallbackKHR;
+ glGetDebugMessageLogKHR: TglGetDebugMessageLogKHR;
+ glPushDebugGroupKHR: TglPushDebugGroupKHR;
+ glPopDebugGroupKHR: TglPopDebugGroupKHR;
+ glObjectLabelKHR: TglObjectLabelKHR;
+ glGetObjectLabelKHR: TglGetObjectLabelKHR;
+ glObjectPtrLabelKHR: TglObjectPtrLabelKHR;
+ glGetObjectPtrLabelKHR: TglGetObjectPtrLabelKHR;
+ glGetPointervKHR: TglGetPointervKHR;
+
+{ GL_KHR_robust_buffer_access_behavior }
+ // none
+
+{ GL_KHR_robustness }
+const
+ GL_CONTEXT_ROBUST_ACCESS_KHR = $90F3;
+ GL_LOSE_CONTEXT_ON_RESET_KHR = $8252;
+ GL_GUILTY_CONTEXT_RESET_KHR = $8253;
+ GL_INNOCENT_CONTEXT_RESET_KHR = $8254;
+ GL_UNKNOWN_CONTEXT_RESET_KHR = $8255;
+ GL_RESET_NOTIFICATION_STRATEGY_KHR = $8256;
+ GL_NO_RESET_NOTIFICATION_KHR = $8261;
+ GL_CONTEXT_LOST_KHR = $0507;
+type
+ TglGetGraphicsResetStatusKHR = function : GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglReadnPixelsKHR = procedure(x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; aBufSize: GLsizei; aData: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetnUniformfvKHR = procedure(aProgram: GLuint; aLocation: GLint; aBufSize: GLsizei; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetnUniformivKHR = procedure(aProgram: GLuint; aLocation: GLint; aBufSize: GLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetnUniformuivKHR = procedure(aProgram: GLuint; aLocation: GLint; aBufSize: GLsizei; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetGraphicsResetStatusKHR: TglGetGraphicsResetStatusKHR;
+ glReadnPixelsKHR: TglReadnPixelsKHR;
+ glGetnUniformfvKHR: TglGetnUniformfvKHR;
+ glGetnUniformivKHR: TglGetnUniformivKHR;
+ glGetnUniformuivKHR: TglGetnUniformuivKHR;
- 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;
+{ GL_KHR_texture_compression_astc_hdr }
+const
+ GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0;
+ GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1;
+ GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2;
+ GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3;
+ GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4;
+ GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5;
+ GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6;
+ GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7;
+ GL_COMPRESSED_RGBA_ASTC_10x5_KHR = $93B8;
+ GL_COMPRESSED_RGBA_ASTC_10x6_KHR = $93B9;
+ GL_COMPRESSED_RGBA_ASTC_10x8_KHR = $93BA;
+ GL_COMPRESSED_RGBA_ASTC_10x10_KHR = $93BB;
+ GL_COMPRESSED_RGBA_ASTC_12x10_KHR = $93BC;
+ GL_COMPRESSED_RGBA_ASTC_12x12_KHR = $93BD;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = $93D0;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = $93D1;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = $93D2;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = $93D3;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = $93D4;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = $93D5;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = $93D6;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = $93D7;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = $93D8;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = $93D9;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = $93DA;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = $93DB;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = $93DC;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = $93DD;
+
+{ GL_KHR_texture_compression_astc_ldr }
+ // none
+
+{ GL_OES_EGL_image }
+type
+ GLeglImageOES = Pointer;
+ TglEGLImageTargetTexture2DOES = procedure(aTarget: GLenum; aImage: GLeglImageOES); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEGLImageTargetRenderbufferStorageOES = procedure(aTarget: GLenum; aImage: GLeglImageOES); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glEGLImageTargetTexture2DOES: TglEGLImageTargetTexture2DOES;
+ glEGLImageTargetRenderbufferStorageOES: TglEGLImageTargetRenderbufferStorageOES;
- EGL_SLOW_CONFIG = $3050;
- EGL_NON_CONFORMANT_CONFIG = $3051;
- EGL_TRANSPARENT_RGB = $3052;
- EGL_RGB_BUFFER = $308E;
- EGL_LUMINANCE_BUFFER = $308F;
+{ GL_OES_EGL_image_external }
+const
+ GL_TEXTURE_EXTERNAL_OES = $8D65;
+ GL_TEXTURE_BINDING_EXTERNAL_OES = $8D67;
+ GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES = $8D68;
+ GL_SAMPLER_EXTERNAL_OES = $8D66;
- EGL_NO_TEXTURE = $305C;
- EGL_TEXTURE_RGB = $305D;
- EGL_TEXTURE_RGBA = $305E;
- EGL_TEXTURE_2D = $305F;
+{ GL_OES_compressed_ETC1_RGB8_sub_texture }
+ // none
- 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;
+{ GL_OES_compressed_ETC1_RGB8_texture }
+const
+ GL_ETC1_RGB8_OES = $8D64;
- EGL_OPENGL_ES_BIT = $0001;
- EGL_OPENVG_BIT = $0002;
- EGL_OPENGL_ES2_BIT = $0004;
- EGL_OPENGL_BIT = $0008;
+{ GL_OES_compressed_paletted_texture }
+const
+ GL_PALETTE4_RGB8_OES = $8B90;
+ GL_PALETTE4_RGBA8_OES = $8B91;
+ GL_PALETTE4_R5_G6_B5_OES = $8B92;
+ GL_PALETTE4_RGBA4_OES = $8B93;
+ GL_PALETTE4_RGB5_A1_OES = $8B94;
+ GL_PALETTE8_RGB8_OES = $8B95;
+ GL_PALETTE8_RGBA8_OES = $8B96;
+ GL_PALETTE8_R5_G6_B5_OES = $8B97;
+ GL_PALETTE8_RGBA4_OES = $8B98;
+ GL_PALETTE8_RGB5_A1_OES = $8B99;
+
+{ GL_OES_depth24 }
+const
+ GL_DEPTH_COMPONENT24_OES = $81A6;
- EGL_VENDOR = $3053;
- EGL_VERSION = $3054;
- EGL_EXTENSIONS = $3055;
- EGL_CLIENT_APIS = $308D;
+{ GL_OES_depth32 }
+const
+ GL_DEPTH_COMPONENT32_OES = $81A7;
- 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;
+{ GL_OES_depth_texture }
+ // none
- EGL_BACK_BUFFER = $3084;
- EGL_SINGLE_BUFFER = $3085;
+{ GL_OES_element_index_uint }
+ // none
- EGL_VG_COLORSPACE_sRGB = $3089;
- EGL_VG_COLORSPACE_LINEAR = $308A;
+{ GL_OES_fbo_render_mipmap }
+ // none
- EGL_VG_ALPHA_FORMAT_NONPRE = $308B;
- EGL_VG_ALPHA_FORMAT_PRE = $308C;
+{ GL_OES_fragment_precision_high }
+ // none
- EGL_DISPLAY_SCALING = 10000;
+{ GL_OES_get_program_binary }
+const
+ GL_PROGRAM_BINARY_LENGTH_OES = $8741;
+ GL_NUM_PROGRAM_BINARY_FORMATS_OES = $87FE;
+ GL_PROGRAM_BINARY_FORMATS_OES = $87FF;
+type
+ TglGetProgramBinaryOES = procedure(aProgram: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aBinaryFormat: PGLenum; aBinary: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramBinaryOES = procedure(aProgram: GLuint; aBinaryFormat: GLenum; const aBinary: Pointer; aLength: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetProgramBinaryOES: TglGetProgramBinaryOES;
+ glProgramBinaryOES: TglProgramBinaryOES;
- EGL_UNKNOWN: EGLint = -1;
+{ GL_OES_mapbuffer }
+const
+ GL_WRITE_ONLY_OES = $88B9;
+ GL_BUFFER_ACCESS_OES = $88BB;
+ GL_BUFFER_MAPPED_OES = $88BC;
+ GL_BUFFER_MAP_POINTER_OES = $88BD;
+type
+ TglMapBufferOES = function (aTarget: GLenum; aAccess: GLenum): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUnmapBufferOES = function (aTarget: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBufferPointervOES = procedure(aTarget: GLenum; aPname: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glMapBufferOES: TglMapBufferOES;
+ glUnmapBufferOES: TglUnmapBufferOES;
+ glGetBufferPointervOES: TglGetBufferPointervOES;
- EGL_BUFFER_PRESERVED = $3094;
- EGL_BUFFER_DESTROYED = $3095;
+{ GL_OES_packed_depth_stencil }
+const
+ GL_DEPTH_STENCIL_OES = $84F9;
+ GL_UNSIGNED_INT_24_8_OES = $84FA;
+ GL_DEPTH24_STENCIL8_OES = $88F0;
- EGL_OPENVG_IMAGE = $3096;
+{ GL_OES_required_internalformat }
+const
+ GL_ALPHA8_OES = $803C;
+ GL_DEPTH_COMPONENT16_OES = $81A5;
+ GL_LUMINANCE4_ALPHA4_OES = $8043;
+ GL_LUMINANCE8_ALPHA8_OES = $8045;
+ GL_LUMINANCE8_OES = $8040;
+ GL_RGBA4_OES = $8056;
+ GL_RGB5_A1_OES = $8057;
+ GL_RGB565_OES = $8D62;
+ GL_RGB8_OES = $8051;
+ GL_RGBA8_OES = $8058;
+ GL_RGB10_EXT = $8052;
+ GL_RGB10_A2_EXT = $8059;
+
+{ GL_OES_rgb8_rgba8 }
+ // none
+
+{ GL_OES_sample_shading }
+const
+ GL_SAMPLE_SHADING_OES = $8C36;
+ GL_MIN_SAMPLE_SHADING_VALUE_OES = $8C37;
+type
+ TglMinSampleShadingOES = procedure(aValue: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glMinSampleShadingOES: TglMinSampleShadingOES;
- EGL_CONTEXT_CLIENT_TYPE = $3097;
+{ GL_OES_sample_
+variables }
+ // none
- EGL_CONTEXT_CLIENT_VERSION = $3098;
+{ GL_OES_shader_image_atomic }
+ // none
- EGL_MULTISAMPLE_RESOLVE_DEFAULT = $309A;
- EGL_MULTISAMPLE_RESOLVE_BOX = $309B;
+{ GL_OES_shader_multisample_interpolation }
+const
+ GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = $8E5B;
+ GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = $8E5C;
+ GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = $8E5D;
- EGL_OPENGL_ES_API = $30A0;
- EGL_OPENVG_API = $30A1;
- EGL_OPENGL_API = $30A2;
+{ GL_OES_standard_derivatives }
+const
+ GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES = $8B8B;
- EGL_DRAW = $3059;
- EGL_READ = $305A;
+{ GL_OES_stencil1 }
+const
+ GL_STENCIL_INDEX1_OES = $8D46;
- EGL_CORE_NATIVE_ENGINE = $305B;
+{ GL_OES_stencil4 }
+const
+ GL_STENCIL_INDEX4_OES = $8D47;
- 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;
+{ GL_OES_surfaceless_context }
+const
+ GL_FRAMEBUFFER_UNDEFINED_OES = $8219;
+{ GL_OES_texture_3D }
+const
+ GL_TEXTURE_WRAP_R_OES = $8072;
+ GL_TEXTURE_3D_OES = $806F;
+ GL_TEXTURE_BINDING_3D_OES = $806A;
+ GL_MAX_3D_TEXTURE_SIZE_OES = $8073;
+ GL_SAMPLER_3D_OES = $8B5F;
+ GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES = $8CD4;
type
- TeglGetError = function: EGLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexImage3DOES = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aFormat: GLenum; aType: GLenum; const aPixels: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexSubImage3DOES = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aType: GLenum; const aPixels: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyTexSubImage3DOES = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexImage3DOES = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aImageSize: GLsizei; const aData: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexSubImage3DOES = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aImageSize: GLsizei; const aData: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferTexture3DOES = procedure(aTarget: GLenum; aAttachment: GLenum; aTextarget: GLenum; aTexture: GLuint; aLevel: GLint; aZoffset: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTexImage3DOES: TglTexImage3DOES;
+ glTexSubImage3DOES: TglTexSubImage3DOES;
+ glCopyTexSubImage3DOES: TglCopyTexSubImage3DOES;
+ glCompressedTexImage3DOES: TglCompressedTexImage3DOES;
+ glCompressedTexSubImage3DOES: TglCompressedTexSubImage3DOES;
+ glFramebufferTexture3DOES: TglFramebufferTexture3DOES;
+
+{ GL_OES_texture_compression_astc }
+const
+ GL_COMPRESSED_RGBA_ASTC_3x3x3_OES = $93C0;
+ GL_COMPRESSED_RGBA_ASTC_4x3x3_OES = $93C1;
+ GL_COMPRESSED_RGBA_ASTC_4x4x3_OES = $93C2;
+ GL_COMPRESSED_RGBA_ASTC_4x4x4_OES = $93C3;
+ GL_COMPRESSED_RGBA_ASTC_5x4x4_OES = $93C4;
+ GL_COMPRESSED_RGBA_ASTC_5x5x4_OES = $93C5;
+ GL_COMPRESSED_RGBA_ASTC_5x5x5_OES = $93C6;
+ GL_COMPRESSED_RGBA_ASTC_6x5x5_OES = $93C7;
+ GL_COMPRESSED_RGBA_ASTC_6x6x5_OES = $93C8;
+ GL_COMPRESSED_RGBA_ASTC_6x6x6_OES = $93C9;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES = $93E0;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES = $93E1;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES = $93E2;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES = $93E3;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES = $93E4;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES = $93E5;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES = $93E6;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES = $93E7;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES = $93E8;
+ GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES = $93E9;
+
+{ GL_OES_texture_float }
+ // none
+
+{ GL_OES_texture_float_linear }
+ // none
+
+{ GL_OES_texture_half_float }
+const
+ GL_HALF_FLOAT_OES = $8D61;
- 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}
+{ GL_OES_texture_half_float_linear }
+ // none
- TeglQueryString = function(aDisplay: EGLDisplay; name: EGLint): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_OES_texture_npot }
+ // none
- TeglGetConfigs = function(aDisplay: EGLDisplay; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TeglChooseConfig = function(aDisplay: EGLDisplay; const aAttribList: PEGLint; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TeglGetConfigAttrib = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aAttribute: EGLint; aValue : PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_OES_texture_stencil8 }
+const
+ GL_STENCIL_INDEX_OES = $1901;
+ GL_STENCIL_INDEX8_OES = $8D48;
- 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}
+{ GL_OES_texture_storage_multisample_2d_array }
+const
+ GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES = $9102;
+ GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES = $9105;
+ GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = $910B;
+ GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = $910C;
+ GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = $910D;
+type
+ TglTexStorage3DMultisampleOES = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTexStorage3DMultisampleOES: TglTexStorage3DMultisampleOES;
- TeglBindAPI = function(aApi: EGLenum): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
- TeglQueryAPI = function: EGLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_OES_vertex_array_object }
+const
+ GL_VERTEX_ARRAY_BINDING_OES = $85B5;
+type
+ TglBindVertexArrayOES = procedure(aArray: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteVertexArraysOES = procedure(n: GLsizei; const aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenVertexArraysOES = procedure(n: GLsizei; aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsVertexArrayOES = function (aArray: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glBindVertexArrayOES: TglBindVertexArrayOES;
+ glDeleteVertexArraysOES: TglDeleteVertexArraysOES;
+ glGenVertexArraysOES: TglGenVertexArraysOES;
+ glIsVertexArrayOES: TglIsVertexArrayOES;
- TeglWaitClient = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_OES_vertex_half_float }
+ // none
- TeglReleaseThread = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_OES_vertex_type_10_10_10_2 }
+const
+ GL_UNSIGNED_INT_10_10_10_2_OES = $8DF6;
+ GL_INT_10_10_10_2_OES = $8DF7;
- TeglCreatePbufferFromClientBuffer = function(aDisplay: EGLDisplay; aBufType: EGLenum; aBuffer: EGLClientBuffer; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_AMD_compressed_3DC_texture }
+const
+ GL_3DC_X_AMD = $87F9;
+ GL_3DC_XY_AMD = $87FA;
- 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}
+{ GL_AMD_compressed_ATC_texture }
+const
+ GL_ATC_RGB_AMD = $8C92;
+ GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = $8C93;
+ GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = $87EE;
- TeglSwapInterval = function(aDisplay: EGLDisplay; aInterval: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_AMD_performance_monitor }
+const
+ GL_COUNTER_TYPE_AMD = $8BC0;
+ GL_COUNTER_RANGE_AMD = $8BC1;
+ GL_UNSIGNED_INT64_AMD = $8BC2;
+ GL_PERCENTAGE_AMD = $8BC3;
+ GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4;
+ GL_PERFMON_RESULT_SIZE_AMD = $8BC5;
+ GL_PERFMON_RESULT_AMD = $8BC6;
+type
+ TglGetPerfMonitorGroupsAMD = procedure(aNumGroups: PGLint; aGroupsSize: GLsizei; aGroups: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfMonitorCountersAMD = procedure(aGroup: GLuint; aNumCounters: PGLint; aMaxActiveCounters: PGLint; aCounterSize: GLsizei; aCounters: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfMonitorGroupStringAMD = procedure(aGroup: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aGroupString: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfMonitorCounterStringAMD = procedure(aGroup: GLuint; aCounter: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aCounterString: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfMonitorCounterInfoAMD = procedure(aGroup: GLuint; aCounter: GLuint; aPname: GLenum; aData: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenPerfMonitorsAMD = procedure(n: GLsizei; aMonitors: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeletePerfMonitorsAMD = procedure(n: GLsizei; aMonitors: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSelectPerfMonitorCountersAMD = procedure(aMonitor: GLuint; aEnable: GLboolean; aGroup: GLuint; aNumCounters: GLint; aCounterList: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBeginPerfMonitorAMD = procedure(aMonitor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndPerfMonitorAMD = procedure(aMonitor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfMonitorCounterDataAMD = procedure(aMonitor: GLuint; aPname: GLenum; aDataSize: GLsizei; aData: PGLuint; aBytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD;
+ glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD;
+ glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD;
+ glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD;
+ glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD;
+ glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD;
+ glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD;
+ glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD;
+ glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD;
+ glEndPerfMonitorAMD: TglEndPerfMonitorAMD;
+ glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD;
+
+{ GL_AMD_program_binary_Z400 }
+const
+ GL_Z400_BINARY_AMD = $8740;
- 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}
+{ GL_ANDROID_extension_pack_es31a }
+ // none
- 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}
+{ GL_ANGLE_depth_texture }
+ // none
- 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}
+{ GL_ANGLE_framebuffer_blit }
+const
+ GL_READ_FRAMEBUFFER_ANGLE = $8CA8;
+ GL_DRAW_FRAMEBUFFER_ANGLE = $8CA9;
+ GL_DRAW_FRAMEBUFFER_BINDING_ANGLE = $8CA6;
+ GL_READ_FRAMEBUFFER_BINDING_ANGLE = $8CAA;
+type
+ TglBlitFramebufferANGLE = 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}
+var
+ glBlitFramebufferANGLE: TglBlitFramebufferANGLE;
- TeglGetProcAddress = function(const aProcName: PAnsiChar): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+{ GL_ANGLE_framebuffer_multisample }
+const
+ GL_RENDERBUFFER_SAMPLES_ANGLE = $8CAB;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE = $8D56;
+ GL_MAX_SAMPLES_ANGLE = $8D57;
+type
+ TglRenderbufferStorageMultisampleANGLE = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glRenderbufferStorageMultisampleANGLE: TglRenderbufferStorageMultisampleANGLE;
+{ GL_ANGLE_instanced_arrays }
+const
+ GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = $88FE;
+type
+ TglDrawArraysInstancedANGLE = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedANGLE = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribDivisorANGLE = procedure(aIndex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
var
- eglGetError: TeglGetError;
+ glDrawArraysInstancedANGLE: TglDrawArraysInstancedANGLE;
+ glDrawElementsInstancedANGLE: TglDrawElementsInstancedANGLE;
+ glVertexAttribDivisorANGLE: TglVertexAttribDivisorANGLE;
- eglGetDisplay: TeglGetDisplay;
- eglInitialize: TeglInitialize;
- eglTerminate: TeglTerminate;
+{ GL_ANGLE_pack_reverse_row_order }
+const
+ GL_PACK_REVERSE_ROW_ORDER_ANGLE = $93A4;
- eglQueryString: TeglQueryString;
+{ GL_ANGLE_program_binary }
+const
+ GL_PROGRAM_BINARY_ANGLE = $93A6;
- eglGetConfigs: TeglGetConfigs;
- eglChooseConfig: TeglChooseConfig;
- eglGetConfigAttrib: TeglGetConfigAttrib;
+{ GL_ANGLE_texture_compression_dxt3 }
+const
+ GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE = $83F2;
- eglCreateWindowSurface: TeglCreateWindowSurface;
+{ GL_ANGLE_texture_compression_dxt5 }
+const
+ GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE = $83F3;
+
+{ GL_ANGLE_texture_usage }
+const
+ GL_TEXTURE_USAGE_ANGLE = $93A2;
+ GL_FRAMEBUFFER_ATTACHMENT_ANGLE = $93A3;
+
+{ GL_ANGLE_translated_shader_source }
+const
+ GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE = $93A0;
+type
+ TglGetTranslatedShaderSourceANGLE = procedure(aShader: GLuint; aBufsize: GLsizei; aLength: PGLsizei; aSource: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetTranslatedShaderSourceANGLE: TglGetTranslatedShaderSourceANGLE;
+
+{ GL_APPLE_clip_distance }
+const
+ GL_MAX_CLIP_DISTANCES_APPLE = $0D32;
+ GL_CLIP_DISTANCE0_APPLE = $3000;
+ GL_CLIP_DISTANCE1_APPLE = $3001;
+ GL_CLIP_DISTANCE2_APPLE = $3002;
+ GL_CLIP_DISTANCE3_APPLE = $3003;
+ GL_CLIP_DISTANCE4_APPLE = $3004;
+ GL_CLIP_DISTANCE5_APPLE = $3005;
+ GL_CLIP_DISTANCE6_APPLE = $3006;
+ GL_CLIP_DISTANCE7_APPLE = $3007;
+
+{ GL_APPLE_color_buffer_packed_float }
+ // none
+
+{ GL_APPLE_copy_texture_levels }
+type
+ TglCopyTextureLevelsAPPLE = procedure(aDestinationTexture: GLuint; aSourceTexture: GLuint; aSourceBaseLevel: GLint; aSourceLevelCount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glCopyTextureLevelsAPPLE: TglCopyTextureLevelsAPPLE;
+
+{ GL_APPLE_framebuffer_multisample }
+const
+ GL_RENDERBUFFER_SAMPLES_APPLE = $8CAB;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE = $8D56;
+ GL_MAX_SAMPLES_APPLE = $8D57;
+ GL_READ_FRAMEBUFFER_APPLE = $8CA8;
+ GL_DRAW_FRAMEBUFFER_APPLE = $8CA9;
+ GL_DRAW_FRAMEBUFFER_BINDING_APPLE = $8CA6;
+ GL_READ_FRAMEBUFFER_BINDING_APPLE = $8CAA;
+type
+ TglRenderbufferStorageMultisampleAPPLE = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglResolveMultisampleFramebufferAPPLE = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glRenderbufferStorageMultisampleAPPLE: TglRenderbufferStorageMultisampleAPPLE;
+ glResolveMultisampleFramebufferAPPLE: TglResolveMultisampleFramebufferAPPLE;
+
+{ GL_APPLE_rgb_422 }
+const
+ GL_RGB_422_APPLE = $8A1F;
+ GL_UNSIGNED_SHORT_8_8_APPLE = $85BA;
+ GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB;
+ GL_RGB_RAW_422_APPLE = $8A51;
+
+{ GL_APPLE_sync }
+const
+ GL_SYNC_OBJECT_APPLE = $8A53;
+ GL_MAX_SERVER_WAIT_TIMEOUT_APPLE = $9111;
+ GL_OBJECT_TYPE_APPLE = $9112;
+ GL_SYNC_CONDITION_APPLE = $9113;
+ GL_SYNC_STATUS_APPLE = $9114;
+ GL_SYNC_FLAGS_APPLE = $9115;
+ GL_SYNC_FENCE_APPLE = $9116;
+ GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE = $9117;
+ GL_UNSIGNALED_APPLE = $9118;
+ GL_SIGNALED_APPLE = $9119;
+ GL_ALREADY_SIGNALED_APPLE = $911A;
+ GL_TIMEOUT_EXPIRED_APPLE = $911B;
+ GL_CONDITION_SATISFIED_APPLE = $911C;
+ GL_WAIT_FAILED_APPLE = $911D;
+ GL_SYNC_FLUSH_COMMANDS_BIT_APPLE = $00000001;
+ GL_TIMEOUT_IGNORED_APPLE = $FFFFFFFFFFFFFFFF;
+type
+ TglFenceSyncAPPLE = function (aCondition: GLenum; aFlags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsSyncAPPLE = function (aSync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteSyncAPPLE = procedure(aSync: GLsync); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClientWaitSyncAPPLE = function (aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglWaitSyncAPPLE = procedure(aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetInteger64vAPPLE = procedure(aPname: GLenum; aParams: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSyncivAPPLE = procedure(aSync: GLsync; aPname: GLenum; aBufSize: GLsizei; aLength: PGLsizei; aValues: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glFenceSyncAPPLE: TglFenceSyncAPPLE;
+ glIsSyncAPPLE: TglIsSyncAPPLE;
+ glDeleteSyncAPPLE: TglDeleteSyncAPPLE;
+ glClientWaitSyncAPPLE: TglClientWaitSyncAPPLE;
+ glWaitSyncAPPLE: TglWaitSyncAPPLE;
+ glGetInteger64vAPPLE: TglGetInteger64vAPPLE;
+ glGetSyncivAPPLE: TglGetSyncivAPPLE;
+
+{ GL_APPLE_texture_format_BGRA8888 }
+const
+ GL_BGRA_EXT = $80E1;
+ GL_BGRA8_EXT = $93A1;
+
+{ GL_APPLE_texture_max_level }
+const
+ GL_TEXTURE_MAX_LEVEL_APPLE = $813D;
+
+{ GL_APPLE_texture_packed_float }
+const
+ GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE = $8C3B;
+ GL_UNSIGNED_INT_5_9_9_9_REV_APPLE = $8C3E;
+ GL_R11F_G11F_B10F_APPLE = $8C3A;
+ GL_RGB9_E5_APPLE = $8C3D;
+
+{ GL_ARM_mali_program_binary }
+const
+ GL_MALI_PROGRAM_BINARY_ARM = $8F61;
+
+{ GL_ARM_mali_shader_binary }
+const
+ GL_MALI_SHADER_BINARY_ARM = $8F60;
+
+{ GL_ARM_rgba8 }
+ // none
+
+{ GL_ARM_shader_framebuffer_fetch }
+const
+ GL_FETCH_PER_SAMPLE_ARM = $8F65;
+ GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM = $8F66;
+
+{ GL_ARM_shader_framebuffer_fetch_depth_stencil }
+
+{ GL_DMP_program_binary }
+const
+ GL_SMAPHS30_PROGRAM_BINARY_DMP = $9251;
+ GL_SMAPHS_PROGRAM_BINARY_DMP = $9252;
+ GL_DMP_PROGRAM_BINARY_DMP = $9253;
+
+{ GL_DMP_shader_binary }
+const
+ GL_SHADER_BINARY_DMP = $9250;
+
+{ GL_EXT_base_instance }
+type
+ TglDrawArraysInstancedBaseInstanceEXT = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei; aInstancecount: GLsizei; aBaseinstance: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedBaseInstanceEXT = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aInstancecount: GLsizei; aBaseinstance: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedBaseVertexBaseInstanceEXT = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aInstancecount: GLsizei; aBasevertex: GLint; aBaseinstance: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawArraysInstancedBaseInstanceEXT: TglDrawArraysInstancedBaseInstanceEXT;
+ glDrawElementsInstancedBaseInstanceEXT: TglDrawElementsInstancedBaseInstanceEXT;
+ glDrawElementsInstancedBaseVertexBaseInstanceEXT: TglDrawElementsInstancedBaseVertexBaseInstanceEXT;
+
+{ GL_EXT_blend_minmax }
+const
+ GL_MIN_EXT = $8007;
+ GL_MAX_EXT = $8008;
+
+{ GL_EXT_color_buffer_half_float }
+const
+ GL_RGBA16F_EXT = $881A;
+ GL_RGB16F_EXT = $881B;
+ GL_RG16F_EXT = $822F;
+ GL_R16F_EXT = $822D;
+ GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = $8211;
+ GL_UNSIGNED_NORMALIZED_EXT = $8C17;
+
+{ GL_EXT_copy_image }
+type
+ TglCopyImageSubDataEXT = procedure(aSrcName: GLuint; aSrcTarget: GLenum; aSrcLevel: GLint; aSrcX: GLint; aSrcY: GLint; aSrcZ: GLint; aDstName: GLuint; aDstTarget: GLenum; aDstLevel: GLint; aDstX: GLint; aDstY: GLint; aDstZ: GLint; aSrcWidth: GLsizei; aSrcHeight: GLsizei; aSrcDepth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glCopyImageSubDataEXT: TglCopyImageSubDataEXT;
+
+{ GL_EXT_debug_label }
+const
+ GL_PROGRAM_PIPELINE_OBJECT_EXT = $8A4F;
+ GL_PROGRAM_OBJECT_EXT = $8B40;
+ GL_SHADER_OBJECT_EXT = $8B48;
+ GL_BUFFER_OBJECT_EXT = $9151;
+ GL_QUERY_OBJECT_EXT = $9153;
+ GL_VERTEX_ARRAY_OBJECT_EXT = $9154;
+ // GL_TRANSFORM_FEEDBACK = $8E22;
+type
+ TglLabelObjectEXT = procedure(aType: GLenum; aObject: GLuint; aLength: GLsizei; const aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetObjectLabelEXT = procedure(aType: GLenum; aObject: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aLabel: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glLabelObjectEXT: TglLabelObjectEXT;
+ glGetObjectLabelEXT: TglGetObjectLabelEXT;
+
+{ GL_EXT_debug_marker }
+type
+ TglInsertEventMarkerEXT = procedure(aLength: GLsizei; const aMarker: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPushGroupMarkerEXT = procedure(aLength: GLsizei; const aMarker: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPopGroupMarkerEXT = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glInsertEventMarkerEXT: TglInsertEventMarkerEXT;
+ glPushGroupMarkerEXT: TglPushGroupMarkerEXT;
+ glPopGroupMarkerEXT: TglPopGroupMarkerEXT;
+
+{ GL_EXT_discard_framebuffer }
+const
+ GL_COLOR_EXT = $1800;
+ GL_DEPTH_EXT = $1801;
+ GL_STENCIL_EXT = $1802;
+type
+ TglDiscardFramebufferEXT = procedure(aTarget: GLenum; aNumAttachments: GLsizei; const aAttachments: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDiscardFramebufferEXT: TglDiscardFramebufferEXT;
+
+{ GL_EXT_disjoint_timer_query }
+const
+ GL_QUERY_COUNTER_BITS_EXT = $8864;
+ GL_CURRENT_QUERY_EXT = $8865;
+ GL_QUERY_RESULT_EXT = $8866;
+ GL_QUERY_RESULT_AVAILABLE_EXT = $8867;
+ GL_TIME_ELAPSED_EXT = $88BF;
+ GL_TIMESTAMP_EXT = $8E28;
+ GL_GPU_DISJOINT_EXT = $8FBB;
+type
+ TglGenQueriesEXT = procedure(n: GLsizei; aIds: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteQueriesEXT = procedure(n: GLsizei; const aIds: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsQueryEXT = function (aId: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBeginQueryEXT = procedure(aTarget: GLenum; aId: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndQueryEXT = procedure(aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglQueryCounterEXT = procedure(aId: GLuint; aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryivEXT = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryObjectivEXT = procedure(aId: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryObjectuivEXT = procedure(aId: GLuint; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryObjecti64vEXT = procedure(aId: GLuint; aPname: GLenum; aParams: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryObjectui64vEXT = procedure(aId: GLuint; aPname: GLenum; aParams: PGLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGenQueriesEXT: TglGenQueriesEXT;
+ glDeleteQueriesEXT: TglDeleteQueriesEXT;
+ glIsQueryEXT: TglIsQueryEXT;
+ glBeginQueryEXT: TglBeginQueryEXT;
+ glEndQueryEXT: TglEndQueryEXT;
+ glQueryCounterEXT: TglQueryCounterEXT;
+ glGetQueryivEXT: TglGetQueryivEXT;
+ glGetQueryObjectivEXT: TglGetQueryObjectivEXT;
+ glGetQueryObjectuivEXT: TglGetQueryObjectuivEXT;
+ glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT;
+ glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT;
+
+{ GL_EXT_draw_buffers }
+const
+ GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF;
+ GL_MAX_DRAW_BUFFERS_EXT = $8824;
+ GL_DRAW_BUFFER0_EXT = $8825;
+ GL_DRAW_BUFFER1_EXT = $8826;
+ GL_DRAW_BUFFER2_EXT = $8827;
+ GL_DRAW_BUFFER3_EXT = $8828;
+ GL_DRAW_BUFFER4_EXT = $8829;
+ GL_DRAW_BUFFER5_EXT = $882A;
+ GL_DRAW_BUFFER6_EXT = $882B;
+ GL_DRAW_BUFFER7_EXT = $882C;
+ GL_DRAW_BUFFER8_EXT = $882D;
+ GL_DRAW_BUFFER9_EXT = $882E;
+ GL_DRAW_BUFFER10_EXT = $882F;
+ GL_DRAW_BUFFER11_EXT = $8830;
+ GL_DRAW_BUFFER12_EXT = $8831;
+ GL_DRAW_BUFFER13_EXT = $8832;
+ GL_DRAW_BUFFER14_EXT = $8833;
+ GL_DRAW_BUFFER15_EXT = $8834;
+ GL_COLOR_ATTACHMENT0_EXT = $8CE0;
+ GL_COLOR_ATTACHMENT1_EXT = $8CE1;
+ GL_COLOR_ATTACHMENT2_EXT = $8CE2;
+ GL_COLOR_ATTACHMENT3_EXT = $8CE3;
+ GL_COLOR_ATTACHMENT4_EXT = $8CE4;
+ GL_COLOR_ATTACHMENT5_EXT = $8CE5;
+ GL_COLOR_ATTACHMENT6_EXT = $8CE6;
+ GL_COLOR_ATTACHMENT7_EXT = $8CE7;
+ GL_COLOR_ATTACHMENT8_EXT = $8CE8;
+ GL_COLOR_ATTACHMENT9_EXT = $8CE9;
+ GL_COLOR_ATTACHMENT10_EXT = $8CEA;
+ GL_COLOR_ATTACHMENT11_EXT = $8CEB;
+ GL_COLOR_ATTACHMENT12_EXT = $8CEC;
+ GL_COLOR_ATTACHMENT13_EXT = $8CED;
+ GL_COLOR_ATTACHMENT14_EXT = $8CEE;
+ GL_COLOR_ATTACHMENT15_EXT = $8CEF;
+type
+ TglDrawBuffersEXT = procedure(n: GLsizei; const aBufs: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawBuffersEXT: TglDrawBuffersEXT;
+
+{ GL_EXT_draw_buffers_indexed }
+ //GL_MIN = $8007;
+ //GL_MAX = $8008;
+type
+ TglEnableiEXT = procedure(aTarget: GLenum; aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDisableiEXT = procedure(aTarget: GLenum; aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendEquationiEXT = procedure(aBuf: GLuint; aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendEquationSeparateiEXT = procedure(aBuf: GLuint; aModeRGB: GLenum; aModeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendFunciEXT = procedure(aBuf: GLuint; aSrc: GLenum; aDst: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendFuncSeparateiEXT = procedure(aBuf: GLuint; aSrcRGB: GLenum; aDstRGB: GLenum; aSrcAlpha: GLenum; aDstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglColorMaskiEXT = procedure(aIndex: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsEnablediEXT = function (aTarget: GLenum; aIndex: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glEnableiEXT: TglEnableiEXT;
+ glDisableiEXT: TglDisableiEXT;
+ glBlendEquationiEXT: TglBlendEquationiEXT;
+ glBlendEquationSeparateiEXT: TglBlendEquationSeparateiEXT;
+ glBlendFunciEXT: TglBlendFunciEXT;
+ glBlendFuncSeparateiEXT: TglBlendFuncSeparateiEXT;
+ glColorMaskiEXT: TglColorMaskiEXT;
+ glIsEnablediEXT: TglIsEnablediEXT;
+
+{ GL_EXT_draw_elements_base_vertex }
+type
+ TglDrawElementsBaseVertexEXT = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aBasevertex: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawRangeElementsBaseVertexEXT = procedure(aMode: GLenum; aStart: GLuint; aEnd: GLuint; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aBasevertex: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedBaseVertexEXT = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aInstancecount: GLsizei; aBasevertex: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMultiDrawElementsBaseVertexEXT = procedure(aMode: GLenum; const aCount: PGLsizei; aType: GLenum; const aConstPindices: Pointer; aPrimcount: GLsizei; const aBasevertex: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawElementsBaseVertexEXT: TglDrawElementsBaseVertexEXT;
+ glDrawRangeElementsBaseVertexEXT: TglDrawRangeElementsBaseVertexEXT;
+ glDrawElementsInstancedBaseVertexEXT: TglDrawElementsInstancedBaseVertexEXT;
+ glMultiDrawElementsBaseVertexEXT: TglMultiDrawElementsBaseVertexEXT;
+
+{ GL_EXT_draw_instanced }
+type
+ TglDrawArraysInstancedEXT = procedure(aMode: GLenum; aStart: GLint; aCount: GLsizei; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedEXT = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT;
+ glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT;
+
+{ GL_EXT_geometry_point_size }
+
+{ GL_EXT_geometry_shader }
+const
+ GL_GEOMETRY_SHADER_EXT = $8DD9;
+ GL_GEOMETRY_SHADER_BIT_EXT = $00000004;
+ GL_GEOMETRY_LINKED_VERTICES_OUT_EXT = $8916;
+ GL_GEOMETRY_LINKED_INPUT_TYPE_EXT = $8917;
+ GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT = $8918;
+ GL_GEOMETRY_SHADER_INVOCATIONS_EXT = $887F;
+ GL_LAYER_PROVOKING_VERTEX_EXT = $825E;
+ GL_LINES_ADJACENCY_EXT = $000A;
+ GL_LINE_STRIP_ADJACENCY_EXT = $000B;
+ GL_TRIANGLES_ADJACENCY_EXT = $000C;
+ GL_TRIANGLE_STRIP_ADJACENCY_EXT = $000D;
+ GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF;
+ GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT = $8A2C;
+ GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8A32;
+ GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT = $9123;
+ GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT = $9124;
+ GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0;
+ GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1;
+ GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT = $8E5A;
+ GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29;
+ GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT = $92CF;
+ GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT = $92D5;
+ GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT = $90CD;
+ GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT = $90D7;
+ GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D;
+ GL_LAST_VERTEX_CONVENTION_EXT = $8E4E;
+ GL_UNDEFINED_VERTEX_EXT = $8260;
+ GL_PRIMITIVES_GENERATED_EXT = $8C87;
+ GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT = $9312;
+ GL_MAX_FRAMEBUFFER_LAYERS_EXT = $9317;
+ GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8;
+ GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7;
+ GL_REFERENCED_BY_GEOMETRY_SHADER_EXT = $9309;
+type
+ TglFramebufferTextureEXT = procedure(aTarget: GLenum; aAttachment: GLenum; aTexture: GLuint; aLevel: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glFramebufferTextureEXT: TglFramebufferTextureEXT;
+
+{ GL_EXT_gpu_shader5 }
+ // none
+
+{ GL_EXT_instanced_arrays }
+const
+ GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT = $88FE;
+type
+ TglVertexAttribDivisorEXT = procedure(aIndex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glVertexAttribDivisorEXT: TglVertexAttribDivisorEXT;
+
+{ GL_EXT_map_buffer_range }
+const
+ GL_MAP_READ_BIT_EXT = $0001;
+ GL_MAP_WRITE_BIT_EXT = $0002;
+ GL_MAP_INVALIDATE_RANGE_BIT_EXT = $0004;
+ GL_MAP_INVALIDATE_BUFFER_BIT_EXT = $0008;
+ GL_MAP_FLUSH_EXPLICIT_BIT_EXT = $0010;
+ GL_MAP_UNSYNCHRONIZED_BIT_EXT = $0020;
+type
+ TglMapBufferRangeEXT = function (aTarget: GLenum; aOffset: GLintptr; aLength: GLsizeiptr; aAccess: GLbitfield): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFlushMappedBufferRangeEXT = procedure(aTarget: GLenum; aOffset: GLintptr; aLength: GLsizeiptr); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glMapBufferRangeEXT: TglMapBufferRangeEXT;
+ glFlushMappedBufferRangeEXT: TglFlushMappedBufferRangeEXT;
+
+{ GL_EXT_multi_draw_arrays }
+type
+ TglMultiDrawArraysEXT = procedure(aMode: GLenum; const aFirst: PGLint; const aCount: PGLsizei; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMultiDrawElementsEXT = procedure(aMode: GLenum; const aCount: PGLsizei; aType: GLenum; const aConstPindices: Pointer; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glMultiDrawArraysEXT: TglMultiDrawArraysEXT;
+ glMultiDrawElementsEXT: TglMultiDrawElementsEXT;
+
+{ GL_EXT_multi_draw_indirect }
+type
+ TglMultiDrawArraysIndirectEXT = procedure(aMode: GLenum; const aIndirect: Pointer; aDrawcount: GLsizei; aStride: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMultiDrawElementsIndirectEXT = procedure(aMode: GLenum; aType: GLenum; const aIndirect: Pointer; aDrawcount: GLsizei; aStride: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glMultiDrawArraysIndirectEXT: TglMultiDrawArraysIndirectEXT;
+ glMultiDrawElementsIndirectEXT: TglMultiDrawElementsIndirectEXT;
+
+{ GL_EXT_multisampled_render_to_texture }
+const
+ GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT = $8D6C;
+ GL_RENDERBUFFER_SAMPLES_EXT = $8CAB;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56;
+ GL_MAX_SAMPLES_EXT = $8D57;
+type
+ TglRenderbufferStorageMultisampleEXT = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferTexture2DMultisampleEXT = procedure(aTarget: GLenum; aAttachment: GLenum; aTextarget: GLenum; aTexture: GLuint; aLevel: GLint; aSamples: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT;
+ glFramebufferTexture2DMultisampleEXT: TglFramebufferTexture2DMultisampleEXT;
+
+{ GL_EXT_multiview_draw_buffers }
+const
+ GL_COLOR_ATTACHMENT_EXT = $90F0;
+ GL_MULTIVIEW_EXT = $90F1;
+ GL_DRAW_BUFFER_EXT = $0C01;
+ GL_READ_BUFFER_EXT = $0C02;
+ GL_MAX_MULTIVIEW_BUFFERS_EXT = $90F2;
+type
+ TglReadBufferIndexedEXT = procedure(aSrc: GLenum; aIndex: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawBuffersIndexedEXT = procedure(n: GLint; const aLocation: PGLenum; const aIndices: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetIntegeri_vEXT = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glReadBufferIndexedEXT: TglReadBufferIndexedEXT;
+ glDrawBuffersIndexedEXT: TglDrawBuffersIndexedEXT;
+ glGetIntegeri_vEXT: TglGetIntegeri_vEXT;
+
+{ GL_EXT_occlusion_query_boolean }
+const
+ GL_ANY_SAMPLES_PASSED_EXT = $8C2F;
+ GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = $8D6A;
+
+{ GL_EXT_primitive_bounding_box }
+const
+ GL_PRIMITIVE_BOUNDING_BOX_EXT = $92BE;
+type
+ TglPrimitiveBoundingBoxEXT = procedure(aMinX: GLfloat; aMinY: GLfloat; aMinZ: GLfloat; aMinW: GLfloat; aMaxX: GLfloat; aMaxY: GLfloat; aMaxZ: GLfloat; aMaxW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glPrimitiveBoundingBoxEXT: TglPrimitiveBoundingBoxEXT;
+
+{ GL_EXT_pvrtc_sRGB }
+const
+ GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT = $8A54;
+ GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT = $8A55;
+ GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT = $8A56;
+ GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT = $8A57;
+ GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG = $93F0;
+ GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG = $93F1;
+
+{ GL_EXT_read_format_bgra }
+const
+ GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT = $8365;
+ GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT = $8366;
+
+{ GL_EXT_render_snorm }
+const
+ //GL_R8_SNORM = $8F94;
+ //GL_RG8_SNORM = $8F95;
+ //GL_RGBA8_SNORM = $8F97;
+ GL_R16_SNORM_EXT = $8F98;
+ GL_RG16_SNORM_EXT = $8F99;
+ GL_RGBA16_SNORM_EXT = $8F9B;
+
+{ GL_EXT_robustness }
+const
+ GL_GUILTY_CONTEXT_RESET_EXT = $8253;
+ GL_INNOCENT_CONTEXT_RESET_EXT = $8254;
+ GL_UNKNOWN_CONTEXT_RESET_EXT = $8255;
+ GL_CONTEXT_ROBUST_ACCESS_EXT = $90F3;
+ GL_RESET_NOTIFICATION_STRATEGY_EXT = $8256;
+ GL_LOSE_CONTEXT_ON_RESET_EXT = $8252;
+ GL_NO_RESET_NOTIFICATION_EXT = $8261;
+type
+ TglGetGraphicsResetStatusEXT = function : GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglReadnPixelsEXT = procedure(x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; aBufSize: GLsizei; aData: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetnUniformfvEXT = procedure(aProgram: GLuint; aLocation: GLint; aBufSize: GLsizei; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetnUniformivEXT = procedure(aProgram: GLuint; aLocation: GLint; aBufSize: GLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetGraphicsResetStatusEXT: TglGetGraphicsResetStatusEXT;
+ glReadnPixelsEXT: TglReadnPixelsEXT;
+ glGetnUniformfvEXT: TglGetnUniformfvEXT;
+ glGetnUniformivEXT: TglGetnUniformivEXT;
+
+{ GL_EXT_sRGB }
+const
+ GL_SRGB_EXT = $8C40;
+ GL_SRGB_ALPHA_EXT = $8C42;
+ GL_SRGB8_ALPHA8_EXT = $8C43;
+ GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT = $8210;
+
+{ GL_EXT_sRGB_write_control }
+const
+ GL_FRAMEBUFFER_SRGB_EXT = $8DB9;
+
+{ GL_EXT_separate_shader_objects }
+const
+ GL_ACTIVE_PROGRAM_EXT = $8259;
+ GL_VERTEX_SHADER_BIT_EXT = $00000001;
+ GL_FRAGMENT_SHADER_BIT_EXT = $00000002;
+ GL_ALL_SHADER_BITS_EXT = $FFFFFFFF;
+ GL_PROGRAM_SEPARABLE_EXT = $8258;
+ GL_PROGRAM_PIPELINE_BINDING_EXT = $825A;
+type
+ TglActiveShaderProgramEXT = procedure(aPipeline: GLuint; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindProgramPipelineEXT = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCreateShaderProgramvEXT = function (aType: GLenum; aCount: GLsizei; const aStrings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteProgramPipelinesEXT = procedure(n: GLsizei; const aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenProgramPipelinesEXT = procedure(n: GLsizei; aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramPipelineInfoLogEXT = procedure(aPipeline: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramPipelineivEXT = procedure(aPipeline: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsProgramPipelineEXT = function (aPipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramParameteriEXT = procedure(aProgram: GLuint; aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1fEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1iEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1ivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2fEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2iEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2ivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3fEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3iEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3ivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4fEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat; aV3: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4iEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint; aV3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4ivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUseProgramStagesEXT = procedure(aPipeline: GLuint; aStages: GLbitfield; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglValidateProgramPipelineEXT = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1uiEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2uiEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3uiEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4uiEXT = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint; aV3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1uivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2uivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3uivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4uivEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2x3fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3x2fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2x4fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4x2fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3x4fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4x3fvEXT = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glActiveShaderProgramEXT: TglActiveShaderProgramEXT;
+ glBindProgramPipelineEXT: TglBindProgramPipelineEXT;
+ glCreateShaderProgramvEXT: TglCreateShaderProgramvEXT;
+ glDeleteProgramPipelinesEXT: TglDeleteProgramPipelinesEXT;
+ glGenProgramPipelinesEXT: TglGenProgramPipelinesEXT;
+ glGetProgramPipelineInfoLogEXT: TglGetProgramPipelineInfoLogEXT;
+ glGetProgramPipelineivEXT: TglGetProgramPipelineivEXT;
+ glIsProgramPipelineEXT: TglIsProgramPipelineEXT;
+ glProgramParameteriEXT: TglProgramParameteriEXT;
+ glProgramUniform1fEXT: TglProgramUniform1fEXT;
+ glProgramUniform1fvEXT: TglProgramUniform1fvEXT;
+ glProgramUniform1iEXT: TglProgramUniform1iEXT;
+ glProgramUniform1ivEXT: TglProgramUniform1ivEXT;
+ glProgramUniform2fEXT: TglProgramUniform2fEXT;
+ glProgramUniform2fvEXT: TglProgramUniform2fvEXT;
+ glProgramUniform2iEXT: TglProgramUniform2iEXT;
+ glProgramUniform2ivEXT: TglProgramUniform2ivEXT;
+ glProgramUniform3fEXT: TglProgramUniform3fEXT;
+ glProgramUniform3fvEXT: TglProgramUniform3fvEXT;
+ glProgramUniform3iEXT: TglProgramUniform3iEXT;
+ glProgramUniform3ivEXT: TglProgramUniform3ivEXT;
+ glProgramUniform4fEXT: TglProgramUniform4fEXT;
+ glProgramUniform4fvEXT: TglProgramUniform4fvEXT;
+ glProgramUniform4iEXT: TglProgramUniform4iEXT;
+ glProgramUniform4ivEXT: TglProgramUniform4ivEXT;
+ glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT;
+ glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT;
+ glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT;
+ glUseProgramStagesEXT: TglUseProgramStagesEXT;
+ glValidateProgramPipelineEXT: TglValidateProgramPipelineEXT;
+ glProgramUniform1uiEXT: TglProgramUniform1uiEXT;
+ glProgramUniform2uiEXT: TglProgramUniform2uiEXT;
+ glProgramUniform3uiEXT: TglProgramUniform3uiEXT;
+ glProgramUniform4uiEXT: TglProgramUniform4uiEXT;
+ glProgramUniform1uivEXT: TglProgramUniform1uivEXT;
+ glProgramUniform2uivEXT: TglProgramUniform2uivEXT;
+ glProgramUniform3uivEXT: TglProgramUniform3uivEXT;
+ glProgramUniform4uivEXT: TglProgramUniform4uivEXT;
+ glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT;
+ glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT;
+ glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT;
+ glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT;
+ glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT;
+ glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT;
+
+{ GL_EXT_shader_framebuffer_fetch }
+const
+ GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = $8A52;
+
+{ GL_EXT_shader_implicit_conversions }
+ // none
+
+{ GL_EXT_shader_integer_mix }
+ // none
+
+{ GL_EXT_shader_io_blocks }
+ // none
+
+{ GL_EXT_shader_pixel_local_storage }
+const
+ GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT = $8F63;
+ GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT = $8F67;
+ GL_SHADER_PIXEL_LOCAL_STORAGE_EXT = $8F64;
+
+{ GL_EXT_shader_texture_lod }
+
+{ GL_EXT_shadow_samplers }
+const
+ GL_TEXTURE_COMPARE_MODE_EXT = $884C;
+ GL_TEXTURE_COMPARE_FUNC_EXT = $884D;
+ GL_COMPARE_REF_TO_TEXTURE_EXT = $884E;
+ GL_SAMPLER_2D_SHADOW_EXT = $8B62;
+
+{ GL_EXT_tessellation_point_size }
+ // none
+
+{ GL_EXT_tessellation_shader }
+const
+ GL_PATCHES_EXT = $000E;
+ GL_PATCH_VERTICES_EXT = $8E72;
+ GL_TESS_CONTROL_OUTPUT_VERTICES_EXT = $8E75;
+ GL_TESS_GEN_MODE_EXT = $8E76;
+ GL_TESS_GEN_SPACING_EXT = $8E77;
+ GL_TESS_GEN_VERTEX_ORDER_EXT = $8E78;
+ GL_TESS_GEN_POINT_MODE_EXT = $8E79;
+ GL_ISOLINES_EXT = $8E7A;
+ GL_QUADS_EXT = $0007;
+ GL_FRACTIONAL_ODD_EXT = $8E7B;
+ GL_FRACTIONAL_EVEN_EXT = $8E7C;
+ GL_MAX_PATCH_VERTICES_EXT = $8E7D;
+ GL_MAX_TESS_GEN_LEVEL_EXT = $8E7E;
+ GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = $8E7F;
+ GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = $8E80;
+ GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT = $8E81;
+ GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT = $8E82;
+ GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT = $8E83;
+ GL_MAX_TESS_PATCH_COMPONENTS_EXT = $8E84;
+ GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT = $8E85;
+ GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT = $8E86;
+ GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT = $8E89;
+ GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT = $8E8A;
+ GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT = $886C;
+ GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT = $886D;
+ GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = $8E1E;
+ GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = $8E1F;
+ GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT = $92CD;
+ GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT = $92CE;
+ GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT = $92D3;
+ GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT = $92D4;
+ GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT = $90CB;
+ GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT = $90CC;
+ GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT = $90D8;
+ GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT = $90D9;
+ GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = $8221;
+ GL_IS_PER_PATCH_EXT = $92E7;
+ GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT = $9307;
+ GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT = $9308;
+ GL_TESS_CONTROL_SHADER_EXT = $8E88;
+ GL_TESS_EVALUATION_SHADER_EXT = $8E87;
+ GL_TESS_CONTROL_SHADER_BIT_EXT = $00000008;
+ GL_TESS_EVALUATION_SHADER_BIT_EXT = $00000010;
+type
+ TglPatchParameteriEXT = procedure(aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glPatchParameteriEXT: TglPatchParameteriEXT;
+
+{ GL_EXT_texture_border_clamp }
+const
+ GL_TEXTURE_BORDER_COLOR_EXT = $1004;
+ GL_CLAMP_TO_BORDER_EXT = $812D;
+type
+ TglTexParameterIivEXT = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexParameterIuivEXT = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexParameterIivEXT = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexParameterIuivEXT = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameterIivEXT = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameterIuivEXT = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSamplerParameterIivEXT = procedure(aSampler: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSamplerParameterIuivEXT = procedure(aSampler: GLuint; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTexParameterIivEXT: TglTexParameterIivEXT;
+ glTexParameterIuivEXT: TglTexParameterIuivEXT;
+ glGetTexParameterIivEXT: TglGetTexParameterIivEXT;
+ glGetTexParameterIuivEXT: TglGetTexParameterIuivEXT;
+ glSamplerParameterIivEXT: TglSamplerParameterIivEXT;
+ glSamplerParameterIuivEXT: TglSamplerParameterIuivEXT;
+ glGetSamplerParameterIivEXT: TglGetSamplerParameterIivEXT;
+ glGetSamplerParameterIuivEXT: TglGetSamplerParameterIuivEXT;
+
+{ GL_EXT_texture_buffer }
+const
+ GL_TEXTURE_BUFFER_EXT = $8C2A;
+ GL_TEXTURE_BUFFER_BINDING_EXT = $8C2A;
+ GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B;
+ GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C;
+ GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D;
+ GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT = $919F;
+ GL_SAMPLER_BUFFER_EXT = $8DC2;
+ GL_INT_SAMPLER_BUFFER_EXT = $8DD0;
+ GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8;
+ GL_IMAGE_BUFFER_EXT = $9051;
+ GL_INT_IMAGE_BUFFER_EXT = $905C;
+ GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067;
+ GL_TEXTURE_BUFFER_OFFSET_EXT = $919D;
+ GL_TEXTURE_BUFFER_SIZE_EXT = $919E;
+type
+ TglTexBufferEXT = procedure(aTarget: GLenum; aInternalformat: GLenum; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexBufferRangeEXT = procedure(aTarget: GLenum; aInternalformat: GLenum; aBuffer: GLuint; aOffset: GLintptr; aSize: GLsizeiptr); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTexBufferEXT: TglTexBufferEXT;
+ glTexBufferRangeEXT: TglTexBufferRangeEXT;
+
+{ GL_EXT_texture_compression_dxt1 }
+const
+ GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
+ GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
+
+{ GL_EXT_texture_compression_s3tc }
+const
+ GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
+ GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
+
+{ GL_EXT_texture_cube_map_array }
+const
+ GL_TEXTURE_CUBE_MAP_ARRAY_EXT = $9009;
+ GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT = $900A;
+ GL_SAMPLER_CUBE_MAP_ARRAY_EXT = $900C;
+ GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT = $900D;
+ GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = $900E;
+ GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = $900F;
+ GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054;
+ GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F;
+ GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A;
+
+{ GL_EXT_texture_filter_anisotropic }
+const
+ GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
+ GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+
+{ GL_EXT_texture_format_BGRA8888 }
+
+{ GL_EXT_texture_norm16 }
+const
+ GL_R16_EXT = $822A;
+ GL_RG16_EXT = $822C;
+ GL_RGBA16_EXT = $805B;
+ GL_RGB16_EXT = $8054;
+ GL_RGB16_SNORM_EXT = $8F9A;
+
+{ GL_EXT_texture_rg }
+const
+ GL_RED_EXT = $1903;
+ GL_RG_EXT = $8227;
+ GL_R8_EXT = $8229;
+ GL_RG8_EXT = $822B;
+
+{ GL_EXT_texture_sRGB_decode }
+const
+ GL_TEXTURE_SRGB_DECODE_EXT = $8A48;
+ GL_DECODE_EXT = $8A49;
+ GL_SKIP_DECODE_EXT = $8A4A;
+
+{ GL_EXT_texture_storage }
+const
+ GL_TEXTURE_IMMUTABLE_FORMAT_EXT = $912F;
+ GL_ALPHA8_EXT = $803C;
+ GL_LUMINANCE8_EXT = $8040;
+ GL_LUMINANCE8_ALPHA8_EXT = $8045;
+ GL_RGBA32F_EXT = $8814;
+ GL_RGB32F_EXT = $8815;
+ GL_ALPHA32F_EXT = $8816;
+ GL_LUMINANCE32F_EXT = $8818;
+ GL_LUMINANCE_ALPHA32F_EXT = $8819;
+ GL_ALPHA16F_EXT = $881C;
+ GL_LUMINANCE16F_EXT = $881E;
+ GL_LUMINANCE_ALPHA16F_EXT = $881F;
+ GL_R32F_EXT = $822E;
+ GL_RG32F_EXT = $8230;
+type
+ TglTexStorage1DEXT = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexStorage2DEXT = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexStorage3DEXT = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTextureStorage1DEXT = procedure(aTexture: GLuint; aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTextureStorage2DEXT = procedure(aTexture: GLuint; aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTextureStorage3DEXT = procedure(aTexture: GLuint; aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTexStorage1DEXT: TglTexStorage1DEXT;
+ glTexStorage2DEXT: TglTexStorage2DEXT;
+ glTexStorage3DEXT: TglTexStorage3DEXT;
+ glTextureStorage1DEXT: TglTextureStorage1DEXT;
+ glTextureStorage2DEXT: TglTextureStorage2DEXT;
+ glTextureStorage3DEXT: TglTextureStorage3DEXT;
+
+{ GL_EXT_texture_type_2_10_10_10_REV }
+const
+ GL_UNSIGNED_INT_2_10_10_10_REV_EXT = $8368;
+
+{ GL_EXT_texture_view }
+const
+ GL_TEXTURE_VIEW_MIN_LEVEL_EXT = $82DB;
+ GL_TEXTURE_VIEW_NUM_LEVELS_EXT = $82DC;
+ GL_TEXTURE_VIEW_MIN_LAYER_EXT = $82DD;
+ GL_TEXTURE_VIEW_NUM_LAYERS_EXT = $82DE;
+ //GL_TEXTURE_IMMUTABLE_LEVELS = $82DF;
+type
+ TglTextureViewEXT = procedure(aTexture: GLuint; aTarget: GLenum; aOrigtexture: GLuint; aInternalformat: GLenum; aMinlevel: GLuint; aNumlevels: GLuint; aMinlayer: GLuint; aNumlayers: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glTextureViewEXT: TglTextureViewEXT;
+
+{ GL_EXT_unpack_subimage }
+const
+ GL_UNPACK_ROW_LENGTH_EXT = $0CF2;
+ GL_UNPACK_SKIP_ROWS_EXT = $0CF3;
+ GL_UNPACK_SKIP_PIXELS_EXT = $0CF4;
+
+{ GL_FJ_shader_binary_GCCSO }
+const
+ GL_GCCSO_SHADER_BINARY_FJ = $9260;
+
+{ GL_IMG_multisampled_render_to_texture }
+const
+ GL_RENDERBUFFER_SAMPLES_IMG = $9133;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG = $9134;
+ GL_MAX_SAMPLES_IMG = $9135;
+ GL_TEXTURE_SAMPLES_IMG = $9136;
+type
+ TglRenderbufferStorageMultisampleIMG = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferTexture2DMultisampleIMG = procedure(aTarget: GLenum; aAttachment: GLenum; aTextarget: GLenum; aTexture: GLuint; aLevel: GLint; aSamples: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glRenderbufferStorageMultisampleIMG: TglRenderbufferStorageMultisampleIMG;
+ glFramebufferTexture2DMultisampleIMG: TglFramebufferTexture2DMultisampleIMG;
+
+{ GL_IMG_program_binary }
+const
+ GL_SGX_PROGRAM_BINARY_IMG = $9130;
+
+{ GL_IMG_read_format }
+const
+ GL_BGRA_IMG = $80E1;
+ GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG = $8365;
+
+{ GL_IMG_shader_binary }
+const
+ GL_SGX_BINARY_IMG = $8C0A;
+
+{ GL_IMG_texture_compression_pvrtc }
+const
+ GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = $8C00;
+ GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = $8C01;
+ GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = $8C02;
+ GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = $8C03;
+
+{ GL_IMG_texture_compression_pvrtc2 }
+const
+ GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = $9137;
+ GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = $9138;
+
+{ GL_INTEL_performance_query }
+const
+ GL_PERFQUERY_SINGLE_CONTEXT_INTEL = $00000000;
+ GL_PERFQUERY_GLOBAL_CONTEXT_INTEL = $00000001;
+ GL_PERFQUERY_WAIT_INTEL = $83FB;
+ GL_PERFQUERY_FLUSH_INTEL = $83FA;
+ GL_PERFQUERY_DONOT_FLUSH_INTEL = $83F9;
+ GL_PERFQUERY_COUNTER_EVENT_INTEL = $94F0;
+ GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL = $94F1;
+ GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL = $94F2;
+ GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL = $94F3;
+ GL_PERFQUERY_COUNTER_RAW_INTEL = $94F4;
+ GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL = $94F5;
+ GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL = $94F8;
+ GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL = $94F9;
+ GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = $94FA;
+ GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = $94FB;
+ GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = $94FC;
+ GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = $94FD;
+ GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = $94FE;
+ GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = $94FF;
+ GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = $9500;
+type
+ TglBeginPerfQueryINTEL = procedure(aQueryHandle: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCreatePerfQueryINTEL = procedure(aQueryId: GLuint; aQueryHandle: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeletePerfQueryINTEL = procedure(aQueryHandle: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndPerfQueryINTEL = procedure(aQueryHandle: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFirstPerfQueryIdINTEL = procedure(aQueryId: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetNextPerfQueryIdINTEL = procedure(aQueryId: GLuint; aNextQueryId: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfCounterInfoINTEL = procedure(aQueryId: GLuint; aCounterId: GLuint; aCounterNameLength: GLuint; aCounterName: PGLchar; aCounterDescLength: GLuint; aCounterDesc: PGLchar; aCounterOffset: PGLuint; aCounterDataSize: PGLuint; aCounterTypeEnum: PGLuint; aCounterDataTypeEnum: PGLuint; aRawCounterMaxValue: PGLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfQueryDataINTEL = procedure(aQueryHandle: GLuint; aFlags: GLuint; aDataSize: GLsizei; aData: PGLvoid; aBytesWritten: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfQueryIdByNameINTEL = procedure(aQueryName: PGLchar; aQueryId: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPerfQueryInfoINTEL = procedure(aQueryId: GLuint; aQueryNameLength: GLuint; aQueryName: PGLchar; aDataSize: PGLuint; aNoCounters: PGLuint; aNoInstances: PGLuint; aCapsMask: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glBeginPerfQueryINTEL: TglBeginPerfQueryINTEL;
+ glCreatePerfQueryINTEL: TglCreatePerfQueryINTEL;
+ glDeletePerfQueryINTEL: TglDeletePerfQueryINTEL;
+ glEndPerfQueryINTEL: TglEndPerfQueryINTEL;
+ glGetFirstPerfQueryIdINTEL: TglGetFirstPerfQueryIdINTEL;
+ glGetNextPerfQueryIdINTEL: TglGetNextPerfQueryIdINTEL;
+ glGetPerfCounterInfoINTEL: TglGetPerfCounterInfoINTEL;
+ glGetPerfQueryDataINTEL: TglGetPerfQueryDataINTEL;
+ glGetPerfQueryIdByNameINTEL: TglGetPerfQueryIdByNameINTEL;
+ glGetPerfQueryInfoINTEL: TglGetPerfQueryInfoINTEL;
+
+{ GL_NV_bindless_texture }
+type
+ TglGetTextureHandleNV = function (aTexture: GLuint): GLuint64; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTextureSamplerHandleNV = function (aTexture: GLuint; aSampler: GLuint): GLuint64; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMakeTextureHandleResidentNV = procedure(aHandle: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMakeTextureHandleNonResidentNV = procedure(aHandle: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetImageHandleNV = function (aTexture: GLuint; aLevel: GLint; aLayered: GLboolean; aLayer: GLint; aFormat: GLenum): GLuint64; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMakeImageHandleResidentNV = procedure(aHandle: GLuint64; aAccess: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMakeImageHandleNonResidentNV = procedure(aHandle: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformHandleui64NV = procedure(aLocation: GLint; aValue: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformHandleui64vNV = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformHandleui64NV = procedure(aProgram: GLuint; aLocation: GLint; aValue: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformHandleui64vNV = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValues: PGLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsTextureHandleResidentNV = function (aHandle: GLuint64): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsImageHandleResidentNV = function (aHandle: GLuint64): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetTextureHandleNV: TglGetTextureHandleNV;
+ glGetTextureSamplerHandleNV: TglGetTextureSamplerHandleNV;
+ glMakeTextureHandleResidentNV: TglMakeTextureHandleResidentNV;
+ glMakeTextureHandleNonResidentNV: TglMakeTextureHandleNonResidentNV;
+ glGetImageHandleNV: TglGetImageHandleNV;
+ glMakeImageHandleResidentNV: TglMakeImageHandleResidentNV;
+ glMakeImageHandleNonResidentNV: TglMakeImageHandleNonResidentNV;
+ glUniformHandleui64NV: TglUniformHandleui64NV;
+ glUniformHandleui64vNV: TglUniformHandleui64vNV;
+ glProgramUniformHandleui64NV: TglProgramUniformHandleui64NV;
+ glProgramUniformHandleui64vNV: TglProgramUniformHandleui64vNV;
+ glIsTextureHandleResidentNV: TglIsTextureHandleResidentNV;
+ glIsImageHandleResidentNV: TglIsImageHandleResidentNV;
+
+{ GL_NV_blend_equation_advanced }
+const
+ GL_BLEND_OVERLAP_NV = $9281;
+ GL_BLEND_PREMULTIPLIED_SRC_NV = $9280;
+ GL_BLUE_NV = $1905;
+ GL_COLORBURN_NV = $929A;
+ GL_COLORDODGE_NV = $9299;
+ GL_CONJOINT_NV = $9284;
+ GL_CONTRAST_NV = $92A1;
+ GL_DARKEN_NV = $9297;
+ GL_DIFFERENCE_NV = $929E;
+ GL_DISJOINT_NV = $9283;
+ GL_DST_ATOP_NV = $928F;
+ GL_DST_IN_NV = $928B;
+ GL_DST_NV = $9287;
+ GL_DST_OUT_NV = $928D;
+ GL_DST_OVER_NV = $9289;
+ GL_EXCLUSION_NV = $92A0;
+ GL_GREEN_NV = $1904;
+ GL_HARDLIGHT_NV = $929B;
+ GL_HARDMIX_NV = $92A9;
+ GL_HSL_COLOR_NV = $92AF;
+ GL_HSL_HUE_NV = $92AD;
+ GL_HSL_LUMINOSITY_NV = $92B0;
+ GL_HSL_SATURATION_NV = $92AE;
+ GL_INVERT_OVG_NV = $92B4;
+ GL_INVERT_RGB_NV = $92A3;
+ GL_LIGHTEN_NV = $9298;
+ GL_LINEARBURN_NV = $92A5;
+ GL_LINEARDODGE_NV = $92A4;
+ GL_LINEARLIGHT_NV = $92A7;
+ GL_MINUS_CLAMPED_NV = $92B3;
+ GL_MINUS_NV = $929F;
+ GL_MULTIPLY_NV = $9294;
+ GL_OVERLAY_NV = $9296;
+ GL_PINLIGHT_NV = $92A8;
+ GL_PLUS_CLAMPED_ALPHA_NV = $92B2;
+ GL_PLUS_CLAMPED_NV = $92B1;
+ GL_PLUS_DARKER_NV = $9292;
+ GL_PLUS_NV = $9291;
+ GL_RED_NV = $1903;
+ GL_SCREEN_NV = $9295;
+ GL_SOFTLIGHT_NV = $929C;
+ GL_SRC_ATOP_NV = $928E;
+ GL_SRC_IN_NV = $928A;
+ GL_SRC_NV = $9286;
+ GL_SRC_OUT_NV = $928C;
+ GL_SRC_OVER_NV = $9288;
+ GL_UNCORRELATED_NV = $9282;
+ GL_VIVIDLIGHT_NV = $92A6;
+ GL_XOR_NV = $1506;
+type
+ TglBlendParameteriNV = procedure(aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glBlendParameteriNV: TglBlendParameteriNV;
+ glBlendBarrierNV: TglBlendBarrierNV;
+
+{ GL_NV_blend_equation_advanced_coherent }
+const
+ GL_BLEND_ADVANCED_COHERENT_NV = $9285;
+
+{ GL_NV_conditional_render }
+const
+ GL_QUERY_WAIT_NV = $8E13;
+ GL_QUERY_NO_WAIT_NV = $8E14;
+ GL_QUERY_BY_REGION_WAIT_NV = $8E15;
+ GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16;
+type
+ TglBeginConditionalRenderNV = procedure(aId: GLuint; aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndConditionalRenderNV = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glBeginConditionalRenderNV: TglBeginConditionalRenderNV;
+ glEndConditionalRenderNV: TglEndConditionalRenderNV;
+
+{ GL_NV_copy_buffer }
+const
+ GL_COPY_READ_BUFFER_NV = $8F36;
+ GL_COPY_WRITE_BUFFER_NV = $8F37;
+type
+ TglCopyBufferSubDataNV = procedure(aReadTarget: GLenum; aWriteTarget: GLenum; aReadOffset: GLintptr; aWriteOffset: GLintptr; aSize: GLsizeiptr); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glCopyBufferSubDataNV: TglCopyBufferSubDataNV;
+
+{ GL_NV_coverage_sample }
+const
+ GL_COVERAGE_COMPONENT_NV = $8ED0;
+ GL_COVERAGE_COMPONENT4_NV = $8ED1;
+ GL_COVERAGE_ATTACHMENT_NV = $8ED2;
+ GL_COVERAGE_BUFFERS_NV = $8ED3;
+ GL_COVERAGE_SAMPLES_NV = $8ED4;
+ GL_COVERAGE_ALL_FRAGMENTS_NV = $8ED5;
+ GL_COVERAGE_EDGE_FRAGMENTS_NV = $8ED6;
+ GL_COVERAGE_AUTOMATIC_NV = $8ED7;
+ GL_COVERAGE_BUFFER_BIT_NV = $00008000;
+type
+ TglCoverageMaskNV = procedure(aMask: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCoverageOperationNV = procedure(aOperation: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glCoverageMaskNV: TglCoverageMaskNV;
+ glCoverageOperationNV: TglCoverageOperationNV;
+
+{ GL_NV_depth_nonlinear }
+const
+ GL_DEPTH_COMPONENT16_NONLINEAR_NV = $8E2C;
+
+{ GL_NV_draw_buffers }
+const
+ GL_MAX_DRAW_BUFFERS_NV = $8824;
+ GL_DRAW_BUFFER0_NV = $8825;
+ GL_DRAW_BUFFER1_NV = $8826;
+ GL_DRAW_BUFFER2_NV = $8827;
+ GL_DRAW_BUFFER3_NV = $8828;
+ GL_DRAW_BUFFER4_NV = $8829;
+ GL_DRAW_BUFFER5_NV = $882A;
+ GL_DRAW_BUFFER6_NV = $882B;
+ GL_DRAW_BUFFER7_NV = $882C;
+ GL_DRAW_BUFFER8_NV = $882D;
+ GL_DRAW_BUFFER9_NV = $882E;
+ GL_DRAW_BUFFER10_NV = $882F;
+ GL_DRAW_BUFFER11_NV = $8830;
+ GL_DRAW_BUFFER12_NV = $8831;
+ GL_DRAW_BUFFER13_NV = $8832;
+ GL_DRAW_BUFFER14_NV = $8833;
+ GL_DRAW_BUFFER15_NV = $8834;
+ GL_COLOR_ATTACHMENT0_NV = $8CE0;
+ GL_COLOR_ATTACHMENT1_NV = $8CE1;
+ GL_COLOR_ATTACHMENT2_NV = $8CE2;
+ GL_COLOR_ATTACHMENT3_NV = $8CE3;
+ GL_COLOR_ATTACHMENT4_NV = $8CE4;
+ GL_COLOR_ATTACHMENT5_NV = $8CE5;
+ GL_COLOR_ATTACHMENT6_NV = $8CE6;
+ GL_COLOR_ATTACHMENT7_NV = $8CE7;
+ GL_COLOR_ATTACHMENT8_NV = $8CE8;
+ GL_COLOR_ATTACHMENT9_NV = $8CE9;
+ GL_COLOR_ATTACHMENT10_NV = $8CEA;
+ GL_COLOR_ATTACHMENT11_NV = $8CEB;
+ GL_COLOR_ATTACHMENT12_NV = $8CEC;
+ GL_COLOR_ATTACHMENT13_NV = $8CED;
+ GL_COLOR_ATTACHMENT14_NV = $8CEE;
+ GL_COLOR_ATTACHMENT15_NV = $8CEF;
+type
+ TglDrawBuffersNV = procedure(n: GLsizei; const aBufs: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawBuffersNV: TglDrawBuffersNV;
+
+{ GL_NV_draw_instanced }
+type
+ TglDrawArraysInstancedNV = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstancedNV = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: Pointer; aPrimcount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDrawArraysInstancedNV: TglDrawArraysInstancedNV;
+ glDrawElementsInstancedNV: TglDrawElementsInstancedNV;
+
+{ GL_NV_explicit_attrib_location }
+ // none
+
+{ GL_NV_fbo_color_attachments }
+const
+ GL_MAX_COLOR_ATTACHMENTS_NV = $8CDF;
+
+{ GL_NV_fence }
+const
+ GL_ALL_COMPLETED_NV = $84F2;
+ GL_FENCE_STATUS_NV = $84F3;
+ GL_FENCE_CONDITION_NV = $84F4;
+type
+ TglDeleteFencesNV = procedure(n: GLsizei; const aFences: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenFencesNV = procedure(n: GLsizei; aFences: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsFenceNV = function (aFence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTestFenceNV = function (aFence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFenceivNV = procedure(aFence: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFinishFenceNV = procedure(aFence: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSetFenceNV = procedure(aFence: GLuint; aCondition: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glDeleteFencesNV: TglDeleteFencesNV;
+ glGenFencesNV: TglGenFencesNV;
+ glIsFenceNV: TglIsFenceNV;
+ glTestFenceNV: TglTestFenceNV;
+ glGetFenceivNV: TglGetFenceivNV;
+ glFinishFenceNV: TglFinishFenceNV;
+ glSetFenceNV: TglSetFenceNV;
+
+{ GL_NV_framebuffer_blit }
+const
+ GL_READ_FRAMEBUFFER_NV = $8CA8;
+ GL_DRAW_FRAMEBUFFER_NV = $8CA9;
+ GL_DRAW_FRAMEBUFFER_BINDING_NV = $8CA6;
+ GL_READ_FRAMEBUFFER_BINDING_NV = $8CAA;
+type
+ TglBlitFramebufferNV = 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}
+var
+ glBlitFramebufferNV: TglBlitFramebufferNV;
+
+{ GL_NV_framebuffer_multisample }
+const
+ GL_RENDERBUFFER_SAMPLES_NV = $8CAB;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV = $8D56;
+ GL_MAX_SAMPLES_NV = $8D57;
+type
+ TglRenderbufferStorageMultisampleNV = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glRenderbufferStorageMultisampleNV: TglRenderbufferStorageMultisampleNV;
+
+{ GL_NV_generate_mipmap_sRGB }
+ // none
+
+{ GL_NV_image_formats }
+ // none
+
+{ GL_NV_instanced_arrays }
+const
+ GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV = $88FE;
+type
+ TglVertexAttribDivisorNV = procedure(aIndex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glVertexAttribDivisorNV: TglVertexAttribDivisorNV;
+
+{ GL_NV_internalformat_sample_query }
+const
+ //GL_TEXTURE_2D_MULTISAMPLE = $9100;
+ GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102;
+ GL_MULTISAMPLES_NV = $9371;
+ GL_SUPERSAMPLE_SCALE_X_NV = $9372;
+ GL_SUPERSAMPLE_SCALE_Y_NV = $9373;
+ GL_CONFORMANT_NV = $9374;
+type
+ TglGetInternalformatSampleivNV = procedure(aTarget: GLenum; aInternalformat: GLenum; aSamples: GLsizei; aPname: GLenum; aBufSize: GLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetInternalformatSampleivNV: TglGetInternalformatSampleivNV;
+
+{ GL_NV_non_square_matrices }
+const
+ GL_FLOAT_MAT2x3_NV = $8B65;
+ GL_FLOAT_MAT2x4_NV = $8B66;
+ GL_FLOAT_MAT3x2_NV = $8B67;
+ GL_FLOAT_MAT3x4_NV = $8B68;
+ GL_FLOAT_MAT4x2_NV = $8B69;
+ GL_FLOAT_MAT4x3_NV = $8B6A;
+type
+ TglUniformMatrix2x3fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix3x2fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix2x4fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix4x2fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix3x4fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix4x3fvNV = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glUniformMatrix2x3fvNV: TglUniformMatrix2x3fvNV;
+ glUniformMatrix3x2fvNV: TglUniformMatrix3x2fvNV;
+ glUniformMatrix2x4fvNV: TglUniformMatrix2x4fvNV;
+ glUniformMatrix4x2fvNV: TglUniformMatrix4x2fvNV;
+ glUniformMatrix3x4fvNV: TglUniformMatrix3x4fvNV;
+ glUniformMatrix4x3fvNV: TglUniformMatrix4x3fvNV;
+
+{ GL_NV_path_rendering }
+const
+ GL_PATH_FORMAT_SVG_NV = $9070;
+ GL_PATH_FORMAT_PS_NV = $9071;
+ GL_STANDARD_FONT_NAME_NV = $9072;
+ GL_SYSTEM_FONT_NAME_NV = $9073;
+ GL_FILE_NAME_NV = $9074;
+ GL_PATH_STROKE_WIDTH_NV = $9075;
+ GL_PATH_END_CAPS_NV = $9076;
+ GL_PATH_INITIAL_END_CAP_NV = $9077;
+ GL_PATH_TERMINAL_END_CAP_NV = $9078;
+ GL_PATH_JOIN_STYLE_NV = $9079;
+ GL_PATH_MITER_LIMIT_NV = $907A;
+ GL_PATH_DASH_CAPS_NV = $907B;
+ GL_PATH_INITIAL_DASH_CAP_NV = $907C;
+ GL_PATH_TERMINAL_DASH_CAP_NV = $907D;
+ GL_PATH_DASH_OFFSET_NV = $907E;
+ GL_PATH_CLIENT_LENGTH_NV = $907F;
+ GL_PATH_FILL_MODE_NV = $9080;
+ GL_PATH_FILL_MASK_NV = $9081;
+ GL_PATH_FILL_COVER_MODE_NV = $9082;
+ GL_PATH_STROKE_COVER_MODE_NV = $9083;
+ GL_PATH_STROKE_MASK_NV = $9084;
+ GL_COUNT_UP_NV = $9088;
+ GL_COUNT_DOWN_NV = $9089;
+ GL_PATH_OBJECT_BOUNDING_BOX_NV = $908A;
+ GL_CONVEX_HULL_NV = $908B;
+ GL_BOUNDING_BOX_NV = $908D;
+ GL_TRANSLATE_X_NV = $908E;
+ GL_TRANSLATE_Y_NV = $908F;
+ GL_TRANSLATE_2D_NV = $9090;
+ GL_TRANSLATE_3D_NV = $9091;
+ GL_AFFINE_2D_NV = $9092;
+ GL_AFFINE_3D_NV = $9094;
+ GL_TRANSPOSE_AFFINE_2D_NV = $9096;
+ GL_TRANSPOSE_AFFINE_3D_NV = $9098;
+ GL_UTF8_NV = $909A;
+ GL_UTF16_NV = $909B;
+ GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = $909C;
+ GL_PATH_COMMAND_COUNT_NV = $909D;
+ GL_PATH_COORD_COUNT_NV = $909E;
+ GL_PATH_DASH_ARRAY_COUNT_NV = $909F;
+ GL_PATH_COMPUTED_LENGTH_NV = $90A0;
+ GL_PATH_FILL_BOUNDING_BOX_NV = $90A1;
+ GL_PATH_STROKE_BOUNDING_BOX_NV = $90A2;
+ GL_SQUARE_NV = $90A3;
+ GL_ROUND_NV = $90A4;
+ GL_TRIANGULAR_NV = $90A5;
+ GL_BEVEL_NV = $90A6;
+ GL_MITER_REVERT_NV = $90A7;
+ GL_MITER_TRUNCATE_NV = $90A8;
+ GL_SKIP_MISSING_GLYPH_NV = $90A9;
+ GL_USE_MISSING_GLYPH_NV = $90AA;
+ GL_PATH_ERROR_POSITION_NV = $90AB;
+ GL_ACCUM_ADJACENT_PAIRS_NV = $90AD;
+ GL_ADJACENT_PAIRS_NV = $90AE;
+ GL_FIRST_TO_REST_NV = $90AF;
+ GL_PATH_GEN_MODE_NV = $90B0;
+ GL_PATH_GEN_COEFF_NV = $90B1;
+ GL_PATH_GEN_COMPONENTS_NV = $90B3;
+ GL_PATH_STENCIL_FUNC_NV = $90B7;
+ GL_PATH_STENCIL_REF_NV = $90B8;
+ GL_PATH_STENCIL_VALUE_MASK_NV = $90B9;
+ GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = $90BD;
+ GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = $90BE;
+ GL_PATH_COVER_DEPTH_FUNC_NV = $90BF;
+ GL_PATH_DASH_OFFSET_RESET_NV = $90B4;
+ GL_MOVE_TO_RESETS_NV = $90B5;
+ GL_MOVE_TO_CONTINUES_NV = $90B6;
+ GL_CLOSE_PATH_NV = $00;
+ GL_MOVE_TO_NV = $02;
+ GL_RELATIVE_MOVE_TO_NV = $03;
+ GL_LINE_TO_NV = $04;
+ GL_RELATIVE_LINE_TO_NV = $05;
+ GL_HORIZONTAL_LINE_TO_NV = $06;
+ GL_RELATIVE_HORIZONTAL_LINE_TO_NV = $07;
+ GL_VERTICAL_LINE_TO_NV = $08;
+ GL_RELATIVE_VERTICAL_LINE_TO_NV = $09;
+ GL_QUADRATIC_CURVE_TO_NV = $0A;
+ GL_RELATIVE_QUADRATIC_CURVE_TO_NV = $0B;
+ GL_CUBIC_CURVE_TO_NV = $0C;
+ GL_RELATIVE_CUBIC_CURVE_TO_NV = $0D;
+ GL_SMOOTH_QUADRATIC_CURVE_TO_NV = $0E;
+ GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = $0F;
+ GL_SMOOTH_CUBIC_CURVE_TO_NV = $10;
+ GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = $11;
+ GL_SMALL_CCW_ARC_TO_NV = $12;
+ GL_RELATIVE_SMALL_CCW_ARC_TO_NV = $13;
+ GL_SMALL_CW_ARC_TO_NV = $14;
+ GL_RELATIVE_SMALL_CW_ARC_TO_NV = $15;
+ GL_LARGE_CCW_ARC_TO_NV = $16;
+ GL_RELATIVE_LARGE_CCW_ARC_TO_NV = $17;
+ GL_LARGE_CW_ARC_TO_NV = $18;
+ GL_RELATIVE_LARGE_CW_ARC_TO_NV = $19;
+ GL_RESTART_PATH_NV = $F0;
+ GL_DUP_FIRST_CUBIC_CURVE_TO_NV = $F2;
+ GL_DUP_LAST_CUBIC_CURVE_TO_NV = $F4;
+ GL_RECT_NV = $F6;
+ GL_CIRCULAR_CCW_ARC_TO_NV = $F8;
+ GL_CIRCULAR_CW_ARC_TO_NV = $FA;
+ GL_CIRCULAR_TANGENT_ARC_TO_NV = $FC;
+ GL_ARC_TO_NV = $FE;
+ GL_RELATIVE_ARC_TO_NV = $FF;
+ GL_BOLD_BIT_NV = $01;
+ GL_ITALIC_BIT_NV = $02;
+ GL_GLYPH_WIDTH_BIT_NV = $01;
+ GL_GLYPH_HEIGHT_BIT_NV = $02;
+ GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = $04;
+ GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = $08;
+ GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = $10;
+ GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = $20;
+ GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = $40;
+ GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = $80;
+ GL_GLYPH_HAS_KERNING_BIT_NV = $100;
+ GL_FONT_X_MIN_BOUNDS_BIT_NV = $00010000;
+ GL_FONT_Y_MIN_BOUNDS_BIT_NV = $00020000;
+ GL_FONT_X_MAX_BOUNDS_BIT_NV = $00040000;
+ GL_FONT_Y_MAX_BOUNDS_BIT_NV = $00080000;
+ GL_FONT_UNITS_PER_EM_BIT_NV = $00100000;
+ GL_FONT_ASCENDER_BIT_NV = $00200000;
+ GL_FONT_DESCENDER_BIT_NV = $00400000;
+ GL_FONT_HEIGHT_BIT_NV = $00800000;
+ GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV = $01000000;
+ GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = $02000000;
+ GL_FONT_UNDERLINE_POSITION_BIT_NV = $04000000;
+ GL_FONT_UNDERLINE_THICKNESS_BIT_NV = $08000000;
+ GL_FONT_HAS_KERNING_BIT_NV = $10000000;
+ GL_ROUNDED_RECT_NV = $E8;
+ GL_RELATIVE_ROUNDED_RECT_NV = $E9;
+ GL_ROUNDED_RECT2_NV = $EA;
+ GL_RELATIVE_ROUNDED_RECT2_NV = $EB;
+ GL_ROUNDED_RECT4_NV = $EC;
+ GL_RELATIVE_ROUNDED_RECT4_NV = $ED;
+ GL_ROUNDED_RECT8_NV = $EE;
+ GL_RELATIVE_ROUNDED_RECT8_NV = $EF;
+ GL_RELATIVE_RECT_NV = $F7;
+ GL_FONT_GLYPHS_AVAILABLE_NV = $9368;
+ GL_FONT_TARGET_UNAVAILABLE_NV = $9369;
+ GL_FONT_UNAVAILABLE_NV = $936A;
+ GL_FONT_UNINTELLIGIBLE_NV = $936B;
+ GL_CONIC_CURVE_TO_NV = $1A;
+ GL_RELATIVE_CONIC_CURVE_TO_NV = $1B;
+ GL_FONT_NUM_GLYPH_INDICES_BIT_NV = $20000000;
+ GL_STANDARD_FONT_FORMAT_NV = $936C;
+ GL_PATH_PROJECTION_NV = $1701;
+ GL_PATH_MODELVIEW_NV = $1700;
+ GL_PATH_MODELVIEW_STACK_DEPTH_NV = $0BA3;
+ GL_PATH_MODELVIEW_MATRIX_NV = $0BA6;
+ GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = $0D36;
+ GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = $84E3;
+ GL_PATH_PROJECTION_STACK_DEPTH_NV = $0BA4;
+ GL_PATH_PROJECTION_MATRIX_NV = $0BA7;
+ GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV = $0D38;
+ GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = $84E4;
+ GL_FRAGMENT_INPUT_NV = $936D;
+type
+ TglGenPathsNV = function (aRange: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeletePathsNV = procedure(aPath: GLuint; aRange: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsPathNV = function (aPath: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathCommandsNV = procedure(aPath: GLuint; aNumCommands: GLsizei; const aCommands: PGLubyte; aNumCoords: GLsizei; aCoordType: GLenum; const aCoords: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathCoordsNV = procedure(aPath: GLuint; aNumCoords: GLsizei; aCoordType: GLenum; const aCoords: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathSubCommandsNV = procedure(aPath: GLuint; aCommandStart: GLsizei; aCommandsToDelete: GLsizei; aNumCommands: GLsizei; const aCommands: PGLubyte; aNumCoords: GLsizei; aCoordType: GLenum; const aCoords: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathSubCoordsNV = procedure(aPath: GLuint; aCoordStart: GLsizei; aNumCoords: GLsizei; aCoordType: GLenum; const aCoords: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathStringNV = procedure(aPath: GLuint; aFormat: GLenum; aLength: GLsizei; const aPathString: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathGlyphsNV = procedure(aFirstPathName: GLuint; aFontTarget: GLenum; const aFontName: Pointer; aFontStyle: GLbitfield; aNumGlyphs: GLsizei; aType: GLenum; const aCharcodes: Pointer; aHandleMissingGlyphs: GLenum; aPathParameterTemplate: GLuint; aEmScale: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathGlyphRangeNV = procedure(aFirstPathName: GLuint; aFontTarget: GLenum; const aFontName: Pointer; aFontStyle: GLbitfield; aFirstGlyph: GLuint; aNumGlyphs: GLsizei; aHandleMissingGlyphs: GLenum; aPathParameterTemplate: GLuint; aEmScale: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglWeightPathsNV = procedure(aResultPath: GLuint; aNumPaths: GLsizei; const aPaths: PGLuint; const aWeights: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyPathNV = procedure(aResultPath: GLuint; aSrcPath: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglInterpolatePathsNV = procedure(aResultPath: GLuint; aPathA: GLuint; aPathB: GLuint; aWeight: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTransformPathNV = procedure(aResultPath: GLuint; aSrcPath: GLuint; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathParameterivNV = procedure(aPath: GLuint; aPname: GLenum; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathParameteriNV = procedure(aPath: GLuint; aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathParameterfvNV = procedure(aPath: GLuint; aPname: GLenum; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathParameterfNV = procedure(aPath: GLuint; aPname: GLenum; aValue: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathDashArrayNV = procedure(aPath: GLuint; aDashCount: GLsizei; const aDashArray: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathStencilFuncNV = procedure(aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathStencilDepthOffsetNV = procedure(aFactor: GLfloat; aUnits: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilFillPathNV = procedure(aPath: GLuint; aFillMode: GLenum; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilStrokePathNV = procedure(aPath: GLuint; aReference: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilFillPathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aFillMode: GLenum; aMask: GLuint; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilStrokePathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aReference: GLint; aMask: GLuint; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathCoverDepthFuncNV = procedure(aFunc: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCoverFillPathNV = procedure(aPath: GLuint; aCoverMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCoverStrokePathNV = procedure(aPath: GLuint; aCoverMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCoverFillPathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aCoverMode: GLenum; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCoverStrokePathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aCoverMode: GLenum; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathParameterivNV = procedure(aPath: GLuint; aPname: GLenum; aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathParameterfvNV = procedure(aPath: GLuint; aPname: GLenum; aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathCommandsNV = procedure(aPath: GLuint; aCommands: PGLubyte); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathCoordsNV = procedure(aPath: GLuint; aCoords: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathDashArrayNV = procedure(aPath: GLuint; aDashArray: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathMetricsNV = procedure(aMetricQueryMask: GLbitfield; aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aStride: GLsizei; aMetrics: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathMetricRangeNV = procedure(aMetricQueryMask: GLbitfield; aFirstPathName: GLuint; aNumPaths: GLsizei; aStride: GLsizei; aMetrics: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathSpacingNV = procedure(aPathListMode: GLenum; aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aAdvanceScale: GLfloat; aKerningScale: GLfloat; aTransformType: GLenum; aReturnedSpacing: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsPointInFillPathNV = function (aPath: GLuint; aMask: GLuint; x: GLfloat; y: GLfloat): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsPointInStrokePathNV = function (aPath: GLuint; x: GLfloat; y: GLfloat): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetPathLengthNV = function (aPath: GLuint; aStartSegment: GLsizei; aNumSegments: GLsizei): GLfloat; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPointAlongPathNV = function (aPath: GLuint; aStartSegment: GLsizei; aNumSegments: GLsizei; aDistance: GLfloat; x: PGLfloat; y: PGLfloat; aTangentX: PGLfloat; aTangentY: PGLfloat): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixLoad3x2fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixLoad3x3fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixLoadTranspose3x3fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixMult3x2fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixMult3x3fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMatrixMultTranspose3x3fNV = procedure(aMatrixMode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilThenCoverFillPathNV = procedure(aPath: GLuint; aFillMode: GLenum; aMask: GLuint; aCoverMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilThenCoverStrokePathNV = procedure(aPath: GLuint; aReference: GLint; aMask: GLuint; aCoverMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilThenCoverFillPathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aFillMode: GLenum; aMask: GLuint; aCoverMode: GLenum; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilThenCoverStrokePathInstancedNV = procedure(aNumPaths: GLsizei; aPathNameType: GLenum; const aPaths: Pointer; aPathBase: GLuint; aReference: GLint; aMask: GLuint; aCoverMode: GLenum; aTransformType: GLenum; const aTransformValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathGlyphIndexRangeNV = function (aFontTarget: GLenum; const aFontName: Pointer; aFontStyle: GLbitfield; aPathParameterTemplate: GLuint; aEmScale: GLfloat; aBaseAndCount: PGLuint): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathGlyphIndexArrayNV = function (aFirstPathName: GLuint; aFontTarget: GLenum; const aFontName: Pointer; aFontStyle: GLbitfield; aFirstGlyphIndex: GLuint; aNumGlyphs: GLsizei; aPathParameterTemplate: GLuint; aEmScale: GLfloat): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPathMemoryGlyphIndexArrayNV = function (aFirstPathName: GLuint; aFontTarget: GLenum; aFontSize: GLsizeiptr; const aFontData: Pointer; aFaceIndex: GLsizei; aFirstGlyphIndex: GLuint; aNumGlyphs: GLsizei; aPathParameterTemplate: GLuint; aEmScale: GLfloat): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramPathFragmentInputGenNV = procedure(aProgram: GLuint; aLocation: GLint; aGenMode: GLenum; aComponents: GLint; const aCoeffs: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramResourcefvNV = procedure(aProgram: GLuint; aProgramInterface: GLenum; aIndex: GLuint; aPropCount: GLsizei; const aProps: PGLenum; aBufSize: GLsizei; aLength: PGLsizei; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGenPathsNV: TglGenPathsNV;
+ glDeletePathsNV: TglDeletePathsNV;
+ glIsPathNV: TglIsPathNV;
+ glPathCommandsNV: TglPathCommandsNV;
+ glPathCoordsNV: TglPathCoordsNV;
+ glPathSubCommandsNV: TglPathSubCommandsNV;
+ glPathSubCoordsNV: TglPathSubCoordsNV;
+ glPathStringNV: TglPathStringNV;
+ glPathGlyphsNV: TglPathGlyphsNV;
+ glPathGlyphRangeNV: TglPathGlyphRangeNV;
+ glWeightPathsNV: TglWeightPathsNV;
+ glCopyPathNV: TglCopyPathNV;
+ glInterpolatePathsNV: TglInterpolatePathsNV;
+ glTransformPathNV: TglTransformPathNV;
+ glPathParameterivNV: TglPathParameterivNV;
+ glPathParameteriNV: TglPathParameteriNV;
+ glPathParameterfvNV: TglPathParameterfvNV;
+ glPathParameterfNV: TglPathParameterfNV;
+ glPathDashArrayNV: TglPathDashArrayNV;
+ glPathStencilFuncNV: TglPathStencilFuncNV;
+ glPathStencilDepthOffsetNV: TglPathStencilDepthOffsetNV;
+ glStencilFillPathNV: TglStencilFillPathNV;
+ glStencilStrokePathNV: TglStencilStrokePathNV;
+ glStencilFillPathInstancedNV: TglStencilFillPathInstancedNV;
+ glStencilStrokePathInstancedNV: TglStencilStrokePathInstancedNV;
+ glPathCoverDepthFuncNV: TglPathCoverDepthFuncNV;
+ glCoverFillPathNV: TglCoverFillPathNV;
+ glCoverStrokePathNV: TglCoverStrokePathNV;
+ glCoverFillPathInstancedNV: TglCoverFillPathInstancedNV;
+ glCoverStrokePathInstancedNV: TglCoverStrokePathInstancedNV;
+ glGetPathParameterivNV: TglGetPathParameterivNV;
+ glGetPathParameterfvNV: TglGetPathParameterfvNV;
+ glGetPathCommandsNV: TglGetPathCommandsNV;
+ glGetPathCoordsNV: TglGetPathCoordsNV;
+ glGetPathDashArrayNV: TglGetPathDashArrayNV;
+ glGetPathMetricsNV: TglGetPathMetricsNV;
+ glGetPathMetricRangeNV: TglGetPathMetricRangeNV;
+ glGetPathSpacingNV: TglGetPathSpacingNV;
+ glIsPointInFillPathNV: TglIsPointInFillPathNV;
+ glIsPointInStrokePathNV: TglIsPointInStrokePathNV;
+ glGetPathLengthNV: TglGetPathLengthNV;
+ glPointAlongPathNV: TglPointAlongPathNV;
+ glMatrixLoad3x2fNV: TglMatrixLoad3x2fNV;
+ glMatrixLoad3x3fNV: TglMatrixLoad3x3fNV;
+ glMatrixLoadTranspose3x3fNV: TglMatrixLoadTranspose3x3fNV;
+ glMatrixMult3x2fNV: TglMatrixMult3x2fNV;
+ glMatrixMult3x3fNV: TglMatrixMult3x3fNV;
+ glMatrixMultTranspose3x3fNV: TglMatrixMultTranspose3x3fNV;
+ glStencilThenCoverFillPathNV: TglStencilThenCoverFillPathNV;
+ glStencilThenCoverStrokePathNV: TglStencilThenCoverStrokePathNV;
+ glStencilThenCoverFillPathInstancedNV: TglStencilThenCoverFillPathInstancedNV;
+ glStencilThenCoverStrokePathInstancedNV: TglStencilThenCoverStrokePathInstancedNV;
+ glPathGlyphIndexRangeNV: TglPathGlyphIndexRangeNV;
+ glPathGlyphIndexArrayNV: TglPathGlyphIndexArrayNV;
+ glPathMemoryGlyphIndexArrayNV: TglPathMemoryGlyphIndexArrayNV;
+ glProgramPathFragmentInputGenNV: TglProgramPathFragmentInputGenNV;
+ glGetProgramResourcefvNV: TglGetProgramResourcefvNV;
+
+{ GL_NV_read_buffer }
+const
+ GL_READ_BUFFER_NV = $0C02;
+type
+ TglReadBufferNV = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glReadBufferNV: TglReadBufferNV;
+
+{ GL_NV_read_buffer_front }
+ // none
+
+{ GL_NV_read_depth }
+ // none
+
+{ GL_NV_read_depth_stencil }
+ // none
+
+{ GL_NV_read_stencil }
+ // none
+
+{ GL_NV_sRGB_formats }
+const
+ GL_SLUMINANCE_NV = $8C46;
+ GL_SLUMINANCE_ALPHA_NV = $8C44;
+ GL_SRGB8_NV = $8C41;
+ GL_SLUMINANCE8_NV = $8C47;
+ GL_SLUMINANCE8_ALPHA8_NV = $8C45;
+ GL_COMPRESSED_SRGB_S3TC_DXT1_NV = $8C4C;
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV = $8C4D;
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV = $8C4E;
+ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV = $8C4F;
+ GL_ETC1_SRGB8_NV = $88EE;
+
+{ GL_NV_shader_noperspective_interpolation }
+ // none
+
+{ GL_NV_shadow_samplers_array }
+const
+ GL_SAMPLER_2D_ARRAY_SHADOW_NV = $8DC4;
+
+{ GL_NV_shadow_samplers_cube }
+const
+ GL_SAMPLER_CUBE_SHADOW_NV = $8DC5;
+
+{ GL_NV_texture_border_clamp }
+const
+ GL_TEXTURE_BORDER_COLOR_NV = $1004;
+ GL_CLAMP_TO_BORDER_NV = $812D;
+
+{ GL_NV_texture_compression_s3tc_update }
+ // none
+
+{ GL_NV_texture_npot_2D_mipmap }
+ // none
+
+{ GL_NV_viewport_array }
+const
+ GL_MAX_VIEWPORTS_NV = $825B;
+ GL_VIEWPORT_SUBPIXEL_BITS_NV = $825C;
+ GL_VIEWPORT_BOUNDS_RANGE_NV = $825D;
+ GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV = $825F;
+type
+ TglViewportArrayvNV = procedure(aFirst: GLuint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglViewportIndexedfNV = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglViewportIndexedfvNV = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglScissorArrayvNV = procedure(aFirst: GLuint; aCount: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglScissorIndexedNV = procedure(aIndex: GLuint; aLeft: GLint; aBottom: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglScissorIndexedvNV = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDepthRangeArrayfvNV = procedure(aFirst: GLuint; aCount: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDepthRangeIndexedfNV = procedure(aIndex: GLuint; n: GLfloat; f: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFloati_vNV = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEnableiNV = procedure(aTarget: GLenum; aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDisableiNV = procedure(aTarget: GLenum; aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsEnablediNV = function (aTarget: GLenum; aIndex: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glViewportArrayvNV: TglViewportArrayvNV;
+ glViewportIndexedfNV: TglViewportIndexedfNV;
+ glViewportIndexedfvNV: TglViewportIndexedfvNV;
+ glScissorArrayvNV: TglScissorArrayvNV;
+ glScissorIndexedNV: TglScissorIndexedNV;
+ glScissorIndexedvNV: TglScissorIndexedvNV;
+ glDepthRangeArrayfvNV: TglDepthRangeArrayfvNV;
+ glDepthRangeIndexedfNV: TglDepthRangeIndexedfNV;
+ glGetFloati_vNV: TglGetFloati_vNV;
+ glEnableiNV: TglEnableiNV;
+ glDisableiNV: TglDisableiNV;
+ glIsEnablediNV: TglIsEnablediNV;
+
+{ GL_QCOM_alpha_test }
+const
+ GL_ALPHA_TEST_QCOM = $0BC0;
+ GL_ALPHA_TEST_FUNC_QCOM = $0BC1;
+ GL_ALPHA_TEST_REF_QCOM = $0BC2;
+type
+ TglAlphaFuncQCOM = procedure(aFunc: GLenum; aRef: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glAlphaFuncQCOM: TglAlphaFuncQCOM;
+
+{ GL_QCOM_binning_control }
+const
+ GL_BINNING_CONTROL_HINT_QCOM = $8FB0;
+ GL_CPU_OPTIMIZED_QCOM = $8FB1;
+ GL_GPU_OPTIMIZED_QCOM = $8FB2;
+ GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM = $8FB3;
+
+{ GL_QCOM_driver_control }
+type
+ TglGetDriverControlsQCOM = procedure(aNum: PGLint; aSize: GLsizei; aDriverControls: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetDriverControlStringQCOM = procedure(aDriverControl: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aDriverControlString: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEnableDriverControlQCOM = procedure(aDriverControl: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDisableDriverControlQCOM = procedure(aDriverControl: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glGetDriverControlsQCOM: TglGetDriverControlsQCOM;
+ glGetDriverControlStringQCOM: TglGetDriverControlStringQCOM;
+ glEnableDriverControlQCOM: TglEnableDriverControlQCOM;
+ glDisableDriverControlQCOM: TglDisableDriverControlQCOM;
+
+{ GL_QCOM_extended_get }
+const
+ GL_TEXTURE_WIDTH_QCOM = $8BD2;
+ GL_TEXTURE_HEIGHT_QCOM = $8BD3;
+ GL_TEXTURE_DEPTH_QCOM = $8BD4;
+ GL_TEXTURE_INTERNAL_FORMAT_QCOM = $8BD5;
+ GL_TEXTURE_FORMAT_QCOM = $8BD6;
+ GL_TEXTURE_TYPE_QCOM = $8BD7;
+ GL_TEXTURE_IMAGE_VALID_QCOM = $8BD8;
+ GL_TEXTURE_NUM_LEVELS_QCOM = $8BD9;
+ GL_TEXTURE_TARGET_QCOM = $8BDA;
+ GL_TEXTURE_OBJECT_VALID_QCOM = $8BDB;
+ GL_STATE_RESTORE = $8BDC;
+type
+ TglExtGetTexturesQCOM = procedure(aTextures: PGLuint; aMaxTextures: GLint; aNumTextures: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetBuffersQCOM = procedure(aBuffers: PGLuint; aMaxBuffers: GLint; aNumBuffers: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetRenderbuffersQCOM = procedure(aRenderbuffers: PGLuint; aMaxRenderbuffers: GLint; aNumRenderbuffers: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetFramebuffersQCOM = procedure(aFramebuffers: PGLuint; aMaxFramebuffers: GLint; aNumFramebuffers: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetTexLevelParameterivQCOM = procedure(aTexture: GLuint; aFace: GLenum; aLevel: GLint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtTexObjectStateOverrideiQCOM = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetTexSubImageQCOM = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aType: GLenum; aTexels: Pointer); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetBufferPointervQCOM = procedure(aTarget: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glExtGetTexturesQCOM: TglExtGetTexturesQCOM;
+ glExtGetBuffersQCOM: TglExtGetBuffersQCOM;
+ glExtGetRenderbuffersQCOM: TglExtGetRenderbuffersQCOM;
+ glExtGetFramebuffersQCOM: TglExtGetFramebuffersQCOM;
+ glExtGetTexLevelParameterivQCOM: TglExtGetTexLevelParameterivQCOM;
+ glExtTexObjectStateOverrideiQCOM: TglExtTexObjectStateOverrideiQCOM;
+ glExtGetTexSubImageQCOM: TglExtGetTexSubImageQCOM;
+ glExtGetBufferPointervQCOM: TglExtGetBufferPointervQCOM;
+
+{ GL_QCOM_extended_get2 }
+type
+ TglExtGetShadersQCOM = procedure(aShaders: PGLuint; aMaxShaders: GLint; aNumShaders: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetProgramsQCOM = procedure(aPrograms: PGLuint; aMaxPrograms: GLint; aNumPrograms: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtIsProgramBinaryQCOM = function (aProgram: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglExtGetProgramBinarySourceQCOM = procedure(aProgram: GLuint; aShadertype: GLenum; aSource: PGLchar; aLength: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glExtGetShadersQCOM: TglExtGetShadersQCOM;
+ glExtGetProgramsQCOM: TglExtGetProgramsQCOM;
+ glExtIsProgramBinaryQCOM: TglExtIsProgramBinaryQCOM;
+ glExtGetProgramBinarySourceQCOM: TglExtGetProgramBinarySourceQCOM;
+
+{ GL_QCOM_perfmon_global_mode }
+const
+ GL_PERFMON_GLOBAL_MODE_QCOM = $8FA0;
+
+{ GL_QCOM_tiled_rendering }
+const
+ GL_COLOR_BUFFER_BIT0_QCOM = $00000001;
+ GL_COLOR_BUFFER_BIT1_QCOM = $00000002;
+ GL_COLOR_BUFFER_BIT2_QCOM = $00000004;
+ GL_COLOR_BUFFER_BIT3_QCOM = $00000008;
+ GL_COLOR_BUFFER_BIT4_QCOM = $00000010;
+ GL_COLOR_BUFFER_BIT5_QCOM = $00000020;
+ GL_COLOR_BUFFER_BIT6_QCOM = $00000040;
+ GL_COLOR_BUFFER_BIT7_QCOM = $00000080;
+ GL_DEPTH_BUFFER_BIT0_QCOM = $00000100;
+ GL_DEPTH_BUFFER_BIT1_QCOM = $00000200;
+ GL_DEPTH_BUFFER_BIT2_QCOM = $00000400;
+ GL_DEPTH_BUFFER_BIT3_QCOM = $00000800;
+ GL_DEPTH_BUFFER_BIT4_QCOM = $00001000;
+ GL_DEPTH_BUFFER_BIT5_QCOM = $00002000;
+ GL_DEPTH_BUFFER_BIT6_QCOM = $00004000;
+ GL_DEPTH_BUFFER_BIT7_QCOM = $00008000;
+ GL_STENCIL_BUFFER_BIT0_QCOM = $00010000;
+ GL_STENCIL_BUFFER_BIT1_QCOM = $00020000;
+ GL_STENCIL_BUFFER_BIT2_QCOM = $00040000;
+ GL_STENCIL_BUFFER_BIT3_QCOM = $00080000;
+ GL_STENCIL_BUFFER_BIT4_QCOM = $00100000;
+ GL_STENCIL_BUFFER_BIT5_QCOM = $00200000;
+ GL_STENCIL_BUFFER_BIT6_QCOM = $00400000;
+ GL_STENCIL_BUFFER_BIT7_QCOM = $00800000;
+ GL_MULTISAMPLE_BUFFER_BIT0_QCOM = $01000000;
+ GL_MULTISAMPLE_BUFFER_BIT1_QCOM = $02000000;
+ GL_MULTISAMPLE_BUFFER_BIT2_QCOM = $04000000;
+ GL_MULTISAMPLE_BUFFER_BIT3_QCOM = $08000000;
+ GL_MULTISAMPLE_BUFFER_BIT4_QCOM = $10000000;
+ GL_MULTISAMPLE_BUFFER_BIT5_QCOM = $20000000;
+ GL_MULTISAMPLE_BUFFER_BIT6_QCOM = $40000000;
+ GL_MULTISAMPLE_BUFFER_BIT7_QCOM = $80000000;
+type
+ TglStartTilingQCOM = procedure(x: GLuint; y: GLuint; aWidth: GLuint; aHeight: GLuint; aPreserveMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndTilingQCOM = procedure(aPreserveMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+var
+ glStartTilingQCOM: TglStartTilingQCOM;
+ glEndTilingQCOM: TglEndTilingQCOM;
+
+{ GL_QCOM_writeonly_rendering }
+const
+ GL_WRITEONLY_RENDERING_QCOM = $8823;
+
+{ GL_VIV_shader_binary }
+const
+ GL_SHADER_BINARY_VIV = $8FC4;
+
+{ ================================================== EGL ============================================================= }
+type
+ EGLint = Integer;
+ EGLboolean = Cardinal;
+ EGLenum = Cardinal;
+ EGLConfig = Pointer;
+ EGLContext = Pointer;
+ EGLDisplay = Pointer;
+ EGLSurface = Pointer;
+ EGLClientBuffer = Pointer;
+ EGLNativeDisplayType = Pointer;
+ EGLNativePixmapType = Pointer;
+ EGLNativeWindowType = packed record
+ element: Cardinal;
+ width: Integer;
+ height: Integer;
+ end;
+
+ PEGLint = ^EGLint;
+ PEGLboolean = ^EGLboolean;
+ PEGLenum = ^EGLenum;
+ PEGLConfig = ^EGLConfig;
+ PEGLContext = ^EGLContext;
+ PEGLDisplay = ^EGLDisplay;
+ PEGLSurface = ^EGLSurface;
+ PEGLClientBuffer = ^EGLClientBuffer;
+ PEGLNativeDisplayType = ^EGLNativeDisplayType;
+ PEGLNativePixmapType = ^EGLNativePixmapType;
+ PEGLNativeWindowType = ^EGLNativeWindowType;
+
+const
+ EGL_FALSE: EGLboolean = 0;
+ EGL_TRUE: EGLboolean = 1;
+
+ EGL_DEFAULT_DISPLAY: EGLNativeDisplayType = nil;
+ EGL_NO_CONTEXT: EGLContext = nil;
+ EGL_NO_DISPLAY: EGLDisplay = nil;
+ EGL_NO_SURFACE: EGLSurface = nil;
+
+ EGL_DONT_CARE: EGLint = -1;
+
+ EGL_SUCCESS = $3000;
+ EGL_NOT_INITIALIZED = $3001;
+ EGL_BAD_ACCESS = $3002;
+ EGL_BAD_ALLOC = $3003;
+ EGL_BAD_ATTRIBUTE = $3004;
+ EGL_BAD_CONFIG = $3005;
+ EGL_BAD_CONTEXT = $3006;
+ EGL_BAD_CURRENT_SURFACE = $3007;
+ EGL_BAD_DISPLAY = $3008;
+ EGL_BAD_MATCH = $3009;
+ EGL_BAD_NATIVE_PIXMAP = $300A;
+ EGL_BAD_NATIVE_WINDOW = $300B;
+ EGL_BAD_PARAMETER = $300C;
+ EGL_BAD_SURFACE = $300D;
+ EGL_CONTEXT_LOST = $300E;
+
+ EGL_BUFFER_SIZE = $3020;
+ EGL_ALPHA_SIZE = $3021;
+ EGL_BLUE_SIZE = $3022;
+ EGL_GREEN_SIZE = $3023;
+ EGL_RED_SIZE = $3024;
+ EGL_DEPTH_SIZE = $3025;
+ EGL_STENCIL_SIZE = $3026;
+ EGL_CONFIG_CAVEAT = $3027;
+ EGL_CONFIG_ID = $3028;
+ EGL_LEVEL = $3029;
+ EGL_MAX_PBUFFER_HEIGHT = $302A;
+ EGL_MAX_PBUFFER_PIXELS = $302B;
+ EGL_MAX_PBUFFER_WIDTH = $302C;
+ EGL_NATIVE_RENDERABLE = $302D;
+ EGL_NATIVE_VISUAL_ID = $302E;
+ EGL_NATIVE_VISUAL_TYPE = $302F;
+ EGL_SAMPLES = $3031;
+ EGL_SAMPLE_BUFFERS = $3032;
+ EGL_SURFACE_TYPE = $3033;
+ EGL_TRANSPARENT_TYPE = $3034;
+ EGL_TRANSPARENT_BLUE_VALUE = $3035;
+ EGL_TRANSPARENT_GREEN_VALUE = $3036;
+ EGL_TRANSPARENT_RED_VALUE = $3037;
+ EGL_NONE = $3038;
+ EGL_BIND_TO_TEXTURE_RGB = $3039;
+ EGL_BIND_TO_TEXTURE_RGBA = $303A;
+ EGL_MIN_SWAP_INTERVAL = $303B;
+ EGL_MAX_SWAP_INTERVAL = $303C;
+ EGL_LUMINANCE_SIZE = $303D;
+ EGL_ALPHA_MASK_SIZE = $303E;
+ EGL_COLOR_BUFFER_TYPE = $303F;
+ EGL_RENDERABLE_TYPE = $3040;
+ EGL_MATCH_NATIVE_PIXMAP = $3041;
+ EGL_CONFORMANT = $3042;
+
+ EGL_SLOW_CONFIG = $3050;
+ EGL_NON_CONFORMANT_CONFIG = $3051;
+ EGL_TRANSPARENT_RGB = $3052;
+ EGL_RGB_BUFFER = $308E;
+ EGL_LUMINANCE_BUFFER = $308F;
+
+ EGL_NO_TEXTURE = $305C;
+ EGL_TEXTURE_RGB = $305D;
+ EGL_TEXTURE_RGBA = $305E;
+ EGL_TEXTURE_2D = $305F;
+
+ EGL_PBUFFER_BIT = $0001;
+ EGL_PIXMAP_BIT = $0002;
+ EGL_WINDOW_BIT = $0004;
+ EGL_VG_COLORSPACE_LINEAR_BIT = $0020;
+ EGL_VG_ALPHA_FORMAT_PRE_BIT = $0040;
+ EGL_MULTISAMPLE_RESOLVE_BOX_BIT = $0200;
+ EGL_SWAP_BEHAVIOR_PRESERVED_BIT = $0400;
+
+ EGL_OPENGL_ES_BIT = $0001;
+ EGL_OPENVG_BIT = $0002;
+ EGL_OPENGL_ES2_BIT = $0004;
+ EGL_OPENGL_BIT = $0008;
+
+ EGL_VENDOR = $3053;
+ EGL_VERSION = $3054;
+ EGL_EXTENSIONS = $3055;
+ EGL_CLIENT_APIS = $308D;
+
+ EGL_HEIGHT = $3056;
+ EGL_WIDTH = $3057;
+ EGL_LARGEST_PBUFFER = $3058;
+ EGL_TEXTURE_FORMAT = $3080;
+ EGL_TEXTURE_TARGET = $3081;
+ EGL_MIPMAP_TEXTURE = $3082;
+ EGL_MIPMAP_LEVEL = $3083;
+ EGL_RENDER_BUFFER = $3086;
+ EGL_VG_COLORSPACE = $3087;
+ EGL_VG_ALPHA_FORMAT = $3088;
+ EGL_HORIZONTAL_RESOLUTION = $3090;
+ EGL_VERTICAL_RESOLUTION = $3091;
+ EGL_PIXEL_ASPECT_RATIO = $3092;
+ EGL_SWAP_BEHAVIOR = $3093;
+ EGL_MULTISAMPLE_RESOLVE = $3099;
+
+ EGL_BACK_BUFFER = $3084;
+ EGL_SINGLE_BUFFER = $3085;
+
+ EGL_VG_COLORSPACE_sRGB = $3089;
+ EGL_VG_COLORSPACE_LINEAR = $308A;
+
+ EGL_VG_ALPHA_FORMAT_NONPRE = $308B;
+ EGL_VG_ALPHA_FORMAT_PRE = $308C;
+
+ EGL_DISPLAY_SCALING = 10000;
+
+ EGL_UNKNOWN: EGLint = -1;
+
+ EGL_BUFFER_PRESERVED = $3094;
+ EGL_BUFFER_DESTROYED = $3095;
+
+ EGL_OPENVG_IMAGE = $3096;
+
+ EGL_CONTEXT_CLIENT_TYPE = $3097;
+
+ EGL_CONTEXT_CLIENT_VERSION = $3098;
+
+ EGL_MULTISAMPLE_RESOLVE_DEFAULT = $309A;
+ EGL_MULTISAMPLE_RESOLVE_BOX = $309B;
+
+ EGL_OPENGL_ES_API = $30A0;
+ EGL_OPENVG_API = $30A1;
+ EGL_OPENGL_API = $30A2;
+
+ EGL_DRAW = $3059;
+ EGL_READ = $305A;
+
+ EGL_CORE_NATIVE_ENGINE = $305B;
+
+ EGL_COLORSPACE = EGL_VG_COLORSPACE;
+ EGL_ALPHA_FORMAT = EGL_VG_ALPHA_FORMAT;
+ EGL_COLORSPACE_sRGB = EGL_VG_COLORSPACE_sRGB;
+ EGL_COLORSPACE_LINEAR = EGL_VG_COLORSPACE_LINEAR;
+ EGL_ALPHA_FORMAT_NONPRE = EGL_VG_ALPHA_FORMAT_NONPRE;
+ EGL_ALPHA_FORMAT_PRE = EGL_VG_ALPHA_FORMAT_PRE;
+
+type
+ TeglGetError = function: EGLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetDisplay = function(aDisplayID: EGLNativeDisplayType): EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglInitialize = function(aDisplay: EGLDisplay; aMajor, aMinor: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglTerminate = function(aDisplay: EGLDisplay): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglQueryString = function(aDisplay: EGLDisplay; name: EGLint): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetConfigs = function(aDisplay: EGLDisplay; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglChooseConfig = function(aDisplay: EGLDisplay; const aAttribList: PEGLint; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetConfigAttrib = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aAttribute: EGLint; aValue : PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreateWindowSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aWinType: PEGLNativeWindowType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCreatePbufferSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCreatePixmapSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aPixmap: EGLNativePixmapType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglDestroySurface = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQuerySurface = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglBindAPI = function(aApi: EGLenum): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQueryAPI = function: EGLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglWaitClient = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglReleaseThread = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreatePbufferFromClientBuffer = function(aDisplay: EGLDisplay; aBufType: EGLenum; aBuffer: EGLClientBuffer; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglSurfaceAttrib = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglBindTexImage = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglReleaseTexImage = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglSwapInterval = function(aDisplay: EGLDisplay; aInterval: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreateContext = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aShareContext: EGLContext; const aAttribList: PEGLint): EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglDestroyContext = function(aDisplay: EGLDisplay; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglMakeCurrent = function(aDisplay: EGLDisplay; aDraw: EGLSurface; aRead: EGLSurface; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetCurrentContext = function: EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetCurrentSurface = function(aReadDraw: EGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetCurrentDisplay = function: EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQueryContext = function(aDisplay: EGLDisplay; aContext: EGLContext; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglWaitGL = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglWaitNative = function(aEngine: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglSwapBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCopyBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aTarget: EGLNativePixmapType): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetProcAddress = function(const aProcName: PAnsiChar): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+var
+ eglGetError: TeglGetError;
+
+ eglGetDisplay: TeglGetDisplay;
+ eglInitialize: TeglInitialize;
+ eglTerminate: TeglTerminate;
+
+ eglQueryString: TeglQueryString;
+
+ eglGetConfigs: TeglGetConfigs;
+ eglChooseConfig: TeglChooseConfig;
+ eglGetConfigAttrib: TeglGetConfigAttrib;
+
+ eglCreateWindowSurface: TeglCreateWindowSurface;
eglCreatePbufferSurface: TeglCreatePbufferSurface;
eglCreatePixmapSurface: TeglCreatePixmapSurface;
eglDestroySurface: TeglDestroySurface;
eglGetProcAddress: TeglGetProcAddress;
{ =================================================== DelphiGL ======================================================= }
+var
+ GLmajor: Integer;
+ GLminor: Integer;
+
+ GL_VERSION_1_0,
+ GL_VERSION_1_1,
+ GL_VERSION_2_0,
+ GL_VERSION_3_0,
+ GL_VERSION_3_1,
+ GL_KHR_blend_equation_advanced,
+ GL_KHR_blend_equation_advanced_coherent,
+ GL_KHR_context_flush_control,
+ GL_KHR_debug,
+ GL_KHR_robust_buffer_access_behavior,
+ GL_KHR_robustness,
+ GL_KHR_texture_compression_astc_hdr,
+ GL_KHR_texture_compression_astc_ldr,
+ GL_OES_EGL_image,
+ GL_OES_EGL_image_external,
+ GL_OES_compressed_ETC1_RGB8_sub_texture,
+ GL_OES_compressed_ETC1_RGB8_texture,
+ GL_OES_compressed_paletted_texture,
+ GL_OES_depth24,
+ GL_OES_depth32,
+ GL_OES_depth_texture,
+ GL_OES_element_index_uint,
+ GL_OES_fbo_render_mipmap,
+ GL_OES_fragment_precision_high,
+ GL_OES_get_program_binary,
+ GL_OES_mapbuffer,
+ GL_OES_packed_depth_stencil,
+ GL_OES_required_internalformat,
+ GL_OES_rgb8_rgba8,
+ GL_OES_sample_shading,
+ GL_OES_sample_variables,
+ GL_OES_shader_image_atomic,
+ GL_OES_shader_multisample_interpolation,
+ GL_OES_standard_derivatives,
+ GL_OES_stencil1,
+ GL_OES_stencil4,
+ GL_OES_surfaceless_context,
+ GL_OES_texture_3D,
+ GL_OES_texture_compression_astc,
+ GL_OES_texture_float,
+ GL_OES_texture_float_linear,
+ GL_OES_texture_half_float,
+ GL_OES_texture_half_float_linear,
+ GL_OES_texture_npot,
+ GL_OES_texture_stencil8,
+ GL_OES_texture_storage_multisample_2d_array,
+ GL_OES_vertex_array_object,
+ GL_OES_vertex_half_float,
+ GL_OES_vertex_type_10_10_10_2,
+ GL_AMD_compressed_3DC_texture,
+ GL_AMD_compressed_ATC_texture,
+ GL_AMD_performance_monitor,
+ GL_AMD_program_binary_Z400,
+ GL_ANDROID_extension_pack_es31a,
+ GL_ANGLE_depth_texture,
+ GL_ANGLE_framebuffer_blit,
+ GL_ANGLE_framebuffer_multisample,
+ GL_ANGLE_instanced_arrays,
+ GL_ANGLE_pack_reverse_row_order,
+ GL_ANGLE_program_binary,
+ GL_ANGLE_texture_compression_dxt3,
+ GL_ANGLE_texture_compression_dxt5,
+ GL_ANGLE_texture_usage,
+ GL_ANGLE_translated_shader_source,
+ GL_APPLE_clip_distance,
+ GL_APPLE_color_buffer_packed_float,
+ GL_APPLE_copy_texture_levels,
+ GL_APPLE_framebuffer_multisample,
+ GL_APPLE_rgb_422,
+ GL_APPLE_sync,
+ GL_APPLE_texture_format_BGRA8888,
+ GL_APPLE_texture_max_level,
+ GL_APPLE_texture_packed_float,
+ GL_ARM_mali_program_binary,
+ GL_ARM_mali_shader_binary,
+ GL_ARM_rgba8,
+ GL_ARM_shader_framebuffer_fetch,
+ GL_ARM_shader_framebuffer_fetch_depth_stencil,
+ GL_DMP_program_binary,
+ GL_DMP_shader_binary,
+ GL_EXT_base_instance,
+ GL_EXT_blend_minmax,
+ GL_EXT_color_buffer_half_float,
+ GL_EXT_copy_image,
+ GL_EXT_debug_label,
+ GL_EXT_debug_marker,
+ GL_EXT_discard_framebuffer,
+ GL_EXT_disjoint_timer_query,
+ GL_EXT_draw_buffers,
+ GL_EXT_draw_buffers_indexed,
+ GL_EXT_draw_elements_base_vertex,
+ GL_EXT_draw_instanced,
+ GL_EXT_geometry_point_size,
+ GL_EXT_geometry_shader,
+ GL_EXT_gpu_shader5,
+ GL_EXT_instanced_arrays,
+ GL_EXT_map_buffer_range,
+ GL_EXT_multi_draw_arrays,
+ GL_EXT_multi_draw_indirect,
+ GL_EXT_multisampled_render_to_texture,
+ GL_EXT_multiview_draw_buffers,
+ GL_EXT_occlusion_query_boolean,
+ GL_EXT_primitive_bounding_box,
+ GL_EXT_pvrtc_sRGB,
+ GL_EXT_read_format_bgra,
+ GL_EXT_render_snorm,
+ GL_EXT_robustness,
+ GL_EXT_sRGB,
+ GL_EXT_sRGB_write_control,
+ GL_EXT_separate_shader_objects,
+ GL_EXT_shader_framebuffer_fetch,
+ GL_EXT_shader_implicit_conversions,
+ GL_EXT_shader_integer_mix,
+ GL_EXT_shader_io_blocks,
+ GL_EXT_shader_pixel_local_storage,
+ GL_EXT_shader_texture_lod,
+ GL_EXT_shadow_samplers,
+ GL_EXT_tessellation_point_size,
+ GL_EXT_tessellation_shader,
+ GL_EXT_texture_border_clamp,
+ GL_EXT_texture_buffer,
+ GL_EXT_texture_compression_dxt1,
+ GL_EXT_texture_compression_s3tc,
+ GL_EXT_texture_cube_map_array,
+ GL_EXT_texture_filter_anisotropic,
+ GL_EXT_texture_format_BGRA8888,
+ GL_EXT_texture_norm16,
+ GL_EXT_texture_rg,
+ GL_EXT_texture_sRGB_decode,
+ GL_EXT_texture_storage,
+ GL_EXT_texture_type_2_10_10_10_REV,
+ GL_EXT_texture_view,
+ GL_EXT_unpack_subimage,
+ GL_FJ_shader_binary_GCCSO,
+ GL_IMG_multisampled_render_to_texture,
+ GL_IMG_program_binary,
+ GL_IMG_read_format,
+ GL_IMG_shader_binary,
+ GL_IMG_texture_compression_pvrtc,
+ GL_IMG_texture_compression_pvrtc2,
+ GL_INTEL_performance_query,
+ GL_NV_bindless_texture,
+ GL_NV_blend_equation_advanced,
+ GL_NV_blend_equation_advanced_coherent,
+ GL_NV_conditional_render,
+ GL_NV_copy_buffer,
+ GL_NV_coverage_sample,
+ GL_NV_depth_nonlinear,
+ GL_NV_draw_buffers,
+ GL_NV_draw_instanced,
+ GL_NV_explicit_attrib_location,
+ GL_NV_fbo_color_attachments,
+ GL_NV_fence,
+ GL_NV_framebuffer_blit,
+ GL_NV_framebuffer_multisample,
+ GL_NV_generate_mipmap_sRGB,
+ GL_NV_image_formats,
+ GL_NV_instanced_arrays,
+ GL_NV_internalformat_sample_query,
+ GL_NV_non_square_matrices,
+ GL_NV_path_rendering,
+ GL_NV_read_buffer,
+ GL_NV_read_buffer_front,
+ GL_NV_read_depth,
+ GL_NV_read_depth_stencil,
+ GL_NV_read_stencil,
+ GL_NV_sRGB_formats,
+ GL_NV_shader_noperspective_interpolation,
+ GL_NV_shadow_samplers_array,
+ GL_NV_shadow_samplers_cube,
+ GL_NV_texture_border_clamp,
+ GL_NV_texture_compression_s3tc_update,
+ GL_NV_texture_npot_2D_mipmap,
+ GL_NV_viewport_array,
+ GL_QCOM_alpha_test,
+ GL_QCOM_binning_control,
+ GL_QCOM_driver_control,
+ GL_QCOM_extended_get,
+ GL_QCOM_extended_get2,
+ GL_QCOM_perfmon_global_mode,
+ GL_QCOM_tiled_rendering,
+ GL_QCOM_writeonly_rendering,
+ GL_VIV_shader_binary: Boolean;
+
type
EdglOpenGLES = class(Exception);
EeglError = class(EdglOpenGLES)
constructor Create(const msg: string; const aErrorCode: EGLint);
end;
+ TActivationFlag = (
+ afReadOpenGLCore,
+ afReadExtensions,
+ afReadCoreVersion,
+ afReadImplProp
+ );
+ TActivationFlags = set of TActivationFlag;
+
TdglRenderContext = packed record
Display: EGLDisplay;
Surface: EGLSurface;
const aConfigAttribs: PEGLint;
const aContextAttribs: PEGLint): TdglRenderContext;
procedure DestroyRenderingContext(const aContext: TdglRenderContext);
-function ActivateRenderingContext(const aContext: TdglRenderContext): Boolean;
+function ActivateRenderingContext(const aContext: TdglRenderContext; const aFlags: TActivationFlags = [afReadOpenGLCore, afReadExtensions, afReadCoreVersion, afReadImplProp]): Boolean;
function DeactivateRenderingContext(const aContext: TdglRenderContext): Boolean;
procedure SwapBuffers(const aContext: TdglRenderContext);
+procedure ReadOpenGLCore;
procedure ReadExtensions;
+procedure ReadCoreVersion;
+procedure ReadImplementationProperties;
+
+procedure Read_GL_KHR_blend_equation_advanced;
+procedure Read_GL_KHR_debug;
+procedure Read_GL_KHR_robustness;
+procedure Read_GL_OES_EGL_image;
+procedure Read_GL_OES_get_program_binary;
+procedure Read_GL_OES_mapbuffer;
+procedure Read_GL_OES_sample_shading;
+procedure Read_GL_OES_texture_3D;
+procedure Read_GL_OES_texture_storage_multisample_2d_array;
+procedure Read_GL_OES_vertex_array_object;
+procedure Read_GL_AMD_performance_monitor;
+procedure Read_GL_ANGLE_framebuffer_blit;
+procedure Read_GL_ANGLE_framebuffer_multisample;
+procedure Read_GL_ANGLE_instanced_arrays;
+procedure Read_GL_ANGLE_translated_shader_source;
+procedure Read_GL_APPLE_copy_texture_levels;
+procedure Read_GL_APPLE_framebuffer_multisample;
+procedure Read_GL_APPLE_sync;
+procedure Read_GL_EXT_base_instance;
+procedure Read_GL_EXT_copy_image;
+procedure Read_GL_EXT_debug_label;
+procedure Read_GL_EXT_debug_marker;
+procedure Read_GL_EXT_discard_framebuffer;
+procedure Read_GL_EXT_disjoint_timer_query;
+procedure Read_GL_EXT_draw_buffers;
+procedure Read_GL_EXT_draw_buffers_indexed;
+procedure Read_GL_EXT_draw_elements_base_vertex;
+procedure Read_GL_EXT_draw_instanced;
+procedure Read_GL_EXT_geometry_shader;
+procedure Read_GL_EXT_instanced_arrays;
+procedure Read_GL_EXT_map_buffer_range;
+procedure Read_GL_EXT_multi_draw_arrays;
+procedure Read_GL_EXT_multi_draw_indirect;
+procedure Read_GL_EXT_multisampled_render_to_texture;
+procedure Read_GL_EXT_multiview_draw_buffers;
+procedure Read_GL_EXT_primitive_bounding_box;
+procedure Read_GL_EXT_robustness;
+procedure Read_GL_EXT_separate_shader_objects;
+procedure Read_GL_EXT_tessellation_shader;
+procedure Read_GL_EXT_texture_border_clamp;
+procedure Read_GL_EXT_texture_buffer;
+procedure Read_GL_EXT_texture_storage;
+procedure Read_GL_EXT_texture_view;
+procedure Read_GL_IMG_multisampled_render_to_texture;
+procedure Read_GL_INTEL_performance_query;
+procedure Read_GL_NV_bindless_texture;
+procedure Read_GL_NV_blend_equation_advanced;
+procedure Read_GL_NV_conditional_render;
+procedure Read_GL_NV_copy_buffer;
+procedure Read_GL_NV_coverage_sample;
+procedure Read_GL_NV_draw_buffers;
+procedure Read_GL_NV_draw_instanced;
+procedure Read_GL_NV_fence;
+procedure Read_GL_NV_framebuffer_blit;
+procedure Read_GL_NV_framebuffer_multisample;
+procedure Read_GL_NV_instanced_arrays;
+procedure Read_GL_NV_internalformat_sample_query;
+procedure Read_GL_NV_non_square_matrices;
+procedure Read_GL_NV_path_rendering;
+procedure Read_GL_NV_read_buffer;
+procedure Read_GL_NV_viewport_array;
+procedure Read_GL_QCOM_alpha_test;
+procedure Read_GL_QCOM_driver_control;
+procedure Read_GL_QCOM_extended_get;
+procedure Read_GL_QCOM_extended_get2;
+procedure Read_GL_QCOM_tiled_rendering;
implementation
begin
result := nil;
+ {$IFDEF DGL_LINUX}
if Assigned(LibHandleOpenGLES) then
result := dlsym(LibHandleOpenGLES, aProcName);
if not Assigned(result) and Assigned(LibHandleEGL) then
result := dlsym(LibHandleEGL, aProcName);
+ {$ENDIF}
end;
function dglFreeAndNilLibrary(var aLibHandle: Pointer): Boolean;
result := false;
end;
-procedure ReadOpenGLCore;
-begin
-
-end;
-
function InitOpenGLES(const aOpenGLESLibName: String; aEGLLibName: String): Boolean;
begin
result := true;
RaiseEglError('unable to destroy surface.');
end;
-function ActivateRenderingContext(const aContext: TdglRenderContext): Boolean;
+function ActivateRenderingContext(const aContext: TdglRenderContext; const aFlags: TActivationFlags): Boolean;
begin
result := (eglMakeCurrent(aContext.Display, aContext.Surface, aContext.Surface, aContext.Context) = GL_TRUE);
+ if (afReadOpenGLCore in aFlags) then
+ ReadOpenGLCore;
+ if (afReadExtensions in aFlags) then
+ ReadExtensions;
+ if (afReadCoreVersion in aFlags) then
+ ReadCoreVersion;
+ if (afReadImplProp in aFlags) then
+ ReadImplementationProperties;
end;
function DeactivateRenderingContext(const aContext: TdglRenderContext): Boolean;
eglSwapBuffers(aContext.Display, aContext.Surface);
end;
+procedure ReadOpenGLCore;
+begin
+ { ============================================= OpenGL ES 1.0 ====================================================== }
+ { Available only in Common profile }
+ glAlphaFunc := dglGetProcAddress('glAlphaFunc');
+ glClearColor := dglGetProcAddress('glClearColor');
+ glClearDepthf := dglGetProcAddress('glClearDepthf');
+ glClipPlanef := dglGetProcAddress('glClipPlanef');
+ glColor4f := dglGetProcAddress('glColor4f');
+ glDepthRangef := dglGetProcAddress('glDepthRangef');
+ glFogf := dglGetProcAddress('glFogf');
+ glFogfv := dglGetProcAddress('glFogfv');
+ glFrustumf := dglGetProcAddress('glFrustumf');
+ glGetClipPlanef := dglGetProcAddress('glGetClipPlanef');
+ glGetFloatv := dglGetProcAddress('glGetFloatv');
+ glGetLightfv := dglGetProcAddress('glGetLightfv');
+ glGetMaterialfv := dglGetProcAddress('glGetMaterialfv');
+ glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv');
+ glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv');
+ glLightModelf := dglGetProcAddress('glLightModelf');
+ glLightModelfv := dglGetProcAddress('glLightModelfv');
+ glLightf := dglGetProcAddress('glLightf');
+ glLightfv := dglGetProcAddress('glLightfv');
+ glLineWidth := dglGetProcAddress('glLineWidth');
+ glLoadMatrixf := dglGetProcAddress('glLoadMatrixf');
+ glMaterialf := dglGetProcAddress('glMaterialf');
+ glMaterialfv := dglGetProcAddress('glMaterialfv');
+ glMultMatrixf := dglGetProcAddress('glMultMatrixf');
+ glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f');
+ glNormal3f := dglGetProcAddress('glNormal3f');
+ glOrthof := dglGetProcAddress('glOrthof');
+ glPointParameterf := dglGetProcAddress('glPointParameterf');
+ glPointParameterfv := dglGetProcAddress('glPointParameterfv');
+ glPointSize := dglGetProcAddress('glPointSize');
+ glPolygonOffset := dglGetProcAddress('glPolygonOffset');
+ glRotatef := dglGetProcAddress('glRotatef');
+ glScalef := dglGetProcAddress('glScalef');
+ glTexEnvf := dglGetProcAddress('glTexEnvf');
+ glTexEnvfv := dglGetProcAddress('glTexEnvfv');
+ glTexParameterf := dglGetProcAddress('glTexParameterf');
+ glTexParameterfv := dglGetProcAddress('glTexParameterfv');
+ glTranslatef := dglGetProcAddress('glTranslatef');
+
+ { Available in both Common and Common-Lite profiles }
+ glActiveTexture := dglGetProcAddress('glActiveTexture');
+ glAlphaFuncx := dglGetProcAddress('glAlphaFuncx');
+ glBindBuffer := dglGetProcAddress('glBindBuffer');
+ glBindTexture := dglGetProcAddress('glBindTexture');
+ glBlendFunc := dglGetProcAddress('glBlendFunc');
+ glBufferData := dglGetProcAddress('glBufferData');
+ glBufferSubData := dglGetProcAddress('glBufferSubData');
+ glClear := dglGetProcAddress('glClear');
+ glClearColorx := dglGetProcAddress('glClearColorx');
+ glClearDepthx := dglGetProcAddress('glClearDepthx');
+ glClearStencil := dglGetProcAddress('glClearStencil');
+ glClientActiveTexture := dglGetProcAddress('glClientActiveTexture');
+ glClipPlanex := dglGetProcAddress('glClipPlanex');
+ glColor4ub := dglGetProcAddress('glColor4ub');
+ glColor4x := dglGetProcAddress('glColor4x');
+ glColorMask := dglGetProcAddress('glColorMask');
+ glColorPointer := dglGetProcAddress('glColorPointer');
+ glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D');
+ glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D');
+ glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D');
+ glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D');
+ glCullFace := dglGetProcAddress('glCullFace');
+ glDeleteBuffers := dglGetProcAddress('glDeleteBuffers');
+ glDeleteTextures := dglGetProcAddress('glDeleteTextures');
+ glDepthFunc := dglGetProcAddress('glDepthFunc');
+ glDepthMask := dglGetProcAddress('glDepthMask');
+ glDepthRangex := dglGetProcAddress('glDepthRangex');
+ glDisable := dglGetProcAddress('glDisable');
+ glDisableClientState := dglGetProcAddress('glDisableClientState');
+ glDrawArrays := dglGetProcAddress('glDrawArrays');
+ glDrawElements := dglGetProcAddress('glDrawElements');
+ glEnable := dglGetProcAddress('glEnable');
+ glEnableClientState := dglGetProcAddress('glEnableClientState');
+ glFinish := dglGetProcAddress('glFinish');
+ glFlush := dglGetProcAddress('glFlush');
+ glFogx := dglGetProcAddress('glFogx');
+ glFogxv := dglGetProcAddress('glFogxv');
+ glFrontFace := dglGetProcAddress('glFrontFace');
+ glFrustumx := dglGetProcAddress('glFrustumx');
+ glGetBooleanv := dglGetProcAddress('glGetBooleanv');
+ glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv');
+ glGetClipPlanex := dglGetProcAddress('glGetClipPlanex');
+ glGenBuffers := dglGetProcAddress('glGenBuffers');
+ glGenTextures := dglGetProcAddress('glGenTextures');
+ glGetError := dglGetProcAddress('glGetError');
+ glGetFixedv := dglGetProcAddress('glGetFixedv');
+ glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+ glGetLightxv := dglGetProcAddress('glGetLightxv');
+ glGetMaterialxv := dglGetProcAddress('glGetMaterialxv');
+ glGetPointerv := dglGetProcAddress('glGetPointerv');
+ glGetString := dglGetProcAddress('glGetString');
+ glGetTexEnviv := dglGetProcAddress('glGetTexEnviv');
+ glGetTexEnvxv := dglGetProcAddress('glGetTexEnvxv');
+ glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv');
+ glGetTexParameterxv := dglGetProcAddress('glGetTexParameterxv');
+ glHint := dglGetProcAddress('glHint');
+ glIsBuffer := dglGetProcAddress('glIsBuffer');
+ glIsEnabled := dglGetProcAddress('glIsEnabled');
+ glIsTexture := dglGetProcAddress('glIsTexture');
+ glLightModelx := dglGetProcAddress('glLightModelx');
+ glLightModelxv := dglGetProcAddress('glLightModelxv');
+ glLightx := dglGetProcAddress('glLightx');
+ glLightxv := dglGetProcAddress('glLightxv');
+ glLineWidthx := dglGetProcAddress('glLineWidthx');
+ glLoadIdentity := dglGetProcAddress('glLoadIdentity');
+ glLoadMatrix := dglGetProcAddress('glLoadMatrix');
+ glLogicOp := dglGetProcAddress('glLogicOp');
+ glMaterialx := dglGetProcAddress('glMaterialx');
+ glMaterialxv := dglGetProcAddress('glMaterialxv');
+ glMatrixMode := dglGetProcAddress('glMatrixMode');
+ glMultMatrixx := dglGetProcAddress('glMultMatrixx');
+ glMultiTexCoord4x := dglGetProcAddress('glMultiTexCoord4x');
+ glNormal3x := dglGetProcAddress('glNormal3x');
+ glNormalPointer := dglGetProcAddress('glNormalPointer');
+ glOrthox := dglGetProcAddress('glOrthox');
+ glPixelStorei := dglGetProcAddress('glPixelStorei');
+ glPointParameterx := dglGetProcAddress('glPointParameterx');
+ glPointParameterxv := dglGetProcAddress('glPointParameterxv');
+ glPointSizex := dglGetProcAddress('glPointSizex');
+ glPolygonOffsetx := dglGetProcAddress('glPolygonOffsetx');
+ glPopMatrix := dglGetProcAddress('glPopMatrix');
+ glPushMatrix := dglGetProcAddress('glPushMatrix');
+ glReadPixels := dglGetProcAddress('glReadPixels');
+ glRotatex := dglGetProcAddress('glRotatex');
+ glSampleCoverage := dglGetProcAddress('glSampleCoverage');
+ glSampleCoveragex := dglGetProcAddress('glSampleCoveragex');
+ glScalex := dglGetProcAddress('glScalex');
+ glScissor := dglGetProcAddress('glScissor');
+ glShadeModel := dglGetProcAddress('glShadeModel');
+ glStencilFunc := dglGetProcAddress('glStencilFunc');
+ glStencilMask := dglGetProcAddress('glStencilMask');
+ glStencilOp := dglGetProcAddress('glStencilOp');
+ glTexCoordPointer := dglGetProcAddress('glTexCoordPointer');
+ glTexEnvi := dglGetProcAddress('glTexEnvi');
+ glTexEnvx := dglGetProcAddress('glTexEnvx');
+ glTexEnviv := dglGetProcAddress('glTexEnviv');
+ glTexEnvxv := dglGetProcAddress('glTexEnvxv');
+ glTexImage2D := dglGetProcAddress('glTexImage2D');
+ glTexParameteri := dglGetProcAddress('glTexParameteri');
+ glTexParameterx := dglGetProcAddress('glTexParameterx');
+ glTexParameteriv := dglGetProcAddress('glTexParameteriv');
+ glTexParameterxv := dglGetProcAddress('glTexParameterxv');
+ glTexSubImage2D := dglGetProcAddress('glTexSubImage2D');
+ glTranslatex := dglGetProcAddress('glTranslatex');
+ glVertexPointer := dglGetProcAddress('glVertexPointer');
+ glViewport := dglGetProcAddress('glViewport');
+
+ { ============================================= OpenGL ES 2.0 ====================================================== }
+ glAttachShader := dglGetProcAddress('glAttachShader');
+ glBindAttribLocation := dglGetProcAddress('glBindAttribLocation');
+ glBindFramebuffer := dglGetProcAddress('glBindFramebuffer');
+ glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer');
+ glBlendColor := dglGetProcAddress('glBlendColor');
+ glBlendEquation := dglGetProcAddress('glBlendEquation');
+ glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate');
+ glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate');
+ glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus');
+ glCompileShader := dglGetProcAddress('glCompileShader');
+ glCreateProgram := dglGetProcAddress('glCreateProgram');
+ glCreateShader := dglGetProcAddress('glCreateShader');
+ glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers');
+ glDeleteProgram := dglGetProcAddress('glDeleteProgram');
+ glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers');
+ glDeleteShader := dglGetProcAddress('glDeleteShader');
+ glDetachShader := dglGetProcAddress('glDetachShader');
+ glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray');
+ glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray');
+ glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer');
+ glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D');
+ glGenerateMipmap := dglGetProcAddress('glGenerateMipmap');
+ glGenFramebuffers := dglGetProcAddress('glGenFramebuffers');
+ glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers');
+ glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib');
+ glGetActiveUniform := dglGetProcAddress('glGetActiveUniform');
+ glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders');
+ glGetAttribLocation := dglGetProcAddress('glGetAttribLocation');
+ glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
+ glGetProgramiv := dglGetProcAddress('glGetProgramiv');
+ glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog');
+ glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv');
+ glGetShaderiv := dglGetProcAddress('glGetShaderiv');
+ glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog');
+ glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat');
+ glGetShaderSource := dglGetProcAddress('glGetShaderSource');
+ glGetUniformfv := dglGetProcAddress('glGetUniformfv');
+ glGetUniformiv := dglGetProcAddress('glGetUniformiv');
+ glGetUniformLocation := dglGetProcAddress('glGetUniformLocation');
+ glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv');
+ glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv');
+ glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv');
+ glIsFramebuffer := dglGetProcAddress('glIsFramebuffer');
+ glIsProgram := dglGetProcAddress('glIsProgram');
+ glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer');
+ glIsShader := dglGetProcAddress('glIsShader');
+ glLinkProgram := dglGetProcAddress('glLinkProgram');
+ glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler');
+ glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage');
+ glShaderBinary := dglGetProcAddress('glShaderBinary');
+ glShaderSource := dglGetProcAddress('glShaderSource');
+ glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate');
+ glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate');
+ glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate');
+ 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');
+
+ { ============================================= 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');
+ glGetIntegeriv := dglGetProcAddress('glGetIntegeriv');
+ 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');
+ glGetInteger64iv := dglGetProcAddress('glGetInteger64iv');
+ 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;
+
procedure ReadExtensions;
begin
+ Read_GL_KHR_blend_equation_advanced;
+ Read_GL_KHR_debug;
+ Read_GL_KHR_robustness;
+ Read_GL_OES_EGL_image;
+ Read_GL_OES_get_program_binary;
+ Read_GL_OES_mapbuffer;
+ Read_GL_OES_sample_shading;
+ Read_GL_OES_texture_3D;
+ Read_GL_OES_texture_storage_multisample_2d_array;
+ Read_GL_OES_vertex_array_object;
+ Read_GL_AMD_performance_monitor;
+ Read_GL_ANGLE_framebuffer_blit;
+ Read_GL_ANGLE_framebuffer_multisample;
+ Read_GL_ANGLE_instanced_arrays;
+ Read_GL_ANGLE_translated_shader_source;
+ Read_GL_APPLE_copy_texture_levels;
+ Read_GL_APPLE_framebuffer_multisample;
+ Read_GL_APPLE_sync;
+ Read_GL_EXT_base_instance;
+ Read_GL_EXT_copy_image;
+ Read_GL_EXT_debug_label;
+ Read_GL_EXT_debug_marker;
+ Read_GL_EXT_discard_framebuffer;
+ Read_GL_EXT_disjoint_timer_query;
+ Read_GL_EXT_draw_buffers;
+ Read_GL_EXT_draw_buffers_indexed;
+ Read_GL_EXT_draw_elements_base_vertex;
+ Read_GL_EXT_draw_instanced;
+ Read_GL_EXT_geometry_shader;
+ Read_GL_EXT_instanced_arrays;
+ Read_GL_EXT_map_buffer_range;
+ Read_GL_EXT_multi_draw_arrays;
+ Read_GL_EXT_multi_draw_indirect;
+ Read_GL_EXT_multisampled_render_to_texture;
+ Read_GL_EXT_multiview_draw_buffers;
+ Read_GL_EXT_primitive_bounding_box;
+ Read_GL_EXT_robustness;
+ Read_GL_EXT_separate_shader_objects;
+ Read_GL_EXT_tessellation_shader;
+ Read_GL_EXT_texture_border_clamp;
+ Read_GL_EXT_texture_buffer;
+ Read_GL_EXT_texture_storage;
+ Read_GL_EXT_texture_view;
+ Read_GL_IMG_multisampled_render_to_texture;
+ Read_GL_INTEL_performance_query;
+ Read_GL_NV_bindless_texture;
+ Read_GL_NV_blend_equation_advanced;
+ Read_GL_NV_conditional_render;
+ Read_GL_NV_copy_buffer;
+ Read_GL_NV_coverage_sample;
+ Read_GL_NV_draw_buffers;
+ Read_GL_NV_draw_instanced;
+ Read_GL_NV_fence;
+ Read_GL_NV_framebuffer_blit;
+ Read_GL_NV_framebuffer_multisample;
+ Read_GL_NV_instanced_arrays;
+ Read_GL_NV_internalformat_sample_query;
+ Read_GL_NV_non_square_matrices;
+ Read_GL_NV_path_rendering;
+ Read_GL_NV_read_buffer;
+ Read_GL_NV_viewport_array;
+ Read_GL_QCOM_alpha_test;
+ Read_GL_QCOM_driver_control;
+ Read_GL_QCOM_extended_get;
+ Read_GL_QCOM_extended_get2;
+ Read_GL_QCOM_tiled_rendering;
+end;
+
+procedure ReadCoreVersion;
+var
+ AnsiBuffer: AnsiString;
+ Buffer: String;
+
+ procedure TrimAndSplitVersionString(const aBuffer: String; out aMajor, aMinor: Integer);
+ var
+ p, s, e, len: Integer;
+ begin
+ aMajor := 0;
+ aMinor := 0;
+ try
+ len := Length(aBuffer);
+ p := Pos('.', aBuffer);
+ if (p = 0) then
+ exit;
+
+ s := p;
+ while (s > 1) and (aBuffer[s - 1] in ['0'..'9']) do
+ dec(s);
+ if (s = p) then
+ exit;
+
+ e := p;
+ while (e < len) and (aBuffer[e + 1] in ['0'..'9']) do
+ inc(e);
+ if (s = p) then
+ exit;
+
+ aMajor := StrToInt(Copy(aBuffer, s - 1, p - s + 1));
+ aMinor := StrToInt(Copy(aBuffer, p + 1, e - p + 1));
+ except
+ aMajor := 0;
+ aMinor := 0;
+ end;
+ end;
+
+begin
+ if not Assigned(glGetString) then
+ glGetString := dglGetProcAddress('glGetString');
+ AnsiBuffer := PAnsiChar(glGetString(GL_VERSION));
+ Buffer := String(AnsiBuffer);
+
+ TrimAndSplitVersionString(Buffer, GLmajor, GLminor);
+
+ GL_VERSION_1_0 := true; // OpenGL ES is always supported
+ GL_VERSION_1_1 := (GLmajor >= 1) and (GLminor >= 1);
+ GL_VERSION_2_0 := (GLmajor >= 2) and (GLminor >= 0);
+ GL_VERSION_3_0 := (GLmajor >= 3) and (GLminor >= 0);
+ GL_VERSION_3_1 := (GLmajor >= 3) and (GLminor >= 1);
+end;
+
+procedure ReadImplementationProperties;
+
+ function GetExtensions: String;
+ var
+ ExtCount, i: GLint;
+ begin
+ result := '';
+
+ if not Assigned(glGetString) then
+ glGetString := dglGetProcAddress('glGetString');
+ if Assigned(glGetString) then
+ result := String(PAnsiChar(glGetString(GL_EXTENSIONS)));
+
+ if (result = '') then begin
+ if not Assigned(glGetIntegerv) then
+ glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+ if not Assigned(glGetStringi) then
+ glGetStringi := dglGetProcAddress('glGetStringi');
+ if Assigned(glGetStringi) and Assigned(glGetIntegerv) then begin
+ glGetIntegerv(GL_NUM_EXTENSIONS, @ExtCount);
+ for i := 0 to ExtCount-1 do begin
+ if (result <> '') then
+ result := result + #$20;
+ result := result + PAnsiChar(glGetStringi(GL_EXTENSIONS, i));
+ end;
+ end;
+ end;
+
+ result := #$20 + result + #$20;
+ end;
+
+ function CheckEx(const aAllExt, aExt: String): Boolean;
+ begin
+ result := (Pos(#$20 + aExt + #$20, aAllExt) > 0);
+ end;
+
+var
+ Buffer: String;
+begin
+ ReadCoreVersion;
+
+ Buffer := GetExtensions;
+
+ // KHR
+ GL_KHR_blend_equation_advanced := CheckEx(Buffer, 'GL_KHR_blend_equation_advanced');
+ GL_KHR_blend_equation_advanced_coherent := CheckEx(Buffer, 'GL_KHR_blend_equation_advanced_coherent');
+ GL_KHR_context_flush_control := CheckEx(Buffer, 'GL_KHR_context_flush_control');
+ GL_KHR_debug := CheckEx(Buffer, 'GL_KHR_debug');
+ GL_KHR_robust_buffer_access_behavior := CheckEx(Buffer, 'GL_KHR_robust_buffer_access_behavior');
+ GL_KHR_robustness := CheckEx(Buffer, 'GL_KHR_robustness');
+ GL_KHR_texture_compression_astc_hdr := CheckEx(Buffer, 'GL_KHR_texture_compression_astc_hdr');
+ GL_KHR_texture_compression_astc_ldr := CheckEx(Buffer, 'GL_KHR_texture_compression_astc_ldr');
+
+ // OES
+ GL_OES_EGL_image := CheckEx(Buffer, 'GL_OES_EGL_image');
+ GL_OES_EGL_image_external := CheckEx(Buffer, 'GL_OES_EGL_image_external');
+ GL_OES_compressed_ETC1_RGB8_sub_texture := CheckEx(Buffer, 'GL_OES_compressed_ETC1_RGB8_sub_texture');
+ GL_OES_compressed_ETC1_RGB8_texture := CheckEx(Buffer, 'GL_OES_compressed_ETC1_RGB8_texture');
+ GL_OES_compressed_paletted_texture := CheckEx(Buffer, 'GL_OES_compressed_paletted_texture');
+ GL_OES_depth24 := CheckEx(Buffer, 'GL_OES_depth24');
+ GL_OES_depth32 := CheckEx(Buffer, 'GL_OES_depth32');
+ GL_OES_depth_texture := CheckEx(Buffer, 'GL_OES_depth_texture');
+ GL_OES_element_index_uint := CheckEx(Buffer, 'GL_OES_element_index_uint');
+ GL_OES_fbo_render_mipmap := CheckEx(Buffer, 'GL_OES_fbo_render_mipmap');
+ GL_OES_fragment_precision_high := CheckEx(Buffer, 'GL_OES_fragment_precision_high');
+ GL_OES_get_program_binary := CheckEx(Buffer, 'GL_OES_get_program_binary');
+ GL_OES_mapbuffer := CheckEx(Buffer, 'GL_OES_mapbuffer');
+ GL_OES_packed_depth_stencil := CheckEx(Buffer, 'GL_OES_packed_depth_stencil');
+ GL_OES_required_internalformat := CheckEx(Buffer, 'GL_OES_required_internalformat');
+ GL_OES_rgb8_rgba8 := CheckEx(Buffer, 'GL_OES_rgb8_rgba8');
+ GL_OES_sample_shading := CheckEx(Buffer, 'GL_OES_sample_shading');
+ GL_OES_sample_variables := CheckEx(Buffer, 'GL_OES_sample_variables');
+ GL_OES_shader_image_atomic := CheckEx(Buffer, 'GL_OES_shader_image_atomic');
+ GL_OES_shader_multisample_interpolation := CheckEx(Buffer, 'GL_OES_shader_multisample_interpolation');
+ GL_OES_standard_derivatives := CheckEx(Buffer, 'GL_OES_standard_derivatives');
+ GL_OES_stencil1 := CheckEx(Buffer, 'GL_OES_stencil1');
+ GL_OES_stencil4 := CheckEx(Buffer, 'GL_OES_stencil4');
+ GL_OES_surfaceless_context := CheckEx(Buffer, 'GL_OES_surfaceless_context');
+ GL_OES_texture_3D := CheckEx(Buffer, 'GL_OES_texture_3D');
+ GL_OES_texture_compression_astc := CheckEx(Buffer, 'GL_OES_texture_compression_astc');
+ GL_OES_texture_float := CheckEx(Buffer, 'GL_OES_texture_float');
+ GL_OES_texture_float_linear := CheckEx(Buffer, 'GL_OES_texture_float_linear');
+ GL_OES_texture_half_float := CheckEx(Buffer, 'GL_OES_texture_half_float');
+ GL_OES_texture_half_float_linear := CheckEx(Buffer, 'GL_OES_texture_half_float_linear');
+ GL_OES_texture_npot := CheckEx(Buffer, 'GL_OES_texture_npot');
+ GL_OES_texture_stencil8 := CheckEx(Buffer, 'GL_OES_texture_stencil8');
+ GL_OES_texture_storage_multisample_2d_array := CheckEx(Buffer, 'GL_OES_texture_storage_multisample_2d_array');
+ GL_OES_vertex_array_object := CheckEx(Buffer, 'GL_OES_vertex_array_object');
+ GL_OES_vertex_half_float := CheckEx(Buffer, 'GL_OES_vertex_half_float');
+ GL_OES_vertex_type_10_10_10_2 := CheckEx(Buffer, 'GL_OES_vertex_type_10_10_10_2');
+
+ // AMD
+ GL_AMD_compressed_3DC_texture := CheckEx(Buffer, 'GL_AMD_compressed_3DC_texture');
+ GL_AMD_compressed_ATC_texture := CheckEx(Buffer, 'GL_AMD_compressed_ATC_texture');
+ GL_AMD_performance_monitor := CheckEx(Buffer, 'GL_AMD_performance_monitor');
+ GL_AMD_program_binary_Z400 := CheckEx(Buffer, 'GL_AMD_program_binary_Z400');
+
+ // ANDROID
+ GL_ANDROID_extension_pack_es31a := CheckEx(Buffer, 'GL_ANDROID_extension_pack_es31a');
+
+ // ANGLE
+ GL_ANGLE_depth_texture := CheckEx(Buffer, 'GL_ANGLE_depth_texture');
+ GL_ANGLE_framebuffer_blit := CheckEx(Buffer, 'GL_ANGLE_framebuffer_blit');
+ GL_ANGLE_framebuffer_multisample := CheckEx(Buffer, 'GL_ANGLE_framebuffer_multisample');
+ GL_ANGLE_instanced_arrays := CheckEx(Buffer, 'GL_ANGLE_instanced_arrays');
+ GL_ANGLE_pack_reverse_row_order := CheckEx(Buffer, 'GL_ANGLE_pack_reverse_row_order');
+ GL_ANGLE_program_binary := CheckEx(Buffer, 'GL_ANGLE_program_binary');
+ GL_ANGLE_texture_compression_dxt3 := CheckEx(Buffer, 'GL_ANGLE_texture_compression_dxt3');
+ GL_ANGLE_texture_compression_dxt5 := CheckEx(Buffer, 'GL_ANGLE_texture_compression_dxt5');
+ GL_ANGLE_texture_usage := CheckEx(Buffer, 'GL_ANGLE_texture_usage');
+ GL_ANGLE_translated_shader_source := CheckEx(Buffer, 'GL_ANGLE_translated_shader_source');
+
+ // APPLE
+ GL_APPLE_clip_distance := CheckEx(Buffer, 'GL_APPLE_clip_distance');
+ GL_APPLE_color_buffer_packed_float := CheckEx(Buffer, 'GL_APPLE_color_buffer_packed_float');
+ GL_APPLE_copy_texture_levels := CheckEx(Buffer, 'GL_APPLE_copy_texture_levels');
+ GL_APPLE_framebuffer_multisample := CheckEx(Buffer, 'GL_APPLE_framebuffer_multisample');
+ GL_APPLE_rgb_422 := CheckEx(Buffer, 'GL_APPLE_rgb_422');
+ GL_APPLE_sync := CheckEx(Buffer, 'GL_APPLE_sync');
+ GL_APPLE_texture_format_BGRA8888 := CheckEx(Buffer, 'GL_APPLE_texture_format_BGRA8888');
+ GL_APPLE_texture_max_level := CheckEx(Buffer, 'GL_APPLE_texture_max_level');
+ GL_APPLE_texture_packed_float := CheckEx(Buffer, 'GL_APPLE_texture_packed_float');
+
+ // ARM
+ GL_ARM_mali_program_binary := CheckEx(Buffer, 'GL_ARM_mali_program_binary');
+ GL_ARM_mali_shader_binary := CheckEx(Buffer, 'GL_ARM_mali_shader_binary');
+ GL_ARM_rgba8 := CheckEx(Buffer, 'GL_ARM_rgba8');
+ GL_ARM_shader_framebuffer_fetch := CheckEx(Buffer, 'GL_ARM_shader_framebuffer_fetch');
+ GL_ARM_shader_framebuffer_fetch_depth_stencil := CheckEx(Buffer, 'GL_ARM_shader_framebuffer_fetch_depth_stencil');
+
+ // DMP
+ GL_DMP_program_binary := CheckEx(Buffer, 'GL_DMP_program_binary');
+ GL_DMP_shader_binary := CheckEx(Buffer, 'GL_DMP_shader_binary');
+
+ // EXT
+ GL_EXT_base_instance := CheckEx(Buffer, 'GL_EXT_base_instance');
+ GL_EXT_blend_minmax := CheckEx(Buffer, 'GL_EXT_blend_minmax');
+ GL_EXT_color_buffer_half_float := CheckEx(Buffer, 'GL_EXT_color_buffer_half_float');
+ GL_EXT_copy_image := CheckEx(Buffer, 'GL_EXT_copy_image');
+ GL_EXT_debug_label := CheckEx(Buffer, 'GL_EXT_debug_label');
+ GL_EXT_debug_marker := CheckEx(Buffer, 'GL_EXT_debug_marker');
+ GL_EXT_discard_framebuffer := CheckEx(Buffer, 'GL_EXT_discard_framebuffer');
+ GL_EXT_disjoint_timer_query := CheckEx(Buffer, 'GL_EXT_disjoint_timer_query');
+ GL_EXT_draw_buffers := CheckEx(Buffer, 'GL_EXT_draw_buffers');
+ GL_EXT_draw_buffers_indexed := CheckEx(Buffer, 'GL_EXT_draw_buffers_indexed');
+ GL_EXT_draw_elements_base_vertex := CheckEx(Buffer, 'GL_EXT_draw_elements_base_vertex');
+ GL_EXT_draw_instanced := CheckEx(Buffer, 'GL_EXT_draw_instanced');
+ GL_EXT_geometry_point_size := CheckEx(Buffer, 'GL_EXT_geometry_point_size');
+ GL_EXT_geometry_shader := CheckEx(Buffer, 'GL_EXT_geometry_shader');
+ GL_EXT_gpu_shader5 := CheckEx(Buffer, 'GL_EXT_gpu_shader5');
+ GL_EXT_instanced_arrays := CheckEx(Buffer, 'GL_EXT_instanced_arrays');
+ GL_EXT_map_buffer_range := CheckEx(Buffer, 'GL_EXT_map_buffer_range');
+ GL_EXT_multi_draw_arrays := CheckEx(Buffer, 'GL_EXT_multi_draw_arrays');
+ GL_EXT_multi_draw_indirect := CheckEx(Buffer, 'GL_EXT_multi_draw_indirect');
+ GL_EXT_multisampled_render_to_texture := CheckEx(Buffer, 'GL_EXT_multisampled_render_to_texture');
+ GL_EXT_multiview_draw_buffers := CheckEx(Buffer, 'GL_EXT_multiview_draw_buffers');
+ GL_EXT_occlusion_query_boolean := CheckEx(Buffer, 'GL_EXT_occlusion_query_boolean');
+ GL_EXT_primitive_bounding_box := CheckEx(Buffer, 'GL_EXT_primitive_bounding_box');
+ GL_EXT_pvrtc_sRGB := CheckEx(Buffer, 'GL_EXT_pvrtc_sRGB');
+ GL_EXT_read_format_bgra := CheckEx(Buffer, 'GL_EXT_read_format_bgra');
+ GL_EXT_render_snorm := CheckEx(Buffer, 'GL_EXT_render_snorm');
+ GL_EXT_robustness := CheckEx(Buffer, 'GL_EXT_robustness');
+ GL_EXT_sRGB := CheckEx(Buffer, 'GL_EXT_sRGB');
+ GL_EXT_sRGB_write_control := CheckEx(Buffer, 'GL_EXT_sRGB_write_control');
+ GL_EXT_separate_shader_objects := CheckEx(Buffer, 'GL_EXT_separate_shader_objects');
+ GL_EXT_shader_framebuffer_fetch := CheckEx(Buffer, 'GL_EXT_shader_framebuffer_fetch');
+ GL_EXT_shader_implicit_conversions := CheckEx(Buffer, 'GL_EXT_shader_implicit_conversions');
+ GL_EXT_shader_integer_mix := CheckEx(Buffer, 'GL_EXT_shader_integer_mix');
+ GL_EXT_shader_io_blocks := CheckEx(Buffer, 'GL_EXT_shader_io_blocks');
+ GL_EXT_shader_pixel_local_storage := CheckEx(Buffer, 'GL_EXT_shader_pixel_local_storage');
+ GL_EXT_shader_texture_lod := CheckEx(Buffer, 'GL_EXT_shader_texture_lod');
+ GL_EXT_shadow_samplers := CheckEx(Buffer, 'GL_EXT_shadow_samplers');
+ GL_EXT_tessellation_point_size := CheckEx(Buffer, 'GL_EXT_tessellation_point_size');
+ GL_EXT_tessellation_shader := CheckEx(Buffer, 'GL_EXT_tessellation_shader');
+ GL_EXT_texture_border_clamp := CheckEx(Buffer, 'GL_EXT_texture_border_clamp');
+ GL_EXT_texture_buffer := CheckEx(Buffer, 'GL_EXT_texture_buffer');
+ GL_EXT_texture_compression_dxt1 := CheckEx(Buffer, 'GL_EXT_texture_compression_dxt1');
+ GL_EXT_texture_compression_s3tc := CheckEx(Buffer, 'GL_EXT_texture_compression_s3tc');
+ GL_EXT_texture_cube_map_array := CheckEx(Buffer, 'GL_EXT_texture_cube_map_array');
+ GL_EXT_texture_filter_anisotropic := CheckEx(Buffer, 'GL_EXT_texture_filter_anisotropic');
+ GL_EXT_texture_format_BGRA8888 := CheckEx(Buffer, 'GL_EXT_texture_format_BGRA8888');
+ GL_EXT_texture_norm16 := CheckEx(Buffer, 'GL_EXT_texture_norm16');
+ GL_EXT_texture_rg := CheckEx(Buffer, 'GL_EXT_texture_rg');
+ GL_EXT_texture_sRGB_decode := CheckEx(Buffer, 'GL_EXT_texture_sRGB_decode');
+ GL_EXT_texture_storage := CheckEx(Buffer, 'GL_EXT_texture_storage');
+ GL_EXT_texture_type_2_10_10_10_REV := CheckEx(Buffer, 'GL_EXT_texture_type_2_10_10_10_REV');
+ GL_EXT_texture_view := CheckEx(Buffer, 'GL_EXT_texture_view');
+ GL_EXT_unpack_subimage := CheckEx(Buffer, 'GL_EXT_unpack_subimage');
+
+ // FJ
+ GL_FJ_shader_binary_GCCSO := CheckEx(Buffer, 'GL_FJ_shader_binary_GCCSO');
+
+ // IMG
+ GL_IMG_multisampled_render_to_texture := CheckEx(Buffer, 'GL_IMG_multisampled_render_to_texture');
+ GL_IMG_program_binary := CheckEx(Buffer, 'GL_IMG_program_binary');
+ GL_IMG_read_format := CheckEx(Buffer, 'GL_IMG_read_format');
+ GL_IMG_shader_binary := CheckEx(Buffer, 'GL_IMG_shader_binary');
+ GL_IMG_texture_compression_pvrtc := CheckEx(Buffer, 'GL_IMG_texture_compression_pvrtc');
+ GL_IMG_texture_compression_pvrtc2 := CheckEx(Buffer, 'GL_IMG_texture_compression_pvrtc2');
+
+ // INTEL
+ GL_INTEL_performance_query := CheckEx(Buffer, 'GL_INTEL_performance_query');
+
+ // NV
+ GL_NV_bindless_texture := CheckEx(Buffer, 'GL_NV_bindless_texture');
+ GL_NV_blend_equation_advanced := CheckEx(Buffer, 'GL_NV_blend_equation_advanced');
+ GL_NV_blend_equation_advanced_coherent := CheckEx(Buffer, 'GL_NV_blend_equation_advanced_coherent');
+ GL_NV_conditional_render := CheckEx(Buffer, 'GL_NV_conditional_render');
+ GL_NV_copy_buffer := CheckEx(Buffer, 'GL_NV_copy_buffer');
+ GL_NV_coverage_sample := CheckEx(Buffer, 'GL_NV_coverage_sample');
+ GL_NV_depth_nonlinear := CheckEx(Buffer, 'GL_NV_depth_nonlinear');
+ GL_NV_draw_buffers := CheckEx(Buffer, 'GL_NV_draw_buffers');
+ GL_NV_draw_instanced := CheckEx(Buffer, 'GL_NV_draw_instanced');
+ GL_NV_explicit_attrib_location := CheckEx(Buffer, 'GL_NV_explicit_attrib_location');
+ GL_NV_fbo_color_attachments := CheckEx(Buffer, 'GL_NV_fbo_color_attachments');
+ GL_NV_fence := CheckEx(Buffer, 'GL_NV_fence');
+ GL_NV_framebuffer_blit := CheckEx(Buffer, 'GL_NV_framebuffer_blit');
+ GL_NV_framebuffer_multisample := CheckEx(Buffer, 'GL_NV_framebuffer_multisample');
+ GL_NV_generate_mipmap_sRGB := CheckEx(Buffer, 'GL_NV_generate_mipmap_sRGB');
+ GL_NV_image_formats := CheckEx(Buffer, 'GL_NV_image_formats');
+ GL_NV_instanced_arrays := CheckEx(Buffer, 'GL_NV_instanced_arrays');
+ GL_NV_internalformat_sample_query := CheckEx(Buffer, 'GL_NV_internalformat_sample_query');
+ GL_NV_non_square_matrices := CheckEx(Buffer, 'GL_NV_non_square_matrices');
+ GL_NV_path_rendering := CheckEx(Buffer, 'GL_NV_path_rendering');
+ GL_NV_read_buffer := CheckEx(Buffer, 'GL_NV_read_buffer');
+ GL_NV_read_buffer_front := CheckEx(Buffer, 'GL_NV_read_buffer_front');
+ GL_NV_read_depth := CheckEx(Buffer, 'GL_NV_read_depth');
+ GL_NV_read_depth_stencil := CheckEx(Buffer, 'GL_NV_read_depth_stencil');
+ GL_NV_read_stencil := CheckEx(Buffer, 'GL_NV_read_stencil');
+ GL_NV_sRGB_formats := CheckEx(Buffer, 'GL_NV_sRGB_formats');
+ GL_NV_shader_noperspective_interpolation := CheckEx(Buffer, 'GL_NV_shader_noperspective_interpolation');
+ GL_NV_shadow_samplers_array := CheckEx(Buffer, 'GL_NV_shadow_samplers_array');
+ GL_NV_shadow_samplers_cube := CheckEx(Buffer, 'GL_NV_shadow_samplers_cube');
+ GL_NV_texture_border_clamp := CheckEx(Buffer, 'GL_NV_texture_border_clamp');
+ GL_NV_texture_compression_s3tc_update := CheckEx(Buffer, 'GL_NV_texture_compression_s3tc_update');
+ GL_NV_texture_npot_2D_mipmap := CheckEx(Buffer, 'GL_NV_texture_npot_2D_mipmap');
+ GL_NV_viewport_array := CheckEx(Buffer, 'GL_NV_viewport_array');
+
+ // QCOM
+ GL_QCOM_alpha_test := CheckEx(Buffer, 'GL_QCOM_alpha_test');
+ GL_QCOM_binning_control := CheckEx(Buffer, 'GL_QCOM_binning_control');
+ GL_QCOM_driver_control := CheckEx(Buffer, 'GL_QCOM_driver_control');
+ GL_QCOM_extended_get := CheckEx(Buffer, 'GL_QCOM_extended_get');
+ GL_QCOM_extended_get2 := CheckEx(Buffer, 'GL_QCOM_extended_get2');
+ GL_QCOM_perfmon_global_mode := CheckEx(Buffer, 'GL_QCOM_perfmon_global_mode');
+ GL_QCOM_tiled_rendering := CheckEx(Buffer, 'GL_QCOM_tiled_rendering');
+ GL_QCOM_writeonly_rendering := CheckEx(Buffer, 'GL_QCOM_writeonly_rendering');
+
+ // VIV
+ GL_VIV_shader_binary := CheckEx(Buffer, 'GL_VIV_shader_binary');
+end;
+
+procedure Read_GL_KHR_blend_equation_advanced;
+begin
+ glBlendBarrierKHR := dglGetProcAddress('glBlendBarrierKHR');
+end;
+
+procedure Read_GL_KHR_debug;
+begin
+ glDebugMessageControlKHR := dglGetProcAddress('glDebugMessageControlKHR');
+ glDebugMessageInsertKHR := dglGetProcAddress('glDebugMessageInsertKHR');
+ glDebugMessageCallbackKHR := dglGetProcAddress('glDebugMessageCallbackKHR');
+ glGetDebugMessageLogKHR := dglGetProcAddress('glGetDebugMessageLogKHR');
+ glPushDebugGroupKHR := dglGetProcAddress('glPushDebugGroupKHR');
+ glPopDebugGroupKHR := dglGetProcAddress('glPopDebugGroupKHR');
+ glObjectLabelKHR := dglGetProcAddress('glObjectLabelKHR');
+ glGetObjectLabelKHR := dglGetProcAddress('glGetObjectLabelKHR');
+ glObjectPtrLabelKHR := dglGetProcAddress('glObjectPtrLabelKHR');
+ glGetObjectPtrLabelKHR := dglGetProcAddress('glGetObjectPtrLabelKHR');
+ glGetPointervKHR := dglGetProcAddress('glGetPointervKHR');
+end;
+
+procedure Read_GL_KHR_robustness;
+begin
+ glGetGraphicsResetStatusKHR := dglGetProcAddress('glGetGraphicsResetStatusKHR');
+ glReadnPixelsKHR := dglGetProcAddress('glReadnPixelsKHR');
+ glGetnUniformfvKHR := dglGetProcAddress('glGetnUniformfvKHR');
+ glGetnUniformivKHR := dglGetProcAddress('glGetnUniformivKHR');
+ glGetnUniformuivKHR := dglGetProcAddress('glGetnUniformuivKHR');
+end;
+
+procedure Read_GL_OES_EGL_image;
+begin
+ glEGLImageTargetTexture2DOES := dglGetProcAddress('glEGLImageTargetTexture2DOES');
+ glEGLImageTargetRenderbufferStorageOES := dglGetProcAddress('glEGLImageTargetRenderbufferStorageOES');
+end;
+
+procedure Read_GL_OES_get_program_binary;
+begin
+ glGetProgramBinaryOES := dglGetProcAddress('glGetProgramBinaryOES');
+ glProgramBinaryOES := dglGetProcAddress('glProgramBinaryOES');
+end;
+
+procedure Read_GL_OES_mapbuffer;
+begin
+ glMapBufferOES := dglGetProcAddress('glMapBufferOES');
+ glUnmapBufferOES := dglGetProcAddress('glUnmapBufferOES');
+ glGetBufferPointervOES := dglGetProcAddress('glGetBufferPointervOES');
+end;
+
+procedure Read_GL_OES_sample_shading;
+begin
+ glMinSampleShadingOES := dglGetProcAddress('glMinSampleShadingOES');
+end;
+
+procedure Read_GL_OES_texture_3D;
+begin
+ glTexImage3DOES := dglGetProcAddress('glTexImage3DOES');
+ glTexSubImage3DOES := dglGetProcAddress('glTexSubImage3DOES');
+ glCopyTexSubImage3DOES := dglGetProcAddress('glCopyTexSubImage3DOES');
+ glCompressedTexImage3DOES := dglGetProcAddress('glCompressedTexImage3DOES');
+ glCompressedTexSubImage3DOES := dglGetProcAddress('glCompressedTexSubImage3DOES');
+ glFramebufferTexture3DOES := dglGetProcAddress('glFramebufferTexture3DOES');
+end;
+
+procedure Read_GL_OES_texture_storage_multisample_2d_array;
+begin
+ glTexStorage3DMultisampleOES := dglGetProcAddress('glTexStorage3DMultisampleOES');
+end;
+
+procedure Read_GL_OES_vertex_array_object;
+begin
+ glBindVertexArrayOES := dglGetProcAddress('glBindVertexArrayOES');
+ glDeleteVertexArraysOES := dglGetProcAddress('glDeleteVertexArraysOES');
+ glGenVertexArraysOES := dglGetProcAddress('glGenVertexArraysOES');
+ glIsVertexArrayOES := dglGetProcAddress('glIsVertexArrayOES');
+end;
+
+procedure Read_GL_AMD_performance_monitor;
+begin
+ glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD');
+ glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD');
+ glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD');
+ glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD');
+ glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD');
+ glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD');
+ glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD');
+ glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD');
+ glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD');
+ glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD');
+ glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD');
+end;
+
+procedure Read_GL_ANGLE_framebuffer_blit;
+begin
+ glBlitFramebufferANGLE := dglGetProcAddress('glBlitFramebufferANGLE');
+end;
+
+procedure Read_GL_ANGLE_framebuffer_multisample;
+begin
+ glRenderbufferStorageMultisampleANGLE := dglGetProcAddress('glRenderbufferStorageMultisampleANGLE');
+end;
+
+procedure Read_GL_ANGLE_instanced_arrays;
+begin
+ glDrawArraysInstancedANGLE := dglGetProcAddress('glDrawArraysInstancedANGLE');
+ glDrawElementsInstancedANGLE := dglGetProcAddress('glDrawElementsInstancedANGLE');
+ glVertexAttribDivisorANGLE := dglGetProcAddress('glVertexAttribDivisorANGLE');
+end;
+
+procedure Read_GL_ANGLE_translated_shader_source;
+begin
+ glGetTranslatedShaderSourceANGLE := dglGetProcAddress('glGetTranslatedShaderSourceANGLE');
+end;
+
+procedure Read_GL_APPLE_copy_texture_levels;
+begin
+ glCopyTextureLevelsAPPLE := dglGetProcAddress('glCopyTextureLevelsAPPLE');
+end;
+
+procedure Read_GL_APPLE_framebuffer_multisample;
+begin
+ glRenderbufferStorageMultisampleAPPLE := dglGetProcAddress('glRenderbufferStorageMultisampleAPPLE');
+ glResolveMultisampleFramebufferAPPLE := dglGetProcAddress('glResolveMultisampleFramebufferAPPLE');
+end;
+
+procedure Read_GL_APPLE_sync;
+begin
+ glFenceSyncAPPLE := dglGetProcAddress('glFenceSyncAPPLE');
+ glIsSyncAPPLE := dglGetProcAddress('glIsSyncAPPLE');
+ glDeleteSyncAPPLE := dglGetProcAddress('glDeleteSyncAPPLE');
+ glClientWaitSyncAPPLE := dglGetProcAddress('glClientWaitSyncAPPLE');
+ glWaitSyncAPPLE := dglGetProcAddress('glWaitSyncAPPLE');
+ glGetInteger64vAPPLE := dglGetProcAddress('glGetInteger64vAPPLE');
+ glGetSyncivAPPLE := dglGetProcAddress('glGetSyncivAPPLE');
+end;
+
+procedure Read_GL_EXT_base_instance;
+begin
+ glDrawArraysInstancedBaseInstanceEXT := dglGetProcAddress('glDrawArraysInstancedBaseInstanceEXT');
+ glDrawElementsInstancedBaseInstanceEXT := dglGetProcAddress('glDrawElementsInstancedBaseInstanceEXT');
+ glDrawElementsInstancedBaseVertexBaseInstanceEXT := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstanceEXT');
+end;
+
+procedure Read_GL_EXT_copy_image;
+begin
+ glCopyImageSubDataEXT := dglGetProcAddress('glCopyImageSubDataEXT');
+end;
+
+procedure Read_GL_EXT_debug_label;
+begin
+ glLabelObjectEXT := dglGetProcAddress('glLabelObjectEXT');
+ glGetObjectLabelEXT := dglGetProcAddress('glGetObjectLabelEXT');
+end;
+
+procedure Read_GL_EXT_debug_marker;
+begin
+ glInsertEventMarkerEXT := dglGetProcAddress('glInsertEventMarkerEXT');
+ glPushGroupMarkerEXT := dglGetProcAddress('glPushGroupMarkerEXT');
+ glPopGroupMarkerEXT := dglGetProcAddress('glPopGroupMarkerEXT');
+end;
+
+procedure Read_GL_EXT_discard_framebuffer;
+begin
+ glDiscardFramebufferEXT := dglGetProcAddress('glDiscardFramebufferEXT');
+end;
+
+procedure Read_GL_EXT_disjoint_timer_query;
+begin
+ glGenQueriesEXT := dglGetProcAddress('glGenQueriesEXT');
+ glDeleteQueriesEXT := dglGetProcAddress('glDeleteQueriesEXT');
+ glIsQueryEXT := dglGetProcAddress('glIsQueryEXT');
+ glBeginQueryEXT := dglGetProcAddress('glBeginQueryEXT');
+ glEndQueryEXT := dglGetProcAddress('glEndQueryEXT');
+ glQueryCounterEXT := dglGetProcAddress('glQueryCounterEXT');
+ glGetQueryivEXT := dglGetProcAddress('glGetQueryivEXT');
+ glGetQueryObjectivEXT := dglGetProcAddress('glGetQueryObjectivEXT');
+ glGetQueryObjectuivEXT := dglGetProcAddress('glGetQueryObjectuivEXT');
+ glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT');
+ glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT');
+end;
+
+procedure Read_GL_EXT_draw_buffers;
+begin
+ glDrawBuffersEXT := dglGetProcAddress('glDrawBuffersEXT');
+end;
+
+procedure Read_GL_EXT_draw_buffers_indexed;
+begin
+ glEnableiEXT := dglGetProcAddress('glEnableiEXT');
+ glDisableiEXT := dglGetProcAddress('glDisableiEXT');
+ glBlendEquationiEXT := dglGetProcAddress('glBlendEquationiEXT');
+ glBlendEquationSeparateiEXT := dglGetProcAddress('glBlendEquationSeparateiEXT');
+ glBlendFunciEXT := dglGetProcAddress('glBlendFunciEXT');
+ glBlendFuncSeparateiEXT := dglGetProcAddress('glBlendFuncSeparateiEXT');
+ glColorMaskiEXT := dglGetProcAddress('glColorMaskiEXT');
+ glIsEnablediEXT := dglGetProcAddress('glIsEnablediEXT');
+end;
+
+procedure Read_GL_EXT_draw_elements_base_vertex;
+begin
+ glDrawElementsBaseVertexEXT := dglGetProcAddress('glDrawElementsBaseVertexEXT');
+ glDrawRangeElementsBaseVertexEXT := dglGetProcAddress('glDrawRangeElementsBaseVertexEXT');
+ glDrawElementsInstancedBaseVertexEXT := dglGetProcAddress('glDrawElementsInstancedBaseVertexEXT');
+ glMultiDrawElementsBaseVertexEXT := dglGetProcAddress('glMultiDrawElementsBaseVertexEXT');
+end;
+
+procedure Read_GL_EXT_draw_instanced;
+begin
+ glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT');
+ glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT');
+end;
+
+procedure Read_GL_EXT_geometry_shader;
+begin
+ glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT');
+end;
+
+procedure Read_GL_EXT_instanced_arrays;
+begin
+ glVertexAttribDivisorEXT := dglGetProcAddress('glVertexAttribDivisorEXT');
+end;
+
+procedure Read_GL_EXT_map_buffer_range;
+begin
+ glMapBufferRangeEXT := dglGetProcAddress('glMapBufferRangeEXT');
+ glFlushMappedBufferRangeEXT := dglGetProcAddress('glFlushMappedBufferRangeEXT');
+end;
+
+procedure Read_GL_EXT_multi_draw_arrays;
+begin
+ glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT');
+ glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT');
+end;
+
+procedure Read_GL_EXT_multi_draw_indirect;
+begin
+ glMultiDrawArraysIndirectEXT := dglGetProcAddress('glMultiDrawArraysIndirectEXT');
+ glMultiDrawElementsIndirectEXT := dglGetProcAddress('glMultiDrawElementsIndirectEXT');
+end;
+
+procedure Read_GL_EXT_multisampled_render_to_texture;
+begin
+ glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT');
+ glFramebufferTexture2DMultisampleEXT := dglGetProcAddress('glFramebufferTexture2DMultisampleEXT');
+end;
+
+procedure Read_GL_EXT_multiview_draw_buffers;
+begin
+ glReadBufferIndexedEXT := dglGetProcAddress('glReadBufferIndexedEXT');
+ glDrawBuffersIndexedEXT := dglGetProcAddress('glDrawBuffersIndexedEXT');
+ glGetIntegeri_vEXT := dglGetProcAddress('glGetIntegeri_vEXT');
+end;
+
+procedure Read_GL_EXT_primitive_bounding_box;
+begin
+ glPrimitiveBoundingBoxEXT := dglGetProcAddress('glPrimitiveBoundingBoxEXT');
+end;
+
+procedure Read_GL_EXT_robustness;
+begin
+ glGetGraphicsResetStatusEXT := dglGetProcAddress('glGetGraphicsResetStatusEXT');
+ glReadnPixelsEXT := dglGetProcAddress('glReadnPixelsEXT');
+ glGetnUniformfvEXT := dglGetProcAddress('glGetnUniformfvEXT');
+ glGetnUniformivEXT := dglGetProcAddress('glGetnUniformivEXT');
+end;
+
+procedure Read_GL_EXT_separate_shader_objects;
+begin
+ glActiveShaderProgramEXT := dglGetProcAddress('glActiveShaderProgramEXT');
+ glBindProgramPipelineEXT := dglGetProcAddress('glBindProgramPipelineEXT');
+ glCreateShaderProgramvEXT := dglGetProcAddress('glCreateShaderProgramvEXT');
+ glDeleteProgramPipelinesEXT := dglGetProcAddress('glDeleteProgramPipelinesEXT');
+ glGenProgramPipelinesEXT := dglGetProcAddress('glGenProgramPipelinesEXT');
+ glGetProgramPipelineInfoLogEXT := dglGetProcAddress('glGetProgramPipelineInfoLogEXT');
+ glGetProgramPipelineivEXT := dglGetProcAddress('glGetProgramPipelineivEXT');
+ glIsProgramPipelineEXT := dglGetProcAddress('glIsProgramPipelineEXT');
+ glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT');
+ glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT');
+ glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT');
+ glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT');
+ glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT');
+ glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT');
+ glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT');
+ glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT');
+ glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT');
+ glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT');
+ glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT');
+ glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT');
+ glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT');
+ glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT');
+ glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT');
+ glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT');
+ glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT');
+ glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT');
+ glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT');
+ glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT');
+ glUseProgramStagesEXT := dglGetProcAddress('glUseProgramStagesEXT');
+ glValidateProgramPipelineEXT := dglGetProcAddress('glValidateProgramPipelineEXT');
+ glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT');
+ glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT');
+ glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT');
+ glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT');
+ glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT');
+ glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT');
+ glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT');
+ glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT');
+ glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT');
+ glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT');
+ glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT');
+ glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT');
+ glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT');
+ glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT');
+end;
+
+procedure Read_GL_EXT_tessellation_shader;
+begin
+ glPatchParameteriEXT := dglGetProcAddress('glPatchParameteriEXT');
+end;
+
+procedure Read_GL_EXT_texture_border_clamp;
+begin
+ glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT');
+ glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT');
+ glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT');
+ glGetTexParameterIuivEXT := dglGetProcAddress('glGetTexParameterIuivEXT');
+ glSamplerParameterIivEXT := dglGetProcAddress('glSamplerParameterIivEXT');
+ glSamplerParameterIuivEXT := dglGetProcAddress('glSamplerParameterIuivEXT');
+ glGetSamplerParameterIivEXT := dglGetProcAddress('glGetSamplerParameterIivEXT');
+ glGetSamplerParameterIuivEXT := dglGetProcAddress('glGetSamplerParameterIuivEXT');
+end;
+
+procedure Read_GL_EXT_texture_buffer;
+begin
+ glTexBufferEXT := dglGetProcAddress('glTexBufferEXT');
+ glTexBufferRangeEXT := dglGetProcAddress('glTexBufferRangeEXT');
+end;
+
+procedure Read_GL_EXT_texture_storage;
+begin
+ glTexStorage1DEXT := dglGetProcAddress('glTexStorage1DEXT');
+ glTexStorage2DEXT := dglGetProcAddress('glTexStorage2DEXT');
+ glTexStorage3DEXT := dglGetProcAddress('glTexStorage3DEXT');
+ glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT');
+ glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT');
+ glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT');
+end;
+
+procedure Read_GL_EXT_texture_view;
+begin
+ glTextureViewEXT := dglGetProcAddress('glTextureViewEXT');
+end;
+
+procedure Read_GL_IMG_multisampled_render_to_texture;
+begin
+ glRenderbufferStorageMultisampleIMG := dglGetProcAddress('glRenderbufferStorageMultisampleIMG');
+ glFramebufferTexture2DMultisampleIMG := dglGetProcAddress('glFramebufferTexture2DMultisampleIMG');
+end;
+procedure Read_GL_INTEL_performance_query;
+begin
+ glBeginPerfQueryINTEL := dglGetProcAddress('glBeginPerfQueryINTEL');
+ glCreatePerfQueryINTEL := dglGetProcAddress('glCreatePerfQueryINTEL');
+ glDeletePerfQueryINTEL := dglGetProcAddress('glDeletePerfQueryINTEL');
+ glEndPerfQueryINTEL := dglGetProcAddress('glEndPerfQueryINTEL');
+ glGetFirstPerfQueryIdINTEL := dglGetProcAddress('glGetFirstPerfQueryIdINTEL');
+ glGetNextPerfQueryIdINTEL := dglGetProcAddress('glGetNextPerfQueryIdINTEL');
+ glGetPerfCounterInfoINTEL := dglGetProcAddress('glGetPerfCounterInfoINTEL');
+ glGetPerfQueryDataINTEL := dglGetProcAddress('glGetPerfQueryDataINTEL');
+ glGetPerfQueryIdByNameINTEL := dglGetProcAddress('glGetPerfQueryIdByNameINTEL');
+ glGetPerfQueryInfoINTEL := dglGetProcAddress('glGetPerfQueryInfoINTEL');
+end;
+
+procedure Read_GL_NV_bindless_texture;
+begin
+ glGetTextureHandleNV := dglGetProcAddress('glGetTextureHandleNV');
+ glGetTextureSamplerHandleNV := dglGetProcAddress('glGetTextureSamplerHandleNV');
+ glMakeTextureHandleResidentNV := dglGetProcAddress('glMakeTextureHandleResidentNV');
+ glMakeTextureHandleNonResidentNV := dglGetProcAddress('glMakeTextureHandleNonResidentNV');
+ glGetImageHandleNV := dglGetProcAddress('glGetImageHandleNV');
+ glMakeImageHandleResidentNV := dglGetProcAddress('glMakeImageHandleResidentNV');
+ glMakeImageHandleNonResidentNV := dglGetProcAddress('glMakeImageHandleNonResidentNV');
+ glUniformHandleui64NV := dglGetProcAddress('glUniformHandleui64NV');
+ glUniformHandleui64vNV := dglGetProcAddress('glUniformHandleui64vNV');
+ glProgramUniformHandleui64NV := dglGetProcAddress('glProgramUniformHandleui64NV');
+ glProgramUniformHandleui64vNV := dglGetProcAddress('glProgramUniformHandleui64vNV');
+ glIsTextureHandleResidentNV := dglGetProcAddress('glIsTextureHandleResidentNV');
+ glIsImageHandleResidentNV := dglGetProcAddress('glIsImageHandleResidentNV');
+end;
+
+procedure Read_GL_NV_blend_equation_advanced;
+begin
+ glBlendParameteriNV := dglGetProcAddress('glBlendParameteriNV');
+ glBlendBarrierNV := dglGetProcAddress('glBlendBarrierNV');
+end;
+
+procedure Read_GL_NV_conditional_render;
+begin
+ glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV');
+ glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV');
+end;
+
+procedure Read_GL_NV_copy_buffer;
+begin
+ glCopyBufferSubDataNV := dglGetProcAddress('glCopyBufferSubDataNV');
+end;
+
+procedure Read_GL_NV_coverage_sample;
+begin
+ glCoverageMaskNV := dglGetProcAddress('glCoverageMaskNV');
+ glCoverageOperationNV := dglGetProcAddress('glCoverageOperationNV');
+end;
+
+procedure Read_GL_NV_draw_buffers;
+begin
+ glDrawBuffersNV := dglGetProcAddress('glDrawBuffersNV');
+end;
+
+procedure Read_GL_NV_draw_instanced;
+begin
+ glDrawArraysInstancedNV := dglGetProcAddress('glDrawArraysInstancedNV');
+ glDrawElementsInstancedNV := dglGetProcAddress('glDrawElementsInstancedNV');
+end;
+
+procedure Read_GL_NV_fence;
+begin
+ glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV');
+ glGenFencesNV := dglGetProcAddress('glGenFencesNV');
+ glIsFenceNV := dglGetProcAddress('glIsFenceNV');
+ glTestFenceNV := dglGetProcAddress('glTestFenceNV');
+ glGetFenceivNV := dglGetProcAddress('glGetFenceivNV');
+ glFinishFenceNV := dglGetProcAddress('glFinishFenceNV');
+ glSetFenceNV := dglGetProcAddress('glSetFenceNV');
+end;
+
+procedure Read_GL_NV_framebuffer_blit;
+begin
+ glBlitFramebufferNV := dglGetProcAddress('glBlitFramebufferNV');
+end;
+
+procedure Read_GL_NV_framebuffer_multisample;
+begin
+ glRenderbufferStorageMultisampleNV := dglGetProcAddress('glRenderbufferStorageMultisampleNV');
+end;
+
+procedure Read_GL_NV_instanced_arrays;
+begin
+ glVertexAttribDivisorNV := dglGetProcAddress('glVertexAttribDivisorNV');
+end;
+
+procedure Read_GL_NV_internalformat_sample_query;
+begin
+ glGetInternalformatSampleivNV := dglGetProcAddress('glGetInternalformatSampleivNV');
+end;
+
+procedure Read_GL_NV_non_square_matrices;
+begin
+ glUniformMatrix2x3fvNV := dglGetProcAddress('glUniformMatrix2x3fvNV');
+ glUniformMatrix3x2fvNV := dglGetProcAddress('glUniformMatrix3x2fvNV');
+ glUniformMatrix2x4fvNV := dglGetProcAddress('glUniformMatrix2x4fvNV');
+ glUniformMatrix4x2fvNV := dglGetProcAddress('glUniformMatrix4x2fvNV');
+ glUniformMatrix3x4fvNV := dglGetProcAddress('glUniformMatrix3x4fvNV');
+ glUniformMatrix4x3fvNV := dglGetProcAddress('glUniformMatrix4x3fvNV');
+end;
+
+procedure Read_GL_NV_path_rendering;
+begin
+ glGenPathsNV := dglGetProcAddress('glGenPathsNV');
+ glDeletePathsNV := dglGetProcAddress('glDeletePathsNV');
+ glIsPathNV := dglGetProcAddress('glIsPathNV');
+ glPathCommandsNV := dglGetProcAddress('glPathCommandsNV');
+ glPathCoordsNV := dglGetProcAddress('glPathCoordsNV');
+ glPathSubCommandsNV := dglGetProcAddress('glPathSubCommandsNV');
+ glPathSubCoordsNV := dglGetProcAddress('glPathSubCoordsNV');
+ glPathStringNV := dglGetProcAddress('glPathStringNV');
+ glPathGlyphsNV := dglGetProcAddress('glPathGlyphsNV');
+ glPathGlyphRangeNV := dglGetProcAddress('glPathGlyphRangeNV');
+ glWeightPathsNV := dglGetProcAddress('glWeightPathsNV');
+ glCopyPathNV := dglGetProcAddress('glCopyPathNV');
+ glInterpolatePathsNV := dglGetProcAddress('glInterpolatePathsNV');
+ glTransformPathNV := dglGetProcAddress('glTransformPathNV');
+ glPathParameterivNV := dglGetProcAddress('glPathParameterivNV');
+ glPathParameteriNV := dglGetProcAddress('glPathParameteriNV');
+ glPathParameterfvNV := dglGetProcAddress('glPathParameterfvNV');
+ glPathParameterfNV := dglGetProcAddress('glPathParameterfNV');
+ glPathDashArrayNV := dglGetProcAddress('glPathDashArrayNV');
+ glPathStencilFuncNV := dglGetProcAddress('glPathStencilFuncNV');
+ glPathStencilDepthOffsetNV := dglGetProcAddress('glPathStencilDepthOffsetNV');
+ glStencilFillPathNV := dglGetProcAddress('glStencilFillPathNV');
+ glStencilStrokePathNV := dglGetProcAddress('glStencilStrokePathNV');
+ glStencilFillPathInstancedNV := dglGetProcAddress('glStencilFillPathInstancedNV');
+ glStencilStrokePathInstancedNV := dglGetProcAddress('glStencilStrokePathInstancedNV');
+ glPathCoverDepthFuncNV := dglGetProcAddress('glPathCoverDepthFuncNV');
+ glCoverFillPathNV := dglGetProcAddress('glCoverFillPathNV');
+ glCoverStrokePathNV := dglGetProcAddress('glCoverStrokePathNV');
+ glCoverFillPathInstancedNV := dglGetProcAddress('glCoverFillPathInstancedNV');
+ glCoverStrokePathInstancedNV := dglGetProcAddress('glCoverStrokePathInstancedNV');
+ glGetPathParameterivNV := dglGetProcAddress('glGetPathParameterivNV');
+ glGetPathParameterfvNV := dglGetProcAddress('glGetPathParameterfvNV');
+ glGetPathCommandsNV := dglGetProcAddress('glGetPathCommandsNV');
+ glGetPathCoordsNV := dglGetProcAddress('glGetPathCoordsNV');
+ glGetPathDashArrayNV := dglGetProcAddress('glGetPathDashArrayNV');
+ glGetPathMetricsNV := dglGetProcAddress('glGetPathMetricsNV');
+ glGetPathMetricRangeNV := dglGetProcAddress('glGetPathMetricRangeNV');
+ glGetPathSpacingNV := dglGetProcAddress('glGetPathSpacingNV');
+ glIsPointInFillPathNV := dglGetProcAddress('glIsPointInFillPathNV');
+ glIsPointInStrokePathNV := dglGetProcAddress('glIsPointInStrokePathNV');
+ glGetPathLengthNV := dglGetProcAddress('glGetPathLengthNV');
+ glPointAlongPathNV := dglGetProcAddress('glPointAlongPathNV');
+ glMatrixLoad3x2fNV := dglGetProcAddress('glMatrixLoad3x2fNV');
+ glMatrixLoad3x3fNV := dglGetProcAddress('glMatrixLoad3x3fNV');
+ glMatrixLoadTranspose3x3fNV := dglGetProcAddress('glMatrixLoadTranspose3x3fNV');
+ glMatrixMult3x2fNV := dglGetProcAddress('glMatrixMult3x2fNV');
+ glMatrixMult3x3fNV := dglGetProcAddress('glMatrixMult3x3fNV');
+ glMatrixMultTranspose3x3fNV := dglGetProcAddress('glMatrixMultTranspose3x3fNV');
+ glStencilThenCoverFillPathNV := dglGetProcAddress('glStencilThenCoverFillPathNV');
+ glStencilThenCoverStrokePathNV := dglGetProcAddress('glStencilThenCoverStrokePathNV');
+ glStencilThenCoverFillPathInstancedNV := dglGetProcAddress('glStencilThenCoverFillPathInstancedNV');
+ glStencilThenCoverStrokePathInstancedNV := dglGetProcAddress('glStencilThenCoverStrokePathInstancedNV');
+ glPathGlyphIndexRangeNV := dglGetProcAddress('glPathGlyphIndexRangeNV');
+ glPathGlyphIndexArrayNV := dglGetProcAddress('glPathGlyphIndexArrayNV');
+ glPathMemoryGlyphIndexArrayNV := dglGetProcAddress('glPathMemoryGlyphIndexArrayNV');
+ glProgramPathFragmentInputGenNV := dglGetProcAddress('glProgramPathFragmentInputGenNV');
+ glGetProgramResourcefvNV := dglGetProcAddress('glGetProgramResourcefvNV');
+end;
+
+procedure Read_GL_NV_read_buffer;
+begin
+ glReadBufferNV := dglGetProcAddress('glReadBufferNV');
+end;
+
+procedure Read_GL_NV_viewport_array;
+begin
+ glViewportArrayvNV := dglGetProcAddress('glViewportArrayvNV');
+ glViewportIndexedfNV := dglGetProcAddress('glViewportIndexedfNV');
+ glViewportIndexedfvNV := dglGetProcAddress('glViewportIndexedfvNV');
+ glScissorArrayvNV := dglGetProcAddress('glScissorArrayvNV');
+ glScissorIndexedNV := dglGetProcAddress('glScissorIndexedNV');
+ glScissorIndexedvNV := dglGetProcAddress('glScissorIndexedvNV');
+ glDepthRangeArrayfvNV := dglGetProcAddress('glDepthRangeArrayfvNV');
+ glDepthRangeIndexedfNV := dglGetProcAddress('glDepthRangeIndexedfNV');
+ glGetFloati_vNV := dglGetProcAddress('glGetFloati_vNV');
+ glEnableiNV := dglGetProcAddress('glEnableiNV');
+ glDisableiNV := dglGetProcAddress('glDisableiNV');
+ glIsEnablediNV := dglGetProcAddress('glIsEnablediNV');
+end;
+
+procedure Read_GL_QCOM_alpha_test;
+begin
+ glAlphaFuncQCOM := dglGetProcAddress('glAlphaFuncQCOM');
+end;
+
+procedure Read_GL_QCOM_driver_control;
+begin
+ glGetDriverControlsQCOM := dglGetProcAddress('glGetDriverControlsQCOM');
+ glGetDriverControlStringQCOM := dglGetProcAddress('glGetDriverControlStringQCOM');
+ glEnableDriverControlQCOM := dglGetProcAddress('glEnableDriverControlQCOM');
+ glDisableDriverControlQCOM := dglGetProcAddress('glDisableDriverControlQCOM');
+end;
+
+procedure Read_GL_QCOM_extended_get;
+begin
+ glExtGetTexturesQCOM := dglGetProcAddress('glExtGetTexturesQCOM');
+ glExtGetBuffersQCOM := dglGetProcAddress('glExtGetBuffersQCOM');
+ glExtGetRenderbuffersQCOM := dglGetProcAddress('glExtGetRenderbuffersQCOM');
+ glExtGetFramebuffersQCOM := dglGetProcAddress('glExtGetFramebuffersQCOM');
+ glExtGetTexLevelParameterivQCOM := dglGetProcAddress('glExtGetTexLevelParameterivQCOM');
+ glExtTexObjectStateOverrideiQCOM := dglGetProcAddress('glExtTexObjectStateOverrideiQCOM');
+ glExtGetTexSubImageQCOM := dglGetProcAddress('glExtGetTexSubImageQCOM');
+ glExtGetBufferPointervQCOM := dglGetProcAddress('glExtGetBufferPointervQCOM');
+end;
+
+procedure Read_GL_QCOM_extended_get2;
+begin
+ glExtGetShadersQCOM := dglGetProcAddress('glExtGetShadersQCOM');
+ glExtGetProgramsQCOM := dglGetProcAddress('glExtGetProgramsQCOM');
+ glExtIsProgramBinaryQCOM := dglGetProcAddress('glExtIsProgramBinaryQCOM');
+ glExtGetProgramBinarySourceQCOM := dglGetProcAddress('glExtGetProgramBinarySourceQCOM');
+end;
+
+procedure Read_GL_QCOM_tiled_rendering;
+begin
+ glStartTilingQCOM := dglGetProcAddress('glStartTilingQCOM');
+ glEndTilingQCOM := dglGetProcAddress('glEndTilingQCOM');
end;
constructor EeglError.Create(const msg: string; const aErrorCode: EGLint);
projects / dglOpenGLES.git / commitdiff