ZenGL 4.1

Zengl_SRC/Update_ZenGL.txt

@@ -1,3 +1,24 @@
+18.09.2023
+	Добавлено определение "CLEAR_STATE". Теперь если его отключить, то не будут очищаться события клавиатуры, мыши, джойстика и тачпада. Пользователю надо будет самому определить где он будет очищать данные события.
+
+16.09.2023
+	Добавлена демка 19 "OpenGL33_1", показывающая самую простенькую работу с шейдерами.
+
+04.09.2023
+	Добавлен модуль gegl_xrandr - это xrandr со всеми обновлениями. Не должен быть частью библиотек ни ZenGL ни GreeEngine.
+
+03.09.2023
+	Добавлены свои конфигурационные (уже настроенные) файлы для demo "18 - LCLZenGL" и для проектов "ZenFont" и корректированы данные проекты.
+
+25.07.2023
+	Корректировка проекта создания шрифтов для ZenGL
+	Корректировка zgl_pasOpenGL для Linux.
+	Внесены определения "VID_NV", "VID_AMD", "VID_INTEL" и "VID_APPLE" для включения/отключения функций/расширений для NVidia, AMD, Intel или Apple, поддерживаемые для OpenGL/OpenGL ES/EGL.
+
+23.07.2023
+	Добавлены заголовки OpenGL ES для всех версий с последними обновлениями на данную дату.
+	Добавлены полные заголовки для EGL с последними обновлениями на данную дату.
+
 03.07.2023
 	Корректировка кода и возврат файлов для стабильной работы ZenGL в DelphiXE.
 

Zengl_SRC/bin/Android/arm64-v8a/old_libtheora.so

@@ -0,0 +1,10 @@
+#version 330 core
+
+in vec4 fragColor;
+
+out vec4 color;
+
+void main()
+{
+    color = fragColor;
+}

Zengl_SRC/bin/shaders/first.vs

@@ -0,0 +1,13 @@
+#version 330 core
+
+layout(location = 0) in vec4 pos;
+layout(location = 1) in vec4 color;
+
+uniform mat4 projMatr;
+
+out vec4 fragColor;
+
+void main() {
+    gl_Position = projMatr * pos;
+    fragColor = color;
+}

Zengl_SRC/demos/Android/15-Video/jni/.project

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>15-Video_jni</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-	</buildSpec>
-	<natures>
-	</natures>
-</projectDescription>

Zengl_SRC/demos/Android/16-Physics/Warning!!!

@@ -76,11 +76,19 @@
         <Mode0 Name="default"/>
       </Modes>
     </RunParams>
-    <Units Count="1">
+    <Units Count="3">
       <Unit0>
         <Filename Value="demo01.lpr"/>
         <IsPartOfProject Value="True"/>
       </Unit0>
+      <Unit1>
+        <Filename Value="../../../srcGL/zgl_matrix.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit1>
+      <Unit2>
+        <Filename Value="../../../srcGEGL/gegl_xrandr.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit2>
     </Units>
   </ProjectOptions>
   <CompilerOptions>
@@ -89,8 +97,8 @@
       <Filename Value="../../../bin/$(TargetCPU)-$(TargetOS)/demo01"/>
     </Target>
     <SearchPaths>
-      <IncludeFiles Value="$(ProjOutDir);../../../headers;../../../srcGEGL;../../../src;../../../srcGL"/>
-      <OtherUnitFiles Value="../../../extra;../../../src;../../../srcGL;../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../srcGEGL"/>
+      <IncludeFiles Value="$(ProjOutDir);../../../headers;../../../srcGEGL;../../../src;../../../srcGL;../../../srcGL/EGL;../../../srcGL/GLES"/>
+      <OtherUnitFiles Value="../../../extra;../../../src;../../../srcGL;../../../srcGL/EGL;../../../srcGL/GLES;../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../srcGEGL"/>
       <UnitOutputDirectory Value="../tmp/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>
     <Parsing>
@@ -106,7 +114,6 @@
     </CodeGeneration>
     <Linking>
       <Debugging>
-        <GenerateDebugInfo Value="False"/>
         <DebugInfoType Value="dsDwarf2"/>
         <StripSymbols Value="True"/>
       </Debugging>

Zengl_SRC/demos/Lazarus/01 - Initialization/demo01.lpr

@@ -3,7 +3,7 @@ program demo01;
 // RU: Этот файл содержит некоторые настройки(например использовать ли статическую компиляцию) и определения ОС под которую происходит компиляция.
 // EN: This file contains some options(e.g. whether to use static compilation) and defines of OS for which is compilation going.
 {$I zglCustomConfig.cfg}
-{$I GLdefine.cfg}
+{$I zgl_config.cfg}
 
 {$IFDEF WINDOWS}
   {$R *.res}
@@ -144,8 +144,8 @@ Begin
   zgl_SetParam(800, 600, false, false);
 
   {$IfDef GL_VERSION_3_0}
-  // RU: Устанавливаем контекст OpenGL 3.3. Для этого надо включить  дефайн "USE_GL_33" в GLdefine.cfg.
-  // EN: Setting context OpenGL 3.3. Enable "USE_GL_33" in GLdefine.cfg.
+  // RU: Устанавливаем контекст OpenGL 3.3. Для этого надо включить  дефайн "USE_GL_33" и отключить "USE_MIN_OPENGL" в GLdefine.cfg.
+  // EN: Setting context OpenGL 3.3. To do this, enable the "USE_GL_33" define and disable "USE_MIN_OPENGL" in GLdefine.cfg.
   SetGLVersionAndFlags(3, 3);
   {$EndIf}
 

Zengl_SRC/demos/Lazarus/01 - Initialization/demo01.res

@@ -89,8 +89,8 @@
       <Filename Value="../../../bin/$(TargetCPU)-$(TargetOS)/demo13"/>
     </Target>
     <SearchPaths>
-      <IncludeFiles Value="$(ProjOutDir);../../../headers;../../../srcGEGL;../../../src;../../../srcGL"/>
-      <OtherUnitFiles Value="../../../headers;../../../extra;../../../src;../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../srcGEGL;../../../srcGL"/>
+      <IncludeFiles Value="$(ProjOutDir);../../../headers;../../../srcGEGL;../../../srcGL/EGL;../../../srcGL/GLES;../../../src;../../../srcGL"/>
+      <OtherUnitFiles Value="../../../headers;../../../extra;../../../src;../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../srcGEGL;../../../srcGL;../../../srcGL/EGL;../../../srcGL/GLES"/>
       <UnitOutputDirectory Value="../tmp/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>
     <Parsing>
@@ -106,7 +106,6 @@
     </CodeGeneration>
     <Linking>
       <Debugging>
-        <GenerateDebugInfo Value="False"/>
         <DebugInfoType Value="dsDwarf2Set"/>
         <StripSymbols Value="True"/>
         <UseExternalDbgSyms Value="True"/>

Zengl_SRC/demos/Lazarus/13 - Particles/demo13.lpr

@@ -141,6 +141,8 @@ Begin
   zgl_Reg( SYS_EXIT, @Quit );
 
   wnd_SetCaption(utf8_Copy('13 - Particles'));
+  scr_SetFPS(1000);
+  scr_SetVSync(False);
 
   zgl_Init();
 End.

Zengl_SRC/demos/Lazarus/13 - Particles/demo13.res

@@ -13,7 +13,7 @@ object Form1: TForm1
   OnMouseDown = FormMouseDown
   OnMouseMove = FormMouseMove
   Position = poScreenCenter
-  LCLVersion = '2.2.0.4'
+  LCLVersion = '2.2.4.0'
   object Timer1: TTimer
     Enabled = False
     Interval = 10

Zengl_SRC/demos/Lazarus/18 - LCLZenGL/demo.pas

@@ -5,8 +5,14 @@
 
 interface
 
-// RU: Для данной демо-версии надо включить "USE_INIT_HANDLE" в файле конфигурации "zgl_config.cfg".
-// EN: For this demo, "USE_INIT_HANDLE" must be enabled in the configuration file "zgl_config.cfg".
+// RU: обратите внимание!!!
+//     Проекты LCL имеют свои конфигурационные файлы "zgl_config.cfg". Лучше всего для каждого вашего проекта иметь свой
+//     конфигурационный файл, это может решить многие проблемы, если вдруг вы будете вносить изменения в конфигурацию проекта
+//     и, это отобразится на других ваших проектах использующих тот же конфигурационный файл.
+// EN: note!!!
+//     LCL projects have their own configuration files "zgl_config.cfg". It's best to have a separate config file for each of
+//     your projects, this can solve many problems if you suddenly make changes to the project config and it will show up on
+//     your other projects using the same config file.
 
 uses
   Classes,
@@ -161,7 +167,8 @@ end;
 
 procedure TForm1.FormCreate(Sender: TObject);
 begin
-  // вариант для неизменного окна или выбирайте нужный вариант в настройках формы.
+  // RU: вариант для неизменного окна или выбирайте нужный вариант в настройках формы.
+  // EN: option for a fixed window or select the desired option in the form settings.
   // Form1.BorderStyle := bsSingle;
 end;
 
@@ -208,26 +215,39 @@ begin
     {$IFDEF LCLGTK2}
     widget := GetFixedWidget( PGtkWidget( Handle ) );
     gtk_widget_realize( widget );
-    zgl_InitToHandle( GDK_WINDOW_XID( widget^.window ) );
+    if not zgl_InitToHandle( GDK_WINDOW_XID( widget^.window ) ) then
+    begin
+      zgl_Destroy;
+      Application.Terminate;
+      Exit;
+    end;
     {$ENDIF}
   {$ENDIF}
 
   {$IFDEF WINDOWS}
-    zgl_InitToHandle( Handle );
+    if not zgl_InitToHandle( Handle ) then
+    begin
+      zgl_Destroy;
+      Application.Terminate;
+      Exit;
+    end;
   {$ENDIF}
 
-  // таймер должен быть изначально выключен. Включаем таймер только когда окно инициализировано.
+  // RU: таймер должен быть изначально выключен! Включаем таймер только когда окно инициализировано.
+  // EN: the timer must be initially turned off! We turn on the timer only when the window is initialized.
   Timer1.Enabled := True;
 end;
 
-// проверка нажатия клавиши
+// RU: проверка нажатия клавиши.
+// EN: keypress check.
 procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
 begin
   if Key = 27 then
     Form1.Close;
 end;
 
-// обработка мыши и проигрывание музыки
+// RU: обработка мыши и проигрывание музыки.
+// EN: mouse handling and music playback.
 procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; X, Y: Integer);
 begin
@@ -240,13 +260,16 @@ begin
     // EN: In this case, we begin to play the sound directly in these coordinates, but they can be changed later using procedure snd_SetPos.
     //     Important: OpenAL can position only mono-sounds.
 
-// эта часть изменена!!! Теперь можно заново воспроизводить звуки, даже если они не закончили играть.
+// !!! -------------------------------------------------------------------------
+// RU: эта часть изменена!!! Теперь можно заново воспроизводить звуки, даже если они не закончили играть.
+// EN: this part has changed! Sounds can now be replayed even if they haven't finished playing.
     if snd_Get(sound, IDSound[0], SND_STATE_PLAYING) = IDSound[0] then
       snd_Stop(sound, IDSound[0]);
     IDSound[0] := snd_Play(sound, FALSE, CalcX2D(X), CalcY2D(Y));
-// ------------------------------------------------------------------------------------------
+// !!! -------------------------------------------------------------------------
 
-// добавляем проверку на проигрывание звука, только если много развных звуков/музыки, то номера надо менять (не только 1!!!)
+// RU: добавляем проверку на проигрывание звука, только если много разных звуков/музыки, то номера надо менять (не только 1!!!)
+// EN: we add a check for sound playback, only if there are many different sounds / music, then the numbers must be changed (not only 1 !!!)
     if col2d_PointInRect(X, Y, r) Then
     begin
       if audioPlay then
@@ -259,7 +282,8 @@ begin
   Timer1.Enabled := true;
 end;
 
-// для примера использования перемещения мышки
+// RU: для примера использования перемещения мышки.
+// EN: for an example of using mouse movement.
 procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,
   Y: Integer);
 begin

Zengl_SRC/demos/Lazarus/18 - LCLZenGL/demoLCL.lpi

@@ -14,7 +14,6 @@
       <XPManifest>
         <DpiAware Value="True"/>
       </XPManifest>
-      <Icon Value="0"/>
     </General>
     <BuildModes Count="1">
       <Item1 Name="Default" Default="True"/>
@@ -51,8 +50,8 @@
       <Filename Value="../../../bin/$(TargetCPU)-$(TargetOS)/demoLCL"/>
     </Target>
     <SearchPaths>
-      <IncludeFiles Value="$(ProjOutDir);../../../srcGEGL;../../../src;../../../srcGL"/>
-      <OtherUnitFiles Value="../../../src;../../../srcGL;../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/chipmunk/$(TargetCPU)-$(TargetOS);../../../srcGEGL"/>
+      <IncludeFiles Value="$(ProjOutDir);../../../srcGEGL;../../../src;../../../srcGL;../../../srcGL/GLES;../../../srcGL/EGL"/>
+      <OtherUnitFiles Value="../../../src;../../../srcGL;../../../srcGL/EGL;../../../srcGL/GLES;../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/chipmunk/$(TargetCPU)-$(TargetOS);../../../srcGEGL"/>
       <UnitOutputDirectory Value="../tmp/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>
     <Parsing>
@@ -65,7 +64,6 @@
     </CodeGeneration>
     <Linking>
       <Debugging>
-        <GenerateDebugInfo Value="False"/>
         <DebugInfoType Value="dsDwarf2Set"/>
         <StripSymbols Value="True"/>
       </Debugging>

Zengl_SRC/demos/Lazarus/18 - LCLZenGL/zgl_config.cfg

@@ -0,0 +1,275 @@
+// Rus: мобильные платформы - Android, iOS, iPhone.
+// Eng: mobile platform - Android, iOS, iPhone.
+{$IF DEFINED(ANDROID) OR DEFINED(iOS) OR DEFINED(iPHONESIM)}
+  {$DEFINE MOBILE}
+{$IFEND}
+
+// так как мне надоело делать проверки, но я знаю что их надо делать, я добавляю дополнительную "отладочную"
+// информацию. Для себя я смогу это отключить, но это можно будет использовать для выявления каких-нибудь определённых багов.
+{$DEFINE FULL_LOGGING}
+
+// Rus: обработка старых процедур для клавиатуры. Если не хотим использовать GreenEngine.
+// Eng: processing of old procedures for the keyboard. If we do not want to use GreenEngine.
+{.$DEFINE KEYBOARD_OLD_FUNCTION}
+{$IFNDEF KEYBOARD_OLD_FUNCTION}
+  {$I gegl_config.cfg}
+{$ENDIF}
+
+// inializing in Handle (LCL, VCL)
+{$DEFINE USE_INIT_HANDLE}
+
+// Delphi 7 and down
+{$IFNDEF FPC}
+  {$IFDEF VER150}                    // Delphi 7
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER140}                    // Delphi 6
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER130}                    // Delphi 5
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER120}                    // Delphi 4
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER110}                    // C++ Builder 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER100}                    // Delphi 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+{$ENDIF}
+
+// Переделать!
+{$IF DEFINED(DARWIN) AND (NOT DEFINED(iOS) OR NOT DEFINED(iPHONESIM))}
+  {$IFNDEF CPUi386 }
+    {$DEFINE MAC_COCOA}
+  {$ENDIF}
+{$IFEND}
+
+{$IFDEF MAC_COCOA}
+  {$DEFINE NO_USE_STATIC_LIBRARY}
+{$ENDIF}
+
+// Use compile library (dll, so ...)
+{$DEFINE LIBRARY_COMPILE}
+
+{$IFDEF MOBILE}
+  {$UNDEF USE_INIT_HANDLE}
+{$ENDIF}
+
+// Rus: вы можете принудительно включить виртуальную клавиатуру везде, а так же виртуальные джойстики.
+// Eng: you can force enable virtual keyboard everywhere, as well as virtual joysticks.
+{.$DEFINE USE_VKEYBOARD}
+
+// Escape = exit
+{$DEFINE USE_EXIT_ESCAPE}
+
+//******************************************************************************
+//       Defines for GNU/Linux
+//******************************************************************************
+{$IFDEF LINUX}
+  // custom -----------------
+  {$DEFINE USE_OGG_STATIC}
+  {.$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_X11}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {.$DEFINE USE_FULL_GLX}
+
+  // OpenGL ES render for PC
+  {$DEFINE USE_GLES}
+  {.$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    // на данный момент ни где не используется. Но, надо знать, данное определение есть для стационарных компьютеров.
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ELSE}
+    {$DEFINE NO_EGL}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Android
+//******************************************************************************
+{$IFDEF ANDROID}
+// Rus: если вы будете использовать (ARM v5) или (ARM v6) отключите DEFINE CPUARMV7A.
+// Eng: if you will be using (ARM v5) or (ARM v6) disable DEFINE CPUARMV7A.
+  {$IFNDEF CPU64}
+    {$DEFINE CPUARMV7A}
+  {$ENDIF}
+  {$IF DEFINED(CPU64) OR DEFINED(CPUARMV7A) or DEFINED(CPUi386) or DEFINED(CPUx86_64)}
+    {$DEFINE NOT_OLD_ARM}   // старшие версии Anroid.
+  {$IFEND}
+  {$DEFINE ANDROID}
+  {$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$DEFINE USE_VORBIS}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$UNDEF  USE_X11}
+  {$UNDEF  USE_OGG_STATIC}
+  {$UNDEF  USE_THEORA_STATIC}
+  {$DEFINE USE_VKEYBOARD}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Windows and Windows Mobile
+//******************************************************************************
+{$IFDEF MSWINDOWS}
+  {$DEFINE WINDOWS}
+{$ENDIF}
+{$IFDEF WINDOWS}
+  // custom -----------------
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}               // disable if use DX Sound
+  {$DEFINE USE_OGG_STATIC}
+  {$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_VORBIS}
+  {.$DEFINE USE_FULL_WGL}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+// Defines for MacOS X and iOS
+//******************************************************************************
+// Переделать!
+{$IFDEF DARWIN}
+  // custom -----------------
+  {/$DEFINE USE_OGG_STATIC}
+  {/$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {$IF DEFINED(iPHONESIM) or (DEFINED(DARWIN) and DEFINED(CPUARM))}
+    {$DEFINE iOS}
+    {$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {.$UNDEF  USE_LIBJPEG}
+    {$DEFINE USE_OGG_STATIC}
+    {.$DEFINE USE_THEORA_STATIC}
+
+    {$UNDEF USE_INIT_HANDLE}
+
+    {$IFNDEF iPHONESIM}
+      // custom -----------
+      // If you don't need to decode theora, you can uncomment this DEFINE
+      // ------------------
+    {$ENDIF}
+  {$ELSE}
+    {$DEFINE MACOSX}
+    // OpenGL ES render for PC
+    {.$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {$IFDEF USE_GLES}
+      {.$DEFINE USE_GLES_ON_DESKTOP}
+    {$ENDIF}
+  {$IFEND}
+{$ENDIF}
+//******************************************************************************
+
+// Rus: окна созданные посредством LCL будут работать только с полным OpenGL. Если вам нужно будет решение для OpenGL ES, просьба оповестить меня об этом,
+//      пока отложу данное решение на потом, на очень далёкое "потом".
+// Eng: windows created with LCL will only work with full OpenGL. If you need a solution for OpenGL ES, please let me know while I put this solution aside
+//      for a very long time later.
+{$IFDEF USE_INIT_HANDLE}
+  {$UNDEF USE_GLES}
+  {$DEFINE NO_EGL}
+{$ENDIF}
+
+// Rus: используем разные конфигурационные файлы для OpenGL и для OpenGL ES.
+// Eng: we use different configuration files for OpenGL and for OpenGL ES.
+{$IFNDEF USE_GLES}
+  {$I GLdefine.cfg}
+{$ELSE}
+  {$I gles_conf.cfg}
+{$ENDIF}
+
+// Functionality
+{$DEFINE USE_LOG_FLUSH}
+{$DEFINE USE_ZIP}
+{$DEFINE USE_JOYSTICK}
+{$DEFINE USE_JPG}
+{$DEFINE USE_PNG}
+{$DEFINE USE_PVR}
+{$DEFINE USE_TGA}
+{$DEFINE USE_SENGINE}
+{$DEFINE USE_PARTICLES}
+{$DEFINE USE_SOUND}
+{$IFDEF USE_SOUND}
+  {$DEFINE USE_OGG}
+  {$DEFINE USE_WAV}
+{$ENDIF}
+{$DEFINE USE_VIDEO}
+{$IFDEF USE_VIDEO}
+  {$DEFINE USE_THEORA}
+{$ENDIF}
+
+// Rus: включите/выключите нужные определения для ваших видеокарт. Это будет влиять на OpenGL, GLES, EGL.
+//      Как я понимаю, корпорации предоставляют разные реализации одних и тех же функций, по разному оптимизированными
+//      для определённых видеокарт. И, таким образом, мы можем создать сильно оптимизированныую программу, которая будет
+//      "сама выбирать" какую функцию использовать для данной видеокарты.
+//      Но, это сложно...
+// Eng: enable/disable the necessary definitions for your graphics cards. This will affect OpenGL, GLES, EGL.
+//      As I understand it, corporations provide different implementations of the same functions, optimized differently
+//      for certain video cards. And thus, we can create a highly optimized program that will "select" which function
+//      to use for a given video card.
+//      But it is difficult...
+{$DEFINE VID_NV}
+{$DEFINE VID_AMD}
+{$DEFINE VID_INTEL}
+{$DEFINE VID_APPLE}
+
+// Enable if you want to use zlib compression functions
+// WARNING: ZenGL doesn't provide all needed object files, you should use yours(just have no desire to recompile zlib for every platform)
+
+// Disable unsupported features
+{$IFNDEF FPC}
+  {$UNDEF USE_OGG_STATIC}
+  {$UNDEF USE_THEORA_STATIC}
+{$ENDIF}
+
+// Specially for buggy Delphi, which trying to parse everything...
+{$MINENUMSIZE 4}
+{$DEFINE USE_INLINE}
+{$IFDEF FPC}
+  {$I zgl_fpc.cfg}
+
+  {$IFNDEF MACOSX}
+    {$IFDEF cpui386}
+      {$DEFINE USE_ASM}
+    {$ENDIF}
+  {$ENDIF}
+{$ELSE}
+  {$DEFINE USE_ASM}
+  {$WARN COMBINING_SIGNED_UNSIGNED OFF}
+  {$WARN COMPARING_SIGNED_UNSIGNED OFF}
+  {$IFNDEF DELPHI7_AND_DOWN}
+    {$DEFINE CPUx86_64}
+  {$ELSE}
+    {$DEFINE CPUi386}
+    {$UNDEF USE_INLINE}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFNDEF USE_INIT_HANDLE}
+  {$DEFINE WND_USE}
+{$ELSE}
+  {$IFDEF WINDOWS}
+    {$DEFINE WND_USE}
+  {$ENDIF}
+{$ENDIF}

Zengl_SRC/demos/Lazarus/19 - OpenGL33_01/demo19.lpi

@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+  <ProjectOptions>
+    <Version Value="12"/>
+    <General>
+      <Flags>
+        <SaveOnlyProjectUnits Value="True"/>
+        <MainUnitHasCreateFormStatements Value="False"/>
+        <MainUnitHasTitleStatement Value="False"/>
+        <MainUnitHasScaledStatement Value="False"/>
+        <CompatibilityMode Value="True"/>
+      </Flags>
+      <SessionStorage Value="InProjectDir"/>
+      <Title Value="demo19"/>
+      <ResourceType Value="res"/>
+      <UseXPManifest Value="True"/>
+      <Icon Value="0"/>
+    </General>
+    <i18n>
+      <EnableI18N LFM="False"/>
+    </i18n>
+    <BuildModes Count="2">
+      <Item1 Name="Release" Default="True"/>
+      <Item2 Name="Debug">
+        <CompilerOptions>
+          <Version Value="11"/>
+          <Target>
+            <Filename Value="demo19"/>
+          </Target>
+          <SearchPaths>
+            <IncludeFiles Value="$(ProjOutDir);../../../headers"/>
+            <OtherUnitFiles Value="../../../headers;../../../extra;../../../src;../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS)"/>
+            <UnitOutputDirectory Value="../tmp/$(TargetCPU)-$(TargetOS)"/>
+          </SearchPaths>
+          <Parsing>
+            <SyntaxOptions>
+              <SyntaxMode Value="Delphi"/>
+            </SyntaxOptions>
+          </Parsing>
+          <CodeGeneration>
+            <Checks>
+              <IOChecks Value="True"/>
+              <RangeChecks Value="True"/>
+              <OverflowChecks Value="True"/>
+              <StackChecks Value="True"/>
+            </Checks>
+            <VerifyObjMethodCallValidity Value="True"/>
+            <Optimizations>
+              <OptimizationLevel Value="0"/>
+            </Optimizations>
+          </CodeGeneration>
+          <Linking>
+            <Debugging>
+              <UseHeaptrc Value="True"/>
+            </Debugging>
+            <Options>
+              <Win32>
+                <GraphicApplication Value="True"/>
+              </Win32>
+            </Options>
+          </Linking>
+          <Other>
+            <Verbosity>
+              <ShowNotes Value="False"/>
+              <ShowHints Value="False"/>
+            </Verbosity>
+          </Other>
+        </CompilerOptions>
+      </Item2>
+    </BuildModes>
+    <PublishOptions>
+      <Version Value="2"/>
+    </PublishOptions>
+    <RunParams>
+      <FormatVersion Value="2"/>
+      <Modes Count="1">
+        <Mode0 Name="default"/>
+      </Modes>
+    </RunParams>
+    <Units Count="2">
+      <Unit0>
+        <Filename Value="demo19.lpr"/>
+        <IsPartOfProject Value="True"/>
+      </Unit0>
+      <Unit1>
+        <Filename Value="../../../../srcGL/zgl_matrix.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit1>
+    </Units>
+  </ProjectOptions>
+  <CompilerOptions>
+    <Version Value="11"/>
+    <Target>
+      <Filename Value="../../../bin/$(TargetCPU)-$(TargetOS)/demo19"/>
+    </Target>
+    <SearchPaths>
+      <IncludeFiles Value="$(ProjOutDir);../../../srcGEGL;../../../srcGL;../../../src;../../../srcGL/EGL;../../../srcGL/GLES"/>
+      <OtherUnitFiles Value="../../../src;../../../srcGEGL;../../../srcGL;../../../srcGL/EGL;../../../srcGL/GLES;../../../lib/zlib/$(TargetCPU)-$(TargetOS);../../../lib/zip/$(TargetCPU)-$(TargetOS);../../../lib/theora/$(TargetCPU)-$(TargetOS);../../../lib/ogg/$(TargetCPU)-$(TargetOS);../../../lib/msvcrt/$(TargetCPU);../../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../../lib/chipmunk/$(TargetCPU)-$(TargetOS)"/>
+      <UnitOutputDirectory Value="../tmp/$(TargetCPU)-$(TargetOS)"/>
+    </SearchPaths>
+    <Parsing>
+      <SyntaxOptions>
+        <SyntaxMode Value="Delphi"/>
+      </SyntaxOptions>
+    </Parsing>
+    <CodeGeneration>
+      <SmartLinkUnit Value="True"/>
+      <Optimizations>
+        <OptimizationLevel Value="3"/>
+      </Optimizations>
+    </CodeGeneration>
+    <Linking>
+      <Debugging>
+        <GenerateDebugInfo Value="False"/>
+        <DebugInfoType Value="dsDwarf2"/>
+        <StripSymbols Value="True"/>
+        <UseExternalDbgSyms Value="True"/>
+      </Debugging>
+      <LinkSmart Value="True"/>
+      <Options>
+        <Win32>
+          <GraphicApplication Value="True"/>
+        </Win32>
+      </Options>
+    </Linking>
+    <Other>
+      <Verbosity>
+        <ShowNotes Value="False"/>
+        <ShowHints Value="False"/>
+      </Verbosity>
+    </Other>
+  </CompilerOptions>
+  <Debugging>
+    <Exceptions Count="3">
+      <Item1>
+        <Name Value="EAbort"/>
+      </Item1>
+      <Item2>
+        <Name Value="ECodetoolError"/>
+      </Item2>
+      <Item3>
+        <Name Value="EFOpenError"/>
+      </Item3>
+    </Exceptions>
+  </Debugging>
+</CONFIG>

Zengl_SRC/demos/Lazarus/19 - OpenGL33_01/demo19.lpr

@@ -0,0 +1,300 @@
+program demo19;
+
+// RU: Этот файл содержит некоторые настройки(например использовать ли статическую компиляцию) и определения ОС под которую происходит компиляция.
+// EN: This file contains some options(e.g. whether to use static compilation) and defines of OS for which is compilation going.
+{$I zglCustomConfig.cfg}
+{$I zgl_config.cfg}
+
+{$IFDEF WINDOWS}
+  {$R *.res}
+{$ENDIF}
+
+uses
+  {$IFDEF UNIX}
+  cthreads,
+  {$ENDIF}
+  Math,
+  zgl_window,
+  zgl_screen,
+  zgl_timers,
+  zgl_utils,
+  zgl_types,
+  zgl_pasOpenGL,
+  zgl_opengl_all,
+  zgl_gltypeconst,
+  zgl_matrix,    // new
+  zgl_file,
+  zgl_log;
+
+const
+  _vertex = 0;
+  _color  = 1;
+
+var
+  DirApp  : UTF8String;
+  DirHome : UTF8String;
+  DirShader: UTF8String = {$IfNDef MAC_COCOA}'shaders/'{$EndIf};
+
+  TimeStart  : LongWord = 0;
+
+  // RU: переменная для хранения индекса юниформа.
+  // EN: variable to store the uniform index.
+  projMatrLoc: GLuint;
+  // RU: шейдер, вершинный шейдер, фрагментный шейдер.
+  // EN: shader, vertex shader, fragment shader.
+  shadProg, vertShad, fragShad: GLuint;
+  // RU: вершины (3 координаты).
+  // EN: vertices (3 coordinates).
+  verticesData: array[0..11] of Single = (-1, 0, -2, 1,
+                                          1, 0, -0.4, 1,
+                                          3, 1, -2, 1);
+  // RU: цветю.
+  // EN: color.
+  colorData: array[0..11] of Single    = (1, 0, 0, 1,
+                                          0, 1, 0, 1,
+                                          0, 0, 1, 1);
+  vao: GLuint;
+  vboHandles: array[0..1] of GLuint;
+
+// RU: создание VAO и VBO.
+// EN: creation of VAO and VBO.
+procedure createVBOAndVAO;
+begin
+  // RU: буферные объекты.
+  // EN: buffer objects.
+  glGenBuffers(2, @vboHandles);
+
+  // RU: Создаём объект массива вершин (для того чтоб при прорисовке этого не делать).
+  // EN: We create an object of an array of vertices (so that we don’t have to do this when drawing).
+  glGenVertexArrays(1, @vao);
+  // установим созданный VAO как текущий
+  glBindVertexArray(vao);
+
+  // RU: активируем массив вершинных атрибутов.
+  // EN: activate the array of vertex attributes.
+  glEnableVertexAttribArray(_vertex); // vertex
+  glEnableVertexAttribArray(_color);  // color
+
+  // RU: закрепить индекс 0 за буфером координат.
+  // EN: assign index 0 to the coordinate buffer.
+  glBindBuffer(GL_ARRAY_BUFFER, vboHandles[_vertex]);
+  // RU: заполнить буфер координат.      Это позволительно, ошибки не создаёт.
+  // EN: fill the coordinate buffer.     This is permissible and does not create errors.
+  glBufferData(GL_ARRAY_BUFFER, SizeOf(verticesData), @verticesData, GL_STATIC_DRAW);
+  glVertexAttribPointer(_vertex, 4, GL_FLOAT, GL_FALSE, 0, nil);
+
+  // RU: закрепить индекс 1 за буфером цвета.
+  // EN: assign index 1 to the color buffer.
+  glBindBuffer(GL_ARRAY_BUFFER, vboHandles[_color]);
+  // RU: заполнить буфер цвета.      Это позволительно, ошибки не создаёт.
+  // EN: fill the color buffer.      This is permissible and does not create errors.
+  glBufferData(GL_ARRAY_BUFFER, SizeOf(colorData), @colorData, GL_STATIC_DRAW);
+  glVertexAttribPointer(_color, 4, GL_FLOAT, GL_FALSE, 0, nil);
+end;
+
+// RU: определяем ViewPort для нашей программы.
+// EN: We define the ViewPort for our program.
+procedure UserSetViewPort;
+begin
+  // RU: вместо "zgl_Get(WINDOW_WIDTH)" и "zgl_Get(WINDOW_HEIGHT)" можно создать
+  //     константы для ширины и высоты окна и указать их во ViewPort.
+  // EN: Instead of "zgl_Get(WINDOW_WIDTH)" and "zgl_Get(WINDOW_HEIGHT)" you can
+  //     create constants for the width and height of the window and specify them
+  //     in the ViewPort.
+  glViewport(0, 0, zgl_Get(WINDOW_WIDTH), zgl_Get(WINDOW_HEIGHT));
+end;
+
+// RU: используем свою матрицу проекции.
+// EN: We use our projection matrix.
+procedure UserMode;
+begin
+  Matrix4_Perspective(45, zgl_Get(WINDOW_WIDTH) / zgl_Get(WINDOW_HEIGHT), 1, 100);
+  // glUseProgram(shadProg);        // это не обязательно в данном случае.
+  // RU: если данная переменная не используется в шейдере, то и вызов делать не будем.
+  // EN: if this variable is not used in the shader, then we will not make the call.
+  if projMatrLoc <> -1 then
+    glUniformMatrix4fv(projMatrLoc, 1, GL_FALSE, @projMatr);
+  // glUseProgram(0);             // это не обязательно в данном случае.
+end;
+
+// RU: Тут можно выполнять загрузку основных ресурсов и производить инициализацию
+//     начальных данных программы.
+// EN: Here you can load the main resources and initialize the initial program data.
+procedure Init;
+var
+  status: GLint;
+begin
+  // RU: создаём буфера и привязываем их к VAO.
+  // EN: we create buffers and bind them to VAO.
+  createVBOAndVAO;
+  // RU: создание шедерной программы и шейдеров.
+  // EN: creating a shader program and shaders.
+  shadProg := glCreateProgram;
+  vertShad := glCreateShader(GL_VERTEX_SHADER);
+  fragShad := glCreateShader(GL_FRAGMENT_SHADER);
+  // RU: загружаем шейдера, компилируем и делаем проверку успешно скомпилирован
+  //     шейдер или нет.
+  // EN: we load the shader, compile it and check whether the shader compiled
+  //     successfully or not.
+  if not LoadAndCreateShader(DirShader + 'first.vs', vertShad) or not LoadAndCreateShader(DirShader + 'first.fs', fragShad) then
+  begin
+    log_Add('Shader not loaded!!!');
+    zgl_Exit;
+  end;
+  // RU: присоединяем шейдера к программе.
+  // EN: We attach the shader to the program.
+  glAttachShader(shadProg, vertShad);
+  glAttachShader(shadProg, fragShad);
+  // RU: линкуем программу.
+  // EN: link the program.
+  glLinkProgram(shadProg);
+  // RU: проверяем статус линковки.
+  // EN: check the status of the link.
+  glGetProgramiv(shadProg, GL_LINK_STATUS, @status);
+  if status <> 1 then
+  begin
+    log_Add('Shader program not link!!!');
+    zgl_Exit;
+  end;
+  // RU: получаем юниформ-индекс projMatr из шейдерной программы.
+  // EN: get the uniform index projMatr from the shader program.
+  projMatrLoc := glGetUniformLocation(shadProg, 'projMatr');
+  // RU: проверяем, указана ли данная матрица в шейдере.
+  // EN: we check whether this matrix is specified in the shader.
+  if projMatrLoc <> -1 then
+  begin
+    // RU: это может быть не критичной ошибкой. Просто данный аргумент не
+    //     используется в шейдере или удалён из шейдера, как не используемый.
+    // EN: this may not be a critical error. It’s just that this argument is not
+    //     used in the shader or has been removed from the shader as not being used.
+    log_Add('projMatr not found in shader.');
+  end;
+
+  // RU: проверка корректности скомпилированной программы.
+  // EN: checking the correctness of the compiled program.
+  glValidateProgram(shadProg);
+  glGetProgramiv(shadProg, GL_VALIDATE_STATUS, @status);
+  if status <> 1 then
+  begin
+    log_Add('Shader program not validate!!!');
+    zgl_Exit;
+  end;
+
+  glDeleteShader(vertShad);
+  glDeleteShader(fragShad);
+
+  glUseProgram(shadProg);
+  zgl_Enable(DEPTH_BUFFER);
+  glDepthMask(GL_TRUE);
+  glDepthFunc(GL_LEQUAL);
+  glDepthRange(0.0, 1.0);
+end;
+
+procedure Draw;
+begin
+  // RU: Тут "рисуем" что угодно :)
+  // EN: Here "draw" anything :)
+  glClearDepth(1);
+  // glUseProgram(shadProg);             // это не обязательно в данном случае.
+  // glBindVertexArray(vao);             // это не обязательно в данном случае.
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+
+  // glUseProgram(0);                    // это не обязательно  в данном случае.
+end;
+
+procedure Update( dt : Double );
+begin
+  // RU: Эта функция наземенима для реализация плавного движения чего-либо, т.к. точность таймеров ограничена FPS.
+  // EN: This function is the best way to implement smooth moving of something, because accuracy of timers are restricted by FPS.
+end;
+
+// RU: Пример использования таймера.
+// EN: An example of using a timer.
+procedure Timer;
+begin
+  // RU: Будем в заголовке показывать количество кадров в секунду.
+  // EN: Caption will show the frames per second.
+  wnd_SetCaption( 'test OpenGL 3.3. [ FPS: ' + u_IntToStr( zgl_Get( RENDER_FPS ) ) + ' ]' );
+end;
+
+procedure KeyMouseEvent;
+begin
+  // RU: Функция обработки клавиатуры, мыши, джойстика и тачпада. Все события связанные с ними очищаются после её обработки.
+  //     Все попытки обработать клавиатуру, мышь или тачпад в других функциях могут привести к непредвиденным ситуациям.
+  // EN: Keyboard, mouse, joystick and touchpad handling function. All events associated with them are cleared after processing it.
+  //     Any attempt to handle the keyboard, mouse, or touchpad in other functions may lead to unexpected situations.
+end;
+
+procedure Quit;
+begin
+  // RU: События которые надо произвести по завершению программы. Очистка данных.
+  // EN: Events to be performed at the end of the program.
+  // это нужно или нет?
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glDeleteBuffers(2, @vboHandles);
+  glBindVertexArray(0);
+  glDeleteVertexArrays(1, @vao);
+
+  glUseProgram(0);
+
+  glDeleteProgram(shadProg);
+end;
+
+Begin
+  // RU: Для загрузки/создания каких-то своих настроек/профилей/etc. можно получить путь к домашенему каталогу пользователя, или к исполняемому файлу(не работает для GNU/Linux).
+  // EN: For loading/creating your own options/profiles/etc. you can get path to user home directory, or to executable file(not works for GNU/Linux).
+  DirApp  := utf8_Copy( PAnsiChar( zgl_Get( DIRECTORY_APPLICATION ) ) );
+  DirHome := utf8_Copy( PAnsiChar( zgl_Get( DIRECTORY_HOME ) ) );
+
+  // RU: Устанавливаем интервал на обработку событий клавиатуры, мыши, тачпада. И регистрируем процедуру.
+  //     Вызывать zgl_SetEventInterval не обязательно. Значение 16 стоит по умолчанию.
+  // EN: We set the interval for processing keyboard, mouse, touchpad events. And we register the procedure.
+  //     Calling zgl_SetEventInterval is optional. The default is 16.
+  zgl_SetEventsInterval(16);
+  zgl_Reg(SYS_EVENTS, @KeyMouseEvent);
+
+  // RU: Создаем таймер с интервалом 1000мс.
+  // EN: Create a timer with interval 1000ms.
+  TimeStart := timer_Add( @Timer, 1000, t_Start );
+
+  // RU: Регистрируем процедуру, что выполнится сразу после инициализации ZenGL.
+  // EN: Register the procedure, that will be executed after ZenGL initialization.
+  zgl_Reg( SYS_LOAD, @Init );
+  // RU: Регистрируем процедуру, где будет происходить рендер.
+  // EN: Register the render procedure.
+  zgl_Reg( SYS_DRAW, @Draw );
+  // RU: Регистрируем процедуру, которая будет принимать разницу времени между кадрами.
+  // EN: Register the procedure, that will get delta time between the frames.
+  zgl_Reg( SYS_UPDATE, @Update );
+  // RU: Регистрируем процедуру, которая выполнится после завершения работы ZenGL.
+  // EN: Register the procedure, that will be executed after ZenGL shutdown.
+  zgl_Reg( SYS_EXIT, @Quit );
+  // RU: пользовательский ViewPort. В данном случае это не обязательно.
+  // EN: custom ViewPort. In this case it is not necessary.
+  zgl_Reg(OGL_VIEW_PORT, @UserSetViewPort);
+  // RU: пользовательский режим 2d или 3d.
+  // EN: custom 2d or 3d mode.
+  zgl_Reg(OGL_USER_MODE, @UserMode);
+
+  // RU: Устанавливаем заголовок окна.
+  // EN: Set the caption of the window.
+  wnd_SetCaption(utf8_Copy('01 - Initialization'));
+  // RU: Разрешаем курсор мыши. True - по умолчанию, значит определять не надо.
+  // EN: Allow to show the mouse cursor. True - by default, which means there is no need to define it.
+  wnd_ShowCursor( TRUE );
+
+  // RU: Указываем первоначальные настройки.
+  // EN: Set screen options.
+  zgl_SetParam(800, 600, false, false);
+
+  {$IfDef GL_VERSION_3_0}
+  // RU: Устанавливаем контекст OpenGL 3.3. Для этого надо включить  дефайн "USE_GL_33" и отключить "USE_MIN_OPENGL" в GLdefine.cfg.
+  // EN: Setting context OpenGL 3.3. To do this, enable the "USE_GL_33" define and disable "USE_MIN_OPENGL" in GLdefine.cfg.
+  SetGLVersionAndFlags(3, 3);
+  {$EndIf}
+
+  // RU: Инициализируем ZenGL.
+  // EN: Initialize ZenGL.
+  zgl_Init();
+End.
+

Zengl_SRC/demos/Lazarus/19 - OpenGL33_01/demo19.lps

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+  <ProjectSession>
+    <Version Value="12"/>
+    <BuildModes Active="Release"/>
+    <Units Count="2">
+      <Unit0>
+        <Filename Value="demo19.lpr"/>
+        <IsPartOfProject Value="True"/>
+        <IsVisibleTab Value="True"/>
+        <TopLine Value="206"/>
+        <CursorPos X="49" Y="284"/>
+        <UsageCount Value="207"/>
+        <Loaded Value="True"/>
+        <DefaultSyntaxHighlighter Value="Delphi"/>
+      </Unit0>
+      <Unit1>
+        <Filename Value="../../../../srcGL/zgl_matrix.pas"/>
+        <IsPartOfProject Value="True"/>
+        <EditorIndex Value="-1"/>
+        <CursorPos X="20" Y="8"/>
+        <UsageCount Value="218"/>
+        <DefaultSyntaxHighlighter Value="Delphi"/>
+      </Unit1>
+    </Units>
+    <RunParams>
+      <FormatVersion Value="2"/>
+      <Modes ActiveMode="default"/>
+    </RunParams>
+  </ProjectSession>
+</CONFIG>

Zengl_SRC/headers/backup/zglCustomConfig.cfg.bak → Zengl_SRC/demos/Lazarus/19 - OpenGL33_01/zglCustomConfig.cfg

@@ -1,4 +1,4 @@
-// Выставляем в постоянную компиляцию без собранных библиотек, с скомпилированными библиотеками наа данный момент можно использовать версию 3.12
+// Выставляем в постоянную компиляцию без собранных библиотек, с скомпилированными библиотеками на данный момент можно использовать версию 3.12
 {$DEFINE USE_ZENGL_STATIC}
 
 // RU: Использовать статическую компиляцию с библиотекой Chipmunk. Возможно только для FreePascal
@@ -23,16 +23,6 @@
     {$DEFINE MACOSX}
   {$IFEND}
 {$ENDIF}
-// это оставил для возможности собирать из-под линукса для андроид, хотя может и не нужно было
-{$IF DEFINED(LINUX) and DEFINED(CPUARM)}
-  {$DEFINE ANDROID}
-{$IFEND}
-
-// мобильные платформы
-// mobile
-{$IF DEFINED(ANDROID) OR DEFINED(iOS) OR DEFINED(iPHONESIM)}
-  {$DEFINE MOBILE}
-{$IFEND}
 
 // RU: Ограничения.
 // EN: Restrictions.
@@ -47,10 +37,3 @@
 {$IFDEF ANDROID}
   {$DEFINE USE_CHIPMUNK_LINK}
 {$ENDIF}
-
-{$IFDEF MACOSX}
-  {$IFNDEF CPUi386}
-    {$UNDEF USE_CHIPMUNK_STATIC}
-    {$UNDEF USE_CHIPMUNK_LINK}
-  {$ENDIF}
-{$ENDIF}

Zengl_SRC/headers/backup/zgl_config.cfg.bak → Zengl_SRC/demos/Lazarus/19 - OpenGL33_01/zgl_config.cfg

@@ -40,6 +40,7 @@
   {$ENDIF}
 {$ENDIF}
 
+// Переделать!
 {$IF DEFINED(DARWIN) AND (NOT DEFINED(iOS) OR NOT DEFINED(iPHONESIM))}
   {$IFNDEF CPUi386 }
     {$DEFINE MAC_COCOA}
@@ -64,7 +65,13 @@
 // Escape = exit
 {$DEFINE USE_EXIT_ESCAPE}
 
-// Defines for GNU/Linux
+// Rus: включаем события очистки клавиатуры, мыши, джойстика и тачпада.
+// Eng:
+{$DEFINE CLEAR_STATE}
+
+//******************************************************************************
+//       Defines for GNU/Linux
+//******************************************************************************
 {$IFDEF LINUX}
   // custom -----------------
   {$DEFINE USE_OGG_STATIC}
@@ -77,13 +84,24 @@
   {$DEFINE USE_VORBIS}
 
   {.$DEFINE USE_FULL_GLX}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {.$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    // на данный момент ни где не используется. Но, надо знать, данное определение есть для стационарных компьютеров.
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
 {$ENDIF}
 
+//******************************************************************************
+//       Defines for Android
+//******************************************************************************
 {$IFDEF ANDROID}
 // Rus: если вы будете использовать (ARM v5) или (ARM v6) отключите DEFINE CPUARMV7A.
 // Eng: if you will be using (ARM v5) or (ARM v6) disable DEFINE CPUARMV7A.
   {$IFNDEF CPU64}
-    {.$DEFINE CPUARMV7A}
+    {$DEFINE CPUARMV7A}
   {$ENDIF}
   {$IF DEFINED(CPU64) OR DEFINED(CPUARMV7A) or DEFINED(CPUi386) or DEFINED(CPUx86_64)}
     {$DEFINE NOT_OLD_ARM}   // старшие версии Anroid.
@@ -101,7 +119,9 @@
   {$UNDEF USE_INIT_HANDLE}
 {$ENDIF}
 
-// Defines for Windows and Windows Mobile
+//******************************************************************************
+//       Defines for Windows and Windows Mobile
+//******************************************************************************
 {$IFDEF MSWINDOWS}
   {$DEFINE WINDOWS}
 {$ENDIF}
@@ -115,9 +135,19 @@
 
   {$DEFINE USE_VORBIS}
   {.$DEFINE USE_FULL_WGL}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
 {$ENDIF}
 
+//******************************************************************************
 // Defines for MacOS X and iOS
+//******************************************************************************
+// Переделать!
 {$IFDEF DARWIN}
   // custom -----------------
   {/$DEFINE USE_OGG_STATIC}
@@ -145,21 +175,25 @@
     {$ENDIF}
   {$ELSE}
     {$DEFINE MACOSX}
+    // OpenGL ES render for PC
+    {.$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {$IFDEF USE_GLES}
+      {.$DEFINE USE_GLES_ON_DESKTOP}
+    {$ENDIF}
   {$IFEND}
 {$ENDIF}
+//******************************************************************************
 
-// OpenGL ES render for PC
-{.$DEFINE USE_GLES}
-
-{$IFDEF WINDOWS}
-  {$UNDEF USE_GLES}
-{$ENDIF}
-{$IFDEF USE_GLES}
-  // эта часть на AMD не работает
-  {.$DEFINE USE_GLES_ON_DESKTOP}
-  {$IFDEF USE_GLES_ON_DESKTOP}
-    {.$DEFINE USE_AMD_DRIVERS}
-  {$ENDIF}
+{$IFNDEF USE_GLES}
+  // Rus: Включите необходимые вам флаги!
+  // Eng: Turn on the flags you need!
+  {.$DEFINE USE_GL_21}
+  {$DEFINE USE_GL_33}
+  {.$DEFINE USE_GL_46}
+  {$I GLdefine.cfg}
+{$ELSE}
+  {$I gles_conf.cfg}
 {$ENDIF}
 
 // Functionality
@@ -182,10 +216,24 @@
   {$DEFINE USE_THEORA}
 {$ENDIF}
 
+// Rus: включите/выключите нужные определения для ваших видеокарт. Это будет влиять на OpenGL, GLES, EGL.
+//      Как я понимаю, корпорации предоставляют разные реализации одних и тех же функций, по разному оптимизированными
+//      для определённых видеокарт. И, таким образом, мы можем создать сильно оптимизированныую программу, которая будет
+//      "сама выбирать" какую функцию использовать для данной видеокарты.
+//      Но, это сложно...
+// Eng: enable/disable the necessary definitions for your graphics cards. This will affect OpenGL, GLES, EGL.
+//      As I understand it, corporations provide different implementations of the same functions, optimized differently
+//      for certain video cards. And thus, we can create a highly optimized program that will "select" which function
+//      to use for a given video card.
+//      But it is difficult...
+{$DEFINE VID_NV}
+{$DEFINE VID_AMD}
+{$DEFINE VID_INTEL}
+{$DEFINE VID_APPLE}
+
 // Enable if you want to use zlib compression functions
 // WARNING: ZenGL doesn't provide all needed object files, you should use yours(just have no desire to recompile zlib for every platform)
 
-
 // Disable unsupported features
 {$IFNDEF FPC}
   {$UNDEF USE_OGG_STATIC}

Zengl_SRC/headers/zgl_config.cfg

@@ -1,5 +1,5 @@
-// мобильные платформы
-// mobile
+// Rus: мобильные платформы - Android, iOS, iPhone.
+// Eng: mobile platform - Android, iOS, iPhone.
 {$IF DEFINED(ANDROID) OR DEFINED(iOS) OR DEFINED(iPHONESIM)}
   {$DEFINE MOBILE}
 {$IFEND}
@@ -40,6 +40,7 @@
   {$ENDIF}
 {$ENDIF}
 
+// Переделать!
 {$IF DEFINED(DARWIN) AND (NOT DEFINED(iOS) OR NOT DEFINED(iPHONESIM))}
   {$IFNDEF CPUi386 }
     {$DEFINE MAC_COCOA}
@@ -64,7 +65,9 @@
 // Escape = exit
 {$DEFINE USE_EXIT_ESCAPE}
 
-// Defines for GNU/Linux
+//******************************************************************************
+//       Defines for GNU/Linux
+//******************************************************************************
 {$IFDEF LINUX}
   // custom -----------------
   {$DEFINE USE_OGG_STATIC}
@@ -77,8 +80,21 @@
   {$DEFINE USE_VORBIS}
 
   {.$DEFINE USE_FULL_GLX}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {.$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    // на данный момент ни где не используется. Но, надо знать, данное определение есть для стационарных компьютеров.
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ELSE}
+    {$DEFINE NO_EGL}
+  {$ENDIF}
 {$ENDIF}
 
+//******************************************************************************
+//       Defines for Android
+//******************************************************************************
 {$IFDEF ANDROID}
 // Rus: если вы будете использовать (ARM v5) или (ARM v6) отключите DEFINE CPUARMV7A.
 // Eng: if you will be using (ARM v5) or (ARM v6) disable DEFINE CPUARMV7A.
@@ -98,10 +114,11 @@
   {$UNDEF  USE_OGG_STATIC}
   {$UNDEF  USE_THEORA_STATIC}
   {$DEFINE USE_VKEYBOARD}
-  {$UNDEF USE_INIT_HANDLE}
 {$ENDIF}
 
-// Defines for Windows and Windows Mobile
+//******************************************************************************
+//       Defines for Windows and Windows Mobile
+//******************************************************************************
 {$IFDEF MSWINDOWS}
   {$DEFINE WINDOWS}
 {$ENDIF}
@@ -115,9 +132,19 @@
 
   {$DEFINE USE_VORBIS}
   {.$DEFINE USE_FULL_WGL}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
 {$ENDIF}
 
+//******************************************************************************
 // Defines for MacOS X and iOS
+//******************************************************************************
+// Переделать!
 {$IFDEF DARWIN}
   // custom -----------------
   {/$DEFINE USE_OGG_STATIC}
@@ -145,21 +172,36 @@
     {$ENDIF}
   {$ELSE}
     {$DEFINE MACOSX}
+    // OpenGL ES render for PC
+    {.$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {$IFDEF USE_GLES}
+      {.$DEFINE USE_GLES_ON_DESKTOP}
+    {$ENDIF}
   {$IFEND}
 {$ENDIF}
+//******************************************************************************
 
-// OpenGL ES render for PC
-{.$DEFINE USE_GLES}
-
-{$IFDEF WINDOWS}
+// Rus: окна созданные посредством LCL будут работать только с полным OpenGL. Если вам нужно будет решение для OpenGL ES, просьба оповестить меня об этом,
+//      пока отложу данное решение на потом, на очень далёкое "потом".
+// Eng: windows created with LCL will only work with full OpenGL. If you need a solution for OpenGL ES, please let me know while I put this solution aside
+//      for a very long time later.
+{$IFDEF USE_INIT_HANDLE}
   {$UNDEF USE_GLES}
+  {$DEFINE NO_EGL}
 {$ENDIF}
-{$IFDEF USE_GLES}
-  // эта часть на AMD не работает
-  {.$DEFINE USE_GLES_ON_DESKTOP}
-  {$IFDEF USE_GLES_ON_DESKTOP}
-    {.$DEFINE USE_AMD_DRIVERS}
-  {$ENDIF}
+
+// Rus: используем разные конфигурационные файлы для OpenGL и для OpenGL ES.
+// Eng: we use different configuration files for OpenGL and for OpenGL ES.
+{$IFNDEF USE_GLES}
+  // Rus: Включите необходимые вам флаги!
+  // Eng: Turn on the flags you need!
+  {.$DEFINE USE_GL_21}
+  {$DEFINE USE_GL_33}
+  {.$DEFINE USE_GL_46}
+  {$I GLdefine.cfg}
+{$ELSE}
+  {$I gles_conf.cfg}
 {$ENDIF}
 
 // Functionality
@@ -182,10 +224,24 @@
   {$DEFINE USE_THEORA}
 {$ENDIF}
 
+// Rus: включите/выключите нужные определения для ваших видеокарт. Это будет влиять на OpenGL, GLES, EGL.
+//      Как я понимаю, корпорации предоставляют разные реализации одних и тех же функций, по разному оптимизированными
+//      для определённых видеокарт. И, таким образом, мы можем создать сильно оптимизированныую программу, которая будет
+//      "сама выбирать" какую функцию использовать для данной видеокарты.
+//      Но, это сложно...
+// Eng: enable/disable the necessary definitions for your graphics cards. This will affect OpenGL, GLES, EGL.
+//      As I understand it, corporations provide different implementations of the same functions, optimized differently
+//      for certain video cards. And thus, we can create a highly optimized program that will "select" which function
+//      to use for a given video card.
+//      But it is difficult...
+{$DEFINE VID_NV}
+{$DEFINE VID_AMD}
+{$DEFINE VID_INTEL}
+{$DEFINE VID_APPLE}
+
 // Enable if you want to use zlib compression functions
 // WARNING: ZenGL doesn't provide all needed object files, you should use yours(just have no desire to recompile zlib for every platform)
 
-
 // Disable unsupported features
 {$IFNDEF FPC}
   {$UNDEF USE_OGG_STATIC}

Zengl_SRC/lib/theora/android/aarchv8a/yuv2bgr16tab.o

@@ -6,14 +6,17 @@
   - таймер для Android.
   - работа с частицами. Более показательная демка по работе с частицами.
   - добавление DX, Metal, Vulkan??? (DX8, DX9 - готовы, Andru уже всё сделал, но возможно нужна переработка?).
-  - добавление компиляции под Android x64. Решить проблему с новыми OGG.
-  	OGG, Vorbis новые есть, необходимо скомпилировать Theora. Но это видимо не совсем Theora, файлы лежат в ZenGL.
   - произвести вывод клавиатуры/джойстика для мобильных систем не зависимо от экранного массштабирования.
   - ??? поддержка множества языков... (по сути надо делать по запросу, для каждого языка, слишком много надо вводить новых данных для обработки).
   - произвести поддержку FPS в зависимости от того какой монитор определился. Для двух и более мониторов решать проблемы FPS при переносе окна с одного монитора на другой.
   
   - произвести поддержку двух мониторов. Определение и работа.
   
-  - проверить работу на Windows, MacOS. Корректировать если есть проблемы.
+  - проверить работу на MacOS. Корректировать если есть проблемы.
   - создать все необходимые динамические и статические библиотеки для MacOS.
   
+  - требуется введение отладочной информации, которую можно будет отключать, если программа проверена.
+  
+  - LCL проекты требуют корректировки при развёртывании окна во весь экран (только в Linux&?).
+
+  - определить интервал обработки событий клавиатуры, мыши, тачпада/тачскрина на самый минимальный таймер. Иначе могут быть проблемы с обработкой событий. Это вызовет задержки в программе (могут не срабатывать нажатия/отжатия).

Zengl_SRC/src/zgl_application.pas

@@ -33,7 +33,7 @@ unit zgl_application;
 interface
 uses
   {$IFDEF USE_X11}
-  X, XLib, XRandr
+  X, XLib, gegl_xrandr
   {$ENDIF}
   {$IFDEF WINDOWS}
   Windows, Messages
@@ -335,7 +335,8 @@ begin
   if not appPause Then
     INC(appFPSCount);
 
-  // это для работы с буферами после отрисовки
+  // Rus: это для работы с буферами после отрисовки.
+  // Eng: this is for dealing with buffers after rendering.
   if Assigned(app_PostPDraw) then
     app_PostPDraw;
 end;
@@ -399,8 +400,7 @@ begin
   if keysDown[K_ESCAPE] = True then
     if Assigned(app_PKeyEscape) then
       app_PKeyEscape
-    else
-    begin
+    else begin
       winOn := False;
       log_Add('Terminate program');
     end;
@@ -428,6 +428,7 @@ begin
     end;
   {$EndIf}
 
+  {$IfDef CLEAR_STATE}
   key_ClearState;
   mouse_ClearState;
   {$IFDEF USE_JOYSTICK}
@@ -436,6 +437,7 @@ begin
   {$IfDef MOBILE}
   touch_ClearState;
   {$EndIf}
+  {$EndIf}
 end;
 {$EndIf}
 

Zengl_SRC/src/zgl_file.pas

@@ -241,6 +241,10 @@ begin
   end;
 {$ENDIF}{$EndIf}
   Result := FileHandle <> FILE_ERROR;
+  {$IfDef FULL_LOGGING}
+  if not Result then
+    log_Add('File ' + FileName + 'not open!');
+  {$EndIf}
 end;
 
 function file_MakeDir(const Directory: UTF8String): Boolean;
@@ -254,7 +258,7 @@ begin
   {$ENDIF}
 
 {$IfDef UNIX}
-{$IfDef DARWIN}
+{$IfNDef DARWIN}
   Result := FpMkdir(filePath + Directory, MODE_MKDIR) = FILE_ERROR;
 {$ENDIF}
 {$EndIf}
@@ -266,6 +270,10 @@ begin
 {$IFDEF DARWIN}
   Result := FpMkdir(platform_GetRes(filePath + Directory), MODE_MKDIR) = FILE_ERROR;
 {$ENDIF}
+  {$IfDef FULL_LOGGING}
+  if not Result then
+    log_Add('Dirrectory ' + Directory + 'not create!');
+  {$EndIf}
 end;
 
 function file_Remove(const Name: UTF8String): Boolean;
@@ -290,10 +298,10 @@ begin
   {$ENDIF}
 
   if not file_Exists(Name) Then
-    begin
-      Result := FALSE;
-      exit;
-    end;
+  begin
+    Result := FALSE;
+    exit;
+  end;
 
 {$IfDef UNIX}{$IfNDef DARWIN}
   FpStat(filePath + Name, status);
@@ -355,6 +363,10 @@ begin
       {$IFDEF iOS}
       Result := iosFileManager.removeItemAtPath_error(utf8_GetNSString(platform_GetRes(filePath + Name)), error);
       {$ENDIF}
+  {$IfDef FULL_LOGGING}
+  if not Result then
+    log_Add('File ' + name + 'not remove!');
+  {$EndIf}
 end;
 
 function file_Exists(const Name: UTF8String): Boolean;
@@ -376,7 +388,6 @@ begin
   {$ENDIF}
 
 {$IfDef UNIX}{$IfNDef DARWIN}
-//  log_Add(filePath + Name);
   Result := FpStat(filePath + Name, status) = 0;
 {$ENDIF}{$EndIf}
 {$IFDEF WINDOWS}
@@ -390,6 +401,10 @@ begin
 {$IFDEF iOS}
   Result := iosFileManager.fileExistsAtPath(utf8_GetNSString(platform_GetRes(filePath + Name)));
 {$ENDIF}
+  {$IfDef FULL_LOGGING}
+  if not Result then
+    log_Add('File ' + name + 'not found!');
+  {$EndIf}
 end;
 
 function file_Seek(FileHandle: zglTFile; Offset, Mode: Integer): LongWord;

Zengl_SRC/src/zgl_opengl.pas

@@ -27,7 +27,6 @@ unit zgl_opengl;
 {$mode objfpc}  // delphi???
 {$EndIf}
 {$I zgl_config.cfg}
-{$I GLdefine.cfg}
 
 {$IfDef MAC_COCOA}
   {$modeswitch objectivec1}

Zengl_SRC/src/zgl_opengl_all.pas

@@ -21,7 +21,7 @@
  *  3. This notice may not be removed or altered from any
  *     source distribution.
 
- !!! modification from Serge - SSW 26.02.2022
+ !!! modification from Serge
 }
 unit zgl_opengl_all;
 
@@ -47,48 +47,15 @@ uses
 
 function InitGL: Boolean;
 procedure FreeGL;
+// В данную функцию мы можем завести проверку всех расширений. Но, надо будет
+// определяться какие расширения будут рабочими. Это надо перебрать всю
+// библиотеку OpenGL.
 function gl_GetProc(const Proc: UTF8String): Pointer;
 function gl_IsSupported(const Extension, SearchIn: UTF8String): Boolean;
 // Rus: проверка и загрузка расширений.
 // Eng:
 procedure gl_LoadEx;
 
-type
-  TVector2d = array[0..1] of double;
-  TVector2f = array[0..1] of single;
-  TVector2i = array[0..1] of longint;
-  TVector2s = array[0..1] of smallint;
-  TVector2b = array[0..1] of byte;
-
-  TVector3d = array[0..2] of double;
-  TVector3f = array[0..2] of single;
-  TVector3i = array[0..2] of longint;
-  TVector3s = array[0..2] of smallint;
-  TVector3b = array[0..2] of byte;
-
-  TVector4d = array[0..3] of double;
-  TVector4f = array[0..3] of single;
-  TVector4i = array[0..3] of longint;
-  TVector4s = array[0..3] of smallint;
-  TVector4b = array[0..3] of byte;
-
-  TMatrix3d = array[0..2] of TVector3d;
-  TMatrix3f = array[0..2] of TVector3f;
-  TMatrix3i = array[0..2] of TVector3i;
-  TMatrix3s = array[0..2] of TVector3s;
-  TMatrix3b = array[0..2] of TVector3b;
-
-  TMatrix4d = array[0..3] of TVector4d;
-  TMatrix4f = array[0..3] of TVector4f;
-  TMatrix4i = array[0..3] of TVector4i;
-  TMatrix4s = array[0..3] of TVector4s;
-  TMatrix4b = array[0..3] of TVector4b;
-
-                              PGLvoid     = Pointer;
-  GLvoid     = Pointer;       PPGLvoid    = ^PGLvoid;
-  GLint64    = Int64;         PGLint64    = ^GLint64;
-  GLuint64   = UInt64;        PGLuint64   = ^GLuint64;
-
   function  glGetString(name: GLenum): PAnsiChar; stdcall; external libGL;            // GL_VERSION_1_0
   procedure glHint(target, mode: GLenum); stdcall; external libGL;                    // GL_VERSION_1_0
 
@@ -255,7 +222,7 @@ end;
 
 function gl_GetProc(const Proc: UTF8String): Pointer;
 var
-  s: String;
+  s: UTF8String;
 begin
   s := '';
   {$IFDEF WINDOWS}
@@ -291,6 +258,7 @@ begin
     Result := glXGetProcAddressARB(PAnsiChar(Proc));
   {$ENDIF}
   {$ENDIF}
+//  log_Add(Proc + s);
 end;
 
 // получение значения заголовка
@@ -302,6 +270,7 @@ begin
   Result := extPos > 0;
   if Result Then
     Result := ((extPos + Length(Extension) - 1) = Length(SearchIn)) or (SearchIn[extPos + Length(Extension)] = ' ');
+  // log_Add(Result);
 end;
 
 procedure gl_LoadEx;
@@ -373,15 +342,16 @@ begin
 
   // WaitVSync
 {$IFDEF LINUX}
-  glXSwapIntervalSGI := gl_GetProc('glXSwapIntervalSGI');
+  glXSwapIntervalSGI := gl_GetProc('glXSwapInterval');
+  if not Assigned(glXSwapIntervalSGI) then
+    glXSwapIntervalSGI := dlsym(oglLibrary, PAnsiChar('glXSwapIntervalSGI'));
   oglCanVSync        := Assigned(glXSwapIntervalSGI);
 {$ENDIF}
 {$IFDEF WINDOWS}
   wglSwapIntervalEXT := gl_GetProc('wglSwapInterval');
   oglCanVSync     := Assigned(wglSwapIntervalEXT);
 {$ENDIF}
-  if oglCanVSync Then
-    scr_VSync;
+  scr_VSync;
   log_Add('Support WaitVSync: ' + u_BoolToStr(oglCanVSync));
 end;
 

Zengl_SRC/src/zgl_opengles.pas

@@ -46,6 +46,9 @@ uses
   {$IFDEF iOS}
   iPhoneAll, CGGeometry,
   {$ENDIF}
+  {$IfNDef NO_EGL}
+  zgl_EGL,
+  {$EndIf}
   zgl_opengles_all;
 
 const
@@ -81,12 +84,7 @@ var
   oglExtensions   : UTF8String;
   ogl3DAccelerator: Boolean;
   oglCanVSync     : Boolean;
-  oglCanAnisotropy: Boolean;
-  oglCanPVRTC     : Boolean;
-  oglCanAutoMipMap: Boolean;
   oglCanFBO       : Boolean;
-  oglCanFBODepth24: Boolean;
-  oglCanFBODepth32: Boolean;
   oglCanPBuffer   : Boolean;
   oglMaxTexSize   : Integer;
   oglMaxFBOSize   : Integer;
@@ -124,6 +122,7 @@ uses
   zgl_window,
   zgl_gltypeconst,
   zgl_log,
+  zgl_gles,
   zgl_utils;
 
 function gles_GetErrorStr(ErrorCode: LongWord): UTF8String;
@@ -162,7 +161,11 @@ begin
 
   if not InitGLES() Then
   begin
+    {$IfNDef USE_GLES20}
     u_Error('Cannot load GLES libraries');
+    {$Else}
+    u_Error('not InitGLES for GLES 2.0');
+    {$EndIf}
     exit;
   end;
 
@@ -183,15 +186,16 @@ begin
   oglDisplay := eglGetDisplay(wndDC);
   {$ENDIF}
 
-  if oglDisplay = EGL_NO_DISPLAY Then
+  if oglDisplay = nil {EGL_NO_DISPLAY} Then
   begin
     log_Add('eglGetDisplay: EGL_DEFAULT_DISPLAY');
-    oglDisplay := eglGetDisplay(EGL_DEFAULT_DISPLAY);    // не работает...
+    oglDisplay := eglGetDisplay({$IfDef WINDOWS}0{$Else}nil{$EndIf});  // eglGetDisplay(EGL_DEFAULT_DISPLAY);    // не работает...
   end;
 
   if not eglInitialize(oglDisplay, @i, @j) Then
   begin
     u_Error('Failed to initialize EGL. Error code - ' + gles_GetErrorStr(eglGetError()));
+    // только ли для Windows?
     {$IFDEF WINDOWS}
     wnd_Destroy;
     {$ENDIF}
@@ -239,6 +243,10 @@ begin
       oglAttr[i + 1] := oglFSAA;
       INC(i, 2);
     end;
+    (* это можно сделать, но будет ли толк? *)
+    oglAttr[i] := EGL_RENDERABLE_TYPE;
+    oglAttr[i + 1] := EGL_OPENGL_ES2_BIT;
+    inc(i, 2);
     oglAttr[i] := EGL_NONE;
 
     log_Add('eglChooseConfig: zDepth = ' + u_IntToStr(oglzDepth) + '; ' + 'stencil = ' + u_IntToStr(oglStencil) + '; ' + 'fsaa = ' + u_IntToStr(oglFSAA) );
@@ -247,14 +255,16 @@ begin
     begin
       if oglFSAA = 0 Then
         break
-      else
-      begin
+      else begin
         oglzDepth := 24;
         DEC(oglFSAA, 2);
       end;
     end else
-      if j <> 1 Then DEC(oglzDepth, 8);
-    if oglzDepth = 0 Then oglzDepth := 1;
+      if j <> 1 Then
+        DEC(oglzDepth, 8);
+
+    if oglzDepth = 0 Then
+      oglzDepth := 1;
   until j = 1;
 
   Result := j = 1;
@@ -268,11 +278,14 @@ begin
   if oglReadPixelsFBO <> 0 Then
     glDeleteFramebuffers(1, @oglReadPixelsFBO);
 
+  if not Assigned(oglDisplay) then
+    exit;
 {$IFNDEF NO_EGL}
   {$IFDEF USE_X11}
   FreeMem(oglVisualInfo);
   {$ENDIF}
-  eglMakeCurrent(oglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+  // eglMakeCurrent(oglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+  eglMakeCurrent(oglDisplay, nil, nil, nil);
   eglTerminate(oglDisplay);
 {$ENDIF}
 {$IFDEF iOS}
@@ -289,9 +302,13 @@ begin
 end;
 
 function gl_Initialize: Boolean;
-  var
-    err: LongWord;
+var
+  err: LongWord;
+  {$IfDef USE_GLES20}
+  contAttr: array[0..7] of EGLint;
+  {$EndIf}
 begin
+//  Result := False;
 {$IFNDEF NO_EGL}
   oglSurface := eglCreateWindowSurface(oglDisplay, oglConfig, {@}wndHandle, nil);
   err := eglGetError();
@@ -300,10 +317,24 @@ begin
       u_Error('Cannot create Windows surface - ' + gles_GetErrorStr(err));
       exit;
     end;
+
+  {$IfDef USE_GLES20}
+  contAttr[0] := EGL_CONTEXT_CLIENT_VERSION;
+  contAttr[1] := 2;
+  // это работает с какими-то глюками? Я могу определить на ноутбуке только версию 1.1 и 3.0
+  contAttr[2] := EGL_CONTEXT_MAJOR_VERSION;
+  contAttr[3] := 2;
+  contAttr[4] := EGL_CONTEXT_MINOR_VERSION;
+  contAttr[5] := 0;
+  contAttr[6] := EGL_NONE;
+  oglContext := eglCreateContext(oglDisplay, oglConfig, nil, contAttr);
+  {$Else}
   oglContext := eglCreateContext(oglDisplay, oglConfig, nil, nil);
+  {$EndIf}
   err := eglGetError();
   if err <> EGL_SUCCESS Then
     begin
+      // EGL может вызывать ошибку в Linux при двух мониторах, но само приложение запускается.
       u_Error('Cannot create OpenGL ES context - ' + gles_GetErrorStr(err));
       exit;
     end;
@@ -362,7 +393,7 @@ begin
 
   glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, eglRenderbuffer);
 
-  {if oglCanFBODepth24 Then
+  {if GL_OES_depth24 Then
      oglzDepth := 24
   else
      oglzDepth := 16;
@@ -418,35 +449,45 @@ begin
   log_Add('GL_MAX_TEXTURE_SIZE: ' + u_IntToStr(oglMaxTexSize));
 
   glCompressedTexImage2D := gl_GetProc('glCompressedTexImage2D');
-  oglCanPVRTC := gl_IsSupported('GL_IMG_texture_compression_pvrtc', oglExtensions);
-  log_Add('GL_EXT_TEXTURE_COMPRESSION_PVRTC: ' + u_BoolToStr(oglCanPVRTC));
-
-  oglCanAutoMipMap := TRUE;
+  GL_IMG_texture_compression_pvrtc := gl_IsSupported('GL_IMG_texture_compression_pvrtc', oglExtensions);
+  log_Add('GL_IMG_texture_compression_pvrtc: ' + u_BoolToStr(GL_IMG_texture_compression_pvrtc));
 
   // Multitexturing
   glGetIntegerv(GL_MAX_TEXTURE_UNITS, @oglMaxTexUnits);
   log_Add('GL_MAX_TEXTURE_UNITS: ' + u_IntToStr(oglMaxTexUnits));
 
   // Anisotropy
-  oglCanAnisotropy := gl_IsSupported('GL_EXT_texture_filter_anisotropic', oglExtensions);
-  if oglCanAnisotropy Then
-    begin
-      glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @oglMaxAnisotropy);
-      oglAnisotropy := oglMaxAnisotropy;
-    end else
-      oglAnisotropy := 0;
-  log_Add('GL_EXT_TEXTURE_FILTER_ANISOTROPIC: ' + u_BoolToStr(oglCanAnisotropy));
+  GL_EXT_texture_filter_anisotropic := gl_IsSupported('GL_EXT_texture_filter_anisotropic', oglExtensions);
+  if GL_EXT_texture_filter_anisotropic Then
+  begin
+    glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @oglMaxAnisotropy);
+    oglAnisotropy := oglMaxAnisotropy;
+  end else
+    oglAnisotropy := 0;
+  log_Add('GL_EXT_texture_filter_anisotropic: ' + u_BoolToStr(GL_EXT_texture_filter_anisotropic));
   log_Add('GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: ' + u_IntToStr(oglMaxAnisotropy));
 
   glBlendEquation     := gl_GetProc('glBlendEquation');
   glBlendFuncSeparate := gl_GetProc('glBlendFuncSeparate');
-  oglSeparate := Assigned(glBlendEquation) and Assigned(glBlendFuncSeparate) and gl_IsSupported('GL_OES_blend_func_separate', oglExtensions);
+
+  {$IfDef USE_GLES20}
+  GL_OES_blend_func_separate := true;
+  {$Else}
+  GL_OES_blend_func_separate := gl_IsSupported('GL_OES_blend_func_separate', oglExtensions);
+  {$EndIf}
+  oglSeparate := Assigned(glBlendEquation) and Assigned(glBlendFuncSeparate) and GL_OES_blend_func_separate;
   log_Add('glBlendEquation: ' + u_BoolToStr(Assigned(glBlendEquation)));
   log_Add('glBlendFuncSeparate: ' + u_BoolToStr(Assigned(glBlendFuncSeparate)));
-  log_Add('GL_OES_BLEND_FUNC_SEPARATE: ' + u_BoolToStr(oglSeparate));
+  log_Add('GL_OES_blend_func_separate: ' + u_BoolToStr(GL_OES_blend_func_separate));
+  log_Add('oglSeparate: ' + u_BoolToStr(oglSeparate));
 
   // FBO
-  if gl_IsSupported('OES_framebuffer_object', oglExtensions) Then
+  {$IfDef USE_GLES20}
+  GL_OES_framebuffer_object := True;
+  {$Else}
+  GL_OES_framebuffer_object := gl_IsSupported('GL_OES_framebuffer_object', oglExtensions);
+  {$EndIf}
+  if GL_OES_framebuffer_object Then
   begin
     oglCanFBO                 := TRUE;
     glBindRenderbuffer        := gl_GetProc('glBindRenderbuffer'       );
@@ -472,8 +513,8 @@ begin
   end else
     oglCanFBO := FALSE;
 
-  oglCanFBODepth24 := gl_IsSupported('GL_OES_depth24', oglExtensions);
-  oglCanFBODepth32 := gl_IsSupported('GL_OES_depth32', oglExtensions);
+  GL_OES_depth24 := gl_IsSupported('GL_OES_depth24', oglExtensions);
+  GL_OES_depth32 := gl_IsSupported('GL_OES_depth32', oglExtensions);
   log_Add('GL_OES_FRAMEBUFFER_OBJECT: ' + u_BoolToStr(oglCanFBO));
 
   // WaitVSync

Zengl_SRC/src/zgl_render.pas

@@ -32,14 +32,14 @@ uses
   zgl_types,
   zgl_gltypeconst;
 
-// Rus: установки 2D режима.
-// Eng: 2D mode settings.
+// Rus: установки 2D режима. Для установки нужного режима используйте процедуру "SetCurrentMode".
+// Eng: 2D mode settings. Use the "SetCurrentMode" procedure to set the desired mode.
 procedure Set2DMode;
-// Rus: установки 3D режима.
-// Eng: 3D mode settings.
+// Rus: установки 3D режима. Для установки нужного режима используйте процедуру "SetCurrentMode".
+// Eng: 3D mode settings. Use the "SetCurrentMode" procedure to set the desired mode.
 procedure Set3DMode(FOVY: Single = 45);
-// Rus: выбор режима 2D, 3D или пользовательского.
-// Eng: select 2D, 3D or custom mode.
+// Rus: выбор режима 2D, 3D или пользовательского. Mode2D, Mode3D, ModeUser.
+// Eng: select 2D, 3D or custom mode. Mode2D, Mode3D, ModeUser.
 procedure SetCurrentMode(mode: LongWord = Mode2D);
 
 // Rus: установка глубины для 3D. То что будет за нулевой точкой (в минусе)
@@ -90,13 +90,6 @@ var
     {$Else}
     rsd0: Single = 0;
     rsd2: Single = 2;
-    {$IF DEFINED(USE_GLES_ON_DESKTOP) and DEFINED(USE_AMD_DRIVERS)}
-    rs0: Double = 0;
-    rs2: Double = 2;
-    {$Else}
-    rs0: Single = 0;
-    rs2: Single = 2;
-    {$IfEnd}
     {$EndIf}
   {$EndIf}
 
@@ -104,12 +97,8 @@ procedure Set2DMode;
 var
 {$IfNDef USE_GLES}
   scrLeft, scrRight, scrTop, scrBottom: Double;
-{$Else}
-{$IF DEFINED(USE_GLES_ON_DESKTOP) and DEFINED(USE_AMD_DRIVERS)}
-  scrLeft, scrRight, scrTop, scrBottom: Double;
 {$Else}
   scrLeft, scrRight, scrTop, scrBottom: Single;
-{$IfEnd}
 {$EndIf}
 begin
   oglMode := Mode2D;
@@ -173,7 +162,7 @@ begin
       scrTop := {$IfDef LINUX}rsd0{$Else}0{$EndIf};
       scrBottom := oglHeight;
     end;
-  {$IfDef USE_GLES} glOrthof{$Else}glOrtho{$EndIf}(scrLeft, scrRight, scrBottom, scrTop, scrNear, scrFar);
+  {$IfDef USE_GLES}glOrthof{$Else}glOrtho{$EndIf}(scrLeft, scrRight, scrBottom, scrTop, scrNear, scrFar);
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
@@ -223,8 +212,8 @@ begin
       Set3DMode(oglFOVY)
     else
       SetUserMode;
-  if Assigned(SetViewPort) then
-    SetViewPort;
+  if Assigned(scr_SetViewPort) then
+    scr_SetViewPort;
   scrViewPort := False;
 end;
 

Zengl_SRC/src/zgl_render_target.pas

@@ -35,7 +35,9 @@ uses
   {$ENDIF}
   {$IFDEF WINDOWS}
   Windows,
+  {$IfNDef USE_GLES}
   zgl_glx_wgl,
+  {$EndIf}
   {$ENDIF}
   {$IFDEF MACOSX}
 //  MacOSAll,       ???
@@ -106,6 +108,9 @@ uses
   zgl_sprite_2d,
   zgl_log,
   zgl_textures,
+  {$IfDef USE_GLES}
+  zgl_gles,
+  {$EndIf}
   zgl_utils;
 
 {$IFNDEF USE_GLES}
@@ -442,10 +447,10 @@ begin
             {$ELSE}
             if oglzDepth > 16 Then
               begin
-                if (oglzDepth = 32) and (oglCanFBODepth32) Then
+                if (oglzDepth = 32) and (GL_OES_depth32) Then
                   glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, Round(Surface.Width / Surface.U), Round(Surface.Height / Surface.V))
                 else
-                  if (oglzDepth = 24) and (oglCanFBODepth24) Then
+                  if (oglzDepth = 24) and (GL_OES_depth24) Then
                     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, Round(Surface.Width / Surface.U), Round(Surface.Height / Surface.V))
                   else
                     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, Round(Surface.Width / Surface.U), Round(Surface.Height / Surface.V));

Zengl_SRC/src/zgl_screen.pas

@@ -26,7 +26,6 @@
 unit zgl_screen;
 
 {$I zgl_config.cfg}
-{$I GLdefine.cfg}
 
 {$IF defined(iOS) or defined(MAC_COCOA)}
   {$modeswitch objectivec1}
@@ -36,14 +35,16 @@ interface
 
 uses
 {$IFDEF USE_X11}
-  X, XLib, XRandr, UnixType,      gdk2, gtk2,   // эти два возможно можно будет в дальнейшем удалить.
+  X, XLib, {gegl_}xrandr, UnixType,  //    gdk2, gtk2,   // эти два возможно можно будет в дальнейшем удалить.
   {$IfNDef USE_GLES}
   zgl_glx_wgl,
   {$EndIf}
 {$ENDIF}
 {$IFDEF WINDOWS}
   Windows,
+{$IfNDef USE_GLES}
   zgl_glx_wgl,
+  {$EndIf}
 {$ENDIF}
 {$IfDef MAC_COCOA}
   CocoaAll,
@@ -59,7 +60,7 @@ const
   REFRESH_DEFAULT = 1;
 
 var
-  SetViewPort: procedure;
+  scr_SetViewPort: procedure;
 
 {$IfNDef ANDROID}
 // Rus: инициализация окна.
@@ -128,7 +129,7 @@ procedure scr_ReadPixels(var pData: Pointer; X, Y, Width, Height: Word);
 //      что Far не должно быть меньше нуля.
 // Eng: depth setting for 2D mode. Can be used for 3D as well, given that Far
 //      must not be less than zero.
-procedure Set2DNearFar(newNear, newFar: {$IfNDef USE_GLES}Double{$Else}{$IF DEFINED(USE_GLES_ON_DESKTOP) and DEFINED(USE_AMD_DRIVERS)}Double{$Else}Single{$IfEnd}{$EndIf});
+procedure Set2DNearFar(newNear, newFar: {$IfNDef USE_GLES}Double{$Else}Single{$EndIf});
 {$IfDef GL_VERSION_3_0}
 // Rus: установка версии OpenGL, маски и флагов. Вызывать обязательно до
 //      создания окна (до zgl_Init)!!! Совместимые версии только до OpenGL 3.1,
@@ -238,42 +239,40 @@ var
   scrFar: Double = 1;
   scrNear: Double = - 1;
   {$Else}
-  {$IF DEFINED(USE_GLES_ON_DESKTOP) and DEFINED(USE_AMD_DRIVERS)}
-  scrFar: Double = 1;
-  scrNear: Double = - 1;
-  {$Else}
   scrFar: Single = 1;
   scrNear: Single = - 1;
-  {$IfEnd}
   {$EndIf}
 
-
 implementation
 uses
   zgl_application,
   zgl_window,
-  zgl_gltypeconst,
   {$IFNDEF USE_GLES}
+  zgl_gltypeconst,
   zgl_opengl,
   zgl_opengl_all,
   {$ELSE}
   zgl_opengles,
   zgl_opengles_all,
+  zgl_gles,
   {$ENDIF}
   zgl_render,
   zgl_render_2d,
   zgl_camera_2d,
   zgl_log,
+  {$IfNDef NO_EGL}
+  zgl_EGL,
+  {$EndIf}
   {$IfDef USE_VKEYBOARD}
   gegl_menu_gui,
   {$EndIf}
   zgl_utils;
 
-{$IFDEF USE_X11}
-function XOpenIM(para1:PDisplay; para2:PXrmHashBucketRec; para3:PAnsiChar; para4:Pchar):PXIM;cdecl;external;
+{$IFDEF USE_X11}     // вернуть, если будет работать с ошибкой работа с клавиатурой в Linux.
+{function XOpenIM(para1:PDisplay; para2:PXrmHashBucketRec; para3:PAnsiChar; para4:Pchar):PXIM;cdecl;external;
 function XCloseIM(im: PXIM): TStatus;cdecl;external;
 function XCreateIC(para1: PXIM; para2: array of const):PXIC;cdecl;external;
-procedure XDestroyIC(ic: PXIC);cdecl;external;
+procedure XDestroyIC(ic: PXIC);cdecl;external;}
 {$ENDIF}
 {$IFDEF WINDOWS}
 const
@@ -290,9 +289,9 @@ var
   tmpSettings: PXRRScreenSize;
   num_rates, j: Integer;
   rates: PSmallInt;
-  _sss1: PGdkScreen;
+//  _sss1: PGdkScreen;
   num_monitors: integer;
-  _rect: TGdkRectangle;
+//  _rect: TGdkRectangle;
   {$ENDIF}
   {$IFDEF WINDOWS}
   tmpSettings: DEVMODEW;
@@ -316,7 +315,7 @@ var
 begin
 {$IFDEF USE_X11}
 
-  // эторешение для GDK, меня интересует решение через Xrandr
+ { // это решение для GDK, меня интересует решение через Xrandr
   gtk_init(@argc, @argv);
  // log_Add('_0_');
   _sss1 := gdk_screen_get_default;
@@ -328,7 +327,120 @@ begin
     gdk_screen_get_monitor_geometry(_sss1, i, @_rect);
   //  log_Add('r.x = ' + u_IntToStr(_rect.x) + '   r.y = ' + u_IntToStr(_rect.y));
   //  log_Add('r.w = ' + u_IntToStr(_rect.width) + '   r.h = ' + u_IntToStr(_rect.height));
-  end;
+  end;      }
+
+(* !!! xrandr  !!!            --------------------------------------------------
+  Делаем подкачку ресурсов: XRRGetScreenResources   (надо ли делать XRRUpdateConfiguration???)
+    typedef struct _XRRScreenResources {
+        Time	timestamp;
+        Time	configTimestamp;
+        int		ncrtc;
+        RRCrtc	*crtcs;
+        int		noutput;
+        RROutput	*outputs;
+        int		nmode;
+        XRRModeInfo	*modes;
+    } XRRScreenResources;
+
+  получаем информацию о всех разрешениях: XRRGetOutputInfo
+    typedef struct _XRROutputInfo {
+        Time	    timestamp;
+        RRCrtc	    crtc;
+        char	    *name;
+        int		    nameLen;
+        unsigned long   mm_width;
+        unsigned long   mm_height;
+        Connection	    connection;
+        SubpixelOrder   subpixel_order;
+        int		    ncrtc;
+        RRCrtc	    *crtcs;
+        int		    nclone;
+        RROutput	    *clones;
+        int		    nmode;
+        int		    npreferred;
+        RRMode	    *modes;
+    } XRROutputInfo;
+
+        RRGetOutputInfo returns information about the current and available
+	configurations 'output'.
+
+	If 'config-timestamp' does not match the current configuration
+	timestamp (as returned by RRGetScreenResources), 'status' is set to
+	InvalidConfigTime and the remaining reply data is empty. Otherwise,
+	'status' is set to Success.
+
+	'timestamp' indicates when the configuration was last set.
+
+	'crtc' is the current source CRTC for video data, or Disabled if the
+	output is not connected to any CRTC.
+
+	'name' is a UTF-8 encoded string designed to be presented to the
+	user to indicate which output this is. E.g. "S-Video" or "DVI".
+
+	'connection' indicates whether the hardware was able to detect a
+	device connected to this output. If the hardware cannot determine
+	whether something is connected, it will set this to
+	UnknownConnection.
+
+	'subpixel-order' contains the resulting subpixel order of the
+	connected device to allow correct subpixel rendering.
+
+	'widthInMillimeters' and 'heightInMillimeters' report the physical
+	size of the displayed area. If unknown, or not really fixed (e.g.,
+	for a projector), these	values are both zero.
+
+	'crtcs' is the list of CRTCs that this output may be connected to.
+	Attempting to connect this output to a different CRTC results in a
+	Match error.
+
+	'clones' is the list of outputs which may be simultaneously
+	connected to the same CRTC along with this output. Attempting to
+	connect this output with an output not in the 'clones' list
+	results in a Match error.
+
+	'modes' is the list of modes supported by this output. Attempting to
+	connect this output to a CRTC not using one of these modes results
+	in a Match error.
+
+	The first 'num-preferred' modes in 'modes' are preferred by the
+	monitor in some way; for fixed-pixel devices, this would generally
+	indicate which modes match the resolution of the output device.
+
+
+        RRGetOutputInfo возвращает информацию о текущей и доступной конфигурации «выход».
+
+        Если «config-timestamp» не соответствует текущей временной метке конфигурации (возвращаемой RRGetScreenResources),
+        «status» устанавливается в InvalidConfigTime, а остальные данные ответа пусты. В противном случае «статус» устанавливается на «Успешно».
+
+        «метка времени» указывает, когда конфигурация была установлена в последний раз.
+
+        «crtc» — текущий источник CRTC для видеоданных или отключен, если выход не подключен ни к одному CRTC.
+
+        «имя» — это строка в кодировке UTF-8, предназначенная для представления пользователю, чтобы указать, какой это вывод. Например. «S-Video» или «DVI».
+
+        «connection» указывает, смогло ли оборудование обнаружить устройство, подключенное к этому выходу. Если оборудование не может определить,
+        подключено ли что-либо, оно установит для этого параметра значение UnknownConnection.
+
+        'subpixel-order' содержит результирующий порядок субпикселей подключенного устройства, обеспечивающий правильную рендеринг субпикселей.
+
+        'widthInMillimeters' и 'heightInMillimeters' сообщают физический размер отображаемой области. Если они неизвестны или не зафиксированы
+        (например, для проектора), оба эти значения равны нулю.
+
+        «crtcs» — это список CRTC, к которым может быть подключен этот выход. Попытка подключить этот выход к другому CRTC приводит к ошибке сопоставления.
+
+        «клоны» — это список выходов, которые могут быть одновременно подключены к одному и тому же CRTC вместе с этим выходом.
+        Попытка соединить этот выход с выходом, которого нет в списке «клонов», приводит к ошибке сопоставления.
+
+        «режимы» — это список режимов, поддерживаемых этим выходом. Попытка подключить этот выход к CRTC, не используя ни один из этих режимов,
+        приводит к ошибке сопоставления.
+
+        Первые «число предпочтительных» режимов в «режимах» каким-то образом являются предпочтительными для монитора; для устройств с
+        фиксированным пикселем это обычно указывает, какие режимы соответствуют разрешению устройства вывода.
+
+  используем данную информацию и очищаем данные: XRRFreeOutputInfo
+
+
+------------------------------------------------------------------------------*)
 
   scrModeList := XRRSizes(scrDisplay, 0, @scrModeCount);
   tmpSettings := scrModeList;
@@ -414,7 +526,6 @@ procedure scr_Init;
   {$endif}
 begin
 {$IFDEF USE_X11}
-
   if appInitialized or scrInitialized Then
     exit;
   log_Init();
@@ -430,10 +541,10 @@ begin
   end;
 
   scrDefault := DefaultScreen(scrDisplay);
-  wndRoot    := {Default}RootWindow(scrDisplay, 0);          // это первичный запрос окна     а вообще, ему пофиг дефолтный рут или нет.
+  wndRoot    := DefaultRootWindow(scrDisplay{, 0});          // это первичный запрос окна     а вообще, ему пофиг дефолтный рут или нет.
 
   XRRSelectInput(scrDisplay, wndRoot, RRScreenChangeNotifyMask); // остаётся вопрос, а нужно ли отправлять сообщение? Если мы его отправляем только при создании.
-//  XRRGetScreenInfo();
+
   if not (XRRQueryExtension(scrDisplay, @scrEventBase, @scrErrorBase)) then
   begin
     u_Error('Error: GLX extension not supported.');
@@ -924,14 +1035,14 @@ begin
     render2dClipYH := render2dClipY + render2dClipH;
   end;
 
-  glViewPort(scrViewportX, scrViewportY, scrViewportW, scrViewportH);
+  glViewport(scrViewportX, scrViewportY, scrViewportW, scrViewportH);
 end;
 
 procedure scr_SetVSync(WSync: Boolean);
 begin
   {$IfNDef USE_INIT_HANDLE}
-  if (useFPS > 60) and WSync then
-    scr_SetFPS(60);
+//  if (useFPS > 60) and WSync then
+//    scr_SetFPS(60);
   {$EndIf}
   scrVSync := WSync;
 end;
@@ -970,16 +1081,7 @@ end;
 {$IfNDef USE_INIT_HANDLE}
 procedure scr_SetFPS(FPS: LongWord);
 begin
-{  if FPS < 30 then
-    FPS := 30;
-  if (FPS <> 60) and (FPS <> 75) and (FPS <> 85) and (FPS <> 90) and (FPS <> 100) and (FPS <> 120) and (FPS <> 144) then
-    FPS := 60;     }
   useFPS := FPS;
-{  if useFPS > 60 then
-  begin
-    scrVSync := True;
-    scr_VSync;
-  end;}
   deltaFPS := 1000 / FPS;
 end;
 {$EndIf}
@@ -1010,7 +1112,7 @@ begin
   glReadPixels(X, oglHeight - Height - Y, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, pData);
 end;
 
-procedure Set2DNearFar(newNear, newFar: {$IfNDef USE_GLES}Double{$Else}{$IF DEFINED(USE_GLES_ON_DESKTOP) and DEFINED(USE_AMD_DRIVERS)}Double{$Else}Single{$IfEnd}{$EndIf});
+procedure Set2DNearFar(newNear, newFar: {$IfNDef USE_GLES}Double{$Else}Single{$EndIf});
 begin
   scrFar := newFar;
   scrNear := newNear;

Zengl_SRC/src/zgl_textures.pas

@@ -154,6 +154,7 @@ uses
   {$ELSE}
   zgl_opengles,
   zgl_opengles_all,
+  zgl_gles,
   {$ENDIF}
   zgl_render_2d,
   zgl_resources,
@@ -252,7 +253,7 @@ begin
   Result := FALSE;
 
   {$IFDEF USE_GLES}
-  if ((not oglCanPVRTC) and ((Texture.Format = TEX_FORMAT_RGBA_DXT1) or (Texture.Format = TEX_FORMAT_RGBA_DXT3) or (Texture.Format = TEX_FORMAT_RGBA_DXT5))) or
+  if ((not GL_IMG_texture_compression_pvrtc) and ((Texture.Format = TEX_FORMAT_RGBA_DXT1) or (Texture.Format = TEX_FORMAT_RGBA_DXT3) or (Texture.Format = TEX_FORMAT_RGBA_DXT5))) or
   {$ELSE}
   if ((not GL_EXT_texture_compression_s3tc) and ((Texture.Format = TEX_FORMAT_RGBA_PVR2) or (Texture.Format = TEX_FORMAT_RGBA_PVR4))) or
   {$ENDIF}
@@ -680,7 +681,7 @@ begin
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   end;
 
-  if {$IfNDef USE_GLES}GL_SGIS_generate_mipmap{$Else}oglCanAutoMipMap{$EndIf} Then
+  {$IfNDef USE_GLES}if GL_SGIS_generate_mipmap Then{$EndIf}
     glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, Byte(Flags and TEX_MIPMAP > 0));
 
   if Flags and TEX_MIPMAP > 0 Then
@@ -703,7 +704,7 @@ begin
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
           glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         end else
-          if (Flags and TEX_FILTER_TRILINEAR > 0) or ((not {$IfNDef USE_GLES}GL_EXT_texture_filter_anisotropic{$Else}oglCanAnisotropy{$EndIf}) and (Flags and TEX_FILTER_ANISOTROPY > 0)) Then
+          if (Flags and TEX_FILTER_TRILINEAR > 0) or ((not GL_EXT_texture_filter_anisotropic) and (Flags and TEX_FILTER_ANISOTROPY > 0)) Then
           begin
             Texture.Flags := Texture.Flags or TEX_FILTER_TRILINEAR;
             glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

Zengl_SRC/src/zgl_utils.pas

@@ -136,10 +136,10 @@ procedure u_Error(const ErrStr: UTF8String);
 procedure u_Warning(const ErrStr: UTF8String);
 
 // Rus: дополнение до ближайшего верхнего 2^n (2, 4, 8, 16, 32 и т. д.)
-// Eng:
+// Eng: complement to nearest upper 2^n (2, 4, 8, 16, 32, etc.)
 function u_GetPOT(Value: Integer): Integer;
 // Rus: задержка в милисекундах.
-// Eng:
+// Eng: delay in milliseconds.
 procedure u_Sleep(Milliseconds: LongWord);
 
 {$IFDEF UNIX}
@@ -153,6 +153,7 @@ function printf(format: PAnsiChar; const args: array of const): Integer; cdecl;
 
 {$ENDIF}
 {$IF DEFINED(LINUX) and DEFINED(CPUx86_64)}
+// GLIBC 2.14 слишком нов, поэтому замените memcpy реализацией Pascal через хак.       Требуется решение для этого или нет?
 // GLIBC 2.14 is too new, so replace memcpy with Pascal implementation via hack
 function memcpy(destination, source: Pointer; num: csize_t): Pointer; cdecl; public name 'memcpy';
 {$IFEND}

Zengl_SRC/src/zgl_window.pas

@@ -37,7 +37,7 @@ uses
   sysutils, BaseUnix,
   {$ENDIF}
   {$IFDEF USE_X11}
-  X, XLib, XUtil, xrandr,
+  X, XLib, XUtil, {gegl_}xrandr,
   {$ENDIF}
   {$IFDEF WINDOWS}
   Windows,
@@ -52,11 +52,11 @@ uses
   zgl_types;
 
 const
-  cs_ZenGL    = 'ZenGL - 0.4.0';
-  cs_Date     = '26.06.2023';
+  cs_ZenGL    = 'ZenGL - 0.4.1';
+  cs_Date     = '18.09.2023';
   cv_major    = 0;
   cv_minor    = 4;
-  cv_revision = 0;
+  cv_revision = 1;
 
   // zgl_Reg
   SYS_APP_INIT           = $000001;
@@ -224,7 +224,7 @@ procedure zgl_Init(FSAA: Byte = 0; StencilBits: Byte = 0);
 {$Else}
 // Rus: инициализация рабочего LCL-окна и запуск программы.
 // Eng: initialization of the working LCL window and launch of the program.
-procedure zgl_InitToHandle(Handle: Ptr; FSAA: Byte = 0; StencilBits: Byte = 0);
+function zgl_InitToHandle(Handle: Ptr; FSAA: Byte = 0; StencilBits: Byte = 0): Boolean;
 {$EndIf}
 {$IfNDef ANDROID}
 // Rus: установка основных путей для запущенного приложения.
@@ -236,7 +236,7 @@ procedure zgl_GetSysDir;
 procedure zgl_Destroy;
 // Rus: указываем программе на завершение работы.
 // Eng: tell the program to end.
-procedure zgl_Exit;
+procedure zgl_Exit; {$IfDef USE_INLINE}inline;{$EndIf}
 // Rus: регистрация функций для создания и работы приложения.
 // Eng: registration of functions for creation and operation of the application.
 procedure zgl_Reg(What: LongWord; UserData: Pointer);
@@ -268,9 +268,11 @@ procedure zgl_Enable(What: LongWord);
 // Eng: turn off ZenGL flags.
 procedure zgl_Disable(What: LongWord);
 {$IfNDef USE_INIT_HANDLE}
-// Rus: установка интервала обработки клавиатуры, мыши и др.
+// Rus: установка интервала обработки клавиатуры, мыши и др. Определяйте данный
+//      интервал не больше чем у самого малого рабочего таймера.
 //      Определять до создания окна!!!
-// Eng: setting the processing interval for the keyboard, mouse, etc.
+// Eng: setting the processing interval for the keyboard, mouse, etc. Determine
+//      this interval no more than that of the smallest working timer.
 //      Define before window creation!!!
 procedure zgl_SetEventsInterval(Interval: Cardinal);
 {$EndIf}
@@ -926,8 +928,8 @@ begin
     exit;
   end;
 
-  if not Assigned(SetViewPort) then
-    SetViewPort := scr_SetViewPort2D;
+  if not Assigned(scr_SetViewPort) then
+    scr_SetViewPort := scr_SetViewPort2D;
 
   appInitialized := TRUE;
 
@@ -974,8 +976,13 @@ begin
 end;
 
 {$Else}
-procedure zgl_InitToHandle(Handle: Ptr; FSAA: Byte = 0; StencilBits: Byte = 0);
+function zgl_InitToHandle(Handle: Ptr; FSAA: Byte = 0; StencilBits: Byte = 0): Boolean;
 begin
+  Result := False;
+  {$IfDef USE_GLES}
+  log_Add('GLES not work in LCL!!!');
+  exit;
+  {$EndIf}
   zgl_GetSysDir();
   log_Init();
 
@@ -1008,6 +1015,7 @@ begin
   app_PInit();
 
   appInitedToHandle := true;
+  Result := True;
 end;
 {$EndIf}
 
@@ -1181,9 +1189,9 @@ begin
     OGL_VIEW_PORT:
       begin
         if Assigned(UserData) then
-          SetViewPort := UserData
+          scr_SetViewPort := UserData
         else
-          SetViewPort := @scr_SetViewPort2D;
+          scr_SetViewPort := @scr_SetViewPort2D;
       end;
     {$IfNDef USE_INIT_HANDLE}
     SYS_EVENTS:
@@ -1332,7 +1340,7 @@ begin
     GAPI_MAX_TEXTURE_UNITS: Result := oglMaxTexUnits;
     GAPI_MAX_ANISOTROPY: Result := oglMaxAnisotropy;
     GAPI_CAN_BLEND_SEPARATE: Result := Ptr(oglSeparate);
-    GAPI_CAN_AUTOGEN_MIPMAP: Result := Ptr({$IfNDef USE_GLES}GL_SGIS_generate_mipmap{$Else}oglCanAutoMipMap{$EndIf});
+    {$IfNDef USE_GLES}GAPI_CAN_AUTOGEN_MIPMAP: Result := Ptr(GL_SGIS_generate_mipmap);{$EndIf}
 
     RENDER_FPS: Result := appFPS;
     RENDER_BATCHES_2D: Result := b2dBatches + 1;

Zengl_SRC/srcGEGL/gegl_VElements.pas

@@ -44,7 +44,9 @@ uses
   zgl_window;
 
 var
+  // менеджер элементов.
   managerSetOfTools: geglTSetOfToolsManager;
+  // указанный элемент и его флаги.
   propEl: geglPPropertElement;
 
 // Rus: создание поля ввода. Заданный прямоугольник; шрифт; размер шрифта;

Zengl_SRC/srcGEGL/gegl_types.pas

@@ -141,12 +141,13 @@ type
   // активен элемент или нет, существует или нет, выбран в данный момент или нет и многое другое.
   // этот менеджер содержит ссылки, на созданные элементы! И их надо обязательно уничтожать по окончанию работы программы!
 
+  // указатель на "свойства" элементов. "Наименование" элемента и его флаги.
   geglPPropertElement = ^geglTPropertElement;
-  // "свойства" элементов. "Наименование" элемента и его флаги
+  // "свойства" элементов. "Наименование" элемента и его флаги.
   geglTPropertElement = record
     Element: LongWord;                             // хватило бы и байта, но для нормальной работы надо ставить большую размерность
                                                    // соответствует общему количеству эл-тов, чтоб не  заходить в сам элемент
-    FlagsProp: LongWord;                           // флаги для свойств элемента, как минимум активен/не активен, существует/удалён
+    FlagsProp: LongWord;                           // флаги для свойств элемента, как минимум активен/не активен, существует/удалён.
   end;
 
   // обрабатывающий менеджер всех элементов, для этого нужна ссылка, на любой элемент

Zengl_SRC/srcGEGL/gegl_xrandr.pas

@@ -0,0 +1,702 @@
+unit gegl_xrandr;
+
+// для Unix с поддержкой Xrandr.
+
+
+// данный модуль может содержать ошибки!!!
+interface
+
+uses
+  x, xlib, ctypes, xrender;
+
+const
+  libXrandr = 'Xrandr';
+  RANDR_NAME                     = 'RANDR';
+  RANDR_MAJOR                    = 1;
+  RANDR_MINOR                    = 6;
+
+  RRNumberErrors                 = 5;
+  RRNumberEvents                 = 2;
+  RRNumberRequests               = 47;
+
+  X_RRQueryVersion               = 0;
+{ we skip 1 to make old clients fail pretty immediately }
+  X_RROldGetScreenInfo           = 1;
+  X_RR1_0SetScreenConfig         = 2;
+{ V1.0 apps share the same set screen config request id }
+  X_RRSetScreenConfig            = 2;
+  X_RROldScreenChangeSelectInput = 3;
+{ 3 used to be ScreenChangeSelectInput; deprecated }
+  X_RRSelectInput                = 4;
+  X_RRGetScreenInfo              = 5;
+
+  (* V1.2 additions *)
+  X_RRGetScreenSizeRange	 = 6;
+  X_RRSetScreenSize	         = 7;
+  X_RRGetScreenResources	 = 8;
+  X_RRGetOutputInfo	         = 9;
+  X_RRListOutputProperties       = 10;
+  X_RRQueryOutputProperty	 = 11;
+  X_RRConfigureOutputProperty    = 12;
+  X_RRChangeOutputProperty       = 13;
+  X_RRDeleteOutputProperty       = 14;
+  X_RRGetOutputProperty	         = 15;
+  X_RRCreateMode		 = 16;
+  X_RRDestroyMode		 = 17;
+  X_RRAddOutputMode	         = 18;
+  X_RRDeleteOutputMode	         = 19;
+  X_RRGetCrtcInfo		 = 20;
+  X_RRSetCrtcConfig	         = 21;
+  X_RRGetCrtcGammaSize	         = 22;
+  X_RRGetCrtcGamma	         = 23;
+  X_RRSetCrtcGamma	         = 24;
+
+(* V1.3 additions *)
+  X_RRGetScreenResourcesCurrent  = 25;
+  X_RRSetCrtcTransform	         = 26;
+  X_RRGetCrtcTransform	         = 27;
+  X_RRGetPanning		 = 28;
+  X_RRSetPanning		 = 29;
+  X_RRSetOutputPrimary	         = 30;
+  X_RRGetOutputPrimary	         = 31;
+
+  RRTransformUnit		 = 1 shl 0;
+  RRTransformScaleUp	         = 1 shl 1;
+  RRTransformScaleDown	         = 1 shl 2;
+  RRTransformProjective	         = 1 shl 3;
+
+(* v1.4 *)
+  X_RRGetProviders	         = 32;
+  X_RRGetProviderInfo	         = 33;
+  X_RRSetProviderOffloadSink     = 34;
+  X_RRSetProviderOutputSource    = 35;
+  X_RRListProviderProperties     = 36;
+  X_RRQueryProviderProperty      = 37;
+  X_RRConfigureProviderProperty  = 38;
+  X_RRChangeProviderProperty     = 39;
+  X_RRDeleteProviderProperty     = 40;
+  X_RRGetProviderProperty	 = 41;
+
+(* v1.5 *)
+  X_RRGetMonitors		 = 42;
+  X_RRSetMonitor		 = 43;
+  X_RRDeleteMonitor	         = 44;
+
+(* v1.6 *)
+  X_RRCreateLease		 = 45;
+  X_RRFreeLease		         = 46;
+
+(* Event selection bits *)
+  RRScreenChangeNotifyMask       = 1 shl 0;
+(* V1.2 additions *)
+  RRCrtcChangeNotifyMask	 = 1 shl 1;
+  RROutputChangeNotifyMask       = 1 shl 2;
+  RROutputPropertyNotifyMask     = 1 shl 3;
+(* V1.4 additions *)
+  RRProviderChangeNotifyMask     = 1 shl 4;
+  RRProviderPropertyNotifyMask   = 1 shl 5;
+  RRResourceChangeNotifyMask     = 1 shl 6;
+(* V1.6 additions *)
+  RRLeaseNotifyMask              = 1 shl 7;
+
+(* Event codes *)
+  RRScreenChangeNotify           = 0;
+(* V1.2 additions *)
+  RRNotify		         = 1;
+(* RRNotify Subcodes *)
+   RRNotify_CrtcChange	         = 0;
+   RRNotify_OutputChange	 = 1;
+   RRNotify_OutputProperty       = 2;
+   RRNotify_ProviderChange       = 3;
+   RRNotify_ProviderProperty     = 4;
+   RRNotify_ResourceChange       = 5;
+(* V1.6 additions *)
+   RRNotify_Lease                = 6;
+(* used in the rotation field; rotation and reflection in 0.1 proto. *)
+  RR_Rotate_0                    = 1;
+  RR_Rotate_90                   = 2;
+  RR_Rotate_180                  = 4;
+  RR_Rotate_270                  = 8;
+
+(* new in 1.0 protocol, to allow reflection of screen *)
+  RR_Reflect_X                   = 16;
+  RR_Reflect_Y                   = 32;
+
+  RRSetConfigSuccess             = 0;
+  RRSetConfigInvalidConfigTime	 = 1;
+  RRSetConfigInvalidTime	 = 2;
+  RRSetConfigFailed		 = 3;
+
+(* new in 1.2 protocol *)
+
+  RR_HSyncPositive               = $00000001;
+  RR_HSyncNegative               = $00000002;
+  RR_VSyncPositive               = $00000004;
+  RR_VSyncNegative               = $00000008;
+  RR_Interlace                   = $00000010;
+  RR_DoubleScan                  = $00000020;
+  RR_CSync                       = $00000040;
+  RR_CSyncPositive               = $00000080;
+  RR_CSyncNegative               = $00000100;
+  RR_HSkewPresent                = $00000200;
+  RR_BCast                       = $00000400;
+  RR_PixelMultiplex              = $00000800;
+  RR_DoubleClock                 = $00001000;
+  RR_ClockDivideBy2              = $00002000;
+
+  RR_Connected                   = 0;
+  RR_Disconnected                = 1;
+  RR_UnknownConnection           = 2;
+
+  BadRROutput                    = 0;
+  BadRRCrtc                      = 1;
+  BadRRMode                      = 2;
+  BadRRProvider                  = 3;
+  BadRRLease                     = 4;
+
+(* Conventional RandR output properties *)
+
+  RR_PROPERTY_BACKLIGHT          = 'Backlight';
+  RR_PROPERTY_RANDR_EDID         = 'EDID';
+  RR_PROPERTY_SIGNAL_FORMAT      = 'SignalFormat';
+  RR_PROPERTY_SIGNAL_PROPERTIES  = 'SignalProperties';
+  RR_PROPERTY_CONNECTOR_TYPE     = 'ConnectorType';
+  RR_PROPERTY_CONNECTOR_NUMBER   = 'ConnectorNumber';
+  RR_PROPERTY_COMPATIBILITY_LIST = 'CompatibilityList';
+  RR_PROPERTY_CLONE_LIST         = 'CloneList';
+  RR_PROPERTY_BORDER             = 'Border"';
+  RR_PROPERTY_BORDER_DIMENSIONS  = 'BorderDimensions';
+  RR_PROPERTY_GUID               = 'GUID';
+  RR_PROPERTY_RANDR_TILE         = 'TILE';
+  RR_PROPERTY_NON_DESKTOP        = 'non-desktop';
+
+(* roles this device can carry out *)
+  RR_Capability_None             = 0;
+  RR_Capability_SourceOutput     = 1;
+  RR_Capability_SinkOutput       = 2;
+  RR_Capability_SourceOffload    = 4;
+  RR_Capability_SinkOffload      = 8;
+
+
+type
+  PRotation      = ^TRotation;
+  TRotation      = cushort;
+  TConnection    = cushort;
+  PSizeID        = ^TSizeID;
+  TSizeID        = cushort;
+  PSubpixelOrder = ^TSubpixelOrder;
+  TSubpixelOrder = cushort;
+
+  PAtom = ^TAtom;
+  pbyte = ^byte;
+  PChar = ^char;
+  PDisplay = ^TDisplay;
+  Pdword = ^dword;
+  Plongint = ^longint;
+  PRROutput = ^RROutput;
+  RROutput = TXID;
+  PRRCrtc = ^RRCrtc;
+  RRCrtc = TXID;
+  PRRMode = ^RRMode;
+  RRMode = TXID;
+  PRRProvider = ^RRProvider;
+  RRProvider = TXID;
+  Psmallint = ^smallint;
+  PTime = ^TTime;
+  PXEvent = ^TXEvent;
+  PXFixed = ^XFixed;
+  XFixed = LongInt;
+
+  PXTransform = ^TXTransform;
+(* взято из нового Xrender, из файла Xrender.h
+  typedef struct _XTransform {
+    XFixed matrix[3][3];
+} XTransform;    *)
+  TXTransform = record
+    matrix: array[0..2] of array[0..2] of XFixed;
+  end;
+
+
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+
+  {
+   * Copyright © 2000 Compaq Computer Corporation, Inc.
+   * Copyright © 2002 Hewlett-Packard Company, Inc.
+   * Copyright © 2006 Intel Corporation
+   * Copyright © 2008 Red Hat, Inc.
+   *
+   * Permission to use, copy, modify, distribute, and sell this software and its
+   * documentation for any purpose is hereby granted without fee, provided that
+   * the above copyright notice appear in all copies and that both that copyright
+   * notice and this permission notice appear in supporting documentation, and
+   * that the name of the copyright holders not be used in advertising or
+   * publicity pertaining to distribution of the software without specific,
+   * written prior permission.  The copyright holders make no representations
+   * about the suitability of this software for any purpose.  It is provided "as
+   * is" without express or implied warranty.
+   *
+   * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+   * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+   * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+   * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+   * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+   * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+   * OF THIS SOFTWARE.
+   *
+   * Author:  Jim Gettys, HP Labs, Hewlett-Packard, Inc.
+   *      Keith Packard, Intel Corporation
+    }
+
+{.$include <X11/extensions/randr.h>}
+{.$include <X11/extensions/Xrender.h>}
+{.$include <X11/Xfuncproto.h>}
+
+
+type
+  PXRRScreenSize = ^TXRRScreenSize;
+  TXRRScreenSize = record
+    Width: longint;
+    Height: longint;
+    mwidth: longint;
+    mheight: longint;
+  end;
+
+    {*  Events. }
+
+  TXRRScreenChangeNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool ;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    root: TWindow;                            { Root window for changed screen  }
+    timestamp: TTime;                         { when the screen change occurred  }
+    config_timestamp: TTime;                  { when the last configuration change  }
+    size_index: TSizeID;
+    subpixel_order: TSubpixelOrder;
+    rotation: TRotation;
+    Width: longint;
+    Height: longint;
+    mwidth: longint;
+    mheight: longint;
+  end;
+
+  TXRRNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_ subtype  }
+  end;
+
+  TXRROutputChangeNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_OutputChange  }
+    output: RROutput;                        { affected output  }
+    crtc: RRCrtc;                            { current crtc (or None)  }
+    mode: RRMode;                            { current mode (or None)  }
+    rotation: TRotation;                     { current rotation of associated crtc  }
+    connection: TConnection;                  { current connection status  }
+    subpixel_order: TSubpixelOrder;
+  end;
+
+  TXRRCrtcChangeNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_CrtcChange  }
+    crtc: RRCrtc;                            { current crtc (or None)  }
+    mode: RRMode;                            { current mode (or None)  }
+    rotation: TRotation;                     { current rotation of associated crtc  }
+    x: longint;                              { position  }
+    y: longint;
+    Width: dword;                            { size  }
+    Height: dword;
+  end;
+
+  TXRROutputPropertyNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_OutputProperty  }
+    output: RROutput;                        { related output  }
+    _property: TAtom;                        { changed property  }
+    timestamp: TTime;                         { time of change  }
+    state: longint;                          { NewValue, Deleted  }
+  end;
+
+  TXRRProviderChangeNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_ProviderChange  }
+    provider: RRProvider;                    { current provider (or None)  }
+    timestamp: TTime;                         { time of change  }
+    current_role: dword;
+  end;
+
+  TXRRProviderPropertyNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_ProviderProperty  }
+    provider: RRProvider;                    { related provider  }
+    _property: TAtom;                        { changed property  }
+    timestamp: TTime;                         { time of change  }
+    state: longint;                          { NewValue, Deleted  }
+  end;
+
+  TXRRResourceChangeNotifyEvent = record
+    _type: longint;                          { event base  }
+    serial: dword;                           { # of last request processed by server  }
+    send_event: TBool;                        { true if this came from a SendEvent request  }
+    display: PDisplay;                       { Display the event was read from  }
+    window: TWindow;                          { window which selected for this event  }
+    subtype: longint;                        { RRNotify_ResourceChange  }
+    timestamp: TTime;                         { time of change  }
+  end;
+
+  { internal representation is private to the library  }
+//  _XRRScreenConfiguration = XRRScreenConfiguration;
+  PXRRScreenConfiguration = ^TXRRScreenConfiguration;
+  TXRRScreenConfiguration = record end;
+
+
+
+function XRRQueryExtension(dpy: PDisplay; event_base_return: Plongint; error_base_return: Plongint): TBool; cdecl; external libXrandr;
+function XRRQueryVersion(dpy: PDisplay; major_version_return: Plongint; minor_version_return: Plongint): TStatus; cdecl; external libXrandr;
+function XRRGetScreenInfo(dpy: PDisplay; window: TWindow): PXRRScreenConfiguration; cdecl; external libXrandr;
+procedure XRRFreeScreenConfigInfo(config: PXRRScreenConfiguration); cdecl; external libXrandr;
+
+    {
+     * Note that screen configuration changes are only permitted if the client can
+     * prove it has up to date configuration information.  We are trying to
+     * insist that it become possible for screens to change dynamically, so
+     * we want to ensure the client knows what it is talking about when requesting
+     * changes.
+
+      Обратите внимание, что изменения конфигурации экрана разрешены только в том
+      случае, если клиент может доказать, что у него есть обновленная информация о
+      конфигурации. Мы пытаемся настоять на том, чтобы экраны могли изменяться
+      динамически, поэтому мы хотим, чтобы клиент знал, о чем он говорит, запрашивая
+      изменения.
+      }
+function XRRSetScreenConfig(dpy: PDisplay; config: PXRRScreenConfiguration;
+  draw: TDrawable; size_index: longint; rotation: TRotation; timestamp: TTime): TStatus; cdecl; external libXrandr;
+
+{ added in v1.1, sorry for the lame name  }
+function XRRSetScreenConfigAndRate(dpy: PDisplay; config: PXRRScreenConfiguration;
+  draw: TDrawable; size_index: longint; rotation: TRotation; rate: smallint; timestamp: TTime): TStatus; cdecl; external libXrandr;
+function XRRConfigRotations(config: PXRRScreenConfiguration;current_rotation: PRotation): TRotation; cdecl; external libXrandr;
+function XRRConfigTimes(config: PXRRScreenConfiguration; config_timestamp: PTime): TTime; cdecl; external libXrandr;
+function XRRConfigSizes(config: PXRRScreenConfiguration; nsizes: Plongint): PXRRScreenSize; cdecl; external libXrandr;
+function XRRConfigRates(config: PXRRScreenConfiguration; TsizeID: longint; nrates: Plongint): Psmallint; cdecl; external libXrandr;
+function XRRConfigCurrentConfiguration(config: PXRRScreenConfiguration; rotation: PRotation): TSizeID; cdecl; external libXrandr;
+function XRRConfigCurrentRate(config: PXRRScreenConfiguration): smallint; cdecl; external libXrandr;
+function XRRRootToScreen(dpy: PDisplay; root: TWindow): longint; cdecl; external libXrandr;
+
+    {
+     * returns the screen configuration for the specified screen; does a lazy
+     * evaluation to delay getting the information, and caches the result.
+     * These routines should be used in preference to XRRGetScreenInfo
+     * to avoid unneeded round trips to the X server.  These are new
+     * in protocol version 0.1.
+
+      возвращает конфигурацию экрана для указанного экрана; выполняет ленивую
+      оценку, чтобы задержать получение информации, и кэширует результат. Эти
+      процедуры следует использовать вместо XRRGetScreenInfo, чтобы избежать
+      ненужных обращений к X-серверу. Это новые возможности протокола версии 0.1.
+      }
+procedure XRRSelectInput(dpy: PDisplay; window: TWindow; mask: longint); cdecl; external libXrandr;
+
+    {
+     * the following are always safe to call, even if RandR is not implemented
+     * on a screen
+
+      всегда безопасно вызывать следующие действия, даже если RandR не реализован на
+      экране
+      }
+function XRRRotations(dpy: PDisplay; screen: longint; current_rotation: PRotation): TRotation; cdecl; external libXrandr;
+function XRRSizes(dpy: PDisplay; screen: longint; nsizes: Plongint): PXRRScreenSize; cdecl; external libXrandr;
+function XRRRates(dpy: PDisplay; screen: longint; TsizeID: longint; nrates: Plongint): Psmallint; cdecl; external libXrandr;
+function XRRTimes(dpy: PDisplay; screen: longint; config_timestamp: PTime): TTime; cdecl; external libXrandr;
+
+{ Version 1.2 additions  }
+function XRRGetScreenSizeRange(dpy: PDisplay; window: TWindow;
+  minWidth: Plongint; minHeight: Plongint; maxWidth: Plongint; maxHeight: Plongint): TStatus; cdecl; external libXrandr;
+procedure XRRSetScreenSize(dpy: PDisplay; window: TWindow; Width: longint; Height: longint; mmWidth: longint; mmHeight: longint); cdecl; external libXrandr;
+
+type
+  TXRRModeFlags = dword;
+
+  PXRRModeInfo = ^TXRRModeInfo;
+  TXRRModeInfo = record
+    id: RRMode;
+    Width: dword;
+    Height: dword;
+    dotClock: dword;
+    hSyncStart: dword;
+    hSyncEnd: dword;
+    hTotal: dword;
+    hSkew: dword;
+    vSyncStart: dword;
+    vSyncEnd: dword;
+    vTotal: dword;
+    Name: Pchar;
+    nameLength: dword;
+    modeFlags: TXRRModeFlags;
+  end;
+//  XRRModeInfo = _XRRModeInfo;
+
+  PXRRScreenResources = ^TXRRScreenResources;
+  TXRRScreenResources = record
+    timestamp: TTime;
+    configTimestamp: TTime;
+    ncrtc: longint;
+    crtcs: PRRCrtc;
+    noutput: longint;
+    outputs: PRROutput;
+    nmode: longint;
+    modes: PXRRModeInfo;
+  end;
+//  XRRScreenResources = _XRRScreenResources;
+
+function XRRGetScreenResources(dpy: PDisplay; window: TWindow): PXRRScreenResources; cdecl; external libXrandr;
+procedure XRRFreeScreenResources(resources: PXRRScreenResources); cdecl; external libXrandr;
+
+type
+  PXRROutputInfo = ^TXRROutputInfo;
+  TXRROutputInfo = record
+    timestamp: TTime;
+    crtc: RRCrtc;
+    Name: Pchar;
+    nameLen: longint;
+    mm_width: dword;
+    mm_height: dword;
+    connection: TConnection;
+    subpixel_order: TSubpixelOrder;
+    ncrtc: longint;
+    crtcs: PRRCrtc;
+    nclone: longint;
+    clones: PRROutput;
+    nmode: longint;
+    npreferred: longint;
+    modes: PRRMode;
+  end;
+//  XRROutputInfo = _XRROutputInfo;
+
+function XRRGetOutputInfo(dpy: PDisplay; resources: PXRRScreenResources; output: RROutput): PXRROutputInfo; cdecl; external libXrandr;
+procedure XRRFreeOutputInfo(outputInfo: PXRROutputInfo); cdecl; external libXrandr;
+function XRRListOutputProperties(dpy: PDisplay; output: RROutput; nprop: Plongint): PAtom; cdecl; external libXrandr;
+
+type
+  PXRRPropertyInfo = ^TXRRPropertyInfo;
+  TXRRPropertyInfo = record
+    pending: TBool;
+    range: TBool;
+    immutable: TBool;
+    num_values: longint;
+    values: Plongint;
+  end;
+
+function XRRQueryOutputProperty(dpy: PDisplay; output: RROutput; _property: TAtom): PXRRPropertyInfo; cdecl; external libXrandr;
+
+procedure XRRConfigureOutputProperty(dpy: PDisplay; output: RROutput;
+  _property: TAtom; pending: TBool; range: TBool; num_values: longint; values: Plongint); cdecl; external libXrandr;
+procedure XRRChangeOutputProperty(dpy: PDisplay; output: RROutput; _property: TAtom; _type: TAtom; format: longint;
+  mode: longint; Data: pbyte {_Xconst } {PChar}; nelements: longint); cdecl; external libXrandr;
+procedure XRRDeleteOutputProperty(dpy: PDisplay; output: RROutput; _property: TAtom); cdecl; external libXrandr;
+function XRRGetOutputProperty(dpy: PDisplay; output: RROutput; _property: TAtom; offset: longint; length: longint; _delete: TBool;
+  pending: TBool; req_type: TAtom; actual_type: PAtom; actual_format: Plongint; nitems: Pdword; bytes_after: Pdword; prop: PPbyte {PPChar}): longint; cdecl; external libXrandr;
+function XRRAllocModeInfo(Name: PChar {_Xconst }; nameLength: longint): PXRRModeInfo; cdecl; external libXrandr;
+function XRRCreateMode(dpy: PDisplay; window: TWindow; modeInfo: PXRRModeInfo): RRMode; cdecl; external libXrandr;
+procedure XRRDestroyMode(dpy: PDisplay; mode: RRMode); cdecl; external libXrandr;
+procedure XRRAddOutputMode(dpy: PDisplay; output: RROutput; mode: RRMode); cdecl; external libXrandr;
+procedure XRRDeleteOutputMode(dpy: PDisplay; output: RROutput; mode: RRMode); cdecl; external libXrandr;
+procedure XRRFreeModeInfo(modeInfo: PXRRModeInfo); cdecl; external libXrandr;
+
+type
+  PXRRCrtcInfo = ^TXRRCrtcInfo;
+  TXRRCrtcInfo = record
+    timestamp: TTime;
+    x: longint;
+    y: longint;
+    Width: dword;
+    Height: dword;
+    mode: RRMode;
+    rotation: TRotation;
+    noutput: longint;
+    outputs: PRROutput;
+    rotations: TRotation;
+    npossible: longint;
+    possible: PRROutput;
+  end;
+//  XRRCrtcInfo = _XRRCrtcInfo;
+
+function XRRGetCrtcInfo(dpy: PDisplay; resources: PXRRScreenResources; crtc: RRCrtc): PXRRCrtcInfo; cdecl; external libXrandr;
+procedure XRRFreeCrtcInfo(crtcInfo: PXRRCrtcInfo); cdecl; external libXrandr;
+function XRRSetCrtcConfig(dpy: PDisplay; resources: PXRRScreenResources;
+  crtc: RRCrtc; timestamp: TTime; x: longint; y: longint; mode: RRMode; rotation: TRotation; outputs: PRROutput; noutputs: longint): TStatus; cdecl; external libXrandr;
+function XRRGetCrtcGammaSize(dpy: PDisplay; crtc: RRCrtc): longint; cdecl; external libXrandr;
+
+type
+  PXRRCrtcGamma = ^TXRRCrtcGamma;
+  TXRRCrtcGamma = record
+    size: longint;
+    red: Pword;
+    green: Pword;
+    blue: Pword;
+  end;
+//  XRRCrtcGamma = _XRRCrtcGamma;
+
+function XRRGetCrtcGamma(dpy: PDisplay; crtc: RRCrtc): PXRRCrtcGamma; cdecl; external libXrandr;
+function XRRAllocGamma(size: longint): PXRRCrtcGamma; cdecl; external libXrandr;
+procedure XRRSetCrtcGamma(dpy: PDisplay; crtc: RRCrtc; gamma: PXRRCrtcGamma); cdecl; external libXrandr;
+procedure XRRFreeGamma(gamma: PXRRCrtcGamma); cdecl; external libXrandr;
+
+{ Version 1.3 additions  }
+function XRRGetScreenResourcesCurrent(dpy: PDisplay; window: TWindow): PXRRScreenResources; cdecl; external libXrandr;
+procedure XRRSetCrtcTransform(dpy: PDisplay; crtc: RRCrtc; transform: PXTransform; filter: PChar{_Xconst }; params: PXFixed; nparams: longint); cdecl; external libXrandr;
+
+type
+  PPXRRCrtcTransformAttributes = ^PXRRCrtcTransformAttributes;
+  PXRRCrtcTransformAttributes = ^TXRRCrtcTransformAttributes;
+  TXRRCrtcTransformAttributes = record
+    pendingTransform: TXTransform;
+    pendingFilter: Pchar;
+    pendingNparams: longint;
+    pendingParams: PXFixed;
+    currentTransform: TXTransform;
+    currentFilter: Pchar;
+    currentNparams: longint;
+    currentParams: PXFixed;
+  end;
+//  XRRCrtcTransformAttributes = _XRRCrtcTransformAttributes;
+
+    {
+     * Get current crtc transforms and filters.
+     * Pass *attributes to XFree to free
+      }
+
+function XRRGetCrtcTransform(dpy: PDisplay; crtc: RRCrtc; attributes: PPXRRCrtcTransformAttributes): TStatus; cdecl; external libXrandr;
+
+    {
+     * intended to take RRScreenChangeNotify,  or
+     * ConfigureNotify (on the root window)
+     * returns 1 if it is an event type it understands, 0 if not
+
+      предназначенный для получения RRScreenChangeNotify или ConfigurationNotify (в
+      корневом окне), возвращает 1, если это тип события, который он понимает, и 0,
+      если нет
+      }
+function XRRUpdateConfiguration(event: PXEvent): longint; cdecl; external libXrandr;
+
+type
+  PXRRPanning = ^TXRRPanning;
+  TXRRPanning = record
+    timestamp: TTime;
+    left: dword;
+    top: dword;
+    Width: dword;
+    Height: dword;
+    track_left: dword;
+    track_top: dword;
+    track_width: dword;
+    track_height: dword;
+    border_left: longint;
+    border_top: longint;
+    border_right: longint;
+    border_bottom: longint;
+  end;
+//  XRRPanning = _XRRPanning;
+
+function XRRGetPanning(dpy: PDisplay; resources: PXRRScreenResources; crtc: RRCrtc): PXRRPanning; cdecl; external libXrandr;
+procedure XRRFreePanning(panning: PXRRPanning); cdecl; external libXrandr;
+function XRRSetPanning(dpy: PDisplay; resources: PXRRScreenResources; crtc: RRCrtc; panning: PXRRPanning): TStatus; cdecl; external libXrandr;
+procedure XRRSetOutputPrimary(dpy: PDisplay; window: TWindow; output: RROutput); cdecl; external libXrandr;
+function XRRGetOutputPrimary(dpy: PDisplay; window: TWindow): RROutput; cdecl; external libXrandr;
+
+type
+  PXRRProviderResources = ^TXRRProviderResources;
+  TXRRProviderResources = record
+    timestamp: TTime;
+    nproviders: longint;
+    providers: PRRProvider;
+  end;
+//  XRRProviderResources = _XRRProviderResources;
+
+function XRRGetProviderResources(dpy: PDisplay; window: TWindow): PXRRProviderResources; cdecl; external libXrandr;
+procedure XRRFreeProviderResources(resources: PXRRProviderResources); cdecl; external libXrandr;
+
+type
+  PXRRProviderInfo = ^TXRRProviderInfo;
+  TXRRProviderInfo = record
+    capabilities: dword;
+    ncrtcs: longint;
+    crtcs: PRRCrtc;
+    noutputs: longint;
+    outputs: PRROutput;
+    Name: Pchar;
+    nassociatedproviders: longint;
+    associated_providers: PRRProvider;
+    associated_capability: Pdword;
+    nameLen: longint;
+  end;
+//  XRRProviderInfo = _XRRProviderInfo;
+
+function XRRGetProviderInfo(dpy: PDisplay; resources: PXRRScreenResources; provider: RRProvider): PXRRProviderInfo; cdecl; external libXrandr;
+procedure XRRFreeProviderInfo(provider: PXRRProviderInfo); cdecl; external libXrandr;
+function XRRSetProviderOutputSource(dpy: PDisplay; provider: TXID; source_provider: TXID): longint; cdecl; external libXrandr;
+function XRRSetProviderOffloadSink(dpy: PDisplay; provider: TXID; sink_provider: TXID): longint; cdecl; external libXrandr;
+function XRRListProviderProperties(dpy: PDisplay; provider: RRProvider; nprop: Plongint): PAtom; cdecl; external libXrandr;
+function XRRQueryProviderProperty(dpy: PDisplay; provider: RRProvider; _property: TAtom): PXRRPropertyInfo; cdecl; external libXrandr;
+procedure XRRConfigureProviderProperty(dpy: PDisplay; provider: RRProvider; _property: tAtom; pending: TBool; range: TBool; num_values: longint; values: Plongint); cdecl; external libXrandr;
+procedure XRRChangeProviderProperty(dpy: PDisplay; provider: RRProvider; _property: TAtom; _type: TAtom; format: longint;
+  mode: longint; Data: pbyte {_Xconst } {PChar}; nelements: longint); cdecl; external libXrandr;
+procedure XRRDeleteProviderProperty(dpy: PDisplay; provider: RRProvider; _property: TAtom); cdecl; external libXrandr;
+function XRRGetProviderProperty(dpy: PDisplay; provider: RRProvider; _property: TAtom; offset: longint; length: longint; _delete: TBool;
+  pending: TBool; req_type: TAtom; actual_type: PAtom; actual_format: Plongint; nitems: Pdword; bytes_after: Pdword; prop: PPbyte {PPChar}): longint; cdecl; external libXrandr;
+
+type
+  PXRRMonitorInfo = ^TXRRMonitorInfo;
+  TXRRMonitorInfo = record
+    Name: TAtom;
+    primary: TBool;
+    automatic: TBool;
+    noutput: longint;
+    x: longint;
+    y: longint;
+    Width: longint;
+    Height: longint;
+    mwidth: longint;
+    mheight: longint;
+    outputs: PRROutput;
+  end;
+//  XRRMonitorInfo = _XRRMonitorInfo;
+
+function XRRAllocateMonitor(dpy: PDisplay; noutput: longint): PXRRMonitorInfo; cdecl; external libXrandr;
+function XRRGetMonitors(dpy: PDisplay; window: TWindow; get_active: TBool; nmonitors: Plongint): PXRRMonitorInfo; cdecl; external libXrandr;
+procedure XRRSetMonitor(dpy: PDisplay; window: TWindow; monitor: PXRRMonitorInfo); cdecl; external libXrandr;
+procedure XRRDeleteMonitor(dpy: PDisplay; window: TWindow; Name: TAtom); cdecl; external libXrandr;
+procedure XRRFreeMonitors(monitors: PXRRMonitorInfo); cdecl; external libXrandr;
+
+implementation
+
+end.
+

Zengl_SRC/srcGL/EGL/egl_conf.cfg

@@ -0,0 +1,188 @@
+{.$DEFINE EGL_NO_MIN}        // on full EGL
+
+{$DEFINE EGL_VERSION_1_0}
+{$DEFINE EGL_VERSION_1_1}
+{$DEFINE EGL_VERSION_1_2}
+{$DEFINE EGL_VERSION_1_3}
+{$DEFINE EGL_VERSION_1_4}
+{$DEFINE EGL_VERSION_1_5}
+  {.$DEFINE EGL_KHR_cl_event}
+{$DEFINE EGL_KHR_cl_event2}
+  {.$DEFINE EGL_KHR_client_get_all_proc_addresses}
+  {.$DEFINE EGL_KHR_config_attribs}
+  {.$DEFINE EGL_KHR_context_flush_control}
+  {.$DEFINE EGL_KHR_create_context}
+  {.$DEFINE EGL_KHR_create_context_no_error}
+{$DEFINE EGL_KHR_debug}
+{$DEFINE EGL_KHR_display_reference}
+{$DEFINE EGL_KHR_fence_sync}
+  {.$DEFINE EGL_KHR_get_all_proc_addresses}
+  {.$DEFINE EGL_KHR_gl_colorspace}
+  {.$DEFINE EGL_KHR_gl_renderbuffer_image}
+  {.$DEFINE EGL_KHR_gl_texture_2D_image}
+  {.$DEFINE EGL_KHR_gl_texture_3D_image}
+  {.$DEFINE EGL_KHR_gl_texture_cubemap_image}
+{$DEFINE EGL_KHR_image}
+  {.$DEFINE EGL_KHR_image_base}
+  {.$DEFINE EGL_KHR_image_pixmap}
+{$DEFINE EGL_KHR_lock_surface}
+  {.$DEFINE EGL_KHR_lock_surface2}
+{$DEFINE EGL_KHR_lock_surface3}
+  {.$DEFINE EGL_KHR_mutable_render_buffer}
+  {.$DEFINE EGL_KHR_no_config_context}
+{$DEFINE EGL_KHR_partial_update}
+  {$IFDEF ANDROID}
+    {.$DEFINE EGL_KHR_platform_android}
+  {$ENDIF}
+  {.$DEFINE EGL_KHR_platform_gbm}
+  {.$DEFINE EGL_KHR_p latform_wayland}
+  {.$DEFINE EGL_KHR_platform_x11}
+{$DEFINE EGL_KHR_reusable_sync}
+{$DEFINE EGL_KHR_stream}
+{$DEFINE EGL_KHR_stream_attrib}
+
+{$IFDEF EGL_KHR_stream}
+  {$DEFINE EGL_KHR_stream_consumer_gltexture}
+  {$DEFINE EGL_KHR_stream_cross_process_fd}
+  {$DEFINE EGL_KHR_stream_fifo}
+    {.$DEFINE EGL_KHR_stream_producer_aldatalocator}
+  {$DEFINE EGL_KHR_stream_producer_eglsurface}
+{$ENDIF}
+
+  {.$DEFINE EGL_KHR_surfaceless_context}
+{$DEFINE EGL_KHR_swap_buffers_with_damage}
+  {.$DEFINE EGL_KHR_vg_parent_image}
+{$DEFINE EGL_KHR_wait_sync}
+
+{$IFDEF ANDROID}
+  {.$DEFINE EGL_ANDROID_GLES_layers}
+{$DEFINE EGL_ANDROID_blob_cache}
+{$DEFINE EGL_ANDROID_create_native_client_buffer}
+  {.$DEFINE EGL_ANDROID_framebuffer_target}
+  {.$DEFINE EGL_ANDROID_front_buffer_auto_refresh}
+{$DEFINE EGL_ANDROID_get_frame_timestamps}
+{$DEFINE EGL_ANDROID_get_native_client_buffer}
+  {.$DEFINE EGL_ANDROID_image_native_buffer}
+{$DEFINE EGL_ANDROID_native_fence_sync}
+{$DEFINE EGL_ANDROID_presentation_time}
+  {.$DEFINE EGL_ANDROID_recordable}
+{$ENDIF
+}
+  {.$DEFINE EGL_ANGLE_d3d_share_handle_client_buffer}
+  {.$DEFINE EGL_ANGLE_device_d3d}
+{$DEFINE EGL_ANGLE_query_surface_pointer}
+  {.$DEFINE EGL_ANGLE_surface_d3d_texture_2d_share_handle}
+{$DEFINE EGL_ANGLE_sync_control_rate}
+  {.$DEFINE EGL_ANGLE_window_fixed_size}
+  {.$DEFINE EGL_ARM_image_format}
+  {.$DEFINE EGL_ARM_implicit_external_sync}
+  {.$DEFINE EGL_ARM_pixmap_multisample_discard}
+  {.$DEFINE EGL_EXT_bind_to_front}
+  {.$DEFINE EGL_EXT_buffer_age}
+  {.$DEFINE EGL_EXT_client_extensions}
+{$DEFINE EGL_EXT_client_sync}
+{$DEFINE EGL_EXT_compositor}
+  {.$DEFINE EGL_EXT_config_select_group}
+  {.$DEFINE EGL_EXT_create_context_robustness}
+{$DEFINE EGL_EXT_device_base}
+  {.$DEFINE EGL_EXT_device_drm}
+  {.$DEFINE EGL_EXT_device_drm_render_node}
+  {.$DEFINE EGL_EXT_device_enumeration}
+  {.$DEFINE EGL_EXT_device_openwf}
+{$DEFINE EGL_EXT_device_persistent_id}
+  {.$DEFINE EGL_EXT_device_query}
+  {.$DEFINE EGL_EXT_device_query_name}
+  {.$DEFINE EGL_EXT_explicit_device}
+  {.$DEFINE EGL_EXT_gl_colorspace_bt2020_hlg}
+  {.$DEFINE EGL_EXT_gl_colorspace_bt2020_linear}
+  {.$DEFINE EGL_EXT_gl_colorspace_bt2020_pq}
+  {.$DEFINE EGL_EXT_gl_colorspace_display_p3}
+  {.$DEFINE EGL_EXT_gl_colorspace_display_p3_linear}
+  {.$DEFINE EGL_EXT_gl_colorspace_display_p3_passthrough}
+  {.$DEFINE EGL_EXT_gl_colorspace_scrgb}
+  {.$DEFINE EGL_EXT_gl_colorspace_scrgb_linear}
+  {.$DEFINE EGL_EXT_image_dma_buf_import}
+{$DEFINE EGL_EXT_image_dma_buf_import_modifiers}
+  {.$DEFINE EGL_EXT_image_gl_colorspace}
+  {.$DEFINE EGL_EXT_image_implicit_sync_control}
+  {.$DEFINE EGL_EXT_multiview_window}
+{$DEFINE EGL_EXT_output_base}
+  {.$DEFINE EGL_EXT_output_drm}
+  {.$DEFINE EGL_EXT_output_openwf}
+  {.$DEFINE EGL_EXT_pixel_format_float}
+{$DEFINE EGL_EXT_platform_base}
+  {.$DEFINE EGL_EXT_platform_device}
+  {.$DEFINE EGL_EXT_platform_wayland}
+  {.$DEFINE EGL_EXT_platform_x11}
+  {.$DEFINE EGL_EXT_platform_xcb}
+  {.$DEFINE EGL_EXT_present_opaque}
+  {.$DEFINE EGL_EXT_protected_content}
+  {.$DEFINE EGL_EXT_protected_surface}
+{$DEFINE EGL_EXT_stream_consumer_egloutput}
+  {.$DEFINE EGL_EXT_surface_CTA861_3_metadata}
+  {.$DEFINE EGL_EXT_surface_SMPTE2086_metadata}
+{$DEFINE EGL_EXT_surface_compression}
+{$DEFINE EGL_EXT_swap_buffers_with_damage}
+{$DEFINE EGL_EXT_sync_reuse}
+  {.$DEFINE EGL_EXT_yuv_surface}
+{$DEFINE EGL_HI_clientpixmap}
+  {.$DEFINE EGL_HI_colorformats}
+  {.$DEFINE EGL_IMG_context_priority}
+  {.$DEFINE EGL_IMG_image_plane_attribs}
+{$DEFINE EGL_MESA_drm_image}
+{$DEFINE EGL_MESA_image_dma_buf_export}
+  {.$DEFINE EGL_MESA_platform_gbm}
+  {.$DEFINE EGL_MESA_platform_surfaceless}
+{$DEFINE EGL_MESA_query_driver}
+{$DEFINE EGL_NOK_swap_region}
+{$DEFINE EGL_NOK_swap_region2}
+  {.$DEFINE EGL_NOK_texture_from_pixmap}
+
+{$IFDEF VID_NV}
+    {.$DEFINE EGL_NV_3dvision_surface}
+    {.$DEFINE EGL_NV_context_priority_realtime}
+    {.$DEFINE EGL_NV_coverage_sample}
+    {.$DEFINE EGL_NV_coverage_sample_resolve}
+    {.$DEFINE EGL_NV_cuda_event}
+    {.$DEFINE EGL_NV_depth_nonlinear}
+    {.$DEFINE EGL_NV_device_cuda}
+  {$DEFINE EGL_NV_native_query}
+    {.$DEFINE EGL_NV_post_convert_rounding}
+  {$DEFINE EGL_NV_post_sub_buffer}
+    {.$DEFINE EGL_NV_quadruple_buffer}
+    {.$DEFINE EGL_NV_robustness_video_memory_purge}
+  {$DEFINE EGL_NV_stream_consumer_eglimage}
+    {.$DEFINE EGL_NV_stream_consumer_eglimage_use_scanout_attrib}
+  {$DEFINE EGL_NV_stream_consumer_gltexture_yuv}
+    {.$DEFINE EGL_NV_stream_cross_display}
+    {.$DEFINE EGL_NV_stream_cross_object}
+    {.$DEFINE EGL_NV_stream_cross_partition}
+    {.$DEFINE EGL_NV_stream_cross_process}
+    {.$DEFINE EGL_NV_stream_cross_system}
+    {.$DEFINE EGL_NV_stream_dma}
+    {.$DEFINE EGL_NV_stream_fifo_next}
+    {.$DEFINE EGL_NV_stream_fifo_synchronous}
+  {$DEFINE EGL_NV_stream_flush}
+    {.$DEFINE EGL_NV_stream_frame_limits}
+  {$DEFINE EGL_NV_stream_metadata}
+    {.$DEFINE EGL_NV_stream_origin}
+    {.$DEFINE EGL_NV_stream_remote}
+  {$DEFINE EGL_NV_stream_reset}
+    {.$DEFINE EGL_NV_stream_socket}
+    {.$DEFINE EGL_NV_stream_socket_inet}
+    {.$DEFINE EGL_NV_stream_socket_unix}
+  {$DEFINE EGL_NV_stream_sync}
+  {$DEFINE EGL_NV_sync}
+  {$DEFINE EGL_NV_system_time}
+    {.$DEFINE EGL_NV_triple_buffer}
+{$ENDIF}
+
+  {.$DEFINE EGL_QNX_image_native_buffer}
+  {.$DEFINE EGL_QNX_platform_screen}
+  {.$DEFINE EGL_TIZEN_image_native_buffer}
+  {.$DEFINE EGL_TIZEN_image_native_surface}
+{$IFDEF WAYLAND}
+  {$DEFINE EGL_WL_bind_wayland_display}
+  {$DEFINE EGL_WL_create_wayland_buffer_from_image}
+{$ENDIF}
+

Zengl_SRC/srcGL/EGL/zgl_EGL.pas

@@ -0,0 +1,2185 @@
+(*
+ *  Copyright (c) 2023 Serge - SSW
+ *
+ *  This software is provided 'as-is', without any express or
+ *  implied warranty. In no event will the authors be held
+ *  liable for any damages arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute
+ *  it freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented;
+ *     you must not claim that you wrote the original software.
+ *     If you use this software in a product, an acknowledgment
+ *     in the product documentation would be appreciated but
+ *     is not required.
+ *
+ *  2. Altered source versions must be plainly marked as such,
+ *     and must not be misrepresented as being the original software.
+ *
+ *  3. This notice may not be removed or altered from any
+ *     source distribution.
+ *)
+
+// Copyright 2013-2020 The Khronos Group Inc.
+// SPDX-License-Identifier: Apache-2.0
+//
+// This header is generated from the Khronos EGL XML API Registry.
+// The current version of the Registry, generator scripts
+// used to make the header, and the header can be found at
+//   http://www.khronos.org/registry/egl
+
+unit zgl_EGL;
+{$I zgl_config.cfg}
+{$I egl_conf.cfg}
+
+interface
+
+{$IFDEF FPC}
+{$PACKRECORDS C}
+{$ENDIF}
+
+  {
+  ** Copyright 2013-2020 The Khronos Group Inc.
+  ** SPDX-License-Identifier: Apache-2.0
+  **
+  ** This header is generated from the Khronos EGL XML API Registry.
+  ** The current version of the Registry, generator scripts
+  ** used to make the header, and the header can be found at
+  **   http://www.khronos.org/registry/egl
+  **
+  ** Khronos $Git commit SHA1: 8c62b915dd $ on $Git commit date: 2021-11-05 23:32:01 -0400 $
+   }
+
+{$IfNDef Windows}
+  {$DEFINE stdcall := cdecl}
+{$ENDIF}
+
+uses
+{$IfDef LINUX}  // !!! not Wayland !!!
+  x, xlib,
+{$EndIf}
+  zgl_utils;
+
+const
+  EGL_ALPHA_SIZE = $3021;
+  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_BLUE_SIZE = $3022;
+  EGL_BUFFER_SIZE = $3020;
+  EGL_CONFIG_CAVEAT = $3027;
+  EGL_CONFIG_ID = $3028;
+  EGL_CORE_NATIVE_ENGINE = $305B;
+  EGL_DEPTH_SIZE = $3025;
+
+  EGL_DRAW = $3059;
+  EGL_EXTENSIONS = $3055;
+  EGL_FALSE = 0;
+  EGL_GREEN_SIZE = $3023;
+  EGL_HEIGHT = $3056;
+  EGL_LARGEST_PBUFFER = $3058;
+  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_NONE = $3038;
+  EGL_NON_CONFORMANT_CONFIG = $3051;
+  EGL_NOT_INITIALIZED = $3001;
+
+  EGL_PBUFFER_BIT = $0001;
+  EGL_PIXMAP_BIT = $0002;
+  EGL_READ = $305A;
+  EGL_RED_SIZE = $3024;
+  EGL_SAMPLES = $3031;
+  EGL_SAMPLE_BUFFERS = $3032;
+  EGL_SLOW_CONFIG = $3050;
+  EGL_STENCIL_SIZE = $3026;
+  EGL_SUCCESS = $3000;
+  EGL_SURFACE_TYPE = $3033;
+  EGL_TRANSPARENT_BLUE_VALUE = $3035;
+  EGL_TRANSPARENT_GREEN_VALUE = $3036;
+  EGL_TRANSPARENT_RED_VALUE = $3037;
+  EGL_TRANSPARENT_RGB = $3052;
+  EGL_TRANSPARENT_TYPE = $3034;
+  EGL_TRUE = 1;
+  EGL_VENDOR = $3053;
+  EGL_VERSION = $3054;
+  EGL_WIDTH = $3057;
+  EGL_WINDOW_BIT = $0004;
+
+  EGL_BACK_BUFFER = $3084;
+  EGL_BIND_TO_TEXTURE_RGB = $3039;
+  EGL_BIND_TO_TEXTURE_RGBA = $303A;
+  EGL_CONTEXT_LOST = $300E;
+  EGL_MIN_SWAP_INTERVAL = $303B;
+  EGL_MAX_SWAP_INTERVAL = $303C;
+  EGL_MIPMAP_TEXTURE = $3082;
+  EGL_MIPMAP_LEVEL = $3083;
+  EGL_NO_TEXTURE = $305C;
+  EGL_TEXTURE_2D = $305F;
+  EGL_TEXTURE_FORMAT = $3080;
+  EGL_TEXTURE_RGB = $305D;
+  EGL_TEXTURE_RGBA = $305E;
+  EGL_TEXTURE_TARGET = $3081;
+
+  EGL_ALPHA_FORMAT = $3088;
+  EGL_ALPHA_FORMAT_NONPRE = $308B;
+  EGL_ALPHA_FORMAT_PRE = $308C;
+  EGL_ALPHA_MASK_SIZE = $303E;
+  EGL_BUFFER_PRESERVED = $3094;
+  EGL_BUFFER_DESTROYED = $3095;
+  EGL_CLIENT_APIS = $308D;
+  EGL_COLORSPACE = $3087;
+  EGL_COLORSPACE_sRGB = $3089;
+  EGL_COLORSPACE_LINEAR = $308A;
+  EGL_COLOR_BUFFER_TYPE = $303F;
+  EGL_CONTEXT_CLIENT_TYPE = $3097;
+  EGL_DISPLAY_SCALING = 10000;
+  EGL_HORIZONTAL_RESOLUTION = $3090;
+  EGL_LUMINANCE_BUFFER = $308F;
+  EGL_LUMINANCE_SIZE = $303D;
+  EGL_OPENGL_ES_BIT = $0001;
+  EGL_OPENVG_BIT = $0002;
+  EGL_OPENGL_ES_API = $30A0;
+  EGL_OPENVG_API = $30A1;
+  EGL_OPENVG_IMAGE = $3096;
+  EGL_PIXEL_ASPECT_RATIO = $3092;
+  EGL_RENDERABLE_TYPE = $3040;
+  EGL_RENDER_BUFFER = $3086;
+  EGL_RGB_BUFFER = $308E;
+  EGL_SINGLE_BUFFER = $3085;
+  EGL_SWAP_BEHAVIOR = $3093;
+
+  EGL_VERTICAL_RESOLUTION = $3091;
+
+  EGL_CONFORMANT = $3042;
+  EGL_CONTEXT_CLIENT_VERSION = $3098;
+  EGL_MATCH_NATIVE_PIXMAP = $3041;
+  EGL_OPENGL_ES2_BIT = $0004;
+  EGL_VG_ALPHA_FORMAT = $3088;
+  EGL_VG_ALPHA_FORMAT_NONPRE = $308B;
+  EGL_VG_ALPHA_FORMAT_PRE = $308C;
+  EGL_VG_ALPHA_FORMAT_PRE_BIT = $0040;
+  EGL_VG_COLORSPACE = $3087;
+  EGL_VG_COLORSPACE_sRGB = $3089;
+  EGL_VG_COLORSPACE_LINEAR = $308A;
+  EGL_VG_COLORSPACE_LINEAR_BIT = $0020;
+
+  EGL_MULTISAMPLE_RESOLVE_BOX_BIT = $0200;
+  EGL_MULTISAMPLE_RESOLVE = $3099;
+  EGL_MULTISAMPLE_RESOLVE_DEFAULT = $309A;
+  EGL_MULTISAMPLE_RESOLVE_BOX = $309B;
+  EGL_OPENGL_API = $30A2;
+  EGL_OPENGL_BIT = $0008;
+  EGL_SWAP_BEHAVIOR_PRESERVED_BIT = $0400;
+
+  EGL_CONTEXT_MAJOR_VERSION = $3098;
+  EGL_CONTEXT_MINOR_VERSION = $30FB;
+  EGL_CONTEXT_OPENGL_PROFILE_MASK = $30FD;
+  EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY = $31BD;
+  EGL_NO_RESET_NOTIFICATION = $31BE;
+  EGL_LOSE_CONTEXT_ON_RESET = $31BF;
+  EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT = $00000001;
+  EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT = $00000002;
+  EGL_CONTEXT_OPENGL_DEBUG = $31B0;
+  EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE = $31B1;
+  EGL_CONTEXT_OPENGL_ROBUST_ACCESS = $31B2;
+  EGL_OPENGL_ES3_BIT = $00000040;
+  EGL_CL_EVENT_HANDLE = $309C;
+  EGL_SYNC_CL_EVENT = $30FE;
+  EGL_SYNC_CL_EVENT_COMPLETE = $30FF;
+  EGL_SYNC_PRIOR_COMMANDS_COMPLETE = $30F0;
+  EGL_SYNC_TYPE = $30F7;
+  EGL_SYNC_STATUS = $30F1;
+  EGL_SYNC_CONDITION = $30F8;
+  EGL_SIGNALED = $30F2;
+  EGL_UNSIGNALED = $30F3;
+  EGL_SYNC_FLUSH_COMMANDS_BIT = $0001;
+  EGL_FOREVER = $FFFFFFFFFFFFFFFF;
+  EGL_TIMEOUT_EXPIRED = $30F5;
+  EGL_CONDITION_SATISFIED = $30F6;
+
+  EGL_SYNC_FENCE = $30F9;
+  EGL_GL_COLORSPACE = $309D;
+  EGL_GL_COLORSPACE_SRGB = $3089;
+  EGL_GL_COLORSPACE_LINEAR = $308A;
+  EGL_GL_RENDERBUFFER = $30B9;
+  EGL_GL_TEXTURE_2D = $30B1;
+  EGL_GL_TEXTURE_LEVEL = $30BC;
+  EGL_GL_TEXTURE_3D = $30B2;
+  EGL_GL_TEXTURE_ZOFFSET = $30BD;
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X = $30B3;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $30B4;
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $30B5;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $30B6;
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $30B7;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $30B8;
+  EGL_IMAGE_PRESERVED = $30D2;
+
+// EGL extended.
+// EGL_EGLEXT_VERSION = 20211116;
+
+  EGL_CL_EVENT_HANDLE_KHR = $309C;
+  EGL_SYNC_CL_EVENT_KHR = $30FE;
+  EGL_SYNC_CL_EVENT_COMPLETE_KHR = $30FF;
+
+  EGL_KHR_client_get_all_proc_addresses = 1;
+
+  EGL_CONFORMANT_KHR = $3042;
+  EGL_VG_COLORSPACE_LINEAR_BIT_KHR = $0020;
+  EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR = $0040;
+
+  EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR = 0;
+  EGL_CONTEXT_RELEASE_BEHAVIOR_KHR = $2097;
+  EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = $2098;
+
+  EGL_CONTEXT_MAJOR_VERSION_KHR = $3098;
+  EGL_CONTEXT_MINOR_VERSION_KHR = $30FB;
+  EGL_CONTEXT_FLAGS_KHR = $30FC;
+  EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR = $30FD;
+  EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR = $31BD;
+  EGL_NO_RESET_NOTIFICATION_KHR = $31BE;
+  EGL_LOSE_CONTEXT_ON_RESET_KHR = $31BF;
+  EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR = $00000001;
+  EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR = $00000002;
+  EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR = $00000004;
+  EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR = $00000001;
+  EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR = $00000002;
+  EGL_OPENGL_ES3_BIT_KHR = $00000040;
+
+  EGL_CONTEXT_OPENGL_NO_ERROR_KHR = $31B3;
+
+  EGL_OBJECT_THREAD_KHR = $33B0;
+  EGL_OBJECT_DISPLAY_KHR = $33B1;
+  EGL_OBJECT_CONTEXT_KHR = $33B2;
+  EGL_OBJECT_SURFACE_KHR = $33B3;
+  EGL_OBJECT_IMAGE_KHR = $33B4;
+  EGL_OBJECT_SYNC_KHR = $33B5;
+  EGL_OBJECT_STREAM_KHR = $33B6;
+  EGL_DEBUG_MSG_CRITICAL_KHR = $33B9;
+  EGL_DEBUG_MSG_ERROR_KHR = $33BA;
+  EGL_DEBUG_MSG_WARN_KHR = $33BB;
+  EGL_DEBUG_MSG_INFO_KHR = $33BC;
+  EGL_DEBUG_CALLBACK_KHR = $33B8;
+
+  EGL_TRACK_REFERENCES_KHR = $3352;
+
+  EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR = $30F0;
+  EGL_SYNC_CONDITION_KHR = $30F8;
+  EGL_SYNC_FENCE_KHR = $30F9;
+
+  EGL_KHR_gl_colorspace = 1;
+  EGL_GL_COLORSPACE_KHR = $309D;
+  EGL_GL_COLORSPACE_SRGB_KHR = $3089;
+  EGL_GL_COLORSPACE_LINEAR_KHR = $308A;
+
+  EGL_GL_RENDERBUFFER_KHR = $30B9;
+
+  EGL_GL_TEXTURE_2D_KHR = $30B1;
+  EGL_GL_TEXTURE_LEVEL_KHR = $30BC;
+
+  EGL_GL_TEXTURE_3D_KHR = $30B2;
+  EGL_GL_TEXTURE_ZOFFSET_KHR = $30BD;
+
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR = $30B3;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR = $30B4;
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR = $30B5;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR = $30B6;
+  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR = $30B7;
+  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR = $30B8;
+
+  EGL_NATIVE_PIXMAP_KHR = $30B0;
+
+  EGL_IMAGE_PRESERVED_KHR = $30D2;
+
+  EGL_READ_SURFACE_BIT_KHR = $0001;
+  EGL_WRITE_SURFACE_BIT_KHR = $0002;
+  EGL_LOCK_SURFACE_BIT_KHR = $0080;
+  EGL_OPTIMAL_FORMAT_BIT_KHR = $0100;
+  EGL_MATCH_FORMAT_KHR = $3043;
+  EGL_FORMAT_RGB_565_EXACT_KHR = $30C0;
+  EGL_FORMAT_RGB_565_KHR = $30C1;
+  EGL_FORMAT_RGBA_8888_EXACT_KHR = $30C2;
+  EGL_FORMAT_RGBA_8888_KHR = $30C3;
+  EGL_MAP_PRESERVE_PIXELS_KHR = $30C4;
+  EGL_LOCK_USAGE_HINT_KHR = $30C5;
+  EGL_BITMAP_POINTER_KHR = $30C6;
+  EGL_BITMAP_PITCH_KHR = $30C7;
+  EGL_BITMAP_ORIGIN_KHR = $30C8;
+  EGL_BITMAP_PIXEL_RED_OFFSET_KHR = $30C9;
+  EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR = $30CA;
+  EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR = $30CB;
+  EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR = $30CC;
+  EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR = $30CD;
+  EGL_LOWER_LEFT_KHR = $30CE;
+  EGL_UPPER_LEFT_KHR = $30CF;
+
+  EGL_BITMAP_PIXEL_SIZE_KHR = $3110;
+
+  EGL_MUTABLE_RENDER_BUFFER_BIT_KHR = $1000;
+
+  EGL_BUFFER_AGE_KHR = $313D;
+
+  EGL_PLATFORM_ANDROID_KHR = $3141;
+
+  EGL_PLATFORM_GBM_KHR = $31D7;
+
+  EGL_PLATFORM_WAYLAND_KHR = $31D8;
+
+  EGL_PLATFORM_X11_KHR = $31D5;
+  EGL_PLATFORM_X11_SCREEN_KHR = $31D6;
+
+  EGL_SYNC_STATUS_KHR = $30F1;
+  EGL_SIGNALED_KHR = $30F2;
+  EGL_UNSIGNALED_KHR = $30F3;
+  EGL_TIMEOUT_EXPIRED_KHR = $30F5;
+  EGL_CONDITION_SATISFIED_KHR = $30F6;
+  EGL_SYNC_TYPE_KHR = $30F7;
+  EGL_SYNC_REUSABLE_KHR = $30FA;
+  EGL_SYNC_FLUSH_COMMANDS_BIT_KHR = $0001;
+  {$IfDef CPU64}
+  EGL_FOREVER_KHR = $FFFFFFFFFFFFFFFF;     // сделано только для 64-х битных систем.
+  {$EndIf}
+
+  EGL_CONSUMER_LATENCY_USEC_KHR = $3210;
+  EGL_PRODUCER_FRAME_KHR = $3212;
+  EGL_CONSUMER_FRAME_KHR = $3213;
+  EGL_STREAM_STATE_KHR = $3214;
+  EGL_STREAM_STATE_CREATED_KHR = $3215;
+  EGL_STREAM_STATE_CONNECTING_KHR = $3216;
+  EGL_STREAM_STATE_EMPTY_KHR = $3217;
+  EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR = $3218;
+  EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR = $3219;
+  EGL_STREAM_STATE_DISCONNECTED_KHR = $321A;
+  EGL_BAD_STREAM_KHR = $321B;
+  EGL_BAD_STATE_KHR = $321C;
+
+  EGL_STREAM_FIFO_LENGTH_KHR = $31FC;
+  EGL_STREAM_TIME_NOW_KHR = $31FD;
+  EGL_STREAM_TIME_CONSUMER_KHR = $31FE;
+  EGL_STREAM_TIME_PRODUCER_KHR = $31FF;
+
+  EGL_VG_PARENT_IMAGE_KHR = $30BA;
+
+  EGL_NATIVE_BUFFER_USAGE_ANDROID = $3143;
+  EGL_NATIVE_BUFFER_USAGE_PROTECTED_BIT_ANDROID = $00000001;
+  EGL_NATIVE_BUFFER_USAGE_RENDERBUFFER_BIT_ANDROID = $00000002;
+  EGL_NATIVE_BUFFER_USAGE_TEXTURE_BIT_ANDROID = $00000004;
+
+  EGL_FRAMEBUFFER_TARGET_ANDROID = $3147;
+
+  EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID = $314C;
+
+
+  EGL_TIMESTAMPS_ANDROID = $3430;
+  EGL_COMPOSITE_DEADLINE_ANDROID = $3431;
+  EGL_COMPOSITE_INTERVAL_ANDROID = $3432;
+  EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID = $3433;
+  EGL_REQUESTED_PRESENT_TIME_ANDROID = $3434;
+  EGL_RENDERING_COMPLETE_TIME_ANDROID = $3435;
+  EGL_COMPOSITION_LATCH_TIME_ANDROID = $3436;
+  EGL_FIRST_COMPOSITION_START_TIME_ANDROID = $3437;
+  EGL_LAST_COMPOSITION_START_TIME_ANDROID = $3438;
+  EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID = $3439;
+  EGL_DISPLAY_PRESENT_TIME_ANDROID = $343A;
+  EGL_DEQUEUE_READY_TIME_ANDROID = $343B;
+  EGL_READS_DONE_TIME_ANDROID = $343C;
+
+  EGL_NATIVE_BUFFER_ANDROID = $3140;
+
+  EGL_SYNC_NATIVE_FENCE_ANDROID = $3144;
+  EGL_SYNC_NATIVE_FENCE_FD_ANDROID = $3145;
+  EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID = $3146;
+  EGL_NO_NATIVE_FENCE_FD_ANDROID = -(1);
+
+  EGL_RECORDABLE_ANDROID = $3142;
+
+  EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE = $3200;
+
+  EGL_D3D9_DEVICE_ANGLE = $33A0;
+  EGL_D3D11_DEVICE_ANGLE = $33A1;
+
+  EGL_FIXED_SIZE_ANGLE = $3201;
+
+  EGL_COLOR_COMPONENT_TYPE_UNSIGNED_INTEGER_ARM = $3287;
+  EGL_COLOR_COMPONENT_TYPE_INTEGER_ARM = $3288;
+
+  EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM = $328A;
+
+  EGL_DISCARD_SAMPLES_ARM = $3286;
+
+  EGL_FRONT_BUFFER_EXT = $3464;
+
+  EGL_BUFFER_AGE_EXT = $313D;
+
+  EGL_SYNC_CLIENT_EXT = $3364;
+  EGL_SYNC_CLIENT_SIGNAL_EXT = $3365;
+
+  EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT = $3460;
+  EGL_EXTERNAL_REF_ID_EXT = $3461;
+  EGL_COMPOSITOR_DROP_NEWEST_FRAME_EXT = $3462;
+  EGL_COMPOSITOR_KEEP_NEWEST_FRAME_EXT = $3463;
+
+  EGL_CONFIG_SELECT_GROUP_EXT = $34C0;
+
+  EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT = $30BF;
+  EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT = $3138;
+  EGL_NO_RESET_NOTIFICATION_EXT = $31BE;
+  EGL_LOSE_CONTEXT_ON_RESET_EXT = $31BF;
+
+  EGL_BAD_DEVICE_EXT = $322B;
+  EGL_DEVICE_EXT = $322C;
+
+  EGL_DRM_DEVICE_FILE_EXT = $3233;
+  EGL_DRM_MASTER_FD_EXT = $333C;
+
+  EGL_DRM_RENDER_NODE_FILE_EXT = $3377;
+
+  EGL_OPENWF_DEVICE_ID_EXT = $3237;
+  EGL_OPENWF_DEVICE_EXT = $333D;
+
+  EGL_DEVICE_UUID_EXT = $335C;
+  EGL_DRIVER_UUID_EXT = $335D;
+  EGL_DRIVER_NAME_EXT = $335E;
+
+  EGL_RENDERER_EXT = $335F;
+
+  EGL_GL_COLORSPACE_BT2020_HLG_EXT = $3540;
+  EGL_GL_COLORSPACE_BT2020_LINEAR_EXT = $333F;
+  EGL_GL_COLORSPACE_BT2020_PQ_EXT = $3340;
+  EGL_GL_COLORSPACE_DISPLAY_P3_EXT = $3363;
+  EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT = $3362;
+  EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT = $3490;
+
+  EGL_GL_COLORSPACE_SCRGB_EXT = $3351;
+
+  EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT = $3350;
+
+  EGL_LINUX_DMA_BUF_EXT = $3270;
+  EGL_LINUX_DRM_FOURCC_EXT = $3271;
+  EGL_DMA_BUF_PLANE0_FD_EXT = $3272;
+  EGL_DMA_BUF_PLANE0_OFFSET_EXT = $3273;
+  EGL_DMA_BUF_PLANE0_PITCH_EXT = $3274;
+  EGL_DMA_BUF_PLANE1_FD_EXT = $3275;
+  EGL_DMA_BUF_PLANE1_OFFSET_EXT = $3276;
+  EGL_DMA_BUF_PLANE1_PITCH_EXT = $3277;
+  EGL_DMA_BUF_PLANE2_FD_EXT = $3278;
+  EGL_DMA_BUF_PLANE2_OFFSET_EXT = $3279;
+  EGL_DMA_BUF_PLANE2_PITCH_EXT = $327A;
+  EGL_YUV_COLOR_SPACE_HINT_EXT = $327B;
+  EGL_SAMPLE_RANGE_HINT_EXT = $327C;
+  EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT = $327D;
+  EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT = $327E;
+  EGL_ITU_REC601_EXT = $327F;
+  EGL_ITU_REC709_EXT = $3280;
+  EGL_ITU_REC2020_EXT = $3281;
+  EGL_YUV_FULL_RANGE_EXT = $3282;
+  EGL_YUV_NARROW_RANGE_EXT = $3283;
+  EGL_YUV_CHROMA_SITING_0_EXT = $3284;
+  EGL_YUV_CHROMA_SITING_0_5_EXT = $3285;
+
+  EGL_DMA_BUF_PLANE3_FD_EXT = $3440;
+  EGL_DMA_BUF_PLANE3_OFFSET_EXT = $3441;
+  EGL_DMA_BUF_PLANE3_PITCH_EXT = $3442;
+  EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT = $3443;
+  EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT = $3444;
+  EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT = $3445;
+  EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT = $3446;
+  EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT = $3447;
+  EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT = $3448;
+  EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT = $3449;
+  EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT = $344A;
+
+  EGL_GL_COLORSPACE_DEFAULT_EXT = $314D;
+
+  EGL_IMPORT_SYNC_TYPE_EXT = $3470;
+  EGL_IMPORT_IMPLICIT_SYNC_EXT = $3471;
+  EGL_IMPORT_EXPLICIT_SYNC_EXT = $3472;
+
+  EGL_MULTIVIEW_VIEW_COUNT_EXT = $3134;
+
+  EGL_BAD_OUTPUT_LAYER_EXT = $322D;
+  EGL_BAD_OUTPUT_PORT_EXT = $322E;
+  EGL_SWAP_INTERVAL_EXT = $322F;
+
+  EGL_DRM_CRTC_EXT = $3234;
+  EGL_DRM_PLANE_EXT = $3235;
+  EGL_DRM_CONNECTOR_EXT = $3236;
+
+  EGL_OPENWF_PIPELINE_ID_EXT = $3238;
+  EGL_OPENWF_PORT_ID_EXT = $3239;
+
+  EGL_COLOR_COMPONENT_TYPE_EXT = $3339;
+  EGL_COLOR_COMPONENT_TYPE_FIXED_EXT = $333A;
+  EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT = $333B;
+
+  EGL_PLATFORM_DEVICE_EXT = $313F;
+
+  EGL_PLATFORM_WAYLAND_EXT = $31D8;
+
+  EGL_PLATFORM_X11_EXT = $31D5;
+  EGL_PLATFORM_X11_SCREEN_EXT = $31D6;
+
+  EGL_PLATFORM_XCB_EXT = $31DC;
+  EGL_PLATFORM_XCB_SCREEN_EXT = $31DE;
+
+  EGL_PRESENT_OPAQUE_EXT = $31DF;
+
+  EGL_PROTECTED_CONTENT_EXT = $32C0;
+
+  EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT = $3360;
+  EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT = $3361;
+
+  EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT = $3341;
+  EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT = $3342;
+  EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT = $3343;
+  EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT = $3344;
+  EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT = $3345;
+  EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT = $3346;
+  EGL_SMPTE2086_WHITE_POINT_X_EXT = $3347;
+  EGL_SMPTE2086_WHITE_POINT_Y_EXT = $3348;
+  EGL_SMPTE2086_MAX_LUMINANCE_EXT = $3349;
+  EGL_SMPTE2086_MIN_LUMINANCE_EXT = $334A;
+  EGL_METADATA_SCALING_EXT = 50000;
+
+  EGL_SURFACE_COMPRESSION_EXT = $34B0;
+  EGL_SURFACE_COMPRESSION_PLANE1_EXT = $328E;
+  EGL_SURFACE_COMPRESSION_PLANE2_EXT = $328F;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT = $34B1;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = $34B2;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT = $34B4;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT = $34B5;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT = $34B6;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT = $34B7;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT = $34B8;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT = $34B9;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT = $34BA;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT = $34BB;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT = $34BC;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT = $34BD;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT = $34BE;
+  EGL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT = $34BF;
+
+  EGL_YUV_ORDER_EXT = $3301;
+  EGL_YUV_NUMBER_OF_PLANES_EXT = $3311;
+  EGL_YUV_SUBSAMPLE_EXT = $3312;
+  EGL_YUV_DEPTH_RANGE_EXT = $3317;
+  EGL_YUV_CSC_STANDARD_EXT = $330A;
+  EGL_YUV_PLANE_BPP_EXT = $331A;
+  EGL_YUV_BUFFER_EXT = $3300;
+  EGL_YUV_ORDER_YUV_EXT = $3302;
+  EGL_YUV_ORDER_YVU_EXT = $3303;
+  EGL_YUV_ORDER_YUYV_EXT = $3304;
+  EGL_YUV_ORDER_UYVY_EXT = $3305;
+  EGL_YUV_ORDER_YVYU_EXT = $3306;
+  EGL_YUV_ORDER_VYUY_EXT = $3307;
+  EGL_YUV_ORDER_AYUV_EXT = $3308;
+  EGL_YUV_SUBSAMPLE_4_2_0_EXT = $3313;
+  EGL_YUV_SUBSAMPLE_4_2_2_EXT = $3314;
+  EGL_YUV_SUBSAMPLE_4_4_4_EXT = $3315;
+  EGL_YUV_DEPTH_RANGE_LIMITED_EXT = $3318;
+  EGL_YUV_DEPTH_RANGE_FULL_EXT = $3319;
+  EGL_YUV_CSC_STANDARD_601_EXT = $330B;
+  EGL_YUV_CSC_STANDARD_709_EXT = $330C;
+  EGL_YUV_CSC_STANDARD_2020_EXT = $330D;
+  EGL_YUV_PLANE_BPP_0_EXT = $331B;
+  EGL_YUV_PLANE_BPP_8_EXT = $331C;
+  EGL_YUV_PLANE_BPP_10_EXT = $331D;
+
+  EGL_CLIENT_PIXMAP_POINTER_HI = $8F74;
+
+  EGL_COLOR_FORMAT_HI = $8F70;
+  EGL_COLOR_RGB_HI = $8F71;
+  EGL_COLOR_RGBA_HI = $8F72;
+  EGL_COLOR_ARGB_HI = $8F73;
+
+  EGL_CONTEXT_PRIORITY_LEVEL_IMG = $3100;
+  EGL_CONTEXT_PRIORITY_HIGH_IMG = $3101;
+  EGL_CONTEXT_PRIORITY_MEDIUM_IMG = $3102;
+  EGL_CONTEXT_PRIORITY_LOW_IMG = $3103;
+
+  EGL_NATIVE_BUFFER_MULTIPLANE_SEPARATE_IMG = $3105;
+  EGL_NATIVE_BUFFER_PLANE_OFFSET_IMG = $3106;
+
+  EGL_DRM_BUFFER_FORMAT_MESA = $31D0;
+  EGL_DRM_BUFFER_USE_MESA = $31D1;
+  EGL_DRM_BUFFER_FORMAT_ARGB32_MESA = $31D2;
+  EGL_DRM_BUFFER_MESA = $31D3;
+  EGL_DRM_BUFFER_STRIDE_MESA = $31D4;
+  EGL_DRM_BUFFER_USE_SCANOUT_MESA = $00000001;
+  EGL_DRM_BUFFER_USE_SHARE_MESA = $00000002;
+  EGL_DRM_BUFFER_USE_CURSOR_MESA = $00000004;
+
+  EGL_PLATFORM_GBM_MESA = $31D7;
+
+  EGL_PLATFORM_SURFACELESS_MESA = $31DD;
+
+  EGL_Y_INVERTED_NOK = $307F;
+
+  EGL_AUTO_STEREO_NV = $3136;
+
+  EGL_CONTEXT_PRIORITY_REALTIME_NV = $3357;
+
+  EGL_COVERAGE_BUFFERS_NV = $30E0;
+  EGL_COVERAGE_SAMPLES_NV = $30E1;
+
+  EGL_COVERAGE_SAMPLE_RESOLVE_NV = $3131;
+  EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV = $3132;
+  EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV = $3133;
+
+  EGL_CUDA_EVENT_HANDLE_NV = $323B;
+  EGL_SYNC_CUDA_EVENT_NV = $323C;
+  EGL_SYNC_CUDA_EVENT_COMPLETE_NV = $323D;
+
+  EGL_DEPTH_ENCODING_NV = $30E2;
+  EGL_DEPTH_ENCODING_NONE_NV = 0;
+  EGL_DEPTH_ENCODING_NONLINEAR_NV = $30E3;
+
+  EGL_CUDA_DEVICE_NV = $323A;
+
+  EGL_POST_SUB_BUFFER_SUPPORTED_NV = $30BE;
+
+  EGL_QUADRUPLE_BUFFER_NV = $3231;
+
+  EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV = $334C;
+
+  EGL_STREAM_CONSUMER_IMAGE_NV = $3373;
+  EGL_STREAM_IMAGE_ADD_NV = $3374;
+  EGL_STREAM_IMAGE_REMOVE_NV = $3375;
+  EGL_STREAM_IMAGE_AVAILABLE_NV = $3376;
+
+  EGL_STREAM_CONSUMER_IMAGE_USE_SCANOUT_NV = $3378;
+
+  EGL_YUV_PLANE0_TEXTURE_UNIT_NV = $332C;
+  EGL_YUV_PLANE1_TEXTURE_UNIT_NV = $332D;
+  EGL_YUV_PLANE2_TEXTURE_UNIT_NV = $332E;
+
+  EGL_STREAM_CROSS_DISPLAY_NV = $334E;
+
+  EGL_STREAM_CROSS_OBJECT_NV = $334D;
+
+  EGL_STREAM_CROSS_PARTITION_NV = $323F;
+
+  EGL_STREAM_CROSS_PROCESS_NV = $3245;
+
+  EGL_STREAM_CROSS_SYSTEM_NV = $334F;
+
+  EGL_STREAM_DMA_NV = $3371;
+  EGL_STREAM_DMA_SERVER_NV = $3372;
+
+  EGL_PENDING_FRAME_NV = $3329;
+  EGL_STREAM_TIME_PENDING_NV = $332A;
+
+  EGL_STREAM_FIFO_SYNCHRONOUS_NV = $3336;
+
+  EGL_PRODUCER_MAX_FRAME_HINT_NV = $3337;
+  EGL_CONSUMER_MAX_FRAME_HINT_NV = $3338;
+
+  EGL_MAX_STREAM_METADATA_BLOCKS_NV = $3250;
+  EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV = $3251;
+  EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV = $3252;
+  EGL_PRODUCER_METADATA_NV = $3253;
+  EGL_CONSUMER_METADATA_NV = $3254;
+  EGL_PENDING_METADATA_NV = $3328;
+  EGL_METADATA0_SIZE_NV = $3255;
+  EGL_METADATA1_SIZE_NV = $3256;
+  EGL_METADATA2_SIZE_NV = $3257;
+  EGL_METADATA3_SIZE_NV = $3258;
+  EGL_METADATA0_TYPE_NV = $3259;
+  EGL_METADATA1_TYPE_NV = $325A;
+  EGL_METADATA2_TYPE_NV = $325B;
+  EGL_METADATA3_TYPE_NV = $325C;
+
+  EGL_STREAM_FRAME_ORIGIN_X_NV = $3366;
+  EGL_STREAM_FRAME_ORIGIN_Y_NV = $3367;
+  EGL_STREAM_FRAME_MAJOR_AXIS_NV = $3368;
+  EGL_CONSUMER_AUTO_ORIENTATION_NV = $3369;
+  EGL_PRODUCER_AUTO_ORIENTATION_NV = $336A;
+  EGL_LEFT_NV = $336B;
+  EGL_RIGHT_NV = $336C;
+  EGL_TOP_NV = $336D;
+  EGL_BOTTOM_NV = $336E;
+  EGL_X_AXIS_NV = $336F;
+  EGL_Y_AXIS_NV = $3370;
+
+  EGL_STREAM_STATE_INITIALIZING_NV = $3240;
+  EGL_STREAM_TYPE_NV = $3241;
+  EGL_STREAM_PROTOCOL_NV = $3242;
+  EGL_STREAM_ENDPOINT_NV = $3243;
+  EGL_STREAM_LOCAL_NV = $3244;
+  EGL_STREAM_PRODUCER_NV = $3247;
+  EGL_STREAM_CONSUMER_NV = $3248;
+  EGL_STREAM_PROTOCOL_FD_NV = $3246;
+
+  EGL_SUPPORT_RESET_NV = $3334;
+  EGL_SUPPORT_REUSE_NV = $3335;
+
+  EGL_STREAM_PROTOCOL_SOCKET_NV = $324B;
+  EGL_SOCKET_HANDLE_NV = $324C;
+  EGL_SOCKET_TYPE_NV = $324D;
+  EGL_SOCKET_TYPE_INET_NV = $324F;
+  EGL_SOCKET_TYPE_UNIX_NV = $324E;
+  EGL_SYNC_NEW_FRAME_NV = $321F;
+
+  EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV = $30E6;
+  EGL_SYNC_STATUS_NV = $30E7;
+  EGL_SIGNALED_NV = $30E8;
+  EGL_UNSIGNALED_NV = $30E9;
+  EGL_SYNC_FLUSH_COMMANDS_BIT_NV = $0001;
+  EGL_FOREVER_NV = $FFFFFFFFFFFFFFFF;
+  EGL_ALREADY_SIGNALED_NV = $30EA;
+  EGL_TIMEOUT_EXPIRED_NV = $30EB;
+  EGL_CONDITION_SATISFIED_NV = $30EC;
+  EGL_SYNC_TYPE_NV = $30ED;
+  EGL_SYNC_CONDITION_NV = $30EE;
+  EGL_SYNC_FENCE_NV = $30EF;
+
+  EGL_TRIPLE_BUFFER_NV = $3230;
+
+  EGL_NATIVE_BUFFER_QNX = $3551;
+  EGL_PLATFORM_SCREEN_QNX = $3550;
+
+  EGL_NATIVE_BUFFER_TIZEN = $32A0;
+  EGL_NATIVE_SURFACE_TIZEN = $32A1;
+
+//  EGL_WL_bind_wayland_display = 1;
+  EGL_WAYLAND_BUFFER_WL = $31D5;
+  EGL_WAYLAND_PLANE_WL = $31D6;
+  EGL_TEXTURE_Y_U_V_WL = $31D7;
+  EGL_TEXTURE_Y_UV_WL = $31D8;
+  EGL_TEXTURE_Y_XUXV_WL = $31D9;
+  EGL_TEXTURE_EXTERNAL_WL = $31DA;
+  EGL_WAYLAND_Y_INVERTED_WL = $31DB;
+
+//  EGL_WL_create_wayland_buffer_from_image = 1;
+
+  EGL_PRESERVED_RESOURCES         = $3030;
+
+  { The types NativeDisplayType, NativeWindowType, and NativePixmapType
+   * are aliases of window-system-dependent types, such as X Display * or
+   * Windows Device Context. They must be defined in platform-specific
+   * code below. The EGL-prefixed versions of Native*Type are the same
+   * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+   *
+   * Khronos STRONGLY RECOMMENDS that you use the default definitions
+   * provided below, since these changes affect both binary and source
+   * portability of applications using EGL running on different EGL
+   * implementations.
+   }
+//------------------------------------------------------------------------------
+   (* Khronos platform-specific types and definitions.
+   *
+   * The master copy of khrplatform.h is maintained in the Khronos EGL
+   * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+   * The last semantic modification to khrplatform.h was at commit ID:
+   *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+   *
+   * Adopters may modify this file to suit their platform. Adopters are
+   * encouraged to submit platform specific modifications to the Khronos
+   * group so that they can be included in future versions of this file.
+   * Please submit changes by filing pull requests or issues on
+   * the EGL Registry repository linked above.
+   *
+   *
+   * See the Implementer's Guidelines for information about where this file
+   * should be located on your system and for more details of its use:
+   *    http://www.khronos.org/registry/implementers_guide.pdf
+   *
+   * This file should be included as
+   *        #include <KHR/khrplatform.h>
+   * by Khronos client API header files that use its types and defines.
+   *
+   * The types in khrplatform.h should only be used to define API-specific types.
+   *
+   * Types defined in khrplatform.h:
+   *    khronos_int8_t              signed   8  bit
+   *    khronos_uint8_t             unsigned 8  bit
+   *    khronos_int16_t             signed   16 bit
+   *    khronos_uint16_t            unsigned 16 bit
+   *    khronos_int32_t             signed   32 bit
+   *    khronos_uint32_t            unsigned 32 bit
+   *    khronos_int64_t             signed   64 bit
+   *    khronos_uint64_t            unsigned 64 bit
+   *    khronos_intptr_t            signed   same number of bits as a pointer
+   *    khronos_uintptr_t           unsigned same number of bits as a pointer
+   *    khronos_ssize_t             signed   size
+   *    khronos_usize_t             unsigned size
+   *    khronos_float_t             signed   32 bit floating point
+   *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+   *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+   *                                         nanoseconds
+   *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+   *    khronos_boolean_enum_t      enumerated boolean type. This should
+   *      only be used as a base type when a client API's boolean type is
+   *      an enum. Client APIs which use an integer or other type for
+   *      booleans cannot use this as the base type for their boolean.
+   *
+   * Tokens defined in khrplatform.h:
+   *
+   *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+   *
+   *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+   *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+   *
+   * Calling convention macros defined in this file:
+   *    KHRONOS_APICALL
+   *    KHRONOS_APIENTRY
+   *    KHRONOS_APIATTRIBUTES
+   *
+   * These may be used in function prototypes as:
+   *
+   *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+   *                                  int arg1,
+   *                                  int arg2) KHRONOS_APIATTRIBUTES;
+   *)
+
+{$IfDef EGL_NO_PLATFORM_SPECIFIC_TYPES}
+// Это значение по умолчанию, для каких систем вообще?
+type
+  EGLNativeDisplayType = pointer;
+  EGLNativePixmapType = pointer;
+  EGLNativeWindowType = pointer;
+{$EndIf}
+
+{$IfDef Windows}           // для всех Windows? Или только для 32-х битной?
+type
+  EGLNativeDisplayType = HDC;
+  EGLNativePixmapType = HBITMAP;
+  EGLNativeWindowType = HWND;
+{$EndIf}
+  (*{$else defined(__EMSCRIPTEN__)}     // что за платформа?
+    type
+      EGLNativeDisplayType = longint;
+      EGLNativePixmapType = longint;
+      EGLNativeWindowType = longint;   *)
+
+{$If defined(__WINSCW__) or defined(__SYMBIAN32__)}  // Symbian    // может пригодится...
+type
+  EGLNativeDisplayType = longint;
+  EGLNativePixmapType = pointer;
+  EGLNativeWindowType = pointer;
+{$IfEnd}
+
+  (* {$else defined(__GBM__)}           // что за платформа?
+    type
+      EGLNativeDisplayType = ^gbm_device;
+      EGLNativePixmapType = ^gbm_bo;
+      EGLNativeWindowType = pointer;   *)
+
+{$IfDef ANDROID}
+type
+  ANativeWindow = record end;
+  egl_native_pixmap_t = record end;
+
+  EGLNativeDisplayType = pointer;
+  EGLNativePixmapType = ^egl_native_pixmap_t;
+  EGLNativeWindowType = ^ANativeWindow;
+{$EndIf}
+
+  (* {$else defined(USE_OZONE)}         // что за платформа?
+    type
+      EGLNativeDisplayType = intptr_t;
+      EGLNativePixmapType = intptr_t;
+      EGLNativeWindowType = intptr_t;  *)
+
+{$IfDef UNIX)}
+  {$If not defined(LINUX) and not defined(MACOSX) and not defined(ANDROID)}     // QNX???
+  type
+    EGLNativeDisplayType = pointer;
+    EGLNativePixmapType = khronos_uintptr_t;              // khronos_uintptr_t = qword;
+    EGLNativeWindowType = khronos_uintptr_t;              // or khronos_uintptr_t = dword;   в зависимости от разрядности.
+  {$IfEnd}
+
+  {$IfDef LINUX}
+  {$IfDef WAYLAND}              // Wayland       WL_EGL_PLATFORM
+  type
+    EGLNativeDisplayType = ^wl_display;
+    EGLNativePixmapType = ^wl_egl_pixmap;
+    EGLNativeWindowType = ^wl_egl_window;
+  {$Else}
+  type
+    EGLNativeDisplayType = PDisplay;
+    EGLNativePixmapType = TPixmap;
+    EGLNativeWindowType = TWindow;
+  {$EndIf}{$EndIf}
+
+  {$IfDef MACOSX}
+  type
+    EGLNativeDisplayType = longint;
+    EGLNativePixmapType = pointer;
+    EGLNativeWindowType = pointer;
+  {$EndIf}
+{$EndIf}
+
+{$IfDef __HAIKU__}
+type
+  EGLNativeDisplayType = pointer;
+  EGLNativePixmapType = khronos_uintptr_t;
+  EGLNativeWindowType = khronos_uintptr_t;
+{$EndIf}
+
+{$IfDef __Fuchsia__}
+type
+  EGLNativeDisplayType = pointer;
+  EGLNativePixmapType = khronos_uintptr_t;
+  EGLNativeWindowType = khronos_uintptr_t;
+{$endif}
+
+{$IfDef QNX}
+type
+  EGLNativeDisplayType = khronos_uintptr_t;
+  EGLNativePixmapType = ^_screen_pixmap;
+  EGLNativeWindowType = ^_screen_window;
+{$EndIf}
+
+    { EGL 1.2 types, renamed for consistency in EGL 1.3  }
+type
+  NativeDisplayType = EGLNativeDisplayType;
+  NativePixmapType = EGLNativePixmapType;
+  NativeWindowType = EGLNativeWindowType;
+    { Define EGLint. This must be a signed integral type large enough to contain
+     * all legal attribute names and values passed into and out of EGL, whether
+     * their type is boolean, bitmask, enumerant (symbolic constant), integer,
+     * handle, or other.  While in general a 32-bit integer will suffice, if
+     * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
+     * integer type.
+      }
+
+type
+  EGLSync = pointer;
+  {$IfDef CPU64}
+  EGLTime = QWord;       // khronos_utime_nanoseconds_t
+  {$Else}
+  EGLTime = DWord;
+  {$EndIf}
+  PEGLImage  = ^EGLImage;
+  EGLImage = pointer;
+
+  PAHardwareBuffer  = ^AHardwareBuffer;
+  Pchar  = ^char;
+  PEGLAttribKHR  = ^EGLAttribKHR;
+  {$IfDef CPU64}
+  EGLAttribKHR = int64;           // intptr_t
+  {$Else}
+  EGLAttribKHR = LongInt;         // intptr_t;
+  {$EndIf}
+  PEGLBoolean  = ^EGLBoolean;
+  PEGLClientPixmapHI  = ^EGLClientPixmapHI;
+  PEGLDeviceEXT  = ^EGLDeviceEXT;
+
+  PEGLNativeDisplayType  = ^EGLNativeDisplayType;
+  PEGLNativePixmapType  = ^EGLNativePixmapType;
+  PEGLNativeWindowType  = ^EGLNativeWindowType;
+  PEGLnsecsANDROID  = ^EGLnsecsANDROID;
+  {$IfDef CPU64}
+  EGLnsecsANDROID = Int64;        // khronos_stime_nanoseconds_t;
+  {$Else}
+  EGLnsecsANDROID = LongInt;      // khronos_stime_nanoseconds_t;
+  {$EndIf}
+  PEGLOutputLayerEXT  = ^EGLOutputLayerEXT;
+  PEGLOutputPortEXT  = ^EGLOutputPortEXT;
+  PEGLTimeKHR  = ^EGLTimeKHR;
+  PEGLuint64KHR  = ^EGLuint64KHR;
+  {$IfDef CPU64}
+  EGLTimeKHR = QWord;       // khronos_utime_nanoseconds_t
+  EGLuint64KHR = QWord;     // khronos_uint64_t;
+  {$Else}
+  EGLTimeKHR = DWord;
+  EGLuint64KHR = DWord;     // khronos_uint64_t;
+  {$EndIf}
+//
+  PEGLAttrib  = ^EGLAttrib;
+  {$IfDef CPU64}
+  EGLAttrib = int64;           // intptr_t
+  {$Else}
+  EGLAttrib = LongInt;         // intptr_t;
+  {$EndIf}
+  PEGLConfig  = ^EGLConfig;
+  PEGLint  = ^EGLint;
+  EGLint = longint;
+  EGLConfig = pointer;
+  EGLBoolean = LongBool; // dword;
+  EGLDisplay = pointer;
+
+  EGLSurface = pointer;
+  EGLContext = pointer;
+  PEGLenum  = ^EGLenum;
+  EGLenum = DWord;
+  EGLClientBuffer = pointer;
+//const
+
+(*  {$IfDef WINDOWS}
+  EGL_DEFAULT_DISPLAY = 0;
+  {$ELSE}
+  EGL_DEFAULT_DISPLAY = nil;
+  {$EndIf}
+  EGL_NO_CONTEXT      = nil;
+  EGL_NO_DISPLAY      = nil;
+  EGL_NO_SURFACE      = nil; *)
+
+//
+  Plongint  = ^longint;
+  Pwl_display  = ^wl_display;
+  Pwl_resource  = ^wl_resource;
+  Pwl_buffer = ^wl_buffer;
+
+  EGLSyncKHR = pointer;
+
+  EGLLabelKHR = pointer;
+  EGLObjectKHR = pointer;
+
+  EGLImageKHR = pointer;
+  EGLStreamKHR = pointer;
+  EGLNativeFileDescriptorKHR = longint;
+  {$IfDef CPU64}
+  EGLsizeiANDROID = Int64;       // khronos_ssize_t;
+  {$Else}
+  EGLsizeiANDROID = LongInt;     // khronos_ssize_t;
+  {$EndIf}
+
+  AHardwareBuffer = record end;
+
+  EGLDeviceEXT = pointer;
+  EGLOutputLayerEXT = pointer;
+  EGLOutputPortEXT = pointer;
+
+  {$IfDef EGL_HI_clientpixmap}
+  EGLClientPixmapHI = record
+    pData : pointer;
+    iWidth : EGLint;
+    iHeight : EGLint;
+    iStride : EGLint;
+  end;
+  {$EndIf}
+
+  EGLSyncNV = pointer;
+  {$IfDef CPU64}
+  EGLTimeNV = QWord;             // khronos_utime_nanoseconds_t;
+  EGLuint64NV = QWord;           // khronos_utime_nanoseconds_t;
+  {$Else}
+  EGLTimeNV = DWord;             // khronos_utime_nanoseconds_t;
+  EGLuint64NV = DWord;           // khronos_utime_nanoseconds_t;
+  {$EndIf}
+
+  wl_display = record end;
+  wl_resource = record end;
+  wl_buffer = record end;
+
+  // __eglMustCastToProperFunctionPointerType = procedure (_para1: pointer); cdecl;
+
+var
+  eglLibrary  : {$IFDEF WINDOWS}LongWord{$ELSE}Pointer{$ENDIF};
+  separateEGL : Boolean;
+
+  {$IfDef EGL_VERSION_1_0}
+var
+  // eglGetProcAddress: function(procname: Pchar): __eglMustCastToProperFunctionPointerType; stdcall;
+  eglGetProcAddress: function(name: PAnsiChar): Pointer; stdcall;
+  eglChooseConfig: function(dpy: EGLDisplay; attrib_list: PEGLint; configs: PEGLConfig; config_size: EGLint; num_config: PEGLint): EGLBoolean; stdcall;
+  eglCreateContext: function(dpy: EGLDisplay; config: EGLConfig; share_context: EGLContext; attrib_list: PEGLint): EGLContext; stdcall;
+  eglCreateWindowSurface: function(dpy: EGLDisplay; config: EGLConfig; win: EGLNativeWindowType; attrib_list: PEGLint): EGLSurface; stdcall;
+  eglDestroyContext: function(dpy: EGLDisplay; ctx: EGLContext): EGLBoolean; stdcall;
+  eglDestroySurface: function(dpy: EGLDisplay; surface: EGLSurface): EGLBoolean; stdcall;
+  eglGetDisplay: function(display_id: EGLNativeDisplayType): EGLDisplay; stdcall;
+  eglGetError: function: EGLint; stdcall;
+  eglInitialize: function(dpy: EGLDisplay; major: PEGLint; minor: PEGLint): EGLBoolean; stdcall;
+  eglMakeCurrent: function(dpy: EGLDisplay; draw: EGLSurface; read: EGLSurface; ctx: EGLContext): EGLBoolean; stdcall;
+  eglSwapBuffers: function(dpy: EGLDisplay; surface: EGLSurface): EGLBoolean; stdcall;
+  eglTerminate: function(dpy: EGLDisplay): EGLBoolean; stdcall;
+  {$IfDef EGL_NO_MIN}
+  eglCopyBuffers: function(dpy: EGLDisplay; surface: EGLSurface; target: EGLNativePixmapType): EGLBoolean; stdcall;
+  eglCreatePbufferSurface: function(dpy: EGLDisplay; config: EGLConfig; attrib_list: PEGLint): EGLSurface; stdcall;
+  eglCreatePixmapSurface: function(dpy: EGLDisplay; config: EGLConfig; pixmap: EGLNativePixmapType; attrib_list: PEGLint): EGLSurface; stdcall;
+  eglGetConfigAttrib: function(dpy: EGLDisplay; config: EGLConfig; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  eglGetConfigs: function(dpy: EGLDisplay; configs: PEGLConfig; config_size: EGLint; num_config: PEGLint): EGLBoolean; stdcall;
+  eglGetCurrentDisplay: function: EGLDisplay; stdcall;
+  eglGetCurrentSurface: function(readdraw: EGLint): EGLSurface; stdcall;
+  eglQueryContext: function(dpy: EGLDisplay; ctx: EGLContext; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  eglQueryString: function(dpy: EGLDisplay; name: EGLint): Pchar; stdcall;
+  eglQuerySurface: function(dpy: EGLDisplay; surface: EGLSurface; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  eglWaitGL: function: EGLBoolean; stdcall;
+  eglWaitNative: function(engine: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_1}
+var
+  {$IfDef EGL_NO_MIN}
+  eglBindTexImage: function(dpy: EGLDisplay; surface: EGLSurface; buffer: EGLint): EGLBoolean; stdcall;
+  eglReleaseTexImage: function(dpy: EGLDisplay; surface: EGLSurface; buffer: EGLint): EGLBoolean; stdcall;
+  eglSurfaceAttrib: function(dpy: EGLDisplay; surface: EGLSurface; attribute: EGLint; value: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+  eglSwapInterval: function(dpy: EGLDisplay; interval: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NO_MIN}
+  {$IfDef EGL_VERSION_1_2}
+var
+  eglBindAPI: function(api: EGLenum): EGLBoolean; stdcall;
+  eglQueryAPI: function: EGLenum; stdcall;
+  eglCreatePbufferFromClientBuffer: function(dpy: EGLDisplay; buftype: EGLenum; buffer: EGLClientBuffer; config: EGLConfig; attrib_list: PEGLint): EGLSurface; stdcall;
+  eglReleaseThread: function: EGLBoolean; stdcall;
+  eglWaitClient: function: EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_3}
+//  function EGL_DEFAULT_DISPLAY: longint;
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_4}
+var
+  eglGetCurrentContext: function: EGLContext; stdcall;
+//  function EGL_NO_SYNC: longint;
+//  function EGL_NO_IMAGE: longint;
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_5}
+var
+  eglCreateSync: function(dpy: EGLDisplay; _type: EGLenum; attrib_list: PEGLAttrib): EGLSync; stdcall;
+  eglDestroySync: function(dpy: EGLDisplay; sync: EGLSync): EGLBoolean; stdcall;
+  eglClientWaitSync: function(dpy: EGLDisplay; sync: EGLSync; flags: EGLint; timeout: EGLTime): EGLint; stdcall;
+  eglGetSyncAttrib: function(dpy: EGLDisplay; sync: EGLSync; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglCreateImage: function(dpy: EGLDisplay; ctx: EGLContext; target: EGLenum; buffer: EGLClientBuffer; attrib_list: PEGLAttrib): EGLImage; stdcall;
+  eglDestroyImage: function(dpy: EGLDisplay; image: EGLImage): EGLBoolean; stdcall;
+  eglGetPlatformDisplay: function(platform: EGLenum; native_display: pointer; attrib_list: PEGLAttrib): EGLDisplay; stdcall;
+  eglCreatePlatformWindowSurface: function(dpy: EGLDisplay; config: EGLConfig; native_window: pointer; attrib_list: PEGLAttrib): EGLSurface; stdcall;
+  eglCreatePlatformPixmapSurface: function(dpy: EGLDisplay; config: EGLConfig; native_pixmap: pointer; attrib_list: PEGLAttrib): EGLSurface; stdcall;
+  eglWaitSync: function(dpy: EGLDisplay; sync: EGLSync; flags: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_cl_event2}
+  eglCreateSync64KHR: function(dpy: EGLDisplay; _type: EGLenum; attrib_list: PEGLAttribKHR): EGLSyncKHR; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_debug}
+type
+  EGLDEBUGPROCKHR = procedure (error: EGLenum; command: Pchar; messageType: EGLint; threadLabel: EGLLabelKHR; objectLabel: EGLLabelKHR;
+                  message: Pchar); stdcall;
+
+var
+  eglDebugMessageControlKHR: function(callback: EGLDEBUGPROCKHR; attrib_list: PEGLAttrib): EGLint; stdcall;
+  eglQueryDebugKHR: function(attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglLabelObjectKHR: function(display: EGLDisplay; objectType: EGLenum; objectKHR: EGLObjectKHR; _label: EGLLabelKHR): EGLint; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_display_reference}
+  eglQueryDisplayAttribKHR: function(dpy: EGLDisplay; name: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_fence_sync}
+  {$IfDef CPU64}
+  eglCreateSyncKHR: function(dpy: EGLDisplay; _type: EGLenum; attrib_list: PEGLint): EGLSyncKHR; stdcall;
+  eglDestroySyncKHR: function(dpy: EGLDisplay; sync: EGLSyncKHR): EGLBoolean; stdcall;
+  eglClientWaitSyncKHR: function(dpy: EGLDisplay; sync: EGLSyncKHR; flags: EGLint; timeout: EGLTimeKHR): EGLint; stdcall;
+  eglGetSyncAttribKHR: function(dpy: EGLDisplay; sync: EGLSyncKHR; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+  {$EndIf}
+
+//  function EGL_NO_IMAGE_KHR: longint;
+
+  {$IfDef EGL_KHR_image}
+  eglCreateImageKHR: function(dpy: EGLDisplay; ctx: EGLContext; target: EGLenum; buffer: EGLClientBuffer; attrib_list: PEGLint): EGLImageKHR; stdcall;
+  eglDestroyImageKHR: function(dpy: EGLDisplay; image: EGLImageKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface}
+  eglLockSurfaceKHR: function(dpy: EGLDisplay; surface: EGLSurface; attrib_list: PEGLint): EGLBoolean; stdcall;
+  eglUnlockSurfaceKHR: function(dpy: EGLDisplay; surface: EGLSurface): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface3}
+  eglQuerySurface64KHR: function(dpy: EGLDisplay; surface: EGLSurface; attribute: EGLint; value: PEGLAttribKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+//  function EGL_NO_CONFIG_KHR: longint;
+
+  {$IfDef EGL_KHR_partial_update}
+  eglSetDamageRegionKHR: function(dpy: EGLDisplay; surface: EGLSurface; rects: PEGLint; n_rects: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+//  function EGL_NO_SYNC_KHR: longint;
+
+  {$IfDef EGL_KHR_reusable_sync}
+  {$IfDef CPU64}
+  eglSignalSyncKHR: function(dpy: EGLDisplay; sync: EGLSyncKHR; mode: EGLenum): EGLBoolean; stdcall;
+  {$EndIf}{$EndIf}
+
+//  function EGL_NO_STREAM_KHR: longint; { return type might be wrong }
+  {$IfDef EGL_KHR_stream}
+  {$IfDef CPU64}
+  eglCreateStreamKHR: function(dpy: EGLDisplay; attrib_list: PEGLint): EGLStreamKHR; stdcall;
+  eglDestroyStreamKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  eglStreamAttribKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: EGLint): EGLBoolean; stdcall;
+  eglQueryStreamKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: PEGLint): EGLBoolean; stdcall;
+  eglQueryStreamu64KHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: PEGLuint64KHR): EGLBoolean; stdcall;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_attrib}
+  {$IfDef CPU64}
+  eglCreateStreamAttribKHR: function(dpy: EGLDisplay; attrib_list: PEGLAttrib): EGLStreamKHR; stdcall;
+  eglSetStreamAttribKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: EGLAttrib): EGLBoolean; stdcall;
+  eglQueryStreamAttribKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglStreamConsumerAcquireAttribKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attrib_list: PEGLAttrib):EGLBoolean; stdcall;
+  eglStreamConsumerReleaseAttribKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attrib_list: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_consumer_gltexture}
+  eglStreamConsumerGLTextureExternalKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  eglStreamConsumerAcquireKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  eglStreamConsumerReleaseKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_cross_process_fd}
+  eglGetStreamFileDescriptorKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLNativeFileDescriptorKHR; stdcall;
+  eglCreateStreamFromFileDescriptorKHR: function(dpy: EGLDisplay; file_descriptor: EGLNativeFileDescriptorKHR): EGLStreamKHR; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_fifo}
+  eglQueryStreamTimeKHR: function(dpy: EGLDisplay; stream: EGLStreamKHR; attribute: EGLenum; value: PEGLTimeKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_producer_eglsurface}
+  eglCreateStreamProducerSurfaceKHR: function(dpy: EGLDisplay; config: EGLConfig; stream: EGLStreamKHR; attrib_list: PEGLint): EGLSurface; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageKHR: function(dpy: EGLDisplay; surface: EGLSurface; rects: PEGLint; n_rects: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_wait_sync}
+  eglWaitSyncKHR: function(dpy: EGLDisplay; sync: EGLSyncKHR; flags: EGLint): EGLint; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_blob_cache}
+type
+  EGLSetBlobFuncANDROID = procedure (key: pointer; keySize: EGLsizeiANDROID; value: pointer; valueSize: EGLsizeiANDROID); stdcall;
+  EGLGetBlobFuncANDROID = function (key: pointer; keySize: EGLsizeiANDROID; value: pointer; valueSize: EGLsizeiANDROID): EGLsizeiANDROID; stdcall;
+
+var
+  eglSetBlobCacheFuncsANDROID: procedure(dpy: EGLDisplay; setBlob: EGLSetBlobFuncANDROID; get: EGLGetBlobFuncANDROID); stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_create_native_client_buffer}
+  eglCreateNativeClientBufferANDROID: function(attrib_list: PEGLint): EGLClientBuffer; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_frame_timestamps}
+  eglGetCompositorTimingSupportedANDROID: function(dpy: EGLDisplay; surface: EGLSurface; name: EGLint): EGLBoolean; stdcall;
+  eglGetCompositorTimingANDROID: function(dpy: EGLDisplay; surface: EGLSurface; numTimestamps: EGLint; names: PEGLint; values: PEGLnsecsANDROID): EGLBoolean; stdcall;
+  eglGetNextFrameIdANDROID: function(dpy: EGLDisplay; surface: EGLSurface; frameId: PEGLuint64KHR): EGLBoolean; stdcall;
+  eglGetFrameTimestampSupportedANDROID: function(dpy: EGLDisplay; surface: EGLSurface; timestamp: EGLint): EGLBoolean; stdcall;
+  eglGetFrameTimestampsANDROID: function(dpy: EGLDisplay; surface: EGLSurface; frameId: EGLuint64KHR; numTimestamps: EGLint; timestamps: PEGLint;
+             values:PEGLnsecsANDROID): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_native_client_buffer}
+  eglGetNativeClientBufferANDROID: function(buffer: PAHardwareBuffer): EGLClientBuffer; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_native_fence_sync}
+  eglDupNativeFenceFDANDROID: function(dpy: EGLDisplay; sync: EGLSyncKHR): EGLint; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_presentation_time}
+  eglPresentationTimeANDROID: function(dpy: EGLDisplay; surface: EGLSurface; time: EGLnsecsANDROID): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_query_surface_pointer}
+  eglQuerySurfacePointerANGLE: function(dpy: EGLDisplay; surface: EGLSurface; attribute: EGLint; value: Ppointer): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_sync_control_rate}
+  eglGetMscRateANGLE: function(dpy: EGLDisplay; surface: EGLSurface; numerator: PEGLint; denominator: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_client_sync}
+  eglClientSignalSyncEXT: function(dpy: EGLDisplay; sync: EGLSync; attrib_list: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_compositor}
+  eglCompositorSetContextListEXT: function(external_ref_ids: PEGLint; num_entries: EGLint): EGLBoolean; stdcall;
+  eglCompositorSetContextAttributesEXT: function(external_ref_id: EGLint; context_attributes: PEGLint; num_entries: EGLint): EGLBoolean; stdcall;
+  eglCompositorSetWindowListEXT: function(external_ref_id: EGLint; external_win_ids: PEGLint; num_entries: EGLint): EGLBoolean; stdcall;
+  eglCompositorSetWindowAttributesEXT: function(external_win_id: EGLint; window_attributes: PEGLint; num_entries: EGLint): EGLBoolean; stdcall;
+  eglCompositorBindTexWindowEXT: function(external_win_id: EGLint): EGLBoolean; stdcall;
+  eglCompositorSetSizeEXT: function(external_win_id: EGLint; width: EGLint; height: EGLint): EGLBoolean; stdcall;
+  eglCompositorSwapPolicyEXT: function(external_win_id: EGLint; policy: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_base}
+  eglQueryDeviceAttribEXT: function(device: EGLDeviceEXT; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglQueryDeviceStringEXT: function(device: EGLDeviceEXT; name: EGLint): Pchar; stdcall;
+  eglQueryDevicesEXT: function(max_devices: EGLint; devices: PEGLDeviceEXT; num_devices: PEGLint): EGLBoolean; stdcall;
+  eglQueryDisplayAttribEXT: function(dpy: EGLDisplay; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_persistent_id}
+  eglQueryDeviceBinaryEXT: function(device: EGLDeviceEXT; name: EGLint; max_size: EGLint; value: pointer; size: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_image_dma_buf_import_modifiers}
+  eglQueryDmaBufFormatsEXT: function(dpy: EGLDisplay; max_formats: EGLint; formats: PEGLint; num_formats: PEGLint): EGLBoolean; stdcall;
+  eglQueryDmaBufModifiersEXT: function(dpy: EGLDisplay; format: EGLint; max_modifiers: EGLint; modifiers: PEGLuint64KHR; external_only: PEGLBoolean;
+             num_modifiers: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_output_base}
+  eglGetOutputLayersEXT: function(dpy: EGLDisplay; attrib_list: PEGLAttrib; layers: PEGLOutputLayerEXT; max_layers: EGLint; num_layers: PEGLint): EGLBoolean; stdcall;
+  eglGetOutputPortsEXT: function(dpy: EGLDisplay; attrib_list: PEGLAttrib; ports: PEGLOutputPortEXT; max_ports: EGLint; num_ports: PEGLint): EGLBoolean; stdcall;
+  eglOutputLayerAttribEXT: function(dpy: EGLDisplay; layer: EGLOutputLayerEXT; attribute: EGLint; value: EGLAttrib): EGLBoolean; stdcall;
+  eglQueryOutputLayerAttribEXT: function(dpy: EGLDisplay; layer: EGLOutputLayerEXT; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglQueryOutputLayerStringEXT: function(dpy: EGLDisplay; layer: EGLOutputLayerEXT; name: EGLint): Pchar; stdcall;
+  eglOutputPortAttribEXT: function(dpy: EGLDisplay; port: EGLOutputPortEXT; attribute: EGLint; value: EGLAttrib): EGLBoolean; stdcall;
+  eglQueryOutputPortAttribEXT: function(dpy: EGLDisplay; port: EGLOutputPortEXT; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglQueryOutputPortStringEXT: function(dpy: EGLDisplay; port: EGLOutputPortEXT; name: EGLint): Pchar; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_platform_base}
+  eglGetPlatformDisplayEXT: function(platform: EGLenum; native_display: pointer; attrib_list: PEGLint): EGLDisplay; stdcall;
+  eglCreatePlatformWindowSurfaceEXT: function(dpy: EGLDisplay; config: EGLConfig; native_window: pointer; attrib_list: PEGLint): EGLSurface; stdcall;
+  eglCreatePlatformPixmapSurfaceEXT: function(dpy: EGLDisplay; config: EGLConfig; native_pixmap: pointer; attrib_list: PEGLint): EGLSurface; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_stream_consumer_egloutput}
+  eglStreamConsumerOutputEXT: function(dpy: EGLDisplay; stream: EGLStreamKHR; layer: EGLOutputLayerEXT): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_surface_compression}
+  eglQuerySupportedCompressionRatesEXT: function(dpy: EGLDisplay; configs: PEGLConfig; attrib_list: PEGLAttrib; rates: PEGLint; rate_size: EGLint;
+             num_rates: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageEXT: function(dpy: EGLDisplay; surface: EGLSurface; rects: PEGLint; n_rects: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_sync_reuse}
+  eglUnsignalSyncEXT: function(dpy: EGLDisplay; sync: EGLSync; attrib_list: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_HI_clientpixmap}
+  eglCreatePixmapSurfaceHI: function(dpy: EGLDisplay; config: EGLConfig; pixmap: PEGLClientPixmapHI): EGLSurface; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_drm_image}
+  eglCreateDRMImageMESA: function(dpy: EGLDisplay; attrib_list: PEGLint): EGLImageKHR; stdcall;
+  eglExportDRMImageMESA: function(dpy: EGLDisplay; image: EGLImageKHR; name: PEGLint; handle: PEGLint; stride: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_image_dma_buf_export}
+  eglExportDMABUFImageQueryMESA: function(dpy: EGLDisplay; image: EGLImageKHR; fourcc: Plongint; num_planes: Plongint; modifiers: PEGLuint64KHR): EGLBoolean; stdcall;
+  eglExportDMABUFImageMESA: function(dpy: EGLDisplay; image: EGLImageKHR; fds: Plongint; strides: PEGLint; offsets: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_query_driver}
+  eglGetDisplayDriverConfig: function(dpy: EGLDisplay): Pchar; stdcall;
+  eglGetDisplayDriverName: function(dpy: EGLDisplay): Pchar; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region}
+  eglSwapBuffersRegionNOK: function(dpy: EGLDisplay; surface: EGLSurface; numRects: EGLint; rects: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region2}
+  eglSwapBuffersRegion2NOK: function(dpy: EGLDisplay; surface: EGLSurface; numRects: EGLint; rects: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_native_query}
+  eglQueryNativeDisplayNV: function(dpy: EGLDisplay; display_id: PEGLNativeDisplayType): EGLBoolean; stdcall;
+  eglQueryNativeWindowNV: function(dpy: EGLDisplay; surf: EGLSurface; window: PEGLNativeWindowType): EGLBoolean; stdcall;
+  eglQueryNativePixmapNV: function(dpy: EGLDisplay; surf: EGLSurface; pixmap: PEGLNativePixmapType): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_post_sub_buffer}
+  eglPostSubBufferNV: function(dpy: EGLDisplay; surface: EGLSurface; x: EGLint; y: EGLint; width: EGLint;
+             height: EGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_eglimage}
+  eglStreamImageConsumerConnectNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; num_modifiers: EGLint; modifiers: PEGLuint64KHR; attrib_list: PEGLAttrib): EGLBoolean; stdcall;
+  eglQueryStreamConsumerEventNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; timeout: EGLTime; event: PEGLenum; aux: PEGLAttrib): EGLint; stdcall;
+  eglStreamAcquireImageNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; pImage: PEGLImage; sync: EGLSync): EGLBoolean; stdcall;
+  eglStreamReleaseImageNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; image: EGLImage; sync: EGLSync): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_gltexture_yuv}
+  eglStreamConsumerGLTextureExternalAttribsNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; attrib_list: PEGLAttrib): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_flush}
+  eglStreamFlushNV: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_metadata}
+  eglQueryDisplayAttribNV: function(dpy: EGLDisplay; attribute: EGLint; value: PEGLAttrib): EGLBoolean; stdcall;
+  eglSetStreamMetadataNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; n: EGLint; offset: EGLint; size: EGLint;
+             data: pointer): EGLBoolean; stdcall;
+  eglQueryStreamMetadataNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; name: EGLenum; n: EGLint; offset: EGLint;
+             size: EGLint; data: pointer): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_reset}
+  eglResetStreamNV: function(dpy: EGLDisplay; stream: EGLStreamKHR): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_sync}
+  eglCreateStreamSyncNV: function(dpy: EGLDisplay; stream: EGLStreamKHR; _type: EGLenum; attrib_list: PEGLint): EGLSyncKHR; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_NV_sync}
+  {$IfDef CPU64}
+  eglCreateFenceSyncNV: function(dpy: EGLDisplay; condition: EGLenum; attrib_list: PEGLint): EGLSyncNV; stdcall;
+  eglDestroySyncNV: function(sync: EGLSyncNV): EGLBoolean; stdcall;
+  eglFenceNV: function(sync: EGLSyncNV): EGLBoolean; stdcall;
+  eglClientWaitSyncNV: function(sync: EGLSyncNV; flags: EGLint; timeout: EGLTimeNV): EGLint; stdcall;
+  eglSignalSyncNV: function(sync: EGLSyncNV; mode: EGLenum): EGLBoolean; stdcall;
+  eglGetSyncAttribNV: function(sync: EGLSyncNV; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_NV_system_time}
+  {$IfDef CPU64}
+  eglGetSystemTimeFrequencyNV: function: EGLuint64NV; stdcall;
+  eglGetSystemTimeNV: function: EGLuint64NV; stdcall;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_WL_bind_wayland_display}
+  eglBindWaylandDisplayWL: function(dpy: EGLDisplay; display: Pwl_display): EGLBoolean; stdcall;
+  eglUnbindWaylandDisplayWL: function(dpy: EGLDisplay; display: Pwl_display): EGLBoolean; stdcall;
+  eglQueryWaylandBufferWL: function(dpy: EGLDisplay; buffer: Pwl_resource; attribute: EGLint; value: PEGLint): EGLBoolean; stdcall;
+  {$EndIf}
+
+  {$IfDef EGL_WL_create_wayland_buffer_from_image}
+  {EGLAPI struct wl_buffer *EGLAPIENTRY eglCreateWaylandBufferFromImageWL (EGLDisplay dpy, EGLImageKHR image); }
+  eglCreateWaylandBufferFromImageWL: function(dpy: EGLDisplay; image: EGLImageKHR): Pwl_buffer; stdcall;
+  {$EndIf}
+  {$EndIf}
+
+function InitEGL: Boolean;
+procedure FreeEGL;
+
+implementation
+
+function InitEGL: Boolean;
+begin
+  Result := False;
+  {$IfDef EGL_VERSION_1_0}
+  eglGetProcAddress := dlsym(eglLibrary, 'eglGetProcAddress');
+  if not Assigned(eglGetProcAddress) then
+    exit;
+
+  eglChooseConfig := eglGetProcAddress('eglChooseConfig');
+  eglCreateContext := eglGetProcAddress('eglCreateContext');
+  eglCreateWindowSurface := eglGetProcAddress('eglCreateWindowSurface');
+  eglDestroyContext := eglGetProcAddress('eglDestroyContext');
+  eglDestroySurface := eglGetProcAddress('eglDestroySurface');
+  eglGetDisplay := eglGetProcAddress('eglGetDisplay');
+  eglGetError := eglGetProcAddress('eglGetError');
+  eglInitialize := eglGetProcAddress('eglInitialize');
+  eglMakeCurrent := eglGetProcAddress('eglMakeCurrent');
+  eglSwapBuffers := eglGetProcAddress('eglSwapBuffers');
+  eglTerminate := eglGetProcAddress('eglTerminate');
+  if not Assigned(eglGetDisplay) or not Assigned(eglInitialize) or not Assigned(eglTerminate) or not Assigned(eglChooseConfig) or
+     not Assigned(eglCreateWindowSurface) or not Assigned(eglDestroySurface) or not Assigned(eglCreateContext) or not Assigned(eglDestroyContext) or
+     not Assigned(eglMakeCurrent) or not Assigned(eglSwapBuffers) then
+    exit;
+  {$IfDef EGL_NO_MIN}
+  eglCopyBuffers := eglGetProcAddress('eglCopyBuffers');
+  eglCreatePbufferSurface := eglGetProcAddress('eglCreatePbufferSurface');
+  eglCreatePixmapSurface := eglGetProcAddress('eglCreatePixmapSurface');   // eglCreatePixmapSurfaceHI
+  eglGetConfigAttrib := eglGetProcAddress('eglGetConfigAttrib');
+  eglGetConfigs := eglGetProcAddress('eglGetConfigs');
+  eglGetCurrentDisplay := eglGetProcAddress('eglGetCurrentDisplay');
+  eglGetCurrentSurface := eglGetProcAddress('eglGetCurrentSurface');
+  eglQueryContext := eglGetProcAddress('eglQueryContext');
+  eglQueryString := eglGetProcAddress('eglQueryString');
+  eglQuerySurface := eglGetProcAddress('eglQuerySurface');          // eglQuerySurface64KHR
+  eglWaitGL := eglGetProcAddress('eglWaitGL');
+  eglWaitNative := eglGetProcAddress('eglWaitNative');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_VERSION_1_1}
+  {$IfDef EGL_NO_MIN}
+  eglBindTexImage := eglGetProcAddress('eglBindTexImage');
+  eglReleaseTexImage := eglGetProcAddress('eglReleaseTexImage');
+  eglSurfaceAttrib := eglGetProcAddress('eglSurfaceAttrib');
+  {$EndIf}
+  eglSwapInterval := eglGetProcAddress('eglSwapInterval');
+  {$EndIf}
+
+  {$IfDef EGL_NO_MIN}
+  {$IfDef EGL_VERSION_1_2}
+  eglBindAPI := eglGetProcAddress('eglBindAPI');
+  eglQueryAPI := eglGetProcAddress('eglQueryAPI');
+  eglCreatePbufferFromClientBuffer := eglGetProcAddress('eglCreatePbufferFromClientBuffer');
+  eglReleaseThread := eglGetProcAddress('eglReleaseThread');
+  eglWaitClient := eglGetProcAddress('eglWaitClient');
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_4}
+  eglGetCurrentContext := eglGetProcAddress('eglGetCurrentContext');
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_5}
+  eglCreateSync := eglGetProcAddress('eglCreateSync');                                     // KHR, 64KHR
+  eglDestroySync := eglGetProcAddress('eglDestroySync');                                   // KHR, NV
+  eglClientWaitSync := eglGetProcAddress('eglClientWaitSync');                             // KHR, NV
+  eglGetSyncAttrib := eglGetProcAddress('eglGetSyncAttrib');                               // KHR, NV
+  eglCreateImage := eglGetProcAddress('eglCreateImage');                                   // KHR
+  eglDestroyImage := eglGetProcAddress('eglDestroyImage');                                 // KHR
+  eglGetPlatformDisplay := eglGetProcAddress('eglGetPlatformDisplay');                     // EXT
+  eglCreatePlatformWindowSurface := eglGetProcAddress('eglCreatePlatformWindowSurface');   // EXT
+  eglCreatePlatformPixmapSurface := eglGetProcAddress('eglCreatePlatformPixmapSurface');   // EXT
+  eglWaitSync := eglGetProcAddress('eglWaitSync');                                         // KHR
+  {$EndIf}
+
+  {$IfDef EGL_KHR_cl_event2}
+  eglCreateSync64KHR := eglGetProcAddress('eglCreateSync64KHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_debug}
+  eglDebugMessageControlKHR := eglGetProcAddress('eglDebugMessageControlKHR');
+  eglQueryDebugKHR := eglGetProcAddress('eglQueryDebugKHR');
+  eglLabelObjectKHR := eglGetProcAddress('eglLabelObjectKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_display_reference}
+  eglQueryDisplayAttribKHR := eglGetProcAddress('eglQueryDisplayAttribKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_fence_sync}
+  {$IfDef CPU64}
+  eglCreateSyncKHR := eglGetProcAddress('eglCreateSyncKHR');
+  eglDestroySyncKHR := eglGetProcAddress('eglDestroySyncKHR');
+  eglClientWaitSyncKHR := eglGetProcAddress('eglClientWaitSyncKHR');
+  eglGetSyncAttribKHR := eglGetProcAddress('eglGetSyncAttribKHR');
+  {$EndIf}
+  {$EndIf}
+
+  {$IfDef EGL_KHR_image}
+  eglCreateImageKHR := eglGetProcAddress('eglCreateImageKHR');
+  eglDestroyImageKHR := eglGetProcAddress('eglDestroyImageKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface}
+  eglLockSurfaceKHR := eglGetProcAddress('eglLockSurfaceKHR');
+  eglUnlockSurfaceKHR := eglGetProcAddress('eglUnlockSurfaceKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface3}
+  eglQuerySurface64KHR := eglGetProcAddress('eglQuerySurface64KHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_partial_update}
+  eglSetDamageRegionKHR := eglGetProcAddress('eglSetDamageRegionKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_reusable_sync}
+  {$IfDef CPU64}
+  eglSignalSyncKHR := eglGetProcAddress('eglSignalSyncKHR');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream}
+  {$IfDef CPU64}
+  eglCreateStreamKHR := eglGetProcAddress('eglCreateStreamKHR');
+  eglDestroyStreamKHR := eglGetProcAddress('eglDestroyStreamKHR');
+  eglStreamAttribKHR := eglGetProcAddress('eglStreamAttribKHR');
+  eglQueryStreamKHR := eglGetProcAddress('eglQueryStreamKHR');
+  eglQueryStreamu64KHR := eglGetProcAddress('eglQueryStreamu64KHR');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_attrib}
+  {$IfDef CPU64}
+  eglCreateStreamAttribKHR := eglGetProcAddress('eglCreateStreamAttribKHR');
+  eglSetStreamAttribKHR := eglGetProcAddress('eglSetStreamAttribKHR');
+  eglQueryStreamAttribKHR := eglGetProcAddress('eglQueryStreamAttribKHR');
+  eglStreamConsumerAcquireAttribKHR := eglGetProcAddress('eglStreamConsumerAcquireAttribKHR');
+  eglStreamConsumerReleaseAttribKHR := eglGetProcAddress('eglStreamConsumerReleaseAttribKHR');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_consumer_gltexture}
+  eglStreamConsumerGLTextureExternalKHR := eglGetProcAddress('eglStreamConsumerGLTextureExternalKHR');
+  eglStreamConsumerAcquireKHR := eglGetProcAddress('eglStreamConsumerAcquireKHR');
+  eglStreamConsumerReleaseKHR := eglGetProcAddress('eglStreamConsumerReleaseKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_cross_process_fd}
+  eglGetStreamFileDescriptorKHR := eglGetProcAddress('eglGetStreamFileDescriptorKHR');
+  eglCreateStreamFromFileDescriptorKHR := eglGetProcAddress('eglCreateStreamFromFileDescriptorKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_fifo}
+  eglQueryStreamTimeKHR := eglGetProcAddress('eglQueryStreamTimeKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_producer_eglsurface}
+  eglCreateStreamProducerSurfaceKHR := eglGetProcAddress('eglCreateStreamProducerSurfaceKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageKHR := eglGetProcAddress('eglSwapBuffersWithDamageKHR');
+  {$EndIf}
+
+  {$IfDef EGL_KHR_wait_sync}
+  eglWaitSyncKHR := eglGetProcAddress('eglWaitSyncKHR');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_blob_cache}
+  eglSetBlobCacheFuncsANDROID := eglGetProcAddress('eglSetBlobCacheFuncsANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_create_native_client_buffer}
+  eglCreateNativeClientBufferANDROID := eglGetProcAddress('eglCreateNativeClientBufferANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_frame_timestamps}
+  eglGetCompositorTimingSupportedANDROID := eglGetProcAddress('eglGetCompositorTimingSupportedANDROID');
+  eglGetCompositorTimingANDROID := eglGetProcAddress('eglGetCompositorTimingANDROID');
+  eglGetNextFrameIdANDROID := eglGetProcAddress('eglGetNextFrameIdANDROID');
+  eglGetFrameTimestampSupportedANDROID := eglGetProcAddress('eglGetFrameTimestampSupportedANDROID');
+  eglGetFrameTimestampsANDROID := eglGetProcAddress('eglGetFrameTimestampsANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_native_client_buffer}
+  eglGetNativeClientBufferANDROID := eglGetProcAddress('eglGetNativeClientBufferANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_native_fence_sync}
+  eglDupNativeFenceFDANDROID := eglGetProcAddress('eglDupNativeFenceFDANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_presentation_time}
+  eglPresentationTimeANDROID := eglGetProcAddress('eglPresentationTimeANDROID');
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_query_surface_pointer}
+  eglQuerySurfacePointerANGLE := eglGetProcAddress('eglQuerySurfacePointerANGLE');
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_sync_control_rate}
+  eglGetMscRateANGLE := eglGetProcAddress('eglGetMscRateANGLE');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_client_sync}
+  eglClientSignalSyncEXT := eglGetProcAddress('eglClientSignalSyncEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_compositor}
+  eglCompositorSetContextListEXT := eglGetProcAddress('eglCompositorSetContextListEXT');
+  eglCompositorSetContextAttributesEXT := eglGetProcAddress('eglCompositorSetContextAttributesEXT');
+  eglCompositorSetWindowListEXT := eglGetProcAddress('eglCompositorSetWindowListEXT');
+  eglCompositorSetWindowAttributesEXT := eglGetProcAddress('eglCompositorSetWindowAttributesEXT');
+  eglCompositorBindTexWindowEXT := eglGetProcAddress('eglCompositorBindTexWindowEXT');
+  eglCompositorSetSizeEXT := eglGetProcAddress('eglCompositorSetSizeEXT');
+  eglCompositorSwapPolicyEXT := eglGetProcAddress('eglCompositorSwapPolicyEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_base}
+  eglQueryDeviceAttribEXT := eglGetProcAddress('eglQueryDeviceAttribEXT');
+  eglQueryDeviceStringEXT := eglGetProcAddress('eglQueryDeviceStringEXT');
+  eglQueryDevicesEXT := eglGetProcAddress('eglQueryDevicesEXT');
+  eglQueryDisplayAttribEXT := eglGetProcAddress('eglQueryDisplayAttribEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_persistent_id}
+  eglQueryDeviceBinaryEXT := eglGetProcAddress('eglQueryDeviceBinaryEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_image_dma_buf_import_modifiers}
+  eglQueryDmaBufFormatsEXT := eglGetProcAddress('eglQueryDmaBufFormatsEXT');
+  eglQueryDmaBufModifiersEXT := eglGetProcAddress('eglQueryDmaBufModifiersEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_output_base}
+  eglGetOutputLayersEXT := eglGetProcAddress('eglGetOutputLayersEXT');
+  eglGetOutputPortsEXT := eglGetProcAddress('eglGetOutputPortsEXT');
+  eglOutputLayerAttribEXT := eglGetProcAddress('eglOutputLayerAttribEXT');
+  eglQueryOutputLayerAttribEXT := eglGetProcAddress('eglQueryOutputLayerAttribEXT');
+  eglQueryOutputLayerStringEXT := eglGetProcAddress('eglQueryOutputLayerStringEXT');
+  eglOutputPortAttribEXT := eglGetProcAddress('eglOutputPortAttribEXT');
+  eglQueryOutputPortAttribEXT := eglGetProcAddress('eglQueryOutputPortAttribEXT');
+  eglQueryOutputPortStringEXT := eglGetProcAddress('eglQueryOutputPortStringEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_platform_base}
+  eglGetPlatformDisplayEXT := eglGetProcAddress('eglGetPlatformDisplayEXT');
+  eglCreatePlatformWindowSurfaceEXT := eglGetProcAddress('eglCreatePlatformWindowSurfaceEXT');
+  eglCreatePlatformPixmapSurfaceEXT := eglGetProcAddress('eglCreatePlatformPixmapSurfaceEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_stream_consumer_egloutput}
+  eglStreamConsumerOutputEXT := eglGetProcAddress('eglStreamConsumerOutputEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_surface_compression}
+  eglQuerySupportedCompressionRatesEXT := eglGetProcAddress('eglQuerySupportedCompressionRatesEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageEXT := eglGetProcAddress('eglSwapBuffersWithDamageEXT');
+  {$EndIf}
+
+  {$IfDef EGL_EXT_sync_reuse}
+  eglUnsignalSyncEXT := eglGetProcAddress('eglUnsignalSyncEXT');
+  {$EndIf}
+
+  {$IfDef EGL_HI_clientpixmap}
+  eglCreatePixmapSurfaceHI := eglGetProcAddress('eglCreatePixmapSurfaceHI');
+  {$EndIf}
+
+  {$IfDef EGL_MESA_drm_image}
+  eglCreateDRMImageMESA := eglGetProcAddress('eglCreateDRMImageMESA');
+  eglExportDRMImageMESA := eglGetProcAddress('eglExportDRMImageMESA');
+  {$EndIf}
+
+  {$IfDef EGL_MESA_image_dma_buf_export}
+  eglExportDMABUFImageQueryMESA := eglGetProcAddress('eglExportDMABUFImageQueryMESA');
+  eglExportDMABUFImageMESA := eglGetProcAddress('eglExportDMABUFImageMESA');
+  {$EndIf}
+
+  {$IfDef EGL_MESA_query_driver}
+  eglGetDisplayDriverConfig := eglGetProcAddress('eglGetDisplayDriverConfig');
+  eglGetDisplayDriverName := eglGetProcAddress('eglGetDisplayDriverName');
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region}
+  eglSwapBuffersRegionNOK := eglGetProcAddress('eglSwapBuffersRegionNOK');
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region2}
+  eglSwapBuffersRegion2NOK := eglGetProcAddress('eglSwapBuffersRegion2NOK');
+  {$EndIf}
+
+  {$IfDef EGL_NV_native_query}
+  eglQueryNativeDisplayNV := eglGetProcAddress('eglQueryNativeDisplayNV');
+  eglQueryNativeWindowNV := eglGetProcAddress('eglQueryNativeWindowNV');
+  eglQueryNativePixmapNV := eglGetProcAddress('eglQueryNativePixmapNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_post_sub_buffer}
+  eglPostSubBufferNV := eglGetProcAddress('eglPostSubBufferNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_eglimage}
+  eglStreamImageConsumerConnectNV := eglGetProcAddress('eglStreamImageConsumerConnectNV');
+  eglQueryStreamConsumerEventNV := eglGetProcAddress('eglQueryStreamConsumerEventNV');
+  eglStreamAcquireImageNV := eglGetProcAddress('eglStreamAcquireImageNV');
+  eglStreamReleaseImageNV := eglGetProcAddress('eglStreamReleaseImageNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_gltexture_yuv}
+  eglStreamConsumerGLTextureExternalAttribsNV := eglGetProcAddress('eglStreamConsumerGLTextureExternalAttribsNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_flush}
+  eglStreamFlushNV := eglGetProcAddress('eglStreamFlushNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_metadata}
+  eglQueryDisplayAttribNV := eglGetProcAddress('eglQueryDisplayAttribNV');
+  eglSetStreamMetadataNV := eglGetProcAddress('eglSetStreamMetadataNV');
+  eglQueryStreamMetadataNV := eglGetProcAddress('eglQueryStreamMetadataNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_reset}
+  eglResetStreamNV := eglGetProcAddress('eglResetStreamNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_sync}
+  eglCreateStreamSyncNV := eglGetProcAddress('eglCreateStreamSyncNV');
+  {$EndIf}
+
+  {$IfDef EGL_NV_sync}
+  {$IfDef CPU64}
+  eglCreateFenceSyncNV := eglGetProcAddress('eglCreateFenceSyncNV');
+  eglDestroySyncNV := eglGetProcAddress('eglDestroySyncNV');
+  eglFenceNV := eglGetProcAddress('eglFenceNV');
+  eglClientWaitSyncNV := eglGetProcAddress('eglClientWaitSyncNV');
+  eglSignalSyncNV := eglGetProcAddress('eglSignalSyncNV');
+  eglGetSyncAttribNV := eglGetProcAddress('eglGetSyncAttribNV');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_NV_system_time}
+  {$IfDef CPU64}
+  eglGetSystemTimeFrequencyNV := eglGetProcAddress('eglGetSystemTimeFrequencyNV');
+  eglGetSystemTimeNV := eglGetProcAddress('eglGetSystemTimeNV');
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_WL_bind_wayland_display}
+  eglBindWaylandDisplayWL := eglGetProcAddress('eglBindWaylandDisplayWL');
+  eglUnbindWaylandDisplayWL := eglGetProcAddress('eglUnbindWaylandDisplayWL');
+  eglQueryWaylandBufferWL := eglGetProcAddress('eglQueryWaylandBufferWL');
+  {$EndIf}
+
+  {$IfDef EGL_WL_create_wayland_buffer_from_image}
+  eglCreateWaylandBufferFromImageWL := eglGetProcAddress('eglCreateWaylandBufferFromImageWL');
+  {$EndIf}
+  {$EndIf}
+  Result := True;
+end;
+
+procedure FreeEGL;
+begin
+  {$IfDef EGL_VERSION_1_0}
+  eglGetProcAddress := nil;
+
+  eglChooseConfig := nil;
+  eglCreateContext := nil;
+  eglCreateWindowSurface := nil;
+  eglDestroyContext := nil;
+  eglDestroySurface := nil;
+  eglGetDisplay := nil;
+  eglGetError := nil;
+  eglInitialize := nil;
+  eglMakeCurrent := nil;
+  eglSwapBuffers := nil;
+  eglTerminate := nil;
+  {$IfDef EGL_NO_MIN}
+  eglCopyBuffers := nil;
+  eglCreatePbufferSurface := nil;
+  eglCreatePixmapSurface := nil;   // eglCreatePixmapSurfaceHI
+  eglGetConfigAttrib := nil;
+  eglGetConfigs := nil;
+  eglGetCurrentDisplay := nil;
+  eglGetCurrentSurface := nil;
+  eglQueryContext := nil;
+  eglQueryString := nil;
+  eglQuerySurface := nil;          // eglQuerySurface64KHR
+  eglWaitGL := nil;
+  eglWaitNative := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_VERSION_1_1}
+  {$IfDef EGL_NO_MIN}
+  eglBindTexImage := nil;
+  eglReleaseTexImage := nil;
+  eglSurfaceAttrib := nil;
+  {$EndIf}
+  eglSwapInterval := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NO_MIN}
+  {$IfDef EGL_VERSION_1_2}
+  eglBindAPI := nil;
+  eglQueryAPI := nil;
+  eglCreatePbufferFromClientBuffer := nil;
+  eglReleaseThread := nil;
+  eglWaitClient := nil;
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_4}
+  eglGetCurrentContext := nil;
+  {$EndIf}
+
+  {$IfDef EGL_VERSION_1_5}
+  eglCreateSync := nil;                    // KHR, 64KHR
+  eglDestroySync := nil;                   // KHR, NV
+  eglClientWaitSync := nil;                // KHR, NV
+  eglGetSyncAttrib := nil;                 // KHR, NV
+  eglCreateImage := nil;                   // KHR
+  eglDestroyImage := nil;                  // KHR
+  eglGetPlatformDisplay := nil;            // EXT
+  eglCreatePlatformWindowSurface := nil;   // EXT
+  eglCreatePlatformPixmapSurface := nil;   // EXT
+  eglWaitSync := nil;                      // KHR
+  {$EndIf}
+
+  {$IfDef EGL_KHR_cl_event2}
+  eglCreateSync64KHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_debug}
+  eglDebugMessageControlKHR := nil;
+  eglQueryDebugKHR := nil;
+  eglLabelObjectKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_display_reference}
+  eglQueryDisplayAttribKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_fence_sync}
+  {$IfDef CPU64}
+  eglCreateSyncKHR := nil;
+  eglDestroySyncKHR := nil;
+  eglClientWaitSyncKHR := nil;
+  eglGetSyncAttribKHR := nil;
+  {$EndIf}
+  {$EndIf}
+
+  {$IfDef EGL_KHR_image}
+  eglCreateImageKHR := nil;
+  eglDestroyImageKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface}
+  eglLockSurfaceKHR := nil;
+  eglUnlockSurfaceKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_lock_surface3}
+  eglQuerySurface64KHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_partial_update}
+  eglSetDamageRegionKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_reusable_sync}
+  {$IfDef CPU64}
+  eglSignalSyncKHR := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream}
+  {$IfDef CPU64}
+  eglCreateStreamKHR := nil;
+  eglDestroyStreamKHR := nil;
+  eglStreamAttribKHR := nil;
+  eglQueryStreamKHR := nil;
+  eglQueryStreamu64KHR := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_attrib}
+  {$IfDef CPU64}
+  eglCreateStreamAttribKHR := nil;
+  eglSetStreamAttribKHR := nil;
+  eglQueryStreamAttribKHR := nil;
+  eglStreamConsumerAcquireAttribKHR := nil;
+  eglStreamConsumerReleaseAttribKHR := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_KHR_stream_consumer_gltexture}
+  eglStreamConsumerGLTextureExternalKHR := nil;
+  eglStreamConsumerAcquireKHR := nil;
+  eglStreamConsumerReleaseKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_cross_process_fd}
+  eglGetStreamFileDescriptorKHR := nil;
+  eglCreateStreamFromFileDescriptorKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_fifo}
+  eglQueryStreamTimeKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_stream_producer_eglsurface}
+  eglCreateStreamProducerSurfaceKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_KHR_wait_sync}
+  eglWaitSyncKHR := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_blob_cache}
+  eglSetBlobCacheFuncsANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_create_native_client_buffer}
+  eglCreateNativeClientBufferANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_frame_timestamps}
+  eglGetCompositorTimingSupportedANDROID := nil;
+  eglGetCompositorTimingANDROID := nil;
+  eglGetNextFrameIdANDROID := nil;
+  eglGetFrameTimestampSupportedANDROID
+  eglGetFrameTimestampsANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_get_native_client_buffer}
+  eglGetNativeClientBufferANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_native_fence_sync}
+  eglDupNativeFenceFDANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANDROID_presentation_time}
+  eglPresentationTimeANDROID := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_query_surface_pointer}
+  eglQuerySurfacePointerANGLE := nil;
+  {$EndIf}
+
+  {$IfDef EGL_ANGLE_sync_control_rate}
+  eglGetMscRateANGLE := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_client_sync}
+  eglClientSignalSyncEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_compositor}
+  eglCompositorSetContextListEXT := nil;
+  eglCompositorSetContextAttributesEXT := nil;
+  eglCompositorSetWindowListEXT := nil;
+  eglCompositorSetWindowAttributesEXT := nil;
+  eglCompositorBindTexWindowEXT := nil;
+  eglCompositorSetSizeEXT := nil;
+  eglCompositorSwapPolicyEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_base}
+  eglQueryDeviceAttribEXT := nil;
+  eglQueryDeviceStringEXT := nil;
+  eglQueryDevicesEXT := nil;
+  eglQueryDisplayAttribEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_device_persistent_id}
+  eglQueryDeviceBinaryEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_image_dma_buf_import_modifiers}
+  eglQueryDmaBufFormatsEXT := nil;
+  eglQueryDmaBufModifiersEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_output_base}
+  eglGetOutputLayersEXT := nil;
+  eglGetOutputPortsEXT := nil;
+  eglOutputLayerAttribEXT := nil;
+  eglQueryOutputLayerAttribEXT := nil;
+  eglQueryOutputLayerStringEXT := nil;
+  eglOutputPortAttribEXT := nil;
+  eglQueryOutputPortAttribEXT := nil;
+  eglQueryOutputPortStringEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_platform_base}
+  eglGetPlatformDisplayEXT := nil;
+  eglCreatePlatformWindowSurfaceEXT := nil;
+  eglCreatePlatformPixmapSurfaceEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_stream_consumer_egloutput}
+  eglStreamConsumerOutputEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_surface_compression}
+  eglQuerySupportedCompressionRatesEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_swap_buffers_with_damage}
+  eglSwapBuffersWithDamageEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_EXT_sync_reuse}
+  eglUnsignalSyncEXT := nil;
+  {$EndIf}
+
+  {$IfDef EGL_HI_clientpixmap}
+  eglCreatePixmapSurfaceHI := nil;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_drm_image}
+  eglCreateDRMImageMESA := nil;
+  eglExportDRMImageMESA := nil;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_image_dma_buf_export}
+  eglExportDMABUFImageQueryMESA := nil;
+  eglExportDMABUFImageMESA := nil;
+  {$EndIf}
+
+  {$IfDef EGL_MESA_query_driver}
+  eglGetDisplayDriverConfig := nil;
+  eglGetDisplayDriverName := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region}
+  eglSwapBuffersRegionNOK := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NOK_swap_region2}
+  eglSwapBuffersRegion2NOK := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_native_query}
+  eglQueryNativeDisplayNV := nil;
+  eglQueryNativeWindowNV := nil;
+  eglQueryNativePixmapNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_post_sub_buffer}
+  eglPostSubBufferNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_eglimage}
+  eglStreamImageConsumerConnectNV := nil;
+  eglQueryStreamConsumerEventNV := nil;
+  eglStreamAcquireImageNV := nil;
+  eglStreamReleaseImageNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_consumer_gltexture_yuv}
+  eglStreamConsumerGLTextureExternalAttribsNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_flush}
+  eglStreamFlushNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_metadata}
+  eglQueryDisplayAttribNV := nil;
+  eglSetStreamMetadataNV := nil;
+  eglQueryStreamMetadataNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_reset}
+  eglResetStreamNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_stream_sync}
+  eglCreateStreamSyncNV := nil;
+  {$EndIf}
+
+  {$IfDef EGL_NV_sync}
+  {$IfDef CPU64}
+  eglCreateFenceSyncNV := nil;
+  eglDestroySyncNV := nil;
+  eglFenceNV := nil;
+  eglClientWaitSyncNV := nil;
+  eglSignalSyncNV := nil;
+  eglGetSyncAttribNV := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_NV_system_time}
+  {$IfDef CPU64}
+  eglGetSystemTimeFrequencyNV := nil;
+  eglGetSystemTimeNV := nil;
+  {$EndIf}{$EndIf}
+
+  {$IfDef EGL_WL_bind_wayland_display}
+  eglBindWaylandDisplayWL := nil;
+  eglUnbindWaylandDisplayWL := nil;
+  eglQueryWaylandBufferWL := nil;
+  {$EndIf}
+
+  {$IfDef EGL_WL_create_wayland_buffer_from_image}
+  eglCreateWaylandBufferFromImageWL := nil;
+  {$EndIf}
+  {$EndIf}
+end;
+
+end.
+

Zengl_SRC/srcGL/GLES/gles_conf.cfg

@@ -0,0 +1,451 @@
+{.$DEFINE USE_MIN_GLES}
+
+{$IFNDEF USE_MIN_GLES}
+  // отключая данное определение, мы включим GLES 10
+  {.$DEFINE USE_GLES20}
+{$ENDIF}
+
+{$IFNDEF USE_MIN_GLES}
+  // Rus: обязательно выключите GL_ES_VERSION_1_0 если будете использовать более новые версии GLES.
+  // Eng: be sure to turn off GL_ES_VERSION_1_0 if you use newer versions of GLES.
+  {$IFNDEF USE_GLES20}
+    {$DEFINE GL_ES_VERSION_1_0}
+  {$ELSE}
+    {$DEFINE GL_ES_VERSION_2_0}
+    {$DEFINE GL_ES_VERSION_3_0}
+    {$DEFINE GL_ES_VERSION_3_1}
+    {$DEFINE GL_ES_VERSION_3_2}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_1_0}
+  // Rus: версия GLES 1.0 не совместима с новыми версиями.
+  // Eng: GLES version 1.0 is not compatible with new versions.
+  {$UNDEF GL_ES_VERSION_2_0}
+  {$UNDEF GL_ES_VERSION_3_0}
+  {$UNDEF GL_ES_VERSION_3_1}
+  {$UNDEF GL_ES_VERSION_3_2}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_3_2}
+  {$UNDEF GL_ES_VERSION_1_0}
+  {$DEFINE GL_ES_VERSION_2_0}
+  {$DEFINE GL_ES_VERSION_3_0}
+  {$DEFINE GL_ES_VERSION_3_1}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_3_1}
+  {$UNDEF GL_ES_VERSION_1_0}
+  {$DEFINE GL_ES_VERSION_2_0}
+  {$DEFINE GL_ES_VERSION_3_0}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_3_0}
+  {$UNDEF GL_ES_VERSION_1_0}
+  {$DEFINE GL_ES_VERSION_2_0}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_2_0}
+  {$UNDEF GL_ES_VERSION_1_0}
+  {$DEFINE GL_ES_VERSION_2_0_EXT}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_1_0}
+  {$DEFINE GL_VERSION_ES_CM_1_0}
+    {.$DEFINE GL_OES_compressed_paletted_texture}
+  {$DEFINE GL_OES_point_size_array}
+    {.$DEFINE GL_OES_point_sprite}
+    {.$DEFINE GL_KHR_debug}
+  {$DEFINE GL_OES_EGL_image}
+    {.$DEFINE GL_OES_EGL_image_external}
+  {$DEFINE GL_OES_blend_equation_separate}
+  {$DEFINE GL_OES_blend_func_separate}
+  {$DEFINE GL_OES_blend_subtract}
+    {.$DEFINE GL_OES_byte_coordinates}
+    {.$DEFINE GL_OES_compressed_ETC1_RGB8_sub_texture}
+    {.$DEFINE GL_OES_compressed_ETC1_RGB8_texture}
+    {.$DEFINE GL_OES_depth24}
+    {.$DEFINE GL_OES_depth32}
+  {$DEFINE GL_OES_draw_texture}
+    {.$DEFINE GL_OES_element_index_uint}
+    {.$DEFINE GL_OES_extended_matrix_palette}
+    {.$DEFINE GL_OES_fbo_render_mipmap}
+  {$DEFINE GL_OES_fixed_point}
+  {$DEFINE GL_OES_framebuffer_object}
+  {$DEFINE GL_OES_mapbuffer}
+    {.$DEFINE GL_OES_matrix_get}
+  {$DEFINE GL_OES_matrix_palette}
+    {.$DEFINE GL_OES_packed_depth_stencil}
+  {$DEFINE GL_OES_query_matrix}
+    {.$DEFINE GL_OES_required_internalformat}
+    {.$DEFINE GL_OES_rgb8_rgba8}
+  {$DEFINE GL_OES_single_precision}
+    {.$DEFINE GL_OES_stencil1}
+    {.$DEFINE GL_OES_stencil4}
+    {.$DEFINE GL_OES_stencil8}
+    {.$DEFINE GL_OES_stencil_wrap}
+    {.$DEFINE GL_OES_surfaceless_context}
+  {$DEFINE GL_OES_texture_cube_map}
+    {.$DEFINE GL_OES_texture_env_crossbar}
+    {.$DEFINE GL_OES_texture_mirrored_repeat}
+    {.$DEFINE GL_OES_texture_npot}
+  {$DEFINE GL_OES_vertex_array_object}
+    {.$DEFINE GL_AMD_compressed_3DC_texture}
+    {.$DEFINE GL_AMD_compressed_ATC_texture}
+  {$DEFINE GL_APPLE_copy_texture_levels}
+  {$DEFINE GL_APPLE_framebuffer_multisample}
+  {$DEFINE GL_APPLE_sync}
+    {.$DEFINE GL_APPLE_texture_2D_limited_npot}
+    {.$DEFINE GL_APPLE_texture_format_BGRA8888}
+    {.$DEFINE GL_APPLE_texture_max_level}
+    {.$DEFINE GL_ARM_rgba8}
+    {.$DEFINE GL_EXT_blend_minmax}
+  {$DEFINE GL_EXT_debug_marker}
+  {$DEFINE GL_EXT_discard_framebuffer}
+  {$DEFINE GL_EXT_map_buffer_range}
+  {$DEFINE GL_EXT_multi_draw_arrays}
+  {$DEFINE GL_EXT_multisampled_render_to_texture}
+    {.$DEFINE GL_EXT_read_format_bgra}
+  {$DEFINE GL_EXT_robustness}
+    {.$DEFINE GL_EXT_sRGB}
+    {.$DEFINE GL_EXT_texture_compression_dxt1}
+    {.$DEFINE GL_EXT_texture_filter_anisotropic}
+    {.$DEFINE GL_EXT_texture_format_BGRA8888}
+    {.$DEFINE GL_EXT_texture_lod_bias}
+  {$DEFINE GL_EXT_texture_storage}
+  {$DEFINE GL_IMG_multisampled_render_to_texture}
+    {.$DEFINE GL_IMG_read_format}
+    {.$DEFINE GL_IMG_texture_compression_pvrtc}
+    {.$DEFINE GL_IMG_texture_env_enhanced_fixed_function}
+  {$DEFINE GL_IMG_user_clip_plane}
+  {$DEFINE GL_NV_fence}
+  {$DEFINE GL_QCOM_driver_control}
+  {$DEFINE GL_QCOM_extended_get}
+  {$DEFINE GL_QCOM_extended_get2}
+    {.$DEFINE GL_QCOM_perfmon_global_mode}
+  {$DEFINE GL_QCOM_tiled_rendering}
+    {.$DEFINE GL_QCOM_writeonly_rendering}
+{$ENDIF}
+
+{$IFDEF GL_ES_VERSION_2_0}
+  // Rus: расширенная версия GLES 2.0.
+  // Eng: extended version of GLES 2.0.
+  {$DEFINE GL_ES_EXT_VERSION_2_0}
+{$ENDIF}
+
+{$IFDEF GL_ES_EXT_VERSION_2_0}
+  {$DEFINE GL_KHR_blend_equation_advanced}
+    {.$DEFINE GL_KHR_blend_equation_advanced_coherent}
+    {.$DEFINE GL_KHR_context_flush_control}
+  {$DEFINE GL_KHR_debug}
+    {.$DEFINE GL_KHR_no_error}
+  {$DEFINE GL_KHR_parallel_shader_compile}
+    {.$DEFINE GL_KHR_robust_buffer_access_behavior}
+  {$DEFINE GL_KHR_robustness}
+    {.$DEFINE GL_KHR_shader_subgroup}
+    {.$DEFINE GL_KHR_texture_compression_astc_hdr}
+    {.$DEFINE GL_KHR_texture_compression_astc_ldr}
+    {.$DEFINE GL_KHR_texture_compression_astc_sliced_3d}
+  {$DEFINE GL_OES_EGL_image}
+    {.$DEFINE GL_OES_EGL_image_external}
+    {.$DEFINE GL_OES_EGL_image_external_essl3}
+    {.$DEFINE GL_OES_compressed_ETC1_RGB8_sub_texture}
+    {.$DEFINE GL_OES_compressed_ETC1_RGB8_texture}
+    {.$DEFINE GL_OES_compressed_paletted_texture}
+  {$DEFINE GL_OES_copy_image}
+    {.$DEFINE GL_OES_depth24}
+    {.$DEFINE GL_OES_depth32}
+    {.$DEFINE GL_OES_depth_texture}
+  {$DEFINE GL_OES_draw_buffers_indexed}
+  {$DEFINE GL_OES_draw_elements_base_vertex}
+    {.$DEFINE GL_OES_element_index_uint}
+    {.$DEFINE GL_OES_fbo_render_mipmap}
+    {.$DEFINE GL_OES_fragment_precision_high}
+    {.$DEFINE GL_OES_geometry_point_size}
+  {$DEFINE GL_OES_geometry_shader}
+  {$DEFINE GL_OES_get_program_binary}
+    {.$DEFINE GL_OES_gpu_shader5}
+  {$DEFINE GL_OES_mapbuffer}
+    {.$DEFINE GL_OES_packed_depth_stencil}
+  {$DEFINE GL_OES_primitive_bounding_box}
+    {.$DEFINE GL_OES_required_internalformat}
+    {.$DEFINE GL_OES_rgb8_rgba8}
+  {$DEFINE GL_OES_sample_shading}
+    {.$DEFINE GL_OES_sample_variables}
+    {.$DEFINE GL_OES_shader_image_atomic}
+    {.$DEFINE GL_OES_shader_io_blocks}
+    {.$DEFINE GL_OES_shader_multisample_interpolation}
+    {.$DEFINE GL_OES_standard_derivatives}
+    {.$DEFINE GL_OES_stencil1}
+    {.$DEFINE GL_OES_stencil4}
+    {.$DEFINE GL_OES_surfaceless_context}
+    {.$DEFINE GL_OES_tessellation_point_size}
+  {$DEFINE GL_OES_tessellation_shader}
+  {$DEFINE GL_OES_texture_3D}
+  {$DEFINE GL_OES_texture_border_clamp}
+  {$DEFINE GL_OES_texture_buffer}
+    {.$DEFINE GL_OES_texture_compression_astc}
+    {.$DEFINE GL_OES_texture_cube_map_array}
+    {.$DEFINE GL_OES_texture_float}
+    {.$DEFINE GL_OES_texture_float_linear}
+    {.$DEFINE GL_OES_texture_half_float}
+    {.$DEFINE GL_OES_texture_half_float_linear}
+    {.$DEFINE GL_OES_texture_npot}
+    {.$DEFINE GL_OES_texture_stencil8}
+  {$DEFINE GL_OES_texture_storage_multisample_2d_array}
+  {$DEFINE GL_OES_texture_view}
+  {$DEFINE GL_OES_vertex_array_object}
+    {.$DEFINE GL_OES_vertex_half_float}
+    {.$DEFINE GL_OES_vertex_type_10_10_10_2}
+  {$DEFINE GL_OES_viewport_array}
+    {.$DEFINE GL_AMD_compressed_3DC_texture}
+    {.$DEFINE GL_AMD_compressed_ATC_texture}
+  {$DEFINE GL_AMD_framebuffer_multisample_advanced}
+  {$DEFINE GL_AMD_performance_monitor}
+    {.$DEFINE GL_AMD_program_binary_Z400}
+    {.$DEFINE GL_ANDROID_extension_pack_es31a}
+    {.$DEFINE GL_ANGLE_depth_texture}
+  {$DEFINE GL_ANGLE_framebuffer_blit}
+  {$DEFINE GL_ANGLE_framebuffer_multisample}
+  {$DEFINE GL_ANGLE_instanced_arrays}
+    {.$DEFINE GL_ANGLE_pack_reverse_row_order}
+    {.$DEFINE GL_ANGLE_program_binary}
+    {.$DEFINE GL_ANGLE_texture_compression_dxt3}
+    {.$DEFINE GL_ANGLE_texture_compression_dxt5}
+    {.$DEFINE GL_ANGLE_texture_usage}
+  {$DEFINE GL_ANGLE_translated_shader_source}
+    {.$DEFINE GL_APPLE_clip_distance}
+    {.$DEFINE GL_APPLE_color_buffer_packed_float}
+  {$DEFINE GL_APPLE_copy_texture_levels}
+  {$DEFINE GL_APPLE_framebuffer_multisample}
+    {.$DEFINE GL_APPLE_rgb_422}
+  {$DEFINE GL_APPLE_sync}
+    {.$DEFINE GL_APPLE_texture_format_BGRA8888}
+    {.$DEFINE GL_APPLE_texture_max_level}
+    {.$DEFINE GL_APPLE_texture_packed_float}
+    {.$DEFINE GL_ARM_mali_program_binary}
+    {.$DEFINE GL_ARM_mali_shader_binary}
+    {.$DEFINE GL_ARM_rgba8}
+    {.$DEFINE GL_ARM_shader_framebuffer_fetch}
+    {.$DEFINE GL_ARM_shader_framebuffer_fetch_depth_stencil}
+    {.$DEFINE GL_ARM_texture_unnormalized_coordinates}
+    {.$DEFINE GL_DMP_program_binary}
+    {.$DEFINE GL_DMP_shader_binary}
+    {.$DEFINE GL_EXT_EGL_image_array}
+  {$DEFINE GL_EXT_EGL_image_storage}
+    {.$DEFINE GL_EXT_EGL_image_storage_compression}
+    {.$DEFINE GL_EXT_YUV_target}
+  {$DEFINE GL_EXT_base_instance}
+  {$DEFINE GL_EXT_blend_func_extended}
+    {.$DEFINE GL_EXT_blend_minmax}
+  {$DEFINE GL_EXT_buffer_storage}
+  {$DEFINE GL_EXT_clear_texture}
+  {$DEFINE GL_EXT_clip_control}
+    {.$DEFINE GL_EXT_clip_cull_distance}
+    {.$DEFINE GL_EXT_color_buffer_float}
+    {.$DEFINE GL_EXT_color_buffer_half_float}
+    {.$DEFINE GL_EXT_conservative_depth}
+  {$DEFINE GL_EXT_copy_image}
+  {$DEFINE GL_EXT_debug_label}
+  {$DEFINE GL_EXT_debug_marker}
+    {.$DEFINE GL_EXT_depth_clamp}
+  {$DEFINE GL_EXT_discard_framebuffer}
+  {$DEFINE GL_EXT_disjoint_timer_query}
+  {$DEFINE GL_EXT_draw_buffers}
+  {$DEFINE GL_EXT_draw_elements_base_vertex}
+  {$DEFINE GL_EXT_draw_instanced}
+  {$DEFINE GL_EXT_draw_transform_feedback}
+  {$DEFINE GL_EXT_external_buffer}
+    {.$DEFINE GL_EXT_float_blend}
+  {$DEFINE GL_EXT_fragment_shading_rate}
+  {$DEFINE GL_EXT_framebuffer_blit_layers}
+    {.$DEFINE GL_EXT_geometry_point_size}
+  {$DEFINE GL_EXT_geometry_shader}
+    {.$DEFINE GL_EXT_gpu_shader5}
+  {$DEFINE GL_EXT_instanced_arrays}
+  {$DEFINE GL_EXT_map_buffer_range}
+  {$DEFINE GL_EXT_memory_object}
+  {$DEFINE GL_EXT_memory_object_fd}
+  {$DEFINE GL_EXT_memory_object_win32}
+  {$DEFINE GL_EXT_multi_draw_arrays}
+  {$DEFINE GL_EXT_multi_draw_indirect}
+    {.$DEFINE GL_EXT_multisampled_compatibility}
+  {$DEFINE GL_EXT_multisampled_render_to_texture}
+    {.$DEFINE GL_EXT_multisampled_render_to_texture2}
+  {$DEFINE GL_EXT_multiview_draw_buffers}
+    {.$DEFINE GL_EXT_multiview_tessellation_geometry_shader}
+    {.$DEFINE GL_EXT_multiview_texture_multisample}
+    {.$DEFINE GL_EXT_multiview_timer_query}
+    {.$DEFINE GL_EXT_occlusion_query_boolean}
+  {$DEFINE GL_EXT_polygon_offset_clamp}
+    {.$DEFINE GL_EXT_post_depth_coverage}
+  {$DEFINE GL_EXT_primitive_bounding_box}
+    {.$DEFINE GL_EXT_protected_textures}
+    {.$DEFINE GL_EXT_pvrtc_sRGB}
+  {$DEFINE GL_EXT_raster_multisample}
+    {.$DEFINE GL_EXT_read_format_bgra}
+    {.$DEFINE GL_EXT_render_snorm}
+  {$DEFINE GL_EXT_robustness}
+    {.$DEFINE GL_EXT_sRGB}
+    {.$DEFINE GL_EXT_sRGB_write_control}
+  {$DEFINE GL_EXT_semaphore}
+  {$DEFINE GL_EXT_semaphore_fd}
+  {$DEFINE GL_EXT_semaphore_win32}
+    {.$DEFINE GL_EXT_separate_depth_stencil}
+  {$DEFINE GL_EXT_separate_shader_objects}
+    {.$DEFINE GL_EXT_shader_framebuffer_fetch}
+  {$DEFINE GL_EXT_shader_framebuffer_fetch_non_coherent}
+    {.$DEFINE GL_EXT_shader_group_vote}
+    {.$DEFINE GL_EXT_shader_implicit_conversions}
+    {.$DEFINE GL_EXT_shader_integer_mix}
+    {.$DEFINE GL_EXT_shader_io_blocks}
+    {.$DEFINE GL_EXT_shader_non_constant_global_initializers}
+    {.$DEFINE GL_EXT_shader_pixel_local_storage}
+  {$DEFINE GL_EXT_shader_pixel_local_storage2}
+    {.$DEFINE GL_EXT_shader_samples_identical}
+    {.$DEFINE GL_EXT_shader_texture_lod}
+    {.$DEFINE GL_EXT_shadow_samplers}
+  {$DEFINE GL_EXT_sparse_texture}
+    {.$DEFINE GL_EXT_sparse_texture2}
+    {.$DEFINE GL_EXT_tessellation_point_size}
+  {$DEFINE GL_EXT_tessellation_shader}
+  {$DEFINE GL_EXT_texture_border_clamp}
+  {$DEFINE GL_EXT_texture_buffer}
+    {.$DEFINE GL_EXT_texture_compression_astc_decode_mode}
+    {.$DEFINE GL_EXT_texture_compression_bptc}
+    {.$DEFINE GL_EXT_texture_compression_dxt1}
+    {.$DEFINE GL_EXT_texture_compression_rgtc}
+    {.$DEFINE GL_EXT_texture_compression_s3tc}
+    {.$DEFINE GL_EXT_texture_compression_s3tc_srgb}
+    {.$DEFINE GL_EXT_texture_cube_map_array}
+    {.$DEFINE GL_EXT_texture_filter_anisotropic}
+    {.$DEFINE GL_EXT_texture_filter_minmax}
+    {.$DEFINE GL_EXT_texture_format_BGRA8888}
+    {.$DEFINE GL_EXT_texture_format_sRGB_override}
+    {.$DEFINE GL_EXT_texture_mirror_clamp_to_edge}
+    {.$DEFINE GL_EXT_texture_norm16}
+    {.$DEFINE GL_EXT_texture_query_lod}
+    {.$DEFINE GL_EXT_texture_rg}
+    {.$DEFINE GL_EXT_texture_sRGB_R8}
+    {.$DEFINE GL_EXT_texture_sRGB_RG8}
+    {.$DEFINE GL_EXT_texture_sRGB_decode}
+    {.$DEFINE GL_EXT_texture_shadow_lod}
+  {$DEFINE GL_EXT_texture_storage}
+  {$DEFINE GL_EXT_texture_storage_compression}
+    {.$DEFINE GL_EXT_texture_type_2_10_10_10_REV}
+  {$DEFINE GL_EXT_texture_view}
+    {.$DEFINE GL_EXT_unpack_subimage}
+  {$DEFINE GL_EXT_win32_keyed_mutex}
+  {$DEFINE GL_EXT_window_rectangles}
+    {.$DEFINE GL_FJ_shader_binary_GCCSO}
+  {$DEFINE GL_IMG_bindless_texture}
+  {$DEFINE GL_IMG_framebuffer_downsample}
+  {$DEFINE GL_IMG_multisampled_render_to_texture}
+    {.$DEFINE GL_IMG_program_binary}
+    {.$DEFINE GL_IMG_read_format}
+    {.$DEFINE GL_IMG_shader_binary}
+    {.$DEFINE GL_IMG_texture_compression_pvrtc}
+    {.$DEFINE GL_IMG_texture_compression_pvrtc2}
+    {.$DEFINE GL_IMG_texture_filter_cubic}
+    {.$DEFINE GL_INTEL_blackhole_render}
+    {.$DEFINE GL_INTEL_conservative_rasterization}
+  {$DEFINE GL_INTEL_framebuffer_CMAA}
+  {$DEFINE GL_INTEL_performance_query}
+    {.$DEFINE GL_MESA_bgra}
+    {.$DEFINE GL_MESA_framebuffer_flip_x}
+  {$DEFINE GL_MESA_framebuffer_flip_y}
+    {.$DEFINE GL_MESA_framebuffer_swap_xy}
+    {.$DEFINE GL_MESA_program_binary_formats}
+    {.$DEFINE GL_MESA_shader_integer_functions}
+    {.$DEFINE GL_NVX_blend_equation_advanced_multi_draw_buffers}
+  {$DEFINE GL_NV_bindless_texture}
+  {$DEFINE GL_NV_blend_equation_advanced}
+    {.$DEFINE GL_NV_blend_equation_advanced_coherent}
+    {.$DEFINE GL_NV_blend_minmax_factor}
+  {$DEFINE GL_NV_clip_space_w_scaling}
+    {.$DEFINE GL_NV_compute_shader_derivatives}
+  {$DEFINE GL_NV_conditional_render}
+  {$DEFINE GL_NV_conservative_raster}
+    {.$DEFINE GL_NV_conservative_raster_pre_snap}
+  {$DEFINE GL_NV_conservative_raster_pre_snap_triangles}
+  {$DEFINE GL_NV_copy_buffer}
+  {$DEFINE GL_NV_coverage_sample}
+    {.$DEFINE GL_NV_depth_nonlinear}
+  {$DEFINE GL_NV_draw_buffers}
+  {$DEFINE GL_NV_draw_instanced}
+  {$DEFINE GL_NV_draw_vulkan_image}
+    {.$DEFINE GL_NV_explicit_attrib_location}
+    {.$DEFINE GL_NV_fbo_color_attachments}
+  {$DEFINE GL_NV_fence}
+    {.$DEFINE GL_NV_fill_rectangle}
+  {$DEFINE GL_NV_fragment_coverage_to_color}
+    {.$DEFINE GL_NV_fragment_shader_barycentric}
+    {.$DEFINE GL_NV_fragment_shader_interlock}
+  {$DEFINE GL_NV_framebuffer_blit}
+  {$DEFINE GL_NV_framebuffer_mixed_samples}
+  {$DEFINE GL_NV_framebuffer_multisample}
+    {.$DEFINE GL_NV_generate_mipmap_sRGB}
+    {.$DEFINE GL_NV_geometry_shader_passthrough}
+  {$DEFINE GL_NV_gpu_shader5}
+    {.$DEFINE GL_NV_image_formats}
+  {$DEFINE GL_NV_instanced_arrays}
+  {$DEFINE GL_NV_internalformat_sample_query}
+  {$DEFINE GL_NV_memory_attachment}
+  {$DEFINE GL_NV_memory_object_sparse}
+  {$DEFINE GL_NV_mesh_shader}
+  {$DEFINE GL_NV_non_square_matrices}
+    {.$DEFINE GL_NV_pack_subimage}
+  {$DEFINE GL_NV_path_rendering}
+    {.$DEFINE GL_NV_path_rendering_shared_edge}
+    {.$DEFINE GL_NV_pixel_buffer_object}
+  {$DEFINE GL_NV_polygon_mode}
+    {.$DEFINE GL_NV_primitive_shading_rate}
+  {$DEFINE GL_NV_read_buffer}
+    {.$DEFINE GL_NV_read_buffer_front}
+    {.$DEFINE GL_NV_read_depth}
+    {.$DEFINE GL_NV_read_depth_stencil}
+    {.$DEFINE GL_NV_read_stencil}
+    {.$DEFINE GL_NV_representative_fragment_test}
+    {.$DEFINE GL_NV_sRGB_formats}
+  {$DEFINE GL_NV_sample_locations}
+    {.$DEFINE GL_NV_sample_mask_override_coverage}
+  {$DEFINE GL_NV_scissor_exclusive}
+    {.$DEFINE GL_NV_shader_atomic_fp16_vector}
+    {.$DEFINE GL_NV_shader_noperspective_interpolation}
+    {.$DEFINE GL_NV_shader_subgroup_partitioned}
+    {.$DEFINE GL_NV_shader_texture_footprint}
+  {$DEFINE GL_NV_shading_rate_image}
+    {.$DEFINE GL_NV_shadow_samplers_array}
+    {.$DEFINE GL_NV_shadow_samplers_cube}
+    {.$DEFINE GL_NV_stereo_view_rendering}
+    {.$DEFINE GL_NV_texture_border_clamp}
+    {.$DEFINE GL_NV_texture_compression_s3tc_update}
+    {.$DEFINE GL_NV_texture_npot_2D_mipmap}
+  {$DEFINE GL_NV_timeline_semaphore}
+  {$DEFINE GL_NV_viewport_array}
+    {.$DEFINE GL_NV_viewport_array2}
+  {$DEFINE GL_NV_viewport_swizzle}
+  {$DEFINE GL_OVR_multiview}
+    {.$DEFINE GL_OVR_multiview2}
+  {$DEFINE GL_OVR_multiview_multisampled_render_to_texture}
+    {.$DEFINE GL_QCOM_YUV_texture_gather}
+  {$DEFINE GL_QCOM_alpha_test}
+    {.$DEFINE GL_QCOM_binning_control}
+  {$DEFINE GL_QCOM_driver_control}
+  {$DEFINE GL_QCOM_extended_get}
+  {$DEFINE GL_QCOM_extended_get2}
+  {$DEFINE GL_QCOM_frame_extrapolation}
+  {$DEFINE GL_QCOM_framebuffer_foveated}
+  {$DEFINE GL_QCOM_motion_estimation}
+    {.$DEFINE GL_QCOM_perfmon_global_mode}
+    {.$DEFINE GL_QCOM_render_shared_exponent}
+  {$DEFINE GL_QCOM_shader_framebuffer_fetch_noncoherent}
+    {.$DEFINE GL_QCOM_shader_framebuffer_fetch_rate}
+  {$DEFINE GL_QCOM_shading_rate}
+  {$DEFINE GL_QCOM_texture_foveated}
+    {.$DEFINE GL_QCOM_texture_foveated2}
+    {.$DEFINE GL_QCOM_texture_foveated_subsampled_layout}
+  {$DEFINE GL_QCOM_tiled_rendering}
+    {.$DEFINE GL_QCOM_writeonly_rendering}
+    {.$DEFINE GL_VIV_shader_binary}
+{$ENDIF}

Zengl_SRC/srcGL/GLES/zgl_gles.pas

@@ -0,0 +1,9057 @@
+(*
+ *  Copyright (c) 2023 Serge - SSW
+ *
+ *  This software is provided 'as-is', without any express or
+ *  implied warranty. In no event will the authors be held
+ *  liable for any damages arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute
+ *  it freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented;
+ *     you must not claim that you wrote the original software.
+ *     If you use this software in a product, an acknowledgment
+ *     in the product documentation would be appreciated but
+ *     is not required.
+ *
+ *  2. Altered source versions must be plainly marked as such,
+ *     and must not be misrepresented as being the original software.
+ *
+ *  3. This notice may not be removed or altered from any
+ *     source distribution.
+ *)
+
+// Copyright 2013-2020 The Khronos Group Inc.
+// SPDX-License-Identifier: MIT
+//
+// This header is generated from the Khronos OpenGL / OpenGL ES XML
+// API Registry. The current version of the Registry, generator scripts
+// used to make the header, and the header can be found at
+//   https://github.com/KhronosGroup/OpenGL-Registry
+
+unit zgl_gles;
+{$I zgl_config.cfg}
+{$mode delphi}
+
+interface
+
+{$IfNDef Windows}
+  {$DEFINE stdcall := cdecl}
+{$ENDIF}
+
+uses
+  zgl_utils;
+
+Type
+  PPGLchar = ^PGLChar;
+  PGLboolean  = ^GLboolean;
+  PGLchar  = ^GLchar;
+  PGLenum  = ^GLenum;
+  PGLfloat  = ^GLfloat;
+  PGLint  = ^GLint;
+  PGLsizei  = ^GLsizei;
+  PGLubyte  = ^GLubyte;
+  PGLuint  = ^GLuint;
+  PGLdouble  = ^GLdouble;
+  PGLint64  = ^GLint64;
+  PGLint64EXT  = ^GLint64EXT;
+  PGLuint64  = ^GLuint64;
+  PGLuint64EXT  = ^GLuint64EXT;
+  PGLfixed  = ^GLfixed;
+  PGLshort = ^GLshort;
+  PGLvoid = Pointer;
+
+  GLbyte = Byte;        // khronos_int8_t;     // число без знака, почему тут со знаком?
+  GLclampf = Single;    // khronos_float_t;
+  GLfixed = LongInt;    // khronos_int32_t;
+  GLshort = SmallInt;   // khronos_int16_t;
+  GLushort = Word;      // khronos_uint16_t;
+  GLvoid = pointer;
+  GLsync = Pointer;     // ^__GLsync;
+
+// WARNING!!!  Зависят от разрядности платформы!
+//           khronos_intptr_t            signed   same number of bits as a pointer
+//           khronos_uintptr_t           unsigned same number of bits as a pointer
+//           khronos_ssize_t             signed   size
+//           khronos_usize_t             unsigned size
+
+  {$If not defined(CPU32) and not defined(CPUARM)}
+  GLsizeiptr = Int64;      // khronos_ssize_t;
+  GLintptr = Int64;        // khronos_intptr_t;
+  GLuint64 = QWord;        // khronos_uint64_t;
+  GLint64 = Int64;         // khronos_int64_t;
+  GLuint64EXT = QWord;     // khronos_uint64_t;
+  GLint64EXT = Int64;      // khronos_int64_t;
+  GLsizeiptrARB = Int64;   // khronos_ssize_t;
+  GLintptrARB = Int64;     // khronos_intptr_t;
+  {$Else}
+  GLsizeiptr = LongInt;    // khronos_ssize_t;
+  GLintptr = LongInt;      // khronos_intptr_t;
+  GLuint64 = Cardinal;     // khronos_uint64_t;
+  GLint64 = LongInt;       // khronos_int64_t;
+  GLuint64EXT = Cardinal;  // khronos_uint64_t;
+  GLint64EXT = LongInt;
+  GLsizeiptrARB = LongInt; // khronos_ssize_t;
+  GLintptrARB = LongInt;   // khronos_intptr_t;
+  {$IfEnd}
+  GLenum = dword;
+  GLuint = dword;
+  GLchar = char;
+  GLfloat = Single;     // khronos_float_t;
+  GLbitfield = dword;
+  GLint = longint;
+  GLboolean = byte;
+  GLsizei = longint;
+  GLubyte = Byte;       // khronos_uint8_t;
+  GLclampx = LongInt;   // khronos_int32_t;
+  GLdouble = double;
+  GLhalf = Word;        // khronos_uint16_t;
+
+  GLeglImageOES = pointer;
+
+type
+  TVector2d = array[0..1] of double;
+  TVector2f = array[0..1] of single;
+  TVector2i = array[0..1] of longint;
+  TVector2s = array[0..1] of smallint;
+  TVector2b = array[0..1] of byte;
+
+  TVector3d = array[0..2] of double;
+  TVector3f = array[0..2] of single;
+  TVector3i = array[0..2] of longint;
+  TVector3s = array[0..2] of smallint;
+  TVector3b = array[0..2] of byte;
+
+  TVector4d = array[0..3] of double;
+  TVector4f = array[0..3] of single;
+  TVector4i = array[0..3] of longint;
+  TVector4s = array[0..3] of smallint;
+  TVector4b = array[0..3] of byte;
+
+  TMatrix3d = array[0..2] of TVector3d;
+  TMatrix3f = array[0..2] of TVector3f;
+  TMatrix3i = array[0..2] of TVector3i;
+  TMatrix3s = array[0..2] of TVector3s;
+  TMatrix3b = array[0..2] of TVector3b;
+
+  TMatrix4d = array[0..3] of TVector4d;
+  TMatrix4f = array[0..3] of TVector4f;
+  TMatrix4i = array[0..3] of TVector4i;
+  TMatrix4s = array[0..3] of TVector4s;
+  TMatrix4b = array[0..3] of TVector4b;
+
+const
+(*******************************************************************************
+*                 GL_ES_VERSION_1_0, GL_ES_VERSION_1_1                         *
+*******************************************************************************)
+// GL_VERSION_ES_CM_1_0
+//  GL_DEPTH_BUFFER_BIT = $00000100;
+//  GL_STENCIL_BUFFER_BIT = $00000400;
+//  GL_COLOR_BUFFER_BIT = $00004000;
+//  GL_FALSE = 0;
+//  GL_TRUE = 1;
+//  GL_POINTS = $0000;
+//  GL_LINES = $0001;
+//  GL_LINE_LOOP = $0002;
+//  GL_LINE_STRIP = $0003;
+//  GL_TRIANGLES = $0004;
+//  GL_TRIANGLE_STRIP = $0005;
+//  GL_TRIANGLE_FAN = $0006;
+//  GL_NEVER = $0200;
+//  GL_LESS = $0201;
+//  GL_EQUAL = $0202;
+//  GL_LEQUAL = $0203;
+//  GL_GREATER = $0204;
+//  GL_NOTEQUAL = $0205;
+//  GL_GEQUAL = $0206;
+//  GL_ALWAYS = $0207;
+//  GL_ZERO = 0;
+//  GL_ONE = 1;
+//  GL_SRC_COLOR = $0300;
+//  GL_ONE_MINUS_SRC_COLOR = $0301;
+//  GL_SRC_ALPHA = $0302;
+//  GL_ONE_MINUS_SRC_ALPHA = $0303;
+//  GL_DST_ALPHA = $0304;
+//  GL_ONE_MINUS_DST_ALPHA = $0305;
+//  GL_DST_COLOR = $0306;
+//  GL_ONE_MINUS_DST_COLOR = $0307;
+//  GL_SRC_ALPHA_SATURATE = $0308;
+  GL_CLIP_PLANE0 = $3000;
+  GL_CLIP_PLANE1 = $3001;
+  GL_CLIP_PLANE2 = $3002;
+  GL_CLIP_PLANE3 = $3003;
+  GL_CLIP_PLANE4 = $3004;
+  GL_CLIP_PLANE5 = $3005;
+//  GL_FRONT = $0404;
+//  GL_BACK = $0405;
+//  GL_FRONT_AND_BACK = $0408;
+  GL_FOG = $0B60;
+  GL_LIGHTING = $0B50;
+//  GL_TEXTURE_2D = $0DE1;
+//  GL_CULL_FACE = $0B44;
+  GL_ALPHA_TEST = $0BC0;
+//  GL_BLEND = $0BE2;
+  GL_COLOR_LOGIC_OP = $0BF2;
+//  GL_DITHER = $0BD0;
+//  GL_STENCIL_TEST = $0B90;
+//  GL_DEPTH_TEST = $0B71;
+  GL_POINT_SMOOTH = $0B10;
+  GL_LINE_SMOOTH = $0B20;
+//  GL_SCISSOR_TEST = $0C11;
+  GL_COLOR_MATERIAL = $0B57;
+  GL_NORMALIZE = $0BA1;
+  GL_RESCALE_NORMAL = $803A;
+//  GL_VERTEX_ARRAY = $8074;
+  GL_NORMAL_ARRAY = $8075;
+  GL_COLOR_ARRAY = $8076;
+  GL_TEXTURE_COORD_ARRAY = $8078;
+  GL_MULTISAMPLE = $809D;
+//  GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE = $809F;
+//  GL_SAMPLE_COVERAGE = $80A0;
+//  GL_NO_ERROR = 0;
+//  GL_INVALID_ENUM = $0500;
+//  GL_INVALID_VALUE = $0501;
+//  GL_INVALID_OPERATION = $0502;
+//  GL_STACK_OVERFLOW = $0503;
+//  GL_STACK_UNDERFLOW = $0504;
+//  GL_OUT_OF_MEMORY = $0505;
+  GL_EXP = $0800;
+  GL_EXP2 = $0801;
+  GL_FOG_DENSITY = $0B62;
+  GL_FOG_START = $0B63;
+  GL_FOG_END = $0B64;
+  GL_FOG_MODE = $0B65;
+  GL_FOG_COLOR = $0B66;
+//  GL_CW = $0900;
+//  GL_CCW = $0901;
+  GL_CURRENT_COLOR = $0B00;
+  GL_CURRENT_NORMAL = $0B02;
+  GL_CURRENT_TEXTURE_COORDS = $0B03;
+  GL_POINT_SIZE = $0B11;
+  GL_POINT_SIZE_MIN = $8126;
+  GL_POINT_SIZE_MAX = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE = $8128;
+  GL_POINT_DISTANCE_ATTENUATION = $8129;
+  GL_SMOOTH_POINT_SIZE_RANGE = $0B12;
+//  GL_LINE_WIDTH = $0B21;
+  GL_SMOOTH_LINE_WIDTH_RANGE = $0B22;
+//  GL_ALIASED_POINT_SIZE_RANGE = $846D;
+//  GL_ALIASED_LINE_WIDTH_RANGE = $846E;
+//  GL_CULL_FACE_MODE = $0B45;
+//  GL_FRONT_FACE = $0B46;
+  GL_SHADE_MODEL = $0B54;
+//  GL_DEPTH_RANGE = $0B70;
+//  GL_DEPTH_WRITEMASK = $0B72;
+//  GL_DEPTH_CLEAR_VALUE = $0B73;
+//  GL_DEPTH_FUNC = $0B74;
+//  GL_STENCIL_CLEAR_VALUE = $0B91;
+//  GL_STENCIL_FUNC = $0B92;
+//  GL_STENCIL_VALUE_MASK = $0B93;
+//  GL_STENCIL_FAIL = $0B94;
+//  GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
+//  GL_STENCIL_PASS_DEPTH_PASS = $0B96;
+//  GL_STENCIL_REF = $0B97;
+//  GL_STENCIL_WRITEMASK = $0B98;
+  GL_MATRIX_MODE = $0BA0;
+//  GL_VIEWPORT = $0BA2;
+  GL_MODELVIEW_STACK_DEPTH = $0BA3;
+  GL_PROJECTION_STACK_DEPTH = $0BA4;
+  GL_TEXTURE_STACK_DEPTH = $0BA5;
+  GL_MODELVIEW_MATRIX = $0BA6;
+  GL_PROJECTION_MATRIX = $0BA7;
+  GL_TEXTURE_MATRIX = $0BA8;
+  GL_ALPHA_TEST_FUNC = $0BC1;
+  GL_ALPHA_TEST_REF = $0BC2;
+  GL_BLEND_DST = $0BE0;
+  GL_BLEND_SRC = $0BE1;
+  GL_LOGIC_OP_MODE = $0BF0;
+//  GL_SCISSOR_BOX = $0C10;
+//  GL_COLOR_CLEAR_VALUE = $0C22;
+//  GL_COLOR_WRITEMASK = $0C23;
+  GL_MAX_LIGHTS = $0D31;
+  GL_MAX_CLIP_PLANES = $0D32;
+//  GL_MAX_TEXTURE_SIZE = $0D33;
+  GL_MAX_MODELVIEW_STACK_DEPTH = $0D36;
+  GL_MAX_PROJECTION_STACK_DEPTH = $0D38;
+  GL_MAX_TEXTURE_STACK_DEPTH = $0D39;
+//  GL_MAX_VIEWPORT_DIMS = $0D3A;
+  GL_MAX_TEXTURE_UNITS = $84E2;
+//  GL_SUBPIXEL_BITS = $0D50;
+//  GL_RED_BITS = $0D52;
+//  GL_GREEN_BITS = $0D53;
+//  GL_BLUE_BITS = $0D54;
+//  GL_ALPHA_BITS = $0D55;
+//  GL_DEPTH_BITS = $0D56;
+//  GL_STENCIL_BITS = $0D57;
+//  GL_POLYGON_OFFSET_UNITS = $2A00;
+//  GL_POLYGON_OFFSET_FILL = $8037;
+//  GL_POLYGON_OFFSET_FACTOR = $8038;
+//  GL_TEXTURE_BINDING_2D = $8069;
+  GL_VERTEX_ARRAY_SIZE = $807A;
+  GL_VERTEX_ARRAY_TYPE = $807B;
+  GL_VERTEX_ARRAY_STRIDE = $807C;
+  GL_NORMAL_ARRAY_TYPE = $807E;
+  GL_NORMAL_ARRAY_STRIDE = $807F;
+  GL_COLOR_ARRAY_SIZE = $8081;
+  GL_COLOR_ARRAY_TYPE = $8082;
+  GL_COLOR_ARRAY_STRIDE = $8083;
+  GL_TEXTURE_COORD_ARRAY_SIZE = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE = $808A;
+  GL_VERTEX_ARRAY_POINTER = $808E;
+  GL_NORMAL_ARRAY_POINTER = $808F;
+  GL_COLOR_ARRAY_POINTER = $8090;
+  GL_TEXTURE_COORD_ARRAY_POINTER = $8092;
+//  GL_SAMPLE_BUFFERS = $80A8;
+//  GL_SAMPLES = $80A9;
+//  GL_SAMPLE_COVERAGE_VALUE = $80AA;
+//  GL_SAMPLE_COVERAGE_INVERT = $80AB;
+//  GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
+//  GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
+//  GL_DONT_CARE = $1100;
+//  GL_FASTEST = $1101;
+//  GL_NICEST = $1102;
+  GL_PERSPECTIVE_CORRECTION_HINT = $0C50;
+  GL_POINT_SMOOTH_HINT = $0C51;
+  GL_LINE_SMOOTH_HINT = $0C52;
+  GL_FOG_HINT = $0C54;
+//  GL_GENERATE_MIPMAP_HINT = $8192;
+  GL_LIGHT_MODEL_AMBIENT = $0B53;
+  GL_LIGHT_MODEL_TWO_SIDE = $0B52;
+  GL_AMBIENT = $1200;
+  GL_DIFFUSE = $1201;
+  GL_SPECULAR = $1202;
+  GL_POSITION = $1203;
+  GL_SPOT_DIRECTION = $1204;
+  GL_SPOT_EXPONENT = $1205;
+  GL_SPOT_CUTOFF = $1206;
+  GL_CONSTANT_ATTENUATION = $1207;
+  GL_LINEAR_ATTENUATION = $1208;
+  GL_QUADRATIC_ATTENUATION = $1209;
+//  GL_BYTE = $1400;
+//  GL_UNSIGNED_BYTE = $1401;
+//  GL_SHORT = $1402;
+//  GL_UNSIGNED_SHORT = $1403;
+//  GL_FLOAT = $1406;
+//  GL_FIXED = $140C;
+  GL_CLEAR = $1500;
+  GL_AND = $1501;
+  GL_AND_REVERSE = $1502;
+  GL_COPY = $1503;
+  GL_AND_INVERTED = $1504;
+  GL_NOOP = $1505;
+  GL_XOR = $1506;
+  GL_OR = $1507;
+  GL_NOR = $1508;
+  GL_EQUIV = $1509;
+//  GL_INVERT = $150A;
+  GL_OR_REVERSE = $150B;
+  GL_COPY_INVERTED = $150C;
+  GL_OR_INVERTED = $150D;
+  GL_NAND = $150E;
+  GL_SET = $150F;
+  GL_EMISSION = $1600;
+  GL_SHININESS = $1601;
+  GL_AMBIENT_AND_DIFFUSE = $1602;
+  GL_MODELVIEW = $1700;
+  GL_PROJECTION = $1701;
+//  GL_TEXTURE = $1702;
+//  GL_ALPHA = $1906;
+//  GL_RGB = $1907;
+//  GL_RGBA = $1908;
+//  GL_LUMINANCE = $1909;
+//  GL_LUMINANCE_ALPHA = $190A;
+//  GL_UNPACK_ALIGNMENT = $0CF5;
+//  GL_PACK_ALIGNMENT = $0D05;
+//  GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
+//  GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
+//  GL_UNSIGNED_SHORT_5_6_5 = $8363;
+  GL_FLAT = $1D00;
+  GL_SMOOTH = $1D01;
+//  GL_KEEP = $1E00;
+//  GL_REPLACE = $1E01;
+//  GL_INCR = $1E02;
+//  GL_DECR = $1E03;
+//  GL_VENDOR = $1F00;
+//  GL_RENDERER = $1F01;
+//  GL_VERSION = $1F02;
+//  GL_EXTENSIONS = $1F03;
+  GL_MODULATE = $2100;
+  GL_DECAL = $2101;
+  GL_ADD = $0104;
+  GL_TEXTURE_ENV_MODE = $2200;
+  GL_TEXTURE_ENV_COLOR = $2201;
+  GL_TEXTURE_ENV = $2300;
+//  GL_NEAREST = $2600;
+//  GL_LINEAR = $2601;
+//  GL_NEAREST_MIPMAP_NEAREST = $2700;
+//  GL_LINEAR_MIPMAP_NEAREST = $2701;
+//  GL_NEAREST_MIPMAP_LINEAR = $2702;
+//  GL_LINEAR_MIPMAP_LINEAR = $2703;
+//  GL_TEXTURE_MAG_FILTER = $2800;
+//  GL_TEXTURE_MIN_FILTER = $2801;
+//  GL_TEXTURE_WRAP_S = $2802;
+//  GL_TEXTURE_WRAP_T = $2803;
+  GL_GENERATE_MIPMAP = $8191;
+//  GL_TEXTURE0 = $84C0;
+//  GL_TEXTURE1 = $84C1;
+//  GL_TEXTURE2 = $84C2;
+//  GL_TEXTURE3 = $84C3;
+//  GL_TEXTURE4 = $84C4;
+//  GL_TEXTURE5 = $84C5;
+//  GL_TEXTURE6 = $84C6;
+//  GL_TEXTURE7 = $84C7;
+//  GL_TEXTURE8 = $84C8;
+//  GL_TEXTURE9 = $84C9;
+//  GL_TEXTURE10 = $84CA;
+//  GL_TEXTURE11 = $84CB;
+//  GL_TEXTURE12 = $84CC;
+//  GL_TEXTURE13 = $84CD;
+//  GL_TEXTURE14 = $84CE;
+//  GL_TEXTURE15 = $84CF;
+//  GL_TEXTURE16 = $84D0;
+//  GL_TEXTURE17 = $84D1;
+//  GL_TEXTURE18 = $84D2;
+//  GL_TEXTURE19 = $84D3;
+//  GL_TEXTURE20 = $84D4;
+//  GL_TEXTURE21 = $84D5;
+//  GL_TEXTURE22 = $84D6;
+//  GL_TEXTURE23 = $84D7;
+//  GL_TEXTURE24 = $84D8;
+//  GL_TEXTURE25 = $84D9;
+//  GL_TEXTURE26 = $84DA;
+//  GL_TEXTURE27 = $84DB;
+//  GL_TEXTURE28 = $84DC;
+//  GL_TEXTURE29 = $84DD;
+//  GL_TEXTURE30 = $84DE;
+//  GL_TEXTURE31 = $84DF;
+//  GL_ACTIVE_TEXTURE = $84E0;
+  GL_CLIENT_ACTIVE_TEXTURE = $84E1;
+//  GL_REPEAT = $2901;
+//  GL_CLAMP_TO_EDGE = $812F;
+  GL_LIGHT0 = $4000;
+  GL_LIGHT1 = $4001;
+  GL_LIGHT2 = $4002;
+  GL_LIGHT3 = $4003;
+  GL_LIGHT4 = $4004;
+  GL_LIGHT5 = $4005;
+  GL_LIGHT6 = $4006;
+  GL_LIGHT7 = $4007;
+//  GL_ARRAY_BUFFER = $8892;
+//  GL_ELEMENT_ARRAY_BUFFER = $8893;
+//  GL_ARRAY_BUFFER_BINDING = $8894;
+//  GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
+  GL_VERTEX_ARRAY_BUFFER_BINDING = $8896;
+  GL_NORMAL_ARRAY_BUFFER_BINDING = $8897;
+  GL_COLOR_ARRAY_BUFFER_BINDING = $8898;
+  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A;
+//  GL_STATIC_DRAW = $88E4;
+//  GL_DYNAMIC_DRAW = $88E8;
+//  GL_BUFFER_SIZE = $8764;
+//  GL_BUFFER_USAGE = $8765;
+  GL_SUBTRACT = $84E7;
+  GL_COMBINE = $8570;
+  GL_COMBINE_RGB = $8571;
+  GL_COMBINE_ALPHA = $8572;
+  GL_RGB_SCALE = $8573;
+  GL_ADD_SIGNED = $8574;
+  GL_INTERPOLATE = $8575;
+  GL_CONSTANT = $8576;
+  GL_PRIMARY_COLOR = $8577;
+  GL_PREVIOUS = $8578;
+  GL_OPERAND0_RGB = $8590;
+  GL_OPERAND1_RGB = $8591;
+  GL_OPERAND2_RGB = $8592;
+  GL_OPERAND0_ALPHA = $8598;
+  GL_OPERAND1_ALPHA = $8599;
+  GL_OPERAND2_ALPHA = $859A;
+  GL_ALPHA_SCALE = $0D1C;
+  GL_SRC0_RGB = $8580;
+  GL_SRC1_RGB = $8581;
+  GL_SRC2_RGB = $8582;
+  GL_SRC0_ALPHA = $8588;
+  GL_SRC1_ALPHA = $8589;
+  GL_SRC2_ALPHA = $858A;
+  GL_DOT3_RGB = $86AE;
+  GL_DOT3_RGBA = $86AF;
+// GL_OES_point_size_array
+  GL_POINT_SIZE_ARRAY_OES = $8B9C;
+  GL_POINT_SIZE_ARRAY_TYPE_OES = $898A;
+  GL_POINT_SIZE_ARRAY_STRIDE_OES = $898B;
+  GL_POINT_SIZE_ARRAY_POINTER_OES = $898C;
+  GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = $8B9F;
+// GL_OES_point_sprite
+  GL_POINT_SPRITE_OES = $8861;
+  GL_COORD_REPLACE_OES = $8862;
+// GL_OES_blend_equation_separate
+  GL_BLEND_EQUATION_RGB_OES = $8009;
+  GL_BLEND_EQUATION_ALPHA_OES = $883D;
+// GL_OES_blend_func_separate
+  GL_BLEND_DST_RGB_OES = $80C8;
+  GL_BLEND_SRC_RGB_OES = $80C9;
+  GL_BLEND_DST_ALPHA_OES = $80CA;
+  GL_BLEND_SRC_ALPHA_OES = $80CB;
+// GL_OES_blend_subtract
+  GL_BLEND_EQUATION_OES = $8009;
+  GL_FUNC_ADD_OES = $8006;
+  GL_FUNC_SUBTRACT_OES = $800A;
+  GL_FUNC_REVERSE_SUBTRACT_OES = $800B;
+// GL_OES_draw_texture
+  GL_TEXTURE_CROP_RECT_OES = $8B9D;
+// GL_OES_fixed_point
+  GL_FIXED_OES = $140C;
+// GL_OES_framebuffer_object
+  GL_NONE_OES = 0;
+  GL_FRAMEBUFFER_OES = $8D40;
+  GL_RENDERBUFFER_OES = $8D41;
+//  GL_RGBA4_OES = $8056;
+//  GL_RGB5_A1_OES = $8057;
+//  GL_RGB565_OES = $8D62;
+//  GL_DEPTH_COMPONENT16_OES = $81A5;
+  GL_RENDERBUFFER_WIDTH_OES = $8D42;
+  GL_RENDERBUFFER_HEIGHT_OES = $8D43;
+  GL_RENDERBUFFER_INTERNAL_FORMAT_OES = $8D44;
+  GL_RENDERBUFFER_RED_SIZE_OES = $8D50;
+  GL_RENDERBUFFER_GREEN_SIZE_OES = $8D51;
+  GL_RENDERBUFFER_BLUE_SIZE_OES = $8D52;
+  GL_RENDERBUFFER_ALPHA_SIZE_OES = $8D53;
+  GL_RENDERBUFFER_DEPTH_SIZE_OES = $8D54;
+  GL_RENDERBUFFER_STENCIL_SIZE_OES = $8D55;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES = $8CD0;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES = $8CD1;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES = $8CD2;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES = $8CD3;
+  GL_COLOR_ATTACHMENT0_OES = $8CE0;
+  GL_DEPTH_ATTACHMENT_OES = $8D00;
+  GL_STENCIL_ATTACHMENT_OES = $8D20;
+  GL_FRAMEBUFFER_COMPLETE_OES = $8CD5;
+  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES = $8CD6;
+  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES = $8CD7;
+  GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES = $8CD9;
+  GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES = $8CDA;
+  GL_FRAMEBUFFER_UNSUPPORTED_OES = $8CDD;
+  GL_FRAMEBUFFER_BINDING_OES = $8CA6;
+  GL_RENDERBUFFER_BINDING_OES = $8CA7;
+  GL_MAX_RENDERBUFFER_SIZE_OES = $84E8;
+  GL_INVALID_FRAMEBUFFER_OPERATION_OES = $0506;
+// GL_OES_matrix_get
+  GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = $898D;
+  GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = $898E;
+  GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = $898F;
+// GL_OES_matrix_palette
+  GL_MAX_VERTEX_UNITS_OES = $86A4;
+  GL_MAX_PALETTE_MATRICES_OES = $8842;
+  GL_MATRIX_PALETTE_OES = $8840;
+  GL_MATRIX_INDEX_ARRAY_OES = $8844;
+  GL_WEIGHT_ARRAY_OES = $86AD;
+  GL_CURRENT_PALETTE_MATRIX_OES = $8843;
+  GL_MATRIX_INDEX_ARRAY_SIZE_OES = $8846;
+  GL_MATRIX_INDEX_ARRAY_TYPE_OES = $8847;
+  GL_MATRIX_INDEX_ARRAY_STRIDE_OES = $8848;
+  GL_MATRIX_INDEX_ARRAY_POINTER_OES = $8849;
+  GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = $8B9E;
+  GL_WEIGHT_ARRAY_SIZE_OES = $86AB;
+  GL_WEIGHT_ARRAY_TYPE_OES = $86A9;
+  GL_WEIGHT_ARRAY_STRIDE_OES = $86AA;
+  GL_WEIGHT_ARRAY_POINTER_OES = $86AC;
+  GL_WEIGHT_ARRAY_BUFFER_BINDING_OES = $889E;
+// GL_OES_stencil_wrap
+  GL_INCR_WRAP_OES = $8507;
+  GL_DECR_WRAP_OES = $8508;
+// GL_OES_texture_cube_map
+  GL_NORMAL_MAP_OES = $8511;
+  GL_REFLECTION_MAP_OES = $8512;
+  GL_TEXTURE_CUBE_MAP_OES = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP_OES = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES = $851A;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES = $851C;
+  GL_TEXTURE_GEN_MODE_OES = $2500;
+  GL_TEXTURE_GEN_STR_OES = $8D60;
+// GL_OES_texture_mirrored_repeat
+  GL_MIRRORED_REPEAT_OES = $8370;
+// GL_AMD_compressed_ATC_texture
+  GL_ATC_RGB_AMD = $8C92;
+//  GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = $8C93;
+//  GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = $87EE;
+// GL_EXT_texture_lod_bias
+  GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD;
+  GL_TEXTURE_FILTER_CONTROL_EXT = $8500;
+  GL_TEXTURE_LOD_BIAS_EXT = $8501;
+// GL_IMG_texture_env_enhanced_fixed_function
+  GL_MODULATE_COLOR_IMG = $8C04;
+  GL_RECIP_ADD_SIGNED_ALPHA_IMG = $8C05;
+  GL_TEXTURE_ALPHA_MODULATE_IMG = $8C06;
+  GL_FACTOR_ALPHA_MODULATE_IMG = $8C07;
+  GL_FRAGMENT_ALPHA_MODULATE_IMG = $8C08;
+  GL_ADD_BLEND_IMG = $8C09;
+  GL_DOT3_RGBA_IMG = $86AF;
+// GL_IMG_user_clip_plane
+  GL_CLIP_PLANE0_IMG = $3000;
+  GL_CLIP_PLANE1_IMG = $3001;
+  GL_CLIP_PLANE2_IMG = $3002;
+  GL_CLIP_PLANE3_IMG = $3003;
+  GL_CLIP_PLANE4_IMG = $3004;
+  GL_CLIP_PLANE5_IMG = $3005;
+  GL_MAX_CLIP_PLANES_IMG = $0D32;
+(*******************************************************************************
+*                           END GLES 1.0/1.1                                 *
+*******************************************************************************)
+
+(*******************************************************************************
+*                            GL_ES_VERSION_2_0                                 *
+*******************************************************************************)
+  GL_DEPTH_BUFFER_BIT = $00000100;
+  GL_STENCIL_BUFFER_BIT = $00000400;
+  GL_COLOR_BUFFER_BIT = $00004000;
+  GL_FALSE = 0;
+  GL_TRUE = 1;
+  GL_POINTS = $0000;
+  GL_LINES = $0001;
+  GL_LINE_LOOP = $0002;
+  GL_LINE_STRIP = $0003;
+  GL_TRIANGLES = $0004;
+  GL_TRIANGLE_STRIP = $0005;
+  GL_TRIANGLE_FAN = $0006;
+  GL_ZERO = 0;
+  GL_ONE = 1;
+  GL_SRC_COLOR = $0300;
+  GL_ONE_MINUS_SRC_COLOR = $0301;
+  GL_SRC_ALPHA = $0302;
+  GL_ONE_MINUS_SRC_ALPHA = $0303;
+  GL_DST_ALPHA = $0304;
+  GL_ONE_MINUS_DST_ALPHA = $0305;
+  GL_DST_COLOR = $0306;
+  GL_ONE_MINUS_DST_COLOR = $0307;
+  GL_SRC_ALPHA_SATURATE = $0308;
+  GL_FUNC_ADD = $8006;
+  GL_BLEND_EQUATION = $8009;
+  GL_BLEND_EQUATION_RGB = $8009;
+  GL_BLEND_EQUATION_ALPHA = $883D;
+  GL_FUNC_SUBTRACT = $800A;
+  GL_FUNC_REVERSE_SUBTRACT = $800B;
+  GL_BLEND_DST_RGB = $80C8;
+  GL_BLEND_SRC_RGB = $80C9;
+  GL_BLEND_DST_ALPHA = $80CA;
+  GL_BLEND_SRC_ALPHA = $80CB;
+  GL_CONSTANT_COLOR = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR = $8002;
+  GL_CONSTANT_ALPHA = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
+  GL_BLEND_COLOR = $8005;
+  GL_ARRAY_BUFFER = $8892;
+  GL_ELEMENT_ARRAY_BUFFER = $8893;
+  GL_ARRAY_BUFFER_BINDING = $8894;
+  GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
+  GL_STREAM_DRAW = $88E0;
+  GL_STATIC_DRAW = $88E4;
+  GL_DYNAMIC_DRAW = $88E8;
+  GL_BUFFER_SIZE = $8764;
+  GL_BUFFER_USAGE = $8765;
+  GL_CURRENT_VERTEX_ATTRIB = $8626;
+  GL_FRONT = $0404;
+  GL_BACK = $0405;
+  GL_FRONT_AND_BACK = $0408;
+  GL_TEXTURE_2D = $0DE1;
+  GL_CULL_FACE = $0B44;
+  GL_BLEND = $0BE2;
+  GL_DITHER = $0BD0;
+  GL_STENCIL_TEST = $0B90;
+  GL_DEPTH_TEST = $0B71;
+  GL_SCISSOR_TEST = $0C11;
+  GL_POLYGON_OFFSET_FILL = $8037;
+  GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
+  GL_SAMPLE_COVERAGE = $80A0;
+  GL_NO_ERROR = 0;
+  GL_INVALID_ENUM = $0500;
+  GL_INVALID_VALUE = $0501;
+  GL_INVALID_OPERATION = $0502;
+  GL_OUT_OF_MEMORY = $0505;
+  GL_CW = $0900;
+  GL_CCW = $0901;
+  GL_LINE_WIDTH = $0B21;
+  GL_ALIASED_POINT_SIZE_RANGE = $846D;
+  GL_ALIASED_LINE_WIDTH_RANGE = $846E;
+  GL_CULL_FACE_MODE = $0B45;
+  GL_FRONT_FACE = $0B46;
+  GL_DEPTH_RANGE = $0B70;
+  GL_DEPTH_WRITEMASK = $0B72;
+  GL_DEPTH_CLEAR_VALUE = $0B73;
+  GL_DEPTH_FUNC = $0B74;
+  GL_STENCIL_CLEAR_VALUE = $0B91;
+  GL_STENCIL_FUNC = $0B92;
+  GL_STENCIL_FAIL = $0B94;
+  GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
+  GL_STENCIL_PASS_DEPTH_PASS = $0B96;
+  GL_STENCIL_REF = $0B97;
+  GL_STENCIL_VALUE_MASK = $0B93;
+  GL_STENCIL_WRITEMASK = $0B98;
+  GL_STENCIL_BACK_FUNC = $8800;
+  GL_STENCIL_BACK_FAIL = $8801;
+  GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;
+  GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;
+  GL_STENCIL_BACK_REF = $8CA3;
+  GL_STENCIL_BACK_VALUE_MASK = $8CA4;
+  GL_STENCIL_BACK_WRITEMASK = $8CA5;
+  GL_VIEWPORT = $0BA2;
+  GL_SCISSOR_BOX = $0C10;
+  GL_COLOR_CLEAR_VALUE = $0C22;
+  GL_COLOR_WRITEMASK = $0C23;
+  GL_UNPACK_ALIGNMENT = $0CF5;
+  GL_PACK_ALIGNMENT = $0D05;
+  GL_MAX_TEXTURE_SIZE = $0D33;
+  GL_MAX_VIEWPORT_DIMS = $0D3A;
+  GL_SUBPIXEL_BITS = $0D50;
+  GL_RED_BITS = $0D52;
+  GL_GREEN_BITS = $0D53;
+  GL_BLUE_BITS = $0D54;
+  GL_ALPHA_BITS = $0D55;
+  GL_DEPTH_BITS = $0D56;
+  GL_STENCIL_BITS = $0D57;
+  GL_POLYGON_OFFSET_UNITS = $2A00;
+  GL_POLYGON_OFFSET_FACTOR = $8038;
+  GL_TEXTURE_BINDING_2D = $8069;
+  GL_SAMPLE_BUFFERS = $80A8;
+  GL_SAMPLES = $80A9;
+  GL_SAMPLE_COVERAGE_VALUE = $80AA;
+  GL_SAMPLE_COVERAGE_INVERT = $80AB;
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
+  GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
+  GL_DONT_CARE = $1100;
+  GL_FASTEST = $1101;
+  GL_NICEST = $1102;
+  GL_GENERATE_MIPMAP_HINT = $8192;
+  GL_BYTE = $1400;
+  GL_UNSIGNED_BYTE = $1401;
+  GL_SHORT = $1402;
+  GL_UNSIGNED_SHORT = $1403;
+  GL_INT = $1404;
+  GL_UNSIGNED_INT = $1405;
+  GL_FLOAT = $1406;
+  GL_FIXED = $140C;
+  GL_DEPTH_COMPONENT = $1902;
+  GL_ALPHA = $1906;
+  GL_RGB = $1907;
+  GL_RGBA = $1908;
+  GL_LUMINANCE = $1909;
+  GL_LUMINANCE_ALPHA = $190A;
+  GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
+  GL_UNSIGNED_SHORT_5_6_5 = $8363;
+  GL_FRAGMENT_SHADER = $8B30;
+  GL_VERTEX_SHADER = $8B31;
+  GL_MAX_VERTEX_ATTRIBS = $8869;
+  GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB;
+  GL_MAX_VARYING_VECTORS = $8DFC;
+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;
+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;
+  GL_MAX_TEXTURE_IMAGE_UNITS = $8872;
+  GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD;
+  GL_SHADER_TYPE = $8B4F;
+  GL_DELETE_STATUS = $8B80;
+  GL_LINK_STATUS = $8B82;
+  GL_VALIDATE_STATUS = $8B83;
+  GL_ATTACHED_SHADERS = $8B85;
+  GL_ACTIVE_UNIFORMS = $8B86;
+  GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;
+  GL_ACTIVE_ATTRIBUTES = $8B89;
+  GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;
+  GL_SHADING_LANGUAGE_VERSION = $8B8C;
+  GL_CURRENT_PROGRAM = $8B8D;
+  GL_NEVER = $0200;
+  GL_LESS = $0201;
+  GL_EQUAL = $0202;
+  GL_LEQUAL = $0203;
+  GL_GREATER = $0204;
+  GL_NOTEQUAL = $0205;
+  GL_GEQUAL = $0206;
+  GL_ALWAYS = $0207;
+  GL_KEEP = $1E00;
+  GL_REPLACE = $1E01;
+  GL_INCR = $1E02;
+  GL_DECR = $1E03;
+  GL_INVERT = $150A;
+  GL_INCR_WRAP = $8507;
+  GL_DECR_WRAP = $8508;
+  GL_VENDOR = $1F00;
+  GL_RENDERER = $1F01;
+  GL_VERSION = $1F02;
+  GL_EXTENSIONS = $1F03;
+  GL_NEAREST = $2600;
+  GL_LINEAR = $2601;
+  GL_NEAREST_MIPMAP_NEAREST = $2700;
+  GL_LINEAR_MIPMAP_NEAREST = $2701;
+  GL_NEAREST_MIPMAP_LINEAR = $2702;
+  GL_LINEAR_MIPMAP_LINEAR = $2703;
+  GL_TEXTURE_MAG_FILTER = $2800;
+  GL_TEXTURE_MIN_FILTER = $2801;
+  GL_TEXTURE_WRAP_S = $2802;
+  GL_TEXTURE_WRAP_T = $2803;
+  GL_TEXTURE = $1702;
+  GL_TEXTURE_CUBE_MAP = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
+  GL_TEXTURE0 = $84C0;
+  GL_TEXTURE1 = $84C1;
+  GL_TEXTURE2 = $84C2;
+  GL_TEXTURE3 = $84C3;
+  GL_TEXTURE4 = $84C4;
+  GL_TEXTURE5 = $84C5;
+  GL_TEXTURE6 = $84C6;
+  GL_TEXTURE7 = $84C7;
+  GL_TEXTURE8 = $84C8;
+  GL_TEXTURE9 = $84C9;
+  GL_TEXTURE10 = $84CA;
+  GL_TEXTURE11 = $84CB;
+  GL_TEXTURE12 = $84CC;
+  GL_TEXTURE13 = $84CD;
+  GL_TEXTURE14 = $84CE;
+  GL_TEXTURE15 = $84CF;
+  GL_TEXTURE16 = $84D0;
+  GL_TEXTURE17 = $84D1;
+  GL_TEXTURE18 = $84D2;
+  GL_TEXTURE19 = $84D3;
+  GL_TEXTURE20 = $84D4;
+  GL_TEXTURE21 = $84D5;
+  GL_TEXTURE22 = $84D6;
+  GL_TEXTURE23 = $84D7;
+  GL_TEXTURE24 = $84D8;
+  GL_TEXTURE25 = $84D9;
+  GL_TEXTURE26 = $84DA;
+  GL_TEXTURE27 = $84DB;
+  GL_TEXTURE28 = $84DC;
+  GL_TEXTURE29 = $84DD;
+  GL_TEXTURE30 = $84DE;
+  GL_TEXTURE31 = $84DF;
+  GL_ACTIVE_TEXTURE = $84E0;
+  GL_REPEAT = $2901;
+  GL_CLAMP_TO_EDGE = $812F;
+  GL_MIRRORED_REPEAT = $8370;
+  GL_FLOAT_VEC2 = $8B50;
+  GL_FLOAT_VEC3 = $8B51;
+  GL_FLOAT_VEC4 = $8B52;
+  GL_INT_VEC2 = $8B53;
+  GL_INT_VEC3 = $8B54;
+  GL_INT_VEC4 = $8B55;
+  GL_BOOL = $8B56;
+  GL_BOOL_VEC2 = $8B57;
+  GL_BOOL_VEC3 = $8B58;
+  GL_BOOL_VEC4 = $8B59;
+  GL_FLOAT_MAT2 = $8B5A;
+  GL_FLOAT_MAT3 = $8B5B;
+  GL_FLOAT_MAT4 = $8B5C;
+  GL_SAMPLER_2D = $8B5E;
+  GL_SAMPLER_CUBE = $8B60;
+  GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;
+  GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;
+  GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;
+  GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;
+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;
+  GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;
+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;
+  GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A;
+  GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B;
+  GL_COMPILE_STATUS = $8B81;
+  GL_INFO_LOG_LENGTH = $8B84;
+  GL_SHADER_SOURCE_LENGTH = $8B88;
+  GL_SHADER_COMPILER = $8DFA;
+  GL_SHADER_BINARY_FORMATS = $8DF8;
+  GL_NUM_SHADER_BINARY_FORMATS = $8DF9;
+  GL_LOW_FLOAT = $8DF0;
+  GL_MEDIUM_FLOAT = $8DF1;
+  GL_HIGH_FLOAT = $8DF2;
+  GL_LOW_INT = $8DF3;
+  GL_MEDIUM_INT = $8DF4;
+  GL_HIGH_INT = $8DF5;
+  GL_FRAMEBUFFER = $8D40;
+  GL_RENDERBUFFER = $8D41;
+  GL_RGBA4 = $8056;
+  GL_RGB5_A1 = $8057;
+  GL_RGB565 = $8D62;
+  GL_DEPTH_COMPONENT16 = $81A5;
+  GL_STENCIL_INDEX8 = $8D48;
+  GL_RENDERBUFFER_WIDTH = $8D42;
+  GL_RENDERBUFFER_HEIGHT = $8D43;
+  GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44;
+  GL_RENDERBUFFER_RED_SIZE = $8D50;
+  GL_RENDERBUFFER_GREEN_SIZE = $8D51;
+  GL_RENDERBUFFER_BLUE_SIZE = $8D52;
+  GL_RENDERBUFFER_ALPHA_SIZE = $8D53;
+  GL_RENDERBUFFER_DEPTH_SIZE = $8D54;
+  GL_RENDERBUFFER_STENCIL_SIZE = $8D55;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3;
+  GL_COLOR_ATTACHMENT0 = $8CE0;
+  GL_DEPTH_ATTACHMENT = $8D00;
+  GL_STENCIL_ATTACHMENT = $8D20;
+  GL_NONE = 0;
+  GL_FRAMEBUFFER_COMPLETE = $8CD5;
+  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6;
+  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7;
+  GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = $8CD9;
+  GL_FRAMEBUFFER_UNSUPPORTED = $8CDD;
+  GL_FRAMEBUFFER_BINDING = $8CA6;
+  GL_RENDERBUFFER_BINDING = $8CA7;
+  GL_MAX_RENDERBUFFER_SIZE = $84E8;
+  GL_INVALID_FRAMEBUFFER_OPERATION = $0506;
+// GL_KHR_blend_equation_advanced
+  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;
+// GL_KHR_blend_equation_advanced_coherent
+  GL_BLEND_ADVANCED_COHERENT_KHR = $9285;
+// GL_KHR_context_flush_control
+  GL_CONTEXT_RELEASE_BEHAVIOR_KHR = $82FB;
+  GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = $82FC;
+// GL_KHR_debug
+  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_PROGRAM_PIPELINE_KHR = $82E4;
+  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;
+
+{$IfDef GL_KHR_debug}
+type
+   GLDEBUGPROCKHR = procedure(source:GLenum; _type:GLenum; id:GLuint; severity:GLenum; length:GLsizei;
+                  message:PGLchar; userParam:pointer);cdecl;
+{$EndIf}
+const
+// GL_KHR_no_error
+  GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR = $00000008;
+// GL_KHR_parallel_shader_compile
+  GL_MAX_SHADER_COMPILER_THREADS_KHR = $91B0;
+  GL_COMPLETION_STATUS_KHR = $91B1;
+// GL_KHR_robustness
+  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;
+// GL_KHR_shader_subgroup
+  GL_SUBGROUP_SIZE_KHR = $9532;
+  GL_SUBGROUP_SUPPORTED_STAGES_KHR = $9533;
+  GL_SUBGROUP_SUPPORTED_FEATURES_KHR = $9534;
+  GL_SUBGROUP_QUAD_ALL_STAGES_KHR = $9535;
+  GL_SUBGROUP_FEATURE_BASIC_BIT_KHR = $00000001;
+  GL_SUBGROUP_FEATURE_VOTE_BIT_KHR = $00000002;
+  GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR = $00000004;
+  GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR = $00000008;
+  GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR = $00000010;
+  GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR = $00000020;
+  GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR = $00000040;
+  GL_SUBGROUP_FEATURE_QUAD_BIT_KHR = $00000080;
+// GL_KHR_texture_compression_astc_hdr
+  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_OES_EGL_image_external
+  GL_TEXTURE_EXTERNAL_OES = $8D65;
+  GL_TEXTURE_BINDING_EXTERNAL_OES = $8D67;
+  GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES = $8D68;
+  GL_SAMPLER_EXTERNAL_OES = $8D66;
+// GL_OES_compressed_ETC1_RGB8_texture
+  GL_ETC1_RGB8_OES = $8D64;
+// GL_OES_compressed_paletted_texture
+  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
+  GL_DEPTH_COMPONENT24_OES = $81A6;
+// GL_OES_depth32
+  GL_DEPTH_COMPONENT32_OES = $81A7;
+// GL_OES_draw_buffers_indexed
+  GL_MIN = $8007;
+  GL_MAX = $8008;
+// GL_OES_geometry_shader
+  GL_GEOMETRY_SHADER_OES = $8DD9;
+  GL_GEOMETRY_SHADER_BIT_OES = $00000004;
+  GL_GEOMETRY_LINKED_VERTICES_OUT_OES = $8916;
+  GL_GEOMETRY_LINKED_INPUT_TYPE_OES = $8917;
+  GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES = $8918;
+  GL_GEOMETRY_SHADER_INVOCATIONS_OES = $887F;
+  GL_LAYER_PROVOKING_VERTEX_OES = $825E;
+  GL_LINES_ADJACENCY_OES = $000A;
+  GL_LINE_STRIP_ADJACENCY_OES = $000B;
+  GL_TRIANGLES_ADJACENCY_OES = $000C;
+  GL_TRIANGLE_STRIP_ADJACENCY_OES = $000D;
+  GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES = $8DDF;
+  GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES = $8A2C;
+  GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES = $8A32;
+  GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES = $9123;
+  GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES = $9124;
+  GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES = $8DE0;
+  GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES = $8DE1;
+  GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES = $8E5A;
+  GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES = $8C29;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES = $92CF;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES = $92D5;
+  GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES = $90CD;
+  GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES = $90D7;
+  GL_FIRST_VERTEX_CONVENTION_OES = $8E4D;
+  GL_LAST_VERTEX_CONVENTION_OES = $8E4E;
+  GL_UNDEFINED_VERTEX_OES = $8260;
+  GL_PRIMITIVES_GENERATED_OES = $8C87;
+  GL_FRAMEBUFFER_DEFAULT_LAYERS_OES = $9312;
+  GL_MAX_FRAMEBUFFER_LAYERS_OES = $9317;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES = $8DA8;
+  GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES = $8DA7;
+  GL_REFERENCED_BY_GEOMETRY_SHADER_OES = $9309;
+// GL_OES_get_program_binary
+  GL_PROGRAM_BINARY_LENGTH_OES = $8741;
+  GL_NUM_PROGRAM_BINARY_FORMATS_OES = $87FE;
+  GL_PROGRAM_BINARY_FORMATS_OES = $87FF;
+// GL_OES_mapbuffer
+  GL_WRITE_ONLY_OES = $88B9;
+  GL_BUFFER_ACCESS_OES = $88BB;
+  GL_BUFFER_MAPPED_OES = $88BC;
+  GL_BUFFER_MAP_POINTER_OES = $88BD;
+// GL_OES_packed_depth_stencil
+  GL_DEPTH_STENCIL_OES = $84F9;
+  GL_UNSIGNED_INT_24_8_OES = $84FA;
+  GL_DEPTH24_STENCIL8_OES = $88F0;
+// GL_OES_primitive_bounding_box
+  GL_PRIMITIVE_BOUNDING_BOX_OES = $92BE;
+// GL_OES_required_internalformat
+  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_sample_shading
+  GL_SAMPLE_SHADING_OES = $8C36;
+  GL_MIN_SAMPLE_SHADING_VALUE_OES = $8C37;
+// GL_OES_shader_multisample_interpolation
+  GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = $8E5B;
+  GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = $8E5C;
+  GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = $8E5D;
+// GL_OES_standard_derivatives
+  GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES = $8B8B;
+// GL_OES_stencil1
+  GL_STENCIL_INDEX1_OES = $8D46;
+// GL_OES_stencil4
+  GL_STENCIL_INDEX4_OES = $8D47;
+// GL_OES_surfaceless_context
+  GL_FRAMEBUFFER_UNDEFINED_OES = $8219;
+// GL_OES_tessellation_shader
+  GL_PATCHES_OES = $000E;
+  GL_PATCH_VERTICES_OES = $8E72;
+  GL_TESS_CONTROL_OUTPUT_VERTICES_OES = $8E75;
+  GL_TESS_GEN_MODE_OES = $8E76;
+  GL_TESS_GEN_SPACING_OES = $8E77;
+  GL_TESS_GEN_VERTEX_ORDER_OES = $8E78;
+  GL_TESS_GEN_POINT_MODE_OES = $8E79;
+  GL_ISOLINES_OES = $8E7A;
+  GL_QUADS_OES = $0007;
+  GL_FRACTIONAL_ODD_OES = $8E7B;
+  GL_FRACTIONAL_EVEN_OES = $8E7C;
+  GL_MAX_PATCH_VERTICES_OES = $8E7D;
+  GL_MAX_TESS_GEN_LEVEL_OES = $8E7E;
+  GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES = $8E7F;
+  GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES = $8E80;
+  GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES = $8E81;
+  GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES = $8E82;
+  GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES = $8E83;
+  GL_MAX_TESS_PATCH_COMPONENTS_OES = $8E84;
+  GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES = $8E85;
+  GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES = $8E86;
+  GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES = $8E89;
+  GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES = $8E8A;
+  GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES = $886C;
+  GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES = $886D;
+  GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES = $8E1E;
+  GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES = $8E1F;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES = $92CD;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES = $92CE;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES = $92D3;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES = $92D4;
+  GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES = $90CB;
+  GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES = $90CC;
+  GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES = $90D8;
+  GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES = $90D9;
+  GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES = $8221;
+  GL_IS_PER_PATCH_OES = $92E7;
+  GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES = $9307;
+  GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES = $9308;
+  GL_TESS_CONTROL_SHADER_OES = $8E88;
+  GL_TESS_EVALUATION_SHADER_OES = $8E87;
+  GL_TESS_CONTROL_SHADER_BIT_OES = $00000008;
+  GL_TESS_EVALUATION_SHADER_BIT_OES = $00000010;
+// GL_OES_texture_3D
+  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;
+// GL_OES_texture_border_clamp
+  GL_TEXTURE_BORDER_COLOR_OES = $1004;
+  GL_CLAMP_TO_BORDER_OES = $812D;
+// GL_OES_texture_buffer
+  GL_TEXTURE_BUFFER_OES = $8C2A;
+  GL_TEXTURE_BUFFER_BINDING_OES = $8C2A;
+  GL_MAX_TEXTURE_BUFFER_SIZE_OES = $8C2B;
+  GL_TEXTURE_BINDING_BUFFER_OES = $8C2C;
+  GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES = $8C2D;
+  GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES = $919F;
+  GL_SAMPLER_BUFFER_OES = $8DC2;
+  GL_INT_SAMPLER_BUFFER_OES = $8DD0;
+  GL_UNSIGNED_INT_SAMPLER_BUFFER_OES = $8DD8;
+  GL_IMAGE_BUFFER_OES = $9051;
+  GL_INT_IMAGE_BUFFER_OES = $905C;
+  GL_UNSIGNED_INT_IMAGE_BUFFER_OES = $9067;
+  GL_TEXTURE_BUFFER_OFFSET_OES = $919D;
+  GL_TEXTURE_BUFFER_SIZE_OES = $919E;
+ // GL_OES_texture_compression_astc
+  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_cube_map_array
+  GL_TEXTURE_CUBE_MAP_ARRAY_OES = $9009;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES = $900A;
+  GL_SAMPLER_CUBE_MAP_ARRAY_OES = $900C;
+  GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES = $900D;
+  GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES = $900E;
+  GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES = $900F;
+  GL_IMAGE_CUBE_MAP_ARRAY_OES = $9054;
+  GL_INT_IMAGE_CUBE_MAP_ARRAY_OES = $905F;
+  GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES = $906A;
+// GL_OES_texture_half_float
+  GL_HALF_FLOAT_OES = $8D61;
+// GL_OES_texture_stencil8
+  GL_STENCIL_INDEX_OES = $1901;
+  GL_STENCIL_INDEX8_OES = $8D48;
+// GL_OES_texture_storage_multisample_2d_array
+  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;
+// GL_OES_texture_view
+  GL_TEXTURE_VIEW_MIN_LEVEL_OES = $82DB;
+  GL_TEXTURE_VIEW_NUM_LEVELS_OES = $82DC;
+  GL_TEXTURE_VIEW_MIN_LAYER_OES = $82DD;
+  GL_TEXTURE_VIEW_NUM_LAYERS_OES = $82DE;
+  GL_TEXTURE_IMMUTABLE_LEVELS = $82DF;
+// GL_OES_vertex_array_object
+  GL_VERTEX_ARRAY_BINDING_OES = $85B5;
+// GL_OES_vertex_type_10_10_10_2
+  GL_UNSIGNED_INT_10_10_10_2_OES = $8DF6;
+  GL_INT_10_10_10_2_OES = $8DF7;
+// GL_OES_viewport_array
+  GL_MAX_VIEWPORTS_OES = $825B;
+  GL_VIEWPORT_SUBPIXEL_BITS_OES = $825C;
+  GL_VIEWPORT_BOUNDS_RANGE_OES = $825D;
+  GL_VIEWPORT_INDEX_PROVOKING_VERTEX_OES = $825F;
+// GL_AMD_compressed_3DC_texture
+  GL_3DC_X_AMD = $87F9;
+  GL_3DC_XY_AMD = $87FA;
+// GL_AMD_compressed_ATC_texture
+  GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = $8C93;
+  GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = $87EE;
+// GL_AMD_framebuffer_multisample_advanced
+  GL_RENDERBUFFER_STORAGE_SAMPLES_AMD = $91B2;
+  GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD = $91B3;
+  GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD = $91B4;
+  GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD = $91B5;
+  GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD = $91B6;
+  GL_SUPPORTED_MULTISAMPLE_MODES_AMD = $91B7;
+// GL_AMD_performance_monitor
+  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;
+// GL_AMD_program_binary_Z400
+  GL_Z400_BINARY_AMD = $8740;
+// GL_ANGLE_framebuffer_blit
+  GL_READ_FRAMEBUFFER_ANGLE = $8CA8;
+  GL_DRAW_FRAMEBUFFER_ANGLE = $8CA9;
+  GL_DRAW_FRAMEBUFFER_BINDING_ANGLE = $8CA6;
+  GL_READ_FRAMEBUFFER_BINDING_ANGLE = $8CAA;
+// GL_ANGLE_framebuffer_multisample
+  GL_RENDERBUFFER_SAMPLES_ANGLE = $8CAB;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE = $8D56;
+  GL_MAX_SAMPLES_ANGLE = $8D57;
+// GL_ANGLE_instanced_arrays
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = $88FE;
+// GL_ANGLE_pack_reverse_row_order
+  GL_PACK_REVERSE_ROW_ORDER_ANGLE = $93A4;
+// GL_ANGLE_program_binary
+  GL_PROGRAM_BINARY_ANGLE = $93A6;
+// GL_ANGLE_texture_compression_dxt3
+  GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE = $83F2;
+// GL_ANGLE_texture_compression_dxt5
+  GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE = $83F3;
+// GL_ANGLE_texture_usage
+  GL_FRAMEBUFFER_ATTACHMENT_ANGLE = $93A3;
+// GL_ANGLE_translated_shader_source
+  GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE = $93A0;
+// GL_APPLE_clip_distance
+  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_framebuffer_multisample
+  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;
+// GL_APPLE_rgb_422
+  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
+  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;
+// GL_APPLE_texture_format_BGRA8888
+  GL_BGRA_EXT = $80E1;
+  GL_BGRA8_EXT = $93A1;
+// GL_APPLE_texture_max_level
+  GL_TEXTURE_MAX_LEVEL_APPLE = $813D;
+// GL_APPLE_texture_packed_float
+  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
+  GL_MALI_PROGRAM_BINARY_ARM = $8F61;
+// GL_ARM_mali_shader_binary
+  GL_MALI_SHADER_BINARY_ARM = $8F60;
+// GL_ARM_shader_framebuffer_fetch
+  GL_FETCH_PER_SAMPLE_ARM = $8F65;
+  GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM = $8F66;
+// GL_DMP_program_binary
+  GL_SMAPHS30_PROGRAM_BINARY_DMP = $9251;
+  GL_SMAPHS_PROGRAM_BINARY_DMP = $9252;
+  GL_DMP_PROGRAM_BINARY_DMP = $9253;
+// GL_DMP_shader_binary
+  GL_SHADER_BINARY_DMP = $9250;
+// GL_EXT_EGL_image_storage_compression
+  GL_SURFACE_COMPRESSION_EXT = $96C0;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT = $96C1;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = $96C2;
+// GL_EXT_YUV_target
+  GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT = $8BE7;
+// GL_EXT_blend_func_extended
+  GL_SRC1_COLOR_EXT = $88F9;
+  GL_SRC1_ALPHA_EXT = $8589;
+  GL_ONE_MINUS_SRC1_COLOR_EXT = $88FA;
+  GL_ONE_MINUS_SRC1_ALPHA_EXT = $88FB;
+  GL_SRC_ALPHA_SATURATE_EXT = $0308;
+  GL_LOCATION_INDEX_EXT = $930F;
+  GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT = $88FC;
+// GL_EXT_blend_minmax
+  GL_MIN_EXT = $8007;
+  GL_MAX_EXT = $8008;
+// GL_EXT_buffer_storage
+  GL_MAP_READ_BIT = $0001;
+  GL_MAP_WRITE_BIT = $0002;
+  GL_MAP_PERSISTENT_BIT_EXT = $0040;
+  GL_MAP_COHERENT_BIT_EXT = $0080;
+  GL_DYNAMIC_STORAGE_BIT_EXT = $0100;
+  GL_CLIENT_STORAGE_BIT_EXT = $0200;
+  GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT = $00004000;
+  GL_BUFFER_IMMUTABLE_STORAGE_EXT = $821F;
+  GL_BUFFER_STORAGE_FLAGS_EXT = $8220;
+// GL_EXT_clip_control
+  GL_LOWER_LEFT_EXT = $8CA1;
+  GL_UPPER_LEFT_EXT = $8CA2;
+  GL_NEGATIVE_ONE_TO_ONE_EXT = $935E;
+  GL_ZERO_TO_ONE_EXT = $935F;
+  GL_CLIP_ORIGIN_EXT = $935C;
+  GL_CLIP_DEPTH_MODE_EXT = $935D;
+// GL_EXT_clip_cull_distance
+  GL_MAX_CLIP_DISTANCES_EXT = $0D32;
+  GL_MAX_CULL_DISTANCES_EXT = $82F9;
+  GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT = $82FA;
+  GL_CLIP_DISTANCE0_EXT = $3000;
+  GL_CLIP_DISTANCE1_EXT = $3001;
+  GL_CLIP_DISTANCE2_EXT = $3002;
+  GL_CLIP_DISTANCE3_EXT = $3003;
+  GL_CLIP_DISTANCE4_EXT = $3004;
+  GL_CLIP_DISTANCE5_EXT = $3005;
+  GL_CLIP_DISTANCE6_EXT = $3006;
+  GL_CLIP_DISTANCE7_EXT = $3007;
+// GL_EXT_color_buffer_half_float
+  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_debug_label
+  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;
+// GL_EXT_depth_clamp
+  GL_DEPTH_CLAMP_EXT = $864F;
+// GL_EXT_discard_framebuffer
+  GL_COLOR_EXT = $1800;
+  GL_DEPTH_EXT = $1801;
+  GL_STENCIL_EXT = $1802;
+// GL_EXT_disjoint_timer_query
+  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;
+// GL_EXT_draw_buffers
+  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;
+{$IfDef GL_EXT_external_buffer}
+type
+  GLeglClientBufferEXT = pointer;
+{$EndIf}
+
+const
+// GL_EXT_fragment_shading_rate
+  GL_SHADING_RATE_1X1_PIXELS_EXT = $96A6;
+  GL_SHADING_RATE_1X2_PIXELS_EXT = $96A7;
+  GL_SHADING_RATE_2X1_PIXELS_EXT = $96A8;
+  GL_SHADING_RATE_2X2_PIXELS_EXT = $96A9;
+  GL_SHADING_RATE_1X4_PIXELS_EXT = $96AA;
+  GL_SHADING_RATE_4X1_PIXELS_EXT = $96AB;
+  GL_SHADING_RATE_4X2_PIXELS_EXT = $96AC;
+  GL_SHADING_RATE_2X4_PIXELS_EXT = $96AD;
+  GL_SHADING_RATE_4X4_PIXELS_EXT = $96AE;
+  GL_SHADING_RATE_EXT = $96D0;
+  GL_SHADING_RATE_ATTACHMENT_EXT = $96D1;
+  GL_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_EXT = $96D2;
+  GL_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_EXT = $96D3;
+  GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_EXT = $96D4;
+  GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_EXT = $96D5;
+  GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_EXT = $96D6;
+  GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT = $96D7;
+  GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT = $96D8;
+  GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT = $96D9;
+  GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT = $96DA;
+  GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO_EXT = $96DB;
+  GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS_EXT = $96DC;
+  GL_FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED_EXT = $96DD;
+  GL_FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED_EXT = $96DE;
+  GL_FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED_EXT = $96DF;
+  GL_FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED_EXT = $8F6F;
+// GL_EXT_geometry_shader
+  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;
+// GL_EXT_instanced_arrays
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT = $88FE;
+// GL_EXT_map_buffer_range
+  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;
+// GL_EXT_memory_object
+  GL_TEXTURE_TILING_EXT = $9580;
+  GL_DEDICATED_MEMORY_OBJECT_EXT = $9581;
+  GL_PROTECTED_MEMORY_OBJECT_EXT = $959B;
+  GL_NUM_TILING_TYPES_EXT = $9582;
+  GL_TILING_TYPES_EXT = $9583;
+  GL_OPTIMAL_TILING_EXT = $9584;
+  GL_LINEAR_TILING_EXT = $9585;
+  GL_NUM_DEVICE_UUIDS_EXT = $9596;
+  GL_DEVICE_UUID_EXT = $9597;
+  GL_DRIVER_UUID_EXT = $9598;
+  GL_UUID_SIZE_EXT = 16;
+// GL_EXT_memory_object_fd
+  GL_HANDLE_TYPE_OPAQUE_FD_EXT = $9586;
+// GL_EXT_memory_object_win32
+  GL_HANDLE_TYPE_OPAQUE_WIN32_EXT = $9587;
+  GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT = $9588;
+  GL_DEVICE_LUID_EXT = $9599;
+  GL_DEVICE_NODE_MASK_EXT = $959A;
+  GL_LUID_SIZE_EXT = 8;
+  GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT = $9589;
+  GL_HANDLE_TYPE_D3D12_RESOURCE_EXT = $958A;
+  GL_HANDLE_TYPE_D3D11_IMAGE_EXT = $958B;
+  GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT = $958C;
+// GL_EXT_multisampled_compatibility
+  GL_MULTISAMPLE_EXT = $809D;
+  GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F;
+// GL_EXT_multisampled_render_to_texture
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT = $8D6C;
+  GL_RENDERBUFFER_SAMPLES_EXT = $8CAB;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56;
+  GL_MAX_SAMPLES_EXT = $8D57;
+// GL_EXT_multiview_draw_buffers
+  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;
+// GL_EXT_occlusion_query_boolean
+  GL_ANY_SAMPLES_PASSED_EXT = $8C2F;
+  GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = $8D6A;
+// GL_EXT_polygon_offset_clamp
+  GL_POLYGON_OFFSET_CLAMP_EXT = $8E1B;
+// GL_EXT_primitive_bounding_box
+  GL_PRIMITIVE_BOUNDING_BOX_EXT = $92BE;
+// GL_EXT_protected_textures
+  GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT = $00000010;
+  GL_TEXTURE_PROTECTED_EXT = $8BFA;
+// GL_EXT_pvrtc_sRGB
+  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_raster_multisample
+  GL_RASTER_MULTISAMPLE_EXT = $9327;
+  GL_RASTER_SAMPLES_EXT = $9328;
+  GL_MAX_RASTER_SAMPLES_EXT = $9329;
+  GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT = $932A;
+  GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = $932B;
+  GL_EFFECTIVE_RASTER_SAMPLES_EXT = $932C;
+// GL_EXT_read_format_bgra
+  GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT = $8365;
+  GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT = $8366;
+// GL_EXT_render_snorm
+  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
+  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;
+// GL_EXT_sRGB
+  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
+  GL_FRAMEBUFFER_SRGB_EXT = $8DB9;
+// GL_EXT_semaphore
+  GL_LAYOUT_GENERAL_EXT = $958D;
+  GL_LAYOUT_COLOR_ATTACHMENT_EXT = $958E;
+  GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT = $958F;
+  GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT = $9590;
+  GL_LAYOUT_SHADER_READ_ONLY_EXT = $9591;
+  GL_LAYOUT_TRANSFER_SRC_EXT = $9592;
+  GL_LAYOUT_TRANSFER_DST_EXT = $9593;
+  GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT = $9530;
+  GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT = $9531;
+// GL_EXT_semaphore_win32
+  GL_HANDLE_TYPE_D3D12_FENCE_EXT = $9594;
+  GL_D3D12_FENCE_VALUE_EXT = $9595;
+// GL_EXT_separate_shader_objects
+  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;
+// GL_EXT_shader_framebuffer_fetch
+  GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = $8A52;
+// GL_EXT_shader_pixel_local_storage
+  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_pixel_local_storage2
+  GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT = $9650;
+  GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT = $9651;
+  GL_FRAMEBUFFER_INCOMPLETE_INSUFFICIENT_SHADER_COMBINED_LOCAL_STORAGE_EXT = $9652;
+// GL_EXT_shadow_samplers
+  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_sparse_texture
+  GL_TEXTURE_SPARSE_EXT = $91A6;
+  GL_VIRTUAL_PAGE_SIZE_INDEX_EXT = $91A7;
+  GL_NUM_SPARSE_LEVELS_EXT = $91AA;
+  GL_NUM_VIRTUAL_PAGE_SIZES_EXT = $91A8;
+  GL_VIRTUAL_PAGE_SIZE_X_EXT = $9195;
+  GL_VIRTUAL_PAGE_SIZE_Y_EXT = $9196;
+  GL_VIRTUAL_PAGE_SIZE_Z_EXT = $9197;
+  GL_TEXTURE_2D_ARRAY = $8C1A;
+  GL_TEXTURE_3D = $806F;
+  GL_MAX_SPARSE_TEXTURE_SIZE_EXT = $9198;
+  GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT = $9199;
+  GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT = $919A;
+  GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT = $91A9;
+// GL_EXT_tessellation_shader
+  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;
+// GL_EXT_texture_border_clamp
+  GL_TEXTURE_BORDER_COLOR_EXT = $1004;
+  GL_CLAMP_TO_BORDER_EXT = $812D;
+// GL_EXT_texture_buffer
+  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;
+// GL_EXT_texture_compression_astc_decode_mode
+  GL_TEXTURE_ASTC_DECODE_PRECISION_EXT = $8F69;
+// GL_EXT_texture_compression_bptc
+  GL_COMPRESSED_RGBA_BPTC_UNORM_EXT = $8E8C;
+  GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = $8E8D;
+  GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT = $8E8E;
+  GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT = $8E8F;
+// GL_EXT_texture_compression_dxt1
+  GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
+  GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
+// GL_EXT_texture_compression_rgtc
+  GL_COMPRESSED_RED_RGTC1_EXT = $8DBB;
+  GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC;
+  GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD;
+  GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE;
+// GL_EXT_texture_compression_s3tc
+  GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
+  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
+// GL_EXT_texture_compression_s3tc_srgb
+  GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F;
+// GL_EXT_texture_cube_map_array
+  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
+  GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
+  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+// GL_EXT_texture_filter_minmax
+  GL_TEXTURE_REDUCTION_MODE_EXT = $9366;
+  GL_WEIGHTED_AVERAGE_EXT = $9367;
+// GL_EXT_texture_format_sRGB_override
+  GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT = $8FBF;
+// GL_EXT_texture_mirror_clamp_to_edge
+  GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743;
+// GL_EXT_texture_norm16
+  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
+  GL_RED_EXT = $1903;
+  GL_RG_EXT = $8227;
+  GL_R8_EXT = $8229;
+  GL_RG8_EXT = $822B;
+// GL_EXT_texture_sRGB_R8
+  GL_SR8_EXT = $8FBD;
+// GL_EXT_texture_sRGB_RG8
+  GL_SRG8_EXT = $8FBE;
+// GL_EXT_texture_sRGB_decode
+  GL_TEXTURE_SRGB_DECODE_EXT = $8A48;
+  GL_DECODE_EXT = $8A49;
+  GL_SKIP_DECODE_EXT = $8A4A;
+// GL_EXT_texture_storage
+  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;
+// GL_EXT_texture_storage_compression
+  GL_NUM_SURFACE_COMPRESSION_FIXED_RATES_EXT = $8F6E;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT = $96C4;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT = $96C5;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT = $96C6;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT = $96C7;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT = $96C8;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT = $96C9;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT = $96CA;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT = $96CB;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT = $96CC;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT = $96CD;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT = $96CE;
+  GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT = $96CF;
+// GL_EXT_texture_type_2_10_10_10_REV
+  GL_UNSIGNED_INT_2_10_10_10_REV_EXT = $8368;
+// GL_EXT_texture_view
+  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_EXT_unpack_subimage
+  GL_UNPACK_ROW_LENGTH_EXT = $0CF2;
+  GL_UNPACK_SKIP_ROWS_EXT = $0CF3;
+  GL_UNPACK_SKIP_PIXELS_EXT = $0CF4;
+// GL_EXT_window_rectangles
+  GL_INCLUSIVE_EXT = $8F10;
+  GL_EXCLUSIVE_EXT = $8F11;
+  GL_WINDOW_RECTANGLE_EXT = $8F12;
+  GL_WINDOW_RECTANGLE_MODE_EXT = $8F13;
+  GL_MAX_WINDOW_RECTANGLES_EXT = $8F14;
+  GL_NUM_WINDOW_RECTANGLES_EXT = $8F15;
+// GL_FJ_shader_binary_GCCSO
+  GL_GCCSO_SHADER_BINARY_FJ = $9260;
+// GL_IMG_framebuffer_downsample
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_AND_DOWNSAMPLE_IMG = $913C;
+  GL_NUM_DOWNSAMPLE_SCALES_IMG = $913D;
+  GL_DOWNSAMPLE_SCALES_IMG = $913E;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG = $913F;
+// GL_IMG_multisampled_render_to_texture
+  GL_RENDERBUFFER_SAMPLES_IMG = $9133;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG = $9134;
+  GL_MAX_SAMPLES_IMG = $9135;
+  GL_TEXTURE_SAMPLES_IMG = $9136;
+// GL_IMG_program_binary
+  GL_SGX_PROGRAM_BINARY_IMG = $9130;
+// GL_IMG_read_format
+  GL_BGRA_IMG = $80E1;
+  GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG = $8365;
+// GL_IMG_shader_binary
+  GL_SGX_BINARY_IMG = $8C0A;
+// GL_IMG_texture_compression_pvrtc
+  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
+  GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = $9137;
+  GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = $9138;
+// GL_IMG_texture_filter_cubic
+  GL_CUBIC_IMG = $9139;
+  GL_CUBIC_MIPMAP_NEAREST_IMG = $913A;
+  GL_CUBIC_MIPMAP_LINEAR_IMG = $913B;
+// GL_INTEL_blackhole_render
+  GL_BLACKHOLE_RENDER_INTEL = $83FC;
+// GL_INTEL_conservative_rasterization
+  GL_CONSERVATIVE_RASTERIZATION_INTEL = $83FE;
+// GL_INTEL_performance_query
+  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;
+// GL_MESA_bgra
+  GL_BGR_EXT = $80E0;
+// GL_MESA_framebuffer_flip_x
+  GL_FRAMEBUFFER_FLIP_X_MESA = $8BBC;
+// GL_MESA_framebuffer_flip_y
+  GL_FRAMEBUFFER_FLIP_Y_MESA = $8BBB;
+// GL_MESA_framebuffer_swap_xy
+  GL_FRAMEBUFFER_SWAP_XY_MESA = $8BBD;
+// GL_MESA_program_binary_formats
+  GL_PROGRAM_BINARY_FORMAT_MESA = $875F;
+// GL_NV_blend_equation_advanced
+  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;
+// GL_NV_blend_equation_advanced_coherent
+  GL_BLEND_ADVANCED_COHERENT_NV = $9285;
+// GL_NV_blend_minmax_factor
+  GL_FACTOR_MIN_AMD = $901C;
+  GL_FACTOR_MAX_AMD = $901D;
+// GL_NV_clip_space_w_scaling
+  GL_VIEWPORT_POSITION_W_SCALE_NV = $937C;
+  GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV = $937D;
+  GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV = $937E;
+// GL_NV_conditional_render
+  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;
+// GL_NV_conservative_raster
+  GL_CONSERVATIVE_RASTERIZATION_NV = $9346;
+  GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV = $9347;
+  GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = $9348;
+  GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = $9349;
+// GL_NV_conservative_raster_pre_snap
+  GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV = $9550;
+// GL_NV_conservative_raster_pre_snap_triangles
+  GL_CONSERVATIVE_RASTER_MODE_NV = $954D;
+  GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV = $954E;
+  GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV = $954F;
+// GL_NV_copy_buffer
+  GL_COPY_READ_BUFFER_NV = $8F36;
+  GL_COPY_WRITE_BUFFER_NV = $8F37;
+// GL_NV_coverage_sample
+  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;
+// GL_NV_depth_nonlinear
+  GL_DEPTH_COMPONENT16_NONLINEAR_NV = $8E2C;
+// GL_NV_draw_buffers
+  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;
+
+{$IfDef GL_NV_draw_vulkan_image}
+type
+  GLVULKANPROCNV = procedure(_para1:pointer);cdecl;
+{$EndIf}
+
+const
+// GL_NV_fbo_color_attachments
+  GL_MAX_COLOR_ATTACHMENTS_NV = $8CDF;
+// GL_NV_fence
+  GL_ALL_COMPLETED_NV = $84F2;
+  GL_FENCE_STATUS_NV = $84F3;
+  GL_FENCE_CONDITION_NV = $84F4;
+// GL_NV_fill_rectangle
+  GL_FILL_RECTANGLE_NV = $933C;
+// GL_NV_fragment_coverage_to_color
+  GL_FRAGMENT_COVERAGE_TO_COLOR_NV = $92DD;
+  GL_FRAGMENT_COVERAGE_COLOR_NV = $92DE;
+// GL_NV_framebuffer_blit
+  GL_READ_FRAMEBUFFER_NV = $8CA8;
+  GL_DRAW_FRAMEBUFFER_NV = $8CA9;
+  GL_DRAW_FRAMEBUFFER_BINDING_NV = $8CA6;
+  GL_READ_FRAMEBUFFER_BINDING_NV = $8CAA;
+// GL_NV_framebuffer_mixed_samples
+  GL_COVERAGE_MODULATION_TABLE_NV = $9331;
+  GL_COLOR_SAMPLES_NV = $8E20;
+  GL_DEPTH_SAMPLES_NV = $932D;
+  GL_STENCIL_SAMPLES_NV = $932E;
+  GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV = $932F;
+  GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV = $9330;
+  GL_COVERAGE_MODULATION_NV = $9332;
+  GL_COVERAGE_MODULATION_TABLE_SIZE_NV = $9333;
+// GL_NV_framebuffer_multisample
+  GL_RENDERBUFFER_SAMPLES_NV = $8CAB;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV = $8D56;
+  GL_MAX_SAMPLES_NV = $8D57;
+// GL_NV_gpu_shader5
+  GL_INT64_NV = $140E;
+  GL_UNSIGNED_INT64_NV = $140F;
+  GL_INT8_NV = $8FE0;
+  GL_INT8_VEC2_NV = $8FE1;
+  GL_INT8_VEC3_NV = $8FE2;
+  GL_INT8_VEC4_NV = $8FE3;
+  GL_INT16_NV = $8FE4;
+  GL_INT16_VEC2_NV = $8FE5;
+  GL_INT16_VEC3_NV = $8FE6;
+  GL_INT16_VEC4_NV = $8FE7;
+  GL_INT64_VEC2_NV = $8FE9;
+  GL_INT64_VEC3_NV = $8FEA;
+  GL_INT64_VEC4_NV = $8FEB;
+  GL_UNSIGNED_INT8_NV = $8FEC;
+  GL_UNSIGNED_INT8_VEC2_NV = $8FED;
+  GL_UNSIGNED_INT8_VEC3_NV = $8FEE;
+  GL_UNSIGNED_INT8_VEC4_NV = $8FEF;
+  GL_UNSIGNED_INT16_NV = $8FF0;
+  GL_UNSIGNED_INT16_VEC2_NV = $8FF1;
+  GL_UNSIGNED_INT16_VEC3_NV = $8FF2;
+  GL_UNSIGNED_INT16_VEC4_NV = $8FF3;
+  GL_UNSIGNED_INT64_VEC2_NV = $8FF5;
+  GL_UNSIGNED_INT64_VEC3_NV = $8FF6;
+  GL_UNSIGNED_INT64_VEC4_NV = $8FF7;
+  GL_FLOAT16_NV = $8FF8;
+  GL_FLOAT16_VEC2_NV = $8FF9;
+  GL_FLOAT16_VEC3_NV = $8FFA;
+  GL_FLOAT16_VEC4_NV = $8FFB;
+  GL_PATCHES = $000E;
+// GL_NV_instanced_arrays
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV = $88FE;
+// GL_NV_internalformat_sample_query
+  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;
+// GL_NV_memory_attachment
+  GL_ATTACHED_MEMORY_OBJECT_NV = $95A4;
+  GL_ATTACHED_MEMORY_OFFSET_NV = $95A5;
+  GL_MEMORY_ATTACHABLE_ALIGNMENT_NV = $95A6;
+  GL_MEMORY_ATTACHABLE_SIZE_NV = $95A7;
+  GL_MEMORY_ATTACHABLE_NV = $95A8;
+  GL_DETACHED_MEMORY_INCARNATION_NV = $95A9;
+  GL_DETACHED_TEXTURES_NV = $95AA;
+  GL_DETACHED_BUFFERS_NV = $95AB;
+  GL_MAX_DETACHED_TEXTURES_NV = $95AC;
+  GL_MAX_DETACHED_BUFFERS_NV = $95AD;
+// GL_NV_mesh_shader
+  GL_MESH_SHADER_NV = $9559;
+  GL_TASK_SHADER_NV = $955A;
+  GL_MAX_MESH_UNIFORM_BLOCKS_NV = $8E60;
+  GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV = $8E61;
+  GL_MAX_MESH_IMAGE_UNIFORMS_NV = $8E62;
+  GL_MAX_MESH_UNIFORM_COMPONENTS_NV = $8E63;
+  GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV = $8E64;
+  GL_MAX_MESH_ATOMIC_COUNTERS_NV = $8E65;
+  GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV = $8E66;
+  GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV = $8E67;
+  GL_MAX_TASK_UNIFORM_BLOCKS_NV = $8E68;
+  GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV = $8E69;
+  GL_MAX_TASK_IMAGE_UNIFORMS_NV = $8E6A;
+  GL_MAX_TASK_UNIFORM_COMPONENTS_NV = $8E6B;
+  GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV = $8E6C;
+  GL_MAX_TASK_ATOMIC_COUNTERS_NV = $8E6D;
+  GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV = $8E6E;
+  GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV = $8E6F;
+  GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV = $95A2;
+  GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV = $95A3;
+  GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV = $9536;
+  GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV = $9537;
+  GL_MAX_MESH_OUTPUT_VERTICES_NV = $9538;
+  GL_MAX_MESH_OUTPUT_PRIMITIVES_NV = $9539;
+  GL_MAX_TASK_OUTPUT_COUNT_NV = $953A;
+  GL_MAX_DRAW_MESH_TASKS_COUNT_NV = $953D;
+  GL_MAX_MESH_VIEWS_NV = $9557;
+  GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV = $92DF;
+  GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV = $9543;
+  GL_MAX_MESH_WORK_GROUP_SIZE_NV = $953B;
+  GL_MAX_TASK_WORK_GROUP_SIZE_NV = $953C;
+  GL_MESH_WORK_GROUP_SIZE_NV = $953E;
+  GL_TASK_WORK_GROUP_SIZE_NV = $953F;
+  GL_MESH_VERTICES_OUT_NV = $9579;
+  GL_MESH_PRIMITIVES_OUT_NV = $957A;
+  GL_MESH_OUTPUT_TYPE_NV = $957B;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV = $959C;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV = $959D;
+  GL_REFERENCED_BY_MESH_SHADER_NV = $95A0;
+  GL_REFERENCED_BY_TASK_SHADER_NV = $95A1;
+  GL_MESH_SHADER_BIT_NV = $00000040;
+  GL_TASK_SHADER_BIT_NV = $00000080;
+  GL_MESH_SUBROUTINE_NV = $957C;
+  GL_TASK_SUBROUTINE_NV = $957D;
+  GL_MESH_SUBROUTINE_UNIFORM_NV = $957E;
+  GL_TASK_SUBROUTINE_UNIFORM_NV = $957F;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV = $959E;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV = $959F;
+// GL_NV_non_square_matrices
+  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;
+// GL_NV_pack_subimage
+  GL_PACK_ROW_LENGTH_NV = $0D02;
+  GL_PACK_SKIP_ROWS_NV = $0D03;
+  GL_PACK_SKIP_PIXELS_NV = $0D04;
+// GL_NV_path_rendering
+  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;
+// GL_NV_path_rendering_shared_edge
+  GL_SHARED_EDGE_NV = $C0;
+// GL_NV_pixel_buffer_object
+  GL_PIXEL_PACK_BUFFER_NV = $88EB;
+  GL_PIXEL_UNPACK_BUFFER_NV = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING_NV = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING_NV = $88EF;
+// GL_NV_polygon_mode
+  GL_POLYGON_MODE_NV = $0B40;
+  GL_POLYGON_OFFSET_POINT_NV = $2A01;
+  GL_POLYGON_OFFSET_LINE_NV = $2A02;
+  GL_POINT_NV = $1B00;
+  GL_LINE_NV = $1B01;
+  GL_FILL_NV = $1B02;
+// GL_NV_primitive_shading_rate
+  GL_SHADING_RATE_IMAGE_PER_PRIMITIVE_NV = $95B1;
+  GL_SHADING_RATE_IMAGE_PALETTE_COUNT_NV = $95B2;
+// GL_NV_read_buffer
+  GL_READ_BUFFER_NV = $0C02;
+// GL_NV_representative_fragment_test
+  GL_REPRESENTATIVE_FRAGMENT_TEST_NV = $937F;
+// GL_NV_sRGB_formats
+  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_sample_locations
+  GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV = $933D;
+  GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV = $933E;
+  GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV = $933F;
+  GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV = $9340;
+  GL_SAMPLE_LOCATION_NV = $8E50;
+  GL_PROGRAMMABLE_SAMPLE_LOCATION_NV = $9341;
+  GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV = $9342;
+  GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV = $9343;
+// GL_NV_scissor_exclusive
+  GL_SCISSOR_TEST_EXCLUSIVE_NV = $9555;
+  GL_SCISSOR_BOX_EXCLUSIVE_NV = $9556;
+// GL_NV_shader_subgroup_partitioned
+  GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = $00000100;
+// GL_NV_shading_rate_image
+  GL_SHADING_RATE_IMAGE_NV = $9563;
+  GL_SHADING_RATE_NO_INVOCATIONS_NV = $9564;
+  GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = $9565;
+  GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = $9566;
+  GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = $9567;
+  GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = $9568;
+  GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = $9569;
+  GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = $956A;
+  GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = $956B;
+  GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = $956C;
+  GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = $956D;
+  GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = $956E;
+  GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = $956F;
+  GL_SHADING_RATE_IMAGE_BINDING_NV = $955B;
+  GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV = $955C;
+  GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV = $955D;
+  GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV = $955E;
+  GL_MAX_COARSE_FRAGMENT_SAMPLES_NV = $955F;
+  GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV = $95AE;
+  GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV = $95AF;
+  GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV = $95B0;
+// GL_NV_shadow_samplers_array
+  GL_SAMPLER_2D_ARRAY_SHADOW_NV = $8DC4;
+// GL_NV_shadow_samplers_cube
+  GL_SAMPLER_CUBE_SHADOW_NV = $8DC5;
+// GL_NV_texture_border_clamp
+  GL_TEXTURE_BORDER_COLOR_NV = $1004;
+  GL_CLAMP_TO_BORDER_NV = $812D;
+// GL_NV_timeline_semaphore
+  GL_TIMELINE_SEMAPHORE_VALUE_NV = $9595;
+  GL_SEMAPHORE_TYPE_NV = $95B3;
+  GL_SEMAPHORE_TYPE_BINARY_NV = $95B4;
+  GL_SEMAPHORE_TYPE_TIMELINE_NV = $95B5;
+  GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV = $95B6;
+// GL_NV_viewport_array
+  GL_MAX_VIEWPORTS_NV = $825B;
+  GL_VIEWPORT_SUBPIXEL_BITS_NV = $825C;
+  GL_VIEWPORT_BOUNDS_RANGE_NV = $825D;
+  GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV = $825F;
+// GL_NV_viewport_swizzle
+  GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV = $9350;
+  GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV = $9351;
+  GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV = $9352;
+  GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = $9353;
+  GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV = $9354;
+  GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = $9355;
+  GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV = $9356;
+  GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV = $9357;
+  GL_VIEWPORT_SWIZZLE_X_NV = $9358;
+  GL_VIEWPORT_SWIZZLE_Y_NV = $9359;
+  GL_VIEWPORT_SWIZZLE_Z_NV = $935A;
+  GL_VIEWPORT_SWIZZLE_W_NV = $935B;
+// GL_OVR_multiview
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = $9630;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = $9632;
+  GL_MAX_VIEWS_OVR = $9631;
+  GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = $9633;
+// GL_QCOM_alpha_test
+  GL_ALPHA_TEST_QCOM = $0BC0;
+  GL_ALPHA_TEST_FUNC_QCOM = $0BC1;
+  GL_ALPHA_TEST_REF_QCOM = $0BC2;
+// GL_QCOM_binning_control
+  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_extended_get
+  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;
+// GL_QCOM_framebuffer_foveated
+  GL_FOVEATION_ENABLE_BIT_QCOM = $00000001;
+  GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM = $00000002;
+// GL_QCOM_motion_estimation
+  GL_MOTION_ESTIMATION_SEARCH_BLOCK_X_QCOM = $8C90;
+  GL_MOTION_ESTIMATION_SEARCH_BLOCK_Y_QCOM = $8C91;
+// GL_QCOM_perfmon_global_mode
+  GL_PERFMON_GLOBAL_MODE_QCOM = $8FA0;
+// GL_QCOM_shader_framebuffer_fetch_noncoherent
+  GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM = $96A2;
+// GL_QCOM_shading_rate
+  GL_SHADING_RATE_QCOM = $96A4;
+  GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM = $96A5;
+  GL_SHADING_RATE_1X1_PIXELS_QCOM = $96A6;
+  GL_SHADING_RATE_1X2_PIXELS_QCOM = $96A7;
+  GL_SHADING_RATE_2X1_PIXELS_QCOM = $96A8;
+  GL_SHADING_RATE_2X2_PIXELS_QCOM = $96A9;
+  GL_SHADING_RATE_4X2_PIXELS_QCOM = $96AC;
+  GL_SHADING_RATE_4X4_PIXELS_QCOM = $96AE;
+// GL_QCOM_texture_foveated
+  GL_TEXTURE_FOVEATED_FEATURE_BITS_QCOM = $8BFB;
+  GL_TEXTURE_FOVEATED_MIN_PIXEL_DENSITY_QCOM = $8BFC;
+  GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM = $8BFD;
+  GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM = $8BFE;
+  GL_FRAMEBUFFER_INCOMPLETE_FOVEATION_QCOM = $8BFF;
+// GL_QCOM_texture_foveated2
+  GL_TEXTURE_FOVEATED_CUTOFF_DENSITY_QCOM = $96A0;
+// GL_QCOM_texture_foveated_subsampled_layout
+  GL_FOVEATION_SUBSAMPLED_LAYOUT_METHOD_BIT_QCOM = $00000004;
+  GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM = $8FA1;
+// GL_QCOM_tiled_rendering
+  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;
+// GL_QCOM_writeonly_rendering
+  GL_WRITEONLY_RENDERING_QCOM = $8823;
+// GL_VIV_shader_binary
+  GL_SHADER_BINARY_VIV = $8FC4;
+(*******************************************************************************
+*                            GL_ES_VERSION_2_0                                 *
+*******************************************************************************)
+
+(*******************************************************************************
+*                            GL_ES_VERSION_3_0                                 *
+*******************************************************************************)
+  GL_READ_BUFFER = $0C02;
+  GL_UNPACK_ROW_LENGTH = $0CF2;
+  GL_UNPACK_SKIP_ROWS = $0CF3;
+  GL_UNPACK_SKIP_PIXELS = $0CF4;
+  GL_PACK_ROW_LENGTH = $0D02;
+  GL_PACK_SKIP_ROWS = $0D03;
+  GL_PACK_SKIP_PIXELS = $0D04;
+  GL_COLOR = $1800;
+  GL_DEPTH = $1801;
+  GL_STENCIL = $1802;
+  GL_RED = $1903;
+  GL_RGB8 = $8051;
+  GL_RGBA8 = $8058;
+  GL_RGB10_A2 = $8059;
+  GL_TEXTURE_BINDING_3D = $806A;
+  GL_UNPACK_SKIP_IMAGES = $806D;
+  GL_UNPACK_IMAGE_HEIGHT = $806E;
+//  GL_TEXTURE_3D = $806F;
+  GL_TEXTURE_WRAP_R = $8072;
+  GL_MAX_3D_TEXTURE_SIZE = $8073;
+  GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
+  GL_MAX_ELEMENTS_VERTICES = $80E8;
+  GL_MAX_ELEMENTS_INDICES = $80E9;
+  GL_TEXTURE_MIN_LOD = $813A;
+  GL_TEXTURE_MAX_LOD = $813B;
+  GL_TEXTURE_BASE_LEVEL = $813C;
+  GL_TEXTURE_MAX_LEVEL = $813D;
+//  GL_MIN = $8007;
+//  GL_MAX = $8008;
+  GL_DEPTH_COMPONENT24 = $81A6;
+  GL_MAX_TEXTURE_LOD_BIAS = $84FD;
+  GL_TEXTURE_COMPARE_MODE = $884C;
+  GL_TEXTURE_COMPARE_FUNC = $884D;
+  GL_CURRENT_QUERY = $8865;
+  GL_QUERY_RESULT = $8866;
+  GL_QUERY_RESULT_AVAILABLE = $8867;
+  GL_BUFFER_MAPPED = $88BC;
+  GL_BUFFER_MAP_POINTER = $88BD;
+  GL_STREAM_READ = $88E1;
+  GL_STREAM_COPY = $88E2;
+  GL_STATIC_READ = $88E5;
+  GL_STATIC_COPY = $88E6;
+  GL_DYNAMIC_READ = $88E9;
+  GL_DYNAMIC_COPY = $88EA;
+  GL_MAX_DRAW_BUFFERS = $8824;
+  GL_DRAW_BUFFER0 = $8825;
+  GL_DRAW_BUFFER1 = $8826;
+  GL_DRAW_BUFFER2 = $8827;
+  GL_DRAW_BUFFER3 = $8828;
+  GL_DRAW_BUFFER4 = $8829;
+  GL_DRAW_BUFFER5 = $882A;
+  GL_DRAW_BUFFER6 = $882B;
+  GL_DRAW_BUFFER7 = $882C;
+  GL_DRAW_BUFFER8 = $882D;
+  GL_DRAW_BUFFER9 = $882E;
+  GL_DRAW_BUFFER10 = $882F;
+  GL_DRAW_BUFFER11 = $8830;
+  GL_DRAW_BUFFER12 = $8831;
+  GL_DRAW_BUFFER13 = $8832;
+  GL_DRAW_BUFFER14 = $8833;
+  GL_DRAW_BUFFER15 = $8834;
+  GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;
+  GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;
+  GL_SAMPLER_3D = $8B5F;
+  GL_SAMPLER_2D_SHADOW = $8B62;
+  GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;
+  GL_PIXEL_PACK_BUFFER = $88EB;
+  GL_PIXEL_UNPACK_BUFFER = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF;
+  GL_FLOAT_MAT2x3 = $8B65;
+  GL_FLOAT_MAT2x4 = $8B66;
+  GL_FLOAT_MAT3x2 = $8B67;
+  GL_FLOAT_MAT3x4 = $8B68;
+  GL_FLOAT_MAT4x2 = $8B69;
+  GL_FLOAT_MAT4x3 = $8B6A;
+  GL_SRGB = $8C40;
+  GL_SRGB8 = $8C41;
+  GL_SRGB8_ALPHA8 = $8C43;
+  GL_COMPARE_REF_TO_TEXTURE = $884E;
+  GL_MAJOR_VERSION = $821B;
+  GL_MINOR_VERSION = $821C;
+  GL_NUM_EXTENSIONS = $821D;
+  GL_RGBA32F = $8814;
+  GL_RGB32F = $8815;
+  GL_RGBA16F = $881A;
+  GL_RGB16F = $881B;
+  GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD;
+  GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF;
+  GL_MIN_PROGRAM_TEXEL_OFFSET = $8904;
+  GL_MAX_PROGRAM_TEXEL_OFFSET = $8905;
+  GL_MAX_VARYING_COMPONENTS = $8B4B;
+//  GL_TEXTURE_2D_ARRAY = $8C1A;
+  GL_TEXTURE_BINDING_2D_ARRAY = $8C1D;
+  GL_R11F_G11F_B10F = $8C3A;
+  GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B;
+  GL_RGB9_E5 = $8C3D;
+  GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E;
+  GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76;
+  GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80;
+  GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83;
+  GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84;
+  GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85;
+  GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88;
+  GL_RASTERIZER_DISCARD = $8C89;
+  GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B;
+  GL_INTERLEAVED_ATTRIBS = $8C8C;
+  GL_SEPARATE_ATTRIBS = $8C8D;
+  GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E;
+  GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F;
+  GL_RGBA32UI = $8D70;
+  GL_RGB32UI = $8D71;
+  GL_RGBA16UI = $8D76;
+  GL_RGB16UI = $8D77;
+  GL_RGBA8UI = $8D7C;
+  GL_RGB8UI = $8D7D;
+  GL_RGBA32I = $8D82;
+  GL_RGB32I = $8D83;
+  GL_RGBA16I = $8D88;
+  GL_RGB16I = $8D89;
+  GL_RGBA8I = $8D8E;
+  GL_RGB8I = $8D8F;
+  GL_RED_INTEGER = $8D94;
+  GL_RGB_INTEGER = $8D98;
+  GL_RGBA_INTEGER = $8D99;
+  GL_SAMPLER_2D_ARRAY = $8DC1;
+  GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4;
+  GL_SAMPLER_CUBE_SHADOW = $8DC5;
+  GL_UNSIGNED_INT_VEC2 = $8DC6;
+  GL_UNSIGNED_INT_VEC3 = $8DC7;
+  GL_UNSIGNED_INT_VEC4 = $8DC8;
+  GL_INT_SAMPLER_2D = $8DCA;
+  GL_INT_SAMPLER_3D = $8DCB;
+  GL_INT_SAMPLER_CUBE = $8DCC;
+  GL_INT_SAMPLER_2D_ARRAY = $8DCF;
+  GL_UNSIGNED_INT_SAMPLER_2D = $8DD2;
+  GL_UNSIGNED_INT_SAMPLER_3D = $8DD3;
+  GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4;
+  GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7;
+  GL_BUFFER_ACCESS_FLAGS = $911F;
+  GL_BUFFER_MAP_LENGTH = $9120;
+  GL_BUFFER_MAP_OFFSET = $9121;
+  GL_DEPTH_COMPONENT32F = $8CAC;
+  GL_DEPTH32F_STENCIL8 = $8CAD;
+  GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD;
+  GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210;
+  GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211;
+  GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212;
+  GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213;
+  GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214;
+  GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215;
+  GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216;
+  GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217;
+  GL_FRAMEBUFFER_DEFAULT = $8218;
+  GL_FRAMEBUFFER_UNDEFINED = $8219;
+  GL_DEPTH_STENCIL_ATTACHMENT = $821A;
+  GL_DEPTH_STENCIL = $84F9;
+  GL_UNSIGNED_INT_24_8 = $84FA;
+  GL_DEPTH24_STENCIL8 = $88F0;
+  GL_UNSIGNED_NORMALIZED = $8C17;
+  GL_DRAW_FRAMEBUFFER_BINDING = $8CA6;
+  GL_READ_FRAMEBUFFER = $8CA8;
+  GL_DRAW_FRAMEBUFFER = $8CA9;
+  GL_READ_FRAMEBUFFER_BINDING = $8CAA;
+  GL_RENDERBUFFER_SAMPLES = $8CAB;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4;
+  GL_MAX_COLOR_ATTACHMENTS = $8CDF;
+  GL_COLOR_ATTACHMENT1 = $8CE1;
+  GL_COLOR_ATTACHMENT2 = $8CE2;
+  GL_COLOR_ATTACHMENT3 = $8CE3;
+  GL_COLOR_ATTACHMENT4 = $8CE4;
+  GL_COLOR_ATTACHMENT5 = $8CE5;
+  GL_COLOR_ATTACHMENT6 = $8CE6;
+  GL_COLOR_ATTACHMENT7 = $8CE7;
+  GL_COLOR_ATTACHMENT8 = $8CE8;
+  GL_COLOR_ATTACHMENT9 = $8CE9;
+  GL_COLOR_ATTACHMENT10 = $8CEA;
+  GL_COLOR_ATTACHMENT11 = $8CEB;
+  GL_COLOR_ATTACHMENT12 = $8CEC;
+  GL_COLOR_ATTACHMENT13 = $8CED;
+  GL_COLOR_ATTACHMENT14 = $8CEE;
+  GL_COLOR_ATTACHMENT15 = $8CEF;
+  GL_COLOR_ATTACHMENT16 = $8CF0;
+  GL_COLOR_ATTACHMENT17 = $8CF1;
+  GL_COLOR_ATTACHMENT18 = $8CF2;
+  GL_COLOR_ATTACHMENT19 = $8CF3;
+  GL_COLOR_ATTACHMENT20 = $8CF4;
+  GL_COLOR_ATTACHMENT21 = $8CF5;
+  GL_COLOR_ATTACHMENT22 = $8CF6;
+  GL_COLOR_ATTACHMENT23 = $8CF7;
+  GL_COLOR_ATTACHMENT24 = $8CF8;
+  GL_COLOR_ATTACHMENT25 = $8CF9;
+  GL_COLOR_ATTACHMENT26 = $8CFA;
+  GL_COLOR_ATTACHMENT27 = $8CFB;
+  GL_COLOR_ATTACHMENT28 = $8CFC;
+  GL_COLOR_ATTACHMENT29 = $8CFD;
+  GL_COLOR_ATTACHMENT30 = $8CFE;
+  GL_COLOR_ATTACHMENT31 = $8CFF;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56;
+  GL_MAX_SAMPLES = $8D57;
+  GL_HALF_FLOAT = $140B;
+//  GL_MAP_READ_BIT = $0001;
+//  GL_MAP_WRITE_BIT = $0002;
+  GL_MAP_INVALIDATE_RANGE_BIT = $0004;
+  GL_MAP_INVALIDATE_BUFFER_BIT = $0008;
+  GL_MAP_FLUSH_EXPLICIT_BIT = $0010;
+  GL_MAP_UNSYNCHRONIZED_BIT = $0020;
+  GL_RG = $8227;
+  GL_RG_INTEGER = $8228;
+  GL_R8 = $8229;
+  GL_RG8 = $822B;
+  GL_R16F = $822D;
+  GL_R32F = $822E;
+  GL_RG16F = $822F;
+  GL_RG32F = $8230;
+  GL_R8I = $8231;
+  GL_R8UI = $8232;
+  GL_R16I = $8233;
+  GL_R16UI = $8234;
+  GL_R32I = $8235;
+  GL_R32UI = $8236;
+  GL_RG8I = $8237;
+  GL_RG8UI = $8238;
+  GL_RG16I = $8239;
+  GL_RG16UI = $823A;
+  GL_RG32I = $823B;
+  GL_RG32UI = $823C;
+  GL_VERTEX_ARRAY_BINDING = $85B5;
+//  GL_R8_SNORM = $8F94;
+//  GL_RG8_SNORM = $8F95;
+  GL_RGB8_SNORM = $8F96;
+//  GL_RGBA8_SNORM = $8F97;
+  GL_SIGNED_NORMALIZED = $8F9C;
+  GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69;
+  GL_COPY_READ_BUFFER = $8F36;
+  GL_COPY_WRITE_BUFFER = $8F37;
+  GL_COPY_READ_BUFFER_BINDING = $8F36;
+  GL_COPY_WRITE_BUFFER_BINDING = $8F37;
+  GL_UNIFORM_BUFFER = $8A11;
+  GL_UNIFORM_BUFFER_BINDING = $8A28;
+  GL_UNIFORM_BUFFER_START = $8A29;
+  GL_UNIFORM_BUFFER_SIZE = $8A2A;
+  GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B;
+  GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D;
+  GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E;
+  GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F;
+  GL_MAX_UNIFORM_BLOCK_SIZE = $8A30;
+  GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31;
+  GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33;
+  GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34;
+  GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35;
+  GL_ACTIVE_UNIFORM_BLOCKS = $8A36;
+  GL_UNIFORM_TYPE = $8A37;
+  GL_UNIFORM_SIZE = $8A38;
+  GL_UNIFORM_NAME_LENGTH = $8A39;
+  GL_UNIFORM_BLOCK_INDEX = $8A3A;
+  GL_UNIFORM_OFFSET = $8A3B;
+  GL_UNIFORM_ARRAY_STRIDE = $8A3C;
+  GL_UNIFORM_MATRIX_STRIDE = $8A3D;
+  GL_UNIFORM_IS_ROW_MAJOR = $8A3E;
+  GL_UNIFORM_BLOCK_BINDING = $8A3F;
+  GL_UNIFORM_BLOCK_DATA_SIZE = $8A40;
+  GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41;
+  GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42;
+  GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46;
+  GL_INVALID_INDEX = $FFFFFFFF;
+  GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122;
+  GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125;
+  GL_MAX_SERVER_WAIT_TIMEOUT = $9111;
+  GL_OBJECT_TYPE = $9112;
+  GL_SYNC_CONDITION = $9113;
+  GL_SYNC_STATUS = $9114;
+  GL_SYNC_FLAGS = $9115;
+  GL_SYNC_FENCE = $9116;
+  GL_SYNC_GPU_COMMANDS_COMPLETE = $9117;
+  GL_UNSIGNALED = $9118;
+  GL_SIGNALED = $9119;
+  GL_ALREADY_SIGNALED = $911A;
+  GL_TIMEOUT_EXPIRED = $911B;
+  GL_CONDITION_SATISFIED = $911C;
+  GL_WAIT_FAILED = $911D;
+  GL_SYNC_FLUSH_COMMANDS_BIT = $00000001;
+  GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF;
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE;
+  GL_ANY_SAMPLES_PASSED = $8C2F;
+  GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A;
+  GL_SAMPLER_BINDING = $8919;
+  GL_RGB10_A2UI = $906F;
+  GL_TEXTURE_SWIZZLE_R = $8E42;
+  GL_TEXTURE_SWIZZLE_G = $8E43;
+  GL_TEXTURE_SWIZZLE_B = $8E44;
+  GL_TEXTURE_SWIZZLE_A = $8E45;
+  GL_GREEN = $1904;
+  GL_BLUE = $1905;
+  GL_INT_2_10_10_10_REV = $8D9F;
+//  GL_TRANSFORM_FEEDBACK = $8E22;
+  GL_TRANSFORM_FEEDBACK_PAUSED = $8E23;
+  GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24;
+  GL_TRANSFORM_FEEDBACK_BINDING = $8E25;
+  GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257;
+  GL_PROGRAM_BINARY_LENGTH = $8741;
+  GL_NUM_PROGRAM_BINARY_FORMATS = $87FE;
+  GL_PROGRAM_BINARY_FORMATS = $87FF;
+  GL_COMPRESSED_R11_EAC = $9270;
+  GL_COMPRESSED_SIGNED_R11_EAC = $9271;
+  GL_COMPRESSED_RG11_EAC = $9272;
+  GL_COMPRESSED_SIGNED_RG11_EAC = $9273;
+  GL_COMPRESSED_RGB8_ETC2 = $9274;
+  GL_COMPRESSED_SRGB8_ETC2 = $9275;
+  GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276;
+  GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277;
+  GL_COMPRESSED_RGBA8_ETC2_EAC = $9278;
+  GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279;
+  GL_TEXTURE_IMMUTABLE_FORMAT = $912F;
+  GL_MAX_ELEMENT_INDEX = $8D6B;
+  GL_NUM_SAMPLE_COUNTS = $9380;
+//  GL_TEXTURE_IMMUTABLE_LEVELS = $82DF;
+(*******************************************************************************
+*                            GL_ES_VERSION_3_0                                 *
+*******************************************************************************)
+
+(*******************************************************************************
+*                            GL_ES_VERSION_3_1                                 *
+*******************************************************************************)
+  GL_COMPUTE_SHADER = $91B9;
+  GL_MAX_COMPUTE_UNIFORM_BLOCKS = $91BB;
+  GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC;
+  GL_MAX_COMPUTE_IMAGE_UNIFORMS = $91BD;
+  GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262;
+  GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263;
+  GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264;
+  GL_MAX_COMPUTE_ATOMIC_COUNTERS = $8265;
+  GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266;
+  GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = $90EB;
+  GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE;
+  GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF;
+  GL_COMPUTE_WORK_GROUP_SIZE = $8267;
+  GL_DISPATCH_INDIRECT_BUFFER = $90EE;
+  GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF;
+  GL_COMPUTE_SHADER_BIT = $00000020;
+  GL_DRAW_INDIRECT_BUFFER = $8F3F;
+  GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43;
+  GL_MAX_UNIFORM_LOCATIONS = $826E;
+  GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310;
+  GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311;
+  GL_FRAMEBUFFER_DEFAULT_SAMPLES = $9313;
+  GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314;
+  GL_MAX_FRAMEBUFFER_WIDTH = $9315;
+  GL_MAX_FRAMEBUFFER_HEIGHT = $9316;
+  GL_MAX_FRAMEBUFFER_SAMPLES = $9318;
+  GL_UNIFORM = $92E1;
+  GL_UNIFORM_BLOCK = $92E2;
+  GL_PROGRAM_INPUT = $92E3;
+  GL_PROGRAM_OUTPUT = $92E4;
+  GL_BUFFER_VARIABLE = $92E5;
+  GL_SHADER_STORAGE_BLOCK = $92E6;
+  GL_ATOMIC_COUNTER_BUFFER = $92C0;
+  GL_TRANSFORM_FEEDBACK_VARYING = $92F4;
+  GL_ACTIVE_RESOURCES = $92F5;
+  GL_MAX_NAME_LENGTH = $92F6;
+  GL_MAX_NUM_ACTIVE_VARIABLES = $92F7;
+  GL_NAME_LENGTH = $92F9;
+  GL_TYPE = $92FA;
+  GL_ARRAY_SIZE = $92FB;
+  GL_OFFSET = $92FC;
+  GL_BLOCK_INDEX = $92FD;
+  GL_ARRAY_STRIDE = $92FE;
+  GL_MATRIX_STRIDE = $92FF;
+  GL_IS_ROW_MAJOR = $9300;
+  GL_ATOMIC_COUNTER_BUFFER_INDEX = $9301;
+  GL_BUFFER_BINDING = $9302;
+  GL_BUFFER_DATA_SIZE = $9303;
+  GL_NUM_ACTIVE_VARIABLES = $9304;
+  GL_ACTIVE_VARIABLES = $9305;
+  GL_REFERENCED_BY_VERTEX_SHADER = $9306;
+  GL_REFERENCED_BY_FRAGMENT_SHADER = $930A;
+  GL_REFERENCED_BY_COMPUTE_SHADER = $930B;
+  GL_TOP_LEVEL_ARRAY_SIZE = $930C;
+  GL_TOP_LEVEL_ARRAY_STRIDE = $930D;
+  GL_LOCATION = $930E;
+  GL_VERTEX_SHADER_BIT = $00000001;
+  GL_FRAGMENT_SHADER_BIT = $00000002;
+  GL_ALL_SHADER_BITS = $FFFFFFFF;
+  GL_PROGRAM_SEPARABLE = $8258;
+  GL_ACTIVE_PROGRAM = $8259;
+  GL_PROGRAM_PIPELINE_BINDING = $825A;
+  GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1;
+  GL_ATOMIC_COUNTER_BUFFER_START = $92C2;
+  GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3;
+  GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC;
+  GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0;
+  GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1;
+  GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2;
+  GL_MAX_FRAGMENT_ATOMIC_COUNTERS = $92D6;
+  GL_MAX_COMBINED_ATOMIC_COUNTERS = $92D7;
+  GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8;
+  GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC;
+  GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = $92D9;
+  GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB;
+  GL_MAX_IMAGE_UNITS = $8F38;
+  GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA;
+  GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE;
+  GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF;
+  GL_IMAGE_BINDING_NAME = $8F3A;
+  GL_IMAGE_BINDING_LEVEL = $8F3B;
+  GL_IMAGE_BINDING_LAYERED = $8F3C;
+  GL_IMAGE_BINDING_LAYER = $8F3D;
+  GL_IMAGE_BINDING_ACCESS = $8F3E;
+  GL_IMAGE_BINDING_FORMAT = $906E;
+  GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001;
+  GL_ELEMENT_ARRAY_BARRIER_BIT = $00000002;
+  GL_UNIFORM_BARRIER_BIT = $00000004;
+  GL_TEXTURE_FETCH_BARRIER_BIT = $00000008;
+  GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020;
+  GL_COMMAND_BARRIER_BIT = $00000040;
+  GL_PIXEL_BUFFER_BARRIER_BIT = $00000080;
+  GL_TEXTURE_UPDATE_BARRIER_BIT = $00000100;
+  GL_BUFFER_UPDATE_BARRIER_BIT = $00000200;
+  GL_FRAMEBUFFER_BARRIER_BIT = $00000400;
+  GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800;
+  GL_ATOMIC_COUNTER_BARRIER_BIT = $00001000;
+  GL_ALL_BARRIER_BITS = $FFFFFFFF;
+  GL_IMAGE_2D = $904D;
+  GL_IMAGE_3D = $904E;
+  GL_IMAGE_CUBE = $9050;
+  GL_IMAGE_2D_ARRAY = $9053;
+  GL_INT_IMAGE_2D = $9058;
+  GL_INT_IMAGE_3D = $9059;
+  GL_INT_IMAGE_CUBE = $905B;
+  GL_INT_IMAGE_2D_ARRAY = $905E;
+  GL_UNSIGNED_INT_IMAGE_2D = $9063;
+  GL_UNSIGNED_INT_IMAGE_3D = $9064;
+  GL_UNSIGNED_INT_IMAGE_CUBE = $9066;
+  GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069;
+  GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7;
+  GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8;
+  GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9;
+  GL_READ_ONLY = $88B8;
+  GL_WRITE_ONLY = $88B9;
+  GL_READ_WRITE = $88BA;
+  GL_SHADER_STORAGE_BUFFER = $90D2;
+  GL_SHADER_STORAGE_BUFFER_BINDING = $90D3;
+  GL_SHADER_STORAGE_BUFFER_START = $90D4;
+  GL_SHADER_STORAGE_BUFFER_SIZE = $90D5;
+  GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6;
+  GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA;
+  GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB;
+  GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC;
+  GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD;
+  GL_MAX_SHADER_STORAGE_BLOCK_SIZE = $90DE;
+  GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF;
+  GL_SHADER_STORAGE_BARRIER_BIT = $00002000;
+  GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = $8F39;
+  GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA;
+  GL_STENCIL_INDEX = $1901;
+  GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E;
+  GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F;
+  GL_SAMPLE_POSITION = $8E50;
+  GL_SAMPLE_MASK = $8E51;
+  GL_SAMPLE_MASK_VALUE = $8E52;
+//  GL_TEXTURE_2D_MULTISAMPLE = $9100;
+  GL_MAX_SAMPLE_MASK_WORDS = $8E59;
+  GL_MAX_COLOR_TEXTURE_SAMPLES = $910E;
+  GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F;
+  GL_MAX_INTEGER_SAMPLES = $9110;
+  GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104;
+  GL_TEXTURE_SAMPLES = $9106;
+  GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107;
+  GL_TEXTURE_WIDTH = $1000;
+  GL_TEXTURE_HEIGHT = $1001;
+  GL_TEXTURE_DEPTH = $8071;
+  GL_TEXTURE_INTERNAL_FORMAT = $1003;
+  GL_TEXTURE_RED_SIZE = $805C;
+  GL_TEXTURE_GREEN_SIZE = $805D;
+  GL_TEXTURE_BLUE_SIZE = $805E;
+  GL_TEXTURE_ALPHA_SIZE = $805F;
+  GL_TEXTURE_DEPTH_SIZE = $884A;
+  GL_TEXTURE_STENCIL_SIZE = $88F1;
+  GL_TEXTURE_SHARED_SIZE = $8C3F;
+  GL_TEXTURE_RED_TYPE = $8C10;
+  GL_TEXTURE_GREEN_TYPE = $8C11;
+  GL_TEXTURE_BLUE_TYPE = $8C12;
+  GL_TEXTURE_ALPHA_TYPE = $8C13;
+  GL_TEXTURE_DEPTH_TYPE = $8C16;
+  GL_TEXTURE_COMPRESSED = $86A1;
+  GL_SAMPLER_2D_MULTISAMPLE = $9108;
+  GL_INT_SAMPLER_2D_MULTISAMPLE = $9109;
+  GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A;
+  GL_VERTEX_ATTRIB_BINDING = $82D4;
+  GL_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D5;
+  GL_VERTEX_BINDING_DIVISOR = $82D6;
+  GL_VERTEX_BINDING_OFFSET = $82D7;
+  GL_VERTEX_BINDING_STRIDE = $82D8;
+  GL_VERTEX_BINDING_BUFFER = $8F4F;
+  GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9;
+  GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA;
+  GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5;
+(*******************************************************************************
+*                            GL_ES_VERSION_3_1                                 *
+*******************************************************************************)
+
+(*******************************************************************************
+*                            GL_ES_VERSION_3_2                                 *
+*******************************************************************************)
+type
+  GLDEBUGPROC = procedure(source:GLenum; _type:GLenum; id:GLuint; severity:GLenum; length:GLsizei;
+                  message:PGLchar; userParam:pointer); stdcall;
+
+const
+  GL_MULTISAMPLE_LINE_WIDTH_RANGE = $9381;
+  GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY = $9382;
+  GL_MULTIPLY = $9294;
+  GL_SCREEN = $9295;
+  GL_OVERLAY = $9296;
+  GL_DARKEN = $9297;
+  GL_LIGHTEN = $9298;
+  GL_COLORDODGE = $9299;
+  GL_COLORBURN = $929A;
+  GL_HARDLIGHT = $929B;
+  GL_SOFTLIGHT = $929C;
+  GL_DIFFERENCE = $929E;
+  GL_EXCLUSION = $92A0;
+  GL_HSL_HUE = $92AD;
+  GL_HSL_SATURATION = $92AE;
+  GL_HSL_COLOR = $92AF;
+  GL_HSL_LUMINOSITY = $92B0;
+  GL_DEBUG_OUTPUT_SYNCHRONOUS = $8242;
+  GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = $8243;
+  GL_DEBUG_CALLBACK_FUNCTION = $8244;
+  GL_DEBUG_CALLBACK_USER_PARAM = $8245;
+  GL_DEBUG_SOURCE_API = $8246;
+  GL_DEBUG_SOURCE_WINDOW_SYSTEM = $8247;
+  GL_DEBUG_SOURCE_SHADER_COMPILER = $8248;
+  GL_DEBUG_SOURCE_THIRD_PARTY = $8249;
+  GL_DEBUG_SOURCE_APPLICATION = $824A;
+  GL_DEBUG_SOURCE_OTHER = $824B;
+  GL_DEBUG_TYPE_ERROR = $824C;
+  GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = $824D;
+  GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = $824E;
+  GL_DEBUG_TYPE_PORTABILITY = $824F;
+  GL_DEBUG_TYPE_PERFORMANCE = $8250;
+  GL_DEBUG_TYPE_OTHER = $8251;
+  GL_DEBUG_TYPE_MARKER = $8268;
+  GL_DEBUG_TYPE_PUSH_GROUP = $8269;
+  GL_DEBUG_TYPE_POP_GROUP = $826A;
+  GL_DEBUG_SEVERITY_NOTIFICATION = $826B;
+  GL_MAX_DEBUG_GROUP_STACK_DEPTH = $826C;
+  GL_DEBUG_GROUP_STACK_DEPTH = $826D;
+  GL_BUFFER = $82E0;
+  GL_SHADER = $82E1;
+  GL_PROGRAM = $82E2;
+  GL_VERTEX_ARRAY = $8074;
+  GL_QUERY = $82E3;
+  GL_PROGRAM_PIPELINE = $82E4;
+//  GL_SAMPLER = $82E6;
+  GL_MAX_LABEL_LENGTH = $82E8;
+  GL_MAX_DEBUG_MESSAGE_LENGTH = $9143;
+  GL_MAX_DEBUG_LOGGED_MESSAGES = $9144;
+  GL_DEBUG_LOGGED_MESSAGES = $9145;
+  GL_DEBUG_SEVERITY_HIGH = $9146;
+  GL_DEBUG_SEVERITY_MEDIUM = $9147;
+  GL_DEBUG_SEVERITY_LOW = $9148;
+  GL_DEBUG_OUTPUT = $92E0;
+  GL_CONTEXT_FLAG_DEBUG_BIT = $00000002;
+  GL_STACK_OVERFLOW = $0503;
+  GL_STACK_UNDERFLOW = $0504;
+  GL_GEOMETRY_SHADER = $8DD9;
+  GL_GEOMETRY_SHADER_BIT = $00000004;
+  GL_GEOMETRY_VERTICES_OUT = $8916;
+  GL_GEOMETRY_INPUT_TYPE = $8917;
+  GL_GEOMETRY_OUTPUT_TYPE = $8918;
+  GL_GEOMETRY_SHADER_INVOCATIONS = $887F;
+  GL_LAYER_PROVOKING_VERTEX = $825E;
+  GL_LINES_ADJACENCY = $000A;
+  GL_LINE_STRIP_ADJACENCY = $000B;
+  GL_TRIANGLES_ADJACENCY = $000C;
+  GL_TRIANGLE_STRIP_ADJACENCY = $000D;
+  GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF;
+  GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C;
+  GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32;
+  GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123;
+  GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124;
+  GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0;
+  GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1;
+  GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A;
+  GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTERS = $92D5;
+  GL_MAX_GEOMETRY_IMAGE_UNIFORMS = $90CD;
+  GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7;
+  GL_FIRST_VERTEX_CONVENTION = $8E4D;
+  GL_LAST_VERTEX_CONVENTION = $8E4E;
+  GL_UNDEFINED_VERTEX = $8260;
+  GL_PRIMITIVES_GENERATED = $8C87;
+  GL_FRAMEBUFFER_DEFAULT_LAYERS = $9312;
+  GL_MAX_FRAMEBUFFER_LAYERS = $9317;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8;
+  GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7;
+  GL_REFERENCED_BY_GEOMETRY_SHADER = $9309;
+  GL_PRIMITIVE_BOUNDING_BOX = $92BE;
+  GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = $00000004;
+  GL_CONTEXT_FLAGS = $821E;
+  GL_LOSE_CONTEXT_ON_RESET = $8252;
+  GL_GUILTY_CONTEXT_RESET = $8253;
+  GL_INNOCENT_CONTEXT_RESET = $8254;
+  GL_UNKNOWN_CONTEXT_RESET = $8255;
+  GL_RESET_NOTIFICATION_STRATEGY = $8256;
+  GL_NO_RESET_NOTIFICATION = $8261;
+  GL_CONTEXT_LOST = $0507;
+  GL_SAMPLE_SHADING = $8C36;
+  GL_MIN_SAMPLE_SHADING_VALUE = $8C37;
+  GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B;
+  GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C;
+  GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D;
+//  GL_PATCHES = $000E;
+  GL_PATCH_VERTICES = $8E72;
+  GL_TESS_CONTROL_OUTPUT_VERTICES = $8E75;
+  GL_TESS_GEN_MODE = $8E76;
+  GL_TESS_GEN_SPACING = $8E77;
+  GL_TESS_GEN_VERTEX_ORDER = $8E78;
+  GL_TESS_GEN_POINT_MODE = $8E79;
+  GL_ISOLINES = $8E7A;
+  GL_QUADS = $0007;
+  GL_FRACTIONAL_ODD = $8E7B;
+  GL_FRACTIONAL_EVEN = $8E7C;
+  GL_MAX_PATCH_VERTICES = $8E7D;
+  GL_MAX_TESS_GEN_LEVEL = $8E7E;
+  GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = $8E7F;
+  GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E80;
+  GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = $8E81;
+  GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = $8E82;
+  GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = $8E83;
+  GL_MAX_TESS_PATCH_COMPONENTS = $8E84;
+  GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = $8E85;
+  GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = $8E86;
+  GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = $8E89;
+  GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = $8E8A;
+  GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = $886C;
+  GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = $886D;
+  GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = $8E1E;
+  GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E1F;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4;
+  GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB;
+  GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC;
+  GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8;
+  GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9;
+//  GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = $8221;
+  GL_IS_PER_PATCH = $92E7;
+  GL_REFERENCED_BY_TESS_CONTROL_SHADER = $9307;
+  GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308;
+  GL_TESS_CONTROL_SHADER = $8E88;
+  GL_TESS_EVALUATION_SHADER = $8E87;
+  GL_TESS_CONTROL_SHADER_BIT = $00000008;
+  GL_TESS_EVALUATION_SHADER_BIT = $00000010;
+  GL_TEXTURE_BORDER_COLOR = $1004;
+  GL_CLAMP_TO_BORDER = $812D;
+  GL_TEXTURE_BUFFER = $8C2A;
+  GL_TEXTURE_BUFFER_BINDING = $8C2A;
+  GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B;
+  GL_TEXTURE_BINDING_BUFFER = $8C2C;
+  GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D;
+  GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F;
+  GL_SAMPLER_BUFFER = $8DC2;
+  GL_INT_SAMPLER_BUFFER = $8DD0;
+  GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8;
+  GL_IMAGE_BUFFER = $9051;
+  GL_INT_IMAGE_BUFFER = $905C;
+  GL_UNSIGNED_INT_IMAGE_BUFFER = $9067;
+  GL_TEXTURE_BUFFER_OFFSET = $919D;
+  GL_TEXTURE_BUFFER_SIZE = $919E;
+  GL_COMPRESSED_RGBA_ASTC_4x4 = $93B0;
+  GL_COMPRESSED_RGBA_ASTC_5x4 = $93B1;
+  GL_COMPRESSED_RGBA_ASTC_5x5 = $93B2;
+  GL_COMPRESSED_RGBA_ASTC_6x5 = $93B3;
+  GL_COMPRESSED_RGBA_ASTC_6x6 = $93B4;
+  GL_COMPRESSED_RGBA_ASTC_8x5 = $93B5;
+  GL_COMPRESSED_RGBA_ASTC_8x6 = $93B6;
+  GL_COMPRESSED_RGBA_ASTC_8x8 = $93B7;
+  GL_COMPRESSED_RGBA_ASTC_10x5 = $93B8;
+  GL_COMPRESSED_RGBA_ASTC_10x6 = $93B9;
+  GL_COMPRESSED_RGBA_ASTC_10x8 = $93BA;
+  GL_COMPRESSED_RGBA_ASTC_10x10 = $93BB;
+  GL_COMPRESSED_RGBA_ASTC_12x10 = $93BC;
+  GL_COMPRESSED_RGBA_ASTC_12x12 = $93BD;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4 = $93D0;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4 = $93D1;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5 = $93D2;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5 = $93D3;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6 = $93D4;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5 = $93D5;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6 = $93D6;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8 = $93D7;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5 = $93D8;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6 = $93D9;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8 = $93DA;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10 = $93DB;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10 = $93DC;
+  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12 = $93DD;
+  GL_TEXTURE_CUBE_MAP_ARRAY = $9009;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A;
+  GL_SAMPLER_CUBE_MAP_ARRAY = $900C;
+  GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D;
+  GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E;
+  GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F;
+  GL_IMAGE_CUBE_MAP_ARRAY = $9054;
+  GL_INT_IMAGE_CUBE_MAP_ARRAY = $905F;
+  GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A;
+//  GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102;
+  GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105;
+  GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B;
+  GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C;
+  GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D;
+(*******************************************************************************
+*                            GL_ES_VERSION_3_2                                 *
+*******************************************************************************)
+
+
+var
+  GL_VERSION_ES_CM_1_0: Boolean;
+  GL_ES_VERSION_2_0: Boolean;
+  GL_ES_VERSION_3_0: Boolean;
+  GL_ES_VERSION_3_1: Boolean;
+  GL_ES_VERSION_3_2: Boolean;
+
+  GL_OES_framebuffer_object: Boolean;                 // "подмена понятий"
+  GL_OES_blend_func_separate: Boolean;                // "подмена понятий"
+  GL_IMG_texture_compression_pvrtc: Boolean;
+  GL_EXT_texture_filter_anisotropic: Boolean;
+  GL_OES_depth24: Boolean;
+  GL_OES_depth32: Boolean;
+  {$IfDef GL_VERSION_ES_CM_1_0}
+  GL_OES_compressed_paletted_texture: Boolean;
+  GL_OES_point_size_array: Boolean;
+  GL_OES_point_sprite: Boolean;
+  GL_KHR_debug: Boolean;
+  GL_OES_EGL_image: Boolean;
+  GL_OES_EGL_image_external: Boolean;
+  GL_OES_blend_equation_separate: Boolean;
+  GL_OES_blend_subtract: Boolean;
+  GL_OES_byte_coordinates: Boolean;
+  GL_OES_compressed_ETC1_RGB8_sub_texture: Boolean;
+  GL_OES_compressed_ETC1_RGB8_texture: Boolean;
+//  GL_OES_depth24: Boolean;
+//  GL_OES_depth32: Boolean;
+  GL_OES_draw_texture: Boolean;
+  GL_OES_element_index_uint: Boolean;
+  GL_OES_extended_matrix_palette: Boolean;
+  GL_OES_fbo_render_mipmap: Boolean;
+  GL_OES_fixed_point: Boolean;
+//  GL_OES_framebuffer_object: Boolean;
+  GL_OES_mapbuffer: Boolean;
+  GL_OES_matrix_get: Boolean;
+  GL_OES_matrix_palette: Boolean;
+  GL_OES_packed_depth_stencil: Boolean;
+  GL_OES_query_matrix: Boolean;
+  GL_OES_required_internalformat: Boolean;
+  GL_OES_rgb8_rgba8: Boolean;
+  GL_OES_single_precision: Boolean;
+  GL_OES_stencil1: Boolean;
+  GL_OES_stencil4: Boolean;
+  GL_OES_stencil8: Boolean;
+  GL_OES_stencil_wrap: Boolean;
+  GL_OES_surfaceless_context: Boolean;
+  GL_OES_texture_cube_map: Boolean;
+  GL_OES_texture_env_crossbar: Boolean;
+  GL_OES_texture_mirrored_repeat: Boolean;
+  GL_OES_texture_npot: Boolean;
+  GL_OES_vertex_array_object: Boolean;
+  GL_AMD_compressed_3DC_texture: Boolean;
+  GL_AMD_compressed_ATC_texture: Boolean;
+  GL_APPLE_copy_texture_levels: Boolean;
+  GL_APPLE_framebuffer_multisample: Boolean;
+  GL_APPLE_sync: Boolean;
+  GL_APPLE_texture_2D_limited_npot: Boolean;
+  GL_APPLE_texture_format_BGRA8888: Boolean;
+  GL_APPLE_texture_max_level: Boolean;
+  GL_ARM_rgba8: Boolean;
+  GL_EXT_blend_minmax: Boolean;
+  GL_EXT_debug_marker: Boolean;
+  GL_EXT_discard_framebuffer: Boolean;
+  GL_EXT_map_buffer_range: Boolean;
+  GL_EXT_multi_draw_arrays: Boolean;
+  GL_EXT_multisampled_render_to_texture: Boolean;
+  GL_EXT_read_format_bgra: Boolean;
+  GL_EXT_robustness: Boolean;
+  GL_EXT_sRGB: Boolean;
+  GL_EXT_texture_compression_dxt1: Boolean;
+//  GL_EXT_texture_filter_anisotropic: Boolean;
+  GL_EXT_texture_format_BGRA8888: Boolean;
+  GL_EXT_texture_lod_bias: Boolean;
+  GL_EXT_texture_storage: Boolean;
+  GL_IMG_multisampled_render_to_texture: Boolean;
+  GL_IMG_read_format: Boolean;
+//  GL_IMG_texture_compression_pvrtc: Boolean;
+  GL_IMG_texture_env_enhanced_fixed_function: Boolean;
+  GL_IMG_user_clip_plane: Boolean;
+  GL_NV_fence: Boolean;
+  GL_QCOM_driver_control: Boolean;
+  GL_QCOM_extended_get: Boolean;
+  GL_QCOM_extended_get2: Boolean;
+  GL_QCOM_perfmon_global_mode: Boolean;
+  GL_QCOM_tiled_rendering: Boolean;
+  GL_QCOM_writeonly_rendering: Boolean;
+{$EndIf}
+
+{$IFDEF GL_ES_EXT_VERSION_2_0}
+  GL_KHR_blend_equation_advanced: Boolean;
+  GL_KHR_blend_equation_advanced_coherent: Boolean;
+  GL_KHR_context_flush_control: Boolean;
+  GL_KHR_debug: Boolean;
+  GL_KHR_no_error: Boolean;
+  GL_KHR_parallel_shader_compile: Boolean;
+  GL_KHR_robust_buffer_access_behavior: Boolean;
+  GL_KHR_robustness: Boolean;
+  GL_KHR_shader_subgroup: Boolean;
+  GL_KHR_texture_compression_astc_hdr: Boolean;
+  GL_KHR_texture_compression_astc_ldr: Boolean;
+  GL_KHR_texture_compression_astc_sliced_3d: Boolean;
+  GL_OES_EGL_image: Boolean;
+  GL_OES_EGL_image_external: Boolean;
+  GL_OES_EGL_image_external_essl3: Boolean;
+  GL_OES_compressed_ETC1_RGB8_sub_texture: Boolean;
+  GL_OES_compressed_ETC1_RGB8_texture: Boolean;
+  GL_OES_compressed_paletted_texture: Boolean;
+  GL_OES_copy_image: Boolean;
+//  GL_OES_depth24: Boolean;
+//  GL_OES_depth32: Boolean;
+  GL_OES_depth_texture: Boolean;
+  GL_OES_draw_buffers_indexed: Boolean;
+  GL_OES_draw_elements_base_vertex: Boolean;
+  GL_OES_element_index_uint: Boolean;
+  GL_OES_fbo_render_mipmap: Boolean;
+  GL_OES_fragment_precision_high: Boolean;
+  GL_OES_geometry_point_size: Boolean;
+  GL_OES_geometry_shader: Boolean;
+  GL_OES_get_program_binary: Boolean;
+  GL_OES_gpu_shader5: Boolean;
+  GL_OES_mapbuffer: Boolean;
+  GL_OES_packed_depth_stencil: Boolean;
+  GL_OES_primitive_bounding_box: Boolean;
+  GL_OES_required_internalformat: Boolean;
+  GL_OES_rgb8_rgba8: Boolean;
+  GL_OES_sample_shading: Boolean;
+  GL_OES_sample_variables: Boolean;
+  GL_OES_shader_image_atomic: Boolean;
+  GL_OES_shader_io_blocks: Boolean;
+  GL_OES_shader_multisample_interpolation: Boolean;
+  GL_OES_standard_derivatives: Boolean;
+  GL_OES_stencil1: Boolean;
+  GL_OES_stencil4: Boolean;
+  GL_OES_surfaceless_context: Boolean;
+  GL_OES_tessellation_point_size: Boolean;
+  GL_OES_tessellation_shader: Boolean;
+  GL_OES_texture_3D: Boolean;
+  GL_OES_texture_border_clamp: Boolean;
+  GL_OES_texture_buffer: Boolean;
+  GL_OES_texture_compression_astc: Boolean;
+  GL_OES_texture_cube_map_array: Boolean;
+  GL_OES_texture_float: Boolean;
+  GL_OES_texture_float_linear: Boolean;
+  GL_OES_texture_half_float: Boolean;
+  GL_OES_texture_half_float_linear: Boolean;
+  GL_OES_texture_npot: Boolean;
+  GL_OES_texture_stencil8: Boolean;
+  GL_OES_texture_storage_multisample_2d_array: Boolean;
+  GL_OES_texture_view: Boolean;
+  GL_OES_vertex_array_object: Boolean;
+  GL_OES_vertex_half_float: Boolean;
+  GL_OES_vertex_type_10_10_10_2: Boolean;
+  GL_OES_viewport_array: Boolean;
+  GL_AMD_compressed_3DC_texture: Boolean;
+  GL_AMD_compressed_ATC_texture: Boolean;
+  GL_AMD_framebuffer_multisample_advanced: Boolean;
+  GL_AMD_performance_monitor: Boolean;
+  GL_AMD_program_binary_Z400: Boolean;
+  GL_ANDROID_extension_pack_es31a: Boolean;
+  GL_ANGLE_depth_texture: Boolean;
+  GL_ANGLE_framebuffer_blit: Boolean;
+  GL_ANGLE_framebuffer_multisample: Boolean;
+  GL_ANGLE_instanced_arrays: Boolean;
+  GL_ANGLE_pack_reverse_row_order: Boolean;
+  GL_ANGLE_program_binary: Boolean;
+  GL_ANGLE_texture_compression_dxt3: Boolean;
+  GL_ANGLE_texture_compression_dxt5: Boolean;
+  GL_ANGLE_texture_usage: Boolean;
+  GL_ANGLE_translated_shader_source: Boolean;
+  GL_APPLE_clip_distance: Boolean;
+  GL_APPLE_color_buffer_packed_float: Boolean;
+  GL_APPLE_copy_texture_levels: Boolean;
+  GL_APPLE_framebuffer_multisample: Boolean;
+  GL_APPLE_rgb_422: Boolean;
+  GL_APPLE_sync: Boolean;
+  GL_APPLE_texture_format_BGRA8888: Boolean;
+  GL_APPLE_texture_max_level: Boolean;
+  GL_APPLE_texture_packed_float: Boolean;
+  GL_ARM_mali_program_binary: Boolean;
+  GL_ARM_mali_shader_binary: Boolean;
+  GL_ARM_rgba8: Boolean;
+  GL_ARM_shader_framebuffer_fetch: Boolean;
+  GL_ARM_shader_framebuffer_fetch_depth_stencil: Boolean;
+  GL_ARM_texture_unnormalized_coordinates: Boolean;
+  GL_DMP_program_binary: Boolean;
+  GL_DMP_shader_binary: Boolean;
+  GL_EXT_EGL_image_array: Boolean;
+  GL_EXT_EGL_image_storage: Boolean;
+  GL_EXT_EGL_image_storage_compression: Boolean;
+  GL_EXT_YUV_target: Boolean;
+  GL_EXT_base_instance: Boolean;
+  GL_EXT_blend_func_extended: Boolean;
+  GL_EXT_blend_minmax: Boolean;
+  GL_EXT_buffer_storage: Boolean;
+  GL_EXT_clear_texture: Boolean;
+  GL_EXT_clip_control: Boolean;
+  GL_EXT_clip_cull_distance: Boolean;
+  GL_EXT_color_buffer_float: Boolean;
+  GL_EXT_color_buffer_half_float: Boolean;
+  GL_EXT_conservative_depth: Boolean;
+  GL_EXT_copy_image: Boolean;
+  GL_EXT_debug_label: Boolean;
+  GL_EXT_debug_marker: Boolean;
+  GL_EXT_depth_clamp: Boolean;
+  GL_EXT_discard_framebuffer: Boolean;
+  GL_EXT_disjoint_timer_query: Boolean;
+  GL_EXT_draw_buffers: Boolean;
+  GL_EXT_draw_elements_base_vertex: Boolean;
+  GL_EXT_draw_instanced: Boolean;
+  GL_EXT_draw_transform_feedback: Boolean;
+  GL_EXT_external_buffer: Boolean;
+  GL_EXT_float_blend: Boolean;
+  GL_EXT_fragment_shading_rate: Boolean;
+  GL_EXT_framebuffer_blit_layers: Boolean;
+  GL_EXT_geometry_point_size: Boolean;
+  GL_EXT_geometry_shader: Boolean;
+  GL_EXT_gpu_shader5: Boolean;
+  GL_EXT_instanced_arrays: Boolean;
+  GL_EXT_map_buffer_range: Boolean;
+  GL_EXT_memory_object: Boolean;
+  GL_EXT_memory_object_fd: Boolean;
+  GL_EXT_memory_object_win32: Boolean;
+  GL_EXT_multi_draw_arrays: Boolean;
+  GL_EXT_multi_draw_indirect: Boolean;
+  GL_EXT_multisampled_compatibility: Boolean;
+  GL_EXT_multisampled_render_to_texture: Boolean;
+  GL_EXT_multisampled_render_to_texture2: Boolean;
+  GL_EXT_multiview_draw_buffers: Boolean;
+  GL_EXT_multiview_tessellation_geometry_shader: Boolean;
+  GL_EXT_multiview_texture_multisample: Boolean;
+  GL_EXT_multiview_timer_query: Boolean;
+  GL_EXT_occlusion_query_boolean: Boolean;
+  GL_EXT_polygon_offset_clamp: Boolean;
+  GL_EXT_post_depth_coverage: Boolean;
+  GL_EXT_primitive_bounding_box: Boolean;
+  GL_EXT_protected_textures: Boolean;
+  GL_EXT_pvrtc_sRGB: Boolean;
+  GL_EXT_raster_multisample: Boolean;
+  GL_EXT_read_format_bgra: Boolean;
+  GL_EXT_render_snorm: Boolean;
+  GL_EXT_robustness: Boolean;
+  GL_EXT_sRGB: Boolean;
+  GL_EXT_sRGB_write_control: Boolean;
+  GL_EXT_semaphore: Boolean;
+  GL_EXT_semaphore_fd: Boolean;
+  GL_EXT_semaphore_win32: Boolean;
+  GL_EXT_separate_depth_stencil: Boolean;
+  GL_EXT_separate_shader_objects: Boolean;
+  GL_EXT_shader_framebuffer_fetch: Boolean;
+  GL_EXT_shader_framebuffer_fetch_non_coherent: Boolean;
+  GL_EXT_shader_group_vote: Boolean;
+  GL_EXT_shader_implicit_conversions: Boolean;
+  GL_EXT_shader_integer_mix: Boolean;
+  GL_EXT_shader_io_blocks: Boolean;
+  GL_EXT_shader_non_constant_global_initializers: Boolean;
+  GL_EXT_shader_pixel_local_storage: Boolean;
+  GL_EXT_shader_pixel_local_storage2: Boolean;
+  GL_EXT_shader_samples_identical: Boolean;
+  GL_EXT_shader_texture_lod: Boolean;
+  GL_EXT_shadow_samplers: Boolean;
+  GL_EXT_sparse_texture: Boolean;
+  GL_EXT_sparse_texture2: Boolean;
+  GL_EXT_tessellation_point_size: Boolean;
+  GL_EXT_tessellation_shader: Boolean;
+  GL_EXT_texture_border_clamp: Boolean;
+  GL_EXT_texture_buffer: Boolean;
+  GL_EXT_texture_compression_astc_decode_mode: Boolean;
+  GL_EXT_texture_compression_bptc: Boolean;
+  GL_EXT_texture_compression_dxt1: Boolean;
+  GL_EXT_texture_compression_rgtc: Boolean;
+  GL_EXT_texture_compression_s3tc: Boolean;
+  GL_EXT_texture_compression_s3tc_srgb: Boolean;
+  GL_EXT_texture_cube_map_array: Boolean;
+//  GL_EXT_texture_filter_anisotropic: Boolean;
+  GL_EXT_texture_filter_minmax: Boolean;
+  GL_EXT_texture_format_BGRA8888: Boolean;
+  GL_EXT_texture_format_sRGB_override: Boolean;
+  GL_EXT_texture_mirror_clamp_to_edge: Boolean;
+  GL_EXT_texture_norm16: Boolean;
+  GL_EXT_texture_query_lod: Boolean;
+  GL_EXT_texture_rg: Boolean;
+  GL_EXT_texture_sRGB_R8: Boolean;
+  GL_EXT_texture_sRGB_RG8: Boolean;
+  GL_EXT_texture_sRGB_decode: Boolean;
+  GL_EXT_texture_shadow_lod: Boolean;
+  GL_EXT_texture_storage: Boolean;
+  GL_EXT_texture_storage_compression: Boolean;
+  GL_EXT_texture_type_2_10_10_10_REV: Boolean;
+  GL_EXT_texture_view: Boolean;
+  GL_EXT_unpack_subimage: Boolean;
+  GL_EXT_win32_keyed_mutex: Boolean;
+  GL_EXT_window_rectangles: Boolean;
+  GL_FJ_shader_binary_GCCSO: Boolean;
+  GL_IMG_bindless_texture: Boolean;
+  GL_IMG_framebuffer_downsample: Boolean;
+  GL_IMG_multisampled_render_to_texture: Boolean;
+  GL_IMG_program_binary: Boolean;
+  GL_IMG_read_format: Boolean;
+  GL_IMG_shader_binary: Boolean;
+//  GL_IMG_texture_compression_pvrtc: Boolean;
+  GL_IMG_texture_compression_pvrtc2: Boolean;
+  GL_IMG_texture_filter_cubic: Boolean;
+  GL_INTEL_blackhole_render: Boolean;
+  GL_INTEL_conservative_rasterization: Boolean;
+  GL_INTEL_framebuffer_CMAA: Boolean;
+  GL_INTEL_performance_query: Boolean;
+  GL_MESA_bgra: Boolean;
+  GL_MESA_framebuffer_flip_x: Boolean;
+  GL_MESA_framebuffer_flip_y: Boolean;
+  GL_MESA_framebuffer_swap_xy: Boolean;
+  GL_MESA_program_binary_formats: Boolean;
+  GL_MESA_shader_integer_functions: Boolean;
+  GL_NVX_blend_equation_advanced_multi_draw_buffers: Boolean;
+  GL_NV_bindless_texture: Boolean;
+  GL_NV_blend_equation_advanced: Boolean;
+  GL_NV_blend_equation_advanced_coherent: Boolean;
+  GL_NV_blend_minmax_factor: Boolean;
+  GL_NV_clip_space_w_scaling: Boolean;
+  GL_NV_compute_shader_derivatives: Boolean;
+  GL_NV_conditional_render: Boolean;
+  GL_NV_conservative_raster: Boolean;
+  GL_NV_conservative_raster_pre_snap: Boolean;
+  GL_NV_conservative_raster_pre_snap_triangles: Boolean;
+  GL_NV_copy_buffer: Boolean;
+  GL_NV_coverage_sample: Boolean;
+  GL_NV_depth_nonlinear: Boolean;
+  GL_NV_draw_buffers: Boolean;
+  GL_NV_draw_instanced: Boolean;
+  GL_NV_draw_vulkan_image: Boolean;
+  GL_NV_explicit_attrib_location: Boolean;
+  GL_NV_fbo_color_attachments: Boolean;
+  GL_NV_fence: Boolean;
+  GL_NV_fill_rectangle: Boolean;
+  GL_NV_fragment_coverage_to_color: Boolean;
+  GL_NV_fragment_shader_barycentric: Boolean;
+  GL_NV_fragment_shader_interlock: Boolean;
+  GL_NV_framebuffer_blit: Boolean;
+  GL_NV_framebuffer_mixed_samples: Boolean;
+  GL_NV_framebuffer_multisample: Boolean;
+  GL_NV_generate_mipmap_sRGB: Boolean;
+  GL_NV_geometry_shader_passthrough: Boolean;
+  GL_NV_gpu_shader5: Boolean;
+  GL_NV_image_formats: Boolean;
+  GL_NV_instanced_arrays: Boolean;
+  GL_NV_internalformat_sample_query: Boolean;
+  GL_NV_memory_attachment: Boolean;
+  GL_NV_memory_object_sparse: Boolean;
+  GL_NV_mesh_shader: Boolean;
+  GL_NV_non_square_matrices: Boolean;
+  GL_NV_pack_subimage: Boolean;
+  GL_NV_path_rendering: Boolean;
+  GL_NV_path_rendering_shared_edge: Boolean;
+  GL_NV_pixel_buffer_object: Boolean;
+  GL_NV_polygon_mode: Boolean;
+  GL_NV_primitive_shading_rate: Boolean;
+  GL_NV_read_buffer: Boolean;
+  GL_NV_read_buffer_front: Boolean;
+  GL_NV_read_depth: Boolean;
+  GL_NV_read_depth_stencil: Boolean;
+  GL_NV_read_stencil: Boolean;
+  GL_NV_representative_fragment_test: Boolean;
+  GL_NV_sRGB_formats: Boolean;
+  GL_NV_sample_locations: Boolean;
+  GL_NV_sample_mask_override_coverage: Boolean;
+  GL_NV_scissor_exclusive: Boolean;
+  GL_NV_shader_atomic_fp16_vector: Boolean;
+  GL_NV_shader_noperspective_interpolation: Boolean;
+  GL_NV_shader_subgroup_partitioned: Boolean;
+  GL_NV_shader_texture_footprint: Boolean;
+  GL_NV_shading_rate_image: Boolean;
+  GL_NV_shadow_samplers_array: Boolean;
+  GL_NV_shadow_samplers_cube: Boolean;
+  GL_NV_stereo_view_rendering: Boolean;
+  GL_NV_texture_border_clamp: Boolean;
+  GL_NV_texture_compression_s3tc_update: Boolean;
+  GL_NV_texture_npot_2D_mipmap: Boolean;
+  GL_NV_timeline_semaphore: Boolean;
+  GL_NV_viewport_array: Boolean;
+  GL_NV_viewport_array2: Boolean;
+  GL_NV_viewport_swizzle: Boolean;
+  GL_OVR_multiview: Boolean;
+  GL_OVR_multiview2: Boolean;
+  GL_OVR_multiview_multisampled_render_to_texture: Boolean;
+  GL_QCOM_YUV_texture_gather: Boolean;
+  GL_QCOM_alpha_test: Boolean;
+  GL_QCOM_binning_control: Boolean;
+  GL_QCOM_driver_control: Boolean;
+  GL_QCOM_extended_get: Boolean;
+  GL_QCOM_extended_get2: Boolean;
+  GL_QCOM_frame_extrapolation: Boolean;
+  GL_QCOM_framebuffer_foveated: Boolean;
+  GL_QCOM_motion_estimation: Boolean;
+  GL_QCOM_perfmon_global_mode: Boolean;
+  GL_QCOM_render_shared_exponent: Boolean;
+  GL_QCOM_shader_framebuffer_fetch_noncoherent: Boolean;
+  GL_QCOM_shader_framebuffer_fetch_rate: Boolean;
+  GL_QCOM_shading_rate: Boolean;
+  GL_QCOM_texture_foveated: Boolean;
+  GL_QCOM_texture_foveated2: Boolean;
+  GL_QCOM_texture_foveated_subsampled_layout: Boolean;
+  GL_QCOM_tiled_rendering: Boolean;
+  GL_QCOM_writeonly_rendering: Boolean;
+  GL_VIV_shader_binary: Boolean;
+{$EndIf}
+
+{$IfDef GL_VERSION_ES_CM_1_0}
+var
+// min GLES function - glAlphaFunc: procedure(func:GLenum; ref:GLfloat); stdcall;
+// min GLES function - glClearColor: procedure(red, green, blue, alpha:GLfloat); stdcall;
+// min GLES function - glClearDepthf: procedure(d:GLfloat); stdcall;
+  glClipPlanef: procedure(p:GLenum; eqn:PGLfloat); stdcall;
+// min GLES function - glColor4f: procedure(red, green, blue, alpha:GLfloat); stdcall;
+  glDepthRangef: procedure(n:GLfloat; f:GLfloat); stdcall;
+  glFogf: procedure(pname:GLenum; param:GLfloat); stdcall;
+  glFogfv: procedure(pname:GLenum; params:PGLfloat); stdcall;
+  glFrustumf: procedure(l:GLfloat; r:GLfloat; b:GLfloat; t:GLfloat; n:GLfloat; f:GLfloat); stdcall;
+  glGetClipPlanef: procedure(plane:GLenum; equation:PGLfloat); stdcall;
+// min GLES function - glGetFloatv: procedure(pname:GLenum; data:PGLfloat); stdcall;
+  glGetLightfv: procedure(light:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glGetMaterialfv: procedure(face:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glGetTexEnvfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glGetTexParameterfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glLightModelf: procedure(pname:GLenum; param:GLfloat); stdcall;
+  glLightModelfv: procedure(pname:GLenum; params:PGLfloat); stdcall;
+  glLightf: procedure(light:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glLightfv: procedure(light:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glLineWidth: procedure(width:GLfloat); stdcall;
+// min GLES function - glLoadMatrixf: procedure(m:PGLfloat); stdcall;
+  glMaterialf: procedure(face:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glMaterialfv: procedure(face:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glMultMatrixf: procedure(m:PGLfloat); stdcall;
+  glMultiTexCoord4f: procedure(target:GLenum; s:GLfloat; t:GLfloat; r:GLfloat; q:GLfloat); stdcall;
+  glNormal3f: procedure(nx:GLfloat; ny:GLfloat; nz:GLfloat); stdcall;
+// min GLES function - glOrthof: procedure(l, r, b, t, n, f:GLfloat); stdcall;
+  glPointParameterf: procedure(pname:GLenum; param:GLfloat); stdcall;
+  glPointParameterfv: procedure(pname:GLenum; params:PGLfloat); stdcall;
+  glPointSize: procedure(size:GLfloat); stdcall;
+  glPolygonOffset: procedure(factor:GLfloat; units:GLfloat); stdcall;
+// min GLES function - glRotatef: procedure(angle:GLfloat; x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+// min GLES function - glScalef: procedure(x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glTexEnvf: procedure(target:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glTexEnvfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+// min GLES function - glTexParameterf: procedure(target:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glTexParameterfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+// min GLES function - glTranslatef: procedure(x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glActiveTexture: procedure(texture:GLenum); stdcall;
+  glAlphaFuncx: procedure(func:GLenum; ref:GLfixed); stdcall;
+  glBindBuffer: procedure(target:GLenum; buffer:GLuint); stdcall;
+// min GLES function - glBindTexture: procedure(target:GLenum; texture:GLuint); stdcall;
+// min GLES function - glBlendFunc: procedure(sfactor, dfactor:GLenum); stdcall;
+  glBufferData: procedure(target:GLenum; size:GLsizeiptr; data:pointer; usage:GLenum); stdcall;
+  glBufferSubData: procedure(target:GLenum; offset:GLintptr; size:GLsizeiptr; data:pointer); stdcall;
+// min GLES function - glClear: procedure(mask:GLbitfield); stdcall;
+  glClearColorx: procedure(red:GLfixed; green:GLfixed; blue:GLfixed; alpha:GLfixed); stdcall;
+  glClearDepthx: procedure(depth:GLfixed); stdcall;
+  glClearStencil: procedure(s:GLint); stdcall;
+  glClientActiveTexture: procedure(texture:GLenum); stdcall;
+  glClipPlanex: procedure(plane:GLenum; equation:PGLfixed); stdcall;
+  glColor4ub: procedure(red:GLubyte; green:GLubyte; blue:GLubyte; alpha:GLubyte); stdcall;
+  glColor4x: procedure(red:GLfixed; green:GLfixed; blue:GLfixed; alpha:GLfixed); stdcall;
+// min GLES function - glColorMask: procedure(red, green, blue, alpha:GLboolean); stdcall;
+// min GLES function - glColorPointer: procedure(size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+// min GLES function - glCompressedTexImage2D: procedure(target:GLenum; level:GLint; internalformat:GLenum; width, height:GLsizei; border:GLint; imageSize:GLsizei; data:pointer); stdcall;
+// min GLES function - glCompressedTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; width:GLsizei; height:GLsizei; format:GLenum; imageSize:GLsizei; data:pointer); stdcall;
+  glCopyTexImage2D: procedure(target:GLenum; level:GLint; internalformat:GLenum; x:GLint; y:GLint;
+              width:GLsizei; height:GLsizei; border:GLint); stdcall;
+// min GLES function - glCopyTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glCullFace: procedure(mode:GLenum); stdcall;
+  glDeleteBuffers: procedure(n:GLsizei; buffers:PGLuint); stdcall;
+// min GLES function - glDeleteTextures: procedure(n:GLsizei; textures:PGLuint); stdcall;
+// min GLES function - glDepthFunc: procedure(func:GLenum); stdcall;
+// min GLES function - glDepthMask: procedure(flag:GLboolean); stdcall;
+  glDepthRangex: procedure(n:GLfixed; f:GLfixed); stdcall;
+// min GLES function - glDisable: procedure(cap:GLenum); stdcall;
+// min GLES function - glDisableClientState: procedure(_array:GLenum); stdcall;
+// min GLES function - glDrawArrays: procedure(mode:GLenum; first:GLint; count:GLsizei); stdcall;
+// min GLES function - glDrawElements: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer); stdcall;
+// min GLES function - glEnable: procedure(cap:GLenum); stdcall;
+// min GLES function - glEnableClientState: procedure(_array:GLenum); stdcall;
+  glFinish: procedure; stdcall;
+  glFlush: procedure; stdcall;
+  glFogx: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glFogxv: procedure(pname:GLenum; param:PGLfixed); stdcall;
+  glFrontFace: procedure(mode:GLenum); stdcall;
+  glFrustumx: procedure(l:GLfixed; r:GLfixed; b:GLfixed; t:GLfixed; n:GLfixed; f:GLfixed); stdcall;
+  glGetBooleanv: procedure(pname:GLenum; data:PGLboolean); stdcall;
+  glGetBufferParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetClipPlanex: procedure(plane:GLenum; equation:PGLfixed); stdcall;
+  glGenBuffers: procedure(n:GLsizei; buffers:PGLuint); stdcall;
+// min GLES function - glGenTextures: procedure(n:GLsizei; textures:PGLuint); stdcall;
+  glGetError: function: GLenum; stdcall;
+  glGetFixedv: procedure(pname:GLenum; params:PGLfixed); stdcall;
+// min GLES function - glGetIntegerv: procedure(pname:GLenum; data:PGLint); stdcall;
+  glGetLightxv: procedure(light:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glGetMaterialxv: procedure(face:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glGetPointerv: procedure(pname:GLenum; params:Ppointer); stdcall;
+// min GLES function - glGetString: function(name:GLenum):PGLubyte; stdcall;
+  glGetTexEnviv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexEnvxv: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glGetTexParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexParameterxv: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+// min GLES function - glHint: procedure(target:GLenum; mode:GLenum); stdcall;
+  glIsBuffer: function(buffer:GLuint):GLboolean; stdcall;
+  glIsEnabled: function(cap:GLenum):GLboolean; stdcall;
+  glIsTexture: function(texture:GLuint):GLboolean; stdcall;
+  glLightModelx: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glLightModelxv: procedure(pname:GLenum; param:PGLfixed); stdcall;
+  glLightx: procedure(light:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glLightxv: procedure(light:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glLineWidthx: procedure(width:GLfixed); stdcall;
+// min GLES function - glLoadIdentity: procedure; stdcall;
+  glLoadMatrixx: procedure(m:PGLfixed); stdcall;
+  glLogicOp: procedure(opcode:GLenum); stdcall;
+  glMaterialx: procedure(face:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glMaterialxv: procedure(face:GLenum; pname:GLenum; param:PGLfixed); stdcall;
+// min GLES function - glMatrixMode: procedure(mode:GLenum); stdcall;
+  glMultMatrixx: procedure(m:PGLfixed); stdcall;
+  glMultiTexCoord4x: procedure(texture:GLenum; s:GLfixed; t:GLfixed; r:GLfixed; q:GLfixed); stdcall;
+  glNormal3x: procedure(nx:GLfixed; ny:GLfixed; nz:GLfixed); stdcall;
+  glNormalPointer: procedure(_type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+  glOrthox: procedure(l:GLfixed; r:GLfixed; b:GLfixed; t:GLfixed; n:GLfixed; f:GLfixed); stdcall;
+// min GLES function - glPixelStorei: procedure(pname:GLenum; param:GLint); stdcall;
+  glPointParameterx: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glPointParameterxv: procedure(pname:GLenum; params:PGLfixed); stdcall;
+  glPointSizex: procedure(size:GLfixed); stdcall;
+  glPolygonOffsetx: procedure(factor:GLfixed; units:GLfixed); stdcall;
+// min GLES function - glPopMatrix: procedure; stdcall;
+// min GLES function - glPushMatrix: procedure; stdcall;
+// min GLES function - glReadPixels: procedure(x, y:GLint; width, height:GLsizei; format, _type:GLenum; pixels:pointer); stdcall;
+  glRotatex: procedure(angle:GLfixed; x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+  glSampleCoverage: procedure(value:GLfloat; invert:GLboolean); stdcall;
+  glSampleCoveragex: procedure(value:GLclampx; invert:GLboolean); stdcall;
+  glScalex: procedure(x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+// min GLES function - glScissor: procedure(x, y:GLint; width, height:GLsizei); stdcall;
+// min GLES function - glShadeModel: procedure(mode:GLenum); stdcall;
+  glStencilFunc: procedure(func:GLenum; ref:GLint; mask:GLuint); stdcall;
+  glStencilMask: procedure(mask:GLuint); stdcall;
+  glStencilOp: procedure(fail:GLenum; zfail:GLenum; zpass:GLenum); stdcall;
+// min GLES function - glTexCoordPointer: procedure(size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+// min GLES function - glTexEnvi: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+// min GLES function - glTexEnvx: procedure(target:GLenum; pname:GLenum; param:GLfixed); stdcall;
+// min GLES function - glTexEnviv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glTexEnvxv: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+// min GLES function - glTexImage2D: procedure(target:GLenum; level, internalformat:GLint; width, height:GLsizei; border:GLint; format, _type:GLenum; pixels:pointer); stdcall;
+// min GLES function - glTexParameteri: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+// min GLES function - glTexParameterx: procedure(target:GLenum; pname:GLenum; param:GLfixed); stdcall;
+// min GLES function - glTexParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glTexParameterxv: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+// min GLES function - glTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; width:GLsizei; height:GLsizei; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glTranslatex: procedure(x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+// min GLES function - glVertexPointer: procedure(size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+// min GLES function - glViewport: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+
+  {$IfDef GL_OES_point_size_array}
+  glPointSizePointerOES: procedure(_type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_equation_separate}
+  glBlendEquationSeparateOES: procedure(modeRGB:GLenum; modeAlpha:GLenum); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_func_separate}
+  // min GLES function - glBlendFuncSeparateOES: procedure(srcRGB:GLenum; dstRGB:GLenum; srcAlpha:GLenum; dstAlpha:GLenum); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_subtract}
+  glBlendEquationOES: procedure(mode:GLenum); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_draw_texture}
+  glDrawTexsOES: procedure(x:GLshort; y:GLshort; z:GLshort; width:GLshort; height:GLshort); stdcall;
+  glDrawTexiOES: procedure(x:GLint; y:GLint; z:GLint; width:GLint; height:GLint); stdcall;
+  glDrawTexxOES: procedure(x:GLfixed; y:GLfixed; z:GLfixed; width:GLfixed; height:GLfixed); stdcall;
+  glDrawTexsvOES: procedure(coords:PGLshort); stdcall;
+  glDrawTexivOES: procedure(coords:PGLint); stdcall;
+  glDrawTexxvOES: procedure(coords:PGLfixed); stdcall;
+  glDrawTexfOES: procedure(x:GLfloat; y:GLfloat; z:GLfloat; width:GLfloat; height:GLfloat); stdcall;
+  glDrawTexfvOES: procedure(coords:PGLfloat); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_fixed_point}
+  glAlphaFuncxOES: procedure(func:GLenum; ref:GLfixed); stdcall;
+  glClearColorxOES: procedure(red:GLfixed; green:GLfixed; blue:GLfixed; alpha:GLfixed); stdcall;
+  glClearDepthxOES: procedure(depth:GLfixed); stdcall;
+  glClipPlanexOES: procedure(plane:GLenum; equation:PGLfixed); stdcall;
+  glColor4xOES: procedure(red:GLfixed; green:GLfixed; blue:GLfixed; alpha:GLfixed); stdcall;
+  glDepthRangexOES: procedure(n:GLfixed; f:GLfixed); stdcall;
+  glFogxOES: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glFogxvOES: procedure(pname:GLenum; param:PGLfixed); stdcall;
+  glFrustumxOES: procedure(l:GLfixed; r:GLfixed; b:GLfixed; t:GLfixed; n:GLfixed; f:GLfixed); stdcall;
+  glGetClipPlanexOES: procedure(plane:GLenum; equation:PGLfixed); stdcall;
+  glGetFixedvOES: procedure(pname:GLenum; params:PGLfixed); stdcall;
+  glGetTexEnvxvOES: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glGetTexParameterxvOES: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glLightModelxOES: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glLightModelxvOES: procedure(pname:GLenum; param:PGLfixed); stdcall;
+  glLightxOES: procedure(light:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glLightxvOES: procedure(light:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glLineWidthxOES: procedure(width:GLfixed); stdcall;
+  glLoadMatrixxOES: procedure(m:PGLfixed); stdcall;
+  glMaterialxOES: procedure(face:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glMaterialxvOES: procedure(face:GLenum; pname:GLenum; param:PGLfixed); stdcall;
+  glMultMatrixxOES: procedure(m:PGLfixed); stdcall;
+  glMultiTexCoord4xOES: procedure(texture:GLenum; s:GLfixed; t:GLfixed; r:GLfixed; q:GLfixed); stdcall;
+  glNormal3xOES: procedure(nx:GLfixed; ny:GLfixed; nz:GLfixed); stdcall;
+  glOrthoxOES: procedure(l:GLfixed; r:GLfixed; b:GLfixed; t:GLfixed; n:GLfixed; f:GLfixed); stdcall;
+  glPointParameterxvOES: procedure(pname:GLenum; params:PGLfixed); stdcall;
+  glPointSizexOES: procedure(size:GLfixed); stdcall;
+  glPolygonOffsetxOES: procedure(factor:GLfixed; units:GLfixed); stdcall;
+  glRotatexOES: procedure(angle:GLfixed; x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+  glScalexOES: procedure(x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+  glTexEnvxOES: procedure(target:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glTexEnvxvOES: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glTexParameterxOES: procedure(target:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glTexParameterxvOES: procedure(target:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glTranslatexOES: procedure(x:GLfixed; y:GLfixed; z:GLfixed); stdcall;
+  glGetLightxvOES: procedure(light:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glGetMaterialxvOES: procedure(face:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glPointParameterxOES: procedure(pname:GLenum; param:GLfixed); stdcall;
+  glSampleCoveragexOES: procedure(value:GLclampx; invert:GLboolean); stdcall;
+  glGetTexGenxvOES: procedure(coord:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  glTexGenxOES: procedure(coord:GLenum; pname:GLenum; param:GLfixed); stdcall;
+  glTexGenxvOES: procedure(coord:GLenum; pname:GLenum; params:PGLfixed); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_framebuffer_object}
+// min GLES function - glIsRenderbufferOES: function(renderbuffer:GLuint):GLboolean; stdcall;
+// min GLES function - glBindRenderbufferOES: procedure(target:GLenum; renderbuffer:GLuint); stdcall;
+// min GLES function - glDeleteRenderbuffersOES: procedure(n:GLsizei; renderbuffers:PGLuint); stdcall;
+// min GLES function - glGenRenderbuffersOES: procedure(n:GLsizei; renderbuffers:PGLuint); stdcall;
+// min GLES function - glRenderbufferStorageOES: procedure(target:GLenum; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+// min GLES function - glGetRenderbufferParameterivOES: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glIsFramebufferOES: function(framebuffer:GLuint):GLboolean; stdcall;
+// min GLES function - glBindFramebufferOES: procedure(target:GLenum; framebuffer:GLuint); stdcall;
+// min GLES function - glDeleteFramebuffersOES: procedure(n:GLsizei; framebuffers:PGLuint); stdcall;
+// min GLES function - glGenFramebuffersOES: procedure(n:GLsizei; framebuffers:PGLuint); stdcall;
+// min GLES function - glCheckFramebufferStatusOES: function(target:GLenum):GLenum; stdcall;
+// min GLES function - glFramebufferRenderbufferOES: procedure(target:GLenum; attachment:GLenum; renderbuffertarget:GLenum; renderbuffer:GLuint); stdcall;
+// min GLES function - glFramebufferTexture2DOES: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint); stdcall;
+// min GLES function - glGetFramebufferAttachmentParameterivOES: procedure(target:GLenum; attachment:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glGenerateMipmapOES: procedure(target:GLenum); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_matrix_palette}
+  glCurrentPaletteMatrixOES: procedure(matrixpaletteindex:GLuint); stdcall;
+  glLoadPaletteFromModelViewMatrixOES: procedure; stdcall;
+  glMatrixIndexPointerOES: procedure(size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+  glWeightPointerOES: procedure(size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_query_matrix}
+  glQueryMatrixxOES: function(mantissa:PGLfixed; exponent:PGLint):GLbitfield; stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_single_precision}
+  glClearDepthfOES: procedure(depth:GLclampf); stdcall;
+  glClipPlanefOES: procedure(plane:GLenum; equation:PGLfloat); stdcall;
+  glDepthRangefOES: procedure(n:GLclampf; f:GLclampf); stdcall;
+  glFrustumfOES: procedure(l:GLfloat; r:GLfloat; b:GLfloat; t:GLfloat; n:GLfloat; f:GLfloat); stdcall;
+  glGetClipPlanefOES: procedure(plane:GLenum; equation:PGLfloat); stdcall;
+  glOrthofOES: procedure(l, r, b, t, n, f:GLfloat); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_OES_texture_cube_map}
+  glTexGenfOES: procedure(coord:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glTexGenfvOES: procedure(coord:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glTexGeniOES: procedure(coord:GLenum; pname:GLenum; param:GLint); stdcall;
+  glTexGenivOES: procedure(coord:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexGenfvOES: procedure(coord:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glGetTexGenivOES: procedure(coord:GLenum; pname:GLenum; params:PGLint); stdcall;
+  {$EndIf}
+
+  {$IfDef GL_IMG_user_clip_plane}
+  glClipPlanefIMG: procedure(p:GLenum; eqn:PGLfloat); stdcall;
+  glClipPlanexIMG: procedure(p:GLenum; eqn:PGLfixed); stdcall;
+  {$EndIf}
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_2_0}
+var
+  glActiveTexture: procedure(texture:GLenum); stdcall;
+  glAttachShader: procedure(_program:GLuint; shader:GLuint); stdcall;
+  glBindAttribLocation: procedure(_program:GLuint; index:GLuint; name:PGLchar); stdcall;
+  glBindBuffer: procedure(target:GLenum; buffer:GLuint); stdcall;
+// min GLES function - glBindFramebuffer: procedure(target:GLenum; framebuffer:GLuint); stdcall;
+// min GLES function - glBindRenderbuffer: procedure(target:GLenum; renderbuffer:GLuint); stdcall;
+// min GLES function - glBindTexture: procedure(target:GLenum; texture:GLuint); stdcall;
+  glBlendColor: procedure(red:GLfloat; green:GLfloat; blue:GLfloat; alpha:GLfloat); stdcall;
+// min GLES function - glBlendEquation: procedure(mode:GLenum); stdcall;
+  glBlendEquationSeparate: procedure(modeRGB:GLenum; modeAlpha:GLenum); stdcall;
+// min GLES function - glBlendFunc: procedure(sfactor, dfactor:GLenum); stdcall;
+// min GLES function - glBlendFuncSeparate: procedure(sfactorRGB:GLenum; dfactorRGB:GLenum; sfactorAlpha:GLenum; dfactorAlpha:GLenum); stdcall;
+  glBufferData: procedure(target:GLenum; size:GLsizeiptr; data:pointer; usage:GLenum); stdcall;
+  glBufferSubData: procedure(target:GLenum; offset:GLintptr; size:GLsizeiptr; data:pointer); stdcall;
+// min GLES function - glCheckFramebufferStatus: function(target:GLenum):GLenum; stdcall;
+// min GLES function - glClear: procedure(mask:GLbitfield); stdcall;
+// min GLES function - glClearColor: procedure(red, green, blue, alpha:GLfloat); stdcall;
+// min GLES function - glClearDepthf: procedure(d:GLfloat); stdcall;
+  glClearStencil: procedure(s:GLint); stdcall;
+// min GLES function - glColorMask: procedure(red, green, blue, alpha:GLboolean); stdcall;
+  glCompileShader: procedure(shader:GLuint); stdcall;
+// min GLES function - glCompressedTexImage2D: procedure(target:GLenum; level:GLint; internalformat:GLenum; width:GLsizei; height:GLsizei; border:GLint; imageSize:GLsizei; data:pointer); stdcall;
+// min GLES function - glCompressedTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; width:GLsizei; height:GLsizei; format:GLenum; imageSize:GLsizei; data:pointer); stdcall;
+  glCopyTexImage2D: procedure(target:GLenum; level:GLint; internalformat:GLenum; x:GLint; y:GLint;
+              width:GLsizei; height:GLsizei; border:GLint); stdcall;
+// min GLES function - glCopyTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glCreateProgram: function: GLuint; stdcall;
+  glCreateShader: function(_type:GLenum):GLuint; stdcall;
+  glCullFace: procedure(mode:GLenum); stdcall;
+  glDeleteBuffers: procedure(n:GLsizei; buffers:PGLuint); stdcall;
+// min GLES function - glDeleteFramebuffers: procedure(n:GLsizei; framebuffers:PGLuint); stdcall;
+  glDeleteProgram: procedure(_program:GLuint); stdcall;
+// min GLES function - glDeleteRenderbuffers: procedure(n:GLsizei; renderbuffers:PGLuint); stdcall;
+  glDeleteShader: procedure(shader:GLuint); stdcall;
+// min GLES function - glDeleteTextures: procedure(n:GLsizei; textures:PGLuint); stdcall;
+// min GLES function - glDepthFunc: procedure(func:GLenum); stdcall;
+// min GLES function - glDepthMask: procedure(flag:GLboolean); stdcall;
+  glDepthRangef: procedure(n:GLfloat; f:GLfloat); stdcall;
+  glDetachShader: procedure(_program:GLuint; shader:GLuint); stdcall;
+// min GLES function - glDisable: procedure(cap:GLenum); stdcall;
+  glDisableVertexAttribArray: procedure(index:GLuint); stdcall;
+// min GLES function - glDrawArrays: procedure(mode:GLenum; first:GLint; count:GLsizei); stdcall;
+// min GLES function - glDrawElements: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer); stdcall;
+// min GLES function - glEnable: procedure(cap:GLenum); stdcall;
+  glEnableVertexAttribArray: procedure(index:GLuint); stdcall;
+  glFinish: procedure; stdcall;
+  glFlush: procedure; stdcall;
+// min GLES function - glFramebufferRenderbuffer: procedure(target:GLenum; attachment:GLenum; renderbuffertarget:GLenum; renderbuffer:GLuint); stdcall;
+// min GLES function - glFramebufferTexture2D: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint); stdcall;
+  glFrontFace: procedure(mode:GLenum); stdcall;
+  glGenBuffers: procedure(n:GLsizei; buffers:PGLuint); stdcall;
+// min GLES function - glGenerateMipmap: procedure(target:GLenum); stdcall;
+// min GLES function - glGenFramebuffers: procedure(n:GLsizei; framebuffers:PGLuint); stdcall;
+// min GLES function - glGenRenderbuffers: procedure(n:GLsizei; renderbuffers:PGLuint); stdcall;
+// min GLES function - glGenTextures: procedure(n:GLsizei; textures:PGLuint); stdcall;
+  glGetActiveAttrib: procedure(_program:GLuint; index:GLuint; bufSize:GLsizei; length:PGLsizei; size:PGLint;
+              _type:PGLenum; name:PGLchar); stdcall;
+  glGetActiveUniform: procedure(_program:GLuint; index:GLuint; bufSize:GLsizei; length:PGLsizei; size:PGLint;
+              _type:PGLenum; name:PGLchar); stdcall;
+  glGetAttachedShaders: procedure(_program:GLuint; maxCount:GLsizei; count:PGLsizei; shaders:PGLuint); stdcall;
+  glGetAttribLocation: function(_program:GLuint; name:PGLchar):GLint; stdcall;
+  glGetBooleanv: procedure(pname:GLenum; data:PGLboolean); stdcall;
+  glGetBufferParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetError: function: GLenum; stdcall;
+// min GLES function - glGetFloatv: procedure(pname:GLenum; data:PGLfloat); stdcall;
+// min GLES function - glGetFramebufferAttachmentParameteriv: procedure(target:GLenum; attachment:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glGetIntegerv: procedure(pname:GLenum; data:PGLint); stdcall;
+  glGetProgramiv: procedure(_program:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetProgramInfoLog: procedure(_program:GLuint; bufSize:GLsizei; length:PGLsizei; infoLog:PGLchar); stdcall;
+// min GLES function - glGetRenderbufferParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetShaderiv: procedure(shader:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetShaderInfoLog: procedure(shader:GLuint; bufSize:GLsizei; length:PGLsizei; infoLog:PGLchar); stdcall;
+  glGetShaderPrecisionFormat: procedure(shadertype:GLenum; precisiontype:GLenum; range:PGLint; precision:PGLint); stdcall;
+  glGetShaderSource: procedure(shader:GLuint; bufSize:GLsizei; length:PGLsizei; source:PGLchar); stdcall;
+  // min GLES function - glGetString: function(name:GLenum):PGLubyte; stdcall;
+  glGetTexParameterfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+  glGetTexParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetUniformfv: procedure(_program:GLuint; location:GLint; params:PGLfloat); stdcall;
+  glGetUniformiv: procedure(_program:GLuint; location:GLint; params:PGLint); stdcall;
+  glGetUniformLocation: function(_program:GLuint; name:PGLchar):GLint; stdcall;
+  glGetVertexAttribfv: procedure(index:GLuint; pname:GLenum; params:PGLfloat); stdcall;
+  glGetVertexAttribiv: procedure(index:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetVertexAttribPointerv: procedure(index:GLuint; pname:GLenum; pointer:Ppointer); stdcall;
+// min GLES function - glHint: procedure(target:GLenum; mode:GLenum); stdcall;
+  glIsBuffer: function(buffer:GLuint):GLboolean; stdcall;
+  glIsEnabled: function(cap:GLenum):GLboolean; stdcall;
+// min GLES function - glIsFramebuffer: function(framebuffer:GLuint):GLboolean; stdcall;
+  glIsProgram: function(_program:GLuint):GLboolean; stdcall;
+// min GLES function - glIsRenderbuffer: function(renderbuffer:GLuint):GLboolean; stdcall;
+  glIsShader: function(shader:GLuint):GLboolean; stdcall;
+  glIsTexture: function(texture:GLuint):GLboolean; stdcall;
+  glLineWidth: procedure(width:GLfloat); stdcall;
+  glLinkProgram: procedure(_program:GLuint); stdcall;
+// min GLES function - glPixelStorei: procedure(pname:GLenum; param:GLint); stdcall;
+  glPolygonOffset: procedure(factor:GLfloat; units:GLfloat); stdcall;
+//  // min GLES function - glReadPixels: procedure(x, y:GLint; width, height:GLsizei; format, _type:GLenum; pixels:pointer); stdcall;
+  glReleaseShaderCompiler: procedure; stdcall;
+// min GLES function - glRenderbufferStorage: procedure(target:GLenum; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glSampleCoverage: procedure(value:GLfloat; invert:GLboolean); stdcall;
+// min GLES function - glScissor: procedure(x, y:GLint; width, height:GLsizei); stdcall;
+  glShaderBinary: procedure(count:GLsizei; shaders:PGLuint; binaryFormat:GLenum; binary:pointer; length:GLsizei); stdcall;
+  glShaderSource: procedure(shader:GLuint; count:GLsizei; _string:PPGLchar; length:PGLint); stdcall;
+  glStencilFunc: procedure(func:GLenum; ref:GLint; mask:GLuint); stdcall;
+  glStencilFuncSeparate: procedure(face:GLenum; func:GLenum; ref:GLint; mask:GLuint); stdcall;
+  glStencilMask: procedure(mask:GLuint); stdcall;
+  glStencilMaskSeparate: procedure(face:GLenum; mask:GLuint); stdcall;
+  glStencilOp: procedure(fail:GLenum; zfail:GLenum; zpass:GLenum); stdcall;
+  glStencilOpSeparate: procedure(face:GLenum; sfail:GLenum; dpfail:GLenum; dppass:GLenum); stdcall;
+// min GLES function - glTexImage2D: procedure(target:GLenum; level, internalformat:GLint; width, height:GLsizei; border:GLint; format, _type:GLenum; pixels:pointer); stdcall;
+// min GLES function - glTexParameterf: procedure(target:GLenum; pname:GLenum; param:GLfloat); stdcall;
+  glTexParameterfv: procedure(target:GLenum; pname:GLenum; params:PGLfloat); stdcall;
+// min GLES function - glTexParameteri: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+// min GLES function - glTexParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+// min GLES function - glTexSubImage2D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; width:GLsizei; height:GLsizei; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glUniform1f: procedure(location:GLint; v0:GLfloat); stdcall;
+  glUniform1fv: procedure(location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glUniform1i: procedure(location:GLint; v0:GLint); stdcall;
+  glUniform1iv: procedure(location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glUniform2f: procedure(location:GLint; v0:GLfloat; v1:GLfloat); stdcall;
+  glUniform2fv: procedure(location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glUniform2i: procedure(location:GLint; v0:GLint; v1:GLint); stdcall;
+  glUniform2iv: procedure(location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glUniform3f: procedure(location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat); stdcall;
+  glUniform3fv: procedure(location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glUniform3i: procedure(location:GLint; v0:GLint; v1:GLint; v2:GLint); stdcall;
+  glUniform3iv: procedure(location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glUniform4f: procedure(location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat; v3:GLfloat); stdcall;
+  glUniform4fv: procedure(location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glUniform4i: procedure(location:GLint; v0:GLint; v1:GLint; v2:GLint; v3:GLint); stdcall;
+  glUniform4iv: procedure(location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glUniformMatrix2fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix3fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix4fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUseProgram: procedure(_program:GLuint); stdcall;
+  glValidateProgram: procedure(_program:GLuint); stdcall;
+  glVertexAttrib1f: procedure(index:GLuint; x:GLfloat); stdcall;
+  glVertexAttrib1fv: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glVertexAttrib2f: procedure(index:GLuint; x:GLfloat; y:GLfloat); stdcall;
+  glVertexAttrib2fv: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glVertexAttrib3f: procedure(index:GLuint; x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glVertexAttrib3fv: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glVertexAttrib4f: procedure(index:GLuint; x:GLfloat; y:GLfloat; z:GLfloat; w:GLfloat); stdcall;
+  glVertexAttrib4fv: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glVertexAttribPointer: procedure(index:GLuint; size:GLint; _type:GLenum; normalized:GLboolean; stride:GLsizei; pointer:pointer); stdcall;
+// min GLES function - glViewport: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_KHR_blend_equation_advanced}
+  glBlendBarrierKHR: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_KHR_debug}
+  glDebugMessageControlKHR: procedure(source:GLenum; _type:GLenum; severity:GLenum; count:GLsizei; ids:PGLuint; enabled:GLboolean); stdcall;
+  glDebugMessageInsertKHR: procedure(source:GLenum; _type:GLenum; id:GLuint; severity:GLenum; length:GLsizei; buf:PGLchar); stdcall;
+  glDebugMessageCallbackKHR: procedure(callback:GLDEBUGPROCKHR; userParam:pointer); stdcall;
+  glGetDebugMessageLogKHR: function(count:GLuint; bufSize:GLsizei; sources:PGLenum; types:PGLenum; ids:PGLuint;
+             severities:PGLenum; lengths:PGLsizei; messageLog:PGLchar):GLuint; stdcall;
+  glPushDebugGroupKHR: procedure(source:GLenum; id:GLuint; length:GLsizei; message:PGLchar); stdcall;
+  glPopDebugGroupKHR: procedure; stdcall;
+  glObjectLabelKHR: procedure(identifier:GLenum; name:GLuint; length:GLsizei; _label:PGLchar); stdcall;
+  glGetObjectLabelKHR: procedure(identifier:GLenum; name:GLuint; bufSize:GLsizei; length:PGLsizei; _label:PGLchar); stdcall;
+  glObjectPtrLabelKHR: procedure(ptr:pointer; length:GLsizei; _label:PGLchar); stdcall;
+  glGetObjectPtrLabelKHR: procedure(ptr:pointer; bufSize:GLsizei; length:PGLsizei; _label:PGLchar); stdcall;
+  glGetPointervKHR: procedure(pname:GLenum; params:Ppointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_KHR_parallel_shader_compile}
+  glMaxShaderCompilerThreadsKHR: procedure(count:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_KHR_robustness}
+  glGetGraphicsResetStatusKHR: function: GLenum; stdcall;
+  glReadnPixelsKHR: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei; format:GLenum;
+              _type:GLenum; bufSize:GLsizei; data:pointer); stdcall;
+  glGetnUniformfvKHR: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLfloat); stdcall;
+  glGetnUniformivKHR: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLint); stdcall;
+  glGetnUniformuivKHR: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_EGL_image}
+var
+  glEGLImageTargetTexture2DOES: procedure(target:GLenum; image:GLeglImageOES); stdcall;
+  glEGLImageTargetRenderbufferStorageOES: procedure(target:GLenum; image:GLeglImageOES); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_copy_image}
+  glCopyImageSubDataOES: procedure(srcName:GLuint; srcTarget:GLenum; srcLevel:GLint; srcX:GLint; srcY:GLint;
+              srcZ:GLint; dstName:GLuint; dstTarget:GLenum; dstLevel:GLint; dstX:GLint;
+              dstY:GLint; dstZ:GLint; srcWidth:GLsizei; srcHeight:GLsizei; srcDepth:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_draw_buffers_indexed}
+  glEnableiOES: procedure(target:GLenum; index:GLuint); stdcall;
+  glDisableiOES: procedure(target:GLenum; index:GLuint); stdcall;
+  glBlendEquationiOES: procedure(buf:GLuint; mode:GLenum); stdcall;
+  glBlendEquationSeparateiOES: procedure(buf:GLuint; modeRGB:GLenum; modeAlpha:GLenum); stdcall;
+  glBlendFunciOES: procedure(buf:GLuint; src:GLenum; dst:GLenum); stdcall;
+  glBlendFuncSeparateiOES: procedure(buf:GLuint; srcRGB:GLenum; dstRGB:GLenum; srcAlpha:GLenum; dstAlpha:GLenum); stdcall;
+  glColorMaskiOES: procedure(index:GLuint; r:GLboolean; g:GLboolean; b:GLboolean; a:GLboolean); stdcall;
+  glIsEnablediOES: function(target:GLenum; index:GLuint):GLboolean; stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_draw_elements_base_vertex}
+  glDrawElementsBaseVertexOES: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; basevertex:GLint); stdcall;
+  glDrawRangeElementsBaseVertexOES: procedure(mode:GLenum; start:GLuint; _end:GLuint; count:GLsizei; _type:GLenum;
+              indices:pointer; basevertex:GLint); stdcall;
+  glDrawElementsInstancedBaseVertexOES: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei;
+              basevertex:GLint); stdcall;
+  glMultiDrawElementsBaseVertexEXT: procedure(mode:GLenum; count:PGLsizei; _type:GLenum; indices:Ppointer; drawcount:GLsizei;
+              basevertex:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_geometry_shader}
+  glFramebufferTextureOES: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_get_program_binary}
+  glGetProgramBinaryOES: procedure(_program:GLuint; bufSize:GLsizei; length:PGLsizei; binaryFormat:PGLenum; binary:pointer); stdcall;
+  glProgramBinaryOES: procedure(_program:GLuint; binaryFormat:GLenum; binary:pointer; length:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_mapbuffer}
+  glMapBufferOES: function(target:GLenum; access:GLenum):pointer; stdcall;
+  glUnmapBufferOES: function(target:GLenum):GLboolean; stdcall;
+  glGetBufferPointervOES: procedure(target:GLenum; pname:GLenum; params:Ppointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_primitive_bounding_box}
+  glPrimitiveBoundingBoxOES: procedure(minX:GLfloat; minY:GLfloat; minZ:GLfloat; minW:GLfloat; maxX:GLfloat;
+              maxY:GLfloat; maxZ:GLfloat; maxW:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_sample_shading}
+  glMinSampleShadingOES: procedure(value:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_tessellation_shader}
+  glPatchParameteriOES: procedure(pname:GLenum; value:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_texture_3D}
+  glTexImage3DOES: procedure(target:GLenum; level:GLint; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; border:GLint; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glTexSubImage3DOES: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glCopyTexSubImage3DOES: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glCompressedTexImage3DOES: procedure(target:GLenum; level:GLint; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; border:GLint; imageSize:GLsizei; data:pointer); stdcall;
+  glCompressedTexSubImage3DOES: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; imageSize:GLsizei; data:pointer); stdcall;
+  glFramebufferTexture3DOES: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint; zoffset:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_texture_border_clamp}
+  glTexParameterIivOES: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glTexParameterIuivOES: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glGetTexParameterIivOES: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexParameterIuivOES: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glSamplerParameterIivOES: procedure(sampler:GLuint; pname:GLenum; param:PGLint); stdcall;
+  glSamplerParameterIuivOES: procedure(sampler:GLuint; pname:GLenum; param:PGLuint); stdcall;
+  glGetSamplerParameterIivOES: procedure(sampler:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetSamplerParameterIuivOES: procedure(sampler:GLuint; pname:GLenum; params:PGLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_texture_buffer}
+  glTexBufferOES: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint); stdcall;
+  glTexBufferRangeOES: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint; offset:GLintptr; size:GLsizeiptr); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_texture_storage_multisample_2d_array}
+  glTexStorage3DMultisampleOES: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; fixedsamplelocations:GLboolean); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_texture_view}
+  glTextureViewOES: procedure(texture:GLuint; target:GLenum; origtexture:GLuint; internalformat:GLenum; minlevel:GLuint;
+              numlevels:GLuint; minlayer:GLuint; numlayers:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_vertex_array_object}
+  glBindVertexArrayOES: procedure(_array:GLuint); stdcall;
+  glDeleteVertexArraysOES: procedure(n:GLsizei; arrays:PGLuint); stdcall;
+  glGenVertexArraysOES: procedure(n:GLsizei; arrays:PGLuint); stdcall;
+  glIsVertexArrayOES: function(_array:GLuint):GLboolean; stdcall;
+{$EndIf}
+
+{$IfDef GL_OES_viewport_array}
+  glViewportArrayvOES: procedure(first:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glViewportIndexedfOES: procedure(index:GLuint; x:GLfloat; y:GLfloat; w:GLfloat; h:GLfloat); stdcall;
+  glViewportIndexedfvOES: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glScissorArrayvOES: procedure(first:GLuint; count:GLsizei; v:PGLint); stdcall;
+  glScissorIndexedOES: procedure(index:GLuint; left:GLint; bottom:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glScissorIndexedvOES: procedure(index:GLuint; v:PGLint); stdcall;
+  glDepthRangeArrayfvOES: procedure(first:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glDepthRangeIndexedfOES: procedure(index:GLuint; n:GLfloat; f:GLfloat); stdcall;
+  glGetFloati_vOES: procedure(target:GLenum; index:GLuint; data:PGLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_AMD_framebuffer_multisample_advanced}
+  glRenderbufferStorageMultisampleAdvancedAMD: procedure(target:GLenum; samples:GLsizei; storageSamples:GLsizei; internalformat:GLenum; width:GLsizei;
+              height:GLsizei); stdcall;
+  glNamedRenderbufferStorageMultisampleAdvancedAMD: procedure(renderbuffer:GLuint; samples:GLsizei; storageSamples:GLsizei; internalformat:GLenum; width:GLsizei;
+              height:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_AMD_performance_monitor}
+  glGetPerfMonitorGroupsAMD: procedure(numGroups:PGLint; groupsSize:GLsizei; groups:PGLuint); stdcall;
+  glGetPerfMonitorCountersAMD: procedure(group:GLuint; numCounters:PGLint; maxActiveCounters:PGLint; counterSize:GLsizei; counters:PGLuint); stdcall;
+  glGetPerfMonitorGroupStringAMD: procedure(group:GLuint; bufSize:GLsizei; length:PGLsizei; groupString:PGLchar); stdcall;
+  glGetPerfMonitorCounterStringAMD: procedure(group:GLuint; counter:GLuint; bufSize:GLsizei; length:PGLsizei; counterString:PGLchar); stdcall;
+  glGetPerfMonitorCounterInfoAMD: procedure(group:GLuint; counter:GLuint; pname:GLenum; data:pointer); stdcall;
+  glGenPerfMonitorsAMD: procedure(n:GLsizei; monitors:PGLuint); stdcall;
+  glDeletePerfMonitorsAMD: procedure(n:GLsizei; monitors:PGLuint); stdcall;
+  glSelectPerfMonitorCountersAMD: procedure(monitor:GLuint; enable:GLboolean; group:GLuint; numCounters:GLint; counterList:PGLuint); stdcall;
+  glBeginPerfMonitorAMD: procedure(monitor:GLuint); stdcall;
+  glEndPerfMonitorAMD: procedure(monitor:GLuint); stdcall;
+  glGetPerfMonitorCounterDataAMD: procedure(monitor:GLuint; pname:GLenum; dataSize:GLsizei; data:PGLuint; bytesWritten:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_blit}
+  glBlitFramebufferANGLE: procedure(srcX0:GLint; srcY0:GLint; srcX1:GLint; srcY1:GLint; dstX0:GLint;
+              dstY0:GLint; dstX1:GLint; dstY1:GLint; mask:GLbitfield; filter:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleANGLE: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_ANGLE_instanced_arrays}
+  glDrawArraysInstancedANGLE: procedure(mode:GLenum; first:GLint; count:GLsizei; primcount:GLsizei); stdcall;
+  glDrawElementsInstancedANGLE: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; primcount:GLsizei); stdcall;
+  glVertexAttribDivisorANGLE: procedure(index:GLuint; divisor:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_ANGLE_translated_shader_source}
+  glGetTranslatedShaderSourceANGLE: procedure(shader:GLuint; bufSize:GLsizei; length:PGLsizei; source:PGLchar); stdcall;
+{$EndIf}
+
+{$IfDef GL_APPLE_copy_texture_levels}
+  glCopyTextureLevelsAPPLE: procedure(destinationTexture:GLuint; sourceTexture:GLuint; sourceBaseLevel:GLint; sourceLevelCount:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_APPLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleAPPLE: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glResolveMultisampleFramebufferAPPLE: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_APPLE_sync}
+  glFenceSyncAPPLE: function(condition:GLenum; flags:GLbitfield):GLsync; stdcall;
+  glIsSyncAPPLE: function(sync:GLsync):GLboolean; stdcall;
+  glDeleteSyncAPPLE: procedure(sync:GLsync); stdcall;
+  glClientWaitSyncAPPLE: function(sync:GLsync; flags:GLbitfield; timeout:GLuint64):GLenum; stdcall;
+  glWaitSyncAPPLE: procedure(sync:GLsync; flags:GLbitfield; timeout:GLuint64); stdcall;
+  glGetInteger64vAPPLE: procedure(pname:GLenum; params:PGLint64); stdcall;
+  glGetSyncivAPPLE: procedure(sync:GLsync; pname:GLenum; count:GLsizei; length:PGLsizei; values:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_EGL_image_storage}
+  glEGLImageTargetTexStorageEXT: procedure(target:GLenum; image:GLeglImageOES; attrib_list:PGLint); stdcall;
+  glEGLImageTargetTextureStorageEXT: procedure(texture:GLuint; image:GLeglImageOES; attrib_list:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_base_instance}
+  glDrawArraysInstancedBaseInstanceEXT: procedure(mode:GLenum; first:GLint; count:GLsizei; instancecount:GLsizei; baseinstance:GLuint); stdcall;
+  glDrawElementsInstancedBaseInstanceEXT: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei; baseinstance:GLuint); stdcall;
+  glDrawElementsInstancedBaseVertexBaseInstanceEXT: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei;
+              basevertex:GLint; baseinstance:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_blend_func_extended}
+  glBindFragDataLocationIndexedEXT: procedure(_program:GLuint; colorNumber:GLuint; index:GLuint; name:PGLchar); stdcall;
+  glBindFragDataLocationEXT: procedure(_program:GLuint; color:GLuint; name:PGLchar); stdcall;
+  glGetProgramResourceLocationIndexEXT: function(_program:GLuint; programInterface:GLenum; name:PGLchar):GLint; stdcall;
+  glGetFragDataIndexEXT: function(_program:GLuint; name:PGLchar):GLint; stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_buffer_storage}
+  glBufferStorageEXT: procedure(target:GLenum; size:GLsizeiptr; data:pointer; flags:GLbitfield); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_clear_texture}
+  glClearTexImageEXT: procedure(texture:GLuint; level:GLint; format:GLenum; _type:GLenum; data:pointer); stdcall;
+  glClearTexSubImageEXT: procedure(texture:GLuint; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; _type:GLenum; data:pointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_clip_control}
+  glClipControlEXT: procedure(origin:GLenum; depth:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_copy_image}
+  glCopyImageSubDataEXT: procedure(srcName:GLuint; srcTarget:GLenum; srcLevel:GLint; srcX:GLint; srcY:GLint;
+              srcZ:GLint; dstName:GLuint; dstTarget:GLenum; dstLevel:GLint; dstX:GLint;
+              dstY:GLint; dstZ:GLint; srcWidth:GLsizei; srcHeight:GLsizei; srcDepth:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_debug_label}
+  glLabelObjectEXT: procedure(_type:GLenum; _object:GLuint; length:GLsizei; _label:PGLchar); stdcall;
+  glGetObjectLabelEXT: procedure(_type:GLenum; _object:GLuint; bufSize:GLsizei; length:PGLsizei; _label:PGLchar); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_debug_marker}
+  glInsertEventMarkerEXT: procedure(length:GLsizei; marker:PGLchar); stdcall;
+  glPushGroupMarkerEXT: procedure(length:GLsizei; marker:PGLchar); stdcall;
+  glPopGroupMarkerEXT: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_discard_framebuffer}
+  glDiscardFramebufferEXT: procedure(target:GLenum; numAttachments:GLsizei; attachments:PGLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_disjoint_timer_query}
+  glGenQueriesEXT: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glDeleteQueriesEXT: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glIsQueryEXT: function(id:GLuint):GLboolean; stdcall;
+  glBeginQueryEXT: procedure(target:GLenum; id:GLuint); stdcall;
+  glEndQueryEXT: procedure(target:GLenum); stdcall;
+  glQueryCounterEXT: procedure(id:GLuint; target:GLenum); stdcall;
+  glGetQueryivEXT: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetQueryObjectivEXT: procedure(id:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetQueryObjectuivEXT: procedure(id:GLuint; pname:GLenum; params:PGLuint); stdcall;
+  glGetQueryObjecti64vEXT: procedure(id:GLuint; pname:GLenum; params:PGLint64); stdcall;
+  glGetQueryObjectui64vEXT: procedure(id:GLuint; pname:GLenum; params:PGLuint64); stdcall;
+  glGetInteger64vEXT: procedure(pname:GLenum; data:PGLint64); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_buffers}
+  glDrawBuffersEXT: procedure(n:GLsizei; bufs:PGLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_elements_base_vertex}
+  glDrawElementsBaseVertexEXT: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; basevertex:GLint); stdcall;
+  glDrawRangeElementsBaseVertexEXT: procedure(mode:GLenum; start:GLuint; _end:GLuint; count:GLsizei; _type:GLenum;
+              indices:pointer; basevertex:GLint); stdcall;
+  glDrawElementsInstancedBaseVertexEXT: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei;
+              basevertex:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_instanced}
+  glDrawArraysInstancedEXT: procedure(mode:GLenum; start:GLint; count:GLsizei; primcount:GLsizei); stdcall;
+  glDrawElementsInstancedEXT: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; primcount:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_transform_feedback}
+  glDrawTransformFeedbackEXT: procedure(mode:GLenum; id:GLuint); stdcall;
+  glDrawTransformFeedbackInstancedEXT: procedure(mode:GLenum; id:GLuint; instancecount:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_external_buffer}
+  glBufferStorageExternalEXT: procedure(target:GLenum; offset:GLintptr; size:GLsizeiptr; clientBuffer:GLeglClientBufferEXT; flags:GLbitfield); stdcall;
+  glNamedBufferStorageExternalEXT: procedure(buffer:GLuint; offset:GLintptr; size:GLsizeiptr; clientBuffer:GLeglClientBufferEXT; flags:GLbitfield); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_fragment_shading_rate}
+  glGetFragmentShadingRatesEXT: procedure(samples:GLsizei; maxCount:GLsizei; count:PGLsizei; shadingRates:PGLenum); stdcall;
+  glShadingRateEXT: procedure(rate:GLenum); stdcall;
+  glShadingRateCombinerOpsEXT: procedure(combinerOp0:GLenum; combinerOp1:GLenum); stdcall;
+  glFramebufferShadingRateEXT: procedure(target:GLenum; attachment:GLenum; texture:GLuint; baseLayer:GLint; numLayers:GLsizei;
+              texelWidth:GLsizei; texelHeight:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_framebuffer_blit_layers}
+  glBlitFramebufferLayersEXT: procedure(srcX0:GLint; srcY0:GLint; srcX1:GLint; srcY1:GLint; dstX0:GLint;
+              dstY0:GLint; dstX1:GLint; dstY1:GLint; mask:GLbitfield; filter:GLenum); stdcall;
+  glBlitFramebufferLayerEXT: procedure(srcX0:GLint; srcY0:GLint; srcX1:GLint; srcY1:GLint; srcLayer:GLint;
+              dstX0:GLint; dstY0:GLint; dstX1:GLint; dstY1:GLint; dstLayer:GLint;
+              mask:GLbitfield; filter:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_geometry_shader}
+  glFramebufferTextureEXT: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_instanced_arrays}
+  glVertexAttribDivisorEXT: procedure(index:GLuint; divisor:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_map_buffer_range}
+  glMapBufferRangeEXT: function(target:GLenum; offset:GLintptr; length:GLsizeiptr; access:GLbitfield):pointer; stdcall;
+  glFlushMappedBufferRangeEXT: procedure(target:GLenum; offset:GLintptr; length:GLsizeiptr); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object}
+  glGetUnsignedBytevEXT: procedure(pname:GLenum; data:PGLubyte); stdcall;
+  glGetUnsignedBytei_vEXT: procedure(target:GLenum; index:GLuint; data:PGLubyte); stdcall;
+  glDeleteMemoryObjectsEXT: procedure(n:GLsizei; memoryObjects:PGLuint); stdcall;
+  glIsMemoryObjectEXT: function(memoryObject:GLuint):GLboolean; stdcall;
+  glCreateMemoryObjectsEXT: procedure(n:GLsizei; memoryObjects:PGLuint); stdcall;
+  glMemoryObjectParameterivEXT: procedure(memoryObject:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetMemoryObjectParameterivEXT: procedure(memoryObject:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glTexStorageMem2DEXT: procedure(target:GLenum; levels:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              memory:GLuint; offset:GLuint64); stdcall;
+  glTexStorageMem2DMultisampleEXT: procedure(target:GLenum; samples:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              fixedSampleLocations:GLboolean; memory:GLuint; offset:GLuint64); stdcall;
+  glTexStorageMem3DEXT: procedure(target:GLenum; levels:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; memory:GLuint; offset:GLuint64); stdcall;
+  glTexStorageMem3DMultisampleEXT: procedure(target:GLenum; samples:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; fixedSampleLocations:GLboolean; memory:GLuint; offset:GLuint64); stdcall;
+  glBufferStorageMemEXT: procedure(target:GLenum; size:GLsizeiptr; memory:GLuint; offset:GLuint64); stdcall;
+  glTextureStorageMem2DEXT: procedure(texture:GLuint; levels:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              memory:GLuint; offset:GLuint64); stdcall;
+  glTextureStorageMem2DMultisampleEXT: procedure(texture:GLuint; samples:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              fixedSampleLocations:GLboolean; memory:GLuint; offset:GLuint64); stdcall;
+  glTextureStorageMem3DEXT: procedure(texture:GLuint; levels:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; memory:GLuint; offset:GLuint64); stdcall;
+  glTextureStorageMem3DMultisampleEXT: procedure(texture:GLuint; samples:GLsizei; internalFormat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; fixedSampleLocations:GLboolean; memory:GLuint; offset:GLuint64); stdcall;
+  glNamedBufferStorageMemEXT: procedure(buffer:GLuint; size:GLsizeiptr; memory:GLuint; offset:GLuint64); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_fd}
+  glImportMemoryFdEXT: procedure(memory:GLuint; size:GLuint64; handleType:GLenum; fd:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_win32}
+  glImportMemoryWin32HandleEXT: procedure(memory:GLuint; size:GLuint64; handleType:GLenum; handle:pointer); stdcall;
+  glImportMemoryWin32NameEXT: procedure(memory:GLuint; size:GLuint64; handleType:GLenum; name:pointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_arrays}
+  glMultiDrawArraysEXT: procedure(mode:GLenum; first:PGLint; count:PGLsizei; primcount:GLsizei); stdcall;
+  glMultiDrawElementsEXT: procedure(mode:GLenum; count:PGLsizei; _type:GLenum; indices:Ppointer; primcount:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_indirect}
+  glMultiDrawArraysIndirectEXT: procedure(mode:GLenum; indirect:pointer; drawcount:GLsizei; stride:GLsizei); stdcall;
+  glMultiDrawElementsIndirectEXT: procedure(mode:GLenum; _type:GLenum; indirect:pointer; drawcount:GLsizei; stride:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleEXT: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glFramebufferTexture2DMultisampleEXT: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint; samples:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_multiview_draw_buffers}
+  glReadBufferIndexedEXT: procedure(src:GLenum; index:GLint); stdcall;
+  glDrawBuffersIndexedEXT: procedure(n:GLint; location:PGLenum; indices:PGLint); stdcall;
+  glGetIntegeri_vEXT: procedure(target:GLenum; index:GLuint; data:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_polygon_offset_clamp}
+   glPolygonOffsetClampEXT: procedure(factor:GLfloat; units:GLfloat; clamp:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_primitive_bounding_box}
+  glPrimitiveBoundingBoxEXT: procedure(minX:GLfloat; minY:GLfloat; minZ:GLfloat; minW:GLfloat; maxX:GLfloat;
+              maxY:GLfloat; maxZ:GLfloat; maxW:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_raster_multisample}
+  glRasterSamplesEXT: procedure(samples:GLuint; fixedsamplelocations:GLboolean); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_robustness}
+  glGetGraphicsResetStatusEXT: function: GLenum; stdcall;
+  glReadnPixelsEXT: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei; format:GLenum; _type:GLenum; bufSize:GLsizei; data:pointer); stdcall;
+  glGetnUniformfvEXT: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLfloat); stdcall;
+  glGetnUniformivEXT: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore}
+  glGenSemaphoresEXT: procedure(n:GLsizei; semaphores:PGLuint); stdcall;
+  glDeleteSemaphoresEXT: procedure(n:GLsizei; semaphores:PGLuint); stdcall;
+  glIsSemaphoreEXT: function(semaphore:GLuint):GLboolean; stdcall;
+  glSemaphoreParameterui64vEXT: procedure(semaphore:GLuint; pname:GLenum; params:PGLuint64); stdcall;
+  glGetSemaphoreParameterui64vEXT: procedure(semaphore:GLuint; pname:GLenum; params:PGLuint64); stdcall;
+  glWaitSemaphoreEXT: procedure(semaphore:GLuint; numBufferBarriers:GLuint; buffers:PGLuint; numTextureBarriers:GLuint; textures:PGLuint;
+              srcLayouts:PGLenum); stdcall;
+  glSignalSemaphoreEXT: procedure(semaphore:GLuint; numBufferBarriers:GLuint; buffers:PGLuint; numTextureBarriers:GLuint; textures:PGLuint;
+              dstLayouts:PGLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_fd}
+  glImportSemaphoreFdEXT: procedure(semaphore:GLuint; handleType:GLenum; fd:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_win32}
+  glImportSemaphoreWin32HandleEXT: procedure(semaphore:GLuint; handleType:GLenum; handle:pointer); stdcall;
+  glImportSemaphoreWin32NameEXT: procedure(semaphore:GLuint; handleType:GLenum; name:pointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_separate_shader_objects}
+  glActiveShaderProgramEXT: procedure(pipeline:GLuint; _program:GLuint); stdcall;
+  glBindProgramPipelineEXT: procedure(pipeline:GLuint); stdcall;
+  glCreateShaderProgramvEXT: function(_type:GLenum; count:GLsizei; strings:PPGLchar):GLuint; stdcall;
+  glDeleteProgramPipelinesEXT: procedure(n:GLsizei; pipelines:PGLuint); stdcall;
+  glGenProgramPipelinesEXT: procedure(n:GLsizei; pipelines:PGLuint); stdcall;
+  glGetProgramPipelineInfoLogEXT: procedure(pipeline:GLuint; bufSize:GLsizei; length:PGLsizei; infoLog:PGLchar); stdcall;
+  glGetProgramPipelineivEXT: procedure(pipeline:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glIsProgramPipelineEXT: function(pipeline:GLuint):GLboolean; stdcall;
+  glProgramParameteriEXT: procedure(_program:GLuint; pname:GLenum; value:GLint); stdcall;
+  glProgramUniform1fEXT: procedure(_program:GLuint; location:GLint; v0:GLfloat); stdcall;
+  glProgramUniform1fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform1iEXT: procedure(_program:GLuint; location:GLint; v0:GLint); stdcall;
+  glProgramUniform1ivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform2fEXT: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat); stdcall;
+  glProgramUniform2fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform2iEXT: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint); stdcall;
+  glProgramUniform2ivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform3fEXT: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat); stdcall;
+  glProgramUniform3fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform3iEXT: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint; v2:GLint); stdcall;
+  glProgramUniform3ivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform4fEXT: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat; v3:GLfloat); stdcall;
+  glProgramUniform4fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform4iEXT: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint; v2:GLint; v3:GLint); stdcall;
+  glProgramUniform4ivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniformMatrix2fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUseProgramStagesEXT: procedure(pipeline:GLuint; stages:GLbitfield; _program:GLuint); stdcall;
+  glValidateProgramPipelineEXT: procedure(pipeline:GLuint); stdcall;
+  glProgramUniform1uiEXT: procedure(_program:GLuint; location:GLint; v0:GLuint); stdcall;
+  glProgramUniform2uiEXT: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint); stdcall;
+  glProgramUniform3uiEXT: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint; v2:GLuint); stdcall;
+  glProgramUniform4uiEXT: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint; v2:GLuint; v3:GLuint); stdcall;
+  glProgramUniform1uivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform2uivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform3uivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform4uivEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniformMatrix2x3fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3x2fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix2x4fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4x2fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3x4fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4x3fvEXT: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_shader_framebuffer_fetch_non_coherent}
+  glFramebufferFetchBarrierEXT: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_shader_pixel_local_storage2}
+  glFramebufferPixelLocalStorageSizeEXT: procedure(target:GLuint; size:GLsizei); stdcall;
+  glGetFramebufferPixelLocalStorageSizeEXT: function(target:GLuint):GLsizei; stdcall;
+  glClearPixelLocalStorageuiEXT: procedure(offset:GLsizei; n:GLsizei; values:PGLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_sparse_texture}
+  glTexPageCommitmentEXT: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; commit:GLboolean); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_tessellation_shader}
+  glPatchParameteriEXT: procedure(pname:GLenum; value:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_border_clamp}
+  glTexParameterIivEXT: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glTexParameterIuivEXT: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glGetTexParameterIivEXT: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexParameterIuivEXT: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glSamplerParameterIivEXT: procedure(sampler:GLuint; pname:GLenum; param:PGLint); stdcall;
+  glSamplerParameterIuivEXT: procedure(sampler:GLuint; pname:GLenum; param:PGLuint); stdcall;
+  glGetSamplerParameterIivEXT: procedure(sampler:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetSamplerParameterIuivEXT: procedure(sampler:GLuint; pname:GLenum; params:PGLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_buffer}
+  glTexBufferEXT: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint); stdcall;
+  glTexBufferRangeEXT: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint; offset:GLintptr; size:GLsizeiptr); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage}
+  glTexStorage1DEXT: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei); stdcall;
+  glTexStorage2DEXT: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glTexStorage3DEXT: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei; depth:GLsizei); stdcall;
+  glTextureStorage1DEXT: procedure(texture:GLuint; target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei); stdcall;
+  glTextureStorage2DEXT: procedure(texture:GLuint; target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glTextureStorage3DEXT: procedure(texture:GLuint; target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei; depth:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage_compression}
+  glTexStorageAttribs2DEXT: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              attrib_list:PGLint); stdcall;
+  glTexStorageAttribs3DEXT: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; attrib_list:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_view}
+  glTextureViewEXT: procedure(texture:GLuint; target:GLenum; origtexture:GLuint; internalformat:GLenum; minlevel:GLuint;
+              numlevels:GLuint; minlayer:GLuint; numlayers:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_win32_keyed_mutex}
+  glAcquireKeyedMutexWin32EXT: function(memory:GLuint; key:GLuint64; timeout:GLuint):GLboolean; stdcall;
+  glReleaseKeyedMutexWin32EXT: function(memory:GLuint; key:GLuint64):GLboolean; stdcall;
+{$EndIf}
+
+{$IfDef GL_EXT_window_rectangles}
+  glWindowRectanglesEXT: procedure(mode:GLenum; count:GLsizei; box:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_IMG_bindless_texture}
+  glGetTextureHandleIMG: function(texture:GLuint):GLuint64; stdcall;
+  glGetTextureSamplerHandleIMG: function(texture:GLuint; sampler:GLuint):GLuint64; stdcall;
+  glUniformHandleui64IMG: procedure(location:GLint; value:GLuint64); stdcall;
+  glUniformHandleui64vIMG: procedure(location:GLint; count:GLsizei; value:PGLuint64); stdcall;
+  glProgramUniformHandleui64IMG: procedure(_program:GLuint; location:GLint; value:GLuint64); stdcall;
+  glProgramUniformHandleui64vIMG: procedure(_program:GLuint; location:GLint; count:GLsizei; values:PGLuint64); stdcall;
+{$EndIf}
+
+{$IfDef GL_IMG_framebuffer_downsample}
+  glFramebufferTexture2DDownsampleIMG: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint;
+              xscale:GLint; yscale:GLint); stdcall;
+  glFramebufferTextureLayerDownsampleIMG: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint; layer:GLint;
+              xscale:GLint; yscale:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_IMG_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleIMG: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glFramebufferTexture2DMultisampleIMG: procedure(target:GLenum; attachment:GLenum; textarget:GLenum; texture:GLuint; level:GLint; samples:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_INTEL_framebuffer_CMAA}
+  glApplyFramebufferAttachmentCMAAINTEL: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_INTEL_performance_query}
+  glBeginPerfQueryINTEL: procedure(queryHandle:GLuint); stdcall;
+  glCreatePerfQueryINTEL: procedure(queryId:GLuint; queryHandle:PGLuint); stdcall;
+  glDeletePerfQueryINTEL: procedure(queryHandle:GLuint); stdcall;
+  glEndPerfQueryINTEL: procedure(queryHandle:GLuint); stdcall;
+  glGetFirstPerfQueryIdINTEL: procedure(queryId:PGLuint); stdcall;
+  glGetNextPerfQueryIdINTEL: procedure(queryId:GLuint; nextQueryId:PGLuint); stdcall;
+  glGetPerfCounterInfoINTEL: procedure(queryId:GLuint; counterId:GLuint; counterNameLength:GLuint; counterName:PGLchar; counterDescLength:GLuint;
+              counterDesc:PGLchar; counterOffset:PGLuint; counterDataSize:PGLuint; counterTypeEnum:PGLuint; counterDataTypeEnum:PGLuint;
+              rawCounterMaxValue:PGLuint64); stdcall;
+  glGetPerfQueryDataINTEL: procedure(queryHandle:GLuint; flags:GLuint; dataSize:GLsizei; data:pointer; bytesWritten:PGLuint); stdcall;
+  glGetPerfQueryIdByNameINTEL: procedure(queryName:PGLchar; queryId:PGLuint); stdcall;
+  glGetPerfQueryInfoINTEL: procedure(queryId:GLuint; queryNameLength:GLuint; queryName:PGLchar; dataSize:PGLuint; noCounters:PGLuint;
+              noInstances:PGLuint; capsMask:PGLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_MESA_framebuffer_flip_y}
+  glFramebufferParameteriMESA: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+  glGetFramebufferParameterivMESA: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_bindless_texture}
+  glGetTextureHandleNV: function(texture:GLuint):GLuint64; stdcall;
+  glGetTextureSamplerHandleNV: function(texture:GLuint; sampler:GLuint):GLuint64; stdcall;
+  glMakeTextureHandleResidentNV: procedure(handle:GLuint64); stdcall;
+  glMakeTextureHandleNonResidentNV: procedure(handle:GLuint64); stdcall;
+  glGetImageHandleNV: function(texture:GLuint; level:GLint; layered:GLboolean; layer:GLint; format:GLenum):GLuint64; stdcall;
+  glMakeImageHandleResidentNV: procedure(handle:GLuint64; access:GLenum); stdcall;
+  glMakeImageHandleNonResidentNV: procedure(handle:GLuint64); stdcall;
+  glUniformHandleui64NV: procedure(location:GLint; value:GLuint64); stdcall;
+  glUniformHandleui64vNV: procedure(location:GLint; count:GLsizei; value:PGLuint64); stdcall;
+  glProgramUniformHandleui64NV: procedure(_program:GLuint; location:GLint; value:GLuint64); stdcall;
+  glProgramUniformHandleui64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; values:PGLuint64); stdcall;
+  glIsTextureHandleResidentNV: function(handle:GLuint64):GLboolean; stdcall;
+  glIsImageHandleResidentNV: function(handle:GLuint64):GLboolean; stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_blend_equation_advanced}
+  glBlendParameteriNV: procedure(pname:GLenum; value:GLint); stdcall;
+  glBlendBarrierNV: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_clip_space_w_scaling}
+  glViewportPositionWScaleNV: procedure(index:GLuint; xcoeff:GLfloat; ycoeff:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_conditional_render}
+  glBeginConditionalRenderNV: procedure(id:GLuint; mode:GLenum); stdcall;
+  glEndConditionalRenderNV: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster}
+  glSubpixelPrecisionBiasNV: procedure(xbits:GLuint; ybits:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster_pre_snap_triangles}
+  glConservativeRasterParameteriNV: procedure(pname:GLenum; param:GLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_copy_buffer}
+  glCopyBufferSubDataNV: procedure(readTarget:GLenum; writeTarget:GLenum; readOffset:GLintptr; writeOffset:GLintptr; size:GLsizeiptr); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_coverage_sample}
+  glCoverageMaskNV: procedure(mask:GLboolean); stdcall;
+  glCoverageOperationNV: procedure(operation:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_draw_buffers}
+  glDrawBuffersNV: procedure(n:GLsizei; bufs:PGLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_draw_instanced}
+  glDrawArraysInstancedNV: procedure(mode:GLenum; first:GLint; count:GLsizei; primcount:GLsizei); stdcall;
+  glDrawElementsInstancedNV: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; primcount:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_draw_vulkan_image}
+  glDrawVkImageNV: procedure(vkImage:GLuint64; sampler:GLuint; x0:GLfloat; y0:GLfloat; x1:GLfloat;
+              y1:GLfloat; z:GLfloat; s0:GLfloat; t0:GLfloat; s1:GLfloat; t1:GLfloat); stdcall;
+  glGetVkProcAddrNV: function(name:PGLchar):GLVULKANPROCNV; stdcall;
+  glWaitVkSemaphoreNV: procedure(vkSemaphore:GLuint64); stdcall;
+  glSignalVkSemaphoreNV: procedure(vkSemaphore:GLuint64); stdcall;
+  glSignalVkFenceNV: procedure(vkFence:GLuint64); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_fence}
+  glDeleteFencesNV: procedure(n:GLsizei; fences:PGLuint); stdcall;
+  glGenFencesNV: procedure(n:GLsizei; fences:PGLuint); stdcall;
+  glIsFenceNV: function(fence:GLuint):GLboolean; stdcall;
+  glTestFenceNV: function(fence:GLuint):GLboolean; stdcall;
+  glGetFenceivNV: procedure(fence:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glFinishFenceNV: procedure(fence:GLuint); stdcall;
+  glSetFenceNV: procedure(fence:GLuint; condition:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_fragment_coverage_to_color}
+  glFragmentCoverageColorNV: procedure(color:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_blit}
+  glBlitFramebufferNV: procedure(srcX0:GLint; srcY0:GLint; srcX1:GLint; srcY1:GLint; dstX0:GLint;
+              dstY0:GLint; dstX1:GLint; dstY1:GLint; mask:GLbitfield; filter:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_mixed_samples}
+  glCoverageModulationTableNV: procedure(n:GLsizei; v:PGLfloat); stdcall;
+  glGetCoverageModulationTableNV: procedure(bufSize:GLsizei; v:PGLfloat); stdcall;
+  glCoverageModulationNV: procedure(components:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_multisample}
+  glRenderbufferStorageMultisampleNV: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_gpu_shader5}
+  glUniform1i64NV: procedure(location:GLint; x:GLint64EXT); stdcall;
+  glUniform2i64NV: procedure(location:GLint; x:GLint64EXT; y:GLint64EXT); stdcall;
+  glUniform3i64NV: procedure(location:GLint; x:GLint64EXT; y:GLint64EXT; z:GLint64EXT); stdcall;
+  glUniform4i64NV: procedure(location:GLint; x:GLint64EXT; y:GLint64EXT; z:GLint64EXT; w:GLint64EXT); stdcall;
+  glUniform1i64vNV: procedure(location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glUniform2i64vNV: procedure(location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glUniform3i64vNV: procedure(location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glUniform4i64vNV: procedure(location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glUniform1ui64NV: procedure(location:GLint; x:GLuint64EXT); stdcall;
+  glUniform2ui64NV: procedure(location:GLint; x:GLuint64EXT; y:GLuint64EXT); stdcall;
+  glUniform3ui64NV: procedure(location:GLint; x:GLuint64EXT; y:GLuint64EXT; z:GLuint64EXT); stdcall;
+  glUniform4ui64NV: procedure(location:GLint; x:GLuint64EXT; y:GLuint64EXT; z:GLuint64EXT; w:GLuint64EXT); stdcall;
+  glUniform1ui64vNV: procedure(location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glUniform2ui64vNV: procedure(location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glUniform3ui64vNV: procedure(location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glUniform4ui64vNV: procedure(location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glGetUniformi64vNV: procedure(_program:GLuint; location:GLint; params:PGLint64EXT); stdcall;
+  glProgramUniform1i64NV: procedure(_program:GLuint; location:GLint; x:GLint64EXT); stdcall;
+  glProgramUniform2i64NV: procedure(_program:GLuint; location:GLint; x:GLint64EXT; y:GLint64EXT); stdcall;
+  glProgramUniform3i64NV: procedure(_program:GLuint; location:GLint; x:GLint64EXT; y:GLint64EXT; z:GLint64EXT); stdcall;
+  glProgramUniform4i64NV: procedure(_program:GLuint; location:GLint; x:GLint64EXT; y:GLint64EXT; z:GLint64EXT; w:GLint64EXT); stdcall;
+  glProgramUniform1i64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glProgramUniform2i64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glProgramUniform3i64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glProgramUniform4i64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint64EXT); stdcall;
+  glProgramUniform1ui64NV: procedure(_program:GLuint; location:GLint; x:GLuint64EXT); stdcall;
+  glProgramUniform2ui64NV: procedure(_program:GLuint; location:GLint; x:GLuint64EXT; y:GLuint64EXT); stdcall;
+  glProgramUniform3ui64NV: procedure(_program:GLuint; location:GLint; x:GLuint64EXT; y:GLuint64EXT; z:GLuint64EXT); stdcall;
+  glProgramUniform4ui64NV: procedure(_program:GLuint; location:GLint; x:GLuint64EXT; y:GLuint64EXT; z:GLuint64EXT; w:GLuint64EXT); stdcall;
+  glProgramUniform1ui64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glProgramUniform2ui64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glProgramUniform3ui64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+  glProgramUniform4ui64vNV: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint64EXT); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_instanced_arrays}
+  glVertexAttribDivisorNV: procedure(index:GLuint; divisor:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_internalformat_sample_query}
+  glGetInternalformatSampleivNV: procedure(target:GLenum; internalformat:GLenum; samples:GLsizei; pname:GLenum; count:GLsizei;
+              params:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_memory_attachment}
+  glGetMemoryObjectDetachedResourcesuivNV: procedure(memory:GLuint; pname:GLenum; first:GLint; count:GLsizei; params:PGLuint); stdcall;
+  glResetMemoryObjectParameterNV: procedure(memory:GLuint; pname:GLenum); stdcall;
+  glTexAttachMemoryNV: procedure(target:GLenum; memory:GLuint; offset:GLuint64); stdcall;
+  glBufferAttachMemoryNV: procedure(target:GLenum; memory:GLuint; offset:GLuint64); stdcall;
+  glTextureAttachMemoryNV: procedure(texture:GLuint; memory:GLuint; offset:GLuint64); stdcall;
+  glNamedBufferAttachMemoryNV: procedure(buffer:GLuint; memory:GLuint; offset:GLuint64); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_memory_object_sparse}
+  glBufferPageCommitmentMemNV: procedure(target:GLenum; offset:GLintptr; size:GLsizeiptr; memory:GLuint; memOffset:GLuint64;
+              commit:GLboolean); stdcall;
+  glTexPageCommitmentMemNV: procedure(target:GLenum; layer:GLint; level:GLint; xoffset:GLint; yoffset:GLint;
+              zoffset:GLint; width:GLsizei; height:GLsizei; depth:GLsizei; memory:GLuint;
+              offset:GLuint64; commit:GLboolean); stdcall;
+  glNamedBufferPageCommitmentMemNV: procedure(buffer:GLuint; offset:GLintptr; size:GLsizeiptr; memory:GLuint; memOffset:GLuint64;
+              commit:GLboolean); stdcall;
+  glTexturePageCommitmentMemNV: procedure(texture:GLuint; layer:GLint; level:GLint; xoffset:GLint; yoffset:GLint;
+              zoffset:GLint; width:GLsizei; height:GLsizei; depth:GLsizei; memory:GLuint;
+              offset:GLuint64; commit:GLboolean); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_mesh_shader}
+  glDrawMeshTasksNV: procedure(first:GLuint; count:GLuint); stdcall;
+  glDrawMeshTasksIndirectNV: procedure(indirect:GLintptr); stdcall;
+  glMultiDrawMeshTasksIndirectNV: procedure(indirect:GLintptr; drawcount:GLsizei; stride:GLsizei); stdcall;
+  glMultiDrawMeshTasksIndirectCountNV: procedure(indirect:GLintptr; drawcount:GLintptr; maxdrawcount:GLsizei; stride:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_non_square_matrices}
+  glUniformMatrix2x3fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix3x2fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix2x4fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix4x2fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix3x4fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix4x3fvNV: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_path_rendering}
+  glGenPathsNV: function(range:GLsizei):GLuint; stdcall;
+  glDeletePathsNV: procedure(path:GLuint; range:GLsizei); stdcall;
+  glIsPathNV: function(path:GLuint):GLboolean; stdcall;
+  glPathCommandsNV: procedure(path:GLuint; numCommands:GLsizei; commands:PGLubyte; numCoords:GLsizei; coordType:GLenum;
+              coords:pointer); stdcall;
+  glPathCoordsNV: procedure(path:GLuint; numCoords:GLsizei; coordType:GLenum; coords:pointer); stdcall;
+  glPathSubCommandsNV: procedure(path:GLuint; commandStart:GLsizei; commandsToDelete:GLsizei; numCommands:GLsizei; commands:PGLubyte;
+              numCoords:GLsizei; coordType:GLenum; coords:pointer); stdcall;
+  glPathSubCoordsNV: procedure(path:GLuint; coordStart:GLsizei; numCoords:GLsizei; coordType:GLenum; coords:pointer); stdcall;
+  glPathStringNV: procedure(path:GLuint; format:GLenum; length:GLsizei; pathString:pointer); stdcall;
+  glPathGlyphsNV: procedure(firstPathName:GLuint; fontTarget:GLenum; fontName:pointer; fontStyle:GLbitfield; numGlyphs:GLsizei;
+              _type:GLenum; charcodes:pointer; handleMissingGlyphs:GLenum; pathParameterTemplate:GLuint; emScale:GLfloat); stdcall;
+  glPathGlyphRangeNV: procedure(firstPathName:GLuint; fontTarget:GLenum; fontName:pointer; fontStyle:GLbitfield; firstGlyph:GLuint;
+              numGlyphs:GLsizei; handleMissingGlyphs:GLenum; pathParameterTemplate:GLuint; emScale:GLfloat); stdcall;
+  glWeightPathsNV: procedure(resultPath:GLuint; numPaths:GLsizei; paths:PGLuint; weights:PGLfloat); stdcall;
+  glCopyPathNV: procedure(resultPath:GLuint; srcPath:GLuint); stdcall;
+  glInterpolatePathsNV: procedure(resultPath:GLuint; pathA:GLuint; pathB:GLuint; weight:GLfloat); stdcall;
+  glTransformPathNV: procedure(resultPath:GLuint; srcPath:GLuint; transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glPathParameterivNV: procedure(path:GLuint; pname:GLenum; value:PGLint); stdcall;
+  glPathParameteriNV: procedure(path:GLuint; pname:GLenum; value:GLint); stdcall;
+  glPathParameterfvNV: procedure(path:GLuint; pname:GLenum; value:PGLfloat); stdcall;
+  glPathParameterfNV: procedure(path:GLuint; pname:GLenum; value:GLfloat); stdcall;
+  glPathDashArrayNV: procedure(path:GLuint; dashCount:GLsizei; dashArray:PGLfloat); stdcall;
+  glPathStencilFuncNV: procedure(func:GLenum; ref:GLint; mask:GLuint); stdcall;
+  glPathStencilDepthOffsetNV: procedure(factor:GLfloat; units:GLfloat); stdcall;
+  glStencilFillPathNV: procedure(path:GLuint; fillMode:GLenum; mask:GLuint); stdcall;
+  glStencilStrokePathNV: procedure(path:GLuint; reference:GLint; mask:GLuint); stdcall;
+  glStencilFillPathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; fillMode:GLenum;
+              mask:GLuint; transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glStencilStrokePathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; reference:GLint;
+              mask:GLuint; transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glPathCoverDepthFuncNV: procedure(func:GLenum); stdcall;
+  glCoverFillPathNV: procedure(path:GLuint; coverMode:GLenum); stdcall;
+  glCoverStrokePathNV: procedure(path:GLuint; coverMode:GLenum); stdcall;
+  glCoverFillPathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; coverMode:GLenum;
+              transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glCoverStrokePathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; coverMode:GLenum;
+              transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glGetPathParameterivNV: procedure(path:GLuint; pname:GLenum; value:PGLint); stdcall;
+  glGetPathParameterfvNV: procedure(path:GLuint; pname:GLenum; value:PGLfloat); stdcall;
+  glGetPathCommandsNV: procedure(path:GLuint; commands:PGLubyte); stdcall;
+  glGetPathCoordsNV: procedure(path:GLuint; coords:PGLfloat); stdcall;
+  glGetPathDashArrayNV: procedure(path:GLuint; dashArray:PGLfloat); stdcall;
+  glGetPathMetricsNV: procedure(metricQueryMask:GLbitfield; numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint;
+              stride:GLsizei; metrics:PGLfloat); stdcall;
+  glGetPathMetricRangeNV: procedure(metricQueryMask:GLbitfield; firstPathName:GLuint; numPaths:GLsizei; stride:GLsizei; metrics:PGLfloat); stdcall;
+  glGetPathSpacingNV: procedure(pathListMode:GLenum; numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint;
+              advanceScale:GLfloat; kerningScale:GLfloat; transformType:GLenum; returnedSpacing:PGLfloat); stdcall;
+  glIsPointInFillPathNV: function(path:GLuint; mask:GLuint; x:GLfloat; y:GLfloat):GLboolean; stdcall;
+  glIsPointInStrokePathNV: function(path:GLuint; x:GLfloat; y:GLfloat):GLboolean; stdcall;
+  glGetPathLengthNV: function(path:GLuint; startSegment:GLsizei; numSegments:GLsizei):GLfloat; stdcall;
+  glPointAlongPathNV: function(path:GLuint; startSegment:GLsizei; numSegments:GLsizei; distance:GLfloat; x:PGLfloat;
+             y:PGLfloat; tangentX:PGLfloat; tangentY:PGLfloat):GLboolean; stdcall;
+  glMatrixLoad3x2fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glMatrixLoad3x3fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glMatrixLoadTranspose3x3fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glMatrixMult3x2fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glMatrixMult3x3fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glMatrixMultTranspose3x3fNV: procedure(matrixMode:GLenum; m:PGLfloat); stdcall;
+  glStencilThenCoverFillPathNV: procedure(path:GLuint; fillMode:GLenum; mask:GLuint; coverMode:GLenum); stdcall;
+  glStencilThenCoverStrokePathNV: procedure(path:GLuint; reference:GLint; mask:GLuint; coverMode:GLenum); stdcall;
+  glStencilThenCoverFillPathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; fillMode:GLenum;
+              mask:GLuint; coverMode:GLenum; transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glStencilThenCoverStrokePathInstancedNV: procedure(numPaths:GLsizei; pathNameType:GLenum; paths:pointer; pathBase:GLuint; reference:GLint;
+              mask:GLuint; coverMode:GLenum; transformType:GLenum; transformValues:PGLfloat); stdcall;
+  glPathGlyphIndexRangeNV: function(fontTarget:GLenum; fontName:pointer; fontStyle:GLbitfield; pathParameterTemplate:GLuint; emScale:GLfloat;
+             baseAndCount:PGLuint):GLenum; stdcall;
+  glPathGlyphIndexArrayNV: function(firstPathName:GLuint; fontTarget:GLenum; fontName:pointer; fontStyle:GLbitfield; firstGlyphIndex:GLuint;
+             numGlyphs:GLsizei; pathParameterTemplate:GLuint; emScale:GLfloat):GLenum; stdcall;
+  glPathMemoryGlyphIndexArrayNV: function(firstPathName:GLuint; fontTarget:GLenum; fontSize:GLsizeiptr; fontData:pointer; faceIndex:GLsizei;
+             firstGlyphIndex:GLuint; numGlyphs:GLsizei; pathParameterTemplate:GLuint; emScale:GLfloat):GLenum; stdcall;
+  glProgramPathFragmentInputGenNV: procedure(_program:GLuint; location:GLint; genMode:GLenum; components:GLint; coeffs:PGLfloat); stdcall;
+  glGetProgramResourcefvNV: procedure(_program:GLuint; programInterface:GLenum; index:GLuint; propCount:GLsizei; props:PGLenum;
+              count:GLsizei; length:PGLsizei; params:PGLfloat); stdcall;
+  glMatrixFrustumEXT: procedure(mode:GLenum; left:GLdouble; right:GLdouble; bottom:GLdouble; top:GLdouble;
+              zNear:GLdouble; zFar:GLdouble); stdcall;
+  glMatrixLoadIdentityEXT: procedure(mode:GLenum); stdcall;
+  glMatrixLoadTransposefEXT: procedure(mode:GLenum; m:PGLfloat); stdcall;
+  glMatrixLoadTransposedEXT: procedure(mode:GLenum; m:PGLdouble); stdcall;
+  glMatrixLoadfEXT: procedure(mode:GLenum; m:PGLfloat); stdcall;
+  glMatrixLoaddEXT: procedure(mode:GLenum; m:PGLdouble); stdcall;
+  glMatrixMultTransposefEXT: procedure(mode:GLenum; m:PGLfloat); stdcall;
+  glMatrixMultTransposedEXT: procedure(mode:GLenum; m:PGLdouble); stdcall;
+  glMatrixMultfEXT: procedure(mode:GLenum; m:PGLfloat); stdcall;
+  glMatrixMultdEXT: procedure(mode:GLenum; m:PGLdouble); stdcall;
+  glMatrixOrthoEXT: procedure(mode:GLenum; left:GLdouble; right:GLdouble; bottom:GLdouble; top:GLdouble;
+              zNear:GLdouble; zFar:GLdouble); stdcall;
+  glMatrixPopEXT: procedure(mode:GLenum); stdcall;
+  glMatrixPushEXT: procedure(mode:GLenum); stdcall;
+  glMatrixRotatefEXT: procedure(mode:GLenum; angle:GLfloat; x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glMatrixRotatedEXT: procedure(mode:GLenum; angle:GLdouble; x:GLdouble; y:GLdouble; z:GLdouble); stdcall;
+  glMatrixScalefEXT: procedure(mode:GLenum; x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glMatrixScaledEXT: procedure(mode:GLenum; x:GLdouble; y:GLdouble; z:GLdouble); stdcall;
+  glMatrixTranslatefEXT: procedure(mode:GLenum; x:GLfloat; y:GLfloat; z:GLfloat); stdcall;
+  glMatrixTranslatedEXT: procedure(mode:GLenum; x:GLdouble; y:GLdouble; z:GLdouble); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_polygon_mode}
+  glPolygonModeNV: procedure(face:GLenum; mode:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_read_buffer}
+  glReadBufferNV: procedure(mode:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_sample_locations}
+  glFramebufferSampleLocationsfvNV: procedure(target:GLenum; start:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glNamedFramebufferSampleLocationsfvNV: procedure(framebuffer:GLuint; start:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glResolveDepthValuesNV: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_scissor_exclusive}
+  glScissorExclusiveNV: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glScissorExclusiveArrayvNV: procedure(first:GLuint; count:GLsizei; v:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_shading_rate_image}
+  glBindShadingRateImageNV: procedure(texture:GLuint); stdcall;
+  glGetShadingRateImagePaletteNV: procedure(viewport:GLuint; entry:GLuint; rate:PGLenum); stdcall;
+  glGetShadingRateSampleLocationivNV: procedure(rate:GLenum; samples:GLuint; index:GLuint; location:PGLint); stdcall;
+  glShadingRateImageBarrierNV: procedure(synchronize:GLboolean); stdcall;
+  glShadingRateImagePaletteNV: procedure(viewport:GLuint; first:GLuint; count:GLsizei; rates:PGLenum); stdcall;
+  glShadingRateSampleOrderNV: procedure(order:GLenum); stdcall;
+  glShadingRateSampleOrderCustomNV: procedure(rate:GLenum; samples:GLuint; locations:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_timeline_semaphore}
+  glCreateSemaphoresNV: procedure(n:GLsizei; semaphores:PGLuint); stdcall;
+  glSemaphoreParameterivNV: procedure(semaphore:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetSemaphoreParameterivNV: procedure(semaphore:GLuint; pname:GLenum; params:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_viewport_array}
+  glViewportArrayvNV: procedure(first:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glViewportIndexedfNV: procedure(index:GLuint; x:GLfloat; y:GLfloat; w:GLfloat; h:GLfloat); stdcall;
+  glViewportIndexedfvNV: procedure(index:GLuint; v:PGLfloat); stdcall;
+  glScissorArrayvNV: procedure(first:GLuint; count:GLsizei; v:PGLint); stdcall;
+  glScissorIndexedNV: procedure(index:GLuint; left:GLint; bottom:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glScissorIndexedvNV: procedure(index:GLuint; v:PGLint); stdcall;
+  glDepthRangeArrayfvNV: procedure(first:GLuint; count:GLsizei; v:PGLfloat); stdcall;
+  glDepthRangeIndexedfNV: procedure(index:GLuint; n:GLfloat; f:GLfloat); stdcall;
+  glGetFloati_vNV: procedure(target:GLenum; index:GLuint; data:PGLfloat); stdcall;
+  glEnableiNV: procedure(target:GLenum; index:GLuint); stdcall;
+  glDisableiNV: procedure(target:GLenum; index:GLuint); stdcall;
+  glIsEnablediNV: function(target:GLenum; index:GLuint):GLboolean; stdcall;
+{$EndIf}
+
+{$IfDef GL_NV_viewport_swizzle}
+  glViewportSwizzleNV: procedure(index:GLuint; swizzlex:GLenum; swizzley:GLenum; swizzlez:GLenum; swizzlew:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_OVR_multiview}
+  glFramebufferTextureMultiviewOVR: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint; baseViewIndex:GLint;
+              numViews:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_OVR_multiview_multisampled_render_to_texture}
+  glFramebufferTextureMultisampleMultiviewOVR: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint; samples:GLsizei;
+              baseViewIndex:GLint; numViews:GLsizei); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_alpha_test}
+  glAlphaFuncQCOM: procedure(func:GLenum; ref:GLclampf); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_driver_control}
+  glGetDriverControlsQCOM: procedure(num:PGLint; size:GLsizei; driverControls:PGLuint); stdcall;
+  glGetDriverControlStringQCOM: procedure(driverControl:GLuint; bufSize:GLsizei; length:PGLsizei; driverControlString:PGLchar); stdcall;
+  glEnableDriverControlQCOM: procedure(driverControl:GLuint); stdcall;
+  glDisableDriverControlQCOM: procedure(driverControl:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get}
+  glExtGetTexturesQCOM: procedure(textures:PGLuint; maxTextures:GLint; numTextures:PGLint); stdcall;
+  glExtGetBuffersQCOM: procedure(buffers:PGLuint; maxBuffers:GLint; numBuffers:PGLint); stdcall;
+  glExtGetRenderbuffersQCOM: procedure(renderbuffers:PGLuint; maxRenderbuffers:GLint; numRenderbuffers:PGLint); stdcall;
+  glExtGetFramebuffersQCOM: procedure(framebuffers:PGLuint; maxFramebuffers:GLint; numFramebuffers:PGLint); stdcall;
+  glExtGetTexLevelParameterivQCOM: procedure(texture:GLuint; face:GLenum; level:GLint; pname:GLenum; params:PGLint); stdcall;
+  glExtTexObjectStateOverrideiQCOM: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+  glExtGetTexSubImageQCOM: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; _type:GLenum; texels:pointer); stdcall;
+  glExtGetBufferPointervQCOM: procedure(target:GLenum; params:Ppointer); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get2}
+  glExtGetShadersQCOM: procedure(shaders:PGLuint; maxShaders:GLint; numShaders:PGLint); stdcall;
+  glExtGetProgramsQCOM: procedure(programs:PGLuint; maxPrograms:GLint; numPrograms:PGLint); stdcall;
+  glExtIsProgramBinaryQCOM: function(_program:GLuint):GLboolean; stdcall;
+  glExtGetProgramBinarySourceQCOM: procedure(_program:GLuint; shadertype:GLenum; source:PGLchar; length:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_frame_extrapolation}
+  glExtrapolateTex2DQCOM: procedure(src1:GLuint; src2:GLuint; output:GLuint; scaleFactor:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_framebuffer_foveated}
+  glFramebufferFoveationConfigQCOM: procedure(framebuffer:GLuint; numLayers:GLuint; focalPointsPerLayer:GLuint; requestedFeatures:GLuint; providedFeatures:PGLuint); stdcall;
+  glFramebufferFoveationParametersQCOM: procedure(framebuffer:GLuint; layer:GLuint; focalPoint:GLuint; focalX:GLfloat; focalY:GLfloat;
+              gainX:GLfloat; gainY:GLfloat; foveaArea:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_motion_estimation}
+  glTexEstimateMotionQCOM: procedure(ref:GLuint; target:GLuint; output:GLuint); stdcall;
+  glTexEstimateMotionRegionsQCOM: procedure(ref:GLuint; target:GLuint; output:GLuint; mask:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_shader_framebuffer_fetch_noncoherent}
+  glFramebufferFetchBarrierQCOM: procedure; stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_shading_rate}
+  glShadingRateQCOM: procedure(rate:GLenum); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_texture_foveated}
+  glTextureFoveationParametersQCOM: procedure(texture:GLuint; layer:GLuint; focalPoint:GLuint; focalX:GLfloat; focalY:GLfloat;
+              gainX:GLfloat; gainY:GLfloat; foveaArea:GLfloat); stdcall;
+{$EndIf}
+
+{$IfDef GL_QCOM_tiled_rendering}
+  glStartTilingQCOM: procedure(x:GLuint; y:GLuint; width:GLuint; height:GLuint; preserveMask:GLbitfield); stdcall;
+  glEndTilingQCOM: procedure(preserveMask:GLbitfield); stdcall;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_0}
+// GL_NV_read_buffer
+  glReadBuffer: procedure(src:GLenum); stdcall;
+// none
+  glDrawRangeElements: procedure(mode:GLenum; start:GLuint; _end:GLuint; count:GLsizei; _type:GLenum; indices:pointer); stdcall;
+// GL_OES_texture_3D
+  glTexImage3D: procedure(target:GLenum; level:GLint; internalformat:GLint; width:GLsizei; height:GLsizei;
+              depth:GLsizei; border:GLint; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glTexSubImage3D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; _type:GLenum; pixels:pointer); stdcall;
+  glCopyTexSubImage3D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              x:GLint; y:GLint; width:GLsizei; height:GLsizei); stdcall;
+  glCompressedTexImage3D: procedure(target:GLenum; level:GLint; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; border:GLint; imageSize:GLsizei; data:pointer); stdcall;
+  glCompressedTexSubImage3D: procedure(target:GLenum; level:GLint; xoffset:GLint; yoffset:GLint; zoffset:GLint;
+              width:GLsizei; height:GLsizei; depth:GLsizei; format:GLenum; imageSize:GLsizei; data:pointer); stdcall;
+// GL_EXT_disjoint_timer_query
+  glGenQueries: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glDeleteQueries: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glIsQuery: function(id:GLuint):GLboolean; stdcall;
+  glBeginQuery: procedure(target:GLenum; id:GLuint); stdcall;
+  glEndQuery: procedure(target:GLenum); stdcall;
+  glGetQueryiv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetQueryObjectuiv: procedure(id:GLuint; pname:GLenum; params:PGLuint); stdcall;
+// GL_OES_mapbuffer
+  glUnmapBuffer: function(target:GLenum):GLboolean; stdcall;
+  glGetBufferPointerv: procedure(target:GLenum; pname:GLenum; params:Ppointer); stdcall;
+// GL_EXT_draw_buffers + GL_NV_draw_buffers
+  glDrawBuffers: procedure(n:GLsizei; bufs:PGLenum); stdcall;
+// GL_NV_non_square_matrices
+  glUniformMatrix2x3fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix3x2fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix2x4fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix4x2fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix3x4fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glUniformMatrix4x3fv: procedure(location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+// GL_ANGLE_framebuffer_blit + GL_NV_framebuffer_blit
+  glBlitFramebuffer: procedure(srcX0:GLint; srcY0:GLint; srcX1:GLint; srcY1:GLint; dstX0:GLint;
+              dstY0:GLint; dstX1:GLint; dstY1:GLint; mask:GLbitfield; filter:GLenum); stdcall;
+// GL_ANGLE_framebuffer_multisample + GL_APPLE_framebuffer_multisample + GL_EXT_multisampled_render_to_texture +
+//                                  GL_IMG_multisampled_render_to_texture + GL_NV_framebuffer_multisample
+  glRenderbufferStorageMultisample: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+// none
+  glFramebufferTextureLayer: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint; layer:GLint); stdcall;
+// GL_EXT_map_buffer_range
+  glMapBufferRange: function(target:GLenum; offset:GLintptr; length:GLsizeiptr; access:GLbitfield):pointer; stdcall;
+  glFlushMappedBufferRange: procedure(target:GLenum; offset:GLintptr; length:GLsizeiptr); stdcall;
+// GL_OES_vertex_array_object
+  glBindVertexArray: procedure(_array:GLuint); stdcall;
+  glDeleteVertexArrays: procedure(n:GLsizei; arrays:PGLuint); stdcall;
+  glGenVertexArrays: procedure(n:GLsizei; arrays:PGLuint); stdcall;
+  glIsVertexArray: function(_array:GLuint):GLboolean; stdcall;
+// GL_EXT_multiview_draw_buffers
+  glGetIntegeri_v: procedure(target:GLenum; index:GLuint; data:PGLint); stdcall;
+// none
+  glBeginTransformFeedback: procedure(primitiveMode:GLenum); stdcall;
+  glEndTransformFeedback: procedure; stdcall;
+  glBindBufferRange: procedure(target:GLenum; index:GLuint; buffer:GLuint; offset:GLintptr; size:GLsizeiptr); stdcall;
+  glBindBufferBase: procedure(target:GLenum; index:GLuint; buffer:GLuint); stdcall;
+  glTransformFeedbackVaryings: procedure(_program:GLuint; count:GLsizei; varyings:PPGLchar; bufferMode:GLenum); stdcall;
+  glGetTransformFeedbackVarying: procedure(_program:GLuint; index:GLuint; bufSize:GLsizei; length:PGLsizei; size:PGLsizei;
+              _type:PGLenum; name:PGLchar); stdcall;
+  glVertexAttribIPointer: procedure(index:GLuint; size:GLint; _type:GLenum; stride:GLsizei; pointer:pointer); stdcall;
+  glGetVertexAttribIiv: procedure(index:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetVertexAttribIuiv: procedure(index:GLuint; pname:GLenum; params:PGLuint); stdcall;
+  glVertexAttribI4i: procedure(index:GLuint; x:GLint; y:GLint; z:GLint; w:GLint); stdcall;
+  glVertexAttribI4ui: procedure(index:GLuint; x:GLuint; y:GLuint; z:GLuint; w:GLuint); stdcall;
+  glVertexAttribI4iv: procedure(index:GLuint; v:PGLint); stdcall;
+  glVertexAttribI4uiv: procedure(index:GLuint; v:PGLuint); stdcall;
+  glGetUniformuiv: procedure(_program:GLuint; location:GLint; params:PGLuint); stdcall;
+  glGetFragDataLocation: function(_program:GLuint; name:PGLchar):GLint; stdcall;
+  glUniform1ui: procedure(location:GLint; v0:GLuint); stdcall;
+  glUniform2ui: procedure(location:GLint; v0:GLuint; v1:GLuint); stdcall;
+  glUniform3ui: procedure(location:GLint; v0:GLuint; v1:GLuint; v2:GLuint); stdcall;
+  glUniform4ui: procedure(location:GLint; v0:GLuint; v1:GLuint; v2:GLuint; v3:GLuint); stdcall;
+  glUniform1uiv: procedure(location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glUniform2uiv: procedure(location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glUniform3uiv: procedure(location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glUniform4uiv: procedure(location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glClearBufferiv: procedure(buffer:GLenum; drawbuffer:GLint; value:PGLint); stdcall;
+  glClearBufferuiv: procedure(buffer:GLenum; drawbuffer:GLint; value:PGLuint); stdcall;
+  glClearBufferfv: procedure(buffer:GLenum; drawbuffer:GLint; value:PGLfloat); stdcall;
+  glClearBufferfi: procedure(buffer:GLenum; drawbuffer:GLint; depth:GLfloat; stencil:GLint); stdcall;
+  glGetStringi: function(name:GLenum; index:GLuint):PGLubyte; stdcall;
+// GL_NV_copy_buffer
+  glCopyBufferSubData: procedure(readTarget:GLenum; writeTarget:GLenum; readOffset:GLintptr; writeOffset:GLintptr; size:GLsizeiptr); stdcall;
+// none
+  glGetUniformIndices: procedure(_program:GLuint; uniformCount:GLsizei; uniformNames:PPGLchar; uniformIndices:PGLuint); stdcall;
+  glGetActiveUniformsiv: procedure(_program:GLuint; uniformCount:GLsizei; uniformIndices:PGLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetUniformBlockIndex: function(_program:GLuint; uniformBlockName:PGLchar):GLuint; stdcall;
+  glGetActiveUniformBlockiv: procedure(_program:GLuint; uniformBlockIndex:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetActiveUniformBlockName: procedure(_program:GLuint; uniformBlockIndex:GLuint; bufSize:GLsizei; length:PGLsizei; uniformBlockName:PGLchar); stdcall;
+  glUniformBlockBinding: procedure(_program:GLuint; uniformBlockIndex:GLuint; uniformBlockBinding:GLuint); stdcall;
+// GL_ANGLE_instanced_arrays            GL_EXT_draw_instanced              GL_NV_draw_instanced
+  glDrawArraysInstanced: procedure(mode:GLenum; first:GLint; count:GLsizei; instancecount:GLsizei); stdcall;
+  glDrawElementsInstanced: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei); stdcall;
+// GL_APPLE_sync
+  glFenceSync: function(condition:GLenum; flags:GLbitfield):GLsync; stdcall;
+  glIsSync: function(sync:GLsync):GLboolean; stdcall;
+  glDeleteSync: procedure(sync:GLsync); stdcall;
+  glClientWaitSync: function(sync:GLsync; flags:GLbitfield; timeout:GLuint64):GLenum; stdcall;
+  glWaitSync: procedure(sync:GLsync; flags:GLbitfield; timeout:GLuint64); stdcall;
+// GL_APPLE_sync                        GL_EXT_disjoint_timer_query
+  glGetInteger64v: procedure(pname:GLenum; data:PGLint64); stdcall;
+// GL_APPLE_sync
+  glGetSynciv: procedure(sync:GLsync; pname:GLenum; bufSize:GLsizei; length:PGLsizei; values:PGLint); stdcall;
+// none
+  glGetInteger64i_v: procedure(target:GLenum; index:GLuint; data:PGLint64); stdcall;
+  glGetBufferParameteri64v: procedure(target:GLenum; pname:GLenum; params:PGLint64); stdcall;
+  glGenSamplers: procedure(count:GLsizei; samplers:PGLuint); stdcall;
+  glDeleteSamplers: procedure(count:GLsizei; samplers:PGLuint); stdcall;
+  glIsSampler: function(sampler:GLuint):GLboolean; stdcall;
+  glBindSampler: procedure(_unit:GLuint; sampler:GLuint); stdcall;
+  glSamplerParameteri: procedure(sampler:GLuint; pname:GLenum; param:GLint); stdcall;
+  glSamplerParameteriv: procedure(sampler:GLuint; pname:GLenum; param:PGLint); stdcall;
+  glSamplerParameterf: procedure(sampler:GLuint; pname:GLenum; param:GLfloat); stdcall;
+  glSamplerParameterfv: procedure(sampler:GLuint; pname:GLenum; param:PGLfloat); stdcall;
+  glGetSamplerParameteriv: procedure(sampler:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetSamplerParameterfv: procedure(sampler:GLuint; pname:GLenum; params:PGLfloat); stdcall;
+// GL_ANGLE_instanced_arrays            GL_EXT_instanced_arrays       GL_NV_instanced_arrays
+  glVertexAttribDivisor: procedure(index:GLuint; divisor:GLuint); stdcall;
+// none
+  glBindTransformFeedback: procedure(target:GLenum; id:GLuint); stdcall;
+  glDeleteTransformFeedbacks: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glGenTransformFeedbacks: procedure(n:GLsizei; ids:PGLuint); stdcall;
+  glIsTransformFeedback: function(id:GLuint):GLboolean; stdcall;
+  glPauseTransformFeedback: procedure; stdcall;
+  glResumeTransformFeedback: procedure; stdcall;
+// GL_OES_get_program_binary
+  glGetProgramBinary: procedure(_program:GLuint; bufSize:GLsizei; length:PGLsizei; binaryFormat:PGLenum; binary:pointer); stdcall;
+  glProgramBinary: procedure(_program:GLuint; binaryFormat:GLenum; binary:pointer; length:GLsizei); stdcall;
+// GL_EXT_separate_shader_objects
+  glProgramParameteri: procedure(_program:GLuint; pname:GLenum; value:GLint); stdcall;
+// none
+  glInvalidateFramebuffer: procedure(target:GLenum; numAttachments:GLsizei; attachments:PGLenum); stdcall;
+  glInvalidateSubFramebuffer: procedure(target:GLenum; numAttachments:GLsizei; attachments:PGLenum; x:GLint; y:GLint;
+              width:GLsizei; height:GLsizei); stdcall;
+// GL_EXT_texture_storage
+  glTexStorage2D: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei); stdcall;
+  glTexStorage3D: procedure(target:GLenum; levels:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei; depth:GLsizei); stdcall;
+// none
+  glGetInternalformativ: procedure(target:GLenum; internalformat:GLenum; pname:GLenum; bufSize:GLsizei; params:PGLint); stdcall;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_1}
+// none
+  glDispatchCompute: procedure(num_groups_x:GLuint; num_groups_y:GLuint; num_groups_z:GLuint); stdcall;
+  glDispatchComputeIndirect: procedure(indirect:GLintptr); stdcall;
+  glDrawArraysIndirect: procedure(mode:GLenum; indirect:pointer); stdcall;
+  glDrawElementsIndirect: procedure(mode:GLenum; _type:GLenum; indirect:pointer); stdcall;
+// GL_MESA_framebuffer_flip_y
+  glFramebufferParameteri: procedure(target:GLenum; pname:GLenum; param:GLint); stdcall;
+  glGetFramebufferParameteriv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+// none
+  glGetProgramInterfaceiv: procedure(_program:GLuint; programInterface:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetProgramResourceIndex: function(_program:GLuint; programInterface:GLenum; name:PGLchar):GLuint; stdcall;
+  glGetProgramResourceName: procedure(_program:GLuint; programInterface:GLenum; index:GLuint; bufSize:GLsizei; length:PGLsizei; name:PGLchar); stdcall;
+  glGetProgramResourceiv: procedure(_program:GLuint; programInterface:GLenum; index:GLuint; propCount:GLsizei; props:PGLenum;
+              bufSize:GLsizei; length:PGLsizei; params:PGLint); stdcall;
+  glGetProgramResourceLocation: function(_program:GLuint; programInterface:GLenum; name:PGLchar):GLint; stdcall;
+// GL_EXT_separate_shader_objects
+  glUseProgramStages: procedure(pipeline:GLuint; stages:GLbitfield; _program:GLuint); stdcall;
+  glActiveShaderProgram: procedure(pipeline:GLuint; _program:GLuint); stdcall;
+  glCreateShaderProgramv: function(_type:GLenum; count:GLsizei; strings:PPGLchar):GLuint; stdcall;
+  glBindProgramPipeline: procedure(pipeline:GLuint); stdcall;
+  glDeleteProgramPipelines: procedure(n:GLsizei; pipelines:PGLuint); stdcall;
+  glGenProgramPipelines: procedure(n:GLsizei; pipelines:PGLuint); stdcall;
+  glIsProgramPipeline: function(pipeline:GLuint):GLboolean; stdcall;
+  glGetProgramPipelineiv: procedure(pipeline:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glProgramUniform1i: procedure(_program:GLuint; location:GLint; v0:GLint); stdcall;
+  glProgramUniform2i: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint); stdcall;
+  glProgramUniform3i: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint; v2:GLint); stdcall;
+  glProgramUniform4i: procedure(_program:GLuint; location:GLint; v0:GLint; v1:GLint; v2:GLint; v3:GLint); stdcall;
+  glProgramUniform1ui: procedure(_program:GLuint; location:GLint; v0:GLuint); stdcall;
+  glProgramUniform2ui: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint); stdcall;
+  glProgramUniform3ui: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint; v2:GLuint); stdcall;
+  glProgramUniform4ui: procedure(_program:GLuint; location:GLint; v0:GLuint; v1:GLuint; v2:GLuint; v3:GLuint); stdcall;
+  glProgramUniform1f: procedure(_program:GLuint; location:GLint; v0:GLfloat); stdcall;
+  glProgramUniform2f: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat); stdcall;
+  glProgramUniform3f: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat); stdcall;
+  glProgramUniform4f: procedure(_program:GLuint; location:GLint; v0:GLfloat; v1:GLfloat; v2:GLfloat; v3:GLfloat); stdcall;
+  glProgramUniform1iv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform2iv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform3iv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform4iv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLint); stdcall;
+  glProgramUniform1uiv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform2uiv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform3uiv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform4uiv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLuint); stdcall;
+  glProgramUniform1fv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform2fv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform3fv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniform4fv: procedure(_program:GLuint; location:GLint; count:GLsizei; value:PGLfloat); stdcall;
+  glProgramUniformMatrix2fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix2x3fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3x2fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix2x4fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4x2fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix3x4fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glProgramUniformMatrix4x3fv: procedure(_program:GLuint; location:GLint; count:GLsizei; transpose:GLboolean; value:PGLfloat); stdcall;
+  glValidateProgramPipeline: procedure(pipeline:GLuint); stdcall;
+  glGetProgramPipelineInfoLog: procedure(pipeline:GLuint; bufSize:GLsizei; length:PGLsizei; infoLog:PGLchar); stdcall;
+// none
+  glBindImageTexture: procedure(_unit:GLuint; texture:GLuint; level:GLint; layered:GLboolean; layer:GLint;
+              access:GLenum; format:GLenum); stdcall;
+  glGetBooleani_v: procedure(target:GLenum; index:GLuint; data:PGLboolean); stdcall;
+  glMemoryBarrier: procedure(barriers:GLbitfield); stdcall;
+  glMemoryBarrierByRegion: procedure(barriers:GLbitfield); stdcall;
+  glTexStorage2DMultisample: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              fixedsamplelocations:GLboolean); stdcall;
+  glGetMultisamplefv: procedure(pname:GLenum; index:GLuint; val:PGLfloat); stdcall;
+  glSampleMaski: procedure(maskNumber:GLuint; mask:GLbitfield); stdcall;
+  glGetTexLevelParameteriv: procedure(target:GLenum; level:GLint; pname:GLenum; params:PGLint); stdcall;
+  glGetTexLevelParameterfv: procedure(target:GLenum; level:GLint; pname:GLenum; params:PGLfloat); stdcall;
+  glBindVertexBuffer: procedure(bindingindex:GLuint; buffer:GLuint; offset:GLintptr; stride:GLsizei); stdcall;
+  glVertexAttribFormat: procedure(attribindex:GLuint; size:GLint; _type:GLenum; normalized:GLboolean; relativeoffset:GLuint); stdcall;
+  glVertexAttribIFormat: procedure(attribindex:GLuint; size:GLint; _type:GLenum; relativeoffset:GLuint); stdcall;
+  glVertexAttribBinding: procedure(attribindex:GLuint; bindingindex:GLuint); stdcall;
+  glVertexBindingDivisor: procedure(bindingindex:GLuint; divisor:GLuint); stdcall;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_2}
+// GL_KHR_blend_equation_advanced        GL_NV_blend_equation_advanced
+  glBlendBarrier: procedure; stdcall;
+// GL_OES_copy_image                     GL_EXT_copy_image
+  glCopyImageSubData: procedure(srcName:GLuint; srcTarget:GLenum; srcLevel:GLint; srcX:GLint; srcY:GLint;
+              srcZ:GLint; dstName:GLuint; dstTarget:GLenum; dstLevel:GLint; dstX:GLint;
+              dstY:GLint; dstZ:GLint; srcWidth:GLsizei; srcHeight:GLsizei; srcDepth:GLsizei); stdcall;
+// GL_KHR_debug
+  glDebugMessageControl: procedure(source:GLenum; _type:GLenum; severity:GLenum; count:GLsizei; ids:PGLuint; enabled:GLboolean); stdcall;
+  glDebugMessageInsert: procedure(source:GLenum; _type:GLenum; id:GLuint; severity:GLenum; length:GLsizei; buf:PGLchar); stdcall;
+  glDebugMessageCallback: procedure(callback:GLDEBUGPROC; userParam:pointer); stdcall;
+  glGetDebugMessageLog: function(count:GLuint; bufSize:GLsizei; sources:PGLenum; types:PGLenum; ids:PGLuint;
+             severities:PGLenum; lengths:PGLsizei; messageLog:PGLchar):GLuint; stdcall;
+  glPushDebugGroup: procedure(source:GLenum; id:GLuint; length:GLsizei; message:PGLchar); stdcall;
+  glPopDebugGroup: procedure; stdcall;
+  glObjectLabel: procedure(identifier:GLenum; name:GLuint; length:GLsizei; _label:PGLchar); stdcall;
+// GL_KHR_debug                          GL_EXT_debug_label
+  glGetObjectLabel: procedure(identifier:GLenum; name:GLuint; bufSize:GLsizei; length:PGLsizei; _label:PGLchar); stdcall;
+// GL_KHR_debug
+  glObjectPtrLabel: procedure(ptr:pointer; length:GLsizei; _label:PGLchar); stdcall;
+  glGetObjectPtrLabel: procedure(ptr:pointer; bufSize:GLsizei; length:PGLsizei; _label:PGLchar); stdcall;
+  glGetPointerv: procedure(pname:GLenum; params:Ppointer); stdcall;
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glEnablei: procedure(target:GLenum; index:GLuint); stdcall;
+  glDisablei: procedure(target:GLenum; index:GLuint); stdcall;
+// GL_OES_draw_buffers_indexed
+  glBlendEquationi: procedure(buf:GLuint; mode:GLenum); stdcall;
+  glBlendEquationSeparatei: procedure(buf:GLuint; modeRGB:GLenum; modeAlpha:GLenum); stdcall;
+  glBlendFunci: procedure(buf:GLuint; src:GLenum; dst:GLenum); stdcall;
+  glBlendFuncSeparatei: procedure(buf:GLuint; srcRGB:GLenum; dstRGB:GLenum; srcAlpha:GLenum; dstAlpha:GLenum); stdcall;
+  glColorMaski: procedure(index:GLuint; r:GLboolean; g:GLboolean; b:GLboolean; a:GLboolean); stdcall;
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glIsEnabledi: function(target:GLenum; index:GLuint):GLboolean; stdcall;
+// GL_OES_draw_elements_base_vertex      GL_EXT_draw_elements_base_vertex
+  glDrawElementsBaseVertex: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; basevertex:GLint); stdcall;
+  glDrawRangeElementsBaseVertex: procedure(mode:GLenum; start:GLuint; _end:GLuint; count:GLsizei; _type:GLenum;
+              indices:pointer; basevertex:GLint); stdcall;
+  glDrawElementsInstancedBaseVertex: procedure(mode:GLenum; count:GLsizei; _type:GLenum; indices:pointer; instancecount:GLsizei;
+              basevertex:GLint); stdcall;
+// GL_OES_geometry_shader                GL_EXT_geometry_shader
+  glFramebufferTexture: procedure(target:GLenum; attachment:GLenum; texture:GLuint; level:GLint); stdcall;
+// GL_OES_primitive_bounding_box         GL_EXT_primitive_bounding_box
+  glPrimitiveBoundingBox: procedure(minX:GLfloat; minY:GLfloat; minZ:GLfloat; minW:GLfloat; maxX:GLfloat;
+              maxY:GLfloat; maxZ:GLfloat; maxW:GLfloat); stdcall;
+// GL_KHR_robustness                     GL_EXT_robustness
+  glGetGraphicsResetStatus: function: GLenum; stdcall;
+  glReadnPixels: procedure(x:GLint; y:GLint; width:GLsizei; height:GLsizei; format:GLenum;
+              _type:GLenum; bufSize:GLsizei; data:pointer); stdcall;
+  glGetnUniformfv: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLfloat); stdcall;
+  glGetnUniformiv: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLint); stdcall;
+// GL_KHR_robustness
+  glGetnUniformuiv: procedure(_program:GLuint; location:GLint; bufSize:GLsizei; params:PGLuint); stdcall;
+// GL_OES_sample_shading
+  glMinSampleShading: procedure(value:GLfloat); stdcall;
+// GL_OES_tessellation_shader            GL_EXT_tessellation_shader
+  glPatchParameteri: procedure(pname:GLenum; value:GLint); stdcall;
+// GL_OES_texture_border_clamp           GL_EXT_texture_border_clamp
+  glTexParameterIiv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glTexParameterIuiv: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glGetTexParameterIiv: procedure(target:GLenum; pname:GLenum; params:PGLint); stdcall;
+  glGetTexParameterIuiv: procedure(target:GLenum; pname:GLenum; params:PGLuint); stdcall;
+  glSamplerParameterIiv: procedure(sampler:GLuint; pname:GLenum; param:PGLint); stdcall;
+  glSamplerParameterIuiv: procedure(sampler:GLuint; pname:GLenum; param:PGLuint); stdcall;
+  glGetSamplerParameterIiv: procedure(sampler:GLuint; pname:GLenum; params:PGLint); stdcall;
+  glGetSamplerParameterIuiv: procedure(sampler:GLuint; pname:GLenum; params:PGLuint); stdcall;
+// GL_OES_texture_buffer                 GL_EXT_texture_buffer
+  glTexBuffer: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint); stdcall;
+  glTexBufferRange: procedure(target:GLenum; internalformat:GLenum; buffer:GLuint; offset:GLintptr; size:GLsizeiptr); stdcall;
+// GL_OES_texture_storage_multisample_2d_array
+  glTexStorage3DMultisample: procedure(target:GLenum; samples:GLsizei; internalformat:GLenum; width:GLsizei; height:GLsizei;
+              depth:GLsizei; fixedsamplelocations:GLboolean); stdcall;
+{$EndIf}
+
+procedure AllCheckGLExtension;
+function LoadOpenGLES: Boolean;
+procedure FreeOpenGLES;
+
+
+implementation
+
+uses
+  zgl_opengles,
+  zgl_opengles_all;
+
+procedure AllCheckGLExtension;
+begin
+  GL_VERSION_ES_CM_1_0 := gl_IsSupported('GL_VERSION_ES_CM_1_0', oglExtensions);
+  GL_ES_VERSION_2_0 := gl_IsSupported('GL_ES_VERSION_2_0', oglExtensions);
+  GL_ES_VERSION_3_0 := gl_IsSupported('GL_ES_VERSION_3_0', oglExtensions);
+  GL_ES_VERSION_3_1 := gl_IsSupported('GL_ES_VERSION_3_1', oglExtensions);
+  GL_ES_VERSION_3_2 := gl_IsSupported('GL_ES_VERSION_3_2', oglExtensions);
+  {$IfDef GL_VERSION_ES_CM_1_0}
+  GL_OES_compressed_paletted_texture := gl_IsSupported('GL_OES_compressed_paletted_texture', oglExtensions);
+  GL_OES_point_size_array := gl_IsSupported('GL_OES_point_size_array', oglExtensions);
+  GL_OES_point_sprite := gl_IsSupported('GL_OES_point_sprite', oglExtensions);
+  GL_KHR_debug := gl_IsSupported('GL_KHR_debug', oglExtensions);
+  GL_OES_EGL_image := gl_IsSupported('GL_OES_EGL_image', oglExtensions);
+  GL_OES_EGL_image_external := gl_IsSupported('GL_OES_EGL_image_external', oglExtensions);
+  GL_OES_blend_equation_separate := gl_IsSupported('GL_OES_blend_equation_separate', oglExtensions);
+//  GL_OES_blend_func_separate := gl_IsSupported('GL_OES_blend_func_separate', oglExtensions);
+  GL_OES_blend_subtract := gl_IsSupported('GL_OES_blend_subtract', oglExtensions);
+  GL_OES_byte_coordinates := gl_IsSupported('GL_OES_byte_coordinates', oglExtensions);
+  GL_OES_compressed_ETC1_RGB8_sub_texture := gl_IsSupported('GL_OES_compressed_ETC1_RGB8_sub_texture', oglExtensions);
+  GL_OES_compressed_ETC1_RGB8_texture := gl_IsSupported('GL_OES_compressed_ETC1_RGB8_texture', oglExtensions);
+//  GL_OES_depth24 := gl_IsSupported('GL_OES_depth24', oglExtensions);
+//  GL_OES_depth32 := gl_IsSupported('GL_OES_depth32', oglExtensions);
+  GL_OES_draw_texture := gl_IsSupported('GL_OES_draw_texture', oglExtensions);
+  GL_OES_element_index_uint := gl_IsSupported('GL_OES_element_index_uint', oglExtensions);
+  GL_OES_extended_matrix_palette := gl_IsSupported('GL_OES_extended_matrix_palette', oglExtensions);
+  GL_OES_fbo_render_mipmap := gl_IsSupported('GL_OES_fbo_render_mipmap', oglExtensions);
+  GL_OES_fixed_point := gl_IsSupported('GL_OES_fixed_point', oglExtensions);
+//  GL_OES_framebuffer_object := gl_IsSupported('GL_OES_framebuffer_object', oglExtensions);
+  GL_OES_mapbuffer := gl_IsSupported('GL_OES_mapbuffer', oglExtensions);
+  GL_OES_matrix_get := gl_IsSupported('GL_OES_matrix_get', oglExtensions);
+  GL_OES_matrix_palette := gl_IsSupported('GL_OES_matrix_palette', oglExtensions);
+  GL_OES_packed_depth_stencil := gl_IsSupported('GL_OES_packed_depth_stencil', oglExtensions);
+  GL_OES_query_matrix := gl_IsSupported('GL_OES_query_matrix', oglExtensions);
+  GL_OES_required_internalformat := gl_IsSupported('GL_OES_required_internalformat', oglExtensions);
+  GL_OES_rgb8_rgba8 := gl_IsSupported('GL_OES_rgb8_rgba8', oglExtensions);
+  GL_OES_single_precision := gl_IsSupported('GL_OES_single_precision', oglExtensions);
+  GL_OES_stencil1 := gl_IsSupported('GL_OES_stencil1', oglExtensions);
+  GL_OES_stencil4 := gl_IsSupported('GL_OES_stencil4', oglExtensions);
+  GL_OES_stencil8 := gl_IsSupported('GL_OES_stencil8', oglExtensions);
+  GL_OES_stencil_wrap := gl_IsSupported('GL_OES_stencil_wrap', oglExtensions);
+  GL_OES_surfaceless_context := gl_IsSupported('GL_OES_surfaceless_context', oglExtensions);
+  GL_OES_texture_cube_map := gl_IsSupported('GL_OES_texture_cube_map', oglExtensions);
+  GL_OES_texture_env_crossbar := gl_IsSupported('GL_OES_texture_env_crossbar', oglExtensions);
+  GL_OES_texture_mirrored_repeat := gl_IsSupported('GL_OES_texture_mirrored_repeat', oglExtensions);
+  GL_OES_texture_npot := gl_IsSupported('GL_OES_texture_npot', oglExtensions);
+  GL_OES_vertex_array_object := gl_IsSupported('GL_OES_vertex_array_object', oglExtensions);
+  GL_AMD_compressed_3DC_texture := gl_IsSupported('GL_AMD_compressed_3DC_texture', oglExtensions);
+  GL_AMD_compressed_ATC_texture := gl_IsSupported('GL_AMD_compressed_ATC_texture', oglExtensions);
+  GL_APPLE_copy_texture_levels := gl_IsSupported('GL_APPLE_copy_texture_levels', oglExtensions);
+  GL_APPLE_framebuffer_multisample := gl_IsSupported('GL_APPLE_framebuffer_multisample', oglExtensions);
+  GL_APPLE_sync := gl_IsSupported('GL_APPLE_sync', oglExtensions);
+  GL_APPLE_texture_2D_limited_npot := gl_IsSupported('GL_APPLE_texture_2D_limited_npot', oglExtensions);
+  GL_APPLE_texture_format_BGRA8888 := gl_IsSupported('GL_APPLE_texture_format_BGRA8888', oglExtensions);
+  GL_APPLE_texture_max_level := gl_IsSupported('GL_APPLE_texture_max_level', oglExtensions);
+  GL_ARM_rgba8 := gl_IsSupported('GL_ARM_rgba8', oglExtensions);
+  GL_EXT_blend_minmax := gl_IsSupported('GL_EXT_blend_minmax', oglExtensions);
+  GL_EXT_debug_marker := gl_IsSupported('GL_EXT_debug_marker', oglExtensions);
+  GL_EXT_discard_framebuffer := gl_IsSupported('GL_EXT_discard_framebuffer', oglExtensions);
+  GL_EXT_map_buffer_range := gl_IsSupported('GL_EXT_map_buffer_range', oglExtensions);
+  GL_EXT_multi_draw_arrays := gl_IsSupported('GL_EXT_multi_draw_arrays', oglExtensions);
+  GL_EXT_multisampled_render_to_texture := gl_IsSupported('GL_EXT_multisampled_render_to_texture', oglExtensions);
+  GL_EXT_read_format_bgra := gl_IsSupported('GL_EXT_read_format_bgra', oglExtensions);
+  GL_EXT_robustness := gl_IsSupported('GL_EXT_robustness', oglExtensions);
+  GL_EXT_sRGB := gl_IsSupported('GL_EXT_sRGB', oglExtensions);
+  GL_EXT_texture_compression_dxt1 := gl_IsSupported('GL_EXT_texture_compression_dxt1', oglExtensions);
+//  GL_EXT_texture_filter_anisotropic := gl_IsSupported('GL_EXT_texture_filter_anisotropic', oglExtensions);
+  GL_EXT_texture_format_BGRA8888 := gl_IsSupported('GL_EXT_texture_format_BGRA8888', oglExtensions);
+  GL_EXT_texture_lod_bias := gl_IsSupported('GL_EXT_texture_lod_bias', oglExtensions);
+  GL_EXT_texture_storage := gl_IsSupported('GL_EXT_texture_storage', oglExtensions);
+  GL_IMG_multisampled_render_to_texture := gl_IsSupported('GL_IMG_multisampled_render_to_texture', oglExtensions);
+  GL_IMG_read_format := gl_IsSupported('GL_IMG_read_format', oglExtensions);
+//  GL_IMG_texture_compression_pvrtc := gl_IsSupported('GL_IMG_texture_compression_pvrtc', oglExtensions);
+  GL_IMG_texture_env_enhanced_fixed_function := gl_IsSupported('GL_IMG_texture_env_enhanced_fixed_function', oglExtensions);
+  GL_IMG_user_clip_plane := gl_IsSupported('GL_IMG_user_clip_plane', oglExtensions);
+  GL_NV_fence := gl_IsSupported('GL_NV_fence', oglExtensions);
+  GL_QCOM_driver_control := gl_IsSupported('GL_QCOM_driver_control', oglExtensions);
+  GL_QCOM_extended_get := gl_IsSupported('GL_QCOM_extended_get', oglExtensions);
+  GL_QCOM_extended_get2 := gl_IsSupported('GL_QCOM_extended_get2', oglExtensions);
+  GL_QCOM_perfmon_global_mode := gl_IsSupported('GL_QCOM_perfmon_global_mode', oglExtensions);
+  GL_QCOM_tiled_rendering := gl_IsSupported('GL_QCOM_tiled_rendering', oglExtensions);
+  GL_QCOM_writeonly_rendering := gl_IsSupported('GL_QCOM_writeonly_rendering', oglExtensions);
+{$EndIf}
+
+{$IFDEF GL_ES_EXT_VERSION_2_0}
+  GL_KHR_blend_equation_advanced := gl_IsSupported('GL_KHR_blend_equation_advanced', oglExtensions);
+  GL_KHR_blend_equation_advanced_coherent := gl_IsSupported('GL_KHR_blend_equation_advanced_coherent', oglExtensions);
+  GL_KHR_context_flush_control := gl_IsSupported('GL_KHR_context_flush_control', oglExtensions);
+  GL_KHR_debug := gl_IsSupported('GL_KHR_debug', oglExtensions);
+  GL_KHR_no_error := gl_IsSupported('GL_KHR_no_error', oglExtensions);
+  GL_KHR_parallel_shader_compile := gl_IsSupported('GL_KHR_parallel_shader_compile', oglExtensions);
+  GL_KHR_robust_buffer_access_behavior := gl_IsSupported('GL_KHR_robust_buffer_access_behavior', oglExtensions);
+  GL_KHR_robustness := gl_IsSupported('GL_KHR_robustness', oglExtensions);
+  GL_KHR_shader_subgroup := gl_IsSupported('GL_KHR_shader_subgroup', oglExtensions);
+  GL_KHR_texture_compression_astc_hdr := gl_IsSupported('GL_KHR_texture_compression_astc_hdr', oglExtensions);
+  GL_KHR_texture_compression_astc_ldr := gl_IsSupported('GL_KHR_texture_compression_astc_ldr', oglExtensions);
+  GL_KHR_texture_compression_astc_sliced_3d := gl_IsSupported('GL_KHR_texture_compression_astc_sliced_3d', oglExtensions);
+  GL_OES_EGL_image := gl_IsSupported('GL_OES_EGL_image', oglExtensions);
+  GL_OES_EGL_image_external := gl_IsSupported('GL_OES_EGL_image_external', oglExtensions);
+  GL_OES_EGL_image_external_essl3 := gl_IsSupported('GL_OES_EGL_image_external_essl3', oglExtensions);
+  GL_OES_compressed_ETC1_RGB8_sub_texture := gl_IsSupported('GL_OES_compressed_ETC1_RGB8_sub_texture', oglExtensions);
+  GL_OES_compressed_ETC1_RGB8_texture := gl_IsSupported('GL_OES_compressed_ETC1_RGB8_texture', oglExtensions);
+  GL_OES_compressed_paletted_texture := gl_IsSupported('GL_OES_compressed_paletted_texture', oglExtensions);
+  GL_OES_copy_image := gl_IsSupported('GL_OES_copy_image', oglExtensions);
+//  GL_OES_depth24 := gl_IsSupported('GL_OES_depth24', oglExtensions);
+//  GL_OES_depth32 := gl_IsSupported('GL_OES_depth32', oglExtensions);
+  GL_OES_depth_texture := gl_IsSupported('GL_OES_depth_texture', oglExtensions);
+  GL_OES_draw_buffers_indexed := gl_IsSupported('GL_OES_draw_buffers_indexed', oglExtensions);
+  GL_OES_draw_elements_base_vertex := gl_IsSupported('GL_OES_draw_elements_base_vertex', oglExtensions);
+  GL_OES_element_index_uint := gl_IsSupported('GL_OES_element_index_uint', oglExtensions);
+  GL_OES_fbo_render_mipmap := gl_IsSupported('GL_OES_fbo_render_mipmap', oglExtensions);
+  GL_OES_fragment_precision_high := gl_IsSupported('GL_OES_fragment_precision_high', oglExtensions);
+  GL_OES_geometry_point_size := gl_IsSupported('GL_OES_geometry_point_size', oglExtensions);
+  GL_OES_geometry_shader := gl_IsSupported('GL_OES_geometry_shader', oglExtensions);
+  GL_OES_get_program_binary := gl_IsSupported('GL_OES_get_program_binary', oglExtensions);
+  GL_OES_gpu_shader5 := gl_IsSupported('GL_OES_gpu_shader5', oglExtensions);
+  GL_OES_mapbuffer := gl_IsSupported('GL_OES_mapbuffer', oglExtensions);
+  GL_OES_packed_depth_stencil := gl_IsSupported('GL_OES_packed_depth_stencil', oglExtensions);
+  GL_OES_primitive_bounding_box := gl_IsSupported('GL_OES_primitive_bounding_box', oglExtensions);
+  GL_OES_required_internalformat := gl_IsSupported('GL_OES_required_internalformat', oglExtensions);
+  GL_OES_rgb8_rgba8 := gl_IsSupported('GL_OES_rgb8_rgba8', oglExtensions);
+  GL_OES_sample_shading := gl_IsSupported('GL_OES_sample_shading', oglExtensions);
+  GL_OES_sample_variables := gl_IsSupported('GL_OES_sample_variables', oglExtensions);
+  GL_OES_shader_image_atomic := gl_IsSupported('GL_OES_shader_image_atomic', oglExtensions);
+  GL_OES_shader_io_blocks := gl_IsSupported('GL_OES_shader_io_blocks', oglExtensions);
+  GL_OES_shader_multisample_interpolation := gl_IsSupported('GL_OES_shader_multisample_interpolation', oglExtensions);
+  GL_OES_standard_derivatives := gl_IsSupported('GL_OES_standard_derivatives', oglExtensions);
+  GL_OES_stencil1 := gl_IsSupported('GL_OES_stencil1', oglExtensions);
+  GL_OES_stencil4 := gl_IsSupported('GL_OES_stencil4', oglExtensions);
+  GL_OES_surfaceless_context := gl_IsSupported('GL_OES_surfaceless_context', oglExtensions);
+  GL_OES_tessellation_point_size := gl_IsSupported('GL_OES_tessellation_point_size', oglExtensions);
+  GL_OES_tessellation_shader := gl_IsSupported('GL_OES_tessellation_shader', oglExtensions);
+  GL_OES_texture_3D := gl_IsSupported('GL_OES_texture_3D', oglExtensions);
+  GL_OES_texture_border_clamp := gl_IsSupported('GL_OES_texture_border_clamp', oglExtensions);
+  GL_OES_texture_buffer := gl_IsSupported('GL_OES_texture_buffer', oglExtensions);
+  GL_OES_texture_compression_astc := gl_IsSupported('GL_OES_texture_compression_astc', oglExtensions);
+  GL_OES_texture_cube_map_array := gl_IsSupported('GL_OES_texture_cube_map_array', oglExtensions);
+  GL_OES_texture_float := gl_IsSupported('GL_OES_texture_float', oglExtensions);
+  GL_OES_texture_float_linear := gl_IsSupported('GL_OES_texture_float_linear', oglExtensions);
+  GL_OES_texture_half_float := gl_IsSupported('GL_OES_texture_half_float', oglExtensions);
+  GL_OES_texture_half_float_linear := gl_IsSupported('GL_OES_texture_half_float_linear', oglExtensions);
+  GL_OES_texture_npot := gl_IsSupported('GL_OES_texture_npot', oglExtensions);
+  GL_OES_texture_stencil8 := gl_IsSupported('GL_OES_texture_stencil8', oglExtensions);
+  GL_OES_texture_storage_multisample_2d_array := gl_IsSupported('GL_OES_texture_storage_multisample_2d_array', oglExtensions);
+  GL_OES_texture_view := gl_IsSupported('GL_OES_texture_view', oglExtensions);
+  GL_OES_vertex_array_object := gl_IsSupported('GL_OES_vertex_array_object', oglExtensions);
+  GL_OES_vertex_half_float := gl_IsSupported('GL_OES_vertex_half_float', oglExtensions);
+  GL_OES_vertex_type_10_10_10_2 := gl_IsSupported('GL_OES_vertex_type_10_10_10_2', oglExtensions);
+  GL_OES_viewport_array := gl_IsSupported('GL_OES_viewport_array', oglExtensions);
+  GL_AMD_compressed_3DC_texture := gl_IsSupported('GL_AMD_compressed_3DC_texture', oglExtensions);
+  GL_AMD_compressed_ATC_texture := gl_IsSupported('GL_AMD_compressed_ATC_texture', oglExtensions);
+  GL_AMD_framebuffer_multisample_advanced := gl_IsSupported('GL_AMD_framebuffer_multisample_advanced', oglExtensions);
+  GL_AMD_performance_monitor := gl_IsSupported('GL_AMD_performance_monitor', oglExtensions);
+  GL_AMD_program_binary_Z400 := gl_IsSupported('GL_AMD_program_binary_Z400', oglExtensions);
+  GL_ANDROID_extension_pack_es31a := gl_IsSupported('GL_ANDROID_extension_pack_es31a', oglExtensions);
+  GL_ANGLE_depth_texture := gl_IsSupported('GL_ANGLE_depth_texture', oglExtensions);
+  GL_ANGLE_framebuffer_blit := gl_IsSupported('GL_ANGLE_framebuffer_blit', oglExtensions);
+  GL_ANGLE_framebuffer_multisample := gl_IsSupported('GL_ANGLE_framebuffer_multisample', oglExtensions);
+  GL_ANGLE_instanced_arrays := gl_IsSupported('GL_ANGLE_instanced_arrays', oglExtensions);
+  GL_ANGLE_pack_reverse_row_order := gl_IsSupported('GL_ANGLE_pack_reverse_row_order', oglExtensions);
+  GL_ANGLE_program_binary := gl_IsSupported('GL_ANGLE_program_binary', oglExtensions);
+  GL_ANGLE_texture_compression_dxt3 := gl_IsSupported('GL_ANGLE_texture_compression_dxt3', oglExtensions);
+  GL_ANGLE_texture_compression_dxt5 := gl_IsSupported('GL_ANGLE_texture_compression_dxt5', oglExtensions);
+  GL_ANGLE_texture_usage := gl_IsSupported('GL_ANGLE_texture_usage', oglExtensions);
+  GL_ANGLE_translated_shader_source := gl_IsSupported('GL_ANGLE_translated_shader_source', oglExtensions);
+  GL_APPLE_clip_distance := gl_IsSupported('GL_APPLE_clip_distance', oglExtensions);
+  GL_APPLE_color_buffer_packed_float := gl_IsSupported('GL_APPLE_color_buffer_packed_float', oglExtensions);
+  GL_APPLE_copy_texture_levels := gl_IsSupported('GL_APPLE_copy_texture_levels', oglExtensions);
+  GL_APPLE_framebuffer_multisample := gl_IsSupported('GL_APPLE_framebuffer_multisample', oglExtensions);
+  GL_APPLE_rgb_422 := gl_IsSupported('GL_APPLE_rgb_422', oglExtensions);
+  GL_APPLE_sync := gl_IsSupported('GL_APPLE_sync', oglExtensions);
+  GL_APPLE_texture_format_BGRA8888 := gl_IsSupported('GL_APPLE_texture_format_BGRA8888', oglExtensions);
+  GL_APPLE_texture_max_level := gl_IsSupported('GL_APPLE_texture_max_level', oglExtensions);
+  GL_APPLE_texture_packed_float := gl_IsSupported('GL_APPLE_texture_packed_float', oglExtensions);
+  GL_ARM_mali_program_binary := gl_IsSupported('GL_ARM_mali_program_binary', oglExtensions);
+  GL_ARM_mali_shader_binary := gl_IsSupported('GL_ARM_mali_shader_binary', oglExtensions);
+  GL_ARM_rgba8 := gl_IsSupported('GL_ARM_rgba8', oglExtensions);
+  GL_ARM_shader_framebuffer_fetch := gl_IsSupported('GL_ARM_shader_framebuffer_fetch', oglExtensions);
+  GL_ARM_shader_framebuffer_fetch_depth_stencil := gl_IsSupported('GL_ARM_shader_framebuffer_fetch_depth_stencil', oglExtensions);
+  GL_ARM_texture_unnormalized_coordinates := gl_IsSupported('GL_ARM_texture_unnormalized_coordinates', oglExtensions);
+  GL_DMP_program_binary := gl_IsSupported('GL_DMP_program_binary', oglExtensions);
+  GL_DMP_shader_binary := gl_IsSupported('GL_DMP_shader_binary', oglExtensions);
+  GL_EXT_EGL_image_array := gl_IsSupported('GL_EXT_EGL_image_array', oglExtensions);
+  GL_EXT_EGL_image_storage := gl_IsSupported('GL_EXT_EGL_image_storage', oglExtensions);
+  GL_EXT_EGL_image_storage_compression := gl_IsSupported('GL_EXT_EGL_image_storage_compression', oglExtensions);
+  GL_EXT_YUV_target := gl_IsSupported('GL_EXT_YUV_target', oglExtensions);
+  GL_EXT_base_instance := gl_IsSupported('GL_EXT_base_instance', oglExtensions);
+  GL_EXT_blend_func_extended := gl_IsSupported('GL_EXT_blend_func_extended', oglExtensions);
+  GL_EXT_blend_minmax := gl_IsSupported('GL_EXT_blend_minmax', oglExtensions);
+  GL_EXT_buffer_storage := gl_IsSupported('GL_EXT_buffer_storage', oglExtensions);
+  GL_EXT_clear_texture := gl_IsSupported('GL_EXT_clear_texture', oglExtensions);
+  GL_EXT_clip_control := gl_IsSupported('GL_EXT_clip_control', oglExtensions);
+  GL_EXT_clip_cull_distance := gl_IsSupported('GL_EXT_clip_cull_distance', oglExtensions);
+  GL_EXT_color_buffer_float := gl_IsSupported('GL_EXT_color_buffer_float', oglExtensions);
+  GL_EXT_color_buffer_half_float := gl_IsSupported('GL_EXT_color_buffer_half_float', oglExtensions);
+  GL_EXT_conservative_depth := gl_IsSupported('GL_EXT_conservative_depth', oglExtensions);
+  GL_EXT_copy_image := gl_IsSupported('GL_EXT_copy_image', oglExtensions);
+  GL_EXT_debug_label := gl_IsSupported('GL_EXT_debug_label', oglExtensions);
+  GL_EXT_debug_marker := gl_IsSupported('GL_EXT_debug_marker', oglExtensions);
+  GL_EXT_depth_clamp := gl_IsSupported('GL_EXT_depth_clamp', oglExtensions);
+  GL_EXT_discard_framebuffer := gl_IsSupported('GL_EXT_discard_framebuffer', oglExtensions);
+  GL_EXT_disjoint_timer_query := gl_IsSupported('GL_EXT_disjoint_timer_query', oglExtensions);
+  GL_EXT_draw_buffers := gl_IsSupported('GL_EXT_draw_buffers', oglExtensions);
+  GL_EXT_draw_elements_base_vertex := gl_IsSupported('GL_EXT_draw_elements_base_vertex', oglExtensions);
+  GL_EXT_draw_instanced := gl_IsSupported('GL_EXT_draw_instanced', oglExtensions);
+  GL_EXT_draw_transform_feedback := gl_IsSupported('GL_EXT_draw_transform_feedback', oglExtensions);
+  GL_EXT_external_buffer := gl_IsSupported('GL_EXT_external_buffer', oglExtensions);
+  GL_EXT_float_blend := gl_IsSupported('v', oglExtensions);
+  GL_EXT_fragment_shading_rate := gl_IsSupported('GL_EXT_fragment_shading_rate', oglExtensions);
+  GL_EXT_framebuffer_blit_layers := gl_IsSupported('GL_EXT_framebuffer_blit_layers', oglExtensions);
+  GL_EXT_geometry_point_size := gl_IsSupported('GL_EXT_geometry_point_size', oglExtensions);
+  GL_EXT_geometry_shader := gl_IsSupported('GL_EXT_geometry_shader', oglExtensions);
+  GL_EXT_gpu_shader5 := gl_IsSupported('GL_EXT_gpu_shader5', oglExtensions);
+  GL_EXT_instanced_arrays := gl_IsSupported('GL_EXT_instanced_arrays', oglExtensions);
+  GL_EXT_map_buffer_range := gl_IsSupported('GL_EXT_map_buffer_range', oglExtensions);
+  GL_EXT_memory_object := gl_IsSupported('GL_EXT_memory_object', oglExtensions);
+  GL_EXT_memory_object_fd := gl_IsSupported('GL_EXT_memory_object_fd', oglExtensions);
+  GL_EXT_memory_object_win32 := gl_IsSupported('GL_EXT_memory_object_win32', oglExtensions);
+  GL_EXT_multi_draw_arrays := gl_IsSupported('GL_EXT_multi_draw_arrays', oglExtensions);
+  GL_EXT_multi_draw_indirect := gl_IsSupported('GL_EXT_multi_draw_indirect', oglExtensions);
+  GL_EXT_multisampled_compatibility := gl_IsSupported('GL_EXT_multisampled_compatibility', oglExtensions);
+  GL_EXT_multisampled_render_to_texture := gl_IsSupported('GL_EXT_multisampled_render_to_texture', oglExtensions);
+  GL_EXT_multisampled_render_to_texture2 := gl_IsSupported('GL_EXT_multisampled_render_to_texture2', oglExtensions);
+  GL_EXT_multiview_draw_buffers := gl_IsSupported('GL_EXT_multiview_draw_buffers', oglExtensions);
+  GL_EXT_multiview_tessellation_geometry_shader := gl_IsSupported('GL_EXT_multiview_tessellation_geometry_shader', oglExtensions);
+  GL_EXT_multiview_texture_multisample := gl_IsSupported('GL_EXT_multiview_texture_multisample', oglExtensions);
+  GL_EXT_multiview_timer_query := gl_IsSupported('GL_EXT_multiview_timer_query', oglExtensions);
+  GL_EXT_occlusion_query_boolean := gl_IsSupported('GL_EXT_occlusion_query_boolean', oglExtensions);
+  GL_EXT_polygon_offset_clamp := gl_IsSupported('GL_EXT_polygon_offset_clamp', oglExtensions);
+  GL_EXT_post_depth_coverage := gl_IsSupported('GL_EXT_post_depth_coverage', oglExtensions);
+  GL_EXT_primitive_bounding_box := gl_IsSupported('GL_EXT_primitive_bounding_box', oglExtensions);
+  GL_EXT_protected_textures := gl_IsSupported('v', oglExtensions);
+  GL_EXT_pvrtc_sRGB := gl_IsSupported('GL_EXT_pvrtc_sRGB', oglExtensions);
+  GL_EXT_raster_multisample := gl_IsSupported('GL_EXT_raster_multisample', oglExtensions);
+  GL_EXT_read_format_bgra := gl_IsSupported('GL_EXT_read_format_bgra', oglExtensions);
+  GL_EXT_render_snorm := gl_IsSupported('GL_EXT_render_snorm', oglExtensions);
+  GL_EXT_robustness := gl_IsSupported('GL_EXT_robustness', oglExtensions);
+  GL_EXT_sRGB := gl_IsSupported('GL_EXT_sRGB', oglExtensions);
+  GL_EXT_sRGB_write_control := gl_IsSupported('GL_EXT_sRGB_write_control', oglExtensions);
+  GL_EXT_semaphore := gl_IsSupported('GL_EXT_semaphore', oglExtensions);
+  GL_EXT_semaphore_fd := gl_IsSupported('GL_EXT_semaphore_fd', oglExtensions);
+  GL_EXT_semaphore_win32 := gl_IsSupported('GL_EXT_semaphore_win32', oglExtensions);
+  GL_EXT_separate_depth_stencil := gl_IsSupported('GL_EXT_separate_depth_stencil', oglExtensions);
+  GL_EXT_separate_shader_objects := gl_IsSupported('GL_EXT_separate_shader_objects', oglExtensions);
+  GL_EXT_shader_framebuffer_fetch := gl_IsSupported('GL_EXT_shader_framebuffer_fetch', oglExtensions);
+  GL_EXT_shader_framebuffer_fetch_non_coherent := gl_IsSupported('GL_EXT_shader_framebuffer_fetch_non_coherent', oglExtensions);
+  GL_EXT_shader_group_vote := gl_IsSupported('GL_EXT_shader_group_vote', oglExtensions);
+  GL_EXT_shader_implicit_conversions := gl_IsSupported('GL_EXT_shader_implicit_conversions', oglExtensions);
+  GL_EXT_shader_integer_mix := gl_IsSupported('GL_EXT_shader_integer_mix', oglExtensions);
+  GL_EXT_shader_io_blocks := gl_IsSupported('GL_EXT_shader_io_blocks', oglExtensions);
+  GL_EXT_shader_non_constant_global_initializers := gl_IsSupported('GL_EXT_shader_non_constant_global_initializers', oglExtensions);
+  GL_EXT_shader_pixel_local_storage := gl_IsSupported('GL_EXT_shader_pixel_local_storage', oglExtensions);
+  GL_EXT_shader_pixel_local_storage2 := gl_IsSupported('GL_EXT_shader_pixel_local_storage2', oglExtensions);
+  GL_EXT_shader_samples_identical := gl_IsSupported('GL_EXT_shader_samples_identical', oglExtensions);
+  GL_EXT_shader_texture_lod := gl_IsSupported('GL_EXT_shader_texture_lod', oglExtensions);
+  GL_EXT_shadow_samplers := gl_IsSupported('GL_EXT_shadow_samplers', oglExtensions);
+  GL_EXT_sparse_texture := gl_IsSupported('GL_EXT_sparse_texture', oglExtensions);
+  GL_EXT_sparse_texture2 := gl_IsSupported('GL_EXT_sparse_texture2', oglExtensions);
+  GL_EXT_tessellation_point_size := gl_IsSupported('GL_EXT_tessellation_point_size', oglExtensions);
+  GL_EXT_tessellation_shader := gl_IsSupported('GL_EXT_tessellation_shader', oglExtensions);
+  GL_EXT_texture_border_clamp := gl_IsSupported('GL_EXT_texture_border_clamp', oglExtensions);
+  GL_EXT_texture_buffer := gl_IsSupported('GL_EXT_texture_buffer', oglExtensions);
+  GL_EXT_texture_compression_astc_decode_mode := gl_IsSupported('GL_EXT_texture_compression_astc_decode_mode', oglExtensions);
+  GL_EXT_texture_compression_bptc := gl_IsSupported('GL_EXT_texture_compression_bptc', oglExtensions);
+  GL_EXT_texture_compression_dxt1 := gl_IsSupported('GL_EXT_texture_compression_dxt1', oglExtensions);
+  GL_EXT_texture_compression_rgtc := gl_IsSupported('GL_EXT_texture_compression_rgtc', oglExtensions);
+  GL_EXT_texture_compression_s3tc := gl_IsSupported('GL_EXT_texture_compression_s3tc', oglExtensions);
+  GL_EXT_texture_compression_s3tc_srgb := gl_IsSupported('GL_EXT_texture_compression_s3tc_srgb', oglExtensions);
+  GL_EXT_texture_cube_map_array := gl_IsSupported('GL_EXT_texture_cube_map_array', oglExtensions);
+//  GL_EXT_texture_filter_anisotropic := gl_IsSupported('GL_EXT_texture_filter_anisotropic', oglExtensions);
+  GL_EXT_texture_filter_minmax := gl_IsSupported('GL_EXT_texture_filter_minmax', oglExtensions);
+  GL_EXT_texture_format_BGRA8888 := gl_IsSupported('GL_EXT_texture_format_BGRA8888', oglExtensions);
+  GL_EXT_texture_format_sRGB_override := gl_IsSupported('GL_EXT_texture_format_sRGB_override', oglExtensions);
+  GL_EXT_texture_mirror_clamp_to_edge := gl_IsSupported('GL_EXT_texture_mirror_clamp_to_edge', oglExtensions);
+  GL_EXT_texture_norm16 := gl_IsSupported('GL_EXT_texture_norm16', oglExtensions);
+  GL_EXT_texture_query_lod := gl_IsSupported('GL_EXT_texture_query_lod', oglExtensions);
+  GL_EXT_texture_rg := gl_IsSupported('GL_EXT_texture_rg', oglExtensions);
+  GL_EXT_texture_sRGB_R8 := gl_IsSupported('GL_EXT_texture_sRGB_R8', oglExtensions);
+  GL_EXT_texture_sRGB_RG8 := gl_IsSupported('GL_EXT_texture_sRGB_RG8', oglExtensions);
+  GL_EXT_texture_sRGB_decode := gl_IsSupported('GL_EXT_texture_sRGB_decode', oglExtensions);
+  GL_EXT_texture_shadow_lod := gl_IsSupported('GL_EXT_texture_shadow_lod', oglExtensions);
+  GL_EXT_texture_storage := gl_IsSupported('GL_EXT_texture_storage', oglExtensions);
+  GL_EXT_texture_storage_compression := gl_IsSupported('GL_EXT_texture_storage_compression', oglExtensions);
+  GL_EXT_texture_type_2_10_10_10_REV := gl_IsSupported('GL_EXT_texture_type_2_10_10_10_REV', oglExtensions);
+  GL_EXT_texture_view := gl_IsSupported('GL_EXT_texture_view', oglExtensions);
+  GL_EXT_unpack_subimage := gl_IsSupported('GL_EXT_unpack_subimage', oglExtensions);
+  GL_EXT_win32_keyed_mutex := gl_IsSupported('GL_EXT_win32_keyed_mutex', oglExtensions);
+  GL_EXT_window_rectangles := gl_IsSupported('GL_EXT_window_rectangles', oglExtensions);
+  GL_FJ_shader_binary_GCCSO := gl_IsSupported('GL_FJ_shader_binary_GCCSO', oglExtensions);
+  GL_IMG_bindless_texture := gl_IsSupported('GL_IMG_bindless_texture', oglExtensions);
+  GL_IMG_framebuffer_downsample := gl_IsSupported('GL_IMG_framebuffer_downsample', oglExtensions);
+  GL_IMG_multisampled_render_to_texture := gl_IsSupported('GL_IMG_multisampled_render_to_texture', oglExtensions);
+  GL_IMG_program_binary := gl_IsSupported('GL_IMG_program_binary', oglExtensions);
+  GL_IMG_read_format := gl_IsSupported('GL_IMG_read_format', oglExtensions);
+  GL_IMG_shader_binary := gl_IsSupported('GL_IMG_shader_binary', oglExtensions);
+//  GL_IMG_texture_compression_pvrtc := gl_IsSupported('GL_IMG_texture_compression_pvrtc', oglExtensions);
+  GL_IMG_texture_compression_pvrtc2 := gl_IsSupported('GL_IMG_texture_compression_pvrtc2', oglExtensions);
+  GL_IMG_texture_filter_cubic := gl_IsSupported('GL_IMG_texture_filter_cubic', oglExtensions);
+  GL_INTEL_blackhole_render := gl_IsSupported('GL_INTEL_blackhole_render', oglExtensions);
+  GL_INTEL_conservative_rasterization := gl_IsSupported('GL_INTEL_conservative_rasterization', oglExtensions);
+  GL_INTEL_framebuffer_CMAA := gl_IsSupported('GL_INTEL_framebuffer_CMAA', oglExtensions);
+  GL_INTEL_performance_query := gl_IsSupported('GL_INTEL_performance_query', oglExtensions);
+  GL_MESA_bgra := gl_IsSupported('GL_MESA_bgra', oglExtensions);
+  GL_MESA_framebuffer_flip_x := gl_IsSupported('GL_MESA_framebuffer_flip_x', oglExtensions);
+  GL_MESA_framebuffer_flip_y := gl_IsSupported('GL_MESA_framebuffer_flip_y', oglExtensions);
+  GL_MESA_framebuffer_swap_xy := gl_IsSupported('GL_MESA_framebuffer_swap_xy', oglExtensions);
+  GL_MESA_program_binary_formats := gl_IsSupported('GL_MESA_program_binary_formats', oglExtensions);
+  GL_MESA_shader_integer_functions := gl_IsSupported('GL_MESA_shader_integer_functions', oglExtensions);
+  GL_NVX_blend_equation_advanced_multi_draw_buffers := gl_IsSupported('GL_NVX_blend_equation_advanced_multi_draw_buffers', oglExtensions);
+  GL_NV_bindless_texture := gl_IsSupported('GL_NV_bindless_texture', oglExtensions);
+  GL_NV_blend_equation_advanced := gl_IsSupported('GL_NV_blend_equation_advanced', oglExtensions);
+  GL_NV_blend_equation_advanced_coherent := gl_IsSupported('GL_NV_blend_equation_advanced_coherent', oglExtensions);
+  GL_NV_blend_minmax_factor := gl_IsSupported('GL_NV_blend_minmax_factor', oglExtensions);
+  GL_NV_clip_space_w_scaling := gl_IsSupported('GL_NV_clip_space_w_scaling', oglExtensions);
+  GL_NV_compute_shader_derivatives := gl_IsSupported('GL_NV_compute_shader_derivatives', oglExtensions);
+  GL_NV_conditional_render := gl_IsSupported('GL_NV_conditional_render', oglExtensions);
+  GL_NV_conservative_raster := gl_IsSupported('GL_NV_conservative_raster', oglExtensions);
+  GL_NV_conservative_raster_pre_snap := gl_IsSupported('GL_NV_conservative_raster_pre_snap', oglExtensions);
+  GL_NV_conservative_raster_pre_snap_triangles := gl_IsSupported('GL_NV_conservative_raster_pre_snap_triangles', oglExtensions);
+  GL_NV_copy_buffer := gl_IsSupported('GL_NV_copy_buffer', oglExtensions);
+  GL_NV_coverage_sample := gl_IsSupported('GL_NV_coverage_sample', oglExtensions);
+  GL_NV_depth_nonlinear := gl_IsSupported('GL_NV_depth_nonlinear', oglExtensions);
+  GL_NV_draw_buffers := gl_IsSupported('GL_NV_draw_buffers', oglExtensions);
+  GL_NV_draw_instanced := gl_IsSupported('GL_NV_draw_instanced', oglExtensions);
+  GL_NV_draw_vulkan_image := gl_IsSupported('GL_NV_draw_vulkan_image', oglExtensions);
+  GL_NV_explicit_attrib_location := gl_IsSupported('GL_NV_explicit_attrib_location', oglExtensions);
+  GL_NV_fbo_color_attachments := gl_IsSupported('GL_NV_fbo_color_attachments', oglExtensions);
+  GL_NV_fence := gl_IsSupported('GL_NV_fence', oglExtensions);
+  GL_NV_fill_rectangle := gl_IsSupported('GL_NV_fill_rectangle', oglExtensions);
+  GL_NV_fragment_coverage_to_color := gl_IsSupported('GL_NV_fragment_coverage_to_color', oglExtensions);
+  GL_NV_fragment_shader_barycentric := gl_IsSupported('GL_NV_fragment_shader_barycentric', oglExtensions);
+  GL_NV_fragment_shader_interlock := gl_IsSupported('GL_NV_fragment_shader_interlock', oglExtensions);
+  GL_NV_framebuffer_blit := gl_IsSupported('GL_NV_framebuffer_blit', oglExtensions);
+  GL_NV_framebuffer_mixed_samples := gl_IsSupported('GL_NV_framebuffer_mixed_samples', oglExtensions);
+  GL_NV_framebuffer_multisample := gl_IsSupported('GL_NV_framebuffer_multisample', oglExtensions);
+  GL_NV_generate_mipmap_sRGB := gl_IsSupported('GL_NV_generate_mipmap_sRGB', oglExtensions);
+  GL_NV_geometry_shader_passthrough := gl_IsSupported('GL_NV_geometry_shader_passthrough', oglExtensions);
+  GL_NV_gpu_shader5 := gl_IsSupported('GL_NV_gpu_shader5', oglExtensions);
+  GL_NV_image_formats := gl_IsSupported('GL_NV_image_formats', oglExtensions);
+  GL_NV_instanced_arrays := gl_IsSupported('GL_NV_instanced_arrays', oglExtensions);
+  GL_NV_internalformat_sample_query := gl_IsSupported('GL_NV_internalformat_sample_query', oglExtensions);
+  GL_NV_memory_attachment := gl_IsSupported('GL_NV_memory_attachment', oglExtensions);
+  GL_NV_memory_object_sparse := gl_IsSupported('GL_NV_memory_object_sparse', oglExtensions);
+  GL_NV_mesh_shader := gl_IsSupported('GL_NV_mesh_shader', oglExtensions);
+  GL_NV_non_square_matrices := gl_IsSupported('GL_NV_non_square_matrices', oglExtensions);
+  GL_NV_pack_subimage := gl_IsSupported('GL_NV_pack_subimage', oglExtensions);
+  GL_NV_path_rendering := gl_IsSupported('GL_NV_path_rendering', oglExtensions);
+  GL_NV_path_rendering_shared_edge := gl_IsSupported('GL_NV_path_rendering_shared_edge', oglExtensions);
+  GL_NV_pixel_buffer_object := gl_IsSupported('GL_NV_pixel_buffer_object', oglExtensions);
+  GL_NV_polygon_mode := gl_IsSupported('GL_NV_polygon_mode', oglExtensions);
+  GL_NV_primitive_shading_rate := gl_IsSupported('GL_NV_primitive_shading_rate', oglExtensions);
+  GL_NV_read_buffer := gl_IsSupported('GL_NV_read_buffer', oglExtensions);
+  GL_NV_read_buffer_front := gl_IsSupported('GL_NV_read_buffer_front', oglExtensions);
+  GL_NV_read_depth := gl_IsSupported('GL_NV_read_depth', oglExtensions);
+  GL_NV_read_depth_stencil := gl_IsSupported('GL_NV_read_depth_stencil', oglExtensions);
+  GL_NV_read_stencil := gl_IsSupported('GL_NV_read_stencil', oglExtensions);
+  GL_NV_representative_fragment_test := gl_IsSupported('GL_NV_representative_fragment_test', oglExtensions);
+  GL_NV_sRGB_formats := gl_IsSupported('GL_NV_sRGB_formats', oglExtensions);
+  GL_NV_sample_locations := gl_IsSupported('GL_NV_sample_locations', oglExtensions);
+  GL_NV_sample_mask_override_coverage := gl_IsSupported('GL_NV_sample_mask_override_coverage', oglExtensions);
+  GL_NV_scissor_exclusive := gl_IsSupported('GL_NV_scissor_exclusive', oglExtensions);
+  GL_NV_shader_atomic_fp16_vector := gl_IsSupported('GL_NV_shader_atomic_fp16_vector', oglExtensions);
+  GL_NV_shader_noperspective_interpolation := gl_IsSupported('GL_NV_shader_noperspective_interpolation', oglExtensions);
+  GL_NV_shader_subgroup_partitioned := gl_IsSupported('GL_NV_shader_subgroup_partitioned', oglExtensions);
+  GL_NV_shader_texture_footprint := gl_IsSupported('GL_NV_shader_texture_footprint', oglExtensions);
+  GL_NV_shading_rate_image := gl_IsSupported('GL_NV_shading_rate_image', oglExtensions);
+  GL_NV_shadow_samplers_array := gl_IsSupported('GL_NV_shadow_samplers_array', oglExtensions);
+  GL_NV_shadow_samplers_cube := gl_IsSupported('GL_NV_shadow_samplers_cube', oglExtensions);
+  GL_NV_stereo_view_rendering := gl_IsSupported('GL_NV_stereo_view_rendering', oglExtensions);
+  GL_NV_texture_border_clamp := gl_IsSupported('GL_NV_texture_border_clamp', oglExtensions);
+  GL_NV_texture_compression_s3tc_update := gl_IsSupported('GL_NV_texture_compression_s3tc_update', oglExtensions);
+  GL_NV_texture_npot_2D_mipmap := gl_IsSupported('GL_NV_texture_npot_2D_mipmap', oglExtensions);
+  GL_NV_timeline_semaphore := gl_IsSupported('GL_NV_timeline_semaphore', oglExtensions);
+  GL_NV_viewport_array := gl_IsSupported('GL_NV_viewport_array', oglExtensions);
+  GL_NV_viewport_array2 := gl_IsSupported('GL_NV_viewport_array2', oglExtensions);
+  GL_NV_viewport_swizzle := gl_IsSupported('GL_NV_viewport_swizzle', oglExtensions);
+  GL_OVR_multiview := gl_IsSupported('GL_OVR_multiview', oglExtensions);
+  GL_OVR_multiview2 := gl_IsSupported('GL_OVR_multiview2', oglExtensions);
+  GL_OVR_multiview_multisampled_render_to_texture := gl_IsSupported('GL_OVR_multiview_multisampled_render_to_texture', oglExtensions);
+  GL_QCOM_YUV_texture_gather := gl_IsSupported('GL_QCOM_YUV_texture_gather', oglExtensions);
+  GL_QCOM_alpha_test := gl_IsSupported('GL_QCOM_alpha_test', oglExtensions);
+  GL_QCOM_binning_control := gl_IsSupported('GL_QCOM_binning_control', oglExtensions);
+  GL_QCOM_driver_control := gl_IsSupported('GL_QCOM_driver_control', oglExtensions);
+  GL_QCOM_extended_get := gl_IsSupported('GL_QCOM_extended_get', oglExtensions);
+  GL_QCOM_extended_get2 := gl_IsSupported('GL_QCOM_extended_get2', oglExtensions);
+  GL_QCOM_frame_extrapolation := gl_IsSupported('GL_QCOM_frame_extrapolation', oglExtensions);
+  GL_QCOM_framebuffer_foveated := gl_IsSupported('GL_QCOM_framebuffer_foveated', oglExtensions);
+  GL_QCOM_motion_estimation := gl_IsSupported('GL_QCOM_motion_estimation', oglExtensions);
+  GL_QCOM_perfmon_global_mode := gl_IsSupported('GL_QCOM_perfmon_global_mode', oglExtensions);
+  GL_QCOM_render_shared_exponent := gl_IsSupported('GL_QCOM_render_shared_exponent', oglExtensions);
+  GL_QCOM_shader_framebuffer_fetch_noncoherent := gl_IsSupported('GL_QCOM_shader_framebuffer_fetch_noncoherent', oglExtensions);
+  GL_QCOM_shader_framebuffer_fetch_rate := gl_IsSupported('GL_QCOM_shader_framebuffer_fetch_rate', oglExtensions);
+  GL_QCOM_shading_rate := gl_IsSupported('GL_QCOM_shading_rate', oglExtensions);
+  GL_QCOM_texture_foveated := gl_IsSupported('GL_QCOM_texture_foveated', oglExtensions);
+  GL_QCOM_texture_foveated2 := gl_IsSupported('GL_QCOM_texture_foveated2', oglExtensions);
+  GL_QCOM_texture_foveated_subsampled_layout := gl_IsSupported('GL_QCOM_texture_foveated_subsampled_layout', oglExtensions);
+  GL_QCOM_tiled_rendering := gl_IsSupported('GL_QCOM_tiled_rendering', oglExtensions);
+  GL_QCOM_writeonly_rendering := gl_IsSupported('GL_QCOM_writeonly_rendering', oglExtensions);
+  GL_VIV_shader_binary := gl_IsSupported('GL_VIV_shader_binary', oglExtensions);
+{$EndIf}
+end;
+
+function LoadOpenGLES: Boolean;
+{$IfDef LINUX}
+{$IfDef GL_ES_VERSION_3_0}
+var
+  i, j: Integer;
+{$EndIf}{$EndIf}
+begin
+  Result := True;
+
+  {$IfDef LINUX}
+  oglExtensions := '';
+  {$IfDef GL_ES_VERSION_3_0}
+ (* if use_glMajorVer >= 3 then          // этот код выдаёт очень "весёлое" зависание при использованиее GLES...
+  begin
+    if not Assigned(glGetStringi) then
+      glGetStringi := gl_GetProc('glGetStringi');
+    if Assigned(glGetStringi) then
+    begin
+      glGetIntegerv(GL_NUM_EXTENSIONS, @j);
+      for i := 0 to j - 1 do
+        oglExtensions := oglExtensions + PAnsiChar(glGetStringi(GL_EXTENSIONS, i)) + #32;
+    end;
+  end; *)
+
+  if oglExtensions = '' then
+  {$EndIf}
+    oglExtensions := glGetString(GL_EXTENSIONS);
+  {$EndIf}
+  AllCheckGLExtension;
+{$IfDef GL_VERSION_ES_CM_1_0}
+// min GLES function - glAlphaFunc := dlsym(glesLibrary, 'glAlphaFunc');
+// min GLES function - glClearColor := dlsym(glesLibrary, 'glClearColor');
+// min GLES function - glClearDepthf := dlsym(glesLibrary, 'glClearDepthf');
+  glClipPlanef := dlsym(glesLibrary, 'glClipPlanef');
+// min GLES function - glColor4f := dlsym(glesLibrary, 'glColor4f');
+  glDepthRangef := dlsym(glesLibrary, 'glDepthRangef');
+  glFogf := dlsym(glesLibrary, 'glFogf');
+  glFogfv := dlsym(glesLibrary, 'glFogfv');
+  glFrustumf := dlsym(glesLibrary, 'glFrustumf');
+  glGetClipPlanef := dlsym(glesLibrary, 'glGetClipPlanef');
+// min GLES function - glGetFloatv := dlsym(glesLibrary, 'glGetFloatv');
+  glGetLightfv := dlsym(glesLibrary, 'glGetLightfv');
+  glGetMaterialfv := dlsym(glesLibrary, 'glGetMaterialfv');
+  glGetTexEnvfv := dlsym(glesLibrary, 'glGetTexEnvfv');
+  glGetTexParameterfv := dlsym(glesLibrary, 'glGetTexParameterfv');
+  glLightModelf := dlsym(glesLibrary, 'glLightModelf');
+  glLightModelfv := dlsym(glesLibrary, 'glLightModelfv');
+  glLightf := dlsym(glesLibrary, 'glLightf');
+  glLightfv := dlsym(glesLibrary, 'glLightfv');
+  glLineWidth := dlsym(glesLibrary, 'glLineWidth');
+// min GLES function - glLoadMatrixf := dlsym(glesLibrary, 'glLoadMatrixf');
+  glMaterialf := dlsym(glesLibrary, 'glMaterialf');
+  glMaterialfv := dlsym(glesLibrary, 'glMaterialfv');
+  glMultMatrixf := dlsym(glesLibrary, 'glMultMatrixf');
+  glMultiTexCoord4f := dlsym(glesLibrary, 'glMultiTexCoord4f');
+  glNormal3f := dlsym(glesLibrary, 'glNormal3f');
+// min GLES function - glOrthof := dlsym(glesLibrary, 'glOrthof');
+  glPointParameterf := dlsym(glesLibrary, 'glPointParameterf');
+  glPointParameterfv := dlsym(glesLibrary, 'glPointParameterfv');
+  glPointSize := dlsym(glesLibrary, 'glPointSize');
+  glPolygonOffset := dlsym(glesLibrary, 'glPolygonOffset');
+// min GLES function - glRotatef := dlsym(glesLibrary, 'glRotatef');
+// min GLES function - glScalef := dlsym(glesLibrary, 'glScalef');
+  glTexEnvf := dlsym(glesLibrary, 'glTexEnvf');
+  glTexEnvfv := dlsym(glesLibrary, 'glTexEnvfv');
+// min GLES function - glTexParameterf := dlsym(glesLibrary, 'glTexParameterf');
+  glTexParameterfv := dlsym(glesLibrary, 'glTexParameterfv');
+// min GLES function - glTranslatef := dlsym(glesLibrary, 'glTranslatef');
+  glActiveTexture := dlsym(glesLibrary, 'glActiveTexture');
+  glAlphaFuncx := dlsym(glesLibrary, 'glAlphaFuncx');
+  glBindBuffer := dlsym(glesLibrary, 'glBindBuffer');
+// min GLES function - glBindTexture := dlsym(glesLibrary, 'glBindTexture');
+// min GLES function - glBlendFunc := dlsym(glesLibrary, 'glBlendFunc');
+  glBufferData := dlsym(glesLibrary, 'glBufferData');
+  glBufferSubData := dlsym(glesLibrary, 'glBufferSubData');
+// min GLES function - glClear := dlsym(glesLibrary, 'glClear');
+  glClearColorx := dlsym(glesLibrary, 'glClearColorx');
+  glClearDepthx := dlsym(glesLibrary, 'glClearDepthx');
+  glClearStencil := dlsym(glesLibrary, 'glClearStencil');
+  glClientActiveTexture := dlsym(glesLibrary, 'glClientActiveTexture');
+  glClipPlanex := dlsym(glesLibrary, 'glClipPlanex');
+  glColor4ub := dlsym(glesLibrary, 'glColor4ub');
+  glColor4x := dlsym(glesLibrary, 'glColor4x');
+// min GLES function - glColorMask := dlsym(glesLibrary, 'glColorMask');
+// min GLES function - glColorPointer := dlsym(glesLibrary, 'glColorPointer');
+// min GLES function - glCompressedTexImage2D := dlsym(glesLibrary, 'glCompressedTexImage2D');
+// min GLES function - glCompressedTexSubImage2D := dlsym(glesLibrary, 'glCompressedTexSubImage2D');
+  glCopyTexImage2D := dlsym(glesLibrary, 'glCopyTexImage2D');
+// min GLES function - glCopyTexSubImage2D := dlsym(glesLibrary, 'glCopyTexSubImage2D');
+  glCullFace := dlsym(glesLibrary, 'glCullFace');
+  glDeleteBuffers := dlsym(glesLibrary, 'glDeleteBuffers');
+// min GLES function - glDeleteTextures := dlsym(glesLibrary, 'glDeleteTextures');
+// min GLES function - glDepthFunc := dlsym(glesLibrary, 'glDepthFunc');
+// min GLES function - glDepthMask := dlsym(glesLibrary, 'glDepthMask');
+  glDepthRangex := dlsym(glesLibrary, 'glDepthRangex');
+// min GLES function - glDisable := dlsym(glesLibrary, 'glDisable');
+// min GLES function - glDisableClientState := dlsym(glesLibrary, 'glDisableClientState');
+// min GLES function - glDrawArrays := dlsym(glesLibrary, 'glDrawArrays');
+// min GLES function - glDrawElements := dlsym(glesLibrary, 'glDrawElements');
+// min GLES function - glEnable := dlsym(glesLibrary, 'glEnable');
+// min GLES function - glEnableClientState := dlsym(glesLibrary, 'glEnableClientState');
+  glFinish := dlsym(glesLibrary, 'glFinish');
+  glFlush := dlsym(glesLibrary, 'glFlush');
+  glFogx := dlsym(glesLibrary, 'glFogx');
+  glFogxv := dlsym(glesLibrary, 'glFogxv');
+  glFrontFace := dlsym(glesLibrary, 'glFrontFace');
+  glFrustumx := dlsym(glesLibrary, 'glFrustumx');
+  glGetBooleanv := dlsym(glesLibrary, 'glGetBooleanv');
+  glGetBufferParameteriv := dlsym(glesLibrary, 'glGetBufferParameteriv');
+  glGetClipPlanex := dlsym(glesLibrary, 'glGetClipPlanex');
+  glGenBuffers := dlsym(glesLibrary, 'glGenBuffers');
+// min GLES function - glGenTextures := dlsym(glesLibrary, 'glGenTextures');
+  glGetError := dlsym(glesLibrary, 'glGetError');
+  glGetFixedv := dlsym(glesLibrary, 'glGetFixedv');
+// min GLES function - glGetIntegerv := dlsym(glesLibrary, 'glGetIntegerv');
+  glGetLightxv := dlsym(glesLibrary, 'glGetLightxv');
+  glGetMaterialxv := dlsym(glesLibrary, 'glGetMaterialxv');
+  glGetPointerv := dlsym(glesLibrary, 'glGetPointerv');
+// min GLES function - glGetString := dlsym(glesLibrary, 'glGetString');
+  glGetTexEnviv := dlsym(glesLibrary, 'glGetTexEnviv');
+  glGetTexEnvxv := dlsym(glesLibrary, 'glGetTexEnvxv');
+  glGetTexParameteriv := dlsym(glesLibrary, 'glGetTexParameteriv');
+  glGetTexParameterxv := dlsym(glesLibrary, 'glGetTexParameterxv');
+// min GLES function - glHint := dlsym(glesLibrary, 'glHint');
+  glIsBuffer := dlsym(glesLibrary, 'glIsBuffer');
+  glIsEnabled := dlsym(glesLibrary, 'glIsEnabled');
+  glIsTexture := dlsym(glesLibrary, 'glIsTexture');
+  glLightModelx := dlsym(glesLibrary, 'glLightModelx');
+  glLightModelxv := dlsym(glesLibrary, 'glLightModelxv');
+  glLightx := dlsym(glesLibrary, 'glLightx');
+  glLightxv := dlsym(glesLibrary, 'glLightxv');
+  glLineWidthx := dlsym(glesLibrary, 'glLineWidthx');
+// min GLES function - glLoadIdentity := dlsym(glesLibrary, 'glLoadIdentity');
+  glLoadMatrixx := dlsym(glesLibrary, 'glLoadMatrixx');
+  glLogicOp := dlsym(glesLibrary, 'glLogicOp');
+  glMaterialx := dlsym(glesLibrary, 'glMaterialx');
+  glMaterialxv := dlsym(glesLibrary, 'glMaterialxv');
+// min GLES function - glMatrixMode := dlsym(glesLibrary, 'glMatrixMode');
+  glMultMatrixx := dlsym(glesLibrary, 'glMultMatrixx');
+  glMultiTexCoord4x := dlsym(glesLibrary, 'glMultiTexCoord4x');
+  glNormal3x := dlsym(glesLibrary, 'glNormal3x');
+  glNormalPointer := dlsym(glesLibrary, 'glNormalPointer');
+  glOrthox := dlsym(glesLibrary, 'glOrthox');
+// min GLES function - glPixelStorei := dlsym(glesLibrary, 'glPixelStorei');
+  glPointParameterx := dlsym(glesLibrary, 'glPointParameterx');
+  glPointParameterxv := dlsym(glesLibrary, 'glPointParameterxv');
+  glPointSizex := dlsym(glesLibrary, 'glPointSizex');
+  glPolygonOffsetx := dlsym(glesLibrary, 'glPolygonOffsetx');
+// min GLES function - glPopMatrix := dlsym(glesLibrary, 'glPopMatrix');
+// min GLES function - glPushMatrix := dlsym(glesLibrary, 'glPushMatrix');
+// min GLES function - glReadPixels := dlsym(glesLibrary, 'glReadPixels');
+  glRotatex := dlsym(glesLibrary, 'glRotatex');
+  glSampleCoverage := dlsym(glesLibrary, 'glSampleCoverage');
+  glSampleCoveragex := dlsym(glesLibrary, 'glSampleCoveragex');
+  glScalex := dlsym(glesLibrary, 'glScalex');
+// min GLES function - glScissor := dlsym(glesLibrary, 'glScissor');
+// min GLES function - glShadeModel := dlsym(glesLibrary, 'glShadeModel');
+  glStencilFunc := dlsym(glesLibrary, 'glStencilFunc');
+  glStencilMask := dlsym(glesLibrary, 'glStencilMask');
+  glStencilOp := dlsym(glesLibrary, 'glStencilOp');
+// min GLES function - glTexCoordPointer := dlsym(glesLibrary, 'glTexCoordPointer');
+// min GLES function - glTexEnvi := dlsym(glesLibrary, 'glTexEnvi');
+// min GLES function - glTexEnvx := dlsym(glesLibrary, 'glTexEnvx');
+// min GLES function - glTexEnviv := dlsym(glesLibrary, 'glTexEnviv');
+// min GLES function - glTexEnvxv := dlsym(glesLibrary, 'glTexEnvxv');
+// min GLES function - glTexImage2D := dlsym(glesLibrary, 'glTexImage2D');
+// min GLES function - glTexParameteri := dlsym(glesLibrary, 'glTexParameteri');
+// min GLES function - glTexParameterx := dlsym(glesLibrary, 'glTexParameterx');
+// min GLES function - glTexParameteriv := dlsym(glesLibrary, 'glTexParameteriv');
+// min GLES function - glTexParameterxv := dlsym(glesLibrary, 'glTexParameterxv');
+// min GLES function - glTexSubImage2D := dlsym(glesLibrary, 'glTexSubImage2D');
+  glTranslatex := dlsym(glesLibrary, 'glTranslatex');
+// min GLES function - glVertexPointer := dlsym(glesLibrary, 'glVertexPointer');
+// min GLES function - glViewport := dlsym(glesLibrary, 'glViewport');
+
+  {$IfDef GL_OES_point_size_array}
+  glPointSizePointerOES := dlsym(glesLibrary, 'glPointSizePointerOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_equation_separate}
+  glBlendEquationSeparateOES := dlsym(glesLibrary, 'glBlendEquationSeparateOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_func_separate}
+  // min GLES function - glBlendFuncSeparateOES := dlsym(glesLibrary, 'glBlendFuncSeparateOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_subtract}
+  glBlendEquationOES := dlsym(glesLibrary, 'glBlendEquationOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_draw_texture}
+  glDrawTexsOES := dlsym(glesLibrary, 'glDrawTexsOES');
+  glDrawTexiOES := dlsym(glesLibrary, 'glDrawTexiOES');
+  glDrawTexxOES := dlsym(glesLibrary, 'glDrawTexxOES');
+  glDrawTexsvOES := dlsym(glesLibrary, 'glDrawTexsvOES');
+  glDrawTexivOES := dlsym(glesLibrary, 'glDrawTexivOES');
+  glDrawTexxvOES := dlsym(glesLibrary, 'glDrawTexxvOES');
+  glDrawTexfOES := dlsym(glesLibrary, 'glDrawTexfOES');
+  glDrawTexfvOES := dlsym(glesLibrary, 'glDrawTexfvOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_fixed_point}
+  glAlphaFuncxOES := dlsym(glesLibrary, 'glAlphaFuncxOES');
+  glClearColorxOES := dlsym(glesLibrary, 'glClearColorxOES');
+  glClearDepthxOES := dlsym(glesLibrary, 'glClearDepthxOES');
+  glClipPlanexOES := dlsym(glesLibrary, 'glClipPlanexOES');
+  glColor4xOES := dlsym(glesLibrary, 'glColor4xOES');
+  glDepthRangexOES := dlsym(glesLibrary, 'glDepthRangexOES');
+  glFogxOES := dlsym(glesLibrary, 'glFogxOES');
+  glFogxvOES := dlsym(glesLibrary, 'glFogxvOES');
+  glFrustumxOES := dlsym(glesLibrary, 'glFrustumxOES');
+  glGetClipPlanexOES := dlsym(glesLibrary, 'glGetClipPlanexOES');
+  glGetFixedvOES := dlsym(glesLibrary, 'glGetFixedvOES');
+  glGetTexEnvxvOES := dlsym(glesLibrary, 'glGetTexEnvxvOES');
+  glGetTexParameterxvOES := dlsym(glesLibrary, 'glGetTexParameterxvOES');
+  glLightModelxOES := dlsym(glesLibrary, 'glLightModelxOES');
+  glLightModelxvOES := dlsym(glesLibrary, 'glLightModelxvOES');
+  glLightxOES := dlsym(glesLibrary, 'glLightxOES');
+  glLightxvOES := dlsym(glesLibrary, 'glLightxvOES');
+  glLineWidthxOES := dlsym(glesLibrary, 'glLineWidthxOES');
+  glLoadMatrixxOES := dlsym(glesLibrary, 'glLoadMatrixxOES');
+  glMaterialxOES := dlsym(glesLibrary, 'glMaterialxOES');
+  glMaterialxvOES := dlsym(glesLibrary, 'glMaterialxvOES');
+  glMultMatrixxOES := dlsym(glesLibrary, 'glMultMatrixxOES');
+  glMultiTexCoord4xOES := dlsym(glesLibrary, 'glMultiTexCoord4xOES');
+  glNormal3xOES := dlsym(glesLibrary, 'glNormal3xOES');
+  glOrthoxOES := dlsym(glesLibrary, 'glOrthoxOES');
+  glPointParameterxvOES := dlsym(glesLibrary, 'glPointParameterxvOES');
+  glPointSizexOES := dlsym(glesLibrary, 'glPointSizexOES');
+  glPolygonOffsetxOES := dlsym(glesLibrary, 'glPolygonOffsetxOES');
+  glRotatexOES := dlsym(glesLibrary, 'glRotatexOES');
+  glScalexOES := dlsym(glesLibrary, 'glScalexOES');
+  glTexEnvxOES := dlsym(glesLibrary, 'glTexEnvxOES');
+  glTexEnvxvOES := dlsym(glesLibrary, 'glTexEnvxvOES');
+  glTexParameterxOES := dlsym(glesLibrary, 'glTexParameterxOES');
+  glTexParameterxvOES := dlsym(glesLibrary, 'glTexParameterxvOES');
+  glTranslatexOES := dlsym(glesLibrary, 'glTranslatexOES');
+  glGetLightxvOES := dlsym(glesLibrary, 'glGetLightxvOES');
+  glGetMaterialxvOES := dlsym(glesLibrary, 'glGetMaterialxvOES');
+  glPointParameterxOES := dlsym(glesLibrary, 'glPointParameterxOES');
+  glSampleCoveragexOES := dlsym(glesLibrary, 'glSampleCoveragexOES');
+  glGetTexGenxvOES := dlsym(glesLibrary, 'glGetTexGenxvOES');
+  glTexGenxOES := dlsym(glesLibrary, 'glTexGenxOES');
+  glTexGenxvOES := dlsym(glesLibrary, 'glTexGenxvOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_framebuffer_object}
+// min GLES function - glIsRenderbufferOES := dlsym(glesLibrary, 'glIsRenderbufferOES');
+// min GLES function - glBindRenderbufferOES := dlsym(glesLibrary, 'glBindRenderbufferOES');
+// min GLES function - glDeleteRenderbuffersOES := dlsym(glesLibrary, 'glDeleteRenderbuffersOES');
+// min GLES function - glGenRenderbuffersOES := dlsym(glesLibrary, 'glGenRenderbuffersOES');
+// min GLES function - glRenderbufferStorageOES := dlsym(glesLibrary, 'glRenderbufferStorageOES');
+// min GLES function - glGetRenderbufferParameterivOES := dlsym(glesLibrary, 'glGetRenderbufferParameterivOES');
+// min GLES function - glIsFramebufferOES := dlsym(glesLibrary, 'glIsFramebufferOES');
+// min GLES function - glBindFramebufferOES := dlsym(glesLibrary, 'glBindFramebufferOES');
+// min GLES function - glDeleteFramebuffersOES := dlsym(glesLibrary, 'glDeleteFramebuffersOES');
+// min GLES function - glGenFramebuffersOES := dlsym(glesLibrary, 'glGenFramebuffersOES');
+// min GLES function - glCheckFramebufferStatusOES := dlsym(glesLibrary, 'glCheckFramebufferStatusOES');
+// min GLES function - glFramebufferRenderbufferOES := dlsym(glesLibrary, 'glFramebufferRenderbufferOES');
+// min GLES function - glFramebufferTexture2DOES := dlsym(glesLibrary, 'glFramebufferTexture2DOES');
+// min GLES function - glGetFramebufferAttachmentParameterivOES := dlsym(glesLibrary, 'glGetFramebufferAttachmentParameterivOES');
+// min GLES function - glGenerateMipmapOES := dlsym(glesLibrary, 'glGenerateMipmapOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_matrix_palette}
+  glCurrentPaletteMatrixOES := dlsym(glesLibrary, 'glCurrentPaletteMatrixOES');
+  glLoadPaletteFromModelViewMatrixOES := dlsym(glesLibrary, 'glLoadPaletteFromModelViewMatrixOES');
+  glMatrixIndexPointerOES := dlsym(glesLibrary, 'glMatrixIndexPointerOES');
+  glWeightPointerOES := dlsym(glesLibrary, 'glWeightPointerOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_query_matrix}
+  glQueryMatrixxOES := dlsym(glesLibrary, 'glQueryMatrixxOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_single_precision}
+  glClearDepthfOES := dlsym(glesLibrary, 'glClearDepthfOES');
+  glClipPlanefOES := dlsym(glesLibrary, 'glClipPlanefOES');
+  glDepthRangefOES := dlsym(glesLibrary, 'glDepthRangefOES');
+  glFrustumfOES := dlsym(glesLibrary, 'glFrustumfOES');
+  glGetClipPlanefOES := dlsym(glesLibrary, 'glGetClipPlanefOES');
+  glOrthofOES := dlsym(glesLibrary, 'glOrthofOES');
+  {$EndIf}
+
+  {$IfDef GL_OES_texture_cube_map}
+  glTexGenfOES := dlsym(glesLibrary, 'glTexGenfOES');
+  glTexGenfvOES := dlsym(glesLibrary, 'glTexGenfvOES');
+  glTexGeniOES := dlsym(glesLibrary, 'glTexGeniOES');
+  glTexGenivOES := dlsym(glesLibrary, 'glTexGenivOES');
+  glGetTexGenfvOES := dlsym(glesLibrary, 'glGetTexGenfvOES');
+  glGetTexGenivOES := dlsym(glesLibrary, 'glGetTexGenivOES');
+  {$EndIf}
+
+  {$IfDef GL_IMG_user_clip_plane}
+  glClipPlanefIMG := dlsym(glesLibrary, 'glClipPlanefIMG');
+  glClipPlanexIMG := dlsym(glesLibrary, 'glClipPlanexIMG');
+  {$EndIf}
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_2_0}
+  glActiveTexture := dlsym(glesLibrary, 'glActiveTexture');
+  glAttachShader := dlsym(glesLibrary, 'glAttachShader');
+  glBindAttribLocation := dlsym(glesLibrary, 'glBindAttribLocation');
+  glBindBuffer := dlsym(glesLibrary, 'glBindBuffer');
+// min GLES function - glBindFramebuffer := dlsym(glesLibrary, 'glBindFramebuffer');
+// min GLES function - glBindRenderbuffer := dlsym(glesLibrary, 'glBindRenderbuffer');
+// min GLES function - glBindTexture := dlsym(glesLibrary, 'glBindTexture');
+  glBlendColor := dlsym(glesLibrary, 'glBlendColor');
+// min GLES function - glBlendEquation := dlsym(glesLibrary, 'glBlendEquation');
+  glBlendEquationSeparate := dlsym(glesLibrary, 'glBlendEquationSeparate');
+// min GLES function - glBlendFunc := dlsym(glesLibrary, 'glBlendFunc');
+// min GLES function - glBlendFuncSeparate := dlsym(glesLibrary, 'glBlendFuncSeparate');
+  glBufferData := dlsym(glesLibrary, 'glBufferData');
+  glBufferSubData := dlsym(glesLibrary, 'glBufferSubData');
+// min GLES function - glCheckFramebufferStatus := dlsym(glesLibrary, 'glCheckFramebufferStatus');
+// min GLES function - glClear := dlsym(glesLibrary, 'glClear');
+// min GLES function - glClearColor := dlsym(glesLibrary, 'glClearColor');
+// min GLES function - glClearDepthf := dlsym(glesLibrary, 'glClearDepthf');
+  glClearStencil := dlsym(glesLibrary, 'glClearStencil');
+// min GLES function - glColorMask := dlsym(glesLibrary, 'glColorMask');
+  glCompileShader := dlsym(glesLibrary, 'glCompileShader');
+// min GLES function - glCompressedTexImage2D := dlsym(glesLibrary, 'glCompressedTexImage2D');
+// min GLES function - glCompressedTexSubImage2D := dlsym(glesLibrary, 'glCompressedTexSubImage2D');
+  glCopyTexImage2D := dlsym(glesLibrary, 'glCopyTexImage2D');
+// min GLES function - glCopyTexSubImage2D := dlsym(glesLibrary, 'glCopyTexSubImage2D');
+  glCreateProgram := dlsym(glesLibrary, 'glCreateProgram');
+  glCreateShader := dlsym(glesLibrary, 'glCreateShader');
+  glCullFace := dlsym(glesLibrary, 'glCullFace');
+  glDeleteBuffers := dlsym(glesLibrary, 'glDeleteBuffers');
+// min GLES function - glDeleteFramebuffers := dlsym(glesLibrary, 'glDeleteFramebuffers');
+  glDeleteProgram := dlsym(glesLibrary, 'glDeleteProgram');
+// min GLES function - glDeleteRenderbuffers := dlsym(glesLibrary, 'glDeleteRenderbuffers');
+  glDeleteShader := dlsym(glesLibrary, 'glDeleteShader');
+// min GLES function - glDeleteTextures := dlsym(glesLibrary, 'glDeleteTextures');
+// min GLES function - glDepthFunc := dlsym(glesLibrary, 'glDepthFunc');
+// min GLES function - glDepthMask := dlsym(glesLibrary, 'glDepthMask');
+  glDepthRangef := dlsym(glesLibrary, 'glDepthRangef');
+  glDetachShader := dlsym(glesLibrary, 'glDetachShader');
+// min GLES function - glDisable := dlsym(glesLibrary, 'glDisable');
+  glDisableVertexAttribArray := dlsym(glesLibrary, 'glDisableVertexAttribArray');
+// min GLES function - glDrawArrays := dlsym(glesLibrary, 'glDrawArrays');
+// min GLES function - glDrawElements := dlsym(glesLibrary, 'glDrawElements');
+// min GLES function - glEnable := dlsym(glesLibrary, 'glEnable');
+  glEnableVertexAttribArray := dlsym(glesLibrary, 'glEnableVertexAttribArray');
+  glFinish := dlsym(glesLibrary, 'glFinish');
+  glFlush := dlsym(glesLibrary, 'glFlush');
+// min GLES function - glFramebufferRenderbuffer := dlsym(glesLibrary, 'glFramebufferRenderbuffer');
+// min GLES function - glFramebufferTexture2D := dlsym(glesLibrary, 'glFramebufferTexture2D');
+  glFrontFace := dlsym(glesLibrary, 'glFrontFace');
+  glGenBuffers := dlsym(glesLibrary, 'glGenBuffers');
+// min GLES function - glGenerateMipmap := dlsym(glesLibrary, 'glGenerateMipmap');
+// min GLES function - glGenFramebuffers := dlsym(glesLibrary, 'glGenFramebuffers');
+// min GLES function - glGenRenderbuffers := dlsym(glesLibrary, 'glGenRenderbuffers');
+// min GLES function - glGenTextures := dlsym(glesLibrary, 'glGenTextures');
+  glGetActiveAttrib := dlsym(glesLibrary, 'glGetActiveAttrib');
+  glGetActiveUniform := dlsym(glesLibrary, 'glGetActiveUniform');
+  glGetAttachedShaders := dlsym(glesLibrary, 'glGetAttachedShaders');
+  glGetAttribLocation := dlsym(glesLibrary, 'glGetAttribLocation');
+  glGetBooleanv := dlsym(glesLibrary, 'glGetBooleanv');
+  glGetBufferParameteriv := dlsym(glesLibrary, 'glGetBufferParameteriv');
+  glGetError := dlsym(glesLibrary, 'glGetError');
+// min GLES function - glGetFloatv := dlsym(glesLibrary, 'glGetFloatv');
+// min GLES function - glGetFramebufferAttachmentParameteriv := dlsym(glesLibrary, 'glGetFramebufferAttachmentParameteriv');
+// min GLES function - glGetIntegerv := dlsym(glesLibrary, 'glGetIntegerv');
+  glGetProgramiv := dlsym(glesLibrary, 'glGetProgramiv');
+  glGetProgramInfoLog := dlsym(glesLibrary, 'glGetProgramInfoLog');
+// min GLES function - glGetRenderbufferParameteriv := dlsym(glesLibrary, 'glGetRenderbufferParameteriv');
+  glGetShaderiv := dlsym(glesLibrary, 'glGetShaderiv');
+  glGetShaderInfoLog := dlsym(glesLibrary, 'glGetShaderInfoLog');
+  glGetShaderPrecisionFormat := dlsym(glesLibrary, 'glGetShaderPrecisionFormat');
+  glGetShaderSource := dlsym(glesLibrary, 'glGetShaderSource');
+  // min GLES function - glGetString := dlsym(glesLibrary, 'glGetString');
+  glGetTexParameterfv := dlsym(glesLibrary, 'glGetTexParameterfv');
+  glGetTexParameteriv := dlsym(glesLibrary, 'glGetTexParameteriv');
+  glGetUniformfv := dlsym(glesLibrary, 'glGetUniformfv');
+  glGetUniformiv := dlsym(glesLibrary, 'glGetUniformiv');
+  glGetUniformLocation := dlsym(glesLibrary, 'glGetUniformLocation');
+  glGetVertexAttribfv := dlsym(glesLibrary, 'glGetVertexAttribfv');
+  glGetVertexAttribiv := dlsym(glesLibrary, 'glGetVertexAttribiv');
+  glGetVertexAttribPointerv := dlsym(glesLibrary, 'glGetVertexAttribPointerv');
+// min GLES function - glHint := dlsym(glesLibrary, 'glHint');
+  glIsBuffer := dlsym(glesLibrary, 'glIsBuffer');
+  glIsEnabled := dlsym(glesLibrary, 'glIsEnabled');
+// min GLES function - glIsFramebuffer := dlsym(glesLibrary, 'glIsFramebuffer');
+  glIsProgram := dlsym(glesLibrary, 'glIsProgram');
+// min GLES function - glIsRenderbuffer := dlsym(glesLibrary, 'glIsRenderbuffer');
+  glIsShader := dlsym(glesLibrary, 'glIsShader');
+  glIsTexture := dlsym(glesLibrary, 'glIsTexture');
+  glLineWidth := dlsym(glesLibrary, 'glLineWidth');
+  glLinkProgram := dlsym(glesLibrary, 'glLinkProgram');
+// min GLES function - glPixelStorei := dlsym(glesLibrary, 'glPixelStorei');
+  glPolygonOffset := dlsym(glesLibrary, 'glPolygonOffset');
+//  // min GLES function - glReadPixels := dlsym(glesLibrary, 'glReadPixels');
+  glReleaseShaderCompiler := dlsym(glesLibrary, 'glReleaseShaderCompiler');
+// min GLES function - glRenderbufferStorage := dlsym(glesLibrary, 'glRenderbufferStorage');
+  glSampleCoverage := dlsym(glesLibrary, 'glSampleCoverage');
+// min GLES function - glScissor := dlsym(glesLibrary, 'glScissor');
+  glShaderBinary := dlsym(glesLibrary, 'glShaderBinary');
+  glShaderSource := dlsym(glesLibrary, 'glShaderSource');
+  glStencilFunc := dlsym(glesLibrary, 'glStencilFunc');
+  glStencilFuncSeparate := dlsym(glesLibrary, 'glStencilFuncSeparate');
+  glStencilMask := dlsym(glesLibrary, 'glStencilMask');
+  glStencilMaskSeparate := dlsym(glesLibrary, 'glStencilMaskSeparate');
+  glStencilOp := dlsym(glesLibrary, 'glStencilOp');
+  glStencilOpSeparate := dlsym(glesLibrary, 'glStencilOpSeparate');
+// min GLES function - glTexImage2D := dlsym(glesLibrary, 'glTexImage2D');
+// min GLES function - glTexParameterf := dlsym(glesLibrary, 'glTexParameterf');
+  glTexParameterfv := dlsym(glesLibrary, 'glTexParameterfv');
+// min GLES function - glTexParameteri := dlsym(glesLibrary, 'glTexParameteri');
+// min GLES function - glTexParameteriv := dlsym(glesLibrary, 'glTexParameteriv');
+// min GLES function - glTexSubImage2D := dlsym(glesLibrary, 'glTexSubImage2D');
+  glUniform1f := dlsym(glesLibrary, 'glUniform1f');
+  glUniform1fv := dlsym(glesLibrary, 'glUniform1fv');
+  glUniform1i := dlsym(glesLibrary, 'glUniform1i');
+  glUniform1iv := dlsym(glesLibrary, 'glUniform1iv');
+  glUniform2f := dlsym(glesLibrary, 'glUniform2f');
+  glUniform2fv := dlsym(glesLibrary, 'glUniform2fv');
+  glUniform2i := dlsym(glesLibrary, 'glUniform2i');
+  glUniform2iv := dlsym(glesLibrary, 'glUniform2iv');
+  glUniform3f := dlsym(glesLibrary, 'glUniform3f');
+  glUniform3fv := dlsym(glesLibrary, 'glUniform3fv');
+  glUniform3i := dlsym(glesLibrary, 'glUniform3i');
+  glUniform3iv := dlsym(glesLibrary, 'glUniform3iv');
+  glUniform4f := dlsym(glesLibrary, 'glUniform4f');
+  glUniform4fv := dlsym(glesLibrary, 'glUniform4fv');
+  glUniform4i := dlsym(glesLibrary, 'glUniform4i');
+  glUniform4iv := dlsym(glesLibrary, 'glUniform4iv');
+  glUniformMatrix2fv := dlsym(glesLibrary, 'glUniformMatrix2fv');
+  glUniformMatrix3fv := dlsym(glesLibrary, 'glUniformMatrix3fv');
+  glUniformMatrix4fv := dlsym(glesLibrary, 'glUniformMatrix4fv');
+  glUseProgram := dlsym(glesLibrary, 'glUseProgram');
+  glValidateProgram := dlsym(glesLibrary, 'glValidateProgram');
+  glVertexAttrib1f := dlsym(glesLibrary, 'glVertexAttrib1f');
+  glVertexAttrib1fv := dlsym(glesLibrary, 'glVertexAttrib1fv');
+  glVertexAttrib2f := dlsym(glesLibrary, 'glVertexAttrib2f');
+  glVertexAttrib2fv := dlsym(glesLibrary, 'glVertexAttrib2fv');
+  glVertexAttrib3f := dlsym(glesLibrary, 'glVertexAttrib3f');
+  glVertexAttrib3fv := dlsym(glesLibrary, 'glVertexAttrib3fv');
+  glVertexAttrib4f := dlsym(glesLibrary, 'glVertexAttrib4f');
+  glVertexAttrib4fv := dlsym(glesLibrary, 'glVertexAttrib4fv');
+  glVertexAttribPointer := dlsym(glesLibrary, 'glVertexAttribPointer');
+// min GLES function - glViewport := dlsym(glesLibrary, 'glViewport');
+{$EndIf}
+
+{$IfDef GL_KHR_blend_equation_advanced}
+  glBlendBarrierKHR := dlsym(glesLibrary, 'glBlendBarrierKHR');
+{$EndIf}
+
+{$IfDef GL_KHR_debug}
+  glDebugMessageControlKHR := dlsym(glesLibrary, 'glDebugMessageControlKHR');
+  glDebugMessageInsertKHR := dlsym(glesLibrary, 'glDebugMessageInsertKHR');
+  glDebugMessageCallbackKHR := dlsym(glesLibrary, 'glDebugMessageCallbackKHR');
+  glGetDebugMessageLogKHR := dlsym(glesLibrary, 'glGetDebugMessageLogKHR');
+  glPushDebugGroupKHR := dlsym(glesLibrary, 'glPushDebugGroupKHR');
+  glPopDebugGroupKHR := dlsym(glesLibrary, 'glPopDebugGroupKHR');
+  glObjectLabelKHR := dlsym(glesLibrary, 'glObjectLabelKHR');
+  glGetObjectLabelKHR := dlsym(glesLibrary, 'glGetObjectLabelKHR');
+  glObjectPtrLabelKHR := dlsym(glesLibrary, 'glObjectPtrLabelKHR');
+  glGetObjectPtrLabelKHR := dlsym(glesLibrary, 'glGetObjectPtrLabelKHR');
+  glGetPointervKHR := dlsym(glesLibrary, 'glGetPointervKHR');
+{$EndIf}
+
+{$IfDef GL_KHR_parallel_shader_compile}
+  glMaxShaderCompilerThreadsKHR := dlsym(glesLibrary, 'glMaxShaderCompilerThreadsKHR');
+{$EndIf}
+
+{$IfDef GL_KHR_robustness}
+  glGetGraphicsResetStatusKHR := dlsym(glesLibrary, 'glGetGraphicsResetStatusKHR');
+  glReadnPixelsKHR := dlsym(glesLibrary, 'glReadnPixelsKHR');
+  glGetnUniformfvKHR := dlsym(glesLibrary, 'glGetnUniformfvKHR');
+  glGetnUniformivKHR := dlsym(glesLibrary, 'glGetnUniformivKHR');
+  glGetnUniformuivKHR := dlsym(glesLibrary, 'glGetnUniformuivKHR');
+{$EndIf}
+
+{$IfDef GL_OES_EGL_image}
+  glEGLImageTargetTexture2DOES := dlsym(glesLibrary, 'glEGLImageTargetTexture2DOES');
+  glEGLImageTargetRenderbufferStorageOES := dlsym(glesLibrary, 'glEGLImageTargetRenderbufferStorageOES');
+{$EndIf}
+
+{$IfDef GL_OES_copy_image}
+  glCopyImageSubDataOES := dlsym(glesLibrary, 'glCopyImageSubDataOES');
+{$EndIf}
+
+{$IfDef GL_OES_draw_buffers_indexed}
+  glEnableiOES := dlsym(glesLibrary, 'glEnableiOES');
+  glDisableiOES := dlsym(glesLibrary, 'glDisableiOES');
+  glBlendEquationiOES := dlsym(glesLibrary, 'glBlendEquationiOES');
+  glBlendEquationSeparateiOES := dlsym(glesLibrary, 'glBlendEquationSeparateiOES');
+  glBlendFunciOES := dlsym(glesLibrary, 'glBlendFunciOES');
+  glBlendFuncSeparateiOES := dlsym(glesLibrary, 'glBlendFuncSeparateiOES');
+  glColorMaskiOES := dlsym(glesLibrary, 'glColorMaskiOES');
+  glIsEnablediOES := dlsym(glesLibrary, 'glIsEnablediOES');
+{$EndIf}
+
+{$IfDef GL_OES_draw_elements_base_vertex}
+  glDrawElementsBaseVertexOES := dlsym(glesLibrary, 'glDrawElementsBaseVertexOES');
+  glDrawRangeElementsBaseVertexOES := dlsym(glesLibrary, 'glDrawRangeElementsBaseVertexOES');
+  glDrawElementsInstancedBaseVertexOES := dlsym(glesLibrary, 'glDrawElementsInstancedBaseVertexOES');
+  glMultiDrawElementsBaseVertexEXT := dlsym(glesLibrary, 'glMultiDrawElementsBaseVertexEXT');
+{$EndIf}
+
+{$IfDef GL_OES_geometry_shader}
+  glFramebufferTextureOES := dlsym(glesLibrary, 'glFramebufferTextureOES');
+{$EndIf}
+
+{$IfDef GL_OES_get_program_binary}
+  glGetProgramBinaryOES := dlsym(glesLibrary, 'glGetProgramBinaryOES');
+  glProgramBinaryOES := dlsym(glesLibrary, 'glProgramBinaryOES');
+{$EndIf}
+
+{$IfDef GL_OES_mapbuffer}
+  glMapBufferOES := dlsym(glesLibrary, 'glMapBufferOES');
+  glUnmapBufferOES := dlsym(glesLibrary, 'glUnmapBufferOES');
+  glGetBufferPointervOES := dlsym(glesLibrary, 'glGetBufferPointervOES');
+{$EndIf}
+
+{$IfDef GL_OES_primitive_bounding_box}
+  glPrimitiveBoundingBoxOES := dlsym(glesLibrary, 'glPrimitiveBoundingBoxOES');
+{$EndIf}
+
+{$IfDef GL_OES_sample_shading}
+  glMinSampleShadingOES := dlsym(glesLibrary, 'glMinSampleShadingOES');
+{$EndIf}
+
+{$IfDef GL_OES_tessellation_shader}
+  glPatchParameteriOES := dlsym(glesLibrary, 'glPatchParameteriOES');
+{$EndIf}
+
+{$IfDef GL_OES_texture_3D}
+  glTexImage3DOES := dlsym(glesLibrary, 'glTexImage3DOES');
+  glTexSubImage3DOES := dlsym(glesLibrary, 'glTexSubImage3DOES');
+  glCopyTexSubImage3DOES := dlsym(glesLibrary, 'glCopyTexSubImage3DOES');
+  glCompressedTexImage3DOES := dlsym(glesLibrary, 'glCompressedTexImage3DOES');
+  glCompressedTexSubImage3DOES := dlsym(glesLibrary, 'glCompressedTexSubImage3DOES');
+  glFramebufferTexture3DOES := dlsym(glesLibrary, 'glFramebufferTexture3DOES');
+{$EndIf}
+
+{$IfDef GL_OES_texture_border_clamp}
+  glTexParameterIivOES := dlsym(glesLibrary, 'glTexParameterIivOES');
+  glTexParameterIuivOES := dlsym(glesLibrary, 'glTexParameterIuivOES');
+  glGetTexParameterIivOES := dlsym(glesLibrary, 'glGetTexParameterIivOES');
+  glGetTexParameterIuivOES := dlsym(glesLibrary, 'glGetTexParameterIuivOES');
+  glSamplerParameterIivOES := dlsym(glesLibrary, 'glSamplerParameterIivOES');
+  glSamplerParameterIuivOES := dlsym(glesLibrary, 'glSamplerParameterIuivOES');
+  glGetSamplerParameterIivOES := dlsym(glesLibrary, 'glGetSamplerParameterIivOES');
+  glGetSamplerParameterIuivOES := dlsym(glesLibrary, 'glGetSamplerParameterIuivOES');
+{$EndIf}
+
+{$IfDef GL_OES_texture_buffer}
+  glTexBufferOES := dlsym(glesLibrary, 'glTexBufferOES');
+  glTexBufferRangeOES := dlsym(glesLibrary, 'glTexBufferRangeOES');
+{$EndIf}
+
+{$IfDef GL_OES_texture_storage_multisample_2d_array}
+  glTexStorage3DMultisampleOES := dlsym(glesLibrary, 'glTexStorage3DMultisampleOES');
+{$EndIf}
+
+{$IfDef GL_OES_texture_view}
+  glTextureViewOES := dlsym(glesLibrary, 'glTextureViewOES');
+{$EndIf}
+
+{$IfDef GL_OES_vertex_array_object}
+  glBindVertexArrayOES := dlsym(glesLibrary, 'glBindVertexArrayOES');
+  glDeleteVertexArraysOES := dlsym(glesLibrary, 'glDeleteVertexArraysOES');
+  glGenVertexArraysOES := dlsym(glesLibrary, 'glGenVertexArraysOES');
+  glIsVertexArrayOES := dlsym(glesLibrary, 'glIsVertexArrayOES');
+{$EndIf}
+
+{$IfDef GL_OES_viewport_array}
+  glViewportArrayvOES := dlsym(glesLibrary, 'glViewportArrayvOES');
+  glViewportIndexedfOES := dlsym(glesLibrary, 'glViewportIndexedfOES');
+  glViewportIndexedfvOES := dlsym(glesLibrary, 'glViewportIndexedfvOES');
+  glScissorArrayvOES := dlsym(glesLibrary, 'glScissorArrayvOES');
+  glScissorIndexedOES := dlsym(glesLibrary, 'glScissorIndexedOES');
+  glScissorIndexedvOES := dlsym(glesLibrary, 'glScissorIndexedvOES');
+  glDepthRangeArrayfvOES := dlsym(glesLibrary, 'glDepthRangeArrayfvOES');
+  glDepthRangeIndexedfOES := dlsym(glesLibrary, 'glDepthRangeIndexedfOES');
+  glGetFloati_vOES := dlsym(glesLibrary, 'glGetFloati_vOES');
+{$EndIf}
+
+{$IfDef GL_AMD_framebuffer_multisample_advanced}
+  glRenderbufferStorageMultisampleAdvancedAMD := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleAdvancedAMD');
+  glNamedRenderbufferStorageMultisampleAdvancedAMD := dlsym(glesLibrary, 'glNamedRenderbufferStorageMultisampleAdvancedAMD');
+{$EndIf}
+
+{$IfDef GL_AMD_performance_monitor}
+  glGetPerfMonitorGroupsAMD := dlsym(glesLibrary, 'glGetPerfMonitorGroupsAMD');
+  glGetPerfMonitorCountersAMD := dlsym(glesLibrary, 'glGetPerfMonitorCountersAMD');
+  glGetPerfMonitorGroupStringAMD := dlsym(glesLibrary, 'glGetPerfMonitorGroupStringAMD');
+  glGetPerfMonitorCounterStringAMD := dlsym(glesLibrary, 'glGetPerfMonitorCounterStringAMD');
+  glGetPerfMonitorCounterInfoAMD := dlsym(glesLibrary, 'glGetPerfMonitorCounterInfoAMD');
+  glGenPerfMonitorsAMD := dlsym(glesLibrary, 'glGenPerfMonitorsAMD');
+  glDeletePerfMonitorsAMD := dlsym(glesLibrary, 'glDeletePerfMonitorsAMD');
+  glSelectPerfMonitorCountersAMD := dlsym(glesLibrary, 'glSelectPerfMonitorCountersAMD');
+  glBeginPerfMonitorAMD := dlsym(glesLibrary, 'glBeginPerfMonitorAMD');
+  glEndPerfMonitorAMD := dlsym(glesLibrary, 'glEndPerfMonitorAMD');
+  glGetPerfMonitorCounterDataAMD := dlsym(glesLibrary, 'glGetPerfMonitorCounterDataAMD');
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_blit}
+  glBlitFramebufferANGLE := dlsym(glesLibrary, 'glBlitFramebufferANGLE');
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleANGLE := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleANGLE');
+{$EndIf}
+
+{$IfDef GL_ANGLE_instanced_arrays}
+  glDrawArraysInstancedANGLE := dlsym(glesLibrary, 'glDrawArraysInstancedANGLE');
+  glDrawElementsInstancedANGLE := dlsym(glesLibrary, 'glDrawElementsInstancedANGLE');
+  glVertexAttribDivisorANGLE := dlsym(glesLibrary, 'glVertexAttribDivisorANGLE');
+{$EndIf}
+
+{$IfDef GL_ANGLE_translated_shader_source}
+  glGetTranslatedShaderSourceANGLE := dlsym(glesLibrary, 'glGetTranslatedShaderSourceANGLE');
+{$EndIf}
+
+{$IfDef GL_APPLE_copy_texture_levels}
+  glCopyTextureLevelsAPPLE := dlsym(glesLibrary, 'glCopyTextureLevelsAPPLE');
+{$EndIf}
+
+{$IfDef GL_APPLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleAPPLE := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleAPPLE');
+  glResolveMultisampleFramebufferAPPLE := dlsym(glesLibrary, 'glResolveMultisampleFramebufferAPPLE');
+{$EndIf}
+
+{$IfDef GL_APPLE_sync}
+  glFenceSyncAPPLE := dlsym(glesLibrary, 'glFenceSyncAPPLE');
+  glIsSyncAPPLE := dlsym(glesLibrary, 'glIsSyncAPPLE');
+  glDeleteSyncAPPLE := dlsym(glesLibrary, 'glDeleteSyncAPPLE');
+  glClientWaitSyncAPPLE := dlsym(glesLibrary, 'glClientWaitSyncAPPLE');
+  glWaitSyncAPPLE := dlsym(glesLibrary, 'glWaitSyncAPPLE');
+  glGetInteger64vAPPLE := dlsym(glesLibrary, 'glGetInteger64vAPPLE');
+  glGetSyncivAPPLE := dlsym(glesLibrary, 'glGetSyncivAPPLE');
+{$EndIf}
+
+{$IfDef GL_EXT_EGL_image_storage}
+  glEGLImageTargetTexStorageEXT := dlsym(glesLibrary, 'glEGLImageTargetTexStorageEXT');
+  glEGLImageTargetTextureStorageEXT := dlsym(glesLibrary, 'glEGLImageTargetTextureStorageEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_base_instance}
+  glDrawArraysInstancedBaseInstanceEXT := dlsym(glesLibrary, 'glDrawArraysInstancedBaseInstanceEXT');
+  glDrawElementsInstancedBaseInstanceEXT := dlsym(glesLibrary, 'glDrawElementsInstancedBaseInstanceEXT');
+  glDrawElementsInstancedBaseVertexBaseInstanceEXT := dlsym(glesLibrary, 'glDrawElementsInstancedBaseVertexBaseInstanceEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_blend_func_extended}
+  glBindFragDataLocationIndexedEXT := dlsym(glesLibrary, 'glBindFragDataLocationIndexedEXT');
+  glBindFragDataLocationEXT := dlsym(glesLibrary, 'glBindFragDataLocationEXT');
+  glGetProgramResourceLocationIndexEXT := dlsym(glesLibrary, 'glGetProgramResourceLocationIndexEXT');
+  glGetFragDataIndexEXT := dlsym(glesLibrary, 'glGetFragDataIndexEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_buffer_storage}
+  glBufferStorageEXT := dlsym(glesLibrary, 'glBufferStorageEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_clear_texture}
+  glClearTexImageEXT := dlsym(glesLibrary, 'glClearTexImageEXT');
+  glClearTexSubImageEXT := dlsym(glesLibrary, 'glClearTexSubImageEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_clip_control}
+  glClipControlEXT := dlsym(glesLibrary, 'glClipControlEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_copy_image}
+  glCopyImageSubDataEXT := dlsym(glesLibrary, 'glCopyImageSubDataEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_debug_label}
+  glLabelObjectEXT := dlsym(glesLibrary, 'glLabelObjectEXT');
+  glGetObjectLabelEXT := dlsym(glesLibrary, 'glGetObjectLabelEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_debug_marker}
+  glInsertEventMarkerEXT := dlsym(glesLibrary, 'glInsertEventMarkerEXT');
+  glPushGroupMarkerEXT := dlsym(glesLibrary, 'glPushGroupMarkerEXT');
+  glPopGroupMarkerEXT := dlsym(glesLibrary, 'glPopGroupMarkerEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_discard_framebuffer}
+  glDiscardFramebufferEXT := dlsym(glesLibrary, 'glDiscardFramebufferEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_disjoint_timer_query}
+  glGenQueriesEXT := dlsym(glesLibrary, 'glGenQueriesEXT');
+  glDeleteQueriesEXT := dlsym(glesLibrary, 'glDeleteQueriesEXT');
+  glIsQueryEXT := dlsym(glesLibrary, 'glIsQueryEXT');
+  glBeginQueryEXT := dlsym(glesLibrary, 'glBeginQueryEXT');
+  glEndQueryEXT := dlsym(glesLibrary, 'glEndQueryEXT');
+  glQueryCounterEXT := dlsym(glesLibrary, 'glQueryCounterEXT');
+  glGetQueryivEXT := dlsym(glesLibrary, 'glGetQueryivEXT');
+  glGetQueryObjectivEXT := dlsym(glesLibrary, 'glGetQueryObjectivEXT');
+  glGetQueryObjectuivEXT := dlsym(glesLibrary, 'glGetQueryObjectuivEXT');
+  glGetQueryObjecti64vEXT := dlsym(glesLibrary, 'glGetQueryObjecti64vEXT');
+  glGetQueryObjectui64vEXT := dlsym(glesLibrary, 'glGetQueryObjectui64vEXT');
+  glGetInteger64vEXT := dlsym(glesLibrary, 'glGetInteger64vEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_draw_buffers}
+  glDrawBuffersEXT := dlsym(glesLibrary, 'glDrawBuffersEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_draw_elements_base_vertex}
+  glDrawElementsBaseVertexEXT := dlsym(glesLibrary, 'glDrawElementsBaseVertexEXT');
+  glDrawRangeElementsBaseVertexEXT := dlsym(glesLibrary, 'glDrawRangeElementsBaseVertexEXT');
+  glDrawElementsInstancedBaseVertexEXT := dlsym(glesLibrary, 'glDrawElementsInstancedBaseVertexEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_draw_instanced}
+  glDrawArraysInstancedEXT := dlsym(glesLibrary, 'glDrawArraysInstancedEXT');
+  glDrawElementsInstancedEXT := dlsym(glesLibrary, 'glDrawElementsInstancedEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_draw_transform_feedback}
+  glDrawTransformFeedbackEXT := dlsym(glesLibrary, 'glDrawTransformFeedbackEXT');
+  glDrawTransformFeedbackInstancedEXT := dlsym(glesLibrary, 'glDrawTransformFeedbackInstancedEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_external_buffer}
+  glBufferStorageExternalEXT := dlsym(glesLibrary, 'glBufferStorageExternalEXT');
+  glNamedBufferStorageExternalEXT := dlsym(glesLibrary, 'glNamedBufferStorageExternalEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_fragment_shading_rate}
+  glGetFragmentShadingRatesEXT := dlsym(glesLibrary, 'glGetFragmentShadingRatesEXT');
+  glShadingRateEXT := dlsym(glesLibrary, 'glShadingRateEXT');
+  glShadingRateCombinerOpsEXT := dlsym(glesLibrary, 'glShadingRateCombinerOpsEXT');
+  glFramebufferShadingRateEXT := dlsym(glesLibrary, 'glFramebufferShadingRateEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_framebuffer_blit_layers}
+  glBlitFramebufferLayersEXT := dlsym(glesLibrary, 'glBlitFramebufferLayersEXT');
+  glBlitFramebufferLayerEXT := dlsym(glesLibrary, 'glBlitFramebufferLayerEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_geometry_shader}
+  glFramebufferTextureEXT := dlsym(glesLibrary, 'glFramebufferTextureEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_instanced_arrays}
+  glVertexAttribDivisorEXT := dlsym(glesLibrary, 'glVertexAttribDivisorEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_map_buffer_range}
+  glMapBufferRangeEXT := dlsym(glesLibrary, 'glMapBufferRangeEXT');
+  glFlushMappedBufferRangeEXT := dlsym(glesLibrary, 'glFlushMappedBufferRangeEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object}
+  glGetUnsignedBytevEXT := dlsym(glesLibrary, 'glGetUnsignedBytevEXT');
+  glGetUnsignedBytei_vEXT := dlsym(glesLibrary, 'glGetUnsignedBytei_vEXT');
+  glDeleteMemoryObjectsEXT := dlsym(glesLibrary, 'glDeleteMemoryObjectsEXT');
+  glIsMemoryObjectEXT := dlsym(glesLibrary, 'glIsMemoryObjectEXT');
+  glCreateMemoryObjectsEXT := dlsym(glesLibrary, 'glCreateMemoryObjectsEXT');
+  glMemoryObjectParameterivEXT := dlsym(glesLibrary, 'glMemoryObjectParameterivEXT');
+  glGetMemoryObjectParameterivEXT := dlsym(glesLibrary, 'glGetMemoryObjectParameterivEXT');
+  glTexStorageMem2DEXT := dlsym(glesLibrary, 'glTexStorageMem2DEXT');
+  glTexStorageMem2DMultisampleEXT := dlsym(glesLibrary, 'glTexStorageMem2DMultisampleEXT');
+  glTexStorageMem3DEXT := dlsym(glesLibrary, 'glTexStorageMem3DEXT');
+  glTexStorageMem3DMultisampleEXT := dlsym(glesLibrary, 'glTexStorageMem3DMultisampleEXT');
+  glBufferStorageMemEXT := dlsym(glesLibrary, 'glBufferStorageMemEXT');
+  glTextureStorageMem2DEXT := dlsym(glesLibrary, 'glTextureStorageMem2DEXT');
+  glTextureStorageMem2DMultisampleEXT := dlsym(glesLibrary, 'glTextureStorageMem2DMultisampleEXT');
+  glTextureStorageMem3DEXT := dlsym(glesLibrary, 'glTextureStorageMem3DEXT');
+  glTextureStorageMem3DMultisampleEXT := dlsym(glesLibrary, 'glTextureStorageMem3DMultisampleEXT');
+  glNamedBufferStorageMemEXT := dlsym(glesLibrary, 'glNamedBufferStorageMemEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_fd}
+  glImportMemoryFdEXT := dlsym(glesLibrary, 'glImportMemoryFdEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_win32}
+  glImportMemoryWin32HandleEXT := dlsym(glesLibrary, 'glImportMemoryWin32HandleEXT');
+  glImportMemoryWin32NameEXT := dlsym(glesLibrary, 'glImportMemoryWin32NameEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_arrays}
+  glMultiDrawArraysEXT := dlsym(glesLibrary, 'glMultiDrawArraysEXT');
+  glMultiDrawElementsEXT := dlsym(glesLibrary, 'glMultiDrawElementsEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_indirect}
+  glMultiDrawArraysIndirectEXT := dlsym(glesLibrary, 'glMultiDrawArraysIndirectEXT');
+  glMultiDrawElementsIndirectEXT := dlsym(glesLibrary, 'glMultiDrawElementsIndirectEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleEXT := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleEXT');
+  glFramebufferTexture2DMultisampleEXT := dlsym(glesLibrary, 'glFramebufferTexture2DMultisampleEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_multiview_draw_buffers}
+  glReadBufferIndexedEXT := dlsym(glesLibrary, 'glReadBufferIndexedEXT');
+  glDrawBuffersIndexedEXT := dlsym(glesLibrary, 'glDrawBuffersIndexedEXT');
+  glGetIntegeri_vEXT := dlsym(glesLibrary, 'glGetIntegeri_vEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_polygon_offset_clamp}
+   glPolygonOffsetClampEXT := dlsym(glesLibrary, 'glPolygonOffsetClampEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_primitive_bounding_box}
+  glPrimitiveBoundingBoxEXT := dlsym(glesLibrary, 'glPrimitiveBoundingBoxEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_raster_multisample}
+  glRasterSamplesEXT := dlsym(glesLibrary, 'glRasterSamplesEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_robustness}
+  glGetGraphicsResetStatusEXT := dlsym(glesLibrary, 'glGetGraphicsResetStatusEXT');
+  glReadnPixelsEXT := dlsym(glesLibrary, 'glReadnPixelsEXT');
+  glGetnUniformfvEXT := dlsym(glesLibrary, 'glGetnUniformfvEXT');
+  glGetnUniformivEXT := dlsym(glesLibrary, 'glGetnUniformivEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore}
+  glGenSemaphoresEXT := dlsym(glesLibrary, 'glGenSemaphoresEXT');
+  glDeleteSemaphoresEXT := dlsym(glesLibrary, 'glDeleteSemaphoresEXT');
+  glIsSemaphoreEXT := dlsym(glesLibrary, 'glIsSemaphoreEXT');
+  glSemaphoreParameterui64vEXT := dlsym(glesLibrary, 'glSemaphoreParameterui64vEXT');
+  glGetSemaphoreParameterui64vEXT := dlsym(glesLibrary, 'glGetSemaphoreParameterui64vEXT');
+  glWaitSemaphoreEXT := dlsym(glesLibrary, 'glWaitSemaphoreEXT');
+  glSignalSemaphoreEXT := dlsym(glesLibrary, 'glSignalSemaphoreEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_fd}
+  glImportSemaphoreFdEXT := dlsym(glesLibrary, 'glImportSemaphoreFdEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_win32}
+  glImportSemaphoreWin32HandleEXT := dlsym(glesLibrary, 'glImportSemaphoreWin32HandleEXT');
+  glImportSemaphoreWin32NameEXT := dlsym(glesLibrary, 'glImportSemaphoreWin32NameEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_separate_shader_objects}
+  glActiveShaderProgramEXT := dlsym(glesLibrary, 'glActiveShaderProgramEXT');
+  glBindProgramPipelineEXT := dlsym(glesLibrary, 'glBindProgramPipelineEXT');
+  glCreateShaderProgramvEXT := dlsym(glesLibrary, 'glCreateShaderProgramvEXT');
+  glDeleteProgramPipelinesEXT := dlsym(glesLibrary, 'glDeleteProgramPipelinesEXT');
+  glGenProgramPipelinesEXT := dlsym(glesLibrary, 'glGenProgramPipelinesEXT');
+  glGetProgramPipelineInfoLogEXT := dlsym(glesLibrary, 'glGetProgramPipelineInfoLogEXT');
+  glGetProgramPipelineivEXT := dlsym(glesLibrary, 'glGetProgramPipelineivEXT');
+  glIsProgramPipelineEXT := dlsym(glesLibrary, 'glIsProgramPipelineEXT');
+  glProgramParameteriEXT := dlsym(glesLibrary, 'glProgramParameteriEXT');
+  glProgramUniform1fEXT := dlsym(glesLibrary, 'glProgramUniform1fEXT');
+  glProgramUniform1fvEXT := dlsym(glesLibrary, 'glProgramUniform1fvEXT');
+  glProgramUniform1iEXT := dlsym(glesLibrary, 'glProgramUniform1iEXT');
+  glProgramUniform1ivEXT := dlsym(glesLibrary, 'glProgramUniform1ivEXT');
+  glProgramUniform2fEXT := dlsym(glesLibrary, 'glProgramUniform2fEXT');
+  glProgramUniform2fvEXT := dlsym(glesLibrary, 'glProgramUniform2fvEXT');
+  glProgramUniform2iEXT := dlsym(glesLibrary, 'glProgramUniform2iEXT');
+  glProgramUniform2ivEXT := dlsym(glesLibrary, 'glProgramUniform2ivEXT');
+  glProgramUniform3fEXT := dlsym(glesLibrary, 'glProgramUniform3fEXT');
+  glProgramUniform3fvEXT := dlsym(glesLibrary, 'glProgramUniform3fvEXT');
+  glProgramUniform3iEXT := dlsym(glesLibrary, 'glProgramUniform3iEXT');
+  glProgramUniform3ivEXT := dlsym(glesLibrary, 'glProgramUniform3ivEXT');
+  glProgramUniform4fEXT := dlsym(glesLibrary, 'glProgramUniform4fEXT');
+  glProgramUniform4fvEXT := dlsym(glesLibrary, 'glProgramUniform4fvEXT');
+  glProgramUniform4iEXT := dlsym(glesLibrary, 'glProgramUniform4iEXT');
+  glProgramUniform4ivEXT := dlsym(glesLibrary, 'glProgramUniform4ivEXT');
+  glProgramUniformMatrix2fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix2fvEXT');
+  glProgramUniformMatrix3fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix3fvEXT');
+  glProgramUniformMatrix4fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix4fvEXT');
+  glUseProgramStagesEXT := dlsym(glesLibrary, 'glUseProgramStagesEXT');
+  glValidateProgramPipelineEXT := dlsym(glesLibrary, 'glValidateProgramPipelineEXT');
+  glProgramUniform1uiEXT := dlsym(glesLibrary, 'glProgramUniform1uiEXT');
+  glProgramUniform2uiEXT := dlsym(glesLibrary, 'glProgramUniform2uiEXT');
+  glProgramUniform3uiEXT := dlsym(glesLibrary, 'glProgramUniform3uiEXT');
+  glProgramUniform4uiEXT := dlsym(glesLibrary, 'glProgramUniform4uiEXT');
+  glProgramUniform1uivEXT := dlsym(glesLibrary, 'glProgramUniform1uivEXT');
+  glProgramUniform2uivEXT := dlsym(glesLibrary, 'glProgramUniform2uivEXT');
+  glProgramUniform3uivEXT := dlsym(glesLibrary, 'glProgramUniform3uivEXT');
+  glProgramUniform4uivEXT := dlsym(glesLibrary, 'glProgramUniform4uivEXT');
+  glProgramUniformMatrix2x3fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix2x3fvEXT');
+  glProgramUniformMatrix3x2fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix3x2fvEXT');
+  glProgramUniformMatrix2x4fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix2x4fvEXT');
+  glProgramUniformMatrix4x2fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix4x2fvEXT');
+  glProgramUniformMatrix3x4fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix3x4fvEXT');
+  glProgramUniformMatrix4x3fvEXT := dlsym(glesLibrary, 'glProgramUniformMatrix4x3fvEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_shader_framebuffer_fetch_non_coherent}
+  glFramebufferFetchBarrierEXT := dlsym(glesLibrary, 'glFramebufferFetchBarrierEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_shader_pixel_local_storage2}
+  glFramebufferPixelLocalStorageSizeEXT := dlsym(glesLibrary, 'glFramebufferPixelLocalStorageSizeEXT');
+  glGetFramebufferPixelLocalStorageSizeEXT := dlsym(glesLibrary, 'glGetFramebufferPixelLocalStorageSizeEXT');
+  glClearPixelLocalStorageuiEXT := dlsym(glesLibrary, 'glClearPixelLocalStorageuiEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_sparse_texture}
+  glTexPageCommitmentEXT := dlsym(glesLibrary, 'glTexPageCommitmentEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_tessellation_shader}
+  glPatchParameteriEXT := dlsym(glesLibrary, 'glPatchParameteriEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_texture_border_clamp}
+  glTexParameterIivEXT := dlsym(glesLibrary, 'glTexParameterIivEXT');
+  glTexParameterIuivEXT := dlsym(glesLibrary, 'glTexParameterIuivEXT');
+  glGetTexParameterIivEXT := dlsym(glesLibrary, 'glGetTexParameterIivEXT');
+  glGetTexParameterIuivEXT := dlsym(glesLibrary, 'glGetTexParameterIuivEXT');
+  glSamplerParameterIivEXT := dlsym(glesLibrary, 'glSamplerParameterIivEXT');
+  glSamplerParameterIuivEXT := dlsym(glesLibrary, 'glSamplerParameterIuivEXT');
+  glGetSamplerParameterIivEXT := dlsym(glesLibrary, 'glGetSamplerParameterIivEXT');
+  glGetSamplerParameterIuivEXT := dlsym(glesLibrary, 'glGetSamplerParameterIuivEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_texture_buffer}
+  glTexBufferEXT := dlsym(glesLibrary, 'glTexBufferEXT');
+  glTexBufferRangeEXT := dlsym(glesLibrary, 'glTexBufferRangeEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage}
+  glTexStorage1DEXT := dlsym(glesLibrary, 'glTexStorage1DEXT');
+  glTexStorage2DEXT := dlsym(glesLibrary, 'glTexStorage2DEXT');
+  glTexStorage3DEXT := dlsym(glesLibrary, 'glTexStorage3DEXT');
+  glTextureStorage1DEXT := dlsym(glesLibrary, 'glTextureStorage1DEXT');
+  glTextureStorage2DEXT := dlsym(glesLibrary, 'glTextureStorage2DEXT');
+  glTextureStorage3DEXT := dlsym(glesLibrary, 'glTextureStorage3DEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage_compression}
+  glTexStorageAttribs2DEXT := dlsym(glesLibrary, 'glTexStorageAttribs2DEXT');
+  glTexStorageAttribs3DEXT := dlsym(glesLibrary, 'glTexStorageAttribs3DEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_texture_view}
+  glTextureViewEXT := dlsym(glesLibrary, 'glTextureViewEXT');
+{$EndIf}
+
+{$IfDef GL_EXT_win32_keyed_mutex}
+  glAcquireKeyedMutexWin32EXT := dlsym(glesLibrary, 'glAcquireKeyedMutexWin32EXT');
+  glReleaseKeyedMutexWin32EXT := dlsym(glesLibrary, 'glReleaseKeyedMutexWin32EXT');
+{$EndIf}
+
+{$IfDef GL_EXT_window_rectangles}
+  glWindowRectanglesEXT := dlsym(glesLibrary, 'glWindowRectanglesEXT');
+{$EndIf}
+
+{$IfDef GL_IMG_bindless_texture}
+  glGetTextureHandleIMG := dlsym(glesLibrary, 'glGetTextureHandleIMG');
+  glGetTextureSamplerHandleIMG := dlsym(glesLibrary, 'glGetTextureSamplerHandleIMG');
+  glUniformHandleui64IMG := dlsym(glesLibrary, 'glUniformHandleui64IMG');
+  glUniformHandleui64vIMG := dlsym(glesLibrary, 'glUniformHandleui64vIMG');
+  glProgramUniformHandleui64IMG := dlsym(glesLibrary, 'glProgramUniformHandleui64IMG');
+  glProgramUniformHandleui64vIMG := dlsym(glesLibrary, 'glProgramUniformHandleui64vIMG');
+{$EndIf}
+
+{$IfDef GL_IMG_framebuffer_downsample}
+  glFramebufferTexture2DDownsampleIMG := dlsym(glesLibrary, 'glFramebufferTexture2DDownsampleIMG');
+  glFramebufferTextureLayerDownsampleIMG := dlsym(glesLibrary, 'glFramebufferTextureLayerDownsampleIMG');
+{$EndIf}
+
+{$IfDef GL_IMG_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleIMG := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleIMG');
+  glFramebufferTexture2DMultisampleIMG := dlsym(glesLibrary, 'glFramebufferTexture2DMultisampleIMG');
+{$EndIf}
+
+{$IfDef GL_INTEL_framebuffer_CMAA}
+  glApplyFramebufferAttachmentCMAAINTEL := dlsym(glesLibrary, 'glApplyFramebufferAttachmentCMAAINTEL');
+{$EndIf}
+
+{$IfDef GL_INTEL_performance_query}
+  glBeginPerfQueryINTEL := dlsym(glesLibrary, 'glBeginPerfQueryINTEL');
+  glCreatePerfQueryINTEL := dlsym(glesLibrary, 'glCreatePerfQueryINTEL');
+  glDeletePerfQueryINTEL := dlsym(glesLibrary, 'glDeletePerfQueryINTEL');
+  glEndPerfQueryINTEL := dlsym(glesLibrary, 'glEndPerfQueryINTEL');
+  glGetFirstPerfQueryIdINTEL := dlsym(glesLibrary, 'glGetFirstPerfQueryIdINTEL');
+  glGetNextPerfQueryIdINTEL := dlsym(glesLibrary, 'glGetNextPerfQueryIdINTEL');
+  glGetPerfCounterInfoINTEL := dlsym(glesLibrary, 'glGetPerfCounterInfoINTEL');
+  glGetPerfQueryDataINTEL := dlsym(glesLibrary, 'glGetPerfQueryDataINTEL');
+  glGetPerfQueryIdByNameINTEL := dlsym(glesLibrary, 'glGetPerfQueryIdByNameINTEL');
+  glGetPerfQueryInfoINTEL := dlsym(glesLibrary, 'glGetPerfQueryInfoINTEL');
+{$EndIf}
+
+{$IfDef GL_MESA_framebuffer_flip_y}
+  glFramebufferParameteriMESA := dlsym(glesLibrary, 'glFramebufferParameteriMESA');
+  glGetFramebufferParameterivMESA := dlsym(glesLibrary, 'glGetFramebufferParameterivMESA');
+{$EndIf}
+
+{$IfDef GL_NV_bindless_texture}
+  glGetTextureHandleNV := dlsym(glesLibrary, 'glGetTextureHandleNV');
+  glGetTextureSamplerHandleNV := dlsym(glesLibrary, 'glGetTextureSamplerHandleNV');
+  glMakeTextureHandleResidentNV := dlsym(glesLibrary, 'glMakeTextureHandleResidentNV');
+  glMakeTextureHandleNonResidentNV := dlsym(glesLibrary, 'glMakeTextureHandleNonResidentNV');
+  glGetImageHandleNV := dlsym(glesLibrary, 'glGetImageHandleNV');
+  glMakeImageHandleResidentNV := dlsym(glesLibrary, 'glMakeImageHandleResidentNV');
+  glMakeImageHandleNonResidentNV := dlsym(glesLibrary, 'glMakeImageHandleNonResidentNV');
+  glUniformHandleui64NV := dlsym(glesLibrary, 'glUniformHandleui64NV');
+  glUniformHandleui64vNV := dlsym(glesLibrary, 'glUniformHandleui64vNV');
+  glProgramUniformHandleui64NV := dlsym(glesLibrary, 'glProgramUniformHandleui64NV');
+  glProgramUniformHandleui64vNV := dlsym(glesLibrary, 'glProgramUniformHandleui64vNV');
+  glIsTextureHandleResidentNV := dlsym(glesLibrary, 'glIsTextureHandleResidentNV');
+  glIsImageHandleResidentNV := dlsym(glesLibrary, 'glIsImageHandleResidentNV');
+{$EndIf}
+
+{$IfDef GL_NV_blend_equation_advanced}
+  glBlendParameteriNV := dlsym(glesLibrary, 'glBlendParameteriNV');
+  glBlendBarrierNV := dlsym(glesLibrary, 'glBlendBarrierNV');
+{$EndIf}
+
+{$IfDef GL_NV_clip_space_w_scaling}
+  glViewportPositionWScaleNV := dlsym(glesLibrary, 'glViewportPositionWScaleNV');
+{$EndIf}
+
+{$IfDef GL_NV_conditional_render}
+  glBeginConditionalRenderNV := dlsym(glesLibrary, 'glBeginConditionalRenderNV');
+  glEndConditionalRenderNV := dlsym(glesLibrary, 'glEndConditionalRenderNV');
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster}
+  glSubpixelPrecisionBiasNV := dlsym(glesLibrary, 'glSubpixelPrecisionBiasNV');
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster_pre_snap_triangles}
+  glConservativeRasterParameteriNV := dlsym(glesLibrary, 'glConservativeRasterParameteriNV');
+{$EndIf}
+
+{$IfDef GL_NV_copy_buffer}
+  glCopyBufferSubDataNV := dlsym(glesLibrary, 'glCopyBufferSubDataNV');
+{$EndIf}
+
+{$IfDef GL_NV_coverage_sample}
+  glCoverageMaskNV := dlsym(glesLibrary, 'glCoverageMaskNV');
+  glCoverageOperationNV := dlsym(glesLibrary, 'glCoverageOperationNV');
+{$EndIf}
+
+{$IfDef GL_NV_draw_buffers}
+  glDrawBuffersNV := dlsym(glesLibrary, 'glDrawBuffersNV');
+{$EndIf}
+
+{$IfDef GL_NV_draw_instanced}
+  glDrawArraysInstancedNV := dlsym(glesLibrary, 'glDrawArraysInstancedNV');
+  glDrawElementsInstancedNV := dlsym(glesLibrary, 'glDrawElementsInstancedNV');
+{$EndIf}
+
+{$IfDef GL_NV_draw_vulkan_image}
+  glDrawVkImageNV := dlsym(glesLibrary, 'glDrawVkImageNV');
+  glGetVkProcAddrNV := dlsym(glesLibrary, 'glGetVkProcAddrNV');
+  glWaitVkSemaphoreNV := dlsym(glesLibrary, 'glWaitVkSemaphoreNV');
+  glSignalVkSemaphoreNV := dlsym(glesLibrary, 'glSignalVkSemaphoreNV');
+  glSignalVkFenceNV := dlsym(glesLibrary, 'glSignalVkFenceNV');
+{$EndIf}
+
+{$IfDef GL_NV_fence}
+  glDeleteFencesNV := dlsym(glesLibrary, 'glDeleteFencesNV');
+  glGenFencesNV := dlsym(glesLibrary, 'glGenFencesNV');
+  glIsFenceNV := dlsym(glesLibrary, 'glIsFenceNV');
+  glTestFenceNV := dlsym(glesLibrary, 'glTestFenceNV');
+  glGetFenceivNV := dlsym(glesLibrary, 'glGetFenceivNV');
+  glFinishFenceNV := dlsym(glesLibrary, 'glFinishFenceNV');
+  glSetFenceNV := dlsym(glesLibrary, 'glSetFenceNV');
+{$EndIf}
+
+{$IfDef GL_NV_fragment_coverage_to_color}
+  glFragmentCoverageColorNV := dlsym(glesLibrary, 'glFragmentCoverageColorNV');
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_blit}
+  glBlitFramebufferNV := dlsym(glesLibrary, 'glBlitFramebufferNV');
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_mixed_samples}
+  glCoverageModulationTableNV := dlsym(glesLibrary, 'glCoverageModulationTableNV');
+  glGetCoverageModulationTableNV := dlsym(glesLibrary, 'glGetCoverageModulationTableNV');
+  glCoverageModulationNV := dlsym(glesLibrary, 'glCoverageModulationNV');
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_multisample}
+  glRenderbufferStorageMultisampleNV := dlsym(glesLibrary, 'glRenderbufferStorageMultisampleNV');
+{$EndIf}
+
+{$IfDef GL_NV_gpu_shader5}
+  glUniform1i64NV := dlsym(glesLibrary, 'glUniform1i64NV');
+  glUniform2i64NV := dlsym(glesLibrary, 'glUniform2i64NV');
+  glUniform3i64NV := dlsym(glesLibrary, 'glUniform3i64NV');
+  glUniform4i64NV := dlsym(glesLibrary, 'glUniform4i64NV');
+  glUniform1i64vNV := dlsym(glesLibrary, 'glUniform1i64vNV');
+  glUniform2i64vNV := dlsym(glesLibrary, 'glUniform2i64vNV');
+  glUniform3i64vNV := dlsym(glesLibrary, 'glUniform3i64vNV');
+  glUniform4i64vNV := dlsym(glesLibrary, 'glUniform4i64vNV');
+  glUniform1ui64NV := dlsym(glesLibrary, 'glUniform1ui64NV');
+  glUniform2ui64NV := dlsym(glesLibrary, 'glUniform2ui64NV');
+  glUniform3ui64NV := dlsym(glesLibrary, 'glUniform3ui64NV');
+  glUniform4ui64NV := dlsym(glesLibrary, 'glUniform4ui64NV');
+  glUniform1ui64vNV := dlsym(glesLibrary, 'glUniform1ui64vNV');
+  glUniform2ui64vNV := dlsym(glesLibrary, 'glUniform2ui64vNV');
+  glUniform3ui64vNV := dlsym(glesLibrary, 'glUniform3ui64vNV');
+  glUniform4ui64vNV := dlsym(glesLibrary, 'glUniform4ui64vNV');
+  glGetUniformi64vNV := dlsym(glesLibrary, 'glGetUniformi64vNV');
+  glProgramUniform1i64NV := dlsym(glesLibrary, 'glProgramUniform1i64NV');
+  glProgramUniform2i64NV := dlsym(glesLibrary, 'glProgramUniform2i64NV');
+  glProgramUniform3i64NV := dlsym(glesLibrary, 'glProgramUniform3i64NV');
+  glProgramUniform4i64NV := dlsym(glesLibrary, 'glProgramUniform4i64NV');
+  glProgramUniform1i64vNV := dlsym(glesLibrary, 'glProgramUniform1i64vNV');
+  glProgramUniform2i64vNV := dlsym(glesLibrary, 'glProgramUniform2i64vNV');
+  glProgramUniform3i64vNV := dlsym(glesLibrary, 'glProgramUniform3i64vNV');
+  glProgramUniform4i64vNV := dlsym(glesLibrary, 'glProgramUniform4i64vNV');
+  glProgramUniform1ui64NV := dlsym(glesLibrary, 'glProgramUniform1ui64NV');
+  glProgramUniform2ui64NV := dlsym(glesLibrary, 'glProgramUniform2ui64NV');
+  glProgramUniform3ui64NV := dlsym(glesLibrary, 'glProgramUniform3ui64NV');
+  glProgramUniform4ui64NV := dlsym(glesLibrary, 'glProgramUniform4ui64NV');
+  glProgramUniform1ui64vNV := dlsym(glesLibrary, 'glProgramUniform1ui64vNV');
+  glProgramUniform2ui64vNV := dlsym(glesLibrary, 'glProgramUniform2ui64vNV');
+  glProgramUniform3ui64vNV := dlsym(glesLibrary, 'glProgramUniform3ui64vNV');
+  glProgramUniform4ui64vNV := dlsym(glesLibrary, 'glProgramUniform4ui64vNV');
+{$EndIf}
+
+{$IfDef GL_NV_instanced_arrays}
+  glVertexAttribDivisorNV := dlsym(glesLibrary, 'glVertexAttribDivisorNV');
+{$EndIf}
+
+{$IfDef GL_NV_internalformat_sample_query}
+  glGetInternalformatSampleivNV := dlsym(glesLibrary, 'glGetInternalformatSampleivNV');
+{$EndIf}
+
+{$IfDef GL_NV_memory_attachment}
+  glGetMemoryObjectDetachedResourcesuivNV := dlsym(glesLibrary, 'glGetMemoryObjectDetachedResourcesuivNV');
+  glResetMemoryObjectParameterNV := dlsym(glesLibrary, 'glResetMemoryObjectParameterNV');
+  glTexAttachMemoryNV := dlsym(glesLibrary, 'glTexAttachMemoryNV');
+  glBufferAttachMemoryNV := dlsym(glesLibrary, 'glBufferAttachMemoryNV');
+  glTextureAttachMemoryNV := dlsym(glesLibrary, 'glTextureAttachMemoryNV');
+  glNamedBufferAttachMemoryNV := dlsym(glesLibrary, 'glNamedBufferAttachMemoryNV');
+{$EndIf}
+
+{$IfDef GL_NV_memory_object_sparse}
+  glBufferPageCommitmentMemNV := dlsym(glesLibrary, 'glBufferPageCommitmentMemNV');
+  glTexPageCommitmentMemNV := dlsym(glesLibrary, 'glTexPageCommitmentMemNV');
+  glNamedBufferPageCommitmentMemNV := dlsym(glesLibrary, 'glNamedBufferPageCommitmentMemNV');
+  glTexturePageCommitmentMemNV := dlsym(glesLibrary, 'glTexturePageCommitmentMemNV');
+{$EndIf}
+
+{$IfDef GL_NV_mesh_shader}
+  glDrawMeshTasksNV := dlsym(glesLibrary, 'glDrawMeshTasksNV');
+  glDrawMeshTasksIndirectNV := dlsym(glesLibrary, 'glDrawMeshTasksIndirectNV');
+  glMultiDrawMeshTasksIndirectNV := dlsym(glesLibrary, 'glMultiDrawMeshTasksIndirectNV');
+  glMultiDrawMeshTasksIndirectCountNV := dlsym(glesLibrary, 'glMultiDrawMeshTasksIndirectCountNV');
+{$EndIf}
+
+{$IfDef GL_NV_non_square_matrices}
+  glUniformMatrix2x3fvNV := dlsym(glesLibrary, 'glUniformMatrix2x3fvNV');
+  glUniformMatrix3x2fvNV := dlsym(glesLibrary, 'glUniformMatrix3x2fvNV');
+  glUniformMatrix2x4fvNV := dlsym(glesLibrary, 'glUniformMatrix2x4fvNV');
+  glUniformMatrix4x2fvNV := dlsym(glesLibrary, 'glUniformMatrix4x2fvNV');
+  glUniformMatrix3x4fvNV := dlsym(glesLibrary, 'glUniformMatrix3x4fvNV');
+  glUniformMatrix4x3fvNV := dlsym(glesLibrary, 'glUniformMatrix4x3fvNV');
+{$EndIf}
+
+{$IfDef GL_NV_path_rendering}
+  glGenPathsNV := dlsym(glesLibrary, 'glGenPathsNV');
+  glDeletePathsNV := dlsym(glesLibrary, 'glDeletePathsNV');
+  glIsPathNV := dlsym(glesLibrary, 'glIsPathNV');
+  glPathCommandsNV := dlsym(glesLibrary, 'glPathCommandsNV');
+  glPathCoordsNV := dlsym(glesLibrary, 'glPathCoordsNV');
+  glPathSubCommandsNV := dlsym(glesLibrary, 'glPathSubCommandsNV');
+  glPathSubCoordsNV := dlsym(glesLibrary, 'glPathSubCoordsNV');
+  glPathStringNV := dlsym(glesLibrary, 'glPathStringNV');
+  glPathGlyphsNV := dlsym(glesLibrary, 'glPathGlyphsNV');
+  glPathGlyphRangeNV := dlsym(glesLibrary, 'glPathGlyphRangeNV');
+  glWeightPathsNV := dlsym(glesLibrary, 'glWeightPathsNV');
+  glCopyPathNV := dlsym(glesLibrary, 'glCopyPathNV');
+  glInterpolatePathsNV := dlsym(glesLibrary, 'glInterpolatePathsNV');
+  glTransformPathNV := dlsym(glesLibrary, 'glTransformPathNV');
+  glPathParameterivNV := dlsym(glesLibrary, 'glPathParameterivNV');
+  glPathParameteriNV := dlsym(glesLibrary, 'glPathParameteriNV');
+  glPathParameterfvNV := dlsym(glesLibrary, 'glPathParameterfvNV');
+  glPathParameterfNV := dlsym(glesLibrary, 'glPathParameterfNV');
+  glPathDashArrayNV := dlsym(glesLibrary, 'glPathDashArrayNV');
+  glPathStencilFuncNV := dlsym(glesLibrary, 'glPathStencilFuncNV');
+  glPathStencilDepthOffsetNV := dlsym(glesLibrary, 'glPathStencilDepthOffsetNV');
+  glStencilFillPathNV := dlsym(glesLibrary, 'glStencilFillPathNV');
+  glStencilStrokePathNV := dlsym(glesLibrary, 'glStencilStrokePathNV');
+  glStencilFillPathInstancedNV := dlsym(glesLibrary, 'glStencilFillPathInstancedNV');
+  glStencilStrokePathInstancedNV := dlsym(glesLibrary, 'glStencilStrokePathInstancedNV');
+  glPathCoverDepthFuncNV := dlsym(glesLibrary, 'glPathCoverDepthFuncNV');
+  glCoverFillPathNV := dlsym(glesLibrary, 'glCoverFillPathNV');
+  glCoverStrokePathNV := dlsym(glesLibrary, 'glCoverStrokePathNV');
+  glCoverFillPathInstancedNV := dlsym(glesLibrary, 'glCoverFillPathInstancedNV');
+  glCoverStrokePathInstancedNV := dlsym(glesLibrary, 'glCoverStrokePathInstancedNV');
+  glGetPathParameterivNV := dlsym(glesLibrary, 'glGetPathParameterivNV');
+  glGetPathParameterfvNV := dlsym(glesLibrary, 'glGetPathParameterfvNV');
+  glGetPathCommandsNV := dlsym(glesLibrary, 'glGetPathCommandsNV');
+  glGetPathCoordsNV := dlsym(glesLibrary, 'glGetPathCoordsNV');
+  glGetPathDashArrayNV := dlsym(glesLibrary, 'glGetPathDashArrayNV');
+  glGetPathMetricsNV := dlsym(glesLibrary, 'glGetPathMetricsNV');
+  glGetPathMetricRangeNV := dlsym(glesLibrary, 'glGetPathMetricRangeNV');
+  glGetPathSpacingNV := dlsym(glesLibrary, 'glGetPathSpacingNV');
+  glIsPointInFillPathNV := dlsym(glesLibrary, 'glIsPointInFillPathNV');
+  glIsPointInStrokePathNV := dlsym(glesLibrary, 'glIsPointInStrokePathNV');
+  glGetPathLengthNV := dlsym(glesLibrary, 'glGetPathLengthNV');
+  glPointAlongPathNV := dlsym(glesLibrary, 'glPointAlongPathNV');
+  glMatrixLoad3x2fNV := dlsym(glesLibrary, 'glMatrixLoad3x2fNV');
+  glMatrixLoad3x3fNV := dlsym(glesLibrary, 'glMatrixLoad3x3fNV');
+  glMatrixLoadTranspose3x3fNV := dlsym(glesLibrary, 'glMatrixLoadTranspose3x3fNV');
+  glMatrixMult3x2fNV := dlsym(glesLibrary, 'glMatrixMult3x2fNV');
+  glMatrixMult3x3fNV := dlsym(glesLibrary, 'glMatrixMult3x3fNV');
+  glMatrixMultTranspose3x3fNV := dlsym(glesLibrary, 'glMatrixMultTranspose3x3fNV');
+  glStencilThenCoverFillPathNV := dlsym(glesLibrary, 'glStencilThenCoverFillPathNV');
+  glStencilThenCoverStrokePathNV := dlsym(glesLibrary, 'glStencilThenCoverStrokePathNV');
+  glStencilThenCoverFillPathInstancedNV := dlsym(glesLibrary, 'glStencilThenCoverFillPathInstancedNV');
+  glStencilThenCoverStrokePathInstancedNV := dlsym(glesLibrary, 'glStencilThenCoverStrokePathInstancedNV');
+  glPathGlyphIndexRangeNV := dlsym(glesLibrary, 'glPathGlyphIndexRangeNV');
+  glPathGlyphIndexArrayNV := dlsym(glesLibrary, 'glPathGlyphIndexArrayNV');
+  glPathMemoryGlyphIndexArrayNV := dlsym(glesLibrary, 'glPathMemoryGlyphIndexArrayNV');
+  glProgramPathFragmentInputGenNV := dlsym(glesLibrary, 'glProgramPathFragmentInputGenNV');
+  glGetProgramResourcefvNV := dlsym(glesLibrary, 'glGetProgramResourcefvNV');
+  glMatrixFrustumEXT := dlsym(glesLibrary, 'glMatrixFrustumEXT');
+  glMatrixLoadIdentityEXT := dlsym(glesLibrary, 'glMatrixLoadIdentityEXT');
+  glMatrixLoadTransposefEXT := dlsym(glesLibrary, 'glMatrixLoadTransposefEXT');
+  glMatrixLoadTransposedEXT := dlsym(glesLibrary, 'glMatrixLoadTransposedEXT');
+  glMatrixLoadfEXT := dlsym(glesLibrary, 'glMatrixLoadfEXT');
+  glMatrixLoaddEXT := dlsym(glesLibrary, 'glMatrixLoaddEXT');
+  glMatrixMultTransposefEXT := dlsym(glesLibrary, 'glMatrixMultTransposefEXT');
+  glMatrixMultTransposedEXT := dlsym(glesLibrary, 'glMatrixMultTransposedEXT');
+  glMatrixMultfEXT := dlsym(glesLibrary, 'glMatrixMultfEXT');
+  glMatrixMultdEXT := dlsym(glesLibrary, 'glMatrixMultdEXT');
+  glMatrixOrthoEXT := dlsym(glesLibrary, 'glMatrixOrthoEXT');
+  glMatrixPopEXT := dlsym(glesLibrary, 'glMatrixPopEXT');
+  glMatrixPushEXT := dlsym(glesLibrary, 'glMatrixPushEXT');
+  glMatrixRotatefEXT := dlsym(glesLibrary, 'glMatrixRotatefEXT');
+  glMatrixRotatedEXT := dlsym(glesLibrary, 'glMatrixRotatedEXT');
+  glMatrixScalefEXT := dlsym(glesLibrary, 'glMatrixScalefEXT');
+  glMatrixScaledEXT := dlsym(glesLibrary, 'glMatrixScaledEXT');
+  glMatrixTranslatefEXT := dlsym(glesLibrary, 'glMatrixTranslatefEXT');
+  glMatrixTranslatedEXT := dlsym(glesLibrary, 'glMatrixTranslatedEXT');
+{$EndIf}
+
+{$IfDef GL_NV_polygon_mode}
+  glPolygonModeNV := dlsym(glesLibrary, 'glPolygonModeNV');
+{$EndIf}
+
+{$IfDef GL_NV_read_buffer}
+  glReadBufferNV := dlsym(glesLibrary, 'glReadBufferNV');
+{$EndIf}
+
+{$IfDef GL_NV_sample_locations}
+  glFramebufferSampleLocationsfvNV := dlsym(glesLibrary, 'glFramebufferSampleLocationsfvNV');
+  glNamedFramebufferSampleLocationsfvNV := dlsym(glesLibrary, 'glNamedFramebufferSampleLocationsfvNV');
+  glResolveDepthValuesNV := dlsym(glesLibrary, 'glResolveDepthValuesNV');
+{$EndIf}
+
+{$IfDef GL_NV_scissor_exclusive}
+  glScissorExclusiveNV := dlsym(glesLibrary, 'glScissorExclusiveNV');
+  glScissorExclusiveArrayvNV := dlsym(glesLibrary, 'glScissorExclusiveArrayvNV');
+{$EndIf}
+
+{$IfDef GL_NV_shading_rate_image}
+  glBindShadingRateImageNV := dlsym(glesLibrary, 'glBindShadingRateImageNV');
+  glGetShadingRateImagePaletteNV := dlsym(glesLibrary, 'glGetShadingRateImagePaletteNV');
+  glGetShadingRateSampleLocationivNV := dlsym(glesLibrary, 'glGetShadingRateSampleLocationivNV');
+  glShadingRateImageBarrierNV := dlsym(glesLibrary, 'glShadingRateImageBarrierNV');
+  glShadingRateImagePaletteNV := dlsym(glesLibrary, 'glShadingRateImagePaletteNV');
+  glShadingRateSampleOrderNV := dlsym(glesLibrary, 'glShadingRateSampleOrderNV');
+  glShadingRateSampleOrderCustomNV := dlsym(glesLibrary, 'glShadingRateSampleOrderCustomNV');
+{$EndIf}
+
+{$IfDef GL_NV_timeline_semaphore}
+  glCreateSemaphoresNV := dlsym(glesLibrary, 'glCreateSemaphoresNV');
+  glSemaphoreParameterivNV := dlsym(glesLibrary, 'glSemaphoreParameterivNV');
+  glGetSemaphoreParameterivNV := dlsym(glesLibrary, 'glGetSemaphoreParameterivNV');
+{$EndIf}
+
+{$IfDef GL_NV_viewport_array}
+  glViewportArrayvNV := dlsym(glesLibrary, 'glViewportArrayvNV');
+  glViewportIndexedfNV := dlsym(glesLibrary, 'glViewportIndexedfNV');
+  glViewportIndexedfvNV := dlsym(glesLibrary, 'glViewportIndexedfvNV');
+  glScissorArrayvNV := dlsym(glesLibrary, 'glScissorArrayvNV');
+  glScissorIndexedNV := dlsym(glesLibrary, 'glScissorIndexedNV');
+  glScissorIndexedvNV := dlsym(glesLibrary, 'glScissorIndexedvNV');
+  glDepthRangeArrayfvNV := dlsym(glesLibrary, 'glDepthRangeArrayfvNV');
+  glDepthRangeIndexedfNV := dlsym(glesLibrary, 'glDepthRangeIndexedfNV');
+  glGetFloati_vNV := dlsym(glesLibrary, 'glGetFloati_vNV');
+  glEnableiNV := dlsym(glesLibrary, 'glEnableiNV');
+  glDisableiNV := dlsym(glesLibrary, 'glDisableiNV');
+  glIsEnablediNV := dlsym(glesLibrary, 'glIsEnablediNV');
+{$EndIf}
+
+{$IfDef GL_NV_viewport_swizzle}
+  glViewportSwizzleNV := dlsym(glesLibrary, 'glViewportSwizzleNV');
+{$EndIf}
+
+{$IfDef GL_OVR_multiview}
+  glFramebufferTextureMultiviewOVR := dlsym(glesLibrary, 'glFramebufferTextureMultiviewOVR');
+{$EndIf}
+
+{$IfDef GL_OVR_multiview_multisampled_render_to_texture}
+  glFramebufferTextureMultisampleMultiviewOVR := dlsym(glesLibrary, 'glFramebufferTextureMultisampleMultiviewOVR');
+{$EndIf}
+
+{$IfDef GL_QCOM_alpha_test}
+  glAlphaFuncQCOM := dlsym(glesLibrary, 'glAlphaFuncQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_driver_control}
+  glGetDriverControlsQCOM := dlsym(glesLibrary, 'glGetDriverControlsQCOM');
+  glGetDriverControlStringQCOM := dlsym(glesLibrary, 'glGetDriverControlStringQCOM');
+  glEnableDriverControlQCOM := dlsym(glesLibrary, 'glEnableDriverControlQCOM');
+  glDisableDriverControlQCOM := dlsym(glesLibrary, 'glDisableDriverControlQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get}
+  glExtGetTexturesQCOM := dlsym(glesLibrary, 'glExtGetTexturesQCOM');
+  glExtGetBuffersQCOM := dlsym(glesLibrary, 'glExtGetBuffersQCOM');
+  glExtGetRenderbuffersQCOM := dlsym(glesLibrary, 'glExtGetRenderbuffersQCOM');
+  glExtGetFramebuffersQCOM := dlsym(glesLibrary, 'glExtGetFramebuffersQCOM');
+  glExtGetTexLevelParameterivQCOM := dlsym(glesLibrary, 'glExtGetTexLevelParameterivQCOM');
+  glExtTexObjectStateOverrideiQCOM := dlsym(glesLibrary, 'glExtTexObjectStateOverrideiQCOM');
+  glExtGetTexSubImageQCOM := dlsym(glesLibrary, 'glExtGetTexSubImageQCOM');
+  glExtGetBufferPointervQCOM := dlsym(glesLibrary, 'glExtGetBufferPointervQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get2}
+  glExtGetShadersQCOM := dlsym(glesLibrary, 'glExtGetShadersQCOM');
+  glExtGetProgramsQCOM := dlsym(glesLibrary, 'glExtGetProgramsQCOM');
+  glExtIsProgramBinaryQCOM := dlsym(glesLibrary, 'glExtIsProgramBinaryQCOM');
+  glExtGetProgramBinarySourceQCOM := dlsym(glesLibrary, 'glExtGetProgramBinarySourceQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_frame_extrapolation}
+  glExtrapolateTex2DQCOM := dlsym(glesLibrary, 'glExtrapolateTex2DQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_framebuffer_foveated}
+  glFramebufferFoveationConfigQCOM := dlsym(glesLibrary, 'glFramebufferFoveationConfigQCOM');
+  glFramebufferFoveationParametersQCOM := dlsym(glesLibrary, 'glFramebufferFoveationParametersQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_motion_estimation}
+  glTexEstimateMotionQCOM := dlsym(glesLibrary, 'glTexEstimateMotionQCOM');
+  glTexEstimateMotionRegionsQCOM := dlsym(glesLibrary, 'glTexEstimateMotionRegionsQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_shader_framebuffer_fetch_noncoherent}
+  glFramebufferFetchBarrierQCOM := dlsym(glesLibrary, 'glFramebufferFetchBarrierQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_shading_rate}
+  glShadingRateQCOM := dlsym(glesLibrary, 'glShadingRateQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_texture_foveated}
+  glTextureFoveationParametersQCOM := dlsym(glesLibrary, 'glTextureFoveationParametersQCOM');
+{$EndIf}
+
+{$IfDef GL_QCOM_tiled_rendering}
+  glStartTilingQCOM := dlsym(glesLibrary, 'glStartTilingQCOM');
+  glEndTilingQCOM := dlsym(glesLibrary, 'glEndTilingQCOM');
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_0}
+// GL_NV_read_buffer
+  glReadBuffer := dlsym(glesLibrary, 'glReadBuffer');
+// none
+  glDrawRangeElements := dlsym(glesLibrary, 'glDrawRangeElements');
+// GL_OES_texture_3D
+  glTexImage3D := dlsym(glesLibrary, 'glTexImage3D');
+  glTexSubImage3D := dlsym(glesLibrary, 'glTexSubImage3D');
+  glCopyTexSubImage3D := dlsym(glesLibrary, 'glCopyTexSubImage3D');
+  glCompressedTexImage3D := dlsym(glesLibrary, 'glCompressedTexImage3D');
+  glCompressedTexSubImage3D := dlsym(glesLibrary, 'glCompressedTexSubImage3D');
+// GL_EXT_disjoint_timer_query
+  glGenQueries := dlsym(glesLibrary, 'glGenQueries');
+  glDeleteQueries := dlsym(glesLibrary, 'glDeleteQueries');
+  glIsQuery := dlsym(glesLibrary, 'glIsQuery');
+  glBeginQuery := dlsym(glesLibrary, 'glBeginQuery');
+  glEndQuery := dlsym(glesLibrary, 'glEndQuery');
+  glGetQueryiv := dlsym(glesLibrary, 'glGetQueryiv');
+  glGetQueryObjectuiv := dlsym(glesLibrary, 'glGetQueryObjectuiv');
+// GL_OES_mapbuffer
+  glUnmapBuffer := dlsym(glesLibrary, 'glUnmapBuffer');
+  glGetBufferPointerv := dlsym(glesLibrary, 'glGetBufferPointerv');
+// GL_EXT_draw_buffers + GL_NV_draw_buffers
+  glDrawBuffers := dlsym(glesLibrary, 'glDrawBuffers');
+// GL_NV_non_square_matrices
+  glUniformMatrix2x3fv := dlsym(glesLibrary, 'glUniformMatrix2x3fv');
+  glUniformMatrix3x2fv := dlsym(glesLibrary, 'glUniformMatrix3x2fv');
+  glUniformMatrix2x4fv := dlsym(glesLibrary, 'glUniformMatrix2x4fv');
+  glUniformMatrix4x2fv := dlsym(glesLibrary, 'glUniformMatrix4x2fv');
+  glUniformMatrix3x4fv := dlsym(glesLibrary, 'glUniformMatrix3x4fv');
+  glUniformMatrix4x3fv := dlsym(glesLibrary, 'glUniformMatrix4x3fv');
+// GL_ANGLE_framebuffer_blit + GL_NV_framebuffer_blit
+  glBlitFramebuffer := dlsym(glesLibrary, 'glBlitFramebuffer');
+// GL_ANGLE_framebuffer_multisample + GL_APPLE_framebuffer_multisample + GL_EXT_multisampled_render_to_texture +
+//                                  GL_IMG_multisampled_render_to_texture + GL_NV_framebuffer_multisample
+  glRenderbufferStorageMultisample := dlsym(glesLibrary, 'glRenderbufferStorageMultisample');
+// none
+  glFramebufferTextureLayer := dlsym(glesLibrary, 'glFramebufferTextureLayer');
+// GL_EXT_map_buffer_range
+  glMapBufferRange := dlsym(glesLibrary, 'glMapBufferRange');
+  glFlushMappedBufferRange := dlsym(glesLibrary, 'glFlushMappedBufferRange');
+// GL_OES_vertex_array_object
+  glBindVertexArray := dlsym(glesLibrary, 'glBindVertexArray');
+  glDeleteVertexArrays := dlsym(glesLibrary, 'glDeleteVertexArrays');
+  glGenVertexArrays := dlsym(glesLibrary, 'glGenVertexArrays');
+  glIsVertexArray := dlsym(glesLibrary, 'glIsVertexArray');
+// GL_EXT_multiview_draw_buffers
+  glGetIntegeri_v := dlsym(glesLibrary, 'glGetIntegeri_v');
+// none
+  glBeginTransformFeedback := dlsym(glesLibrary, 'glBeginTransformFeedback');
+  glEndTransformFeedback := dlsym(glesLibrary, 'glEndTransformFeedback');
+  glBindBufferRange := dlsym(glesLibrary, 'glBindBufferRange');
+  glBindBufferBase := dlsym(glesLibrary, 'glBindBufferBase');
+  glTransformFeedbackVaryings := dlsym(glesLibrary, 'glTransformFeedbackVaryings');
+  glGetTransformFeedbackVarying := dlsym(glesLibrary, 'glGetTransformFeedbackVarying');
+  glVertexAttribIPointer := dlsym(glesLibrary, 'glVertexAttribIPointer');
+  glGetVertexAttribIiv := dlsym(glesLibrary, 'glGetVertexAttribIiv');
+  glGetVertexAttribIuiv := dlsym(glesLibrary, 'glGetVertexAttribIuiv');
+  glVertexAttribI4i := dlsym(glesLibrary, 'glVertexAttribI4i');
+  glVertexAttribI4ui := dlsym(glesLibrary, 'glVertexAttribI4ui');
+  glVertexAttribI4iv := dlsym(glesLibrary, 'glVertexAttribI4iv');
+  glVertexAttribI4uiv := dlsym(glesLibrary, 'glVertexAttribI4uiv');
+  glGetUniformuiv := dlsym(glesLibrary, 'glGetUniformuiv');
+  glGetFragDataLocation := dlsym(glesLibrary, 'glGetFragDataLocation');
+  glUniform1ui := dlsym(glesLibrary, 'glUniform1ui');
+  glUniform2ui := dlsym(glesLibrary, 'glUniform2ui');
+  glUniform3ui := dlsym(glesLibrary, 'glUniform3ui');
+  glUniform4ui := dlsym(glesLibrary, 'glUniform4ui');
+  glUniform1uiv := dlsym(glesLibrary, 'glUniform1uiv');
+  glUniform2uiv := dlsym(glesLibrary, 'glUniform2uiv');
+  glUniform3uiv := dlsym(glesLibrary, 'glUniform3uiv');
+  glUniform4uiv := dlsym(glesLibrary, 'glUniform4uiv');
+  glClearBufferiv := dlsym(glesLibrary, 'glClearBufferiv');
+  glClearBufferuiv := dlsym(glesLibrary, 'glClearBufferuiv');
+  glClearBufferfv := dlsym(glesLibrary, 'glClearBufferfv');
+  glClearBufferfi := dlsym(glesLibrary, 'glClearBufferfi');
+  glGetStringi := dlsym(glesLibrary, 'glGetStringi');
+// GL_NV_copy_buffer
+  glCopyBufferSubData := dlsym(glesLibrary, 'glCopyBufferSubData');
+// none
+  glGetUniformIndices := dlsym(glesLibrary, 'glGetUniformIndices');
+  glGetActiveUniformsiv := dlsym(glesLibrary, 'glGetActiveUniformsiv');
+  glGetUniformBlockIndex := dlsym(glesLibrary, 'glGetUniformBlockIndex');
+  glGetActiveUniformBlockiv := dlsym(glesLibrary, 'glGetActiveUniformBlockiv');
+  glGetActiveUniformBlockName := dlsym(glesLibrary, 'glGetActiveUniformBlockName');
+  glUniformBlockBinding := dlsym(glesLibrary, 'glUniformBlockBinding');
+// GL_ANGLE_instanced_arrays            GL_EXT_draw_instanced              GL_NV_draw_instanced
+  glDrawArraysInstanced := dlsym(glesLibrary, 'glDrawArraysInstanced');
+  glDrawElementsInstanced := dlsym(glesLibrary, 'glDrawElementsInstanced');
+// GL_APPLE_sync
+  glFenceSync := dlsym(glesLibrary, 'glFenceSync');
+  glIsSync := dlsym(glesLibrary, 'glIsSync');
+  glDeleteSync := dlsym(glesLibrary, 'glDeleteSync');
+  glClientWaitSync := dlsym(glesLibrary, 'glClientWaitSync');
+  glWaitSync := dlsym(glesLibrary, 'glWaitSync');
+// GL_APPLE_sync                        GL_EXT_disjoint_timer_query
+  glGetInteger64v := dlsym(glesLibrary, 'glGetInteger64v');
+// GL_APPLE_sync
+  glGetSynciv := dlsym(glesLibrary, 'glGetSynciv');
+// none
+  glGetInteger64i_v := dlsym(glesLibrary, 'glGetInteger64i_v');
+  glGetBufferParameteri64v := dlsym(glesLibrary, 'glGetBufferParameteri64v');
+  glGenSamplers := dlsym(glesLibrary, 'glGenSamplers');
+  glDeleteSamplers := dlsym(glesLibrary, 'glDeleteSamplers');
+  glIsSampler := dlsym(glesLibrary, 'glIsSampler');
+  glBindSampler := dlsym(glesLibrary, 'glBindSampler');
+  glSamplerParameteri := dlsym(glesLibrary, 'glSamplerParameteri');
+  glSamplerParameteriv := dlsym(glesLibrary, 'glSamplerParameteriv');
+  glSamplerParameterf := dlsym(glesLibrary, 'glSamplerParameterf');
+  glSamplerParameterfv := dlsym(glesLibrary, 'glSamplerParameterfv');
+  glGetSamplerParameteriv := dlsym(glesLibrary, 'glGetSamplerParameteriv');
+  glGetSamplerParameterfv := dlsym(glesLibrary, 'glGetSamplerParameterfv');
+// GL_ANGLE_instanced_arrays            GL_EXT_instanced_arrays       GL_NV_instanced_arrays
+  glVertexAttribDivisor := dlsym(glesLibrary, 'glVertexAttribDivisor');
+// none
+  glBindTransformFeedback := dlsym(glesLibrary, 'glBindTransformFeedback');
+  glDeleteTransformFeedbacks := dlsym(glesLibrary, 'glDeleteTransformFeedbacks');
+  glGenTransformFeedbacks := dlsym(glesLibrary, 'glGenTransformFeedbacks');
+  glIsTransformFeedback := dlsym(glesLibrary, 'glIsTransformFeedback');
+  glPauseTransformFeedback := dlsym(glesLibrary, 'glPauseTransformFeedback');
+  glResumeTransformFeedback := dlsym(glesLibrary, 'glResumeTransformFeedback');
+// GL_OES_get_program_binary
+  glGetProgramBinary := dlsym(glesLibrary, 'glGetProgramBinary');
+  glProgramBinary := dlsym(glesLibrary, 'glProgramBinary');
+// GL_EXT_separate_shader_objects
+  glProgramParameteri := dlsym(glesLibrary, 'glProgramParameteri');
+// none
+  glInvalidateFramebuffer := dlsym(glesLibrary, 'glInvalidateFramebuffer');
+  glInvalidateSubFramebuffer := dlsym(glesLibrary, 'glInvalidateSubFramebuffer');
+// GL_EXT_texture_storage
+  glTexStorage2D := dlsym(glesLibrary, 'glTexStorage2D');
+  glTexStorage3D := dlsym(glesLibrary, 'glTexStorage3D');
+// none
+  glGetInternalformativ := dlsym(glesLibrary, 'glGetInternalformativ');
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_1}
+// none
+  glDispatchCompute := dlsym(glesLibrary, 'glDispatchCompute');
+  glDispatchComputeIndirect := dlsym(glesLibrary, 'glDispatchComputeIndirect');
+  glDrawArraysIndirect := dlsym(glesLibrary, 'glDrawArraysIndirect');
+  glDrawElementsIndirect := dlsym(glesLibrary, 'glDrawElementsIndirect');
+// GL_MESA_framebuffer_flip_y
+  glFramebufferParameteri := dlsym(glesLibrary, 'glFramebufferParameteri');
+  glGetFramebufferParameteriv := dlsym(glesLibrary, 'glGetFramebufferParameteriv');
+// none
+  glGetProgramInterfaceiv := dlsym(glesLibrary, 'glGetProgramInterfaceiv');
+  glGetProgramResourceIndex := dlsym(glesLibrary, 'glGetProgramResourceIndex');
+  glGetProgramResourceName := dlsym(glesLibrary, 'glGetProgramResourceName');
+  glGetProgramResourceiv := dlsym(glesLibrary, 'glGetProgramResourceiv');
+  glGetProgramResourceLocation := dlsym(glesLibrary, 'glGetProgramResourceLocation');
+// GL_EXT_separate_shader_objects
+  glUseProgramStages := dlsym(glesLibrary, 'glUseProgramStages');
+  glActiveShaderProgram := dlsym(glesLibrary, 'glActiveShaderProgram');
+  glCreateShaderProgramv := dlsym(glesLibrary, 'glCreateShaderProgramv');
+  glBindProgramPipeline := dlsym(glesLibrary, 'glBindProgramPipeline');
+  glDeleteProgramPipelines := dlsym(glesLibrary, 'glDeleteProgramPipelines');
+  glGenProgramPipelines := dlsym(glesLibrary, 'glGenProgramPipelines');
+  glIsProgramPipeline := dlsym(glesLibrary, 'glIsProgramPipeline');
+  glGetProgramPipelineiv := dlsym(glesLibrary, 'glGetProgramPipelineiv');
+  glProgramUniform1i := dlsym(glesLibrary, 'glProgramUniform1i');
+  glProgramUniform2i := dlsym(glesLibrary, 'glProgramUniform2i');
+  glProgramUniform3i := dlsym(glesLibrary, 'glProgramUniform3i');
+  glProgramUniform4i := dlsym(glesLibrary, 'glProgramUniform4i');
+  glProgramUniform1ui := dlsym(glesLibrary, 'glProgramUniform1ui');
+  glProgramUniform2ui := dlsym(glesLibrary, 'glProgramUniform2ui');
+  glProgramUniform3ui := dlsym(glesLibrary, 'glProgramUniform3ui');
+  glProgramUniform4ui := dlsym(glesLibrary, 'glProgramUniform4ui');
+  glProgramUniform1f := dlsym(glesLibrary, 'glProgramUniform1f');
+  glProgramUniform2f := dlsym(glesLibrary, 'glProgramUniform2f');
+  glProgramUniform3f := dlsym(glesLibrary, 'glProgramUniform3f');
+  glProgramUniform4f := dlsym(glesLibrary, 'glProgramUniform4f');
+  glProgramUniform1iv := dlsym(glesLibrary, 'glProgramUniform1iv');
+  glProgramUniform2iv := dlsym(glesLibrary, 'glProgramUniform2iv');
+  glProgramUniform3iv := dlsym(glesLibrary, 'glProgramUniform3iv');
+  glProgramUniform4iv := dlsym(glesLibrary, 'glProgramUniform4iv');
+  glProgramUniform1uiv := dlsym(glesLibrary, 'glProgramUniform1uiv');
+  glProgramUniform2uiv := dlsym(glesLibrary, 'glProgramUniform2uiv');
+  glProgramUniform3uiv := dlsym(glesLibrary, 'glProgramUniform3uiv');
+  glProgramUniform4uiv := dlsym(glesLibrary, 'glProgramUniform4uiv');
+  glProgramUniform1fv := dlsym(glesLibrary, 'glProgramUniform1fv');
+  glProgramUniform2fv := dlsym(glesLibrary, 'glProgramUniform2fv');
+  glProgramUniform3fv := dlsym(glesLibrary, 'glProgramUniform3fv');
+  glProgramUniform4fv := dlsym(glesLibrary, 'glProgramUniform4fv');
+  glProgramUniformMatrix2fv := dlsym(glesLibrary, 'glProgramUniformMatrix2fv');
+  glProgramUniformMatrix3fv := dlsym(glesLibrary, 'glProgramUniformMatrix3fv');
+  glProgramUniformMatrix4fv := dlsym(glesLibrary, 'glProgramUniformMatrix4fv');
+  glProgramUniformMatrix2x3fv := dlsym(glesLibrary, 'glProgramUniformMatrix2x3fv');
+  glProgramUniformMatrix3x2fv := dlsym(glesLibrary, 'glProgramUniformMatrix3x2fv');
+  glProgramUniformMatrix2x4fv := dlsym(glesLibrary, 'glProgramUniformMatrix2x4fv');
+  glProgramUniformMatrix4x2fv := dlsym(glesLibrary, 'glProgramUniformMatrix4x2fv');
+  glProgramUniformMatrix3x4fv := dlsym(glesLibrary, 'glProgramUniformMatrix3x4fv');
+  glProgramUniformMatrix4x3fv := dlsym(glesLibrary, 'glProgramUniformMatrix4x3fv');
+  glValidateProgramPipeline := dlsym(glesLibrary, 'glValidateProgramPipeline');
+  glGetProgramPipelineInfoLog := dlsym(glesLibrary, 'glGetProgramPipelineInfoLog');
+// none
+  glBindImageTexture := dlsym(glesLibrary, 'glBindImageTexture');
+  glGetBooleani_v := dlsym(glesLibrary, 'glGetBooleani_v');
+  glMemoryBarrier := dlsym(glesLibrary, 'glMemoryBarrier');
+  glMemoryBarrierByRegion := dlsym(glesLibrary, 'glMemoryBarrierByRegion');
+  glTexStorage2DMultisample := dlsym(glesLibrary, 'glTexStorage2DMultisample');
+  glGetMultisamplefv := dlsym(glesLibrary, 'glGetMultisamplefv');
+  glSampleMaski := dlsym(glesLibrary, 'glSampleMaski');
+  glGetTexLevelParameteriv := dlsym(glesLibrary, 'glGetTexLevelParameteriv');
+  glGetTexLevelParameterfv := dlsym(glesLibrary, 'glGetTexLevelParameterfv');
+  glBindVertexBuffer := dlsym(glesLibrary, 'glBindVertexBuffer');
+  glVertexAttribFormat := dlsym(glesLibrary, 'glVertexAttribFormat');
+  glVertexAttribIFormat := dlsym(glesLibrary, 'glVertexAttribIFormat');
+  glVertexAttribBinding := dlsym(glesLibrary, 'glVertexAttribBinding');
+  glVertexBindingDivisor := dlsym(glesLibrary, 'glVertexBindingDivisor');
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_2}
+// GL_KHR_blend_equation_advanced        GL_NV_blend_equation_advanced
+  glBlendBarrier := dlsym(glesLibrary, 'glBlendBarrier');
+// GL_OES_copy_image                     GL_EXT_copy_image
+  glCopyImageSubData := dlsym(glesLibrary, 'glCopyImageSubData');
+// GL_KHR_debug
+  glDebugMessageControl := dlsym(glesLibrary, 'glDebugMessageControl');
+  glDebugMessageInsert := dlsym(glesLibrary, 'glDebugMessageInsert');
+  glDebugMessageCallback := dlsym(glesLibrary, 'glDebugMessageCallback');
+  glGetDebugMessageLog := dlsym(glesLibrary, 'glGetDebugMessageLog');
+  glPushDebugGroup := dlsym(glesLibrary, 'glPushDebugGroup');
+  glPopDebugGroup := dlsym(glesLibrary, 'glPopDebugGroup');
+  glObjectLabel := dlsym(glesLibrary, 'glObjectLabel');
+// GL_KHR_debug                          GL_EXT_debug_label
+  glGetObjectLabel := dlsym(glesLibrary, 'glGetObjectLabel');
+// GL_KHR_debug
+  glObjectPtrLabel := dlsym(glesLibrary, 'glObjectPtrLabel');
+  glGetObjectPtrLabel := dlsym(glesLibrary, 'glGetObjectPtrLabel');
+  glGetPointerv := dlsym(glesLibrary, 'glGetPointerv');
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glEnablei := dlsym(glesLibrary, 'glEnablei');
+  glDisablei := dlsym(glesLibrary, 'glDisablei');
+// GL_OES_draw_buffers_indexed
+  glBlendEquationi := dlsym(glesLibrary, 'glBlendEquationi');
+  glBlendEquationSeparatei := dlsym(glesLibrary, 'glBlendEquationSeparatei');
+  glBlendFunci := dlsym(glesLibrary, 'glBlendFunci');
+  glBlendFuncSeparatei := dlsym(glesLibrary, 'glBlendFuncSeparatei');
+  glColorMaski := dlsym(glesLibrary, 'glColorMaski');
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glIsEnabledi := dlsym(glesLibrary, 'glIsEnabledi');
+// GL_OES_draw_elements_base_vertex      GL_EXT_draw_elements_base_vertex
+  glDrawElementsBaseVertex := dlsym(glesLibrary, 'glDrawElementsBaseVertex');
+  glDrawRangeElementsBaseVertex := dlsym(glesLibrary, 'glDrawRangeElementsBaseVertex');
+  glDrawElementsInstancedBaseVertex := dlsym(glesLibrary, 'glDrawElementsInstancedBaseVertex');
+// GL_OES_geometry_shader                GL_EXT_geometry_shader
+  glFramebufferTexture := dlsym(glesLibrary, 'glFramebufferTexture');
+// GL_OES_primitive_bounding_box         GL_EXT_primitive_bounding_box
+  glPrimitiveBoundingBox := dlsym(glesLibrary, 'glPrimitiveBoundingBox');
+// GL_KHR_robustness                     GL_EXT_robustness
+  glGetGraphicsResetStatus := dlsym(glesLibrary, 'glGetGraphicsResetStatus');
+  glReadnPixels := dlsym(glesLibrary, 'glReadnPixels');
+  glGetnUniformfv := dlsym(glesLibrary, 'glGetnUniformfv');
+  glGetnUniformiv := dlsym(glesLibrary, 'glGetnUniformiv');
+// GL_KHR_robustness
+  glGetnUniformuiv := dlsym(glesLibrary, 'glGetnUniformuiv');
+// GL_OES_sample_shading
+  glMinSampleShading := dlsym(glesLibrary, 'glMinSampleShading');
+// GL_OES_tessellation_shader            GL_EXT_tessellation_shader
+  glPatchParameteri := dlsym(glesLibrary, 'glPatchParameteri');
+// GL_OES_texture_border_clamp           GL_EXT_texture_border_clamp
+  glTexParameterIiv := dlsym(glesLibrary, 'glTexParameterIiv');
+  glTexParameterIuiv := dlsym(glesLibrary, 'glTexParameterIuiv');
+  glGetTexParameterIiv := dlsym(glesLibrary, 'glGetTexParameterIiv');
+  glGetTexParameterIuiv := dlsym(glesLibrary, 'glGetTexParameterIuiv');
+  glSamplerParameterIiv := dlsym(glesLibrary, 'glSamplerParameterIiv');
+  glSamplerParameterIuiv := dlsym(glesLibrary, 'glSamplerParameterIuiv');
+  glGetSamplerParameterIiv := dlsym(glesLibrary, 'glGetSamplerParameterIiv');
+  glGetSamplerParameterIuiv := dlsym(glesLibrary, 'glGetSamplerParameterIuiv');
+// GL_OES_texture_buffer                 GL_EXT_texture_buffer
+  glTexBuffer := dlsym(glesLibrary, 'glTexBuffer');
+  glTexBufferRange := dlsym(glesLibrary, 'glTexBufferRange');
+// GL_OES_texture_storage_multisample_2d_array
+  glTexStorage3DMultisample := dlsym(glesLibrary, 'glTexStorage3DMultisample');
+{$EndIf}
+end;
+
+procedure FreeOpenGLES;
+begin
+  {$IfDef GL_VERSION_ES_CM_1_0}
+// min GLES function - glAlphaFunc := nil;
+// min GLES function - glClearColor := nil;
+// min GLES function - glClearDepthf := nil;
+  glClipPlanef := nil;
+// min GLES function - glColor4f := nil;
+  glDepthRangef := nil;
+  glFogf := nil;
+  glFogfv := nil;
+  glFrustumf := nil;
+  glGetClipPlanef := nil;
+// min GLES function - glGetFloatv := nil;
+  glGetLightfv := nil;
+  glGetMaterialfv := nil;
+  glGetTexEnvfv := nil;
+  glGetTexParameterfv := nil;
+  glLightModelf := nil;
+  glLightModelfv := nil;
+  glLightf := nil;
+  glLightfv := nil;
+  glLineWidth := nil;
+// min GLES function - glLoadMatrixf := nil;
+  glMaterialf := nil;
+  glMaterialfv := nil;
+  glMultMatrixf := nil;
+  glMultiTexCoord4f := nil;
+  glNormal3f := nil;
+// min GLES function - glOrthof := nil;
+  glPointParameterf := nil;
+  glPointParameterfv := nil;
+  glPointSize := nil;
+  glPolygonOffset := nil;
+// min GLES function - glRotatef := nil;
+// min GLES function - glScalef := nil;
+  glTexEnvf := nil;
+  glTexEnvfv := nil;
+// min GLES function - glTexParameterf := nil;
+  glTexParameterfv := nil;
+// min GLES function - glTranslatef := nil;
+  glActiveTexture := nil;
+  glAlphaFuncx := nil;
+  glBindBuffer := nil;
+// min GLES function - glBindTexture := nil;
+// min GLES function - glBlendFunc := nil;
+  glBufferData := nil;
+  glBufferSubData := nil;
+// min GLES function - glClear := nil;
+  glClearColorx := nil;
+  glClearDepthx := nil;
+  glClearStencil := nil;
+  glClientActiveTexture := nil;
+  glClipPlanex := nil;
+  glColor4ub := nil;
+  glColor4x := nil;
+// min GLES function - glColorMask := nil;
+// min GLES function - glColorPointer := nil;
+// min GLES function - glCompressedTexImage2D := nil;
+// min GLES function - glCompressedTexSubImage2D := nil;
+  glCopyTexImage2D := nil;
+// min GLES function - glCopyTexSubImage2D := nil;
+  glCullFace := nil;
+  glDeleteBuffers := nil;
+// min GLES function - glDeleteTextures := nil;
+// min GLES function - glDepthFunc := nil;
+// min GLES function - glDepthMask := nil;
+  glDepthRangex := nil;
+// min GLES function - glDisable := nil;
+// min GLES function - glDisableClientState := nil;
+// min GLES function - glDrawArrays := nil;
+// min GLES function - glDrawElements := nil;
+// min GLES function - glEnable := nil;
+// min GLES function - glEnableClientState := nil;
+  glFinish := nil;
+  glFlush := nil;
+  glFogx := nil;
+  glFogxv := nil;
+  glFrontFace := nil;
+  glFrustumx := nil;
+  glGetBooleanv := nil;
+  glGetBufferParameteriv := nil;
+  glGetClipPlanex := nil;
+  glGenBuffers := nil;
+// min GLES function - glGenTextures := nil;
+  glGetError := nil;
+  glGetFixedv := nil;
+// min GLES function - nil;
+  glGetLightxv := nil;
+  glGetMaterialxv := nil;
+  glGetPointerv := nil;
+// min GLES function - glGetString := nil;
+  glGetTexEnviv := nil;
+  glGetTexEnvxv := nil;
+  glGetTexParameteriv := nil;
+  glGetTexParameterxv := nil;
+// min GLES function - glHint := nil;
+  glIsBuffer := nil;
+  glIsEnabled := nil;
+  glIsTexture := nil;
+  glLightModelx := nil;
+  glLightModelxv := nil;
+  glLightx := nil;
+  glLightxv := nil;
+  glLineWidthx := nil;
+// min GLES function - glLoadIdentity := nil;
+  glLoadMatrixx := nil;
+  glLogicOp := nil;
+  glMaterialx := nil;
+  glMaterialxv := nil;
+// min GLES function - glMatrixMode := nil;
+  glMultMatrixx := nil;
+  glMultiTexCoord4x := nil;
+  glNormal3x := nil;
+  glNormalPointer := nil;
+  glOrthox := nil;
+// min GLES function - glPixelStorei := nil;
+  glPointParameterx := nil;
+  glPointParameterxv := nil;
+  glPointSizex := nil;
+  glPolygonOffsetx := nil;
+// min GLES function - glPopMatrix := nil;
+// min GLES function - glPushMatrix := nil;
+// min GLES function - glReadPixels := nil;
+  glRotatex := nil;
+  glSampleCoverage := nil;
+  glSampleCoveragex := nil;
+  glScalex := nil;
+// min GLES function - glScissor := nil;
+// min GLES function - glShadeModel := nil;
+  glStencilFunc := nil;
+  glStencilMask := nil;
+  glStencilOp := nil;
+// min GLES function - glTexCoordPointer := nil;
+// min GLES function - glTexEnvi := nil;
+// min GLES function - glTexEnvx := nil;
+// min GLES function - glTexEnviv := nil;
+// min GLES function - glTexEnvxv := nil;
+// min GLES function - glTexImage2D := nil;
+// min GLES function - glTexParameteri := nil;
+// min GLES function - glTexParameterx := nil;
+// min GLES function - glTexParameteriv := nil;
+// min GLES function - glTexParameterxv := nil;
+// min GLES function - glTexSubImage2D := nil;
+  glTranslatex := nil;
+// min GLES function - glVertexPointer := nil;
+// min GLES function - glViewport := nil;
+
+  {$IfDef GL_OES_point_size_array}
+  glPointSizePointerOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_equation_separate}
+  glBlendEquationSeparateOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_func_separate}
+  // min GLES function - glBlendFuncSeparateOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_blend_subtract}
+  glBlendEquationOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_draw_texture}
+  glDrawTexsOES := nil;
+  glDrawTexiOES := nil;
+  glDrawTexxOES := nil;
+  glDrawTexsvOES := nil;
+  glDrawTexivOES := nil;
+  glDrawTexxvOES := nil;
+  glDrawTexfOES := nil;
+  glDrawTexfvOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_fixed_point}
+  glAlphaFuncxOES := nil;
+  glClearColorxOES := nil;
+  glClearDepthxOES := nil;
+  glClipPlanexOES := nil;
+  glColor4xOES := nil;
+  glDepthRangexOES := nil;
+  glFogxOES := nil;
+  glFogxvOES := nil;
+  glFrustumxOES := nil;
+  glGetClipPlanexOES := nil;
+  glGetFixedvOES := nil;
+  glGetTexEnvxvOES := nil;
+  glGetTexParameterxvOES := nil;
+  glLightModelxOES := nil;
+  glLightModelxvOES := nil;
+  glLightxOES := nil;
+  glLightxvOES := nil;
+  glLineWidthxOES := nil;
+  glLoadMatrixxOES := nil;
+  glMaterialxOES := nil;
+  glMaterialxvOES := nil;
+  glMultMatrixxOES := nil;
+  glMultiTexCoord4xOES := nil;
+  glNormal3xOES := nil;
+  glOrthoxOES := nil;
+  glPointParameterxvOES := nil;
+  glPointSizexOES := nil;
+  glPolygonOffsetxOES := nil;
+  glRotatexOES := nil;
+  glScalexOES := nil;
+  glTexEnvxOES := nil;
+  glTexEnvxvOES := nil;
+  glTexParameterxOES := nil;
+  glTexParameterxvOES := nil;
+  glTranslatexOES := nil;
+  glGetLightxvOES := nil;
+  glGetMaterialxvOES := nil;
+  glPointParameterxOES := nil;
+  glSampleCoveragexOES := nil;
+  glGetTexGenxvOES := nil;
+  glTexGenxOES := nil;
+  glTexGenxvOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_framebuffer_object}
+// min GLES function - glIsRenderbufferOES := nil;
+// min GLES function - glBindRenderbufferOES := nil;
+// min GLES function - glDeleteRenderbuffersOES := nil;
+// min GLES function - glGenRenderbuffersOES := nil;
+// min GLES function - glRenderbufferStorageOES := nil;
+// min GLES function - glGetRenderbufferParameterivOES := nil;
+// min GLES function - glIsFramebufferOES := nil;
+// min GLES function - glBindFramebufferOES := nil;
+// min GLES function - glDeleteFramebuffersOES := nil;
+// min GLES function - glGenFramebuffersOES := nil;
+// min GLES function - glCheckFramebufferStatusOES := nil;
+// min GLES function - glFramebufferRenderbufferOES := nil;
+// min GLES function - glFramebufferTexture2DOES := nil;
+// min GLES function - glGetFramebufferAttachmentParameterivOES := nil;
+// min GLES function - glGenerateMipmapOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_matrix_palette}
+  glCurrentPaletteMatrixOES := nil;
+  glLoadPaletteFromModelViewMatrixOES := nil;
+  glMatrixIndexPointerOES := nil;
+  glWeightPointerOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_query_matrix}
+  glQueryMatrixxOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_single_precision}
+  glClearDepthfOES := nil;
+  glClipPlanefOES := nil;
+  glDepthRangefOES := nil;
+  glFrustumfOES := nil;
+  glGetClipPlanefOES := nil;
+  glOrthofOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_OES_texture_cube_map}
+  glTexGenfOES := nil;
+  glTexGenfvOES := nil;
+  glTexGeniOES := nil;
+  glTexGenivOES := nil;
+  glGetTexGenfvOES := nil;
+  glGetTexGenivOES := nil;
+  {$EndIf}
+
+  {$IfDef GL_IMG_user_clip_plane}
+  glClipPlanefIMG := nil;
+  glClipPlanexIMG := nil;
+  {$EndIf}
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_2_0}
+  glActiveTexture := nil;
+  glAttachShader := nil;
+  glBindAttribLocation := nil;
+  glBindBuffer := nil;
+// min GLES function - glBindFramebuffer := nil;
+// min GLES function - glBindRenderbuffer := nil;
+// min GLES function - glBindTexture := nil;
+  glBlendColor := nil;
+// min GLES function - glBlendEquation := nil;
+  glBlendEquationSeparate := nil;
+// min GLES function - glBlendFunc := nil;
+// min GLES function - glBlendFuncSeparate := nil;
+  glBufferData := nil;
+  glBufferSubData := nil;
+// min GLES function - glCheckFramebufferStatus := nil;
+// min GLES function - glClear := nil;
+// min GLES function - glClearColor := nil;
+// min GLES function - glClearDepthf := nil;
+  glClearStencil := nil;
+// min GLES function - glColorMask := nil;
+  glCompileShader := nil;
+// min GLES function - glCompressedTexImage2D := nil;
+// min GLES function - glCompressedTexSubImage2D := nil;
+  glCopyTexImage2D := nil;
+// min GLES function - glCopyTexSubImage2D := nil;
+  glCreateProgram := nil;
+  glCreateShader := nil;
+  glCullFace := nil;
+  glDeleteBuffers := nil;
+// min GLES function - glDeleteFramebuffers := nil;
+  glDeleteProgram := nil;
+// min GLES function - glDeleteRenderbuffers := nil;
+  glDeleteShader := nil;
+// min GLES function - glDeleteTextures := nil;
+// min GLES function - glDepthFunc := nil;
+// min GLES function - glDepthMask := nil;
+  glDepthRangef := nil;
+  glDetachShader := nil;
+// min GLES function - glDisable := nil;
+  glDisableVertexAttribArray := nil;
+// min GLES function - glDrawArrays := nil;
+// min GLES function - glDrawElements := nil;
+// min GLES function - glEnable := nil;
+  glEnableVertexAttribArray := nil;
+  glFinish := nil;
+  glFlush := nil;
+// min GLES function - glFramebufferRenderbuffer := nil;
+// min GLES function - glFramebufferTexture2D := nil;
+  glFrontFace := nil;
+  glGenBuffers := nil;
+// min GLES function - glGenerateMipmap := nil;
+// min GLES function - glGenFramebuffers := nil;
+// min GLES function - glGenRenderbuffers := nil;
+// min GLES function - glGenTextures := nil;
+  glGetActiveAttrib := nil;
+  glGetActiveUniform := nil;
+  glGetAttachedShaders := nil;
+  glGetAttribLocation := nil;
+  glGetBooleanv := nil;
+  glGetBufferParameteriv := nil;
+  glGetError := nil;
+// min GLES function - glGetFloatv := nil;
+// min GLES function - glGetFramebufferAttachmentParameteriv := nil;
+// min GLES function - glGetIntegerv := nil;
+  glGetProgramiv := nil;
+  glGetProgramInfoLog := nil;
+// min GLES function - glGetRenderbufferParameteriv := nil;
+  glGetShaderiv := nil;
+  glGetShaderInfoLog := nil;
+  glGetShaderPrecisionFormat := nil;
+  glGetShaderSource := nil;
+  // min GLES function - glGetString := nil;
+  glGetTexParameterfv := nil;
+  glGetTexParameteriv := nil;
+  glGetUniformfv := nil;
+  glGetUniformiv := nil;
+  glGetUniformLocation := nil;
+  glGetVertexAttribfv := nil;
+  glGetVertexAttribiv := nil;
+  glGetVertexAttribPointerv := nil;
+// min GLES function - glHint := nil;
+  glIsBuffer := nil;
+  glIsEnabled := nil;
+// min GLES function - glIsFramebuffer := nil;
+  glIsProgram := nil;
+// min GLES function - glIsRenderbuffer := nil;
+  glIsShader := nil;
+  glIsTexture := nil;
+  glLineWidth := nil;
+  glLinkProgram := nil;
+// min GLES function - glPixelStorei := nil;
+  glPolygonOffset := nil;
+//  // min GLES function - glReadPixels := nil;
+  glReleaseShaderCompiler := nil;
+// min GLES function - glRenderbufferStorage := nil;
+  glSampleCoverage := nil;
+// min GLES function - glScissor := nil;
+  glShaderBinary := nil;
+  glShaderSource := nil;
+  glStencilFunc := nil;
+  glStencilFuncSeparate := nil;
+  glStencilMask := nil;
+  glStencilMaskSeparate := nil;
+  glStencilOp := nil;
+  glStencilOpSeparate := nil;
+// min GLES function - glTexImage2D := dlsym(glesLibrary, 'glTexImage2D');
+// min GLES function - glTexParameterf := dlsym(glesLibrary, 'glTexParameterf');
+  glTexParameterfv := nil;
+// min GLES function - glTexParameteri := dlsym(glesLibrary, 'glTexParameteri');
+// min GLES function - glTexParameteriv := dlsym(glesLibrary, 'glTexParameteriv');
+// min GLES function - glTexSubImage2D := dlsym(glesLibrary, 'glTexSubImage2D');
+  glUniform1f := nil;
+  glUniform1fv := nil;
+  glUniform1i := nil;
+  glUniform1iv := nil;
+  glUniform2f := nil;
+  glUniform2fv := nil;
+  glUniform2i := nil;
+  glUniform2iv := nil;
+  glUniform3f := nil;
+  glUniform3fv := nil;
+  glUniform3i := nil;
+  glUniform3iv := nil;
+  glUniform4f := nil;
+  glUniform4fv := nil;
+  glUniform4i := nil;
+  glUniform4iv := nil;
+  glUniformMatrix2fv := nil;
+  glUniformMatrix3fv := nil;
+  glUniformMatrix4fv := nil;
+  glUseProgram := nil;
+  glValidateProgram := nil;
+  glVertexAttrib1f := nil;
+  glVertexAttrib1fv := nil;
+  glVertexAttrib2f := nil;
+  glVertexAttrib2fv := nil;
+  glVertexAttrib3f := nil;
+  glVertexAttrib3fv := nil;
+  glVertexAttrib4f := nil;
+  glVertexAttrib4fv := nil;
+  glVertexAttribPointer := nil;
+// min GLES function - glViewport := dlsym(glesLibrary, 'glViewport');
+{$EndIf}
+
+{$IfDef GL_KHR_blend_equation_advanced}
+  glBlendBarrierKHR := nil;
+{$EndIf}
+
+{$IfDef GL_KHR_debug}
+  glDebugMessageControlKHR := nil;
+  glDebugMessageInsertKHR := nil;
+  glDebugMessageCallbackKHR := nil;
+  glGetDebugMessageLogKHR := nil;
+  glPushDebugGroupKHR := nil;
+  glPopDebugGroupKHR := nil;
+  glObjectLabelKHR := nil;
+  glGetObjectLabelKHR := nil;
+  glObjectPtrLabelKHR := nil;
+  glGetObjectPtrLabelKHR := nil;
+  glGetPointervKHR := nil;
+{$EndIf}
+
+{$IfDef GL_KHR_parallel_shader_compile}
+  glMaxShaderCompilerThreadsKHR := nil;
+{$EndIf}
+
+{$IfDef GL_KHR_robustness}
+  glGetGraphicsResetStatusKHR := nil;
+  glReadnPixelsKHR := nil;
+  glGetnUniformfvKHR := nil;
+  glGetnUniformivKHR := nil;
+  glGetnUniformuivKHR := nil;
+{$EndIf}
+
+{$IfDef GL_OES_EGL_image}
+  glEGLImageTargetTexture2DOES := nil;
+  glEGLImageTargetRenderbufferStorageOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_copy_image}
+  glCopyImageSubDataOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_draw_buffers_indexed}
+  glEnableiOES := nil;
+  glDisableiOES := nil;
+  glBlendEquationiOES := nil;
+  glBlendEquationSeparateiOES := nil;
+  glBlendFunciOES := nil;
+  glBlendFuncSeparateiOES := nil;
+  glColorMaskiOES := nil;
+  glIsEnablediOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_draw_elements_base_vertex}
+  glDrawElementsBaseVertexOES := nil;
+  glDrawRangeElementsBaseVertexOES := nil;
+  glDrawElementsInstancedBaseVertexOES := nil;
+  glMultiDrawElementsBaseVertexEXT := nil;
+{$EndIf}
+
+{$IfDef GL_OES_geometry_shader}
+  glFramebufferTextureOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_get_program_binary}
+  glGetProgramBinaryOES := nil;
+  glProgramBinaryOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_mapbuffer}
+  glMapBufferOES := nil;
+  glUnmapBufferOES := nil;
+  glGetBufferPointervOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_primitive_bounding_box}
+  glPrimitiveBoundingBoxOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_sample_shading}
+  glMinSampleShadingOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_tessellation_shader}
+  glPatchParameteriOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_texture_3D}
+  glTexImage3DOES := nil;
+  glTexSubImage3DOES := nil;
+  glCopyTexSubImage3DOES := nil;
+  glCompressedTexImage3DOES := nil;
+  glCompressedTexSubImage3DOES := nil;
+  glFramebufferTexture3DOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_texture_border_clamp}
+  glTexParameterIivOES := nil;
+  glTexParameterIuivOES := nil;
+  glGetTexParameterIivOES := nil;
+  glGetTexParameterIuivOES := nil;
+  glSamplerParameterIivOES := nil;
+  glSamplerParameterIuivOES := nil;
+  glGetSamplerParameterIivOES := nil;
+  glGetSamplerParameterIuivOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_texture_buffer}
+  glTexBufferOES := nil;
+  glTexBufferRangeOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_texture_storage_multisample_2d_array}
+  glTexStorage3DMultisampleOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_texture_view}
+  glTextureViewOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_vertex_array_object}
+  glBindVertexArrayOES := nil;
+  glDeleteVertexArraysOES := nil;
+  glGenVertexArraysOES := nil;
+  glIsVertexArrayOES := nil;
+{$EndIf}
+
+{$IfDef GL_OES_viewport_array}
+  glViewportArrayvOES := nil;
+  glViewportIndexedfOES := nil;
+  glViewportIndexedfvOES := nil;
+  glScissorArrayvOES := nil;
+  glScissorIndexedOES := nil;
+  glScissorIndexedvOES := nil;
+  glDepthRangeArrayfvOES := nil;
+  glDepthRangeIndexedfOES := nil;
+  glGetFloati_vOES := nil;
+{$EndIf}
+
+{$IfDef GL_AMD_framebuffer_multisample_advanced}
+  glRenderbufferStorageMultisampleAdvancedAMD := nil;
+  glNamedRenderbufferStorageMultisampleAdvancedAMD := nil;
+{$EndIf}
+
+{$IfDef GL_AMD_performance_monitor}
+  glGetPerfMonitorGroupsAMD := nil;
+  glGetPerfMonitorCountersAMD := nil;
+  glGetPerfMonitorGroupStringAMD := nil;
+  glGetPerfMonitorCounterStringAMD := nil;
+  glGetPerfMonitorCounterInfoAMD := nil;
+  glGenPerfMonitorsAMD := nil;
+  glDeletePerfMonitorsAMD := nil;
+  glSelectPerfMonitorCountersAMD := nil;
+  glBeginPerfMonitorAMD := nil;
+  glEndPerfMonitorAMD := nil;
+  glGetPerfMonitorCounterDataAMD := nil;
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_blit}
+  glBlitFramebufferANGLE := nil;
+{$EndIf}
+
+{$IfDef GL_ANGLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleANGLE := nil;
+{$EndIf}
+
+{$IfDef GL_ANGLE_instanced_arrays}
+  glDrawArraysInstancedANGLE := nil;
+  glDrawElementsInstancedANGLE := nil;
+  glVertexAttribDivisorANGLE := nil;
+{$EndIf}
+
+{$IfDef GL_ANGLE_translated_shader_source}
+  glGetTranslatedShaderSourceANGLE := nil;
+{$EndIf}
+
+{$IfDef GL_APPLE_copy_texture_levels}
+  glCopyTextureLevelsAPPLE := nil;
+{$EndIf}
+
+{$IfDef GL_APPLE_framebuffer_multisample}
+  glRenderbufferStorageMultisampleAPPLE := nil;
+  glResolveMultisampleFramebufferAPPLE := nil;
+{$EndIf}
+
+{$IfDef GL_APPLE_sync}
+  glFenceSyncAPPLE := nil;
+  glIsSyncAPPLE := nil;
+  glDeleteSyncAPPLE := nil;
+  glClientWaitSyncAPPLE := nil;
+  glWaitSyncAPPLE := nil;
+  glGetInteger64vAPPLE := nil;
+  glGetSyncivAPPLE := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_EGL_image_storage}
+  glEGLImageTargetTexStorageEXT := nil;
+  glEGLImageTargetTextureStorageEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_base_instance}
+  glDrawArraysInstancedBaseInstanceEXT := nil;
+  glDrawElementsInstancedBaseInstanceEXT := nil;
+  glDrawElementsInstancedBaseVertexBaseInstanceEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_blend_func_extended}
+  glBindFragDataLocationIndexedEXT := nil;
+  glBindFragDataLocationEXT := nil;
+  glGetProgramResourceLocationIndexEXT := nil;
+  glGetFragDataIndexEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_buffer_storage}
+  glBufferStorageEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_clear_texture}
+  glClearTexImageEXT := nil;
+  glClearTexSubImageEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_clip_control}
+  glClipControlEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_copy_image}
+  glCopyImageSubDataEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_debug_label}
+  glLabelObjectEXT := nil;
+  glGetObjectLabelEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_debug_marker}
+  glInsertEventMarkerEXT := nil;
+  glPushGroupMarkerEXT := nil;
+  glPopGroupMarkerEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_discard_framebuffer}
+  glDiscardFramebufferEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_disjoint_timer_query}
+  glGenQueriesEXT := nil;
+  glDeleteQueriesEXT := nil;
+  glIsQueryEXT := nil;
+  glBeginQueryEXT := nil;
+  glEndQueryEXT := nil;
+  glQueryCounterEXT := nil;
+  glGetQueryivEXT := nil;
+  glGetQueryObjectivEXT := nil;
+  glGetQueryObjectuivEXT := nil;
+  glGetQueryObjecti64vEXT := nil;
+  glGetQueryObjectui64vEXT := nil;
+  glGetInteger64vEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_buffers}
+  glDrawBuffersEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_elements_base_vertex}
+  glDrawElementsBaseVertexEXT := nil;
+  glDrawRangeElementsBaseVertexEXT := nil;
+  glDrawElementsInstancedBaseVertexEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_instanced}
+  glDrawArraysInstancedEXT := nil;
+  glDrawElementsInstancedEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_draw_transform_feedback}
+  glDrawTransformFeedbackEXT := nil;
+  glDrawTransformFeedbackInstancedEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_external_buffer}
+  glBufferStorageExternalEXT := nil;
+  glNamedBufferStorageExternalEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_fragment_shading_rate}
+  glGetFragmentShadingRatesEXT := nil;
+  glShadingRateEXT := nil;
+  glShadingRateCombinerOpsEXT := nil;
+  glFramebufferShadingRateEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_framebuffer_blit_layers}
+  glBlitFramebufferLayersEXT := nil;
+  glBlitFramebufferLayerEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_geometry_shader}
+  glFramebufferTextureEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_instanced_arrays}
+  glVertexAttribDivisorEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_map_buffer_range}
+  glMapBufferRangeEXT := nil;
+  glFlushMappedBufferRangeEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object}
+  glGetUnsignedBytevEXT := nil;
+  glGetUnsignedBytei_vEXT := nil;
+  glDeleteMemoryObjectsEXT := nil;
+  glIsMemoryObjectEXT := nil;
+  glCreateMemoryObjectsEXT := nil;
+  glMemoryObjectParameterivEXT := nil;
+  glGetMemoryObjectParameterivEXT := nil;
+  glTexStorageMem2DEXT := nil;
+  glTexStorageMem2DMultisampleEXT := nil;
+  glTexStorageMem3DEXT := nil;
+  glTexStorageMem3DMultisampleEXT := nil;
+  glBufferStorageMemEXT := nil;
+  glTextureStorageMem2DEXT := nil;
+  glTextureStorageMem2DMultisampleEXT := nil;
+  glTextureStorageMem3DEXT := nil;
+  glTextureStorageMem3DMultisampleEXT := nil;
+  glNamedBufferStorageMemEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_fd}
+  glImportMemoryFdEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_memory_object_win32}
+  glImportMemoryWin32HandleEXT := nil;
+  glImportMemoryWin32NameEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_arrays}
+  glMultiDrawArraysEXT := nil;
+  glMultiDrawElementsEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_multi_draw_indirect}
+  glMultiDrawArraysIndirectEXT := nil;
+  glMultiDrawElementsIndirectEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleEXT := nil;
+  glFramebufferTexture2DMultisampleEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_multiview_draw_buffers}
+  glReadBufferIndexedEXT := nil;
+  glDrawBuffersIndexedEXT := nil;
+  glGetIntegeri_vEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_polygon_offset_clamp}
+   glPolygonOffsetClampEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_primitive_bounding_box}
+  glPrimitiveBoundingBoxEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_raster_multisample}
+  glRasterSamplesEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_robustness}
+  glGetGraphicsResetStatusEXT := nil;
+  glReadnPixelsEXT := nil;
+  glGetnUniformfvEXT := nil;
+  glGetnUniformivEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore}
+  glGenSemaphoresEXT := nil;
+  glDeleteSemaphoresEXT := nil;
+  glIsSemaphoreEXT := nil;
+  glSemaphoreParameterui64vEXT := nil;
+  glGetSemaphoreParameterui64vEXT := nil;
+  glWaitSemaphoreEXT := nil;
+  glSignalSemaphoreEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_fd}
+  glImportSemaphoreFdEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_semaphore_win32}
+  glImportSemaphoreWin32HandleEXT := nil;
+  glImportSemaphoreWin32NameEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_separate_shader_objects}
+  glActiveShaderProgramEXT := nil;
+  glBindProgramPipelineEXT := nil;
+  glCreateShaderProgramvEXT := nil;
+  glDeleteProgramPipelinesEXT := nil;
+  glGenProgramPipelinesEXT := nil;
+  glGetProgramPipelineInfoLogEXT := nil;
+  glGetProgramPipelineivEXT := nil;
+  glIsProgramPipelineEXT := nil;
+  glProgramParameteriEXT := nil;
+  glProgramUniform1fEXT := nil;
+  glProgramUniform1fvEXT := nil;
+  glProgramUniform1iEXT := nil;
+  glProgramUniform1ivEXT := nil;
+  glProgramUniform2fEXT := nil;
+  glProgramUniform2fvEXT := nil;
+  glProgramUniform2iEXT := nil;
+  glProgramUniform2ivEXT := nil;
+  glProgramUniform3fEXT := nil;
+  glProgramUniform3fvEXT := nil;
+  glProgramUniform3iEXT := nil;
+  glProgramUniform3ivEXT := nil;
+  glProgramUniform4fEXT := nil;
+  glProgramUniform4fvEXT := nil;
+  glProgramUniform4iEXT := nil;
+  glProgramUniform4ivEXT := nil;
+  glProgramUniformMatrix2fvEXT := nil;
+  glProgramUniformMatrix3fvEXT := nil;
+  glProgramUniformMatrix4fvEXT := nil;
+  glUseProgramStagesEXT := nil;
+  glValidateProgramPipelineEXT := nil;
+  glProgramUniform1uiEXT := nil;
+  glProgramUniform2uiEXT := nil;
+  glProgramUniform3uiEXT := nil;
+  glProgramUniform4uiEXT := nil;
+  glProgramUniform1uivEXT := nil;
+  glProgramUniform2uivEXT := nil;
+  glProgramUniform3uivEXT := nil;
+  glProgramUniform4uivEXT := nil;
+  glProgramUniformMatrix2x3fvEXT := nil;
+  glProgramUniformMatrix3x2fvEXT := nil;
+  glProgramUniformMatrix2x4fvEXT := nil;
+  glProgramUniformMatrix4x2fvEXT := nil;
+  glProgramUniformMatrix3x4fvEXT := nil;
+  glProgramUniformMatrix4x3fvEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_shader_framebuffer_fetch_non_coherent}
+  glFramebufferFetchBarrierEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_shader_pixel_local_storage2}
+  glFramebufferPixelLocalStorageSizeEXT := nil;
+  glGetFramebufferPixelLocalStorageSizeEXT := nil;
+  glClearPixelLocalStorageuiEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_sparse_texture}
+  glTexPageCommitmentEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_tessellation_shader}
+  glPatchParameteriEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_border_clamp}
+  glTexParameterIivEXT := nil;
+  glTexParameterIuivEXT := nil;
+  glGetTexParameterIivEXT := nil;
+  glGetTexParameterIuivEXT := nil;
+  glSamplerParameterIivEXT := nil;
+  glSamplerParameterIuivEXT := nil;
+  glGetSamplerParameterIivEXT := nil;
+  glGetSamplerParameterIuivEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_buffer}
+  glTexBufferEXT := nil;
+  glTexBufferRangeEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage}
+  glTexStorage1DEXT := nil;
+  glTexStorage2DEXT := nil;
+  glTexStorage3DEXT := nil;
+  glTextureStorage1DEXT := nil;
+  glTextureStorage2DEXT := nil;
+  glTextureStorage3DEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_storage_compression}
+  glTexStorageAttribs2DEXT := nil;
+  glTexStorageAttribs3DEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_texture_view}
+  glTextureViewEXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_win32_keyed_mutex}
+  glAcquireKeyedMutexWin32EXT := nil;
+  glReleaseKeyedMutexWin32EXT := nil;
+{$EndIf}
+
+{$IfDef GL_EXT_window_rectangles}
+  glWindowRectanglesEXT := nil;
+{$EndIf}
+
+{$IfDef GL_IMG_bindless_texture}
+  glGetTextureHandleIMG := nil;
+  glGetTextureSamplerHandleIMG := nil;
+  glUniformHandleui64IMG := nil;
+  glUniformHandleui64vIMG := nil;
+  glProgramUniformHandleui64IMG := nil;
+  glProgramUniformHandleui64vIMG := nil;
+{$EndIf}
+
+{$IfDef GL_IMG_framebuffer_downsample}
+  glFramebufferTexture2DDownsampleIMG := nil;
+  glFramebufferTextureLayerDownsampleIMG := nil;
+{$EndIf}
+
+{$IfDef GL_IMG_multisampled_render_to_texture}
+  glRenderbufferStorageMultisampleIMG := nil;
+  glFramebufferTexture2DMultisampleIMG := nil;
+{$EndIf}
+
+{$IfDef GL_INTEL_framebuffer_CMAA}
+  glApplyFramebufferAttachmentCMAAINTEL := nil;
+{$EndIf}
+
+{$IfDef GL_INTEL_performance_query}
+  glBeginPerfQueryINTEL := nil;
+  glCreatePerfQueryINTEL := nil;
+  glDeletePerfQueryINTEL := nil;
+  glEndPerfQueryINTEL := nil;
+  glGetFirstPerfQueryIdINTEL := nil;
+  glGetNextPerfQueryIdINTEL := nil;
+  glGetPerfCounterInfoINTEL := nil;
+  glGetPerfQueryDataINTEL := nil;
+  glGetPerfQueryIdByNameINTEL := nil;
+  glGetPerfQueryInfoINTEL := nil;
+{$EndIf}
+
+{$IfDef GL_MESA_framebuffer_flip_y}
+  glFramebufferParameteriMESA := nil;
+  glGetFramebufferParameterivMESA := nil;
+{$EndIf}
+
+{$IfDef GL_NV_bindless_texture}
+  glGetTextureHandleNV := nil;
+  glGetTextureSamplerHandleNV := nil;
+  glMakeTextureHandleResidentNV := nil;
+  glMakeTextureHandleNonResidentNV := nil;
+  glGetImageHandleNV := nil;
+  glMakeImageHandleResidentNV := nil;
+  glMakeImageHandleNonResidentNV := nil;
+  glUniformHandleui64NV := nil;
+  glUniformHandleui64vNV := nil;
+  glProgramUniformHandleui64NV := nil;
+  glProgramUniformHandleui64vNV := nil;
+  glIsTextureHandleResidentNV := nil;
+  glIsImageHandleResidentNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_blend_equation_advanced}
+  glBlendParameteriNV := nil;
+  glBlendBarrierNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_clip_space_w_scaling}
+  glViewportPositionWScaleNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_conditional_render}
+  glBeginConditionalRenderNV := nil;
+  glEndConditionalRenderNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster}
+  glSubpixelPrecisionBiasNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_conservative_raster_pre_snap_triangles}
+  glConservativeRasterParameteriNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_copy_buffer}
+  glCopyBufferSubDataNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_coverage_sample}
+  glCoverageMaskNV := nil;
+  glCoverageOperationNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_draw_buffers}
+  glDrawBuffersNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_draw_instanced}
+  glDrawArraysInstancedNV := nil;
+  glDrawElementsInstancedNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_draw_vulkan_image}
+  glDrawVkImageNV := nil;
+  glGetVkProcAddrNV := nil;
+  glWaitVkSemaphoreNV := nil;
+  glSignalVkSemaphoreNV := nil;
+  glSignalVkFenceNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_fence}
+  glDeleteFencesNV := nil;
+  glGenFencesNV := nil;
+  glIsFenceNV := nil;
+  glTestFenceNV := nil;
+  glGetFenceivNV := nil;
+  glFinishFenceNV := nil;
+  glSetFenceNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_fragment_coverage_to_color}
+  glFragmentCoverageColorNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_blit}
+  glBlitFramebufferNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_mixed_samples}
+  glCoverageModulationTableNV := nil;
+  glGetCoverageModulationTableNV := nil;
+  glCoverageModulationNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_framebuffer_multisample}
+  glRenderbufferStorageMultisampleNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_gpu_shader5}
+  glUniform1i64NV := nil;
+  glUniform2i64NV := nil;
+  glUniform3i64NV := nil;
+  glUniform4i64NV := nil;
+  glUniform1i64vNV := nil;
+  glUniform2i64vNV := nil;
+  glUniform3i64vNV := nil;
+  glUniform4i64vNV := nil;
+  glUniform1ui64NV := nil;
+  glUniform2ui64NV := nil;
+  glUniform3ui64NV := nil;
+  glUniform4ui64NV := nil;
+  glUniform1ui64vNV := nil;
+  glUniform2ui64vNV := nil;
+  glUniform3ui64vNV := nil;
+  glUniform4ui64vNV := nil;
+  glGetUniformi64vNV := nil;
+  glProgramUniform1i64NV := nil;
+  glProgramUniform2i64NV := nil;
+  glProgramUniform3i64NV := nil;
+  glProgramUniform4i64NV := nil;
+  glProgramUniform1i64vNV := nil;
+  glProgramUniform2i64vNV := nil;
+  glProgramUniform3i64vNV := nil;
+  glProgramUniform4i64vNV := nil;
+  glProgramUniform1ui64NV := nil;
+  glProgramUniform2ui64NV := nil;
+  glProgramUniform3ui64NV := nil;
+  glProgramUniform4ui64NV := nil;
+  glProgramUniform1ui64vNV := nil;
+  glProgramUniform2ui64vNV := nil;
+  glProgramUniform3ui64vNV := nil;
+  glProgramUniform4ui64vNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_instanced_arrays}
+  glVertexAttribDivisorNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_internalformat_sample_query}
+  glGetInternalformatSampleivNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_memory_attachment}
+  glGetMemoryObjectDetachedResourcesuivNV := nil;
+  glResetMemoryObjectParameterNV := nil;
+  glTexAttachMemoryNV := nil;
+  glBufferAttachMemoryNV := nil;
+  glTextureAttachMemoryNV := nil;
+  glNamedBufferAttachMemoryNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_memory_object_sparse}
+  glBufferPageCommitmentMemNV := nil;
+  glTexPageCommitmentMemNV := nil;
+  glNamedBufferPageCommitmentMemNV := nil;
+  glTexturePageCommitmentMemNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_mesh_shader}
+  glDrawMeshTasksNV := nil;
+  glDrawMeshTasksIndirectNV := nil;
+  glMultiDrawMeshTasksIndirectNV := nil;
+  glMultiDrawMeshTasksIndirectCountNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_non_square_matrices}
+  glUniformMatrix2x3fvNV := nil;
+  glUniformMatrix3x2fvNV := nil;
+  glUniformMatrix2x4fvNV := nil;
+  glUniformMatrix4x2fvNV := nil;
+  glUniformMatrix3x4fvNV := nil;
+  glUniformMatrix4x3fvNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_path_rendering}
+  glGenPathsNV := nil;
+  glDeletePathsNV := nil;
+  glIsPathNV := nil;
+  glPathCommandsNV := nil;
+  glPathCoordsNV := nil;
+  glPathSubCommandsNV := nil;
+  glPathSubCoordsNV := nil;
+  glPathStringNV := nil;
+  glPathGlyphsNV := nil;
+  glPathGlyphRangeNV := nil;
+  glWeightPathsNV := nil;
+  glCopyPathNV := nil;
+  glInterpolatePathsNV := nil;
+  glTransformPathNV := nil;
+  glPathParameterivNV := nil;
+  glPathParameteriNV := nil;
+  glPathParameterfvNV := nil;
+  glPathParameterfNV := nil;
+  glPathDashArrayNV := nil;
+  glPathStencilFuncNV := nil;
+  glPathStencilDepthOffsetNV := nil;
+  glStencilFillPathNV := nil;
+  glStencilStrokePathNV := nil;
+  glStencilFillPathInstancedNV := nil;
+  glStencilStrokePathInstancedNV := nil;
+  glPathCoverDepthFuncNV := nil;
+  glCoverFillPathNV := nil;
+  glCoverStrokePathNV := nil;
+  glCoverFillPathInstancedNV := nil;
+  glCoverStrokePathInstancedNV := nil;
+  glGetPathParameterivNV := nil;
+  glGetPathParameterfvNV := nil;
+  glGetPathCommandsNV := nil;
+  glGetPathCoordsNV := nil;
+  glGetPathDashArrayNV := nil;
+  glGetPathMetricsNV := nil;
+  glGetPathMetricRangeNV := nil;
+  glGetPathSpacingNV := nil;
+  glIsPointInFillPathNV := nil;
+  glIsPointInStrokePathNV := nil;
+  glGetPathLengthNV := nil;
+  glPointAlongPathNV := nil;
+  glMatrixLoad3x2fNV := nil;
+  glMatrixLoad3x3fNV := nil;
+  glMatrixLoadTranspose3x3fNV := nil;
+  glMatrixMult3x2fNV := nil;
+  glMatrixMult3x3fNV := nil;
+  glMatrixMultTranspose3x3fNV := nil;
+  glStencilThenCoverFillPathNV := nil;
+  glStencilThenCoverStrokePathNV := nil;
+  glStencilThenCoverFillPathInstancedNV := nil;
+  glStencilThenCoverStrokePathInstancedNV := nil;
+  glPathGlyphIndexRangeNV := nil;
+  glPathGlyphIndexArrayNV := nil;
+  glPathMemoryGlyphIndexArrayNV := nil;
+  glProgramPathFragmentInputGenNV := nil;
+  glGetProgramResourcefvNV := nil;
+  glMatrixFrustumEXT := nil;
+  glMatrixLoadIdentityEXT := nil;
+  glMatrixLoadTransposefEXT := nil;
+  glMatrixLoadTransposedEXT := nil;
+  glMatrixLoadfEXT := nil;
+  glMatrixLoaddEXT := nil;
+  glMatrixMultTransposefEXT := nil;
+  glMatrixMultTransposedEXT := nil;
+  glMatrixMultfEXT := nil;
+  glMatrixMultdEXT := nil;
+  glMatrixOrthoEXT := nil;
+  glMatrixPopEXT := nil;
+  glMatrixPushEXT := nil;
+  glMatrixRotatefEXT := nil;
+  glMatrixRotatedEXT := nil;
+  glMatrixScalefEXT := nil;
+  glMatrixScaledEXT := nil;
+  glMatrixTranslatefEXT := nil;
+  glMatrixTranslatedEXT := nil;
+{$EndIf}
+
+{$IfDef GL_NV_polygon_mode}
+  glPolygonModeNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_read_buffer}
+  glReadBufferNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_sample_locations}
+  glFramebufferSampleLocationsfvNV := nil;
+  glNamedFramebufferSampleLocationsfvNV := nil;
+  glResolveDepthValuesNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_scissor_exclusive}
+  glScissorExclusiveNV := nil;
+  glScissorExclusiveArrayvNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_shading_rate_image}
+  glBindShadingRateImageNV := nil;
+  glGetShadingRateImagePaletteNV := nil;
+  glGetShadingRateSampleLocationivNV := nil;
+  glShadingRateImageBarrierNV := nil;
+  glShadingRateImagePaletteNV := nil;
+  glShadingRateSampleOrderNV := nil;
+  glShadingRateSampleOrderCustomNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_timeline_semaphore}
+  glCreateSemaphoresNV := nil;
+  glSemaphoreParameterivNV := nil;
+  glGetSemaphoreParameterivNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_viewport_array}
+  glViewportArrayvNV := nil;
+  glViewportIndexedfNV := nil;
+  glViewportIndexedfvNV := nil;
+  glScissorArrayvNV := nil;
+  glScissorIndexedNV := nil;
+  glScissorIndexedvNV := nil;
+  glDepthRangeArrayfvNV := nil;
+  glDepthRangeIndexedfNV := nil;
+  glGetFloati_vNV := nil;
+  glEnableiNV := nil;
+  glDisableiNV := nil;
+  glIsEnablediNV := nil;
+{$EndIf}
+
+{$IfDef GL_NV_viewport_swizzle}
+  glViewportSwizzleNV := nil;
+{$EndIf}
+
+{$IfDef GL_OVR_multiview}
+  glFramebufferTextureMultiviewOVR := nil;
+{$EndIf}
+
+{$IfDef GL_OVR_multiview_multisampled_render_to_texture}
+  glFramebufferTextureMultisampleMultiviewOVR := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_alpha_test}
+  glAlphaFuncQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_driver_control}
+  glGetDriverControlsQCOM := nil;
+  glGetDriverControlStringQCOM := nil;
+  glEnableDriverControlQCOM := nil;
+  glDisableDriverControlQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get}
+  glExtGetTexturesQCOM := nil;
+  glExtGetBuffersQCOM := nil;
+  glExtGetRenderbuffersQCOM := nil;
+  glExtGetFramebuffersQCOM := nil;
+  glExtGetTexLevelParameterivQCOM := nil;
+  glExtTexObjectStateOverrideiQCOM := nil;
+  glExtGetTexSubImageQCOM := nil;
+  glExtGetBufferPointervQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_extended_get2}
+  glExtGetShadersQCOM := nil;
+  glExtGetProgramsQCOM := nil;
+  glExtIsProgramBinaryQCOM := nil;
+  glExtGetProgramBinarySourceQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_frame_extrapolation}
+  glExtrapolateTex2DQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_framebuffer_foveated}
+  glFramebufferFoveationConfigQCOM := nil;
+  glFramebufferFoveationParametersQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_motion_estimation}
+  glTexEstimateMotionQCOM := nil;
+  glTexEstimateMotionRegionsQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_shader_framebuffer_fetch_noncoherent}
+  glFramebufferFetchBarrierQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_shading_rate}
+  glShadingRateQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_texture_foveated}
+  glTextureFoveationParametersQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_QCOM_tiled_rendering}
+  glStartTilingQCOM := nil;
+  glEndTilingQCOM := nil;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_0}
+// GL_NV_read_buffer
+  glReadBuffer := nil;
+// none
+  glDrawRangeElements := nil;
+// GL_OES_texture_3D
+  glTexImage3D := nil;
+  glTexSubImage3D := nil;
+  glCopyTexSubImage3D := nil;
+  glCompressedTexImage3D := nil;
+  glCompressedTexSubImage3D := nil;
+// GL_EXT_disjoint_timer_query
+  glGenQueries := nil;
+  glDeleteQueries := nil;
+  glIsQuery := nil;
+  glBeginQuery := nil;
+  glEndQuery := nil;
+  glGetQueryiv := nil;
+  glGetQueryObjectuiv := nil;
+// GL_OES_mapbuffer
+  glUnmapBuffer := nil;
+  glGetBufferPointerv := nil;
+// GL_EXT_draw_buffers + GL_NV_draw_buffers
+  glDrawBuffers := nil;
+// GL_NV_non_square_matrices
+  glUniformMatrix2x3fv := nil;
+  glUniformMatrix3x2fv := nil;
+  glUniformMatrix2x4fv := nil;
+  glUniformMatrix4x2fv := nil;
+  glUniformMatrix3x4fv := nil;
+  glUniformMatrix4x3fv := nil;
+// GL_ANGLE_framebuffer_blit + GL_NV_framebuffer_blit
+  glBlitFramebuffer := nil;
+// GL_ANGLE_framebuffer_multisample + GL_APPLE_framebuffer_multisample + GL_EXT_multisampled_render_to_texture +
+//                                  GL_IMG_multisampled_render_to_texture + GL_NV_framebuffer_multisample
+  glRenderbufferStorageMultisample := nil;
+// none
+  glFramebufferTextureLayer := nil;
+// GL_EXT_map_buffer_range
+  glMapBufferRange := nil;
+  glFlushMappedBufferRange := nil;
+// GL_OES_vertex_array_object
+  glBindVertexArray := nil;
+  glDeleteVertexArrays := nil;
+  glGenVertexArrays := nil;
+  glIsVertexArray := nil;
+// GL_EXT_multiview_draw_buffers
+  glGetIntegeri_v := nil;
+// none
+  glBeginTransformFeedback := nil;
+  glEndTransformFeedback := nil;
+  glBindBufferRange := nil;
+  glBindBufferBase := nil;
+  glTransformFeedbackVaryings := nil;
+  glGetTransformFeedbackVarying := nil;
+  glVertexAttribIPointer := nil;
+  glGetVertexAttribIiv := nil;
+  glGetVertexAttribIuiv := nil;
+  glVertexAttribI4i := nil;
+  glVertexAttribI4ui := nil;
+  glVertexAttribI4iv := nil;
+  glVertexAttribI4uiv := nil;
+  glGetUniformuiv := nil;
+  glGetFragDataLocation := nil;
+  glUniform1ui := nil;
+  glUniform2ui := nil;
+  glUniform3ui := nil;
+  glUniform4ui := nil;
+  glUniform1uiv := nil;
+  glUniform2uiv := nil;
+  glUniform3uiv := nil;
+  glUniform4uiv := nil;
+  glClearBufferiv := nil;
+  glClearBufferuiv := nil;
+  glClearBufferfv := nil;
+  glClearBufferfi := nil;
+  glGetStringi := nil;
+// GL_NV_copy_buffer
+  glCopyBufferSubData := nil;
+// none
+  glGetUniformIndices := nil;
+  glGetActiveUniformsiv := nil;
+  glGetUniformBlockIndex := nil;
+  glGetActiveUniformBlockiv := nil;
+  glGetActiveUniformBlockName := nil;
+  glUniformBlockBinding := nil;
+// GL_ANGLE_instanced_arrays            GL_EXT_draw_instanced              GL_NV_draw_instanced
+  glDrawArraysInstanced := nil;
+  glDrawElementsInstanced := nil;
+// GL_APPLE_sync
+  glFenceSync := nil;
+  glIsSync := nil;
+  glDeleteSync := nil;
+  glClientWaitSync := nil;
+  glWaitSync := nil;
+// GL_APPLE_sync                        GL_EXT_disjoint_timer_query
+  glGetInteger64v := nil;
+// GL_APPLE_sync
+  glGetSynciv := nil;
+// none
+  glGetInteger64i_v := nil;
+  glGetBufferParameteri64v := nil;
+  glGenSamplers := nil;
+  glDeleteSamplers := nil;
+  glIsSampler := nil;
+  glBindSampler := nil;
+  glSamplerParameteri := nil;
+  glSamplerParameteriv := nil;
+  glSamplerParameterf := nil;
+  glSamplerParameterfv := nil;
+  glGetSamplerParameteriv := nil;
+  glGetSamplerParameterfv := nil;
+// GL_ANGLE_instanced_arrays            GL_EXT_instanced_arrays       GL_NV_instanced_arrays
+  glVertexAttribDivisor := nil;
+// none
+  glBindTransformFeedback := nil;
+  glDeleteTransformFeedbacks := nil;
+  glGenTransformFeedbacks := nil;
+  glIsTransformFeedback := nil;
+  glPauseTransformFeedback := nil;
+  glResumeTransformFeedback := nil;
+// GL_OES_get_program_binary
+  glGetProgramBinary := nil;
+  glProgramBinary := nil;
+// GL_EXT_separate_shader_objects
+  glProgramParameteri := nil;
+// none
+  glInvalidateFramebuffer := nil;
+  glInvalidateSubFramebuffer := nil;
+// GL_EXT_texture_storage
+  glTexStorage2D := nil;
+  glTexStorage3D := nil;
+// none
+  glGetInternalformativ := nil;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_1}
+// none
+  glDispatchCompute := nil;
+  glDispatchComputeIndirect := nil;
+  glDrawArraysIndirect := nil;
+  glDrawElementsIndirect := nil;
+// GL_MESA_framebuffer_flip_y
+  glFramebufferParameteri := nil;
+  glGetFramebufferParameteriv := nil;
+// none
+  glGetProgramInterfaceiv := nil;
+  glGetProgramResourceIndex := nil;
+  glGetProgramResourceName := nil;
+  glGetProgramResourceiv := nil;
+  glGetProgramResourceLocation := nil;
+// GL_EXT_separate_shader_objects
+  glUseProgramStages := nil;
+  glActiveShaderProgram := nil;
+  glCreateShaderProgramv := nil;
+  glBindProgramPipeline := nil;
+  glDeleteProgramPipelines := nil;
+  glGenProgramPipelines := nil;
+  glIsProgramPipeline := nil;
+  glGetProgramPipelineiv := nil;
+  glProgramUniform1i := nil;
+  glProgramUniform2i := nil;
+  glProgramUniform3i := nil;
+  glProgramUniform4i := nil;
+  glProgramUniform1ui := nil;
+  glProgramUniform2ui := nil;
+  glProgramUniform3ui := nil;
+  glProgramUniform4ui := nil;
+  glProgramUniform1f := nil;
+  glProgramUniform2f := nil;
+  glProgramUniform3f := nil;
+  glProgramUniform4f := nil;
+  glProgramUniform1iv := nil;
+  glProgramUniform2iv := nil;
+  glProgramUniform3iv := nil;
+  glProgramUniform4iv := nil;
+  glProgramUniform1uiv := nil;
+  glProgramUniform2uiv := nil;
+  glProgramUniform3uiv := nil;
+  glProgramUniform4uiv := nil;
+  glProgramUniform1fv := nil;
+  glProgramUniform2fv := nil;
+  glProgramUniform3fv := nil;
+  glProgramUniform4fv := nil;
+  glProgramUniformMatrix2fv := nil;
+  glProgramUniformMatrix3fv := nil;
+  glProgramUniformMatrix4fv := nil;
+  glProgramUniformMatrix2x3fv := nil;
+  glProgramUniformMatrix3x2fv := nil;
+  glProgramUniformMatrix2x4fv := nil;
+  glProgramUniformMatrix4x2fv := nil;
+  glProgramUniformMatrix3x4fv := nil;
+  glProgramUniformMatrix4x3fv := nil;
+  glValidateProgramPipeline := nil;
+  glGetProgramPipelineInfoLog := nil;
+// none
+  glBindImageTexture := nil;
+  glGetBooleani_v := nil;
+  glMemoryBarrier := nil;
+  glMemoryBarrierByRegion := nil;
+  glTexStorage2DMultisample := nil;
+  glGetMultisamplefv := nil;
+  glSampleMaski := nil;
+  glGetTexLevelParameteriv := nil;
+  glGetTexLevelParameterfv := nil;
+  glBindVertexBuffer := nil;
+  glVertexAttribFormat := nil;
+  glVertexAttribIFormat := nil;
+  glVertexAttribBinding := nil;
+  glVertexBindingDivisor := nil;
+{$EndIf}
+
+{$IfDef GL_ES_VERSION_3_2}
+// GL_KHR_blend_equation_advanced        GL_NV_blend_equation_advanced
+  glBlendBarrier := nil;
+// GL_OES_copy_image                     GL_EXT_copy_image
+  glCopyImageSubData := nil;
+// GL_KHR_debug
+  glDebugMessageControl := nil;
+  glDebugMessageInsert := nil;
+  glDebugMessageCallback := nil;
+  glGetDebugMessageLog := nil;
+  glPushDebugGroup := nil;
+  glPopDebugGroup := nil;
+  glObjectLabel := nil;
+// GL_KHR_debug                          GL_EXT_debug_label
+  glGetObjectLabel := nil;
+// GL_KHR_debug
+  glObjectPtrLabel := nil;
+  glGetObjectPtrLabel := nil;
+  glGetPointerv := nil;
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glEnablei := nil;
+  glDisablei := nil;
+// GL_OES_draw_buffers_indexed
+  glBlendEquationi := nil;
+  glBlendEquationSeparatei := nil;
+  glBlendFunci := nil;
+  glBlendFuncSeparatei := nil;
+  glColorMaski := nil;
+// GL_OES_draw_buffers_indexed           GL_NV_viewport_array
+  glIsEnabledi := nil;
+// GL_OES_draw_elements_base_vertex      GL_EXT_draw_elements_base_vertex
+  glDrawElementsBaseVertex := nil;
+  glDrawRangeElementsBaseVertex := nil;
+  glDrawElementsInstancedBaseVertex := nil;
+// GL_OES_geometry_shader                GL_EXT_geometry_shader
+  glFramebufferTexture := nil;
+// GL_OES_primitive_bounding_box         GL_EXT_primitive_bounding_box
+  glPrimitiveBoundingBox := nil;
+// GL_KHR_robustness                     GL_EXT_robustness
+  glGetGraphicsResetStatus := nil;
+  glReadnPixels := nil;
+  glGetnUniformfv := nil;
+  glGetnUniformiv := nil;
+// GL_KHR_robustness
+  glGetnUniformuiv := nil;
+// GL_OES_sample_shading
+  glMinSampleShading := nil;
+// GL_OES_tessellation_shader            GL_EXT_tessellation_shader
+  glPatchParameteri := nil;
+// GL_OES_texture_border_clamp           GL_EXT_texture_border_clamp
+  glTexParameterIiv := nil;
+  glTexParameterIuiv := nil;
+  glGetTexParameterIiv := nil;
+  glGetTexParameterIuiv := nil;
+  glSamplerParameterIiv := nil;
+  glSamplerParameterIuiv := nil;
+  glGetSamplerParameterIiv := nil;
+  glGetSamplerParameterIuiv := nil;
+// GL_OES_texture_buffer                 GL_EXT_texture_buffer
+  glTexBuffer := nil;
+  glTexBufferRange := nil;
+// GL_OES_texture_storage_multisample_2d_array
+  glTexStorage3DMultisample := nil;
+{$EndIf}
+end;
+
+end.
+

Zengl_SRC/srcGL/GLdefine.cfg

@@ -7,9 +7,6 @@
 // Eng: standard OpenGL split by version (everything is disabled). You can enable the version you are interested
 //      in here if you don't need additional extensions.
 //      Don't forget that on MacOS these are specific versions! But in ZenGL we can set the minimum version.
-{.$DEFINE USE_GL_21}           // Включите необходимые вам флаги!
-{.$DEFINE USE_GL_33}           // Turn on the flags you need!
-{.$DEFINE USE_GL_46}
 
 {$IFDEF MAC_COCOA}             // MacOS
   {$IFDEF USE_GL_33}
@@ -20,8 +17,8 @@
   {$ENDIF}
 {$ENDIF}
 
-// Rus: USE_MIN_OPENGL это основной рабочий набор для ZenGL.
-// Eng: USE_MIN_OPENGL is the main working set for ZenGL.
+// Rus: USE_MIN_OPENGL это основной рабочий набор для ZenGL. Отключите, если хотите использовать GL_CORE или GL_EXT.
+// Eng: USE_MIN_OPENGL is the main working set for ZenGL. Disable if you want to use GL_CORE or GL_EXT.
 {$DEFINE USE_MIN_OPENGL}
 
 (*********************************************************************************
@@ -38,14 +35,17 @@
   // Rus: устаревшие расширения для OpenGL 1.0 + 1.1.
   // Eng: deprecated extensions for OpenGL 1.0 + 1.1.
   {$define USE_DEPRECATED}
+
   // Rus: это полная версия OpenGL, в неё включены все расширения. Но если ваша видеокарта не поддерживает эти расширения,
   //      то они просто не загрузятся. Проверка всех расширений производится.
   // Eng: this is the full version of OpenGL, it includes all extensions. But if your video card does not support these
   //      extensions, then they simply will not load. All extensions are checked.
   {.$DEFINE USE_GLEXT}
+
   // по замыслу GL_CORE и GL_EXT должны быть основными, но в ZenGL мы сможем выбирать версию которая интересует именно нас.
   // мы можем включить GL_EXT (полный OpenGL) и ниже выключить дефайны которые нас не интересуют.
   {.$define USE_GLCORE}
+
   {$IF defined(USE_GLCORE) or defined(USE_GLEXT)}
     // Включение полной версии OpenGL или определённой версии. Всё в порядке очереди, версия GL_4+ включится самой последней,
     // потому если вы хотите использовать версию GL_4+ и выше, то всё остальное можно будет отключить.
@@ -117,12 +117,18 @@
 {$ENDIF}
 
 {$IFDEF USE_GL_32}
+  {$define GL_VERSION_1_5}
+  {$define GL_VERSION_2_0}
+  {$define GL_VERSION_2_1}
   {$define GL_VERSION_3_0}
   {$define GL_VERSION_3_1}
   {$define GL_VERSION_3_2}
 {$ENDIF}
 
 {$IFDEF USE_GL_33}
+  {$define GL_VERSION_1_5}
+  {$define GL_VERSION_2_0}
+  {$define GL_VERSION_2_1}
   {$define GL_VERSION_3_0}
   {$define GL_VERSION_3_1}
   {$define GL_VERSION_3_2}
@@ -130,6 +136,9 @@
 {$ENDIF}
 
 {$IFDEF USE_GL_41}
+  {$define GL_VERSION_1_5}
+  {$define GL_VERSION_2_0}
+  {$define GL_VERSION_2_1}
   {$define GL_VERSION_3_0}   // определить, какие ещё расширения нужны для использования GL 4.6
   {$define GL_VERSION_3_1}
   {$define GL_VERSION_3_2}
@@ -139,6 +148,9 @@
 {$ENDIF}
 
 {$IFDEF USE_GL_46}
+  {$define GL_VERSION_1_5}
+  {$define GL_VERSION_2_0}
+  {$define GL_VERSION_2_1}
   {$define GL_VERSION_3_0}   // определить, какие ещё расширения нужны для использования GL 4.6
   {$define GL_VERSION_3_1}
   {$define GL_VERSION_3_2}
@@ -172,9 +184,9 @@
   {$IFDEF GL_VERSION_3_0}
     {$Define GL_ARB_compatibility}
   {$ENDIF}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_color_buffer_float}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_compressed_texture_pixel_storage}
   {.$define GL_ARB_compute_shader}
   {$define GL_ARB_compute_variable_group_size}
@@ -186,14 +198,14 @@
   {$define GL_ARB_debug_output}
   {.$define GL_ARB_depth_buffer_float}
   {.$define GL_ARB_depth_clamp}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$define GL_ARB_depth_texture}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_derivative_control}
   {.$define GL_ARB_direct_state_access}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$define GL_ARB_draw_buffers}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_ARB_draw_buffers_blend}
   {.$define GL_ARB_draw_elements_base_vertex}
   {.$define GL_ARB_draw_indirect}
@@ -203,11 +215,11 @@
   {.$define GL_ARB_explicit_uniform_location}
   {.$define GL_ARB_fragment_coord_conventions}
   {.$define GL_ARB_fragment_layer_viewport}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$define GL_ARB_fragment_program}
       {.$define GL_ARB_fragment_program_shadow}
       {$define GL_ARB_fragment_shader}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_fragment_shader_interlock}
   {.$define GL_ARB_framebuffer_no_attachments}
   {.$define GL_ARB_framebuffer_object}
@@ -219,10 +231,10 @@
   {.$define GL_ARB_gpu_shader5}
   {.$define GL_ARB_gpu_shader_fp64}
   {$define GL_ARB_gpu_shader_int64}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_half_float_pixel}
       {$define GL_ARB_imaging}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_half_float_vertex}
   {$define GL_ARB_indirect_parameters}
   {$define GL_ARB_instanced_arrays}
@@ -231,24 +243,24 @@
   {.$define GL_ARB_invalidate_subdata}
   {.$define GL_ARB_map_buffer_alignment}
   {.$define GL_ARB_map_buffer_range}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_matrix_palette}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_multi_bind}
   {.$define GL_ARB_multi_draw_indirect}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_multisample}
       {$Define GL_ARB_multitexture}
       {$Define GL_ARB_occlusion_query}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_occlusion_query2}
   {$define GL_ARB_parallel_shader_compile}
   {$define GL_ARB_pipeline_statistics_query}
   {$define GL_ARB_pixel_buffer_object}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_point_parameters}
       {$Define GL_ARB_point_sprite}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_polygon_offset_clamp}
   {.$define GL_ARB_post_depth_coverage}
   {.$define GL_ARB_program_interface_query}
@@ -272,26 +284,26 @@
   {.$define GL_ARB_shader_group_vote}
   {.$define GL_ARB_shader_image_load_store}
   {.$define GL_ARB_shader_image_size}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_shader_objects}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_shader_precision}
   {.$define GL_ARB_shader_stencil_export}
   {.$define GL_ARB_shader_storage_buffer_object}
   {.$define GL_ARB_shader_subroutine}
   {.$define GL_ARB_shader_texture_image_samples}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_ARB_shader_texture_lod}
       {$Define GL_ARB_shading_language_100}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_shader_viewport_layer_array}
   {.$define GL_ARB_shading_language_420pack}
   {$define GL_ARB_shading_language_include}
   {.$define GL_ARB_shading_language_packing}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_shadow}
       {$Define GL_ARB_shadow_ambient}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_ARB_sparse_buffer}
   {$define GL_ARB_sparse_texture}
   {.$define GL_ARB_sparse_texture2}
@@ -305,26 +317,26 @@
   {$define GL_ARB_texture_buffer_object}
   {.$define GL_ARB_texture_buffer_object_rgb32}
   {.$define GL_ARB_texture_buffer_range}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_texture_compression}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_ARB_texture_compression_bptc}
   {.$define GL_ARB_texture_compression_rgtc}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_texture_cube_map}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_ARB_texture_cube_map_array}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_ARB_texture_env_add}
       {$Define GL_ARB_texture_env_combine}
       {.$Define GL_ARB_texture_env_crossbar}
       {$Define GL_ARB_texture_env_dot3}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_texture_filter_anisotropic}
   {$define GL_ARB_texture_filter_minmax}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_texture_float}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_ARB_texture_gather}
   {.$define GL_ARB_texture_mirror_clamp_to_edge}
   {$define GL_ARB_texture_mirrored_repeat}
@@ -332,9 +344,9 @@
   {.$define GL_ARB_texture_non_power_of_two}
   {.$define GL_ARB_texture_query_levels}
   {.$define GL_ARB_texture_query_lod}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_ARB_texture_rectangle}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_texture_rg}
   {.$define GL_ARB_texture_rgb10_a2ui}
   {.$define GL_ARB_texture_stencil8}
@@ -347,26 +359,26 @@
   {.$define GL_ARB_transform_feedback3}
   {.$define GL_ARB_transform_feedback_instanced}
   {$define GL_ARB_transform_feedback_overflow_query}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_transpose_matrix}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_uniform_buffer_object}
   {.$define GL_ARB_vertex_array_bgra}
   {.$define GL_ARB_vertex_array_object}
   {.$define GL_ARB_vertex_attrib_64bit}
   {.$define GL_ARB_vertex_attrib_binding}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_vertex_blend}
       {$Define GL_ARB_vertex_buffer_object}
       {$Define GL_ARB_vertex_program}
       {$Define GL_ARB_vertex_shader}
-     {$ENDIF}
+    {$ENDIF}
   {.$define GL_ARB_vertex_type_10f_11f_11f_rev}
   {.$define GL_ARB_vertex_type_2_10_10_10_rev}
   {$define GL_ARB_viewport_array}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ARB_window_pos}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_KHR_blend_equation_advanced}
   {$define GL_KHR_blend_equation_advanced_coherent}
   {.$define GL_KHR_context_flush_control}
@@ -379,7 +391,7 @@
   {$define GL_KHR_texture_compression_astc_hdr}
   {.$define GL_KHR_texture_compression_astc_ldr}
   {.$define GL_KHR_texture_compression_astc_sliced_3d}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_OES_byte_coordinates}
       {$Define GL_OES_compressed_paletted_texture}
       {$Define GL_OES_fixed_point}
@@ -389,14 +401,18 @@
       {$Define GL_3DFX_multisample}
       {$Define GL_3DFX_tbuffer}
       {$Define GL_3DFX_texture_compression_FXT1}
+    {$ENDIF}
+
+{$IFDEF VID_AMD}
+    {$IFDEF USE_GLEXT}
       {$Define GL_AMD_blend_minmax_factor}
       {.$Define GL_AMD_conservative_depth}
       {$Define GL_AMD_debug_output}
       {$Define GL_AMD_depth_clamp_separate}
       {$Define GL_AMD_draw_buffers_blend}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_AMD_framebuffer_multisample_advanced}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_AMD_framebuffer_sample_positions}
       {.$Define GL_AMD_gcn_shader}
       {$Define GL_AMD_gpu_shader_half_float}
@@ -406,9 +422,9 @@
       {$Define GL_AMD_multi_draw_indirect}
       {$Define GL_AMD_name_gen_delete}
       {$Define GL_AMD_occlusion_query_event}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_AMD_performance_monitor}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_AMD_pinned_memory}
       {$Define GL_AMD_query_buffer_object}
       {$Define GL_AMD_sample_positions}
@@ -429,6 +445,12 @@
       {.$Define GL_AMD_vertex_shader_layer}
       {$Define GL_AMD_vertex_shader_tessellator}
       {.$Define GL_AMD_vertex_shader_viewport_index}
+    {$ENDIF}
+{$ENDIF}
+// ---- end AMD
+
+{$IFDEF VID_APPLE}
+    {$IFDEF USE_GLEXT}
       {$Define GL_APPLE_aux_depth_stencil}
       {$Define GL_APPLE_client_storage}
       {$Define GL_APPLE_element_array}
@@ -436,9 +458,9 @@
       {$Define GL_APPLE_float_pixels}
       {$Define GL_APPLE_flush_buffer_range}
       {$Define GL_APPLE_object_purgeable}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_APPLE_rgb_422}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_APPLE_row_bytes}
       {$Define GL_APPLE_specular_vector}
       {$Define GL_APPLE_texture_range}
@@ -447,6 +469,12 @@
       {$Define GL_APPLE_vertex_array_range}
       {$Define GL_APPLE_vertex_program_evaluators}
       {$Define GL_APPLE_ycbcr_422}
+    {$ENDIF}
+{$ENDIF}
+// ---- end APPLE
+
+{$IFDEF VID_AMD}
+    {$IFDEF USE_GLEXT}
       {$Define GL_ATI_draw_buffers}
       {$Define GL_ATI_element_array}
       {$Define GL_ATI_envmap_bumpmap}
@@ -463,11 +491,16 @@
       {$Define GL_ATI_vertex_array_object}
       {$Define GL_ATI_vertex_attrib_array_object}
       {$Define GL_ATI_vertex_streams}
+    {$ENDIF}
+{$ENDIF}
+// ---- end AMD
+
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_422_pixels}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_EGL_image_storage}
   {.$define GL_EXT_EGL_sync}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_abgr}
       {$Define GL_EXT_bgra}
       {$Define GL_EXT_bindable_uniform}
@@ -485,18 +518,18 @@
       {$Define GL_EXT_coordinate_frame}
       {$Define GL_EXT_copy_texture}
       {$Define GL_EXT_cull_vertex}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_debug_label}
   {$define GL_EXT_debug_marker}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_depth_bounds_test}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_direct_state_access}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_draw_buffers2}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_draw_instanced}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_draw_range_elements}
       {$Define GL_EXT_external_buffer}
       {$Define GL_EXT_fog_coord}
@@ -520,11 +553,11 @@
       {.$Define GL_EXT_misc_attribute}
       {$Define GL_EXT_multi_draw_arrays}
       {$Define GL_EXT_multisample}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_EXT_multiview_tessellation_geometry_shader}
   {.$Define GL_EXT_multiview_texture_multisample}
   {.$Define GL_EXT_multiview_timer_query}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_packed_depth_stencil}
       {$Define GL_EXT_packed_float}
       {$Define GL_EXT_packed_pixels}
@@ -534,32 +567,32 @@
       {.$Define GL_EXT_pixel_transform_color_table}
       {$Define GL_EXT_point_parameters}
       {$Define GL_EXT_polygon_offset}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_polygon_offset_clamp}
   {.$Define GL_EXT_post_depth_coverage}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_provoking_vertex}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_raster_multisample}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_rescale_normal}
       {$Define GL_EXT_secondary_color}
       {$Define GL_EXT_semaphore}
       {$Define GL_EXT_semaphore_fd}
       {$Define GL_EXT_semaphore_win32}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_separate_shader_objects}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$define GL_EXT_separate_specular_color}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_shader_framebuffer_fetch}
   {$define GL_EXT_shader_framebuffer_fetch_non_coherent}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_EXT_shader_image_load_formatted}
       {$Define GL_EXT_shader_image_load_store}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_EXT_shader_integer_mix}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_EXT_shadow_funcs}
       {$Define GL_EXT_shared_texture_palette}
       {.$Define GL_EXT_sparse_texture2}
@@ -573,34 +606,34 @@
       {$Define GL_EXT_texture_buffer_object}
       {$Define GL_EXT_texture_compression_latc}
       {$Define GL_EXT_texture_compression_rgtc}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_texture_compression_s3tc}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_texture_cube_map}
       {.$Define GL_EXT_texture_env_add}
       {$Define GL_EXT_texture_env_combine}
       {$Define GL_EXT_texture_env_dot3}
       {$Define GL_EXT_texture_filter_anisotropic}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_texture_filter_minmax}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_texture_integer}
       {$Define GL_EXT_texture_lod_bias}
       {$Define GL_EXT_texture_mirror_clamp}
       {$Define GL_EXT_texture_object}
       {$Define GL_EXT_texture_perturb_normal}
       {$Define GL_EXT_texture_sRGB}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_texture_sRGB_R8}
   {$define GL_EXT_texture_sRGB_RG8}
   {$define GL_EXT_texture_sRGB_decode}
   {.$Define GL_EXT_texture_shadow_lod}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_texture_shared_exponent}
       {$Define GL_EXT_texture_snorm}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_texture_storage}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_texture_swizzle}
       {$Define GL_EXT_timer_query}
       {$Define GL_EXT_transform_feedback}
@@ -610,9 +643,9 @@
       {$Define GL_EXT_vertex_shader}
       {$Define GL_EXT_vertex_weighting}
       {$Define GL_EXT_win32_keyed_mutex}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_EXT_window_rectangles}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_EXT_x11_sync_object}
       {$Define GL_GREMEDY_frame_terminator}
       {$Define GL_GREMEDY_string_marker}
@@ -629,25 +662,30 @@
       {$Define GL_INGR_blend_func_separate}
       {$Define GL_INGR_color_clamp}
       {$Define GL_INGR_interlace_read}
-     {$ENDIF}
+    {$ENDIF}
+
+{$IFDEF VID_INTEL}
   {$define GL_INTEL_blackhole_render}
   {$define GL_INTEL_conservative_rasterization}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_INTEL_fragment_shader_ordering}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_INTEL_framebuffer_CMAA}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_INTEL_map_texture}
       {$Define GL_INTEL_parallel_arrays}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_INTEL_performance_query}
-     {$IFDEF USE_GLEXT}
+{$ENDIF}
+// ----- end Intel
+
+    {$IFDEF USE_GLEXT}
       {$Define GL_MESAX_texture_stack}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_MESA_framebuffer_flip_x}
   {$define GL_MESA_framebuffer_flip_y}
   {$define GL_MESA_framebuffer_swap_xy}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_MESA_pack_invert}
       {$Define GL_MESA_program_binary_formats}
       {$Define GL_MESA_resize_buffers}
@@ -655,6 +693,10 @@
       {$Define GL_MESA_tile_raster_order}
       {$Define GL_MESA_window_pos}
       {$Define GL_MESA_ycbcr_texture}
+    {$ENDIF}
+
+{$IFDEF VID_NV}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NVX_blend_equation_advanced_multi_draw_buffers}
       {$Define GL_NVX_conditional_render}
       {$Define GL_NVX_gpu_memory_info}
@@ -662,21 +704,21 @@
       {$Define GL_NVX_linked_gpu_multicast}
       {$Define GL_NVX_progress_fence}
       {$Define GL_NV_alpha_to_coverage_dither_control}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_bindless_multi_draw_indirect}
   {$define GL_NV_bindless_multi_draw_indirect_count}
   {$define GL_NV_bindless_texture}
   {$define GL_NV_blend_equation_advanced}
   {$define GL_NV_blend_equation_advanced_coherent}
   {$define GL_NV_blend_minmax_factor}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NV_blend_square}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_clip_space_w_scaling}
   {$define GL_NV_command_list}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_compute_program5}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_NV_compute_shader_derivatives}
   {$define GL_NV_conditional_render}
   {$define GL_NV_conservative_raster}
@@ -684,49 +726,49 @@
   {$define GL_NV_conservative_raster_pre_snap}
   {$define GL_NV_conservative_raster_pre_snap_triangles}
   {.$Define GL_NV_conservative_raster_underestimation}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_copy_depth_to_color}
       {$Define GL_NV_copy_image}
       {$Define GL_NV_deep_texture3D}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_depth_buffer_float}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_depth_clamp}
       {$Define GL_NV_draw_texture}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_draw_vulkan_image}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_evaluators}
       {$Define GL_NV_explicit_multisample}
       {$Define GL_NV_fence}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_fill_rectangle}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_float_buffer}
       {$Define GL_NV_fog_distance}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_fragment_coverage_to_color}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_fragment_program}
       {$Define GL_NV_fragment_program2}
       {.$Define GL_NV_fragment_program4}
       {.$Define GL_NV_fragment_program_option}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_NV_fragment_shader_barycentric}
   {.$Define GL_NV_fragment_shader_interlock}
   {$define GL_NV_framebuffer_mixed_samples}
   {$define GL_NV_framebuffer_multisample_coverage}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_geometry_program4}
       {.$Define GL_NV_geometry_shader4}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_NV_geometry_shader_passthrough}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_gpu_multicast}
       {$Define GL_NV_gpu_program4}
       {$Define GL_NV_gpu_program5}
       {.$Define GL_NV_gpu_program5_mem_extended}
-     {$ENDIF}
+    {$ENDIF}
 
      // узнать, работает ли эта часть при GLext!!!!
      // хотя функции подменены в другом разделе. У меня его вообще нет!!!
@@ -734,43 +776,43 @@
   {$define GL_NV_gpu_shader5}
   {$ENDIF}
 
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_half_float}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_internalformat_sample_query}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_light_max_exponent}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_memory_attachment}
   {$define GL_NV_memory_object_sparse}
   {$define GL_NV_mesh_shader}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NV_multisample_coverage}
       {$Define GL_NV_multisample_filter_hint}
       {$Define GL_NV_occlusion_query}
       {$Define GL_NV_packed_depth_stencil}
       {$Define GL_NV_parameter_buffer_object}
       {.$Define GL_NV_parameter_buffer_object2}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_path_rendering}
   {$define GL_NV_path_rendering_shared_edge}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_pixel_data_range}
       {$Define GL_NV_point_sprite}
       {$Define GL_NV_present_video}
       {$Define GL_NV_primitive_restart}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_primitive_shading_rate}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_query_resource}
       {$Define GL_NV_query_resource_tag}
       {$Define GL_NV_register_combiners}
       {$Define GL_NV_register_combiners2}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_representative_fragment_test}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_robustness_video_memory_purge}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_sample_locations}
   {.$Define GL_NV_sample_mask_override_coverage}
   {$define GL_NV_scissor_exclusive}
@@ -781,47 +823,47 @@
   {.$Define GL_NV_shader_atomic_int64}
   {$define GL_NV_shader_buffer_load}
   {$define GL_NV_shader_buffer_store}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NV_shader_storage_buffer_object}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_shader_subgroup_partitioned}
   {.$Define GL_NV_shader_texture_footprint}
   {$define GL_NV_shader_thread_group}
   {.$Define GL_NV_shader_thread_shuffle}
   {$define GL_NV_shading_rate_image}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NV_stereo_view_rendering}
       {$Define GL_NV_tessellation_program5}
       {$Define GL_NV_texgen_emboss}
       {$Define GL_NV_texgen_reflection}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_texture_barrier}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {.$Define GL_NV_texture_compression_vtc}
       {$Define GL_NV_texture_env_combine4}
       {$Define GL_NV_texture_expand_normal}
       {$Define GL_NV_texture_multisample}
       {$Define GL_NV_texture_rectangle}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_NV_texture_rectangle_compressed}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_texture_shader}
       {$Define GL_NV_texture_shader2}
       {$Define GL_NV_texture_shader3}
       {$Define GL_NV_timeline_semaphore}
       {$Define GL_NV_transform_feedback}
       {$Define GL_NV_transform_feedback2}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_uniform_buffer_unified_memory}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_vdpau_interop}
       {$Define GL_NV_vdpau_interop2}
       {$Define GL_NV_vertex_array_range}
       {$Define GL_NV_vertex_array_range2}
-     {$ENDIF}
+    {$ENDIF}
   {$define GL_NV_vertex_attrib_integer_64bit}
   {$define GL_NV_vertex_buffer_unified_memory}
-     {$IFDEF USE_GLEXT}
+    {$IFDEF USE_GLEXT}
       {$Define GL_NV_vertex_program}
       {.$Define GL_NV_vertex_program1_1}
       {.$Define GL_NV_vertex_program2}
@@ -829,21 +871,24 @@
       {.$Define GL_NV_vertex_program3}
       {$Define GL_NV_vertex_program4}
       {$Define GL_NV_video_capture}
-     {$ENDIF}
+    {$ENDIF}
   {.$Define GL_NV_viewport_array2}
   {$define GL_NV_viewport_swizzle}
-     {$IFDEF USE_GLEXT}
+{$ENDIF}
+//  ---- end NVidia
+
+    {$IFDEF USE_GLEXT}
       {$Define GL_OML_interlace}
       {$Define GL_OML_resample}
       {$Define GL_OML_subsample}
-     {$ENDIF}
-  {$define GL_OVR_multiview}
-  {.$Define GL_OVR_multiview2}
-     {$IFDEF USE_GLEXT}
-      {$Define GL_PGI_misc_hints}
-      {.$Define GL_PGI_vertex_hints}
-      {$Define GL_REND_screen_coordinates}
-      {$Define GL_S3_s3tc}
+    {$ENDIF}
+  {$DEFINE GL_OVR_multiview}
+  {.$DEFINE GL_OVR_multiview2}
+    {$IFDEF USE_GLEXT}
+      {$DEFINE GL_PGI_misc_hints}
+      {.$DEFINE GL_PGI_vertex_hints}
+      {$DEFINE GL_REND_screen_coordinates}
+      {$DEFINE GL_S3_s3tc}
       {$Define GL_SGIS_detail_texture}
       {$Define GL_SGIS_fog_function}
       {.$Define GL_SGIS_generate_mipmap}
@@ -909,7 +954,7 @@
       {$Define GL_SUN_vertex}
       {$Define GL_WIN_phong_shading}
       {$Define GL_WIN_specular_fog}
-     {$ENDIF}
+    {$ENDIF}
 {$IfEnd}
 
 {$IFDEF WINDOWS}

Zengl_SRC/srcGL/zgl_gltypeconst.pas

@@ -1,11 +1,44 @@
-(* вынесено в отдельный файл, для удобства и возможности использовать везде
+(*******************************************************************************
+*  вынесено в отдельный файл, для удобства и возможности использовать везде
 *  константы и типы не занимают в исполняемом файле места, потому можно создавать
 *  миллионы констант
 *  метки в файле стоят, потому поиск по константам можно проводить по меткам.
 *
 *  Для типов требуется "разбить" по определёнию для определённых платформ.
 *  Какие-то определения могут не подходить по типам. Смотрите файлы кроноса.
-*)
+*******************************************************************************)
+
+(*
+ *  Copyright (c) 2022-2023 Serge - SSW
+ *
+ *  This software is provided 'as-is', without any express or
+ *  implied warranty. In no event will the authors be held
+ *  liable for any damages arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute
+ *  it freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented;
+ *     you must not claim that you wrote the original software.
+ *     If you use this software in a product, an acknowledgment
+ *     in the product documentation would be appreciated but
+ *     is not required.
+ *
+ *  2. Altered source versions must be plainly marked as such,
+ *     and must not be misrepresented as being the original software.
+ *
+ *  3. This notice may not be removed or altered from any
+ *     source distribution.
+ *)
+
+// Copyright 2013-2020 The Khronos Group Inc.
+// SPDX-License-Identifier: MIT
+//
+// This header is generated from the Khronos OpenGL / OpenGL ES XML
+// API Registry. The current version of the Registry, generator scripts
+// used to make the header, and the header can be found at
+//   https://github.com/KhronosGroup/OpenGL-Registry
 
 unit zgl_gltypeconst;
 {$I zgl_config.cfg}
@@ -686,6 +719,37 @@ type
   // GLX_SGIX_video_source
   GLXVideoSourceSGIX = TXID;
 
+type
+  TVector2d = array[0..1] of double;
+  TVector2f = array[0..1] of single;
+  TVector2i = array[0..1] of longint;
+  TVector2s = array[0..1] of smallint;
+  TVector2b = array[0..1] of byte;
+
+  TVector3d = array[0..2] of double;
+  TVector3f = array[0..2] of single;
+  TVector3i = array[0..2] of longint;
+  TVector3s = array[0..2] of smallint;
+  TVector3b = array[0..2] of byte;
+
+  TVector4d = array[0..3] of double;
+  TVector4f = array[0..3] of single;
+  TVector4i = array[0..3] of longint;
+  TVector4s = array[0..3] of smallint;
+  TVector4b = array[0..3] of byte;
+
+  TMatrix3d = array[0..2] of TVector3d;
+  TMatrix3f = array[0..2] of TVector3f;
+  TMatrix3i = array[0..2] of TVector3i;
+  TMatrix3s = array[0..2] of TVector3s;
+  TMatrix3b = array[0..2] of TVector3b;
+
+  TMatrix4d = array[0..3] of TVector4d;
+  TMatrix4f = array[0..3] of TVector4f;
+  TMatrix4i = array[0..3] of TVector4i;
+  TMatrix4s = array[0..3] of TVector4s;
+  TMatrix4b = array[0..3] of TVector4b;
+
 {$ifdef GLX_EXT_stereo_tree}
 type
   GLXStereoNotifyEventEXT = record

Zengl_SRC/srcGL/zgl_matrix.pas

@@ -0,0 +1,133 @@
+unit zgl_matrix;
+{$mode delphi}
+{$I zgl_config.cfg}
+interface
+
+uses
+  Math,
+  zgl_window,
+  zgl_types,
+  zgl_gltypeconst,
+  zgl_pasOpenGL,
+  zgl_file;
+
+// RU: матрица перспективы.
+// EN: perspective matrix.
+procedure Matrix4_Perspective(fovy, aspect, _near, _far: Single);
+// RU: ортографическая матрица.
+// EN: orthographic matrix.
+procedure Matrix4_Orthographic(Left, Right, Bottom, Top, _Near, _Far: Single);
+// RU: загрузка шейдера, компиляция и проверка на успех компиляции.
+// EN: loading the shader, compiling and checking for compilation success.
+function LoadAndCreateShader(name: string; shade: GLuint): Boolean;
+
+var
+  // RU: массив матрицы проекции.
+  // EN:
+  projMatr: array[0..15] of Single;
+
+implementation
+
+procedure Matrix4_Perspective(fovy, aspect, _near, _far: Single);
+var
+  f: Single;
+begin
+  f := 1 / tan(fovy * Pi / 180);
+  projMatr[0] := f / aspect;
+  projMatr[1] := 0;
+  projMatr[2] := 0;
+  projMatr[3] := 0;
+
+  projMatr[4] := 0;
+  projMatr[5] := f;
+  projMatr[6] := 0;
+  projMatr[7] := 0;
+
+  projMatr[8] := 0;
+  projMatr[9] := 0;
+  projMatr[10] := (_far + _near) / (_near - _far);
+  projMatr[11] := 2 * _far * _near / (_near - _far);
+
+  projMatr[12] := 0;
+  projMatr[13] := 0;
+  projMatr[14] := - 1;
+  projMatr[15] := 0;
+end;
+
+procedure Matrix4_Orthographic(Left, Right, Bottom, Top, _Near, _Far: Single);
+var
+  f: Single;
+begin
+  f := Right - Left;
+  projMatr[0] := 2 / f;
+  projMatr[1] := 0;
+  projMatr[2] := 0;
+  projMatr[3] := -(Right + Left) / f;
+
+  f := Top - Bottom;
+  projMatr[4] := 0;
+  projMatr[5] := 2 / f;
+  projMatr[6] := 0;
+  projMatr[7] := -(top + Bottom) / f;
+
+  f := _Far - _Near;
+  projMatr[8] := 0;
+  projMatr[9] := 0;
+  projMatr[10] := - 2 / f;
+  projMatr[11] := -(_Far + _Near) / f;
+
+  projMatr[12] := 0;
+  projMatr[13] := 0;
+  projMatr[14] := 0;
+  projMatr[15] := 1;
+end;
+
+function LoadAndCreateShader(name: string; shade: GLuint): Boolean;
+var
+  Ftext: zglTFile;
+  Fmem: zglTMemory;
+  status: GLint;
+begin
+  Result := False;
+  // RU: проверка существования загружаемого файла.
+  // EN: Checking the existence of the downloaded file.
+  if not file_Exists(name) then
+    Exit;
+  // RU: открываем файл.
+  // EN: open the file.
+  if file_Open(Ftext, name, FOM_OPENR)then
+  begin
+    Fmem.Size := file_GetSize(Ftext);
+    Fmem.Position := 0;
+    // RU: подготавливаем память для загрузки шейдера.
+    // EN: prepare memory for loading the shader.
+    zgl_GetMem(Fmem.Memory, Fmem.Size);
+    // RU: загружаем шейдер в память.
+    // EN: load the shader into memory.
+    file_Read(Ftext, Fmem.Memory^, Fmem.Size);
+    file_Close(Ftext);
+    // RU: исходный код шейдера и его компиляция. Обратите внимание, "Fmem.Memory"
+    //     это указатель на память, где находится строка. И мы передаём указатель
+    //     на данный участок памяти. Это работает правильно, потому что данные
+    //     должны идти под двойным указателем (PPGLchar).
+    // EN: shader source code and its compilation. Note that "Fmem.Memory" is a
+    //     pointer to the memory where the string is located. And we pass a
+    //     pointer to this memory location. This works correctly because the data
+    //     must go under a double pointer (PPGLchar).
+    glShaderSource(shade, 1, @Fmem.Memory, @Fmem.Size);
+    glCompileShader(shade);
+    // RU: освобождаем память, данный текст больше не нужен.
+    // EN: freeing up memory, this text is no longer needed.
+    zgl_FreeMem(Fmem.Memory);
+  end;
+
+  // RU: проверяем на успех компиляции шейдера.
+  // EN: check for success of shader compilation.
+  glGetShaderiv(shade, GL_COMPILE_STATUS, @status);
+  if status <> 1 then
+    Exit;
+  Result := True;
+end;
+
+end.
+

Zengl_SRC/srcGL/zgl_pasOpenGL.pas

@@ -1,5 +1,5 @@
 (*
- *  Copyright (c) 2022 Serge - SSW
+ *  Copyright (c) 2022-2023 Serge - SSW
  *
  *  This software is provided 'as-is', without any express or
  *  implied warranty. In no event will the authors be held
@@ -22,9 +22,16 @@
  *     source distribution.
  *)
 
+// Copyright 2013-2020 The Khronos Group Inc.
+// SPDX-License-Identifier: MIT
+//
+// This header is generated from the Khronos OpenGL / OpenGL ES XML
+// API Registry. The current version of the Registry, generator scripts
+// used to make the header, and the header can be found at
+//   https://github.com/KhronosGroup/OpenGL-Registry
+
 unit zgl_pasOpenGL;
 {$I zgl_config.cfg}
-{$I GLdefine.cfg}
 
 {$IfDef UNIX}
   {$DEFINE stdcall := cdecl}
@@ -4651,66 +4658,25 @@ procedure AllCheckGLExtension;
 //      максимально возможное. Если в файле конфигурации (GLdefine.cfg) задано
 //      использовать версию OpenGL 2.1 (USE_GL_21), а ваша видеокарта может
 //      работать с OpenGL версии 4.4, то вы будете работать с версией OpengL не
-//      выше 2.1.    !!! Обратите на это нвимание!!!
-// Eng:
+//      выше 2.1.    !!! Обратите на это внимание!!!
+// Eng: checking the version of OpenGL. Returns the actual value or the maximum
+//      possible value. If the configuration file (GLdefine.cfg) is set to use
+//      OpenGL version 2.1 (USE_GL_21) and your graphics card can run OpenGL
+//      version 4.4, then you will be running OpengL 2.1. Not higher!
+//      !!! Pay attention to this!!!
 procedure CheckGLVersion;
-// Rus: загрузка динамических функций.
-// Eng:
+// Rus: загрузка динамических функций OpenGL.
+// Eng: loading dynamic OpenGL functions.
 function LoadOpenGL: Boolean;
 
 implementation
 
 uses
   zgl_opengl,
-  zgl_opengl_all,
-  zgl_glu;
-
-(*{$IFDEF LINUX}
-
-function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external 'dl';
-function dlclose(Lib: Pointer): LongInt; cdecl; external 'dl';
-
-function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external 'dl';
-{$ENDIF}
-
-function glLoadLib(Name: PChar): Pointer;
-begin
-  {$IfDef WINDOWS}
-  Result := Pointer(LoadLibrary(Name));
-  {$EndIf}
-  {$IfDef LINUX}
-  Result := dlopen(Name, $001);
-  {$EndIf}
-end;
-
-function glFreeLib(Lib: Pointer): Boolean;
-begin
-  {$IfDef WINDOWS}
-  Result := FreeLibrary();
-  {$EndIf}
-  {$IfDef LINUX}
-  Result := dlclose(Lib) = 0;
-  {$EndIf}
-end; *)
-
-(* function gl_GetProcAddr(const procName: PAnsiChar): Pointer;  // в ZenGL это не нужно
-begin
-  {$IfDef WINDOWS}
-  if Assigned(wglGetProcAddress) then
-    Result := wglGetProcAddress(procName);
-  if Result = nil then
-    Result := GetProcAddress(HMODULE(gl_Library), procName);
-  {$EndIf}
-  {$IfDef LINUX}
-  if Assigned(glXGetProcAddress) then
-    Result := glXGetProcAddress(procName);
-  if Result = nil then
-    if Assigned(glXGetProcAddressARB) then
-      Result := glXGetProcAddressARB(procName);
-  if Result = nil then
-    Result := dlsym(gl_Library, procName);
-  {$EndIf}
-end; *)
+  zgl_opengl_all
+  {$IfDef USE_GLU}
+  , zgl_glu
+  {$EndIf};
 
 {$If defined(USE_GLCORE) or defined(USE_GLEXT)}
 procedure AllCheckGLExtension;
@@ -5729,6 +5695,8 @@ begin
   {$IfEnd}
 end;
 
+// Примечание: для Windows мы можем загружать библиотеку почти в любое время, для Linux
+//             мы должны это делать только после создания окна и контекста для окна.
 function LoadOpenGL: Boolean;
 {$IfDef LINUX}
 {$IfDef GL_VERSION_3_0}
@@ -5759,8 +5727,9 @@ begin
         oglExtensions := oglExtensions + PAnsiChar(glGetStringi(GL_EXTENSIONS, i)) + #32;
     end;
   end;
-  {$EndIf}
+
   if oglExtensions = '' then
+  {$EndIf}
     oglExtensions := glGetString(GL_EXTENSIONS);
   {$EndIf}
 

Zengl_SRC/tools/ZenFont(LCL)/ZenFont.lpi

@@ -51,8 +51,8 @@
       <Filename Value="ZenFont"/>
     </Target>
     <SearchPaths>
-      <IncludeFiles Value="$(ProjOutDir);../../src;../../headers;../../srcGL;../../srcGEGL"/>
-      <OtherUnitFiles Value="../../src;../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../lib/msvcrt/$(TargetCPU);../../lib/ogg/$(TargetCPU)-$(TargetOS);../../lib/theora/$(TargetCPU)-$(TargetOS);../../lib/zlib/$(TargetCPU)-$(TargetOS);../../lib/zip/$(TargetCPU)-$(TargetOS);../../srcGL;../../srcGEGL"/>
+      <IncludeFiles Value="$(ProjOutDir);../../src;../../srcGL;../../srcGL/EGL;../../srcGL/GLES;../../srcGEGL"/>
+      <OtherUnitFiles Value="../../src;../../lib/jpeg/$(TargetCPU)-$(TargetOS);../../lib/msvcrt/$(TargetCPU);../../lib/ogg/$(TargetCPU)-$(TargetOS);../../lib/theora/$(TargetCPU)-$(TargetOS);../../lib/zlib/$(TargetCPU)-$(TargetOS);../../lib/zip/$(TargetCPU)-$(TargetOS);../../srcGL;../../srcGL/EGL;../../srcGL/GLES;../../srcGEGL"/>
       <UnitOutputDirectory Value="tmp/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>
     <Parsing>
@@ -69,6 +69,7 @@
     <Linking>
       <Debugging>
         <GenerateDebugInfo Value="False"/>
+        <DebugInfoType Value="dsDwarf2"/>
         <StripSymbols Value="True"/>
       </Debugging>
       <LinkSmart Value="True"/>

Zengl_SRC/tools/ZenFont(LCL)/ZenFont.lps

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+  <ProjectSession>
+    <Version Value="12"/>
+    <Units Count="2">
+      <Unit0>
+        <Filename Value="ZenFont.lpr"/>
+        <IsPartOfProject Value="True"/>
+        <UsageCount Value="21"/>
+        <DefaultSyntaxHighlighter Value="Delphi"/>
+      </Unit0>
+      <Unit1>
+        <Filename Value="uMain.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="Form1"/>
+        <HasResources Value="True"/>
+        <ResourceBaseClass Value="Form"/>
+        <IsVisibleTab Value="True"/>
+        <CursorPos X="41" Y="18"/>
+        <UsageCount Value="21"/>
+        <Loaded Value="True"/>
+        <LoadedDesigner Value="True"/>
+        <DefaultSyntaxHighlighter Value="Delphi"/>
+      </Unit1>
+    </Units>
+    <RunParams>
+      <FormatVersion Value="2"/>
+      <Modes ActiveMode="default"/>
+    </RunParams>
+  </ProjectSession>
+</CONFIG>

Zengl_SRC/tools/ZenFont(LCL)/uMain.lfm

@@ -1,9 +1,10 @@
 object Form1: TForm1
   Left = 281
   Height = 600
-  Top = 42
+  Top = 416
   Width = 800
   ActiveControl = Panel1
+  BorderStyle = bsSingle
   Caption = 'ZenFont 0.2.6(LCL)'
   ClientHeight = 600
   ClientWidth = 800
@@ -13,7 +14,7 @@ object Form1: TForm1
   OnClose = FormClose
   OnResize = FormResize
   Position = poScreenCenter
-  LCLVersion = '2.2.0.4'
+  LCLVersion = '2.2.4.0'
   Visible = True
   object GroupBox1: TGroupBox
     Left = 0
@@ -22,14 +23,14 @@ object Form1: TForm1
     Width = 800
     Align = alBottom
     Caption = 'Parameters'
-    ClientHeight = 180
-    ClientWidth = 796
+    ClientHeight = 176
+    ClientWidth = 798
     TabOrder = 0
     object CheckBoxAntialiasing: TCheckBox
       Left = 10
-      Height = 19
+      Height = 27
       Top = 95
-      Width = 82
+      Width = 114
       Caption = 'Antialiasing'
       Checked = True
       OnChange = CheckBoxAntialiasingChange
@@ -38,9 +39,9 @@ object Form1: TForm1
     end
     object CheckBoxPack: TCheckBox
       Left = 10
-      Height = 19
+      Height = 27
       Top = 120
-      Width = 45
+      Width = 62
       Caption = 'Pack'
       Checked = True
       OnChange = CheckBoxPackChange
@@ -49,17 +50,18 @@ object Form1: TForm1
     end
     object LabelCurrentPage: TLabel
       Left = 10
-      Height = 15
+      Height = 23
       Top = 55
-      Width = 72
+      Width = 104
       Caption = 'Current Page:'
+      ParentColor = False
     end
     object ComboBoxPageSize: TComboBox
       Left = 90
-      Height = 23
+      Height = 35
       Top = 10
       Width = 70
-      ItemHeight = 15
+      ItemHeight = 0
       ItemIndex = 1
       Items.Strings = (
         '128'
@@ -75,10 +77,11 @@ object Form1: TForm1
     end
     object LabelPageSize: TLabel
       Left = 10
-      Height = 15
+      Height = 23
       Top = 15
-      Width = 52
+      Width = 76
       Caption = 'Page Size:'
+      ParentColor = False
     end
     object ButtonChooseFont: TButton
       Left = 10
@@ -90,7 +93,7 @@ object Form1: TForm1
       TabOrder = 3
     end
     object ButtonSaveFont: TButton
-      Left = 640
+      Left = 642
       Height = 25
       Top = 40
       Width = 150
@@ -100,7 +103,7 @@ object Form1: TForm1
       TabOrder = 5
     end
     object ButtonExit: TButton
-      Left = 640
+      Left = 642
       Height = 25
       Top = 150
       Width = 150
@@ -110,7 +113,7 @@ object Form1: TForm1
       TabOrder = 6
     end
     object ButtonRebuildFont: TButton
-      Left = 640
+      Left = 642
       Height = 25
       Top = 10
       Width = 150
@@ -123,44 +126,48 @@ object Form1: TForm1
       Left = 170
       Height = 70
       Top = 105
-      Width = 460
+      Width = 462
       Anchors = [akTop, akLeft, akRight]
       Caption = 'Char Padding'
-      ClientHeight = 50
-      ClientWidth = 456
+      ClientHeight = 46
+      ClientWidth = 460
       TabOrder = 7
       object Label1: TLabel
         Left = 120
-        Height = 15
+        Height = 23
         Top = 15
-        Width = 23
+        Width = 32
         Caption = 'Top:'
+        ParentColor = False
       end
       object Label2: TLabel
         Left = 10
-        Height = 15
+        Height = 23
         Top = 15
-        Width = 23
+        Width = 33
         Caption = 'Left:'
+        ParentColor = False
       end
       object Label3: TLabel
         Left = 220
-        Height = 15
+        Height = 23
         Top = 15
-        Width = 31
+        Width = 44
         Caption = 'Right:'
+        ParentColor = False
       end
       object Label4: TLabel
         Left = 340
-        Height = 15
+        Height = 23
         Top = 15
-        Width = 43
+        Width = 61
         Caption = 'Bottom:'
+        ParentColor = False
       end
       object SpinTop: TSpinEdit
         Left = 160
-        Height = 23
-        Top = 10
+        Height = 40
+        Top = 0
         Width = 50
         OnChange = SpinTopChange
         TabOrder = 1
@@ -168,8 +175,8 @@ object Form1: TForm1
       end
       object SpinLeft: TSpinEdit
         Left = 60
-        Height = 23
-        Top = 10
+        Height = 40
+        Top = 0
         Width = 50
         OnChange = SpinLeftChange
         TabOrder = 0
@@ -177,8 +184,8 @@ object Form1: TForm1
       end
       object SpinRight: TSpinEdit
         Left = 280
-        Height = 23
-        Top = 10
+        Height = 40
+        Top = 0
         Width = 50
         OnChange = SpinRightChange
         TabOrder = 2
@@ -186,8 +193,8 @@ object Form1: TForm1
       end
       object SpinBottom: TSpinEdit
         Left = 400
-        Height = 23
-        Top = 10
+        Height = 40
+        Top = 0
         Width = 50
         OnChange = SpinBottomChange
         TabOrder = 3
@@ -196,7 +203,7 @@ object Form1: TForm1
     end
     object SpinCurrentPage: TSpinEdit
       Left = 110
-      Height = 23
+      Height = 40
       Top = 50
       Width = 50
       Enabled = False
@@ -210,11 +217,11 @@ object Form1: TForm1
       Left = 295
       Height = 95
       Top = 0
-      Width = 335
+      Width = 337
       Anchors = [akTop, akLeft, akRight]
       Caption = 'Chars'
-      ClientHeight = 75
-      ClientWidth = 331
+      ClientHeight = 71
+      ClientWidth = 335
       TabOrder = 9
       object ButtonDefaultSymbols: TButton
         Left = 11
@@ -226,7 +233,7 @@ object Form1: TForm1
         TabOrder = 0
       end
       object ButtonImportSymbols: TButton
-        Left = 170
+        Left = 174
         Height = 25
         Top = 45
         Width = 150
@@ -236,10 +243,10 @@ object Form1: TForm1
         TabOrder = 1
       end
       object EditChars: TEdit
-        Left = 10
-        Height = 23
-        Top = 10
-        Width = 310
+        Left = 11
+        Height = 40
+        Top = 0
+        Width = 314
         Anchors = [akTop, akLeft, akRight]
         TabOrder = 2
       end
@@ -250,13 +257,13 @@ object Form1: TForm1
       Top = 0
       Width = 120
       Caption = 'Test String'
-      ClientHeight = 75
-      ClientWidth = 116
+      ClientHeight = 71
+      ClientWidth = 118
       TabOrder = 10
       object EditTest: TEdit
         Left = 10
-        Height = 23
-        Top = 10
+        Height = 40
+        Top = 0
         Width = 95
         TabOrder = 0
         Text = 'Test'

Zengl_SRC/tools/ZenFont(LCL)/uMain.pas

@@ -1,5 +1,14 @@
 unit uMain;
 
+// RU: обратите внимание!!!
+//     Проекты LCL имеют свои конфигурационные файлы "zgl_config.cfg". Лучше всего для каждого вашего проекта иметь свой
+//     конфигурационный файл, это может решить многие проблемы, если вдруг вы будете вносить изменения в конфигурацию проекта
+//     и, это отобразится на других ваших проектах использующих тот же конфигурационный файл.
+// EN: note!!!
+//     LCL projects have their own configuration files "zgl_config.cfg". It's best to have a separate config file for each of
+//     your projects, this can solve many problems if you suddenly make changes to the project config and it will show up on
+//     your other projects using the same config file.
+
 interface
 
 uses
@@ -378,14 +387,12 @@ begin
   Timer1.Enabled := False;
   SaveFontDialog.FileName := FontDialog.Font.Name + '-' + style + '-' + IntToStr( fg_FontSize ) + 'pt';
 
-//  if SaveFontDialog.Execute() Then
-//    begin
-      _name := file_GetName( SaveFontDialog.FileName );
-      dir  := file_GetDirectory( SaveFontDialog.FileName );
-      fontgen_SaveFont( fg_Font, _name );
+  _name := file_GetName( SaveFontDialog.FileName );
+  dir  := file_GetDirectory( SaveFontDialog.FileName );
+  fontgen_SaveFont( fg_Font, _name );
 
   ShowMessage(_name + ' save');
-//    end;
+
   Timer1.Enabled := True;
 end;
 

Zengl_SRC/tools/ZenFont(LCL)/zgl_config.cfg

@@ -0,0 +1,275 @@
+// Rus: мобильные платформы - Android, iOS, iPhone.
+// Eng: mobile platform - Android, iOS, iPhone.
+{$IF DEFINED(ANDROID) OR DEFINED(iOS) OR DEFINED(iPHONESIM)}
+  {$DEFINE MOBILE}
+{$IFEND}
+
+// так как мне надоело делать проверки, но я знаю что их надо делать, я добавляю дополнительную "отладочную"
+// информацию. Для себя я смогу это отключить, но это можно будет использовать для выявления каких-нибудь определённых багов.
+{$DEFINE FULL_LOGGING}
+
+// Rus: обработка старых процедур для клавиатуры. Если не хотим использовать GreenEngine.
+// Eng: processing of old procedures for the keyboard. If we do not want to use GreenEngine.
+{.$DEFINE KEYBOARD_OLD_FUNCTION}
+{$IFNDEF KEYBOARD_OLD_FUNCTION}
+  {$I gegl_config.cfg}
+{$ENDIF}
+
+// inializing in Handle (LCL, VCL)
+{$DEFINE USE_INIT_HANDLE}
+
+// Delphi 7 and down
+{$IFNDEF FPC}
+  {$IFDEF VER150}                    // Delphi 7
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER140}                    // Delphi 6
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER130}                    // Delphi 5
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER120}                    // Delphi 4
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER110}                    // C++ Builder 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER100}                    // Delphi 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+{$ENDIF}
+
+// Переделать!
+{$IF DEFINED(DARWIN) AND (NOT DEFINED(iOS) OR NOT DEFINED(iPHONESIM))}
+  {$IFNDEF CPUi386 }
+    {$DEFINE MAC_COCOA}
+  {$ENDIF}
+{$IFEND}
+
+{$IFDEF MAC_COCOA}
+  {$DEFINE NO_USE_STATIC_LIBRARY}
+{$ENDIF}
+
+// Use compile library (dll, so ...)
+{$DEFINE LIBRARY_COMPILE}
+
+{$IFDEF MOBILE}
+  {$UNDEF USE_INIT_HANDLE}
+{$ENDIF}
+
+// Rus: вы можете принудительно включить виртуальную клавиатуру везде, а так же виртуальные джойстики.
+// Eng: you can force enable virtual keyboard everywhere, as well as virtual joysticks.
+{.$DEFINE USE_VKEYBOARD}
+
+// Escape = exit
+{$DEFINE USE_EXIT_ESCAPE}
+
+//******************************************************************************
+//       Defines for GNU/Linux
+//******************************************************************************
+{$IFDEF LINUX}
+  // custom -----------------
+  {$DEFINE USE_OGG_STATIC}
+  {.$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_X11}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {.$DEFINE USE_FULL_GLX}
+
+  // OpenGL ES render for PC
+  {$DEFINE USE_GLES}
+  {.$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    // на данный момент ни где не используется. Но, надо знать, данное определение есть для стационарных компьютеров.
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ELSE}
+    {$DEFINE NO_EGL}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Android
+//******************************************************************************
+{$IFDEF ANDROID}
+// Rus: если вы будете использовать (ARM v5) или (ARM v6) отключите DEFINE CPUARMV7A.
+// Eng: if you will be using (ARM v5) or (ARM v6) disable DEFINE CPUARMV7A.
+  {$IFNDEF CPU64}
+    {$DEFINE CPUARMV7A}
+  {$ENDIF}
+  {$IF DEFINED(CPU64) OR DEFINED(CPUARMV7A) or DEFINED(CPUi386) or DEFINED(CPUx86_64)}
+    {$DEFINE NOT_OLD_ARM}   // старшие версии Anroid.
+  {$IFEND}
+  {$DEFINE ANDROID}
+  {$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$DEFINE USE_VORBIS}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$UNDEF  USE_X11}
+  {$UNDEF  USE_OGG_STATIC}
+  {$UNDEF  USE_THEORA_STATIC}
+  {$DEFINE USE_VKEYBOARD}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Windows and Windows Mobile
+//******************************************************************************
+{$IFDEF MSWINDOWS}
+  {$DEFINE WINDOWS}
+{$ENDIF}
+{$IFDEF WINDOWS}
+  // custom -----------------
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}               // disable if use DX Sound
+  {$DEFINE USE_OGG_STATIC}
+  {$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_VORBIS}
+  {.$DEFINE USE_FULL_WGL}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+// Defines for MacOS X and iOS
+//******************************************************************************
+// Переделать!
+{$IFDEF DARWIN}
+  // custom -----------------
+  {/$DEFINE USE_OGG_STATIC}
+  {/$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {$IF DEFINED(iPHONESIM) or (DEFINED(DARWIN) and DEFINED(CPUARM))}
+    {$DEFINE iOS}
+    {$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {.$UNDEF  USE_LIBJPEG}
+    {$DEFINE USE_OGG_STATIC}
+    {.$DEFINE USE_THEORA_STATIC}
+
+    {$UNDEF USE_INIT_HANDLE}
+
+    {$IFNDEF iPHONESIM}
+      // custom -----------
+      // If you don't need to decode theora, you can uncomment this DEFINE
+      // ------------------
+    {$ENDIF}
+  {$ELSE}
+    {$DEFINE MACOSX}
+    // OpenGL ES render for PC
+    {.$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {$IFDEF USE_GLES}
+      {.$DEFINE USE_GLES_ON_DESKTOP}
+    {$ENDIF}
+  {$IFEND}
+{$ENDIF}
+//******************************************************************************
+
+// Rus: окна созданные посредством LCL будут работать только с полным OpenGL. Если вам нужно будет решение для OpenGL ES, просьба оповестить меня об этом,
+//      пока отложу данное решение на потом, на очень далёкое "потом".
+// Eng: windows created with LCL will only work with full OpenGL. If you need a solution for OpenGL ES, please let me know while I put this solution aside
+//      for a very long time later.
+{$IFDEF USE_INIT_HANDLE}
+  {$UNDEF USE_GLES}
+  {$DEFINE NO_EGL}
+{$ENDIF}
+
+// Rus: используем разные конфигурационные файлы для OpenGL и для OpenGL ES.
+// Eng: we use different configuration files for OpenGL and for OpenGL ES.
+{$IFNDEF USE_GLES}
+  {$I GLdefine.cfg}
+{$ELSE}
+  {$I gles_conf.cfg}
+{$ENDIF}
+
+// Functionality
+{$DEFINE USE_LOG_FLUSH}
+{$DEFINE USE_ZIP}
+{$DEFINE USE_JOYSTICK}
+{$DEFINE USE_JPG}
+{$DEFINE USE_PNG}
+{$DEFINE USE_PVR}
+{$DEFINE USE_TGA}
+{$DEFINE USE_SENGINE}
+{$DEFINE USE_PARTICLES}
+{$DEFINE USE_SOUND}
+{$IFDEF USE_SOUND}
+  {$DEFINE USE_OGG}
+  {$DEFINE USE_WAV}
+{$ENDIF}
+{$DEFINE USE_VIDEO}
+{$IFDEF USE_VIDEO}
+  {$DEFINE USE_THEORA}
+{$ENDIF}
+
+// Rus: включите/выключите нужные определения для ваших видеокарт. Это будет влиять на OpenGL, GLES, EGL.
+//      Как я понимаю, корпорации предоставляют разные реализации одних и тех же функций, по разному оптимизированными
+//      для определённых видеокарт. И, таким образом, мы можем создать сильно оптимизированныую программу, которая будет
+//      "сама выбирать" какую функцию использовать для данной видеокарты.
+//      Но, это сложно...
+// Eng: enable/disable the necessary definitions for your graphics cards. This will affect OpenGL, GLES, EGL.
+//      As I understand it, corporations provide different implementations of the same functions, optimized differently
+//      for certain video cards. And thus, we can create a highly optimized program that will "select" which function
+//      to use for a given video card.
+//      But it is difficult...
+{$DEFINE VID_NV}
+{$DEFINE VID_AMD}
+{$DEFINE VID_INTEL}
+{$DEFINE VID_APPLE}
+
+// Enable if you want to use zlib compression functions
+// WARNING: ZenGL doesn't provide all needed object files, you should use yours(just have no desire to recompile zlib for every platform)
+
+// Disable unsupported features
+{$IFNDEF FPC}
+  {$UNDEF USE_OGG_STATIC}
+  {$UNDEF USE_THEORA_STATIC}
+{$ENDIF}
+
+// Specially for buggy Delphi, which trying to parse everything...
+{$MINENUMSIZE 4}
+{$DEFINE USE_INLINE}
+{$IFDEF FPC}
+  {$I zgl_fpc.cfg}
+
+  {$IFNDEF MACOSX}
+    {$IFDEF cpui386}
+      {$DEFINE USE_ASM}
+    {$ENDIF}
+  {$ENDIF}
+{$ELSE}
+  {$DEFINE USE_ASM}
+  {$WARN COMBINING_SIGNED_UNSIGNED OFF}
+  {$WARN COMPARING_SIGNED_UNSIGNED OFF}
+  {$IFNDEF DELPHI7_AND_DOWN}
+    {$DEFINE CPUx86_64}
+  {$ELSE}
+    {$DEFINE CPUi386}
+    {$UNDEF USE_INLINE}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFNDEF USE_INIT_HANDLE}
+  {$DEFINE WND_USE}
+{$ELSE}
+  {$IFDEF WINDOWS}
+    {$DEFINE WND_USE}
+  {$ENDIF}
+{$ENDIF}

Zengl_SRC/tools/ZenFont(VCL delphi7)/uMain.pas

@@ -1,5 +1,14 @@
 unit uMain;
 
+// RU: îáðàòèòå âíèìàíèå!!!
+//     Ïðîåêòû LCL èìåþò ñâîè êîíôèãóðàöèîííûå ôàéëû "zgl_config.cfg". Ëó÷øå âñåãî äëÿ êàæäîãî âàøåãî ïðîåêòà èìåòü ñâîé
+//     êîíôèãóðàöèîííûé ôàéë, ýòî ìîæåò ðåøèòü ìíîãèå ïðîáëåìû, åñëè âäðóã âû áóäåòå âíîñèòü èçìåíåíèÿ â êîíôèãóðàöèþ ïðîåêòà
+//     è, ýòî îòîáðàçèòñÿ íà äðóãèõ âàøèõ ïðîåêòàõ èñïîëüçóþùèõ òîò æå êîíôèãóðàöèîííûé ôàéë.
+// EN: note!!!
+//     LCL projects have their own configuration files "zgl_config.cfg". It's best to have a separate config file for each of
+//     your projects, this can solve many problems if you suddenly make changes to the project config and it will show up on
+//     your other projects using the same config file.
+
 interface
 
 uses
@@ -67,8 +76,7 @@ type
     procedure FormResize(Sender: TObject);
     procedure Panel1MouseDown(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; X, Y: Integer);
-    procedure Panel1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer
-     );
+    procedure Panel1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
     procedure Panel1MouseUp(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; X, Y: Integer);
     procedure SpinLeftChange(Sender: TObject);
@@ -159,7 +167,7 @@ begin
   len := length(EditChars.Text);
   while i <= len do
   begin
-    c := utf8_toUnicode(EditChars.Text, i, @j);
+    c := utf8_GetID(EditChars.Text, i, @j);
     if not fg_CharsUse[c] Then
     begin
       fg_CharsUse[c] := TRUE;
@@ -364,12 +372,10 @@ begin
   Timer1.Enabled := False;
   SaveFontDialog.FileName := FontDialog.Font.Name + '-' + style + '-' + IntToStr(fg_FontSize) + 'pt';
 
-//  if SaveFontDialog.Execute() Then
-//  begin
-    name := file_GetName(SaveFontDialog.FileName);
-    dir  := file_GetDirectory(SaveFontDialog.FileName);
-    fontgen_SaveFont(fg_Font, name);
-//  end;
+  name := file_GetName(SaveFontDialog.FileName);
+  dir  := file_GetDirectory(SaveFontDialog.FileName);
+  fontgen_SaveFont(fg_Font, name);
+
   ShowMessage(name + ' save');
   Timer1.Enabled := True;
 end;
@@ -401,7 +407,7 @@ end;
 procedure TForm1.FormActivate(Sender: TObject);
 begin
   if not zgl_Inited then
-  begin
+  begin
     zgl_Inited := True;
     zgl_Disable(APP_USE_LOG);
 
@@ -414,15 +420,15 @@ begin
 end;
 
 procedure TForm1.SpinCurrentPageChange(Sender: TObject);
-begin
-  if SpinCurrentPage.Value < 1 then
-    SpinCurrentPage.Value := 1;
-end;
-
+begin
+  if SpinCurrentPage.Value < 1 then
+    SpinCurrentPage.Value := 1;
+end;
+
 procedure TForm1.Timer1Timer(Sender: TObject);
-begin
-  app_PLoop;
-end;
-
+begin
+  app_PLoop;
+end;
+
 end.
 

Zengl_SRC/tools/ZenFont(VCL delphi7)/zgl_config.cfg

@@ -0,0 +1,272 @@
+// Rus: мобильные платформы - Android, iOS, iPhone.
+// Eng: mobile platform - Android, iOS, iPhone.
+{$IF DEFINED(ANDROID) OR DEFINED(iOS) OR DEFINED(iPHONESIM)}
+  {$DEFINE MOBILE}
+{$IFEND}
+
+// так как мне надоело делать проверки, но я знаю что их надо делать, я добавляю дополнительную "отладочную"
+// информацию. Для себя я смогу это отключить, но это можно будет использовать для выявления каких-нибудь определённых багов.
+{$DEFINE FULL_LOGGING}
+
+// Rus: обработка старых процедур для клавиатуры. Если не хотим использовать GreenEngine.
+// Eng: processing of old procedures for the keyboard. If we do not want to use GreenEngine.
+{.$DEFINE KEYBOARD_OLD_FUNCTION}
+{$IFNDEF KEYBOARD_OLD_FUNCTION}
+  {$I gegl_config.cfg}
+{$ENDIF}
+
+// inializing in Handle (LCL, VCL)
+{$DEFINE USE_INIT_HANDLE}
+
+// Delphi 7 and down
+{$IFNDEF FPC}
+  {$IFDEF VER150}                    // Delphi 7
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER140}                    // Delphi 6
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER130}                    // Delphi 5
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER120}                    // Delphi 4
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER110}                    // C++ Builder 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+  {$IFDEF VER100}                    // Delphi 3
+    {$DEFINE DELPHI7_AND_DOWN}
+  {$ENDIF}
+{$ENDIF}
+
+// Переделать!
+{$IF DEFINED(DARWIN) AND (NOT DEFINED(iOS) OR NOT DEFINED(iPHONESIM))}
+  {$IFNDEF CPUi386 }
+    {$DEFINE MAC_COCOA}
+  {$ENDIF}
+{$IFEND}
+
+{$IFDEF MAC_COCOA}
+  {$DEFINE NO_USE_STATIC_LIBRARY}
+{$ENDIF}
+
+// Use compile library (dll, so ...)
+{$DEFINE LIBRARY_COMPILE}
+
+{$IFDEF MOBILE}
+  {$UNDEF USE_INIT_HANDLE}
+{$ENDIF}
+
+// Rus: вы можете принудительно включить виртуальную клавиатуру везде, а так же виртуальные джойстики.
+// Eng: you can force enable virtual keyboard everywhere, as well as virtual joysticks.
+{.$DEFINE USE_VKEYBOARD}
+
+// Escape = exit
+{$DEFINE USE_EXIT_ESCAPE}
+
+//******************************************************************************
+//       Defines for GNU/Linux
+//******************************************************************************
+{$IFDEF LINUX}
+  // custom -----------------
+  {$DEFINE USE_OGG_STATIC}
+  {.$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_X11}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {.$DEFINE USE_FULL_GLX}
+
+  // OpenGL ES render for PC
+  {$DEFINE USE_GLES}
+  {.$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    // на данный момент ни где не используется. Но, надо знать, данное определение есть для стационарных компьютеров.
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Android
+//******************************************************************************
+{$IFDEF ANDROID}
+// Rus: если вы будете использовать (ARM v5) или (ARM v6) отключите DEFINE CPUARMV7A.
+// Eng: if you will be using (ARM v5) or (ARM v6) disable DEFINE CPUARMV7A.
+  {$IFNDEF CPU64}
+    {$DEFINE CPUARMV7A}
+  {$ENDIF}
+  {$IF DEFINED(CPU64) OR DEFINED(CPUARMV7A) or DEFINED(CPUi386) or DEFINED(CPUx86_64)}
+    {$DEFINE NOT_OLD_ARM}   // старшие версии Anroid.
+  {$IFEND}
+  {$DEFINE ANDROID}
+  {$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$DEFINE USE_VORBIS}
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$UNDEF  USE_X11}
+  {$UNDEF  USE_OGG_STATIC}
+  {$UNDEF  USE_THEORA_STATIC}
+  {$DEFINE USE_VKEYBOARD}
+{$ENDIF}
+
+//******************************************************************************
+//       Defines for Windows and Windows Mobile
+//******************************************************************************
+{$IFDEF MSWINDOWS}
+  {$DEFINE WINDOWS}
+{$ENDIF}
+{$IFDEF WINDOWS}
+  // custom -----------------
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}               // disable if use DX Sound
+  {$DEFINE USE_OGG_STATIC}
+  {$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_VORBIS}
+  {.$DEFINE USE_FULL_WGL}
+
+  // OpenGL ES render for PC
+  {.$DEFINE USE_GLES}
+  {$DEFINE NO_EGL}
+  {$IFDEF USE_GLES}
+    {$DEFINE USE_GLES_ON_DESKTOP}
+  {$ENDIF}
+{$ENDIF}
+
+//******************************************************************************
+// Defines for MacOS X and iOS
+//******************************************************************************
+// Переделать!
+{$IFDEF DARWIN}
+  // custom -----------------
+  {/$DEFINE USE_OGG_STATIC}
+  {/$DEFINE USE_THEORA_STATIC}
+  // ------------------------
+
+  {$DEFINE USE_LIBJPEG}
+  {$DEFINE USE_OPENAL}
+  {$DEFINE USE_VORBIS}
+
+  {$IF DEFINED(iPHONESIM) or (DEFINED(DARWIN) and DEFINED(CPUARM))}
+    {$DEFINE iOS}
+    {$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {.$UNDEF  USE_LIBJPEG}
+    {$DEFINE USE_OGG_STATIC}
+    {.$DEFINE USE_THEORA_STATIC}
+
+    {$UNDEF USE_INIT_HANDLE}
+
+    {$IFNDEF iPHONESIM}
+      // custom -----------
+      // If you don't need to decode theora, you can uncomment this DEFINE
+      // ------------------
+    {$ENDIF}
+  {$ELSE}
+    {$DEFINE MACOSX}
+    // OpenGL ES render for PC
+    {.$DEFINE USE_GLES}
+    {$DEFINE NO_EGL}
+    {$IFDEF USE_GLES}
+      {.$DEFINE USE_GLES_ON_DESKTOP}
+    {$ENDIF}
+  {$IFEND}
+{$ENDIF}
+//******************************************************************************
+
+// Rus: окна созданные посредством LCL будут работать только с полным OpenGL. Если вам нужно будет решение для OpenGL ES, просьба оповестить меня об этом,
+//      пока отложу данное решение на потом, на очень далёкое "потом".
+// Eng: windows created with LCL will only work with full OpenGL. If you need a solution for OpenGL ES, please let me know while I put this solution aside
+//      for a very long time later.
+{$IFDEF USE_INIT_HANDLE}
+  {$UNDEF USE_GLES}
+{$ENDIF}
+
+// Rus: используем разные конфигурационные файлы для OpenGL и для OpenGL ES.
+// Eng: we use different configuration files for OpenGL and for OpenGL ES.
+{$IFNDEF USE_GLES}
+  {$I GLdefine.cfg}
+{$ELSE}
+  {$I gles_conf.cfg}
+{$ENDIF}
+
+// Functionality
+{$DEFINE USE_LOG_FLUSH}
+{$DEFINE USE_ZIP}
+{$DEFINE USE_JOYSTICK}
+{$DEFINE USE_JPG}
+{$DEFINE USE_PNG}
+{$DEFINE USE_PVR}
+{$DEFINE USE_TGA}
+{$DEFINE USE_SENGINE}
+{$DEFINE USE_PARTICLES}
+{$DEFINE USE_SOUND}
+{$IFDEF USE_SOUND}
+  {$DEFINE USE_OGG}
+  {$DEFINE USE_WAV}
+{$ENDIF}
+{$DEFINE USE_VIDEO}
+{$IFDEF USE_VIDEO}
+  {$DEFINE USE_THEORA}
+{$ENDIF}
+
+// Rus: включите/выключите нужные определения для ваших видеокарт. Это будет влиять на OpenGL, GLES, EGL.
+//      Как я понимаю, корпорации предоставляют разные реализации одних и тех же функций, по разному оптимизированными
+//      для определённых видеокарт. И, таким образом, мы можем создать сильно оптимизированныую программу, которая будет
+//      "сама выбирать" какую функцию использовать для данной видеокарты.
+//      Но, это сложно...
+// Eng: enable/disable the necessary definitions for your graphics cards. This will affect OpenGL, GLES, EGL.
+//      As I understand it, corporations provide different implementations of the same functions, optimized differently
+//      for certain video cards. And thus, we can create a highly optimized program that will "select" which function
+//      to use for a given video card.
+//      But it is difficult...
+{$DEFINE VID_NV}
+{$DEFINE VID_AMD}
+{$DEFINE VID_INTEL}
+{$DEFINE VID_APPLE}
+
+// Enable if you want to use zlib compression functions
+// WARNING: ZenGL doesn't provide all needed object files, you should use yours(just have no desire to recompile zlib for every platform)
+
+// Disable unsupported features
+{$IFNDEF FPC}
+  {$UNDEF USE_OGG_STATIC}
+  {$UNDEF USE_THEORA_STATIC}
+{$ENDIF}
+
+// Specially for buggy Delphi, which trying to parse everything...
+{$MINENUMSIZE 4}
+{$DEFINE USE_INLINE}
+{$IFDEF FPC}
+  {$I zgl_fpc.cfg}
+
+  {$IFNDEF MACOSX}
+    {$IFDEF cpui386}
+      {$DEFINE USE_ASM}
+    {$ENDIF}
+  {$ENDIF}
+{$ELSE}
+  {$DEFINE USE_ASM}
+  {$WARN COMBINING_SIGNED_UNSIGNED OFF}
+  {$WARN COMPARING_SIGNED_UNSIGNED OFF}
+  {$IFNDEF DELPHI7_AND_DOWN}
+    {$DEFINE CPUx86_64}
+  {$ELSE}
+    {$DEFINE CPUi386}
+    {$UNDEF USE_INLINE}
+  {$ENDIF}
+{$ENDIF}
+
+{$IFNDEF USE_INIT_HANDLE}
+  {$DEFINE WND_USE}
+{$ELSE}
+  {$IFDEF WINDOWS}
+    {$DEFINE WND_USE}
+  {$ENDIF}
+{$ENDIF}