Date: Sun, 21 Dec 2014 18:58:52 +0000 (+0100) Subject: * added documentation (in-code and pasdoc generated) X-Git-Url: https://git.delphigl.com/?a=commitdiff_plain;h=1f9d3b8b9ce7d5e05f7af88c7ab0fd094609d9e5;p=LazOpenGLCore.git * added documentation (in-code and pasdoc generated) * added some small examples --- diff --git a/doc/AllClasses.html b/doc/AllClasses.html new file mode 100644 index 0000000..15013b0 --- /dev/null +++ b/doc/AllClasses.html @@ -0,0 +1,107 @@ + + + +All Classes, Interfaces, Objects and Records + + + + + +

All Classes, Interfaces, Objects and Records

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Unit	Description
EglBitmap	glBitmap	glBitmap exception
EglBitmapNonPowerOfTwo	glBitmap	exception for non power of two textures
EglBitmapNotSupported	glBitmap	exception for not supported functions
EglBitmapSizeToLarge	glBitmap	exception for to large textures
EglBitmapUnsupportedFormat	glBitmap	exception for unsupporetd formats
TglBitmap	glBitmap	base class for all glBitmap classes. used to manage OpenGL texture objects and to load, save and manipulate texture data
TglBitmap1D	glBitmap	wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D
TglBitmap2D	glBitmap	wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D)
TglBitmapCubeMap	glBitmap	wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP)
TglBitmapFormatDescriptor	glBitmap	describes the properties of a given texture data format
TglBitmapFunctionRec	glBitmap	structure to store data for converting in
TglBitmapNormalMap	glBitmap	wrapper class for cube normal maps
TglBitmapPixelData	glBitmap	structure to store pixel data in
TglBitmapRec4ub	glBitmap	record that stores 4 unsigned byte values
TglBitmapRec4ui	glBitmap	record that stores 4 unsigned integer values
TglBitmapRec4ul	glBitmap	record that stores 4 unsigned long integer values
TglBitmapSize	glBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllConstants.html b/doc/AllConstants.html new file mode 100644 index 0000000..c24a437 --- /dev/null +++ b/doc/AllConstants.html @@ -0,0 +1,27 @@ + + + +All Constants + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Constants

+ + + + + + + + + + + +

Name	Unit	Description
NULL_SIZE	glBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllFunctions.html b/doc/AllFunctions.html new file mode 100644 index 0000000..a2448be --- /dev/null +++ b/doc/AllFunctions.html @@ -0,0 +1,132 @@ + + + +All Functions and Procedures + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Functions and Procedures

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Unit	Description
glBitmapCreateTestTexture	glBitmap
glBitmapGetDefaultDeleteTextureOnFree	glBitmap
glBitmapGetDefaultFilter	glBitmap
glBitmapGetDefaultFormat	glBitmap
glBitmapGetDefaultFreeDataAfterGenTexture	glBitmap
glBitmapGetDefaultMipmap	glBitmap
glBitmapGetDefaultSwizzle	glBitmap
glBitmapGetDefaultTextureWrap	glBitmap
glBitmapPosition	glBitmap
glBitmapRec4ub	glBitmap
glBitmapRec4ubCompare	glBitmap
glBitmapRec4ui	glBitmap
glBitmapRec4uiCompare	glBitmap
glBitmapRec4ul	glBitmap
glBitmapSetDefaultDeleteTextureOnFree	glBitmap
glBitmapSetDefaultFilter	glBitmap
glBitmapSetDefaultFormat	glBitmap
glBitmapSetDefaultFreeDataAfterGenTexture	glBitmap
glBitmapSetDefaultMipmap	glBitmap
glBitmapSetDefaultSwizzle	glBitmap
glBitmapSetDefaultWrap	glBitmap
glBitmapSize	glBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllIdentifiers.html b/doc/AllIdentifiers.html new file mode 100644 index 0000000..a60ffbe --- /dev/null +++ b/doc/AllIdentifiers.html @@ -0,0 +1,267 @@ + + + +All Identifiers + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Identifiers

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Unit	Description
EglBitmap	glBitmap	glBitmap exception
EglBitmapNonPowerOfTwo	glBitmap	exception for non power of two textures
EglBitmapNotSupported	glBitmap	exception for not supported functions
EglBitmapSizeToLarge	glBitmap	exception for to large textures
EglBitmapUnsupportedFormat	glBitmap	exception for unsupporetd formats
glBitmapCreateTestTexture	glBitmap
glBitmapGetDefaultDeleteTextureOnFree	glBitmap
glBitmapGetDefaultFilter	glBitmap
glBitmapGetDefaultFormat	glBitmap
glBitmapGetDefaultFreeDataAfterGenTexture	glBitmap
glBitmapGetDefaultMipmap	glBitmap
glBitmapGetDefaultSwizzle	glBitmap
glBitmapGetDefaultTextureWrap	glBitmap
glBitmapPosition	glBitmap
glBitmapRec4ub	glBitmap
glBitmapRec4ubCompare	glBitmap
glBitmapRec4ui	glBitmap
glBitmapRec4uiCompare	glBitmap
glBitmapRec4ul	glBitmap
glBitmapSetDefaultDeleteTextureOnFree	glBitmap
glBitmapSetDefaultFilter	glBitmap
glBitmapSetDefaultFormat	glBitmap
glBitmapSetDefaultFreeDataAfterGenTexture	glBitmap
glBitmapSetDefaultMipmap	glBitmap
glBitmapSetDefaultSwizzle	glBitmap
glBitmapSetDefaultWrap	glBitmap
glBitmapSize	glBitmap
NULL_SIZE	glBitmap
PglBitmapPixelData	glBitmap
TglBitmap	glBitmap	base class for all glBitmap classes. used to manage OpenGL texture objects and to load, save and manipulate texture data
TglBitmap1D	glBitmap	wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D
TglBitmap2D	glBitmap	wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D)
TglBitmapCubeMap	glBitmap	wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP)
TglBitmapFileType	glBitmap	Portable Network Graphic file (PNG)
TglBitmapFileTypes	glBitmap
TglBitmapFormat	glBitmap	type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types
TglBitmapFormatDescriptor	glBitmap	describes the properties of a given texture data format
TglBitmapFunction	glBitmap	callback to use for converting texture data
TglBitmapFunctionRec	glBitmap	structure to store data for converting in
TglBitmapMipMap	glBitmap	possible mipmap types
TglBitmapNormalMap	glBitmap	wrapper class for cube normal maps
TglBitmapNormalMapFunc	glBitmap	possible normal map functions
TglBitmapPixelData	glBitmap	structure to store pixel data in
TglBitmapPixelPosition	glBitmap
TglBitmapRec4ub	glBitmap	record that stores 4 unsigned byte values
TglBitmapRec4ui	glBitmap	record that stores 4 unsigned integer values
TglBitmapRec4ul	glBitmap	record that stores 4 unsigned long integer values
TglBitmapSize	glBitmap
TglBitmapSizeFields	glBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllTypes.html b/doc/AllTypes.html new file mode 100644 index 0000000..1bd8543 --- /dev/null +++ b/doc/AllTypes.html @@ -0,0 +1,67 @@ + + + +All Types + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Types

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Unit	Description
PglBitmapPixelData	glBitmap
TglBitmapFileType	glBitmap	Portable Network Graphic file (PNG)
TglBitmapFileTypes	glBitmap
TglBitmapFormat	glBitmap	type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types
TglBitmapFunction	glBitmap	callback to use for converting texture data
TglBitmapMipMap	glBitmap	possible mipmap types
TglBitmapNormalMapFunc	glBitmap	possible normal map functions
TglBitmapPixelPosition	glBitmap
TglBitmapSizeFields	glBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllUnits.html b/doc/AllUnits.html new file mode 100644 index 0000000..d165995 --- /dev/null +++ b/doc/AllUnits.html @@ -0,0 +1,31 @@ + + + +All Units + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Units

+ + + + + + + + + +

Name Description

glBitmap

glBitmap by Steffen Xonna aka Lossy eX (2003-2008) http://www.opengl24.de/index.php?cat=header&file=glbitmap + +

modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + +

The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/MPL-1.1.html + +

The glBitmap is a Delphi/FPC unit that contains several wrapper classes to manage OpenGL texture objects. Below you can find a list of the main functionality of this classes: - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) - upload texture data to video card - download texture data from video card - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/AllVariables.html b/doc/AllVariables.html new file mode 100644 index 0000000..e8f9961 --- /dev/null +++ b/doc/AllVariables.html @@ -0,0 +1,17 @@ + + + +All Variables + + + + + +

All Variables

+The units do not contain any variables.

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/ClassHierarchy.html b/doc/ClassHierarchy.html new file mode 100644 index 0000000..68a0311 --- /dev/null +++ b/doc/ClassHierarchy.html @@ -0,0 +1,35 @@ + + + +Class Hierarchy + + + + + +

Class Hierarchy

TObject
- Exception
  - EglBitmap
    +
  - EglBitmapNotSupported
  +
- TglBitmap
  - TglBitmap1D
  - TglBitmap2D
    - TglBitmapCubeMap
      - TglBitmapNormalMap
      +
    +
  +
- TglBitmapFormatDescriptor
+

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/PasDocSettings.pds b/doc/PasDocSettings.pds new file mode 100644 index 0000000..6d28be1 --- /dev/null +++ b/doc/PasDocSettings.pds @@ -0,0 +1,71 @@ +[Main] +StoreRelativePaths=1 +Language=en +OutputDir=..\doc +GenerateFormat=0 +ProjectName= +Verbosity=2 +ClassMembers_0=1 +ClassMembers_1=1 +ClassMembers_2=1 +ClassMembers_3=1 +ClassMembers_4=1 +ClassMembers_5=1 +ClassMembers_6=1 +ClassMembers_7=1 +ImplicitVisibility=0 +Sorting_0=0 +Sorting_1=0 +Sorting_2=0 +Sorting_3=0 +Sorting_4=0 +Sorting_5=0 +Sorting_6=0 +Sorting_7=0 +Sorting_8=0 +Sorting_9=0 +CssFileName= +IntroductionFileName= +ConclusionFileName= +WriteUsesList=0 +AutoAbstract=0 +AutoLink=0 +HandleMacros=1 +UseTipueSearch=0 +LineBreakQuality=0 +SpecialMarkerTreatment=1 +Title= +VizGraphClasses=0 +VizGraphUses=0 +CheckSpelling=0 +LatexGraphicsPackage=0 + +[Defines] +Count=4 +Item_0=FPC +Item_1=MSWINDOWS +Item_2=WIN32 +Item_3=CPU386 + +[Header] +Count=0 + +[Footer] +Count=0 + +[IncludeDirectories] +Count=1 +Item_0=..\..\glBitmap + +[Files] +Count=1 +Item_0=..\glBitmap.pas + +[HyphenatedWords] +Count=0 + +[SpecialMarkers] +Count=0 + +[IgnoreWords] +Count=0 diff --git a/doc/automated.gif b/doc/automated.gif new file mode 100644 index 0000000..7c271d8 Binary files /dev/null and b/doc/automated.gif differ diff --git a/doc/glBitmap.EglBitmap.html b/doc/glBitmap.EglBitmap.html new file mode 100644 index 0000000..15d12eb --- /dev/null +++ b/doc/glBitmap.EglBitmap.html @@ -0,0 +1,29 @@ + + + +glBitmap: Class EglBitmap + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class EglBitmap

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type EglBitmap = class(Exception)

Description

+glBitmap exception

Hierarchy

Exception
EglBitmap

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.EglBitmapNonPowerOfTwo.html b/doc/glBitmap.EglBitmapNonPowerOfTwo.html new file mode 100644 index 0000000..339a4bb --- /dev/null +++ b/doc/glBitmap.EglBitmapNonPowerOfTwo.html @@ -0,0 +1,30 @@ + + + +glBitmap: Class EglBitmapNonPowerOfTwo + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class EglBitmapNonPowerOfTwo

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type EglBitmapNonPowerOfTwo = class(EglBitmap)

Description

+exception for non power of two textures

Hierarchy

Exception
EglBitmap
EglBitmapNonPowerOfTwo

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.EglBitmapNotSupported.html b/doc/glBitmap.EglBitmapNotSupported.html new file mode 100644 index 0000000..fc8e97c --- /dev/null +++ b/doc/glBitmap.EglBitmapNotSupported.html @@ -0,0 +1,29 @@ + + + +glBitmap: Class EglBitmapNotSupported + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class EglBitmapNotSupported

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type EglBitmapNotSupported = class(Exception)

Description

+exception for not supported functions

Hierarchy

Exception
EglBitmapNotSupported

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.EglBitmapSizeToLarge.html b/doc/glBitmap.EglBitmapSizeToLarge.html new file mode 100644 index 0000000..f3bd141 --- /dev/null +++ b/doc/glBitmap.EglBitmapSizeToLarge.html @@ -0,0 +1,30 @@ + + + +glBitmap: Class EglBitmapSizeToLarge + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class EglBitmapSizeToLarge

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type EglBitmapSizeToLarge = class(EglBitmap)

Description

+exception for to large textures

Hierarchy

Exception
EglBitmap
EglBitmapSizeToLarge

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.EglBitmapUnsupportedFormat.html b/doc/glBitmap.EglBitmapUnsupportedFormat.html new file mode 100644 index 0000000..fe2bf30 --- /dev/null +++ b/doc/glBitmap.EglBitmapUnsupportedFormat.html @@ -0,0 +1,60 @@ + + + +glBitmap: Class EglBitmapUnsupportedFormat + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class EglBitmapUnsupportedFormat

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type EglBitmapUnsupportedFormat = class(EglBitmap)

Description

+exception for unsupporetd formats

Hierarchy

Exception
EglBitmap
EglBitmapUnsupportedFormat

Overview

Methods

+ + + + + + + + + +

	`constructor Create(const aFormat: TglBitmapFormat); overload;`
	`constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;`

Description

Methods

+ + + + + + +

	`constructor Create(const aFormat: TglBitmapFormat); overload;`
+

+ + + + + + +

	`constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;`
+

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmap.html b/doc/glBitmap.TglBitmap.html new file mode 100644 index 0000000..7f53bf5 --- /dev/null +++ b/doc/glBitmap.TglBitmap.html @@ -0,0 +1,2061 @@ + + + +glBitmap: Class TglBitmap + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmap

+ + +

Unit

+glBitmap

Declaration

+type TglBitmap = class(TObject)

Description

+base class for all glBitmap classes. used to manage OpenGL texture objects and to load, save and manipulate texture data

Hierarchy

TObject
TglBitmap

Overview

Fields

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`fID: GLuint;`
	`fTarget: GLuint;`
	`fAnisotropic: Integer;`
	`fDeleteTextureOnFree: Boolean;`
	`fFreeDataOnDestroy: Boolean;`
	`fFreeDataAfterGenTexture: Boolean;`
	`fData: PByte;`
	`fBorderColor: array[0..3] of Single;`
	`fDimension: TglBitmapSize;`
	`fMipMap: TglBitmapMipMap;`
	`fFormat: TglBitmapFormat;`
	`fPixelSize: Integer;`
	`fRowSize: Integer;`
	`fFilterMin: GLenum;`
	`fFilterMag: GLenum;`
	`fWrapS: GLenum;`
	`fWrapT: GLenum;`
	`fWrapR: GLenum;`
	`fSwizzle: array[0..3] of GLenum;`
	`fFilename: String;`
	`fCustomName: String;`
	`fCustomNameW: WideString;`
	`fCustomData: Pointer;`

Methods

	`function GetFormatDesc: TglBitmapFormatDescriptor;`
	`function GetWidth: Integer; virtual;`
	`function GetHeight: Integer; virtual;`
	`function GetFileWidth: Integer; virtual;`
	`function GetFileHeight: Integer; virtual;`
	`procedure SetCustomData(const aValue: Pointer);`
	`procedure SetCustomName(const aValue: String);`
	`procedure SetCustomNameW(const aValue: WideString);`
	`procedure SetFreeDataOnDestroy(const aValue: Boolean);`
	`procedure SetDeleteTextureOnFree(const aValue: Boolean);`
	`procedure SetFormat(const aValue: TglBitmapFormat);`
	`procedure SetFreeDataAfterGenTexture(const aValue: Boolean);`
	`procedure SetID(const aValue: Cardinal);`
	`procedure SetMipMap(const aValue: TglBitmapMipMap);`
	`procedure SetTarget(const aValue: Cardinal);`
	`procedure SetAnisotropic(const aValue: Integer);`
	`procedure CreateID;`
	`procedure SetupParameters();`
	`procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;`
	`procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;`
	`function FlipHorz: Boolean; virtual;`
	`function FlipVert: Boolean; virtual;`
	`procedure AfterConstruction; override;`
	`procedure BeforeDestruction; override;`
	`procedure PrepareResType(var aResource: String; var aResType: PChar);`
	`procedure LoadFromFile(const aFilename: String);`
	`procedure LoadFromStream(const aStream: TStream); virtual;`
	`procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);`
	`procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);`
	`procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);`
	`procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);`
	`procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;`
	`function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;`
	`function Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;`
	`function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;`
	`function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;`
	`function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;`
	`function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;`
	`function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;`
	`function AddAlphaFromValue(const aAlpha: Byte): Boolean;`
	`function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;`
	`function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;`
	`function RemoveAlpha: Boolean; virtual;`
	`function Clone: TglBitmap;`
	`procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);`
	`procedure FreeData;`
	`procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);`
	`procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);`
	`procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);`
	`procedure SetFilter(const aMin, aMag: GLenum);`
	`procedure SetWrap( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);`
	`procedure SetSwizzle(const r, g, b, a: GLenum);`
	`procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;`
	`procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;`
	`constructor Create; overload;`
	`constructor Create(const aFileName: String); overload;`
	`constructor Create(const aStream: TStream); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;`
	`constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;`
	`constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;`
	`function LoadRAW(const aStream: TStream): Boolean;`
	`procedure SaveRAW(const aStream: TStream);`
	`function LoadBMP(const aStream: TStream): Boolean;`
	`procedure SaveBMP(const aStream: TStream);`
	`function LoadTGA(const aStream: TStream): Boolean;`
	`procedure SaveTGA(const aStream: TStream);`
	`function LoadDDS(const aStream: TStream): Boolean;`
	`procedure SaveDDS(const aStream: TStream);`

Properties

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`property Width: Integer read GetWidth;`
	`property Height: Integer read GetHeight;`
	`property FileWidth: Integer read GetFileWidth;`
	`property FileHeight: Integer read GetFileHeight;`
	`property ID: Cardinal read fID write SetID;`
	`property Target: Cardinal read fTarget write SetTarget;`
	`property Format: TglBitmapFormat read fFormat write SetFormat;`
	`property MipMap: TglBitmapMipMap read fMipMap write SetMipMap;`
	`property Anisotropic: Integer read fAnisotropic write SetAnisotropic;`
	`property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc;`
	`property Filename: String read fFilename;`
	`property CustomName: String read fCustomName write SetCustomName;`
	`property CustomNameW: WideString read fCustomNameW write SetCustomNameW;`
	`property CustomData: Pointer read fCustomData write SetCustomData;`
	`property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree;`
	`property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy;`
	`property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture;`
	`property Dimension: TglBitmapSize read fDimension;`
	`property Data: PByte read fData;`

Description

Fields

+ + + + + + +

	`fID: GLuint;`
+ +name of the OpenGL texture object +

+ + + + + + +

	`fTarget: GLuint;`
+ +texture target (e.g. GL_TEXTURE_2D) +

+ + + + + + +

	`fAnisotropic: Integer;`
+ +anisotropic level +

+ + + + + + +

	`fDeleteTextureOnFree: Boolean;`
+ +delete OpenGL texture object when this object is destroyed +

+ + + + + + +

	`fFreeDataOnDestroy: Boolean;`
+ +free stored data when this object is destroyed +

+ + + + + + +

	`fFreeDataAfterGenTexture: Boolean;`
+ +free stored data after data was uploaded to video card +

+ + + + + + +

	`fData: PByte;`
+ +data of this texture +

+ + + + + + +

	`fBorderColor: array[0..3] of Single;`
+ +color of the texture border +

+ + + + + + +

	`fDimension: TglBitmapSize;`
+ +size of this texture +

+ + + + + + +

	`fMipMap: TglBitmapMipMap;`
+ +mipmap type +

+ + + + + + +

	`fFormat: TglBitmapFormat;`
+ +format the texture data is stored in +

+ + + + + + +

	`fPixelSize: Integer;`
+ +size of one pixel (in byte) +

+ + + + + + +

	`fRowSize: Integer;`
+ +size of one pixel row (in byte) +

+ + + + + + +

	`fFilterMin: GLenum;`
+ +min filter to apply to the texture +

+ + + + + + +

	`fFilterMag: GLenum;`
+ +mag filter to apply to the texture +

+ + + + + + +

	`fWrapS: GLenum;`
+ +texture wrapping for x axis +

+ + + + + + +

	`fWrapT: GLenum;`
+ +texture wrapping for y axis +

+ + + + + + +

	`fWrapR: GLenum;`
+ +texture wrapping for z axis +

+ + + + + + +

	`fSwizzle: array[0..3] of GLenum;`
+ +color channel swizzle +

+ + + + + + +

	`fFilename: String;`
+ +filename the texture was load from +

+ + + + + + +

	`fCustomName: String;`
+ +user defined name +

+ + + + + + +

	`fCustomNameW: WideString;`
+ +user defined name +

+ + + + + + +

	`fCustomData: Pointer;`
+ +user defined data +

Methods

+ + + + + + +

function GetFormatDesc: TglBitmapFormatDescriptor;

Returns

format descriptor that describes the format of the stored data

+ + + + + + +

function GetWidth: Integer; virtual;

Returns

the actual width of the texture

+ + + + + + +

function GetHeight: Integer; virtual;

Returns

the actual height of the texture

+ + + + + + +

function GetFileWidth: Integer; virtual;

Returns

the width of the texture or 1 if the width is zero

+ + + + + + +

function GetFileHeight: Integer; virtual;

Returns

the height of the texture or 1 if the height is zero

+ + + + + + +

	`procedure SetCustomData(const aValue: Pointer);`
+ +set a new value for fCustomData +

+ + + + + + +

	`procedure SetCustomName(const aValue: String);`
+ +set a new value for fCustomName +

+ + + + + + +

	`procedure SetCustomNameW(const aValue: WideString);`
+ +set a new value for fCustomNameW +

+ + + + + + +

	`procedure SetFreeDataOnDestroy(const aValue: Boolean);`
+ +set new value for fFreeDataOnDestroy +

+ + + + + + +

	`procedure SetDeleteTextureOnFree(const aValue: Boolean);`
+ +set new value for fDeleteTextureOnFree +

+ + + + + + +

	`procedure SetFormat(const aValue: TglBitmapFormat);`
+ +set new value for the data format. only possible if new format has the same pixel size. if you want to convert the texture data, see ConvertTo function +

+ + + + + + +

	`procedure SetFreeDataAfterGenTexture(const aValue: Boolean);`
+ +set new value for fFreeDataAfterGenTexture +

+ + + + + + +

	`procedure SetID(const aValue: Cardinal);`
+ +set name of OpenGL texture object +

+ + + + + + +

	`procedure SetMipMap(const aValue: TglBitmapMipMap);`
+ +set new value for fMipMap +

+ + + + + + +

	`procedure SetTarget(const aValue: Cardinal);`
+ +set new value for target +

+ + + + + + +

	`procedure SetAnisotropic(const aValue: Integer);`
+ +set new value for fAnisotrophic +

+ + + + + + +

	`procedure CreateID;`
+ +create OpenGL texture object (delete exisiting object if exists) +

+ + + + + + +

	`procedure SetupParameters();`
+ +setup texture parameters +

+ + + + + + +

procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;

+set data pointer of texture data

Parameters

aData: pointer to new texture data (be carefull, aData could be freed by this function)
aFormat: format of the data stored at aData
aWidth: width of the texture data
aHeight: height of the texture data

+ + + + + + +

procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;

+generate texture (upload texture data to video card)

Parameters

aTestTextureSize: test texture size before uploading and raise exception if something is wrong

+ + + + + + +

function FlipHorz: Boolean; virtual;

+flip texture horizontal

Returns

True in success, False otherwise

+ + + + + + +

function FlipVert: Boolean; virtual;

+flip texture vertical

Returns

True in success, False otherwise

+ + + + + + +

	`procedure AfterConstruction; override;`
+ +this method is called after the constructor and sets the default values of this object +

+ + + + + + +

	`procedure BeforeDestruction; override;`
+ +this method is called before the destructor and does some cleanup +

+ + + + + + +

procedure PrepareResType(var aResource: String; var aResType: PChar);

+splits a resource identifier into the resource and it's type

Parameters

aResource: resource identifier to split and store name in
aResType: type of the resource

+ + + + + + +

procedure LoadFromFile(const aFilename: String);

+load a texture from a file

Parameters

aFilename: file to load texuture from

+ + + + + + +

procedure LoadFromStream(const aStream: TStream); virtual;

+load a texture from a stream

Parameters

aStream: stream to load texture from

+ + + + + + +

procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);

+use a function to generate texture data

Parameters

aSize: size of the texture
aFunc: callback to use for generation
aFormat: format of the texture data
aArgs: user defined paramaters (use at will)

+ + + + + + +

procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);

+load a texture from a resource

Parameters

aInstance: resource handle
aResource: resource indentifier
aResType: resource type (if known)

+ + + + + + +

procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);

+load a texture from a resource id

Parameters

aInstance: resource handle
aResource: resource ID
aResType: resource type

+ + + + + + +

procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);

+save texture data to a file

Parameters

aFilename: filename to store texture in
aFileType: file type to store data into

+ + + + + + +

procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;

+save texture data to a stream

Parameters

aFilename: filename to store texture in
aFileType: file type to store data into

+ + + + + + +

function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;

+convert texture data using a user defined callback

Parameters

aFunc: callback to use for converting
aCreateTemp: create a temporary buffer to use for converting
aArgs: user defined paramters (use at will)

Returns

True if converting was successful, False otherwise

+ + + + + + +

function Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;

+convert texture data using a user defined callback

Parameters

aSource: glBitmap to read data from
aFunc: callback to use for converting
aCreateTemp: create a temporary buffer to use for converting
aFormat: format of the new data
aArgs: user defined paramters (use at will)

Returns

True if converting was successful, False otherwise

+ + + + + + +

function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;

+convert texture data using a specific format

Parameters

aFormat: new format of texture data

Returns

True if converting was successful, False otherwise

+ + + + + + +

function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+load alpha channel data from resource

Parameters

aInstance: resource handle
aResource: resource ID
aResType: resource type
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+load alpha channel data from resource ID

Parameters

aInstance: resource handle
aResourceID: resource ID
aResType: resource type
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;

+add alpha channel data from function

Parameters

aFunc: callback to get data from
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap)

Parameters

aFilename: file to load alpha channel data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap)

Parameters

aStream: stream to load alpha channel data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+add alpha channel data from existing glBitmap object

Parameters

aBitmap: TglBitmap to copy alpha channel data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0-255)
aGreen: green threshold (0-255)
aBlue: blue threshold (0-255)
aDeviatation: accepted deviatation (0-255)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0-Range.r)
aGreen: green threshold (0-Range.g)
aBlue: blue threshold (0-Range.b)
aDeviatation: accepted deviatation (0-max(Range.rgb))

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0.0-1.0)
aGreen: green threshold (0.0-1.0)
aBlue: blue threshold (0.0-1.0)
aDeviatation: accepted deviatation (0.0-1.0)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValue(const aAlpha: Byte): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0-255)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0-max(Range.rgb))

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0.0-1.0)

Returns

True on success, False otherwise

+ + + + + + +

function RemoveAlpha: Boolean; virtual;

+remove alpha channel

Returns

True on success, False otherwise

+ + + + + + +

function Clone: TglBitmap;

+create a clone of the current object

Returns

clone of this object

+ + + + + + +

procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);

+invert color data (xor)

Parameters

aUseRGB: xor each color channel
aUseAlpha: xor alpha channel

+ + + + + + +

	`procedure FreeData;`
+ +free texture stored data +

+ + + + + + +

procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);

+fill complete texture with one color

Parameters

aRed: red color for border (0-255)
aGreen: green color for border (0-255)
aBlue: blue color for border (0-255)
aAlpha: alpha color for border (0-255)

+ + + + + + +

procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);

+fill complete texture with one color

Parameters

aRed: red color for border (0-Range.r)
aGreen: green color for border (0-Range.g)
aBlue: blue color for border (0-Range.b)
aAlpha: alpha color for border (0-Range.a)

+ + + + + + +

procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);

+fill complete texture with one color

Parameters

aRed: red color for border (0.0-1.0)
aGreen: green color for border (0.0-1.0)
aBlue: blue color for border (0.0-1.0)
aAlpha: alpha color for border (0.0-1.0)

+ + + + + + +

procedure SetFilter(const aMin, aMag: GLenum);

+set new texture filer

Parameters

aMin: min filter
aMag: mag filter

+ + + + + + +

procedure SetWrap( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);

+set new texture wrapping

Parameters

S: texture wrapping for x axis
T: texture wrapping for y axis
R: texture wrapping for z axis

+ + + + + + +

procedure SetSwizzle(const r, g, b, a: GLenum);

+set new swizzle

Parameters

r: swizzle for red channel
g: swizzle for green channel
b: swizzle for blue channel
a: swizzle for alpha channel

+ + + + + + +

procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;

+bind texture

Parameters

aEnableTextureUnit: enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))

+ + + + + + +

procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;

+bind texture

Parameters

aDisableTextureUnit: disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))

+ + + + + + +

	`constructor Create; overload;`
+ +constructor - created an empty texture +

+ + + + + + +

constructor Create(const aFileName: String); overload;

+constructor - creates a texture and load it from a file

Parameters

aFilename: file to load texture from

+ + + + + + +

constructor Create(const aStream: TStream); overload;

+constructor - creates a texture and load it from a stream

Parameters

aStream: stream to load texture from

+ + + + + + +

constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;

+constructor - creates a texture with the given size, format and data you can control this by setting DeleteTextureOnFree, FreeDataOnDestroy and FreeDataAfterGenTexture

Parameters

aSize: size of the texture
aFormat: format of the given data
aData: texture data - be carefull: the data will now be managed by the glBitmap object,

+ + + + + + +

constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;

+constructor - creates a texture with the given size and format and uses the given callback to create the data

Parameters

aSize: size of the texture
aFormat: format of the given data
aFunc: callback to use for generating the data
aArgs: user defined parameters (use at will)

+ + + + + + +

constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;

+constructor - creates a texture and loads it from a resource

Parameters

aInstance: resource handle
aResource: resource indentifier
aResType: resource type (if known)

+ + + + + + +

constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;

+constructor - creates a texture and loads it from a resource

Parameters

aInstance: resource handle
aResourceID: resource ID
aResType: resource type (if known)

+ + + + + + +

function LoadRAW(const aStream: TStream): Boolean;

+try to load a RAW image from a stream

Parameters

aStream: stream to load RAW image from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveRAW(const aStream: TStream);

+save texture data as RAW image to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadBMP(const aStream: TStream): Boolean;

+try to load a BMP from a stream

Parameters

aStream: stream to load BMP from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveBMP(const aStream: TStream);

+save texture data as BMP to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadTGA(const aStream: TStream): Boolean;

+try to load a TGA from a stream

Parameters

aStream: stream to load TGA from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveTGA(const aStream: TStream);

+save texture data as TGA to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadDDS(const aStream: TStream): Boolean;

+try to load a DDS from a stream

Parameters

aStream: stream to load DDS from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveDDS(const aStream: TStream);

+save texture data as DDS to stream

Parameters

aStream: stream to save data to

Properties

+ + + + + + +

	`property Width: Integer read GetWidth;`
+ +the actual width of the texture +

+ + + + + + +

	`property Height: Integer read GetHeight;`
+ +the actual height of the texture +

+ + + + + + +

	`property FileWidth: Integer read GetFileWidth;`
+ +the width of the texture or 1 if the width is zero +

+ + + + + + +

	`property FileHeight: Integer read GetFileHeight;`
+ +the height of the texture or 1 if the height is zero +

+ + + + + + +

	`property ID: Cardinal read fID write SetID;`
+ +name of the OpenGL texture object +

+ + + + + + +

	`property Target: Cardinal read fTarget write SetTarget;`
+ +texture target (e.g. GL_TEXTURE_2D) +

+ + + + + + +

	`property Format: TglBitmapFormat read fFormat write SetFormat;`
+ +format the texture data is stored in +

+ + + + + + +

	`property MipMap: TglBitmapMipMap read fMipMap write SetMipMap;`
+ +mipmap type +

+ + + + + + +

	`property Anisotropic: Integer read fAnisotropic write SetAnisotropic;`
+ +anisotropic level +

+ + + + + + +

	`property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc;`
+ +format descriptor that describes the format of the stored data +

+ + + + + + +

	`property Filename: String read fFilename;`
+ +filename the texture was load from +

+ + + + + + +

	`property CustomName: String read fCustomName write SetCustomName;`
+ +user defined name (use at will) +

+ + + + + + +

	`property CustomNameW: WideString read fCustomNameW write SetCustomNameW;`
+ +user defined name (as WideString; use at will) +

+ + + + + + +

	`property CustomData: Pointer read fCustomData write SetCustomData;`
+ +user defined data (use at will) +

+ + + + + + +

	`property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree;`
+ +delete texture object when this object is destroyed +

+ + + + + + +

	`property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy;`
+ +free stored data when this object is destroyed +

+ + + + + + +

	`property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture;`
+ +free stored data after it is uplaoded to video card +

+ + + + + + +

	`property Dimension: TglBitmapSize read fDimension;`
+ +size of the texture +

+ + + + + + +

	`property Data: PByte read fData;`
+ +texture data (or `Nil` if unset) +

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmap1D.html b/doc/glBitmap.TglBitmap1D.html new file mode 100644 index 0000000..d41d806 --- /dev/null +++ b/doc/glBitmap.TglBitmap1D.html @@ -0,0 +1,146 @@ + + + +glBitmap: Class TglBitmap1D + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmap1D

+ + +

Fields

Unit

+glBitmap

Declaration

+type TglBitmap1D = class(TglBitmap)

Description

+wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D

Hierarchy

TObject
TglBitmap
TglBitmap1D

Overview

Methods

+ + + + + + + + + + + + + + + + + + + + + +

	`procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;`
	`procedure UploadData(const aBuildWithGlu: Boolean);`
	`procedure AfterConstruction; override;`
	`function FlipHorz: Boolean; override;`
	`procedure GenTexture(const aTestTextureSize: Boolean = true); override;`

Properties

+ + + + + +

property Width;

Description

Methods

+ + + + + + +

procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;

+set data pointer of texture data

Parameters

aData: pointer to new texture data (be carefull, aData could be freed by this function)
aFormat: format of the data stored at aData
aWidth: width of the texture data
aHeight: height of the texture data

+ + + + + + +

procedure UploadData(const aBuildWithGlu: Boolean);

+upload the texture data to video card

Parameters

aBuildWithGlu: use glu functions to build mipmaps

+ + + + + + +

	`procedure AfterConstruction; override;`
+ +this method is called after constructor and initializes the object +

+ + + + + + +

function FlipHorz: Boolean; override;

+flip texture horizontally

Returns

True on success, @fals otherwise

+ + + + + + +

procedure GenTexture(const aTestTextureSize: Boolean = true); override;

+generate texture (create texture object if not exist, set texture parameters and upload data

Parameters

aTestTextureSize: check the size of the texture and throw exception if something is wrong

Properties

+ + + + + + +

	`property Width;`
+ +actual with of the texture +

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmap2D.html b/doc/glBitmap.TglBitmap2D.html new file mode 100644 index 0000000..ce0232a --- /dev/null +++ b/doc/glBitmap.TglBitmap2D.html @@ -0,0 +1,279 @@ + + + +glBitmap: Class TglBitmap2D + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmap2D

+ + +

Unit

+glBitmap

Declaration

+type TglBitmap2D = class(TglBitmap)

Description

+wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D)

Hierarchy

TObject
TglBitmap
TglBitmap2D

Overview

Fields

+ + + + + +

fLines: array of PByte;

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`function GetScanline(const aIndex: Integer): Pointer;`
	`procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;`
	`procedure UploadData(const aTarget: GLenum);`
	`procedure AfterConstruction; override;`
	`procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);`
	`procedure GenTexture(const aTestTextureSize: Boolean = true); override;`
	`function FlipHorz: Boolean; override;`
	`function FlipVert: Boolean; override;`
	`procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);`

Properties

+ + + + + + + + + + + + + +

	`property Width;`
	`property Height;`
	`property Scanline[constaIndex:Integer]: Pointer read GetScanline;`

Description

Fields

+ + + + + + +

	`fLines: array of PByte;`
+ +array to store scanline entry points in +

Methods

+ + + + + + +

function GetScanline(const aIndex: Integer): Pointer;

+get a specific scanline

Parameters

aIndex: index of the scanline to return

Returns

scanline at position aIndex or Nil

+ + + + + + +

procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;

+set data pointer of texture data

Parameters

aData: pointer to new texture data (be carefull, aData could be freed by this function)
aFormat: format of the data stored at aData
aWidth: width of the texture data
aHeight: height of the texture data

+ + + + + + +

procedure UploadData(const aTarget: GLenum);

+upload the texture data to video card

Parameters

aTarget: target o upload data to (e.g. GL_TEXTURE_2D)
aBuildWithGlu: use glu functions to build mipmaps

+ + + + + + +

	`procedure AfterConstruction; override;`
+ +this method is called after constructor and initializes the object +

+ + + + + + +

procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);

+copy a part of the frame buffer top the texture

Parameters

aTop: topmost pixel to copy
aLeft: leftmost pixel to copy
aRight: rightmost pixel to copy
aBottom: bottommost pixel to copy
aFormat: format to store data in

+ + + + + + +

procedure GenTexture(const aTestTextureSize: Boolean = true); override;

+generate texture (create texture object if not exist, set texture parameters and upload data)

Parameters

aTestTextureSize: check the size of the texture and throw exception if something is wrong

+ + + + + + +

function FlipHorz: Boolean; override;

+flip texture horizontally

Returns

True on success, False otherwise

+ + + + + + +

function FlipVert: Boolean; override;

+flip texture vertically

Returns

True on success, False otherwise

+ + + + + + +

procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);

+create normal map from texture data

Parameters

aFunc: normal map function to generate normalmap with
aScale: scale of the normale stored in the normal map
aUseAlpha: generate normalmap from alpha channel data (if present)

Properties

+ + + + + + +

	`property Width;`
+ +actual width of the texture +

+ + + + + + +

	`property Height;`
+ +actual height of the texture +

+ + + + + + +

	`property Scanline[constaIndex:Integer]: Pointer read GetScanline;`
+ +scanline to access texture data directly +

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapCubeMap.html b/doc/glBitmap.TglBitmapCubeMap.html new file mode 100644 index 0000000..e3bd45b --- /dev/null +++ b/doc/glBitmap.TglBitmapCubeMap.html @@ -0,0 +1,133 @@ + + + +glBitmap: Class TglBitmapCubeMap + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmapCubeMap

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapCubeMap = class(TglBitmap2D)

Description

+wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP)

Hierarchy

TObject
TglBitmap
TglBitmap2D
TglBitmapCubeMap

Overview

Methods

+ + + + + + + + + + + + + + + + + + + + + +

	`procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;`
	`procedure AfterConstruction; override;`
	`procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);`
	`procedure Bind( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;`
	`procedure Unbind( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;`

Description

Methods

+ + + + + + +

procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;

+generate texture (create texture object if not exist, set texture parameters and upload data do not call directly for cubemaps, use GenerateCubeMap instead

Parameters

aTestTextureSize: check the size of the texture and throw exception if something is wrong

+ + + + + + +

	`procedure AfterConstruction; override;`
+ +this method is called after constructor and initializes the object +

+ + + + + + +

procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);

+generate texture (create texture object if not exist, set texture parameters and upload data

Parameters

aCubeTarget: cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X)
aTestTextureSize: check the size of the texture and throw exception if something is wrong

+ + + + + + +

procedure Bind( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;

+bind texture

Parameters

aEnableTexCoordsGen: enable cube map generator
aEnableTextureUnit: enable texture unit

+ + + + + + +

procedure Unbind( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;

+unbind texture

Parameters

aDisableTexCoordsGen: disable cube map generator
aDisableTextureUnit: disable texture unit

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapFormatDescriptor.html b/doc/glBitmap.TglBitmapFormatDescriptor.html new file mode 100644 index 0000000..c903418 --- /dev/null +++ b/doc/glBitmap.TglBitmapFormatDescriptor.html @@ -0,0 +1,743 @@ + + + +glBitmap: Class TglBitmapFormatDescriptor + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmapFormatDescriptor

+ + +

Unit

+glBitmap

Declaration

+type TglBitmapFormatDescriptor = class(TObject)

Description

+describes the properties of a given texture data format

Hierarchy

TObject
TglBitmapFormatDescriptor

Overview

Fields

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`fBytesPerPixel: Single;`
	`fChannelCount: Integer;`
	`fMask: TglBitmapRec4ul;`
	`fRange: TglBitmapRec4ui;`
	`fFormat: TglBitmapFormat;`
	`fWithAlpha: TglBitmapFormat;`
	`fWithoutAlpha: TglBitmapFormat;`
	`fOpenGLFormat: TglBitmapFormat;`
	`fRGBInverted: TglBitmapFormat;`
	`fUncompressed: TglBitmapFormat;`
	`fBitsPerPixel: Integer;`
	`fIsCompressed: Boolean;`
	`fPrecision: TglBitmapRec4ub;`
	`fShift: TglBitmapRec4ub;`
	`fglFormat: GLenum;`
	`fglInternalFormat: GLenum;`
	`fglDataFormat: GLenum;`

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`function GetHasRed: Boolean;`
	`function GetHasGreen: Boolean;`
	`function GetHasBlue: Boolean;`
	`function GetHasAlpha: Boolean;`
	`function GetHasColor: Boolean;`
	`function GetIsGrayscale: Boolean;`
	`procedure SetValues; virtual;`
	`procedure CalcValues;`
	`constructor Create;`
	`class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;`

Properties

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`property Format: TglBitmapFormat read fFormat;`
	`property ChannelCount: Integer read fChannelCount;`
	`property IsCompressed: Boolean read fIsCompressed;`
	`property BitsPerPixel: Integer read fBitsPerPixel;`
	`property BytesPerPixel: Single read fBytesPerPixel;`
	`property Precision: TglBitmapRec4ub read fPrecision;`
	`property Shift: TglBitmapRec4ub read fShift;`
	`property Range: TglBitmapRec4ui read fRange;`
	`property Mask: TglBitmapRec4ul read fMask;`
	`property RGBInverted: TglBitmapFormat read fRGBInverted;`
	`property WithAlpha: TglBitmapFormat read fWithAlpha;`
	`property WithoutAlpha: TglBitmapFormat read fWithAlpha;`
	`property OpenGLFormat: TglBitmapFormat read fOpenGLFormat;`
	`property Uncompressed: TglBitmapFormat read fUncompressed;`
	`property glFormat: GLenum read fglFormat;`
	`property glInternalFormat: GLenum read fglInternalFormat;`
	`property glDataFormat: GLenum read fglDataFormat;`
	`property HasRed: Boolean read GetHasRed;`
	`property HasGreen: Boolean read GetHasGreen;`
	`property HasBlue: Boolean read GetHasBlue;`
	`property HasAlpha: Boolean read GetHasAlpha;`
	`property HasColor: Boolean read GetHasColor;`
	`property IsGrayscale: Boolean read GetIsGrayscale;`

Description

Fields

+ + + + + + +

	`fBytesPerPixel: Single;`
+ +number of bytes for each pixel +

+ + + + + + +

	`fChannelCount: Integer;`
+ +number of color channels +

+ + + + + + +

	`fMask: TglBitmapRec4ul;`
+ +bitmask for each color channel +

+ + + + + + +

	`fRange: TglBitmapRec4ui;`
+ +maximal value of each color channel +

+ + + + + + +

	`fFormat: TglBitmapFormat;`
+ +format this descriptor belongs to +

+ + + + + + +

	`fWithAlpha: TglBitmapFormat;`
+ +suitable format with alpha channel +

+ + + + + + +

	`fWithoutAlpha: TglBitmapFormat;`
+ +suitable format without alpha channel +

+ + + + + + +

	`fOpenGLFormat: TglBitmapFormat;`
+ +suitable format that is supported by OpenGL +

+ + + + + + +

	`fRGBInverted: TglBitmapFormat;`
+ +suitable format with inverted RGB channels +

+ + + + + + +

	`fUncompressed: TglBitmapFormat;`
+ +suitable format with uncompressed data +

+ + + + + + +

	`fBitsPerPixel: Integer;`
+ +number of bits per pixel +

+ + + + + + +

	`fIsCompressed: Boolean;`
+ +`True` if the format is compressed, `False` otherwise +

+ + + + + + +

	`fPrecision: TglBitmapRec4ub;`
+ +number of bits for each color channel +

+ + + + + + +

	`fShift: TglBitmapRec4ub;`
+ +bit offset for each color channel +

+ + + + + + +

	`fglFormat: GLenum;`
+ +OpenGL format enum (e.g. GL_RGB) +

+ + + + + + +

	`fglInternalFormat: GLenum;`
+ +OpenGL internal format enum (e.g. GL_RGB8) +

+ + + + + + +

	`fglDataFormat: GLenum;`
+ +OpenGL data format enum (e.g. GL_UNSIGNED_BYTE) +

Methods

+ + + + + + +

function GetHasRed: Boolean;

Returns

True if the format has a red color channel, False otherwise

+ + + + + + +

function GetHasGreen: Boolean;

Returns

True if the format has a green color channel, False otherwise

+ + + + + + +

function GetHasBlue: Boolean;

Returns

True if the format has a blue color channel, False otherwise

+ + + + + + +

function GetHasAlpha: Boolean;

Returns

True if the format has a alpha color channel, False otherwise

+ + + + + + +

function GetHasColor: Boolean;

Returns

True if the format has any color color channel, False otherwise

+ + + + + + +

function GetIsGrayscale: Boolean;

Returns

True if the format is a grayscale format, False otherwise

+ + + + + + +

	`procedure SetValues; virtual;`
+ +set values for this format descriptor +

+ + + + + + +

	`procedure CalcValues;`
+ +calculate cached values +

+ + + + + + +

	`constructor Create;`
+ +constructor +

+ + + + + + +

class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;

+get the format descriptor by a given OpenGL internal format

Parameters

aInternalFormat: OpenGL internal format to get format descriptor for

Returns

suitable format descriptor or tfEmpty-Descriptor

Properties

+ + + + + + +

	`property Format: TglBitmapFormat read fFormat;`
+ +format this descriptor belongs to +

+ + + + + + +

	`property ChannelCount: Integer read fChannelCount;`
+ +number of color channels +

+ + + + + + +

	`property IsCompressed: Boolean read fIsCompressed;`
+ +`True` if the format is compressed, `False` otherwise +

+ + + + + + +

	`property BitsPerPixel: Integer read fBitsPerPixel;`
+ +number of bytes per pixel +

+ + + + + + +

	`property BytesPerPixel: Single read fBytesPerPixel;`
+ +number of bits per pixel +

+ + + + + + +

	`property Precision: TglBitmapRec4ub read fPrecision;`
+ +number of bits for each color channel +

+ + + + + + +

	`property Shift: TglBitmapRec4ub read fShift;`
+ +bit offset for each color channel +

+ + + + + + +

	`property Range: TglBitmapRec4ui read fRange;`
+ +maximal value of each color channel +

+ + + + + + +

	`property Mask: TglBitmapRec4ul read fMask;`
+ +bitmask for each color channel +

+ + + + + + +

	`property RGBInverted: TglBitmapFormat read fRGBInverted;`
+ +suitable format with inverted RGB channels +

+ + + + + + +

	`property WithAlpha: TglBitmapFormat read fWithAlpha;`
+ +suitable format with alpha channel +

+ + + + + + +

	`property WithoutAlpha: TglBitmapFormat read fWithAlpha;`
+ +suitable format without alpha channel +

+ + + + + + +

	`property OpenGLFormat: TglBitmapFormat read fOpenGLFormat;`
+ +suitable format that is supported by OpenGL +

+ + + + + + +

	`property Uncompressed: TglBitmapFormat read fUncompressed;`
+ +suitable format with uncompressed data +

+ + + + + + +

	`property glFormat: GLenum read fglFormat;`
+ +OpenGL format enum (e.g. GL_RGB) +

+ + + + + + +

	`property glInternalFormat: GLenum read fglInternalFormat;`
+ +OpenGL internal format enum (e.g. GL_RGB8) +

+ + + + + + +

	`property glDataFormat: GLenum read fglDataFormat;`
+ +OpenGL data format enum (e.g. GL_UNSIGNED_BYTE) +

+ + + + + + +

	`property HasRed: Boolean read GetHasRed;`
+ +`True` if the format has a red color channel, `False` otherwise +

+ + + + + + +

	`property HasGreen: Boolean read GetHasGreen;`
+ +`True` if the format has a green color channel, `False` otherwise +

+ + + + + + +

	`property HasBlue: Boolean read GetHasBlue;`
+ +`True` if the format has a blue color channel, `False` otherwise +

+ + + + + + +

	`property HasAlpha: Boolean read GetHasAlpha;`
+ +`True` if the format has a alpha color channel, `False` otherwise +

+ + + + + + +

	`property HasColor: Boolean read GetHasColor;`
+ +`True` if the format has any color color channel, `False` otherwise +

+ + + + + + +

	`property IsGrayscale: Boolean read GetIsGrayscale;`
+ +`True` if the format is a grayscale format, `False` otherwise +

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapFunctionRec.html b/doc/glBitmap.TglBitmapFunctionRec.html new file mode 100644 index 0000000..23f734f --- /dev/null +++ b/doc/glBitmap.TglBitmapFunctionRec.html @@ -0,0 +1,105 @@ + + + +glBitmap: record TglBitmapFunctionRec + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

record TglBitmapFunctionRec

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapFunctionRec = record

Description

+structure to store data for converting in

Overview

Fields

+ + + + + + + + + + + + + + + + + + + +

Sender: TglBitmap;

Size: TglBitmapSize;

Position: TglBitmapPixelPosition;

Source: TglBitmapPixelData;

Dest: TglBitmapPixelData;

Args: Pointer;

Description

Fields

+ + + + + +

Sender: TglBitmap;

+texture object that stores the data to convert

+ + + + + +

Size: TglBitmapSize;

+size of the texture

+ + + + + +

Position: TglBitmapPixelPosition;

+position of the currently pixel

+ + + + + +

Source: TglBitmapPixelData;

+pixel data of the current pixel

+ + + + + +

Dest: TglBitmapPixelData;

+new data of the pixel (must be filled in)

+ + + + + +

Args: Pointer;

+user defined args that was passed to the convert function

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapNormalMap.html b/doc/glBitmap.TglBitmapNormalMap.html new file mode 100644 index 0000000..b58e758 --- /dev/null +++ b/doc/glBitmap.TglBitmapNormalMap.html @@ -0,0 +1,73 @@ + + + +glBitmap: Class TglBitmapNormalMap + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Class TglBitmapNormalMap

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapNormalMap = class(TglBitmapCubeMap)

Description

+wrapper class for cube normal maps

Hierarchy

TObject
TglBitmap
TglBitmap2D
TglBitmapCubeMap
TglBitmapNormalMap

Overview

Methods

+ + + + + + + + + +

	`procedure AfterConstruction; override;`
	`procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);`

Description

Methods

+ + + + + + +

	`procedure AfterConstruction; override;`
+ +this method is called after constructor and initializes the object +

+ + + + + + +

procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);

+create cube normal map from texture data and upload it to video card

Parameters

aSize: size of each cube map texture
aTestTextureSize: check texture size when uploading and throw exception if something is wrong

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapPixelData.html b/doc/glBitmap.TglBitmapPixelData.html new file mode 100644 index 0000000..9144e65 --- /dev/null +++ b/doc/glBitmap.TglBitmapPixelData.html @@ -0,0 +1,69 @@ + + + +glBitmap: packed record TglBitmapPixelData + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

packed record TglBitmapPixelData

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapPixelData = packed record

Description

+structure to store pixel data in

Overview

Fields

+ + + + + + + + + + +

Data: TglBitmapRec4ui;

Range: TglBitmapRec4ui;

Format: TglBitmapFormat;

Description

Fields

+ + + + + +

Data: TglBitmapRec4ui;

+color data for each color channel

+ + + + + +

Range: TglBitmapRec4ui;

+maximal color value for each channel

+ + + + + +

Format: TglBitmapFormat;

+format of the pixel

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapRec4ub.html b/doc/glBitmap.TglBitmapRec4ub.html new file mode 100644 index 0000000..7f5f880 --- /dev/null +++ b/doc/glBitmap.TglBitmapRec4ub.html @@ -0,0 +1,83 @@ + + + +glBitmap: packed record TglBitmapRec4ub + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

packed record TglBitmapRec4ub

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapRec4ub = packed record

Description

+record that stores 4 unsigned byte values

Overview

Fields

+ + + + + + + + + + + + + + + + +

r: Byte

g: Byte

b: Byte

a: Byte

arr: array[0..3] of Byte

Description

Fields

+ + + + + +

r: Byte

+ + + + + +

g: Byte

+ + + + + +

b: Byte

+ + + + + +

a: Byte

+ + + + + +

arr: array[0..3] of Byte

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapRec4ui.html b/doc/glBitmap.TglBitmapRec4ui.html new file mode 100644 index 0000000..36e5ce5 --- /dev/null +++ b/doc/glBitmap.TglBitmapRec4ui.html @@ -0,0 +1,83 @@ + + + +glBitmap: packed record TglBitmapRec4ui + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

packed record TglBitmapRec4ui

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapRec4ui = packed record

Description

+record that stores 4 unsigned integer values

Overview

Fields

+ + + + + + + + + + + + + + + + +

r: Cardinal

g: Cardinal

b: Cardinal

a: Cardinal

arr: array[0..3] of Cardinal

Description

Fields

+ + + + + +

r: Cardinal

+ + + + + +

g: Cardinal

+ + + + + +

b: Cardinal

+ + + + + +

a: Cardinal

+ + + + + +

arr: array[0..3] of Cardinal

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapRec4ul.html b/doc/glBitmap.TglBitmapRec4ul.html new file mode 100644 index 0000000..f9e9b67 --- /dev/null +++ b/doc/glBitmap.TglBitmapRec4ul.html @@ -0,0 +1,83 @@ + + + +glBitmap: packed record TglBitmapRec4ul + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

packed record TglBitmapRec4ul

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapRec4ul = packed record

Description

+record that stores 4 unsigned long integer values

Overview

Fields

+ + + + + + + + + + + + + + + + +

r: QWord

g: QWord

b: QWord

a: QWord

arr: array[0..3] of QWord

Description

Fields

+ + + + + +

r: QWord

+ + + + + +

g: QWord

+ + + + + +

b: QWord

+ + + + + +

a: QWord

+ + + + + +

arr: array[0..3] of QWord

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.TglBitmapSize.html b/doc/glBitmap.TglBitmapSize.html new file mode 100644 index 0000000..67b9ace --- /dev/null +++ b/doc/glBitmap.TglBitmapSize.html @@ -0,0 +1,61 @@ + + + +glBitmap: packed record TglBitmapSize + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

packed record TglBitmapSize

+ + +

Description

Hierarchy

Fields

Methods

Properties

Unit

+glBitmap

Declaration

+type TglBitmapSize = packed record

Description

Overview

Fields

+ + + + + + + + + + +

Fields: TglBitmapSizeFields;

X: Word;

Y: Word;

Description

Fields

+ + + + + +

Fields: TglBitmapSizeFields;

+ + + + + +

X: Word;

+ + + + + +

Y: Word;

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/glBitmap.html b/doc/glBitmap.html new file mode 100644 index 0000000..839c453 --- /dev/null +++ b/doc/glBitmap.html @@ -0,0 +1,602 @@ + + + +glBitmap + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Unit glBitmap

+ + +

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

+glBitmap by Steffen Xonna aka Lossy eX (2003-2008) http://www.opengl24.de/index.php?cat=header&file=glbitmap + +

modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + +

Overview

Classes, Interfaces, Objects and Records

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Description
Class `EglBitmap`
Class `EglBitmapNotSupported`
Class `EglBitmapSizeToLarge`
Class `EglBitmapNonPowerOfTwo`
Class `EglBitmapUnsupportedFormat`
packed record `TglBitmapRec4ui`
packed record `TglBitmapRec4ub`
packed record `TglBitmapRec4ul`
Class `TglBitmapFormatDescriptor`
packed record `TglBitmapPixelData`
packed record `TglBitmapSize`
record `TglBitmapFunctionRec`
Class `TglBitmap`
Class `TglBitmap1D`
Class `TglBitmap2D`
Class `TglBitmapCubeMap`
Class `TglBitmapNormalMap`

Functions and Procedures

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);

procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);

procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);

procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);

procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);

procedure glBitmapSetDefaultWrap( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);

procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);

function glBitmapGetDefaultDeleteTextureOnFree: Boolean;

function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;

function glBitmapGetDefaultMipmap: TglBitmapMipMap;

function glBitmapGetDefaultFormat: TglBitmapFormat;

procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);

procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);

procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);

function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;

function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;

function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;

function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;

function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;

function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;

function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;

function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D;

Types

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

TglBitmapFormat = (...);

TglBitmapFileType = (...);

TglBitmapFileTypes = set of TglBitmapFileType;

TglBitmapMipMap = (...);

TglBitmapNormalMapFunc = (...);

PglBitmapPixelData = ˆTglBitmapPixelData;

TglBitmapSizeFields = set of (ffX, ffY);

TglBitmapPixelPosition = TglBitmapSize;

TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);

Constants

+ + + + +

NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0);

Description

Functions and Procedures

+ + + + + +

procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);

+ + + + + +

procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);

+ + + + + +

procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);

+ + + + + +

procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);

+ + + + + +

procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);

+ + + + + +

procedure glBitmapSetDefaultWrap( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);

+ + + + + +

procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);

+ + + + + +

function glBitmapGetDefaultDeleteTextureOnFree: Boolean;

+ + + + + +

function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;

+ + + + + +

function glBitmapGetDefaultMipmap: TglBitmapMipMap;

+ + + + + +

function glBitmapGetDefaultFormat: TglBitmapFormat;

+ + + + + +

procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);

+ + + + + +

procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);

+ + + + + +

procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);

+ + + + + +

function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;

+ + + + + +

function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;

+ + + + + +

function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;

+ + + + + +

function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;

+ + + + + +

function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;

+ + + + + +

function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;

+ + + + + +

function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;

+ + + + + +

function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D;

Types

+ + + + + +

TglBitmapFormat = (...);

+type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types

Values

+tfEmpty = 0:
+tfAlpha4ub1: 1 x unsigned byte
+tfAlpha8ub1: 1 x unsigned byte
+tfAlpha16us1: 1 x unsigned short
+tfLuminance4ub1: 1 x unsigned byte
+tfLuminance8ub1: 1 x unsigned byte
+tfLuminance16us1: 1 x unsigned short
+tfLuminance4Alpha4ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+tfLuminance6Alpha2ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+tfLuminance8Alpha8ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+tfLuminance12Alpha4us2: 1 x unsigned short (lum), 1 x unsigned short (alpha)
+tfLuminance16Alpha16us2: 1 x unsigned short (lum), 1 x unsigned short (alpha)
+tfR3G3B2ub1: 1 x unsigned byte (3bit red, 3bit green, 2bit blue)
+tfRGBX4us1: 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd)
+tfXRGB4us1: 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue)
+tfR5G6B5us1: 1 x unsigned short (5bit red, 6bit green, 5bit blue)
+tfRGB5X1us1: 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved)
+tfX1RGB5us1: 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue)
+tfRGB8ub3: 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue)
+tfRGBX8ui1: 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved)
+tfXRGB8ui1: 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue)
+tfRGB10X2ui1: 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved)
+tfX2RGB10ui1: 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue)
+tfRGB16us3: 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue)
+tfRGBA4us1: 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha)
+tfARGB4us1: 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue)
+tfRGB5A1us1: 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha)
+tfA1RGB5us1: 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue)
+tfRGBA8ui1: 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha)
+tfARGB8ui1: 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue)
+tfRGBA8ub4: 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha)
+tfRGB10A2ui1: 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha)
+tfA2RGB10ui1: 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue)
+tfRGBA16us4: 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha)
+tfBGRX4us1: 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved)
+tfXBGR4us1: 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red)
+tfB5G6R5us1: 1 x unsigned short (5bit blue, 6bit green, 5bit red)
+tfBGR5X1us1: 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved)
+tfX1BGR5us1: 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red)
+tfBGR8ub3: 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red)
+tfBGRX8ui1: 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved)
+tfXBGR8ui1: 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red)
+tfBGR10X2ui1: 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved)
+tfX2BGR10ui1: 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red)
+tfBGR16us3: 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red)
+tfBGRA4us1: 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha)
+tfABGR4us1: 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red)
+tfBGR5A1us1: 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha)
+tfA1BGR5us1: 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red)
+tfBGRA8ui1: 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha)
+tfABGR8ui1: 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red)
+tfBGRA8ub4: 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha)
+tfBGR10A2ui1: 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha)
+tfA2BGR10ui1: 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red)
+tfBGRA16us4: 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha)
+tfDepth16us1: 1 x unsigned short (depth)
+tfDepth24ui1: 1 x unsigned int (depth)
+tfDepth32ui1: 1 x unsigned int (depth)
+tfS3tcDtx1RGBA:
+tfS3tcDtx3RGBA:
+tfS3tcDtx5RGBA:

+ + + + + +

TglBitmapFileType = (...);

+Portable Network Graphic file (PNG)

Values

+ftDDS: Direct Draw Surface file (DDS)
+ftTGA: Targa Image File (TGA)
+ftBMP: Windows Bitmap File (BMP)
+ftRAW: glBitmap RAW file format

+ + + + + +

TglBitmapFileTypes = set of TglBitmapFileType;

+ + + + + +

TglBitmapMipMap = (...);

+possible mipmap types

Values

+mmNone: no mipmaps
+mmMipmap: normal mipmaps
+mmMipmapGlu: mipmaps generated with glu functions

+ + + + + +

TglBitmapNormalMapFunc = (...);

+possible normal map functions

Values

+nm4Samples:
+nmSobel:
+nm3x3:
+nm5x5:

+ + + + + +

PglBitmapPixelData = ˆTglBitmapPixelData;

+ + + + + +

TglBitmapSizeFields = set of (ffX, ffY);

+ + + + + +

TglBitmapPixelPosition = TglBitmapSize;

+ + + + + +

TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);

+callback to use for converting texture data

Constants

+ + + + + +

NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0);

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/index.html b/doc/index.html new file mode 100644 index 0000000..d165995 --- /dev/null +++ b/doc/index.html @@ -0,0 +1,31 @@ + + + +All Units + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

All Units

+ + + + + + + + + +

Name Description

glBitmap

glBitmap by Steffen Xonna aka Lossy eX (2003-2008) http://www.opengl24.de/index.php?cat=header&file=glbitmap + +

modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + +

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/legend.html b/doc/legend.html new file mode 100644 index 0000000..e2df3a3 --- /dev/null +++ b/doc/legend.html @@ -0,0 +1,53 @@ + + + +Legend + + + + + +

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

Legend

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Marker	Visibility
	Strict Private
	Private
	Strict Protected
	Protected
	Public
	Published
	Automated
	Implicit

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 + +

diff --git a/doc/pasdoc.css b/doc/pasdoc.css new file mode 100644 index 0000000..81e3138 --- /dev/null +++ b/doc/pasdoc.css @@ -0,0 +1,171 @@ +body, html, table.container { + margin: 0; + padding: 0; +} + +body { + font-family: Verdana,Arial; + color: black; + background-color: white; + font-size: 12px; +} + +table.container { + width: 100%; + border-spacing: 0; +} +table.container td { + vertical-align: top; +} + +td.navigation { + width: 200px; + color: white; + background-color: #787878; + margin: 0; + /* padding-bottom is a little larger, to make navigation column have some + nice height even when td.content column is very small. */ + padding: 1em 1em 100px 1em; +} +td.navigation p { padding: 0; } +td.navigation h2 { margin-top: 0; } + +td.content { padding: 1em; } +td.content h1 { margin-top: 0; } + +img { border:0px; } + +a:link {color:#C91E0C; text-decoration: none; } +a:visited {color:#7E5C31; text-decoration: none; } +a:hover {text-decoration: underline; } +a:active {text-decoration: underline; } + +a.navigation:link { color: white; text-decoration: none; } +a.navigation:visited { color: white; text-decoration: none; } +a.navigation:hover { color: white; font-weight: bold; text-decoration: none; } +a.navigation:active { color: white; text-decoration: none; } + +a.bold:link {color:#C91E0C; text-decoration: none; font-weight:bold; } +a.bold:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } +a.bold:hover {text-decoration: underline; font-weight:bold; } +a.bold:active {text-decoration: underline; font-weight:bold; } + +a.section {color: green; text-decoration: none; font-weight: bold; } +a.section:hover {color: green; text-decoration: underline; font-weight: bold; } + +ul.useslist a:link {color:#C91E0C; text-decoration: none; font-weight:bold; } +ul.useslist a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } +ul.useslist a:hover {text-decoration: underline; font-weight:bold; } +ul.useslist a:active {text-decoration: underline; font-weight:bold; } + +ul.hierarchy { list-style-type:none; } +ul.hierarchylevel { list-style-type:none; } + +p.unitlink a:link {color:#C91E0C; text-decoration: none; font-weight:bold; } +p.unitlink a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } +p.unitlink a:hover {text-decoration: underline; font-weight:bold; } +p.unitlink a:active {text-decoration: underline; font-weight:bold; } + +tr.list { background: #FFBF44; } +tr.list2 { background: #FFC982; } +tr.listheader { background: #C91E0C; color: white; } + +table.wide_list { border-spacing:2px; width:100%; } +table.wide_list td { vertical-align:top; padding:4px; } + +table.markerlegend { width:auto; } +table.markerlegend td.legendmarker { text-align:center; } + +table.sections { background:white; } +table.sections td {background:lightgray; } + +table.summary td.itemcode { width:100%; } +table.detail td.itemcode { width:100%; } + +td.itemname {white-space:nowrap; } +td.itemunit {white-space:nowrap; } +td.itemdesc { width:100%; } + +div.nodescription { color:red; } +dl.parameters dt { color:blue; } + +/* Various browsers have various default styles for

, + sometimes ugly for our purposes, so it's best to set things + like font-size and font-weight in out pasdoc.css explicitly. / +h6.description_section { + / font-size 100% means that it has the same font size as the + parent element, i.e. normal description text / + font-size: 100%; + font-weight: bold; + / By default browsers usually have some large margin-bottom and + margin-top for tags. In our case, margin-bottom is + unnecessary, we want to visually show that description_section + is closely related to content below. In this situation + (where the font size is just as a normal text), smaller bottom + margin seems to look good. / + margin-bottom: 0em; +} + +/ Style applied to Pascal code in documentation + (e.g. produced by @longcode tag) } / +span.pascal_string { color: #000080; } +span.pascal_keyword { font-weight: bolder; } +span.pascal_comment { color: #000080; font-style: italic; } +span.pascal_compiler_comment { color: #008000; } +span.pascal_numeric { } +span.pascal_hex { } + +p.hint_directive { color: red; } + +input#search_text { } +input#search_submit_button { } + +acronym.mispelling { background-color: #ffa; } + +/ Actually this reduces vertical space between every paragraph + inside list with @itemSpacing(compact). + While we would like to reduce this space only for the + top of 1st and bottom of last paragraph within each list item. + But, well, user probably will not do any paragraph breaks + within a list with @itemSpacing(compact) anyway, so it's + acceptable solution. / +ul.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } +ol.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } +dl.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } + +/ Style for table created by @table tags: + just some thin border. + + This way we have some borders around the cells + (so cells are visibly separated), but the border + "blends with the background" so it doesn't look too ugly. + Hopefully it looks satisfactory in most cases and for most + people. + + We add padding for cells, otherwise they look too close. + This is normal thing to do when border-collapse is set to + collapse (because this eliminates spacing between cells). +/ +table.table_tag { border-collapse: collapse; } +table.table_tag td { border: 1pt solid gray; padding: 0.3em; } +table.table_tag th { border: 1pt solid gray; padding: 0.3em; } + +table.detail { + border: 1pt solid gray; + margin-top: 0.3em; + margin-bottom: 0.3em; +} + +.search-form { white-space: nowrap; } +.search-input, .search-button { display: inline-block; vertical-align: middle; } + +/ Do not make extra vertical space at the beginning/end of table cells. + We need ">" selector, to not change paragraphs inside lists inside + table cells. / +table.table_tag td > p:first-child, +table.table_tag th > p:first-child, + td.itemdesc > p:first-child { margin-top: 0em; } + +table.table_tag td > p:last-child, +table.table_tag th > p:last-child, + td.itemdesc > p:last-child { margin-bottom: 0em; } diff --git a/doc/private.gif b/doc/private.gif new file mode 100644 index 0000000..dca4ce2 Binary files /dev/null and b/doc/private.gif differ diff --git a/doc/protected.gif b/doc/protected.gif new file mode 100644 index 0000000..96cc382 Binary files /dev/null and b/doc/protected.gif differ diff --git a/doc/public.gif b/doc/public.gif new file mode 100644 index 0000000..89f1197 Binary files /dev/null and b/doc/public.gif differ diff --git a/doc/published.gif b/doc/published.gif new file mode 100644 index 0000000..6ed9af6 Binary files /dev/null and b/doc/published.gif differ diff --git a/examples/GrabScreen/GrabScreen.lpi b/examples/GrabScreen/GrabScreen.lpi new file mode 100644 index 0000000..de9d899 --- /dev/null +++ b/examples/GrabScreen/GrabScreen.lpi @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + <UseAppBundle Value="False"/> + <ResourceType Value="res"/> + </General> + <i18n> + <EnableI18N LFM="False"/> + </i18n> + <VersionInfo> + <StringTable ProductVersion=""/> + </VersionInfo> + <BuildModes Count="1"> + <Item1 Name="Default" Default="True"/> + </BuildModes> + <PublishOptions> + <Version Value="2"/> + </PublishOptions> + <RunParams> + <local> + <FormatVersion Value="1"/> + </local> + </RunParams> + <Units Count="4"> + <Unit0> + <Filename Value="GrabScreen.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="GrabScreen"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="dglOpenGL"/> + </Unit1> + <Unit2> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Helper"/> + </Unit2> + <Unit3> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="glBitmap"/> + </Unit3> + </Units> + </ProjectOptions> + <CompilerOptions> + <Version Value="11"/> + <PathDelim Value="\"/> + <Target> + <Filename Value="GrabScreen"/> + </Target> + <SearchPaths> + <IncludeFiles Value="$(ProjOutDir)"/> + <OtherUnitFiles Value="..;..\.."/> + <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/> + </SearchPaths> + </CompilerOptions> + <Debugging> + <Exceptions Count="3"> + <Item1> + <Name Value="EAbort"/> + </Item1> + <Item2> + <Name Value="ECodetoolError"/> + </Item2> + <Item3> + <Name Value="EFOpenError"/> + </Item3> + </Exceptions> + </Debugging> +</CONFIG> diff --git a/examples/GrabScreen/GrabScreen.lpr b/examples/GrabScreen/GrabScreen.lpr new file mode 100644 index 0000000..c3b7b77 --- /dev/null +++ b/examples/GrabScreen/GrabScreen.lpr @@ -0,0 +1,58 @@ +program SimpleLoadFromFile; + +{$mode objfpc}{$H+} + +uses + {$IFDEF UNIX}{$IFDEF UseCThreads} + cthreads, + {$ENDIF}{$ENDIF} + Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper; + +var + oglWindow: TOpenGLWindow; + running: Boolean = true; + +function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; +var + tex: TglBitmap2D; +begin + case Msg of + WM_DESTROY: begin + running := false; + end; + + WM_KEYDOWN: begin + if wParam = VK_RETURN then begin + tex := TglBitmap2D.Create; // create empty texture + try + tex.GrabScreen(0, 0, 800, 600, tfRGB8ub3); // copy current framebuffer content to texture + tex.SaveToFile(ExtractFilePath(ApplicationName) + 'screen.bmp', ftBMP); // save texture to file + WriteLn('screen saved to screen.bmp'); + finally + FreeAndNil(tex); + end; + end; + end; + end; + result := DefWindowProc(hWnd, Msg, wParam, lParam); +end; + +procedure RenderLoop; +begin + glBegin(GL_TRIANGLES); + glColor4f(1, 0, 0, 1); glVertex2f(400, 100); + glColor4f(0, 1, 0, 1); glVertex2f(100, 500); + glColor4f(0, 0, 1, 1); glVertex2f(700, 500); + glEnd; +end; + +begin + oglWindow := CreateOpenGLWindow('GrapScreen (hit enter to grab screen)', 800, 600, @WindowProc); + while running and ProgressMesages do begin + RenderLoop; + SwapBuffers(oglWindow.DC); + end; + DestroyOpenGLWindow(oglWindow); +end. + + diff --git a/examples/GrabScreen/GrabScreen.lps b/examples/GrabScreen/GrabScreen.lps new file mode 100644 index 0000000..dd7a9c5 --- /dev/null +++ b/examples/GrabScreen/GrabScreen.lps @@ -0,0 +1,77 @@ +<?xml version="1.0" encoding="UTF-8"?> +<CONFIG> + <ProjectSession> + <PathDelim Value="\"/> + <Version Value="9"/> + <BuildModes Active="Default"/> + <Units Count="4"> + <Unit0> + <Filename Value="GrabScreen.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="GrabScreen"/> + <IsVisibleTab Value="True"/> + <TopLine Value="15"/> + <CursorPos X="25" Y="30"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="dglOpenGL"/> + <EditorIndex Value="-1"/> + <UsageCount Value="20"/> + </Unit1> + <Unit2> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Helper"/> + <EditorIndex Value="1"/> + <TopLine Value="37"/> + <CursorPos X="40" Y="36"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit2> + <Unit3> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="glBitmap"/> + <EditorIndex Value="2"/> + <TopLine Value="8731"/> + <CursorPos X="9" Y="8903"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit3> + </Units> + <JumpHistory Count="7" HistoryIndex="6"> + <Position1> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="14" Column="9"/> + </Position1> + <Position2> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="16" Column="27"/> + </Position2> + <Position3> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="45" Column="106" TopLine="21"/> + </Position3> + <Position4> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="52" Column="18" TopLine="27"/> + </Position4> + <Position5> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="55" Column="6" TopLine="26"/> + </Position5> + <Position6> + <Filename Value="GrabScreen.lpr"/> + <Caret Line="47" Column="46" TopLine="24"/> + </Position6> + <Position7> + <Filename Value="..\Helper.pas"/> + <Caret Line="39" Column="13" TopLine="17"/> + </Position7> + </JumpHistory> + </ProjectSession> +</CONFIG> diff --git a/examples/Helper.pas b/examples/Helper.pas new file mode 100644 index 0000000..5311e5c --- /dev/null +++ b/examples/Helper.pas @@ -0,0 +1,91 @@ +unit Helper; + +{$mode objfpc}{$H+} + +interface + +uses + Classes, SysUtils, Windows, dglOpenGL; + +type + TOpenGLWindow = packed record + LWndClass: TWndClass; + hMainHandle: HWND; + DC: HDC; + RC: HGLRC; + end; + +function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow; +function ProgressMesages: Boolean; +procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow); + +implementation + +function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow; +begin + //create the window + result.LWndClass.hInstance := hInstance; + with result.LWndClass do begin + lpszClassName := 'MyWinApiWnd'; + Style := CS_PARENTDC or CS_BYTEALIGNCLIENT; + hIcon := LoadIcon(hInstance,'MAINICON'); + lpfnWndProc := aWndProc; + hbrBackground := COLOR_BTNFACE+1; + hCursor := LoadCursor(0,IDC_ARROW); + end; + RegisterClass(result.LWndClass); + result.hMainHandle := CreateWindow( + result.LWndClass.lpszClassName, + PAnsiChar(aCaption), + WS_CAPTION or WS_MINIMIZEBOX or WS_SYSMENU or WS_VISIBLE, + (GetSystemMetrics(SM_CXSCREEN) - aWidth) div 2, + (GetSystemMetrics(SM_CYSCREEN) - aHeight) div 2, + aWidth, aHeight, 0, 0, hInstance, nil); + + // create and activate rendering context + result.DC := GetDC(result.hMainHandle); + if (result.DC = 0) then begin + WriteLn('unable to get DeviceContext'); + halt; + end; + result.RC := CreateRenderingContext(result.DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0); + if (result.RC = 0) then begin + WriteLn('unable to create RenderingContext'); + halt; + end; + ActivateRenderingContext(result.DC, result.RC); + + // init OpenGL + glViewport(0, 0, aWidth, aHeight); + glClearColor(0, 0, 0, 0); + glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); + + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity; + glOrtho(0, aWidth, aHeight, 0, -10, 10); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity; +end; + +function ProgressMesages: Boolean; +var + Msg: TMSG; +begin + result := GetMessage(Msg, 0, 0, 0); + if result then begin + TranslateMessage(Msg); + DispatchMessage(Msg); + end; +end; + +procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow); +begin + DestroyRenderingContext(aWindow.RC); + ReleaseDC(aWindow.hMainHandle, aWindow.DC); +end; + +end. + diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi new file mode 100644 index 0000000..cc27760 --- /dev/null +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi @@ -0,0 +1,81 @@ +<?xml version="1.0" encoding="UTF-8"?> +<CONFIG> + <ProjectOptions> + <Version Value="9"/> + <PathDelim Value="\"/> + <General> + <Flags> + <MainUnitHasCreateFormStatements Value="False"/> + <MainUnitHasTitleStatement Value="False"/> + </Flags> + <SessionStorage Value="InProjectDir"/> + <MainUnit Value="0"/> + <Title Value="SimpleLoadFromFile"/> + <UseAppBundle Value="False"/> + <ResourceType Value="res"/> + </General> + <i18n> + <EnableI18N LFM="False"/> + </i18n> + <VersionInfo> + <StringTable ProductVersion=""/> + </VersionInfo> + <BuildModes Count="1"> + <Item1 Name="Default" Default="True"/> + </BuildModes> + <PublishOptions> + <Version Value="2"/> + </PublishOptions> + <RunParams> + <local> + <FormatVersion Value="1"/> + </local> + </RunParams> + <Units Count="4"> + <Unit0> + <Filename Value="SimpleLoadFromFile.lpr"/> + <IsPartOfProject Value="True"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="dglOpenGL"/> + </Unit1> + <Unit2> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="glBitmap"/> + </Unit2> + <Unit3> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Helper"/> + </Unit3> + </Units> + </ProjectOptions> + <CompilerOptions> + <Version Value="11"/> + <PathDelim Value="\"/> + <Target> + <Filename Value="SimpleLoadFromFile"/> + </Target> + <SearchPaths> + <IncludeFiles Value="$(ProjOutDir)"/> + <OtherUnitFiles Value="..;..\.."/> + <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/> + </SearchPaths> + </CompilerOptions> + <Debugging> + <Exceptions Count="3"> + <Item1> + <Name Value="EAbort"/> + </Item1> + <Item2> + <Name Value="ECodetoolError"/> + </Item2> + <Item3> + <Name Value="EFOpenError"/> + </Item3> + </Exceptions> + </Debugging> +</CONFIG> diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr new file mode 100644 index 0000000..cb7cc15 --- /dev/null +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr @@ -0,0 +1,56 @@ +program SimpleLoadFromFile; + +{$mode objfpc}{$H+} + +uses + {$IFDEF UNIX}{$IFDEF UseCThreads} + cthreads, + {$ENDIF}{$ENDIF} + Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper; + +var + oglWindow: TOpenGLWindow; + running: Boolean = true; + tex: TglBitmap2D; + +function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; +begin + case Msg of + WM_DESTROY: begin + running := false; + end; + end; + result := DefWindowProc(hWnd, Msg, wParam, lParam); +end; + +procedure RenderLoop; +begin + tex.Bind(); + glColor4f(1, 1, 1, 1); + glBegin(GL_QUADS); + glTexCoord2f(0, 0); glVertex2f(100, 100); + glTexCoord2f(1, 0); glVertex2f(700, 100); + glTexCoord2f(1, 1); glVertex2f(700, 500); + glTexCoord2f(0, 1); glVertex2f(100, 500); + glEnd; + tex.Unbind(); +end; + +begin + oglWindow := CreateOpenGLWindow('SimpleLoadFromFile', 800, 600, @WindowProc); + try + // load texture + tex := TglBitmap2D.Create; + tex.LoadFromFile(ExtractFilePath(ApplicationName) + '../textures/BMP_24_RGB8.bmp'); + tex.GenTexture; + + while running and ProgressMesages do begin + RenderLoop; + SwapBuffers(oglWindow.DC); + end; + finally + FreeAndNil(tex); + DestroyOpenGLWindow(oglWindow); + end; +end. + diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps new file mode 100644 index 0000000..84a19dc --- /dev/null +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps @@ -0,0 +1,34 @@ +<?xml version="1.0" encoding="UTF-8"?> +<CONFIG> + <ProjectSession> + <PathDelim Value="\"/> + <Version Value="9"/> + <BuildModes Active="Default"/> + <Units Count="4"> + <Unit0> + <Filename Value="SimpleLoadFromFile.lpr"/> + <IsPartOfProject Value="True"/> + <IsVisibleTab Value="True"/> + <TopLine Value="22"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UsageCount Value="20"/> + </Unit1> + <Unit2> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UsageCount Value="20"/> + </Unit2> + <Unit3> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UsageCount Value="20"/> + </Unit3> + </Units> + <JumpHistory HistoryIndex="-1"/> + </ProjectSession> +</CONFIG> diff --git a/examples/TextureFromFunction/TextureFromFunction.lpi b/examples/TextureFromFunction/TextureFromFunction.lpi new file mode 100644 index 0000000..3852d10 --- /dev/null +++ b/examples/TextureFromFunction/TextureFromFunction.lpi @@ -0,0 +1,82 @@ +<?xml version="1.0" encoding="UTF-8"?> +<CONFIG> + <ProjectOptions> + <Version Value="9"/> + <PathDelim Value="\"/> + <General> + <Flags> + <MainUnitHasCreateFormStatements Value="False"/> + <MainUnitHasTitleStatement Value="False"/> + </Flags> + <SessionStorage Value="InProjectDir"/> + <MainUnit Value="0"/> + <Title Value="TextureFromFunction"/> + <UseAppBundle Value="False"/> + <ResourceType Value="res"/> + </General> + <i18n> + <EnableI18N LFM="False"/> + </i18n> + <VersionInfo> + <StringTable ProductVersion=""/> + </VersionInfo> + <BuildModes Count="1"> + <Item1 Name="Default" Default="True"/> + </BuildModes> + <PublishOptions> + <Version Value="2"/> + </PublishOptions> + <RunParams> + <local> + <FormatVersion Value="1"/> + </local> + </RunParams> + <Units Count="4"> + <Unit0> + <Filename Value="TextureFromFunction.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="TextureFromFunction"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="dglOpenGL"/> + </Unit1> + <Unit2> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Helper"/> + </Unit2> + <Unit3> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="glBitmap"/> + </Unit3> + </Units> + </ProjectOptions> + <CompilerOptions> + <Version Value="11"/> + <PathDelim Value="\"/> + <Target> + <Filename Value="TextureFromFunction"/> + </Target> + <SearchPaths> + <IncludeFiles Value="$(ProjOutDir)"/> + <OtherUnitFiles Value="..;..\.."/> + <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/> + </SearchPaths> + </CompilerOptions> + <Debugging> + <Exceptions Count="3"> + <Item1> + <Name Value="EAbort"/> + </Item1> + <Item2> + <Name Value="ECodetoolError"/> + </Item2> + <Item3> + <Name Value="EFOpenError"/> + </Item3> + </Exceptions> + </Debugging> +</CONFIG> diff --git a/examples/TextureFromFunction/TextureFromFunction.lpr b/examples/TextureFromFunction/TextureFromFunction.lpr new file mode 100644 index 0000000..f960c25 --- /dev/null +++ b/examples/TextureFromFunction/TextureFromFunction.lpr @@ -0,0 +1,95 @@ +program SimpleLoadFromFile; + +{$mode objfpc}{$H+} + +uses + {$IFDEF UNIX}{$IFDEF UseCThreads} + cthreads, + {$ENDIF}{$ENDIF} + Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper; + +var + oglWindow: TOpenGLWindow; + running: Boolean = true; + tex: TglBitmap2D; + +function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; +begin + case Msg of + WM_DESTROY: begin + running := false; + end; + end; + result := DefWindowProc(hWnd, Msg, wParam, lParam); +end; + +procedure RenderLoop; +begin + tex.Bind(); + glColor4f(1, 1, 1, 1); + glBegin(GL_QUADS); + glTexCoord2f(0, 0); glVertex2f(100, 100); + glTexCoord2f(1, 0); glVertex2f(700, 100); + glTexCoord2f(1, 1); glVertex2f(700, 500); + glTexCoord2f(0, 1); glVertex2f(100, 500); + glEnd; + tex.Unbind(); +end; + +{ function to generate texture data } +procedure GenerateTextureFunc1(var FuncRec: TglBitmapFunctionRec); +var + g1, g2, g3, g4: Single; +begin + g1 := (sin(FuncRec.Position.X / 25) + 1) / 2; // generator function 1: large sinus on x position (0.0 to 1.0) + g2 := (sin(FuncRec.Position.Y / 25) + 1) / 2; // generator function 2: large sinus on y position (0.0 to 1.0) + g3 := FuncRec.Position.X / FuncRec.Size.X; // generator function 3: linear fade on x position (0.0 to 1.0) + g4 := FuncRec.Position.Y / FuncRec.Size.Y; // generator function 4: linear fade on y position (0.0 to 1.0) + + FuncRec.Dest.Data.r := Trunc(g1 FuncRec.Dest.Range.r); + FuncRec.Dest.Data.g := Trunc(g2 * FuncRec.Dest.Range.g); + FuncRec.Dest.Data.b := Trunc(g3 * FuncRec.Dest.Range.b); + FuncRec.Dest.Data.a := Trunc(g4 * FuncRec.Dest.Range.a); +end; + +{ function to generate texture data } +procedure GenerateTextureFunc2(var FuncRec: TglBitmapFunctionRec); +var + x, y: Single; +begin + x := FuncRec.Position.X / FuncRec.Size.X; + y := FuncRec.Position.Y / FuncRec.Size.Y; + if (x < 0.05) or (x > 0.95) or (y < 0.05) or (y > 0.95) then + begin + FuncRec.Dest.Data := FuncRec.Dest.Range; + end else if (y < 0.333) then begin + FuncRec.Dest.Data := glBitmapRec4ui(0, 0, 0, 0); + end else if (y < 0.666) then begin + FuncRec.Dest.Data := glBitmapRec4ui(FuncRec.Dest.Range.r, 0, 0, 0); + end else begin + FuncRec.Dest.Data := glBitmapRec4ui(FuncRec.Dest.Range.r, FuncRec.Dest.Range.g, 0, 0); + end; +end; + +begin + oglWindow := CreateOpenGLWindow('TextureFromFunction', 800, 600, @WindowProc); + try + // create texture use either GenerateTextureFunc1 or GenerateTextureFunc2 + tex := TglBitmap2D.Create( + glBitmapSize(512, 512), + tfRGBA8ub4, + @GenerateTextureFunc1 + //@GenerateTextureFunc2 + ); + tex.GenTexture; + + while running and ProgressMesages do begin + RenderLoop; + SwapBuffers(oglWindow.DC); + end; + finally + FreeAndNil(tex); + DestroyOpenGLWindow(oglWindow); + end; +end. + diff --git a/examples/TextureFromFunction/TextureFromFunction.lps b/examples/TextureFromFunction/TextureFromFunction.lps new file mode 100644 index 0000000..e3c3fb0 --- /dev/null +++ b/examples/TextureFromFunction/TextureFromFunction.lps @@ -0,0 +1,86 @@ +<?xml version="1.0" encoding="UTF-8"?> +<CONFIG> + <ProjectSession> + <PathDelim Value="\"/> + <Version Value="9"/> + <BuildModes Active="Default"/> + <Units Count="5"> + <Unit0> + <Filename Value="TextureFromFunction.lpr"/> + <IsPartOfProject Value="True"/> + <UnitName Value="TextureFromFunction"/> + <IsVisibleTab Value="True"/> + <TopLine Value="59"/> + <CursorPos X="9" Y="81"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit0> + <Unit1> + <Filename Value="..\dglOpenGL.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="dglOpenGL"/> + <EditorIndex Value="2"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit1> + <Unit2> + <Filename Value="..\Helper.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="Helper"/> + <EditorIndex Value="3"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit2> + <Unit3> + <Filename Value="..\..\glBitmap.pas"/> + <IsPartOfProject Value="True"/> + <UnitName Value="glBitmap"/> + <EditorIndex Value="1"/> + <TopLine Value="852"/> + <CursorPos X="67" Y="869"/> + <UsageCount Value="20"/> + <Loaded Value="True"/> + </Unit3> + <Unit4> + <Filename Value="..\SimpleLoadFromFile\SimpleLoadFromFile.lpr"/> + <UnitName Value="SimpleLoadFromFile"/> + <EditorIndex Value="-1"/> + <TopLine Value="23"/> + <CursorPos Y="56"/> + <UsageCount Value="10"/> + </Unit4> + </Units> + <JumpHistory Count="8" HistoryIndex="6"> + <Position1> + <Filename Value="TextureFromFunction.lpr"/> + </Position1> + <Position2> + <Filename Value="..\..\glBitmap.pas"/> + </Position2> + <Position3> + <Filename Value="TextureFromFunction.lpr"/> + <Caret Line="44" Column="62" TopLine="23"/> + </Position3> + <Position4> + <Filename Value="..\..\glBitmap.pas"/> + <Caret Line="1474" Column="3" TopLine="1445"/> + </Position4> + <Position5> + <Filename Value="..\..\glBitmap.pas"/> + <Caret Line="874" Column="3" TopLine="1340"/> + </Position5> + <Position6> + <Filename Value="TextureFromFunction.lpr"/> + <Caret Line="59" TopLine="29"/> + </Position6> + <Position7> + <Filename Value="TextureFromFunction.lpr"/> + <Caret Line="62" Column="32" TopLine="46"/> + </Position7> + <Position8> + <Filename Value="TextureFromFunction.lpr"/> + <Caret Line="91" TopLine="58"/> + </Position8> + </JumpHistory> + </ProjectSession> +</CONFIG> diff --git a/examples/dglOpenGL.pas b/examples/dglOpenGL.pas new file mode 100644 index 0000000..7772eee --- /dev/null +++ b/examples/dglOpenGL.pas @@ -0,0 +1,20081 @@ +{ ============================================================================ + + OpenGL 4.4 - Headertranslation + Version 4.4 + Date : 2013/07/22 + + Supported environments and targets : + - (Win32) Delphi 4 and up + - (Win32, Win64) Delphi XE2 + - (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up) + +============================================================================== + + Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h. + It also contains some helperfunctions that were inspired by those + found in Mike Lischke's OpenGL12.pas. + + Copyright (C) DGL-OpenGL2-Portteam + All Rights Reserved + + Obtained through: + Delphi OpenGL Community(DGL) - www.delphigl.com + + Converted and maintained by DGL's GL2.0-Team : + - Sascha Willems - http://www.saschawillems.de + - Steffen Xonna (Lossy eX) - http://www.dev-center.de + Additional input : + - Andrey Gruzdev (Mac OS X patch for XE2 / FPC) + - Lars Middendorf + - Martin Waldegger (Mars) + - Benjamin Rosseaux (BeRo) - http://www.0ok.de + Additional thanks: + sigsegv (libdl.so) + +============================================================================== + You may retrieve the latest version of this file at the Delphi OpenGL + Community home page, located at http://www.delphigl.com/ + + The contents of this file are used with permission, subject to + the Mozilla Public License Version 1.1 (the "License"); you may + not use this file except in compliance with the License. You may + obtain a copy of the License at + http://www.mozilla.org/MPL/MPL-1.1.html + + Software distributed under the License is distributed on an + "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + +============================================================================== + History : + Version 1.0 Initial Release + Version 1.1 Added PPointer in Tpyessection for compatiblity with Delphi + versions lower than 7 (SW) + Added a function named RaiseLastOSError including a comment + on how to make it run under Delphi versions lower than 7 (SW) + Added some data types according to the GL-Syntax (SW) + Version 1.2 Fixed some problems with getting the addresses of some + Extensions (e.g. glTexImage3D) where the EXT/ARB did work + but not the core-functions (SW) + Version 1.3 A second call to ReadimplementationProperties won't + revert to the default libs anymore (MW) + Libraries now will be released if necessary (MW) + Version 1.3a Small fixes for glSlang-functions (SW) + Version 1.3b Fixed a small bug with GL_ARB_shader_objects, that lead + lead to that extension not loaded correctly (SW) + Version 1.3c more GL 1.5 compliance by FOG_COORD_xx and + ARB less VBO and occlusion query routines (MW) + Version 1.3d Fixed linebreaks (should now be corrected under D5) (SW) + Version 1.4 Changed header to correspond to the OpenGL-Shading + Language specification 1.10 : + - Added new GL_SAMPLER_-Constants + - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB + - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB + - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW) + Version 1.4a Fixed a missing stdcall for glBindAttribLocationARB (SW) + Version 1.4b Fixed declaration for glUniform(f/i)vARB (added count) (MW) + glCompileShaderARB changed from function to procedure (MW) + Version 1.5 Added support for FreePascal (BR) + Added type TGLVectorf3/TGLVector3f (SW) + Version 1.6 Added Extension GL_EXT_framebuffer_object (SX) + Version 1.7 Added Extension GL_ARB_fragment_program_shadow (SX) + Added Extension GL_ARB_draw_buffers (SX) + Added Extension GL_ARB_texture_rectangle (SX) + Added Extension GL_ARB_color_buffer_float (SX) + Added Extension GL_ARB_half_float_pixel (SX) + Added Extension GL_ARB_texture_float (SX) + Added Extension GL_ARB_pixel_buffer_object (SX) + Added Extension GL_EXT_depth_bounds_test (SX) + Added Extension GL_EXT_texture_mirror_clamp (SX) + Added Extension GL_EXT_blend_equation_separate (SX) + Added Extension GL_EXT_pixel_buffer_object (SX) + Added Extension GL_EXT_texture_compression_dxt1 (SX) + Added Extension GL_NV_fragment_program_option (SX) + Added Extension GL_NV_fragment_program2 (SX) + Added Extension GL_NV_vertex_program2_option (SX) + Added Extension GL_NV_vertex_program3 (SX) + Version 1.8 Added explicit delegate type definitions (LM) + Added .Net 1.1 Support (LM) + Added .Net overloaded functions (LM) + Added delayed extension loading and stubs (LM) + Added automatic InitOpenGL call in CreateRenderingContext(LM) + Added extra Read_* function (LM) + Version 2.0 fixed some Problem with version string and damn drivers. + String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX) + Removed unexisting extension GL_ARB_texture_mirror_repeat(SX) + Added Extension WGL_ARB_pixel_format_float (SX) + Added Extension GL_EXT_stencil_clear_tag (SX) + Added Extension GL_EXT_texture_rectangle (SX) + Added Extension GL_EXT_texture_edge_clamp (SX) + Some 1.5 Core Consts added (now completed) (SX) + gluProject need pointer for not .net (SX) + gluUnProject need pointer for not .net (SX) + wglUseFontOutlines* need pointer for not .net (SX) + wglSwapMultipleBuffers need pointer for not .net (SX) + Bug with wglGetExtensionsStringEXT removed + different type for .net (SX) + Added OpenGL 2.0 Core (SX) + Version 2.0.1 fixed some problems with glGetActiveAttrib in 2.0 Core (SX) + fixes some problems with gluProject (SX) + fixes some problems with gluUnProject (SX) + fixes some problems with gluTessVertex (SX) + fixes some problems with gluLoadSamplingMatrices (SX) + Version 2.1 Removed .NET Support (SX) + Better support for Linux (SX) + Better Codeformation (SX) + Added some more Vector/Matrix types (SX) + Added OpenGL 2.1 Core (SX) + Added Extension GL_EXT_packed_depth_stencil (SX) + Added Extension GL_EXT_texture_sRGB (SX) + Added Extension GL_EXT_framebuffer_blit (SX) + Added Extension GL_EXT_framebuffer_multisample (SX) + Added Extension GL_EXT_timer_query (SX) + Added Extension GL_EXT_gpu_program_parameters (SX) + Added Extension GL_EXT_bindable_uniform (SX) + Added Extension GL_EXT_draw_buffers2 (SX) + Added Extension GL_EXT_draw_instanced (SX) + Added Extension GL_EXT_framebuffer_sRGB (SX) + Added Extension GL_EXT_geometry_shader4 (SX) + Added Extension GL_EXT_gpu_shader4 (SX) + Added Extension GL_EXT_packed_float (SX) + Added Extension GL_EXT_texture_array (SX) + Added Extension GL_EXT_texture_buffer_object (SX) + Added Extension GL_EXT_texture_compression_latc (SX) + Added Extension GL_EXT_texture_compression_rgtc (SX) + Added Extension GL_EXT_texture_integer (SX) + Added Extension GL_EXT_texture_shared_exponent (SX) + Added Extension GL_NV_depth_buffer_float (SX) + Added Extension GL_NV_fragment_program4 (SX) + Added Extension GL_NV_framebuffer_multisample_coverage (SX) + Added Extension GL_NV_geometry_program4 (SX) + Added Extension GL_NV_gpu_program4 (SX) + Added Extension GL_NV_parameter_buffer_object (SX) + Added Extension GL_NV_transform_feedback (SX) + Added Extension GL_NV_vertex_program4 (SX) + Version 3.0 fixed some const of GL_EXT_texture_shared_exponent (SX) + possible better support for mac (SX) + Added OpenGL 3.0 Core (SX) + Added Extension GL_ARB_depth_buffer_float (SX) + Added Extension GL_ARB_draw_instanced (SX) + Added Extension GL_ARB_framebuffer_object (SX) + Added Extension GL_ARB_framebuffer_sRGB (SX) + Added Extension GL_ARB_geometry_shader4 (SX) + Added Extension GL_ARB_half_float_vertex (SX) + Added Extension GL_ARB_instanced_arrays (SX) + Added Extension GL_ARB_map_buffer_range (SX) + Added Extension GL_ARB_texture_buffer_object (SX) + Added Extension GL_ARB_texture_compression_rgtc (SX) + Added Extension GL_ARB_texture_rg (SX) + Added Extension GL_ARB_vertex_array_object (SX) + Added Extension GL_NV_conditional_render (SX) + Added Extension GL_NV_present_video (SX) + Added Extension GL_EXT_transform_feedback (SX) + Added Extension GL_EXT_direct_state_access (SX) + Added Extension GL_EXT_vertex_array_bgra (SX) + Added Extension GL_EXT_texture_swizzle (SX) + Added Extension GL_NV_explicit_multisample (SX) + Added Extension GL_NV_transform_feedback2 (SX) + Added Extension WGL_ARB_create_context (SX) + Added Extension WGL_NV_present_video (SX) + Added Extension WGL_NV_video_out (SX) + Added Extension WGL_NV_swap_group (SX) + Added Extension WGL_NV_gpu_affinity (SX) + Added define DGL_TINY_HEADER to suppress automatic + function loading (SX) + glProcedure renamed to dglGetProcAddress and now it's + visible from outside the unit to custom load functions (SX) + dglCheckExtension added to check if an extension exists (SX) + Read_GL_ARB_buffer_object renamed to + Read_GL_ARB_vertex_buffer_object (SX) + Version 3.0.1 fixed an problem with fpc (SX) + Version 3.0.2 fixed an problem with WGL_ARB_create_context (SX) + Version 3.2 Functions from GL_VERSION_3_0 where updated (SX) + Functions from GL_ARB_map_buffer_range where updated (SX) + Functions from GL_NV_present_video where added (SX) + Added consts of GL_ARB_instanced_arrays (SX) + Defines to identify Delphi was changed (prevent for + feature maintenance) (SX) + Added Extension GL_ATI_meminfo (SX) + Added Extension GL_AMD_performance_monitor (SX) + Added Extension GL_AMD_texture_texture4 (SX) + Added Extension GL_AMD_vertex_shader_tesselator (SX) + Added Extension GL_EXT_provoking_vertex (SX) + Added Extension WGL_AMD_gpu_association (SX) + Added OpenGL 3.1 Core (SX) + All deprecated stuff can be disabled if you undef the + define DGL_DEPRECATED (SX) + Added Extension GL_ARB_uniform_buffer_object (SX) + Added Extension GL_ARB_compatibility (SX) + Added Extension GL_ARB_copy_buffer (SX) + Added Extension GL_ARB_shader_texture_lod (SX) + Remove function from GL_NV_present_video (SX) + Added Extension WGL_3DL_stereo_control (SX) + Added Extension GL_EXT_texture_snorm (SX) + Added Extension GL_AMD_draw_buffers_blend (SX) + Added Extension GL_APPLE_texture_range (SX) + Added Extension GL_APPLE_float_pixels (SX) + Added Extension GL_APPLE_vertex_program_evaluators (SX) + Added Extension GL_APPLE_aux_depth_stencil (SX) + Added Extension GL_APPLE_object_purgeable (SX) + Added Extension GL_APPLE_row_bytes (SX) + Added OpenGL 3.2 Core (SX) + Added Extension GL_ARB_depth_clamp (SX) + Added Extension GL_ARB_draw_elements_base_vertex (SX) + Added Extension GL_ARB_fragment_coord_conventions (SX) + Added Extension GL_ARB_provoking_vertex (SX) + Added Extension GL_ARB_seamless_cube_map (SX) + Added Extension GL_ARB_sync (SX) + Added Extension GL_ARB_texture_multisample (SX) + Added Extension GL_ARB_vertex_array_bgra (SX) + Added Extension GL_ARB_draw_buffers_blend (SX) + Added Extension GL_ARB_sample_shading (SX) + Added Extension GL_ARB_texture_cube_map_array (SX) + Added Extension GL_ARB_texture_gather (SX) + Added Extension GL_ARB_texture_query_lod (SX) + Added Extension WGL_ARB_create_context_profile (SX) + Added GLX Core up to Version 1.4 (SX) + Added Extension GLX_ARB_multisample (SX) + Added Extension GLX_ARB_fbconfig_float (SX) + Added Extension GLX_ARB_get_proc_address (SX) + Added Extension GLX_ARB_create_context (SX) + Added Extension GLX_ARB_create_context_profile (SX) + Added Extension GLX_EXT_visual_info (SX) + Added Extension GLX_EXT_visual_rating (SX) + Added Extension GLX_EXT_import_context (SX) + Added Extension GLX_EXT_fbconfig_packed_float (SX) + Added Extension GLX_EXT_framebuffer_sRGB (SX) + Added Extension GLX_EXT_texture_from_pixmap (SX) + Version 3.2.1 Fixed some problems with Delphi < 6 (SX) + Version 3.2.2 Added Extension GL_APPLE_rgb_422 (SX) + Added Extension GL_EXT_separate_shader_objects (SX) + Added Extension GL_NV_video_capture (SX) + Added Extension GL_NV_copy_image (SX) + Added Extension GL_NV_parameter_buffer_object2 (SX) + Added Extension GL_NV_shader_buffer_load (SX) + Added Extension GL_NV_vertex_buffer_unified_memory (SX) + Added Extension GL_NV_texture_barrier (SX) + Variable GL_EXT_texture_snorm will be filled (SX) + Variable GL_APPLE_row_bytes will be filled (SX) + Added Extension WGL_NV_video_capture (SX) + Added Extension WGL_NV_copy_image (SX) + WGL_NV_video_out now named WGL_NV_video_output (SX) + Added Extension GLX_EXT_swap_control (SX) + Version 3.2.3 Fixed an Problem with glGetAttribLocation (SX) + Added const GL_UNIFORM_BUFFER_EXT (SX) + Functions of GL_NV_texture_barrier now will be loaded (SX) + Version 4.0 Changes on Extension GL_ARB_texture_gather (SX) + Changes on Extension GL_NV_shader_buffer_load (SX) + Added OpenGL 3.3 Core (SX) + Added OpenGL 4.0 Core (SX) + Added Extension GL_AMD_shader_stencil_export (SX) + Added Extension GL_AMD_seamless_cubemap_per_texture (SX) + Added Extension GL_ARB_shading_language_include (SX) + Added Extension GL_ARB_texture_compression_bptc (SX) + Added Extension GL_ARB_blend_func_extended (SX) + Added Extension GL_ARB_explicit_attrib_location (SX) + Added Extension GL_ARB_occlusion_query2 (SX) + Added Extension GL_ARB_sampler_objects (SX) + Added Extension GL_ARB_shader_bit_encoding (SX) + Added Extension GL_ARB_texture_rgb10_a2ui (SX) + Added Extension GL_ARB_texture_swizzle (SX) + Added Extension GL_ARB_timer_query (SX) + Added Extension GL_ARB_vertex_type_2_10_10_10_rev (SX) + Added Extension GL_ARB_draw_indirect (SX) + Added Extension GL_ARB_gpu_shader5 (SX) + Added Extension GL_ARB_gpu_shader_fp64 (SX) + Added Extension GL_ARB_shader_subroutine (SX) + Added Extension GL_ARB_tessellation_shader (SX) + Added Extension GL_ARB_texture_buffer_object_rgb32 (SX) + Added Extension GL_ARB_transform_feedback2 (SX) + Added Extension GL_ARB_transform_feedback3 (SX) + Version 4.1 Possible fix some strange linux behavior (SX) + All function uses GL instead of TGL types (SX) + GL_AMD_vertex_shader_tesselator will be read now (SX) + GL_AMD_draw_buffers_blend will be read now (SX) + Changes on glStencilFuncSeparate (GL_2_0) (SX) + Changes on GL_VERSION_3_2 (SX) + Changes on GL_VERSION_3_3 (SX) + Changes on GL_VERSION_4_0 (SX) + Changes on GL_ARB_sample_shading (SX) + Changes on GL_ARB_texture_cube_map_array (SX) + Changes on GL_ARB_gpu_shader5 (SX) + Changes on GL_ARB_transform_feedback3 (SX) + Changes on GL_ARB_sampler_objects (SX) + Changes on GL_ARB_gpu_shader_fp64 (SX) + Changes on GL_APPLE_element_array (SX) + Changes on GL_APPLE_vertex_array_range (SX) + Changes on GL_NV_transform_feedback (SX) + Changes on GL_NV_vertex_buffer_unified_memory (SX) + Changes on GL_EXT_multi_draw_arrays (SX) + Changes on GL_EXT_direct_state_access (SX) + Changes on GL_AMD_performance_monitor (SX) + Changes on GL_AMD_seamless_cubemap_per_texture (SX) + Changes on GL_EXT_geometry_shader4 (SX) + Added OpenGL 4.1 Core (SX) + Added Extension GL_ARB_ES2_compatibility (SX) + Added Extension GL_ARB_get_program_binary (SX) + Added Extension GL_ARB_separate_shader_objects (SX) + Added Extension GL_ARB_shader_precision (SX) + Added Extension GL_ARB_vertex_attrib_64bit (SX) + Added Extension GL_ARB_viewport_array (SX) + Added Extension GL_ARB_cl_event (SX) + Added Extension GL_ARB_debug_output (SX) + Added Extension GL_ARB_robustness (SX) + Added Extension GL_ARB_shader_stencil_export (SX) + Added Extension GL_AMD_conservative_depth (SX) + Added Extension GL_EXT_shader_image_load_store (SX) + Added Extension GL_EXT_vertex_attrib_64bit (SX) + Added Extension GL_NV_gpu_program5 (SX) + Added Extension GL_NV_gpu_shader5 (SX) + Added Extension GL_NV_shader_buffer_store (SX) + Added Extension GL_NV_tessellation_program5 (SX) + Added Extension GL_NV_vertex_attrib_integer_64bit (SX) + Added Extension GL_NV_multisample_coverage (SX) + Added Extension GL_AMD_name_gen_delete (SX) + Added Extension GL_AMD_debug_output (SX) + Added Extension GL_NV_vdpau_interop (SX) + Added Extension GL_AMD_transform_feedback3_lines_triangles (SX) + Added Extension GL_AMD_depth_clamp_separate (SX) + Added Extension GL_EXT_texture_sRGB_decode (SX) + Added Extension WGL_ARB_framebuffer_sRGB (SX) + Added Extension WGL_ARB_create_context_robustness (SX) + Added Extension WGL_EXT_create_context_es2_profile (SX) + Added Extension WGL_NV_multisample_coverage (SX) + Added Extension GLX_ARB_vertex_buffer_object (SX) + Added Extension GLX_ARB_framebuffer_sRGB (SX) + Added Extension GLX_ARB_create_context_robustness (SX) + Added Extension GLX_EXT_create_context_es2_profile (SX) + Version 4.1a Fix for dglGetProcAddress with FPC and linux (def param) (SW) + Version 4.2 Added OpenGL 4.2 Core (SW) + Added Extension GL_ARB_base_instance (SW) + Added Extension GL_ARB_shading_language_420pack (SW) + Added Extension GL_ARB_transform_feedback_instanced (SW) + Added Extension GL_ARB_compressed_texture_pixel_storage (SW) + Added Extension GL_ARB_conservative_depth (SW) + Added Extension GL_ARB_internalformat_query (SW) + Added Extension GL_ARB_map_buffer_alignment (SW) + Added Extension GL_ARB_shader_atomic_counters (SW) + Added Extension GL_ARB_shader_image_load_store (SW) + Added Extension GL_ARB_shading_language_packing (SW) + Added Extension GL_ARB_texture_storage (SW) + Added Extension WGL_NV_DX_interop (SW) + Added Define for WGL_EXT_create_context_es2_profile (SW) + Version 4.2a Added Mac OS X patch by Andrey Gruzdev (SW) + Version 4.3 Added OpenGL 4.3 Core (SW) + Added GL_ARB_arrays_of_arrays (SW) + Added GL_ARB_fragment_layer_viewport (SW) + Added GL_ARB_shader_image_size (SW) + Added GL_ARB_ES3_compatibility (SW) + Added GL_ARB_clear_buffer_object (SW) + Added GL_ARB_compute_shader (SW) + Added GL_ARB_copy_image (SW) + Added GL_KHR_debug (SW) + Added GL_ARB_explicit_uniform_location, (SW) + Added GL_ARB_framebuffer_no_attachments (SW) + Added GL_ARB_internalformat_query2 (SW) + Added GL_ARB_invalidate_subdata (SW) + Added GL_ARB_multi_draw_indirect (SW) + Added GL_ARB_program_interface_query (SW) + Added GL_ARB_robust_buffer_access_behavior (SW) + Added GL_ARB_shader_storage_buffer_object (SW) + Added GL_ARB_stencil_texturing (SW) + Added GL_ARB_texture_buffer_range (SW) + Added GL_ARB_texture_query_levels (SW) + Added GL_ARB_texture_storage_multisample (SW) + Added GL_ARB_texture_view (SW) + Added GL_ARB_vertex_attrib_binding (SW) + Added new vendor-specific extensions (SW) + Added GL_NV_path_rendering (SW) + Added GL_AMD_pinned_memory (SW) + Added GL_AMD_stencil_operation_extended (SW) + Added GL_AMD_vertex_shader_viewport_index (SW) + Added GL_AMD_vertex_shader_layer (SW) + Added GL_NV_bindless_texture (SW) + Added GL_NV_shader_atomic_float (SW) + Added GL_AMD_query_buffer_object (SW) + Added CreateRenderingContextVersion (SW) + Version 4.4 Added ARB_buffer_storage (SW) + Added ARB_clear_texture extension (SW) + Added ARB_enhanced_layouts extension (SW) + Added ARB_multi_bind extension (SW) + Added ARB_query_buffer_object extension (SW) + Added ARB_texture_mirror_clamp_to_edge extension (SW) + Added ARB_texture_stencil8 extension (SW) + Added ARB_vertex_type_10f_11f_11f_rev extension (SW) + Added MAX_VERTEX_ATTRIB_STRIDE stat (SW) + Added missing functions for GL_EXT_direct_state_access (SW) + GL3.0+ uses non-deprecated way of getting extensions + (thanks to frenK) (SW) + Added missing cdecl for TglXGetVisualFromFBConfig (SW) + + +============================================================================== + Header based on glext.h rev 87 (2012-08-06) + Header based on wglext.h rev 24 (2012/01/04) + Header based on glxext.h rev 33 (2012/02/29) (only Core/ARB/EXT) + + This is an important notice for maintaining. Dont remove it. And make sure + to keep it up to date +============================================================================== } + +{$define DGL_DEPRECATED} +{ + This define defines if the header should use deprecated ARB stuff or not. + per Default the Header use deprecated Stuff. +} + + +{.$define DGL_TINY_HEADER} +{ + If you enable the define DGL_TINY_HEADER no function automatically will be loaded if you + call ActivateRenderingContext. This may some bit faster and the smart linker can delete + all non used functions. This will reduce the filesize of your binary file. But in this + case you have to load the functions by yourself. There are two ways to do this. + + 1. You can load whole extension by calling the func Read_Extensionname. But if you do + this it's possible to load functions you dont use. So you have the same "problem" + like before. But it's only an bit smaler. + > Read_GL_ARB_multitexture; + + 2. You are able to load only the functions you exactly need. In this case you are able + to use the variables of the dglOpenGL.pas. So you only need to load the functions + and you can use the header like before. + To do this you have to created and activated an opengl context and than you can load + the needed functions. + > ActivateRenderingContext(fDC, fRC); + > glActiveTextureARB := dglGetProcAddress('glActiveTextureARB'); + > glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB'); + + So only the function "glActiveTextureARB" and "glMultiTexCoord2fARB" will be loaded. + + + Please notice that the extension variables won't be loaded if this define is active. But + you can call dglCheckExtension to check if any extension exists. You can assign them to + the variables of the dglOpenGL.pas so all code they use this will find them. + + > GL_ARB_shading_language_100 := dglCheckExtension('GL_ARB_shading_language_100'); +} + + +unit dglOpenGL; + +interface + +// defines to configure freepascal +{$IFDEF FPC} + {$MODE Delphi} + + {$IFNDEF WINDOWS} + {$LINKLIB c} + {$ENDIF} +{$ENDIF} + +// known delphi versions +{$IFNDEF FPC} // if freepascal isnt defined + {$IFDEF VER140} // Delphi 6 + {$DEFINE DELPHI6_AND_DOWN} + {$ENDIF} + + {$IFDEF VER130} // Delphi 5 + {$DEFINE DELPHI6_AND_DOWN} + {$ENDIF} + + {$IFDEF VER120} // Delphi 4 + {$DEFINE DELPHI6_AND_DOWN} + {$ENDIF} + + {$IFDEF VER110} // C++ Builder 3 + {$DEFINE DELPHI6_AND_DOWN} + {$ENDIF} + + {$IFDEF VER100} // Delphi 3 + {$DEFINE DELPHI6_AND_DOWN} + {$ENDIF} +{$ENDIF} + +// Options for Delphi < 5 +{$IFDEF DELPHI6_AND_DOWN} + {$A+} +{$ELSE} + {$A4} +{$ENDIF} + +// generell options +{$H+,O+,X+} + +// detecting Windows +{$IFDEF Win32} // Delphi and fpc of 32 Bit Windows + {$DEFINE DGL_WIN} +{$ENDIF} + +{$IFDEF Win64} // Delphi and fpc of 32 Bit Windows + {$DEFINE DGL_WIN} +{$ENDIF} + +// detecting Linux +{$IFDEF linux} // Linux + {$DEFINE DGL_LINUX} +{$ENDIF} + +{$IFDEF DARWIN} // Mac OS X and FPC + {$DEFINE DGL_MAC} +{$ENDIF} + +{$IFDEF DELPHI} // Mac OS X add Delphi +{$IFDEF MACOS} + {$DEFINE DGL_MAC} +{$ENDIF} +{$ENDIF} + + +// detecting 64 Bit CPU +{$IFDEF CPU64} // fpc on 64 bit cpus + {$DEFINE DGL_64BIT} // dgl define for 64 bit +{$ENDIF} + + + +uses + {$IFDEF FPC}{$IFDEF DARWIN}dynlibs,{$ENDIF}{$ENDIF} // LoadLibrary functions + SysUtils + {$IFDEF DGL_WIN}, Windows{$ENDIF} + {$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF} + ; + +type + // Needed for Delphi 6 and less (defined in system.pas for Delphi 7) + PPointer = ^Pointer; + PCardinal = ^Cardinal; + + GLenum = Cardinal; + GLboolean = BYTEBOOL; + GLbitfield = Cardinal; + GLbyte = Shortint; + GLshort = SmallInt; + GLint = Integer; + GLsizei = Integer; + GLubyte = Byte; + GLushort = Word; + GLuint = Cardinal; + GLfloat = Single; + GLclampf = Single; + GLdouble = Double; + GLclampd = Double; + GLvoid = Pointer; + GLint64 = Int64; + GLuint64 = {$IFDEF DELPHI6_AND_DOWN} Int64 {$ELSE} UInt64 {$ENDIF}; + + TGLenum = GLenum; + TGLboolean = GLboolean; + TGLbitfield = GLbitfield; + TGLbyte = GLbyte; + TGLshort = GLshort; + TGLint = GLint; + TGLsizei = GLsizei; + TGLubyte = GLubyte; + TGLushort = GLushort; + TGLuint = GLuint; + TGLfloat = GLfloat; + TGLclampf = GLclampf; + TGLdouble = GLdouble; + TGLclampd = GLclampd; + TGLvoid = GLvoid; + TGLint64 = GLint64; + TGLuint64 = GLuint64; + + PGLboolean = ^GLboolean; + PGLbyte = ^GLbyte; + PGLshort = ^GLshort; + PGLint = ^GLint; + PGLsizei = ^GLsizei; + PGLubyte = ^GLubyte; + PGLushort = ^GLushort; + PGLuint = ^GLuint; + PGLclampf = ^GLclampf; + PGLfloat = ^GLfloat; + PGLdouble = ^GLdouble; + PGLclampd = ^GLclampd; + PGLenum = ^GLenum; + PGLvoid = Pointer; + PPGLvoid = ^PGLvoid; + PGLint64 = ^GLint64; + PGLuint64 = ^GLuint64; + + // GL_NV_half_float + GLhalfNV = WORD; + TGLhalfNV = GLhalfNV; + PGLhalfNV = ^GLhalfNV; + + // GL_ARB_shader_objects + PGLHandleARB = ^GLHandleARB; + GLHandleARB = Integer; + GLcharARB = AnsiChar; + PGLcharARB = PAnsiChar; + PPGLcharARB = ^PGLcharARB; + + // GL_VERSION_1_5 + GLintptr = GLint; + GLsizeiptr = GLsizei; + + // GL_ARB_vertex_buffer_object + GLintptrARB = GLint; + GLsizeiptrARB = GLsizei; + + // GL_VERSION_2_0 + GLHandle = Integer; + PGLchar = PAnsiChar; + PPGLchar = ^PGLChar; + + // GL_EXT_timer_query + GLint64EXT = Int64; + TGLint64EXT = GLint64EXT; + PGLint64EXT = ^GLint64EXT; + + GLuint64EXT = GLuint64; + TGLuint64EXT = GLuint64EXT; + PGLuint64EXT = ^GLuint64EXT; + + // WGL_ARB_pbuffer + HPBUFFERARB = THandle; + + // WGL_EXT_pbuffer + HPBUFFEREXT = THandle; + + // WGL_NV_present_video + PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV; + HVIDEOOUTPUTDEVICENV = THandle; + + // WGL_NV_video_output + PHPVIDEODEV = ^HPVIDEODEV; + HPVIDEODEV = THandle; + + // WGL_NV_gpu_affinity + PHPGPUNV = ^HPGPUNV; + PHGPUNV = ^HGPUNV; + + // WGL_NV_video_capture + HVIDEOINPUTDEVICENV = THandle; + PHVIDEOINPUTDEVICENV = ^HVIDEOINPUTDEVICENV; + + HPGPUNV = THandle; + HGPUNV = THandle; + + // GL_ARB_sync + GLsync = Pointer; + + // GL_ARB_cl_event + { These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event } + _cl_context = record end; + _cl_event = record end; + p_cl_context = ^_cl_context; + p_cl_event = ^_cl_event; + + // GL_ARB_debug_output + TglDebugProcARB = procedure (source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_debug_output + TglDebugProcAMD = procedure (id: GLuint; category: GLenum; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // (4.3) GL_KHR_debug + TglDebugProc = procedure(source : GLEnum; type_ : GLEnum; id : GLUInt; severity : GLUInt; length : GLsizei; const message_ : PGLCHar; userParam : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vdpau_interop + GLvdpauSurfaceNV = GLintptr; + PGLvdpauSurfaceNV = ^GLvdpauSurfaceNV; + + + // GLX + {$IFDEF DGL_LINUX} + GLXContext = Pointer; + GLXContextID = TXID; + GLXDrawable = TXID; + GLXFBConfig = Pointer; + GLXPbuffer = TXID; + GLXPixmap = TXID; + GLXWindow = TXID; + + Window = TXID; + Colormap = TXID; + Pixmap = TXID; + Font = TXID; + {$ENDIF} + + // Datatypes corresponding to GL's types TGL(name)(type)(count) + TGLVectorub2 = array[0..1] of GLubyte; + TGLVectori2 = array[0..1] of GLint; + TGLVectorf2 = array[0..1] of GLfloat; + TGLVectord2 = array[0..1] of GLdouble; + TGLVectorp2 = array[0..1] of Pointer; + + TGLVectorub3 = array[0..2] of GLubyte; + TGLVectori3 = array[0..2] of GLint; + TGLVectorf3 = array[0..2] of GLfloat; + TGLVectord3 = array[0..2] of GLdouble; + TGLVectorp3 = array[0..2] of Pointer; + + TGLVectorub4 = array[0..3] of GLubyte; + TGLVectori4 = array[0..3] of GLint; + TGLVectorf4 = array[0..3] of GLfloat; + TGLVectord4 = array[0..3] of GLdouble; + TGLVectorp4 = array[0..3] of Pointer; + + TGLArrayf4 = TGLVectorf4; + TGLArrayf3 = TGLVectorf3; + TGLArrayd3 = TGLVectord3; + TGLArrayi4 = TGLVectori4; + TGLArrayp4 = TGLVectorp4; + + TGlMatrixub3 = array[0..2, 0..2] of GLubyte; + TGlMatrixi3 = array[0..2, 0..2] of GLint; + TGLMatrixf3 = array[0..2, 0..2] of GLfloat; + TGLMatrixd3 = array[0..2, 0..2] of GLdouble; + + TGlMatrixub4 = array[0..3, 0..3] of GLubyte; + TGlMatrixi4 = array[0..3, 0..3] of GLint; + TGLMatrixf4 = array[0..3, 0..3] of GLfloat; + TGLMatrixd4 = array[0..3, 0..3] of GLdouble; + + TGLVector3f = TGLVectorf3; + + // Datatypes corresponding to OpenGL12.pas for easy porting + TVector3d = TGLVectord3; + + TVector4i = TGLVectori4; + TVector4f = TGLVectorf4; + TVector4p = TGLVectorp4; + + TMatrix4f = TGLMatrixf4; + TMatrix4d = TGLMatrixd4; + + PGLMatrixd4 = ^TGLMatrixd4; + PVector4i = ^TVector4i; + + + +{$IFDEF FPC} + TRect = packed record + Left, Top, Right, Bottom: Longint; + end; +{$ENDIF} + + + PGPU_DEVICE = ^GPU_DEVICE; + GPU_DEVICE = record + cb: DWORD; + DeviceName: array [0..31] of AnsiChar; + DeviceString: array [0..127] of AnsiChar; + Flags: DWORD; + rcVirtualScreen: TRect; + end; + + +type +{$IFDEF FPC} + {$IFDEF DGL_WIN} + PWGLSwap = ^TWGLSwap; + {$EXTERNALSYM _WGLSWAP} + _WGLSWAP = packed record + hdc: HDC; + uiFlags: UINT; + end; + + TWGLSwap = _WGLSWAP; + {$EXTERNALSYM WGLSWAP} + WGLSWAP = _WGLSWAP; + + {$ENDIF} +{$ENDIF} + + // GLU types + TGLUNurbs = record + end; + TGLUQuadric = record + end; + TGLUTesselator = record + end; + PGLUNurbs = ^TGLUNurbs; + PGLUQuadric = ^TGLUQuadric; + PGLUTesselator = ^TGLUTesselator; + // backwards compatibility + TGLUNurbsObj = TGLUNurbs; + TGLUQuadricObj = TGLUQuadric; + TGLUTesselatorObj = TGLUTesselator; + TGLUTriangulatorObj = TGLUTesselator; + PGLUNurbsObj = PGLUNurbs; + PGLUQuadricObj = PGLUQuadric; + PGLUTesselatorObj = PGLUTesselator; + PGLUTriangulatorObj = PGLUTesselator; + + // GLUQuadricCallback + TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GLUTessCallback + TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + // GLUNurbsCallback + TGLUNurbsErrorProc = procedure(ErrorCode: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +var + GL_VERSION_1_0, + GL_VERSION_1_1, + GL_VERSION_1_2, + GL_VERSION_1_3, + GL_VERSION_1_4, + GL_VERSION_1_5, + GL_VERSION_2_0, + GL_VERSION_2_1, + GL_VERSION_3_0, + GL_VERSION_3_1, + GL_VERSION_3_2, + GL_VERSION_3_3, + GL_VERSION_4_0, + GL_VERSION_4_1, + GL_VERSION_4_2, + GL_VERSION_4_3, + GL_VERSION_4_4, + GLU_VERSION_1_1, + GLU_VERSION_1_2, + GLU_VERSION_1_3, + GL_3DFX_multisample, + GL_3DFX_tbuffer, + GL_3DFX_texture_compression_FXT1, + GL_APPLE_client_storage, + GL_APPLE_element_array, + GL_APPLE_fence, + GL_APPLE_specular_vector, + GL_APPLE_transform_hint, + GL_APPLE_vertex_array_object, + GL_APPLE_vertex_array_range, + GL_APPLE_ycbcr_422, + GL_APPLE_texture_range, + GL_APPLE_float_pixels, + GL_APPLE_vertex_program_evaluators, + GL_APPLE_aux_depth_stencil, + GL_APPLE_object_purgeable, + GL_APPLE_row_bytes, + GL_APPLE_rgb_422, + GL_ARB_depth_texture, + GL_ARB_fragment_program, + GL_ARB_imaging, + GL_ARB_matrix_palette, + GL_ARB_multisample, + GL_ARB_multitexture, + GL_ARB_point_parameters, + GL_ARB_shadow, + GL_ARB_shadow_ambient, + GL_ARB_texture_border_clamp, + GL_ARB_texture_compression, + GL_ARB_texture_cube_map, + GL_ARB_texture_env_add, + GL_ARB_texture_env_combine, + GL_ARB_texture_env_crossbar, + GL_ARB_texture_env_dot3, + GL_ARB_texture_mirrored_repeat, + GL_ARB_transpose_matrix, + GL_ARB_vertex_blend, + GL_ARB_vertex_buffer_object, + GL_ARB_vertex_program, + GL_ARB_window_pos, + GL_ARB_shader_objects, + GL_ARB_vertex_shader, + GL_ARB_fragment_shader, + GL_ARB_shading_language_100, + GL_ARB_occlusion_query, + GL_ARB_texture_non_power_of_two, + GL_ARB_point_sprite, + GL_ARB_fragment_program_shadow, + GL_ARB_draw_buffers, + GL_ARB_texture_rectangle, + GL_ARB_color_buffer_float, + GL_ARB_half_float_pixel, + GL_ARB_texture_float, + GL_ARB_pixel_buffer_object, + GL_ARB_depth_buffer_float, + GL_ARB_draw_instanced, + GL_ARB_framebuffer_object, + GL_ARB_framebuffer_sRGB, + GL_ARB_geometry_shader4, + GL_ARB_half_float_vertex, + GL_ARB_instanced_arrays, + GL_ARB_map_buffer_range, + GL_ARB_texture_buffer_object, + GL_ARB_texture_compression_rgtc, + GL_ARB_texture_rg, + GL_ARB_vertex_array_object, + GL_ARB_uniform_buffer_object, + GL_ARB_compatibility, + GL_ARB_copy_buffer, + GL_ARB_shader_texture_lod, + GL_ARB_depth_clamp, + GL_ARB_draw_elements_base_vertex, + GL_ARB_fragment_coord_conventions, + GL_ARB_provoking_vertex, + GL_ARB_seamless_cube_map, + GL_ARB_sync, + GL_ARB_texture_multisample, + GL_ARB_vertex_array_bgra, + GL_ARB_draw_buffers_blend, + GL_ARB_sample_shading, + GL_ARB_texture_cube_map_array, + GL_ARB_texture_gather, + GL_ARB_texture_query_lod, + GL_ARB_shading_language_include, + GL_ARB_texture_compression_bptc, + GL_ARB_blend_func_extended, + GL_ARB_explicit_attrib_location, + GL_ARB_occlusion_query2, + GL_ARB_sampler_objects, + GL_ARB_shader_bit_encoding, + GL_ARB_texture_rgb10_a2ui, + GL_ARB_texture_swizzle, + GL_ARB_timer_query, + GL_ARB_vertex_type_2_10_10_10_rev, + GL_ARB_draw_indirect, + GL_ARB_gpu_shader5, + GL_ARB_gpu_shader_fp64, + GL_ARB_shader_subroutine, + GL_ARB_tessellation_shader, + GL_ARB_texture_buffer_object_rgb32, + GL_ARB_transform_feedback2, + GL_ARB_transform_feedback3, + GL_ARB_ES2_compatibility, + GL_ARB_get_program_binary, + GL_ARB_separate_shader_objects, + GL_ARB_shader_precision, + GL_ARB_vertex_attrib_64bit, + GL_ARB_viewport_array, + + // GL 4.2 + GL_ARB_base_instance, + GL_ARB_shading_language_420pack, + GL_ARB_transform_feedback_instanced, + GL_ARB_compressed_texture_pixel_storage, + GL_ARB_conservative_depth, + GL_ARB_internalformat_query, + GL_ARB_map_buffer_alignment, + GL_ARB_shader_atomic_counters, + GL_ARB_shader_image_load_store, + GL_ARB_shading_language_packing, + GL_ARB_texture_storage, + // END GL 4.2 + + // GL 4.3 + GL_ARB_arrays_of_arrays, + GL_ARB_fragment_layer_viewport, + GL_ARB_shader_image_size, + GL_ARB_ES3_compatibility, + GL_ARB_clear_buffer_object, + GL_ARB_compute_shader, + GL_ARB_copy_image, + GL_KHR_debug, + GL_ARB_explicit_uniform_location, + GL_ARB_framebuffer_no_attachments, + GL_ARB_internalformat_query2, + GL_ARB_invalidate_subdata, + GL_ARB_multi_draw_indirect, + GL_ARB_program_interface_query, + GL_ARB_robust_buffer_access_behavior, + GL_ARB_shader_storage_buffer_object, + GL_ARB_stencil_texturing, + GL_ARB_texture_buffer_range, + GL_ARB_texture_query_levels, + GL_ARB_texture_storage_multisample, + GL_ARB_texture_view, + GL_ARB_vertex_attrib_binding, + GL_NV_path_rendering, + GL_AMD_pinned_memory, + GL_AMD_stencil_operation_extended, + GL_AMD_vertex_shader_viewport_index, + GL_AMD_vertex_shader_layer, + GL_NV_bindless_texture, + GL_NV_shader_atomic_float, + GL_AMD_query_buffer_object, + // END GL 4.3 + + // GL 4.4 + GL_ARB_buffer_storage, + GL_ARB_clear_texture, + GL_ARB_enhanced_layouts, + GL_ARB_multi_bind, + GL_ARB_query_buffer_object, + GL_ARB_texture_mirror_clamp_to_edge, + GL_ARB_texture_stencil8, + GL_ARB_vertex_type_10f_11f_11f_rev, + // END 4.4 + + GL_ARB_cl_event, + GL_ARB_debug_output, + GL_ARB_robustness, + GL_ARB_shader_stencil_export, + GL_ATI_draw_buffers, + GL_ATI_element_array, + GL_ATI_envmap_bumpmap, + GL_ATI_fragment_shader, + GL_ATI_map_object_buffer, + GL_ATI_pn_triangles, + GL_ATI_separate_stencil, + GL_ATI_text_fragment_shader, + GL_ATI_texture_env_combine3, + GL_ATI_texture_float, + GL_ATI_texture_mirror_once, + GL_ATI_vertex_array_object, + GL_ATI_vertex_attrib_array_object, + GL_ATI_vertex_streams, + GL_ATI_meminfo, + GL_AMD_performance_monitor, + GL_AMD_texture_texture4, + GL_AMD_vertex_shader_tesselator, + GL_AMD_draw_buffers_blend, + GL_AMD_shader_stencil_export, + GL_AMD_seamless_cubemap_per_texture, + GL_AMD_conservative_depth, + GL_AMD_name_gen_delete, + GL_AMD_debug_output, + GL_AMD_transform_feedback3_lines_triangles, + GL_AMD_depth_clamp_separate, + GL_EXT_422_pixels, + GL_EXT_abgr, + GL_EXT_bgra, + GL_EXT_blend_color, + GL_EXT_blend_func_separate, + GL_EXT_blend_logic_op, + GL_EXT_blend_minmax, + GL_EXT_blend_subtract, + GL_EXT_clip_volume_hint, + GL_EXT_cmyka, + GL_EXT_color_matrix, + GL_EXT_color_subtable, + GL_EXT_compiled_vertex_array, + GL_EXT_convolution, + GL_EXT_coordinate_frame, + GL_EXT_copy_texture, + GL_EXT_cull_vertex, + GL_EXT_draw_range_elements, + GL_EXT_fog_coord, + GL_EXT_framebuffer_object, + GL_EXT_histogram, + GL_EXT_index_array_formats, + GL_EXT_index_func, + GL_EXT_index_material, + GL_EXT_index_texture, + GL_EXT_light_texture, + GL_EXT_misc_attribute, + GL_EXT_multi_draw_arrays, + GL_EXT_multisample, + GL_EXT_packed_pixels, + GL_EXT_paletted_texture, + GL_EXT_pixel_transform, + GL_EXT_pixel_transform_color_table, + GL_EXT_point_parameters, + GL_EXT_polygon_offset, + GL_EXT_rescale_normal, + GL_EXT_secondary_color, + GL_EXT_separate_specular_color, + GL_EXT_shadow_funcs, + GL_EXT_shared_texture_palette, + GL_EXT_stencil_two_side, + GL_EXT_stencil_wrap, + GL_EXT_subtexture, + GL_EXT_texture, + GL_EXT_texture3D, + GL_EXT_texture_compression_s3tc, + GL_EXT_texture_cube_map, + GL_EXT_texture_edge_clamp, + GL_EXT_texture_env_add, + GL_EXT_texture_env_combine, + GL_EXT_texture_env_dot3, + GL_EXT_texture_filter_anisotropic, + GL_EXT_texture_lod_bias, + GL_EXT_texture_object, + GL_EXT_texture_perturb_normal, + GL_EXT_texture_rectangle, + GL_EXT_vertex_array, + GL_EXT_vertex_shader, + GL_EXT_vertex_weighting, + GL_EXT_depth_bounds_test, + GL_EXT_texture_mirror_clamp, + GL_EXT_blend_equation_separate, + GL_EXT_pixel_buffer_object, + GL_EXT_texture_compression_dxt1, + GL_EXT_stencil_clear_tag, + GL_EXT_packed_depth_stencil, + GL_EXT_texture_sRGB, + GL_EXT_framebuffer_blit, + GL_EXT_framebuffer_multisample, + GL_EXT_timer_query, + GL_EXT_gpu_program_parameters, + GL_EXT_bindable_uniform, + GL_EXT_draw_buffers2, + GL_EXT_draw_instanced, + GL_EXT_framebuffer_sRGB, + GL_EXT_geometry_shader4, + GL_EXT_gpu_shader4, + GL_EXT_packed_float, + GL_EXT_texture_array, + GL_EXT_texture_buffer_object, + GL_EXT_texture_compression_latc, + GL_EXT_texture_compression_rgtc, + GL_EXT_texture_integer, + GL_EXT_texture_shared_exponent, + GL_EXT_transform_feedback, + GL_EXT_direct_state_access, + GL_EXT_vertex_array_bgra, + GL_EXT_texture_swizzle, + GL_EXT_provoking_vertex, + GL_EXT_texture_snorm, + GL_EXT_separate_shader_objects, + GL_EXT_shader_image_load_store, + GL_EXT_vertex_attrib_64bit, + GL_EXT_texture_sRGB_decode, + GL_FfdMaskSGIX, + GL_HP_convolution_border_modes, + GL_HP_image_transform, + GL_HP_occlusion_test, + GL_HP_texture_lighting, + GL_IBM_cull_vertex, + GL_IBM_multimode_draw_arrays, + GL_IBM_rasterpos_clip, + GL_IBM_texture_mirrored_repeat, + GL_IBM_vertex_array_lists, + GL_INGR_blend_func_separate, + GL_INGR_color_clamp, + GL_INGR_interlace_read, + GL_INGR_palette_buffer, + GL_INTEL_parallel_arrays, + GL_INTEL_texture_scissor, + GL_MESA_resize_buffers, + GL_MESA_window_pos, + GL_NV_blend_square, + GL_NV_copy_depth_to_color, + GL_NV_depth_clamp, + GL_NV_evaluators, + GL_NV_fence, + GL_NV_float_buffer, + GL_NV_fog_distance, + GL_NV_fragment_program, + GL_NV_half_float, + GL_NV_light_max_exponent, + GL_NV_multisample_filter_hint, + GL_NV_occlusion_query, + GL_NV_packed_depth_stencil, + GL_NV_pixel_data_range, + GL_NV_point_sprite, + GL_NV_primitive_restart, + GL_NV_register_combiners, + GL_NV_register_combiners2, + GL_NV_texgen_emboss, + GL_NV_texgen_reflection, + GL_NV_texture_compression_vtc, + GL_NV_texture_env_combine4, + GL_NV_texture_expand_normal, + GL_NV_texture_rectangle, + GL_NV_texture_shader, + GL_NV_texture_shader2, + GL_NV_texture_shader3, + GL_NV_vertex_array_range, + GL_NV_vertex_array_range2, + GL_NV_vertex_program, + GL_NV_vertex_program1_1, + GL_NV_vertex_program2, + GL_NV_fragment_program_option, + GL_NV_fragment_program2, + GL_NV_vertex_program2_option, + GL_NV_vertex_program3, + GL_NV_depth_buffer_float, + GL_NV_fragment_program4, + GL_NV_framebuffer_multisample_coverage, + GL_NV_geometry_program4, + GL_NV_gpu_program4, + GL_NV_parameter_buffer_object, + GL_NV_transform_feedback, + GL_NV_vertex_program4, + GL_NV_conditional_render, + GL_NV_present_video, + GL_NV_explicit_multisample, + GL_NV_transform_feedback2, + GL_NV_video_capture, + GL_NV_copy_image, + GL_NV_parameter_buffer_object2, + GL_NV_shader_buffer_load, + GL_NV_vertex_buffer_unified_memory, + GL_NV_gpu_program5, + GL_NV_gpu_shader5, + GL_NV_shader_buffer_store, + GL_NV_tessellation_program5, + GL_NV_vertex_attrib_integer_64bit, + GL_NV_multisample_coverage, + GL_NV_vdpau_interop, + GL_NV_texture_barrier, + GL_OML_interlace, + GL_OML_resample, + GL_OML_subsample, + GL_PGI_misc_hints, + GL_PGI_vertex_hints, + GL_REND_screen_coordinates, + GL_S3_s3tc, + GL_SGIS_detail_texture, + GL_SGIS_fog_function, + GL_SGIS_generate_mipmap, + GL_SGIS_multisample, + GL_SGIS_pixel_texture, + GL_SGIS_point_line_texgen, + GL_SGIS_point_parameters, + GL_SGIS_sharpen_texture, + GL_SGIS_texture4D, + GL_SGIS_texture_border_clamp, + GL_SGIS_texture_color_mask, + GL_SGIS_texture_edge_clamp, + GL_SGIS_texture_filter4, + GL_SGIS_texture_lod, + GL_SGIS_texture_select, + GL_SGIX_async, + GL_SGIX_async_histogram, + GL_SGIX_async_pixel, + GL_SGIX_blend_alpha_minmax, + GL_SGIX_calligraphic_fragment, + GL_SGIX_clipmap, + GL_SGIX_convolution_accuracy, + GL_SGIX_depth_pass_instrument, + GL_SGIX_depth_texture, + GL_SGIX_flush_raster, + GL_SGIX_fog_offset, + GL_SGIX_fog_scale, + GL_SGIX_fragment_lighting, + GL_SGIX_framezoom, + GL_SGIX_igloo_interface, + GL_SGIX_impact_pixel_texture, + GL_SGIX_instruments, + GL_SGIX_interlace, + GL_SGIX_ir_instrument1, + GL_SGIX_list_priority, + GL_SGIX_pixel_texture, + GL_SGIX_pixel_tiles, + GL_SGIX_polynomial_ffd, + GL_SGIX_reference_plane, + GL_SGIX_resample, + GL_SGIX_scalebias_hint, + GL_SGIX_shadow, + GL_SGIX_shadow_ambient, + GL_SGIX_sprite, + GL_SGIX_subsample, + GL_SGIX_tag_sample_buffer, + GL_SGIX_texture_add_env, + GL_SGIX_texture_coordinate_clamp, + GL_SGIX_texture_lod_bias, + GL_SGIX_texture_multi_buffer, + GL_SGIX_texture_scale_bias, + GL_SGIX_texture_select, + GL_SGIX_vertex_preclip, + GL_SGIX_ycrcb, + GL_SGIX_ycrcb_subsample, + GL_SGIX_ycrcba, + GL_SGI_color_matrix, + GL_SGI_color_table, + GL_SGI_depth_pass_instrument, + GL_SGI_texture_color_table, + GL_SUNX_constant_data, + GL_SUN_convolution_border_modes, + GL_SUN_global_alpha, + GL_SUN_mesh_array, + GL_SUN_slice_accum, + GL_SUN_triangle_list, + GL_SUN_vertex, + + GL_WIN_phong_shading, + GL_WIN_specular_fog, + WGL_3DFX_multisample, + WGL_ARB_buffer_region, + WGL_ARB_extensions_string, + WGL_ARB_make_current_read, + WGL_ARB_multisample, + WGL_ARB_pbuffer, + WGL_ARB_pixel_format, + WGL_ARB_pixel_format_float, + WGL_ARB_render_texture, + WGL_ARB_create_context, + WGL_ARB_create_context_profile, + WGL_ARB_framebuffer_sRGB, + WGL_ARB_create_context_robustness, + WGL_ATI_pixel_format_float, + WGL_AMD_gpu_association, + WGL_EXT_depth_float, + WGL_EXT_display_color_table, + WGL_EXT_extensions_string, + WGL_EXT_make_current_read, + WGL_EXT_multisample, + WGL_EXT_pbuffer, + WGL_EXT_pixel_format, + WGL_EXT_swap_control, + WGL_EXT_create_context_es2_profile, + WGL_I3D_digital_video_control, + WGL_I3D_gamma, + WGL_I3D_genlock, + WGL_I3D_image_buffer, + WGL_I3D_swap_frame_lock, + WGL_I3D_swap_frame_usage, + WGL_NV_float_buffer, + WGL_NV_render_depth_texture, + WGL_NV_render_texture_rectangle, + WGL_NV_vertex_array_range, + WGL_NV_present_video, + WGL_NV_video_output, + WGL_NV_swap_group, + WGL_NV_gpu_affinity, + WGL_NV_video_capture, + WGL_NV_copy_image, + WGL_NV_multisample_coverage, + WGL_NV_DX_interop, + WGL_OML_sync_control, + WGL_3DL_stereo_control, + WIN_draw_range_elements, + WIN_swap_hint, + +// GLX_VERSION_1_0, + GLX_VERSION_1_3, + GLX_VERSION_1_4, + GLX_ARB_multisample, + GLX_ARB_fbconfig_float, + GLX_ARB_get_proc_address, + GLX_ARB_create_context, + GLX_ARB_create_context_profile, + GLX_ARB_vertex_buffer_object, + GLX_ARB_framebuffer_sRGB, + GLX_ARB_create_context_robustness, + GLX_EXT_visual_info, + GLX_EXT_visual_rating, + GLX_EXT_import_context, + GLX_EXT_fbconfig_packed_float, + GLX_EXT_framebuffer_sRGB, + GLX_EXT_texture_from_pixmap, + GLX_EXT_swap_control, + GLX_EXT_create_context_es2_profile : Boolean; + +const + // GL_VERSION_1_1 + { AttribMask } + GL_DEPTH_BUFFER_BIT = $00000100; + GL_STENCIL_BUFFER_BIT = $00000400; + GL_COLOR_BUFFER_BIT = $00004000; + { Boolean } + GL_TRUE = 1; + GL_FALSE = 0; + { BeginMode } + GL_POINTS = $0000; + GL_LINES = $0001; + GL_LINE_LOOP = $0002; + GL_LINE_STRIP = $0003; + GL_TRIANGLES = $0004; + GL_TRIANGLE_STRIP = $0005; + GL_TRIANGLE_FAN = $0006; + { AlphaFunction } + GL_NEVER = $0200; + GL_LESS = $0201; + GL_EQUAL = $0202; + GL_LEQUAL = $0203; + GL_GREATER = $0204; + GL_NOTEQUAL = $0205; + GL_GEQUAL = $0206; + GL_ALWAYS = $0207; + { BlendingFactorDest } + GL_ZERO = 0; + GL_ONE = 1; + GL_SRC_COLOR = $0300; + GL_ONE_MINUS_SRC_COLOR = $0301; + GL_SRC_ALPHA = $0302; + GL_ONE_MINUS_SRC_ALPHA = $0303; + GL_DST_ALPHA = $0304; + GL_ONE_MINUS_DST_ALPHA = $0305; + { BlendingFactorSrc } + GL_DST_COLOR = $0306; + GL_ONE_MINUS_DST_COLOR = $0307; + GL_SRC_ALPHA_SATURATE = $0308; + { DrawBufferMode } + GL_NONE = 0; + GL_FRONT_LEFT = $0400; + GL_FRONT_RIGHT = $0401; + GL_BACK_LEFT = $0402; + GL_BACK_RIGHT = $0403; + GL_FRONT = $0404; + GL_BACK = $0405; + GL_LEFT = $0406; + GL_RIGHT = $0407; + GL_FRONT_AND_BACK = $0408; + { ErrorCode } + GL_NO_ERROR = 0; + GL_INVALID_ENUM = $0500; + GL_INVALID_VALUE = $0501; + GL_INVALID_OPERATION = $0502; + GL_OUT_OF_MEMORY = $0505; + { FrontFaceDirection } + GL_CW = $0900; + GL_CCW = $0901; + { GetPName } + GL_POINT_SIZE = $0B11; + GL_POINT_SIZE_RANGE = $0B12; + GL_POINT_SIZE_GRANULARITY = $0B13; + GL_LINE_SMOOTH = $0B20; + GL_LINE_WIDTH = $0B21; + GL_LINE_WIDTH_RANGE = $0B22; + GL_LINE_WIDTH_GRANULARITY = $0B23; + GL_POLYGON_SMOOTH = $0B41; + GL_CULL_FACE = $0B44; + GL_CULL_FACE_MODE = $0B45; + GL_FRONT_FACE = $0B46; + GL_DEPTH_RANGE = $0B70; + GL_DEPTH_TEST = $0B71; + GL_DEPTH_WRITEMASK = $0B72; + GL_DEPTH_CLEAR_VALUE = $0B73; + GL_DEPTH_FUNC = $0B74; + GL_STENCIL_TEST = $0B90; + 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_VIEWPORT = $0BA2; + GL_DITHER = $0BD0; + GL_BLEND_DST = $0BE0; + GL_BLEND_SRC = $0BE1; + GL_BLEND = $0BE2; + GL_LOGIC_OP_MODE = $0BF0; + GL_COLOR_LOGIC_OP = $0BF2; + GL_DRAW_BUFFER = $0C01; + GL_READ_BUFFER = $0C02; + GL_SCISSOR_BOX = $0C10; + GL_SCISSOR_TEST = $0C11; + GL_COLOR_CLEAR_VALUE = $0C22; + GL_COLOR_WRITEMASK = $0C23; + GL_DOUBLEBUFFER = $0C32; + GL_STEREO = $0C33; + GL_LINE_SMOOTH_HINT = $0C52; + GL_POLYGON_SMOOTH_HINT = $0C53; + GL_UNPACK_SWAP_BYTES = $0CF0; + GL_UNPACK_LSB_FIRST = $0CF1; + GL_UNPACK_ROW_LENGTH = $0CF2; + GL_UNPACK_SKIP_ROWS = $0CF3; + GL_UNPACK_SKIP_PIXELS = $0CF4; + GL_UNPACK_ALIGNMENT = $0CF5; + GL_PACK_SWAP_BYTES = $0D00; + GL_PACK_LSB_FIRST = $0D01; + GL_PACK_ROW_LENGTH = $0D02; + GL_PACK_SKIP_ROWS = $0D03; + GL_PACK_SKIP_PIXELS = $0D04; + GL_PACK_ALIGNMENT = $0D05; + GL_MAX_TEXTURE_SIZE = $0D33; + GL_MAX_VIEWPORT_DIMS = $0D3A; + GL_SUBPIXEL_BITS = $0D50; + GL_TEXTURE_1D = $0DE0; + GL_TEXTURE_2D = $0DE1; + GL_POLYGON_OFFSET_UNITS = $2A00; + GL_POLYGON_OFFSET_POINT = $2A01; + GL_POLYGON_OFFSET_LINE = $2A02; + GL_POLYGON_OFFSET_FILL = $8037; + GL_POLYGON_OFFSET_FACTOR = $8038; + GL_TEXTURE_BINDING_1D = $8068; + GL_TEXTURE_BINDING_2D = $8069; + { GetTextureParameter } + GL_TEXTURE_WIDTH = $1000; + GL_TEXTURE_HEIGHT = $1001; + GL_TEXTURE_INTERNAL_FORMAT = $1003; + GL_TEXTURE_BORDER_COLOR = $1004; + GL_TEXTURE_BORDER = $1005; + GL_TEXTURE_RED_SIZE = $805C; + GL_TEXTURE_GREEN_SIZE = $805D; + GL_TEXTURE_BLUE_SIZE = $805E; + GL_TEXTURE_ALPHA_SIZE = $805F; + { HintMode } + GL_DONT_CARE = $1100; + GL_FASTEST = $1101; + GL_NICEST = $1102; + { DataType } + 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_DOUBLE = $140A; + { LogicOp } + GL_CLEAR = $1500; + GL_AND = $1501; + GL_AND_REVERSE = $1502; + GL_COPY = $1503; + GL_AND_INVERTED = $1504; + GL_NOOP = $1505; + GL_XOR = $1506; + GL_OR = $1507; + GL_NOR = $1508; + GL_EQUIV = $1509; + GL_INVERT = $150A; + GL_OR_REVERSE = $150B; + GL_COPY_INVERTED = $150C; + GL_OR_INVERTED = $150D; + GL_NAND = $150E; + GL_SET = $150F; + { MatrixMode (for gl3.h, FBO attachment type) } + GL_TEXTURE = $1702; + { PixelCopyType } + GL_COLOR = $1800; + GL_DEPTH = $1801; + GL_STENCIL = $1802; + { PixelFormat } + GL_STENCIL_INDEX = $1901; + GL_DEPTH_COMPONENT = $1902; + GL_RED = $1903; + GL_GREEN = $1904; + GL_BLUE = $1905; + GL_ALPHA = $1906; + GL_RGB = $1907; + GL_RGBA = $1908; + { PolygonMode } + GL_POINT = $1B00; + GL_LINE = $1B01; + GL_FILL = $1B02; + { StencilOp } + GL_KEEP = $1E00; + GL_REPLACE = $1E01; + GL_INCR = $1E02; + GL_DECR = $1E03; + { StringName } + GL_VENDOR = $1F00; + GL_RENDERER = $1F01; + GL_VERSION = $1F02; + GL_EXTENSIONS = $1F03; + { TextureMagFilter } + GL_NEAREST = $2600; + GL_LINEAR = $2601; + { TextureMinFilter } + GL_NEAREST_MIPMAP_NEAREST = $2700; + GL_LINEAR_MIPMAP_NEAREST = $2701; + GL_NEAREST_MIPMAP_LINEAR = $2702; + GL_LINEAR_MIPMAP_LINEAR = $2703; + { TextureParameterName } + GL_TEXTURE_MAG_FILTER = $2800; + GL_TEXTURE_MIN_FILTER = $2801; + GL_TEXTURE_WRAP_S = $2802; + GL_TEXTURE_WRAP_T = $2803; + { TextureTarget } + GL_PROXY_TEXTURE_1D = $8063; + GL_PROXY_TEXTURE_2D = $8064; + { TextureWrapMode } + GL_REPEAT = $2901; + { PixelInternalFormat } + GL_R3_G3_B2 = $2A10; + GL_RGB4 = $804F; + GL_RGB5 = $8050; + GL_RGB8 = $8051; + GL_RGB10 = $8052; + GL_RGB12 = $8053; + GL_RGB16 = $8054; + GL_RGBA2 = $8055; + GL_RGBA4 = $8056; + GL_RGB5_A1 = $8057; + GL_RGBA8 = $8058; + GL_RGB10_A2 = $8059; + GL_RGBA12 = $805A; + GL_RGBA16 = $805B; +{$ifdef DGL_DEPRECATED} + GL_ACCUM = $0100; + GL_LOAD = $0101; + GL_RETURN = $0102; + GL_MULT = $0103; + GL_ADD = $0104; + GL_CURRENT_BIT = $00000001; + GL_POINT_BIT = $00000002; + GL_LINE_BIT = $00000004; + GL_POLYGON_BIT = $00000008; + GL_POLYGON_STIPPLE_BIT = $00000010; + GL_PIXEL_MODE_BIT = $00000020; + GL_LIGHTING_BIT = $00000040; + GL_FOG_BIT = $00000080; + GL_ACCUM_BUFFER_BIT = $00000200; + GL_VIEWPORT_BIT = $00000800; + GL_TRANSFORM_BIT = $00001000; + GL_ENABLE_BIT = $00002000; + GL_HINT_BIT = $00008000; + GL_EVAL_BIT = $00010000; + GL_LIST_BIT = $00020000; + GL_TEXTURE_BIT = $00040000; + GL_SCISSOR_BIT = $00080000; + GL_ALL_ATTRIB_BITS = $000FFFFF; + GL_QUADS = $0007; + GL_QUAD_STRIP = $0008; + GL_POLYGON = $0009; + 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_2_BYTES = $1407; + GL_3_BYTES = $1408; + GL_4_BYTES = $1409; + GL_AUX0 = $0409; + GL_AUX1 = $040A; + GL_AUX2 = $040B; + GL_AUX3 = $040C; + GL_STACK_OVERFLOW = $0503; + GL_STACK_UNDERFLOW = $0504; + GL_2D = $0600; + GL_3D = $0601; + GL_3D_COLOR = $0602; + GL_3D_COLOR_TEXTURE = $0603; + GL_4D_COLOR_TEXTURE = $0604; + GL_PASS_THROUGH_TOKEN = $0700; + GL_POINT_TOKEN = $0701; + GL_LINE_TOKEN = $0702; + GL_POLYGON_TOKEN = $0703; + GL_BITMAP_TOKEN = $0704; + GL_DRAW_PIXEL_TOKEN = $0705; + GL_COPY_PIXEL_TOKEN = $0706; + GL_LINE_RESET_TOKEN = $0707; + GL_EXP = $0800; + GL_EXP2 = $0801; + GL_COEFF = $0A00; + GL_ORDER = $0A01; + GL_DOMAIN = $0A02; + GL_CURRENT_COLOR = $0B00; + GL_CURRENT_INDEX = $0B01; + GL_CURRENT_NORMAL = $0B02; + GL_CURRENT_TEXTURE_COORDS = $0B03; + GL_CURRENT_RASTER_COLOR = $0B04; + GL_CURRENT_RASTER_INDEX = $0B05; + GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06; + GL_CURRENT_RASTER_POSITION = $0B07; + GL_CURRENT_RASTER_POSITION_VALID = $0B08; + GL_CURRENT_RASTER_DISTANCE = $0B09; + GL_POINT_SMOOTH = $0B10; + GL_LINE_STIPPLE = $0B24; + GL_LINE_STIPPLE_PATTERN = $0B25; + GL_LINE_STIPPLE_REPEAT = $0B26; + GL_LIST_MODE = $0B30; + GL_MAX_LIST_NESTING = $0B31; + GL_LIST_BASE = $0B32; + GL_LIST_INDEX = $0B33; + GL_POLYGON_MODE = $0B40; + GL_POLYGON_STIPPLE = $0B42; + GL_EDGE_FLAG = $0B43; + GL_LIGHTING = $0B50; + GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51; + GL_LIGHT_MODEL_TWO_SIDE = $0B52; + GL_LIGHT_MODEL_AMBIENT = $0B53; + GL_SHADE_MODEL = $0B54; + GL_COLOR_MATERIAL_FACE = $0B55; + GL_COLOR_MATERIAL_PARAMETER = $0B56; + GL_COLOR_MATERIAL = $0B57; + GL_FOG = $0B60; + GL_FOG_INDEX = $0B61; + GL_FOG_DENSITY = $0B62; + GL_FOG_START = $0B63; + GL_FOG_END = $0B64; + GL_FOG_MODE = $0B65; + GL_FOG_COLOR = $0B66; + GL_ACCUM_CLEAR_VALUE = $0B80; + GL_MATRIX_MODE = $0BA0; + GL_NORMALIZE = $0BA1; + 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_ATTRIB_STACK_DEPTH = $0BB0; + GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1; + GL_ALPHA_TEST = $0BC0; + GL_ALPHA_TEST_FUNC = $0BC1; + GL_ALPHA_TEST_REF = $0BC2; + GL_INDEX_LOGIC_OP = $0BF1; + GL_AUX_BUFFERS = $0C00; + GL_INDEX_CLEAR_VALUE = $0C20; + GL_INDEX_WRITEMASK = $0C21; + GL_INDEX_MODE = $0C30; + GL_RGBA_MODE = $0C31; + GL_RENDER_MODE = $0C40; + GL_PERSPECTIVE_CORRECTION_HINT = $0C50; + GL_POINT_SMOOTH_HINT = $0C51; + GL_FOG_HINT = $0C54; + GL_TEXTURE_GEN_S = $0C60; + GL_TEXTURE_GEN_T = $0C61; + GL_TEXTURE_GEN_R = $0C62; + GL_TEXTURE_GEN_Q = $0C63; + GL_PIXEL_MAP_I_TO_I = $0C70; + GL_PIXEL_MAP_S_TO_S = $0C71; + GL_PIXEL_MAP_I_TO_R = $0C72; + GL_PIXEL_MAP_I_TO_G = $0C73; + GL_PIXEL_MAP_I_TO_B = $0C74; + GL_PIXEL_MAP_I_TO_A = $0C75; + GL_PIXEL_MAP_R_TO_R = $0C76; + GL_PIXEL_MAP_G_TO_G = $0C77; + GL_PIXEL_MAP_B_TO_B = $0C78; + GL_PIXEL_MAP_A_TO_A = $0C79; + GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0; + GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1; + GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2; + GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3; + GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4; + GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5; + GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6; + GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7; + GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8; + GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9; + GL_MAP_COLOR = $0D10; + GL_MAP_STENCIL = $0D11; + GL_INDEX_SHIFT = $0D12; + GL_INDEX_OFFSET = $0D13; + GL_RED_SCALE = $0D14; + GL_RED_BIAS = $0D15; + GL_ZOOM_X = $0D16; + GL_ZOOM_Y = $0D17; + GL_GREEN_SCALE = $0D18; + GL_GREEN_BIAS = $0D19; + GL_BLUE_SCALE = $0D1A; + GL_BLUE_BIAS = $0D1B; + GL_ALPHA_SCALE = $0D1C; + GL_ALPHA_BIAS = $0D1D; + GL_DEPTH_SCALE = $0D1E; + GL_DEPTH_BIAS = $0D1F; + GL_MAX_EVAL_ORDER = $0D30; + GL_MAX_LIGHTS = $0D31; + GL_MAX_CLIP_PLANES = $0D32; + GL_MAX_PIXEL_MAP_TABLE = $0D34; + GL_MAX_ATTRIB_STACK_DEPTH = $0D35; + GL_MAX_MODELVIEW_STACK_DEPTH = $0D36; + GL_MAX_NAME_STACK_DEPTH = $0D37; + GL_MAX_PROJECTION_STACK_DEPTH = $0D38; + GL_MAX_TEXTURE_STACK_DEPTH = $0D39; + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B; + GL_INDEX_BITS = $0D51; + 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_ACCUM_RED_BITS = $0D58; + GL_ACCUM_GREEN_BITS = $0D59; + GL_ACCUM_BLUE_BITS = $0D5A; + GL_ACCUM_ALPHA_BITS = $0D5B; + GL_NAME_STACK_DEPTH = $0D70; + GL_AUTO_NORMAL = $0D80; + GL_MAP1_COLOR_4 = $0D90; + GL_MAP1_INDEX = $0D91; + GL_MAP1_NORMAL = $0D92; + GL_MAP1_TEXTURE_COORD_1 = $0D93; + GL_MAP1_TEXTURE_COORD_2 = $0D94; + GL_MAP1_TEXTURE_COORD_3 = $0D95; + GL_MAP1_TEXTURE_COORD_4 = $0D96; + GL_MAP1_VERTEX_3 = $0D97; + GL_MAP1_VERTEX_4 = $0D98; + GL_MAP2_COLOR_4 = $0DB0; + GL_MAP2_INDEX = $0DB1; + GL_MAP2_NORMAL = $0DB2; + GL_MAP2_TEXTURE_COORD_1 = $0DB3; + GL_MAP2_TEXTURE_COORD_2 = $0DB4; + GL_MAP2_TEXTURE_COORD_3 = $0DB5; + GL_MAP2_TEXTURE_COORD_4 = $0DB6; + GL_MAP2_VERTEX_3 = $0DB7; + GL_MAP2_VERTEX_4 = $0DB8; + GL_MAP1_GRID_DOMAIN = $0DD0; + GL_MAP1_GRID_SEGMENTS = $0DD1; + GL_MAP2_GRID_DOMAIN = $0DD2; + GL_MAP2_GRID_SEGMENTS = $0DD3; + GL_FEEDBACK_BUFFER_POINTER = $0DF0; + GL_FEEDBACK_BUFFER_SIZE = $0DF1; + GL_FEEDBACK_BUFFER_TYPE = $0DF2; + GL_SELECTION_BUFFER_POINTER = $0DF3; + GL_SELECTION_BUFFER_SIZE = $0DF4; + 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_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_COMPILE = $1300; + GL_COMPILE_AND_EXECUTE = $1301; + GL_EMISSION = $1600; + GL_SHININESS = $1601; + GL_AMBIENT_AND_DIFFUSE = $1602; + GL_COLOR_INDEXES = $1603; + GL_MODELVIEW = $1700; + GL_PROJECTION = $1701; + GL_COLOR_INDEX = $1900; + GL_LUMINANCE = $1909; + GL_LUMINANCE_ALPHA = $190A; + GL_BITMAP = $1A00; + GL_RENDER = $1C00; + GL_FEEDBACK = $1C01; + GL_SELECT = $1C02; + GL_FLAT = $1D00; + GL_SMOOTH = $1D01; + GL_S = $2000; + GL_T = $2001; + GL_R = $2002; + GL_Q = $2003; + GL_MODULATE = $2100; + GL_DECAL = $2101; + GL_TEXTURE_ENV_MODE = $2200; + GL_TEXTURE_ENV_COLOR = $2201; + GL_TEXTURE_ENV = $2300; + GL_EYE_LINEAR = $2400; + GL_OBJECT_LINEAR = $2401; + GL_SPHERE_MAP = $2402; + GL_TEXTURE_GEN_MODE = $2500; + GL_OBJECT_PLANE = $2501; + GL_EYE_PLANE = $2502; + GL_CLAMP = $2900; + GL_CLIENT_PIXEL_STORE_BIT = $00000001; + GL_CLIENT_VERTEX_ARRAY_BIT = $00000002; + GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF; + GL_ALPHA4 = $803B; + GL_ALPHA8 = $803C; + GL_ALPHA12 = $803D; + GL_ALPHA16 = $803E; + GL_LUMINANCE4 = $803F; + GL_LUMINANCE8 = $8040; + GL_LUMINANCE12 = $8041; + GL_LUMINANCE16 = $8042; + GL_LUMINANCE4_ALPHA4 = $8043; + GL_LUMINANCE6_ALPHA2 = $8044; + GL_LUMINANCE8_ALPHA8 = $8045; + GL_LUMINANCE12_ALPHA4 = $8046; + GL_LUMINANCE12_ALPHA12 = $8047; + GL_LUMINANCE16_ALPHA16 = $8048; + GL_INTENSITY = $8049; + GL_INTENSITY4 = $804A; + GL_INTENSITY8 = $804B; + GL_INTENSITY12 = $804C; + GL_INTENSITY16 = $804D; + GL_TEXTURE_LUMINANCE_SIZE = $8060; + GL_TEXTURE_INTENSITY_SIZE = $8061; + GL_TEXTURE_PRIORITY = $8066; + GL_TEXTURE_RESIDENT = $8067; + GL_VERTEX_ARRAY = $8074; + GL_NORMAL_ARRAY = $8075; + GL_COLOR_ARRAY = $8076; + GL_INDEX_ARRAY = $8077; + GL_TEXTURE_COORD_ARRAY = $8078; + GL_EDGE_FLAG_ARRAY = $8079; + 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_INDEX_ARRAY_TYPE = $8085; + GL_INDEX_ARRAY_STRIDE = $8086; + GL_TEXTURE_COORD_ARRAY_SIZE = $8088; + GL_TEXTURE_COORD_ARRAY_TYPE = $8089; + GL_TEXTURE_COORD_ARRAY_STRIDE = $808A; + GL_EDGE_FLAG_ARRAY_STRIDE = $808C; + GL_VERTEX_ARRAY_POINTER = $808E; + GL_NORMAL_ARRAY_POINTER = $808F; + GL_COLOR_ARRAY_POINTER = $8090; + GL_INDEX_ARRAY_POINTER = $8091; + GL_TEXTURE_COORD_ARRAY_POINTER = $8092; + GL_EDGE_FLAG_ARRAY_POINTER = $8093; + GL_V2F = $2A20; + GL_V3F = $2A21; + GL_C4UB_V2F = $2A22; + GL_C4UB_V3F = $2A23; + GL_C3F_V3F = $2A24; + GL_N3F_V3F = $2A25; + GL_C4F_N3F_V3F = $2A26; + GL_T2F_V3F = $2A27; + GL_T4F_V4F = $2A28; + GL_T2F_C4UB_V3F = $2A29; + GL_T2F_C3F_V3F = $2A2A; + GL_T2F_N3F_V3F = $2A2B; + GL_T2F_C4F_N3F_V3F = $2A2C; + GL_T4F_C4F_N3F_V4F = $2A2D; + GL_COLOR_TABLE_FORMAT_EXT = $80D8; + GL_COLOR_TABLE_WIDTH_EXT = $80D9; + GL_COLOR_TABLE_RED_SIZE_EXT = $80DA; + GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB; + GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF; + GL_LOGIC_OP = GL_INDEX_LOGIC_OP; + GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT; +{$endif} + + // GL_VERSION_1_2 + GL_UNSIGNED_BYTE_3_3_2 = $8032; + GL_UNSIGNED_SHORT_4_4_4_4 = $8033; + GL_UNSIGNED_SHORT_5_5_5_1 = $8034; + GL_UNSIGNED_INT_8_8_8_8 = $8035; + GL_UNSIGNED_INT_10_10_10_2 = $8036; + GL_TEXTURE_BINDING_3D = $806A; + GL_PACK_SKIP_IMAGES = $806B; + GL_PACK_IMAGE_HEIGHT = $806C; + GL_UNPACK_SKIP_IMAGES = $806D; + GL_UNPACK_IMAGE_HEIGHT = $806E; + GL_TEXTURE_3D = $806F; + GL_PROXY_TEXTURE_3D = $8070; + GL_TEXTURE_DEPTH = $8071; + GL_TEXTURE_WRAP_R = $8072; + GL_MAX_3D_TEXTURE_SIZE = $8073; + GL_UNSIGNED_BYTE_2_3_3_REV = $8362; + GL_UNSIGNED_SHORT_5_6_5 = $8363; + GL_UNSIGNED_SHORT_5_6_5_REV = $8364; + GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365; + GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366; + GL_UNSIGNED_INT_8_8_8_8_REV = $8367; + GL_UNSIGNED_INT_2_10_10_10_REV = $8368; + GL_BGR = $80E0; + GL_BGRA = $80E1; + GL_MAX_ELEMENTS_VERTICES = $80E8; + GL_MAX_ELEMENTS_INDICES = $80E9; + GL_CLAMP_TO_EDGE = $812F; + GL_TEXTURE_MIN_LOD = $813A; + GL_TEXTURE_MAX_LOD = $813B; + GL_TEXTURE_BASE_LEVEL = $813C; + GL_TEXTURE_MAX_LEVEL = $813D; + GL_SMOOTH_POINT_SIZE_RANGE = $0B12; + GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13; + GL_SMOOTH_LINE_WIDTH_RANGE = $0B22; + GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23; + GL_ALIASED_LINE_WIDTH_RANGE = $846E; +{$ifdef DGL_DEPRECATED} + GL_RESCALE_NORMAL = $803A; + GL_LIGHT_MODEL_COLOR_CONTROL = $81F8; + GL_SINGLE_COLOR = $81F9; + GL_SEPARATE_SPECULAR_COLOR = $81FA; + GL_ALIASED_POINT_SIZE_RANGE = $846D; +{$endif} + + // GL_VERSION_1_3 + 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_MULTISAMPLE = $809D; + GL_SAMPLE_ALPHA_TO_COVERAGE = $809E; + GL_SAMPLE_ALPHA_TO_ONE = $809F; + GL_SAMPLE_COVERAGE = $80A0; + GL_SAMPLE_BUFFERS = $80A8; + GL_SAMPLES = $80A9; + GL_SAMPLE_COVERAGE_VALUE = $80AA; + GL_SAMPLE_COVERAGE_INVERT = $80AB; + 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_PROXY_TEXTURE_CUBE_MAP = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; + GL_COMPRESSED_RGB = $84ED; + GL_COMPRESSED_RGBA = $84EE; + GL_TEXTURE_COMPRESSION_HINT = $84EF; + GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0; + GL_TEXTURE_COMPRESSED = $86A1; + GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2; + GL_COMPRESSED_TEXTURE_FORMATS = $86A3; + GL_CLAMP_TO_BORDER = $812D; +{$ifdef DGL_DEPRECATED} + GL_CLIENT_ACTIVE_TEXTURE = $84E1; + GL_MAX_TEXTURE_UNITS = $84E2; + GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3; + GL_TRANSPOSE_PROJECTION_MATRIX = $84E4; + GL_TRANSPOSE_TEXTURE_MATRIX = $84E5; + GL_TRANSPOSE_COLOR_MATRIX = $84E6; + GL_MULTISAMPLE_BIT = $20000000; + GL_NORMAL_MAP = $8511; + GL_REFLECTION_MAP = $8512; + GL_COMPRESSED_ALPHA = $84E9; + GL_COMPRESSED_LUMINANCE = $84EA; + GL_COMPRESSED_LUMINANCE_ALPHA = $84EB; + GL_COMPRESSED_INTENSITY = $84EC; + GL_COMBINE = $8570; + GL_COMBINE_RGB = $8571; + GL_COMBINE_ALPHA = $8572; + GL_SOURCE0_RGB = $8580; + GL_SOURCE1_RGB = $8581; + GL_SOURCE2_RGB = $8582; + GL_SOURCE0_ALPHA = $8588; + GL_SOURCE1_ALPHA = $8589; + GL_SOURCE2_ALPHA = $858A; + 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_RGB_SCALE = $8573; + GL_ADD_SIGNED = $8574; + GL_INTERPOLATE = $8575; + GL_SUBTRACT = $84E7; + GL_CONSTANT = $8576; + GL_PRIMARY_COLOR = $8577; + GL_PREVIOUS = $8578; + GL_DOT3_RGB = $86AE; + GL_DOT3_RGBA = $86AF; +{$endif} + + // GL_VERSION_1_4 + GL_BLEND_DST_RGB = $80C8; + GL_BLEND_SRC_RGB = $80C9; + GL_BLEND_DST_ALPHA = $80CA; + GL_BLEND_SRC_ALPHA = $80CB; + GL_POINT_FADE_THRESHOLD_SIZE = $8128; + GL_DEPTH_COMPONENT16 = $81A5; + GL_DEPTH_COMPONENT24 = $81A6; + GL_DEPTH_COMPONENT32 = $81A7; + GL_MIRRORED_REPEAT = $8370; + GL_MAX_TEXTURE_LOD_BIAS = $84FD; + GL_TEXTURE_LOD_BIAS = $8501; + GL_INCR_WRAP = $8507; + GL_DECR_WRAP = $8508; + GL_TEXTURE_DEPTH_SIZE = $884A; + GL_TEXTURE_COMPARE_MODE = $884C; + GL_TEXTURE_COMPARE_FUNC = $884D; +{$ifdef DGL_DEPRECATED} + GL_POINT_SIZE_MIN = $8126; + GL_POINT_SIZE_MAX = $8127; + GL_POINT_DISTANCE_ATTENUATION = $8129; + GL_GENERATE_MIPMAP = $8191; + GL_GENERATE_MIPMAP_HINT = $8192; + GL_FOG_COORDINATE_SOURCE = $8450; + GL_FOG_COORDINATE = $8451; + GL_FRAGMENT_DEPTH = $8452; + GL_CURRENT_FOG_COORDINATE = $8453; + GL_FOG_COORDINATE_ARRAY_TYPE = $8454; + GL_FOG_COORDINATE_ARRAY_STRIDE = $8455; + GL_FOG_COORDINATE_ARRAY_POINTER = $8456; + GL_FOG_COORDINATE_ARRAY = $8457; + GL_COLOR_SUM = $8458; + GL_CURRENT_SECONDARY_COLOR = $8459; + GL_SECONDARY_COLOR_ARRAY_SIZE = $845A; + GL_SECONDARY_COLOR_ARRAY_TYPE = $845B; + GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C; + GL_SECONDARY_COLOR_ARRAY_POINTER = $845D; + GL_SECONDARY_COLOR_ARRAY = $845E; + GL_TEXTURE_FILTER_CONTROL = $8500; + GL_DEPTH_TEXTURE_MODE = $884B; + GL_COMPARE_R_TO_TEXTURE = $884E; +{$endif} + + // GL_VERSION_1_5 + GL_BUFFER_SIZE = $8764; + GL_BUFFER_USAGE = $8765; + GL_QUERY_COUNTER_BITS = $8864; + GL_CURRENT_QUERY = $8865; + GL_QUERY_RESULT = $8866; + GL_QUERY_RESULT_AVAILABLE = $8867; + GL_ARRAY_BUFFER = $8892; + GL_ELEMENT_ARRAY_BUFFER = $8893; + GL_ARRAY_BUFFER_BINDING = $8894; + GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895; + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F; + GL_READ_ONLY = $88B8; + GL_WRITE_ONLY = $88B9; + GL_READ_WRITE = $88BA; + GL_BUFFER_ACCESS = $88BB; + GL_BUFFER_MAPPED = $88BC; + GL_BUFFER_MAP_POINTER = $88BD; + GL_STREAM_DRAW = $88E0; + GL_STREAM_READ = $88E1; + GL_STREAM_COPY = $88E2; + GL_STATIC_DRAW = $88E4; + GL_STATIC_READ = $88E5; + GL_STATIC_COPY = $88E6; + GL_DYNAMIC_DRAW = $88E8; + GL_DYNAMIC_READ = $88E9; + GL_DYNAMIC_COPY = $88EA; + GL_SAMPLES_PASSED = $8914; +{$ifdef DGL_DEPRECATED} + GL_VERTEX_ARRAY_BUFFER_BINDING = $8896; + GL_NORMAL_ARRAY_BUFFER_BINDING = $8897; + GL_COLOR_ARRAY_BUFFER_BINDING = $8898; + GL_INDEX_ARRAY_BUFFER_BINDING = $8899; + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A; + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B; + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C; + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D; + GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E; + GL_FOG_COORD_SRC = $8450; + GL_FOG_COORD = $8451; + GL_CURRENT_FOG_COORD = $8453; + GL_FOG_COORD_ARRAY_TYPE = $8454; + GL_FOG_COORD_ARRAY_STRIDE = $8455; + GL_FOG_COORD_ARRAY_POINTER = $8456; + GL_FOG_COORD_ARRAY = $8457; + GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D; + GL_SRC0_RGB = $8580; + GL_SRC1_RGB = $8581; + GL_SRC2_RGB = $8582; + GL_SRC0_ALPHA = $8588; + GL_SRC1_ALPHA = $8589; + GL_SRC2_ALPHA = $858A; +{$endif} + + // GL_VERSION_2_0 + GL_BLEND_EQUATION_RGB = $8009; + 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_CURRENT_VERTEX_ATTRIB = $8626; + GL_VERTEX_PROGRAM_POINT_SIZE = $8642; + GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645; + 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_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_BLEND_EQUATION_ALPHA = $883D; + GL_MAX_VERTEX_ATTRIBS = $8869; + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A; + GL_MAX_TEXTURE_IMAGE_UNITS = $8872; + GL_FRAGMENT_SHADER = $8B30; + GL_VERTEX_SHADER = $8B31; + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49; + GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A; + GL_MAX_VARYING_FLOATS = $8B4B; + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C; + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D; + GL_SHADER_TYPE = $8B4F; + 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_1D = $8B5D; + GL_SAMPLER_2D = $8B5E; + GL_SAMPLER_3D = $8B5F; + GL_SAMPLER_CUBE = $8B60; + GL_SAMPLER_1D_SHADOW = $8B61; + GL_SAMPLER_2D_SHADOW = $8B62; + GL_DELETE_STATUS = $8B80; + GL_COMPILE_STATUS = $8B81; + GL_LINK_STATUS = $8B82; + GL_VALIDATE_STATUS = $8B83; + GL_INFO_LOG_LENGTH = $8B84; + GL_ATTACHED_SHADERS = $8B85; + GL_ACTIVE_UNIFORMS = $8B86; + GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87; + GL_SHADER_SOURCE_LENGTH = $8B88; + GL_ACTIVE_ATTRIBUTES = $8B89; + GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A; + GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B; + GL_SHADING_LANGUAGE_VERSION = $8B8C; + GL_CURRENT_PROGRAM = $8B8D; + GL_POINT_SPRITE_COORD_ORIGIN = $8CA0; + GL_LOWER_LEFT = $8CA1; + GL_UPPER_LEFT = $8CA2; + GL_STENCIL_BACK_REF = $8CA3; + GL_STENCIL_BACK_VALUE_MASK = $8CA4; + GL_STENCIL_BACK_WRITEMASK = $8CA5; +{$ifdef DGL_DEPRECATED} + GL_VERTEX_PROGRAM_TWO_SIDE = $8643; + GL_POINT_SPRITE = $8861; + GL_COORD_REPLACE = $8862; + GL_MAX_TEXTURE_COORDS = $8871; +{$endif} + + // GL_VERSION_2_1 + 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_SRGB_ALPHA = $8C42; + GL_SRGB8_ALPHA8 = $8C43; + GL_COMPRESSED_SRGB = $8C48; + GL_COMPRESSED_SRGB_ALPHA = $8C49; +{$ifdef DGL_DEPRECATED} + GL_CURRENT_RASTER_SECONDARY_COLOR = $845F; + GL_SLUMINANCE_ALPHA = $8C44; + GL_SLUMINANCE8_ALPHA8 = $8C45; + GL_SLUMINANCE = $8C46; + GL_SLUMINANCE8 = $8C47; + GL_COMPRESSED_SLUMINANCE = $8C4A; + GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B; +{$endif} + + // GL_VERSION_3_0 + GL_COMPARE_REF_TO_TEXTURE = $884E; + GL_CLIP_DISTANCE0 = $3000; + GL_CLIP_DISTANCE1 = $3001; + GL_CLIP_DISTANCE2 = $3002; + GL_CLIP_DISTANCE3 = $3003; + GL_CLIP_DISTANCE4 = $3004; + GL_CLIP_DISTANCE5 = $3005; + GL_CLIP_DISTANCE6 = $3006; + GL_CLIP_DISTANCE7 = $3007; + GL_MAX_CLIP_DISTANCES = $0D32; + GL_MAJOR_VERSION = $821B; + GL_MINOR_VERSION = $821C; + GL_NUM_EXTENSIONS = $821D; + GL_CONTEXT_FLAGS = $821E; + GL_DEPTH_BUFFER = $8223; + GL_STENCIL_BUFFER = $8224; + GL_COMPRESSED_RED = $8225; + GL_COMPRESSED_RG = $8226; + GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001; + 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_CLAMP_READ_COLOR = $891C; + GL_FIXED_ONLY = $891D; + GL_MAX_VARYING_COMPONENTS = $8B4B; + GL_TEXTURE_1D_ARRAY = $8C18; + GL_PROXY_TEXTURE_1D_ARRAY = $8C19; + GL_TEXTURE_2D_ARRAY = $8C1A; + GL_PROXY_TEXTURE_2D_ARRAY = $8C1B; + GL_TEXTURE_BINDING_1D_ARRAY = $8C1C; + 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_TEXTURE_SHARED_SIZE = $8C3F; + 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_PRIMITIVES_GENERATED = $8C87; + 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_GREEN_INTEGER = $8D95; + GL_BLUE_INTEGER = $8D96; + GL_RGB_INTEGER = $8D98; + GL_RGBA_INTEGER = $8D99; + GL_BGR_INTEGER = $8D9A; + GL_BGRA_INTEGER = $8D9B; + GL_SAMPLER_1D_ARRAY = $8DC0; + GL_SAMPLER_2D_ARRAY = $8DC1; + GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3; + 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_1D = $8DC9; + GL_INT_SAMPLER_2D = $8DCA; + GL_INT_SAMPLER_3D = $8DCB; + GL_INT_SAMPLER_CUBE = $8DCC; + GL_INT_SAMPLER_1D_ARRAY = $8DCE; + GL_INT_SAMPLER_2D_ARRAY = $8DCF; + GL_UNSIGNED_INT_SAMPLER_1D = $8DD1; + GL_UNSIGNED_INT_SAMPLER_2D = $8DD2; + GL_UNSIGNED_INT_SAMPLER_3D = $8DD3; + GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4; + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6; + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7; + GL_QUERY_WAIT = $8E13; + GL_QUERY_NO_WAIT = $8E14; + GL_QUERY_BY_REGION_WAIT = $8E15; + GL_QUERY_BY_REGION_NO_WAIT = $8E16; + GL_BUFFER_ACCESS_FLAGS = $911F; + GL_BUFFER_MAP_LENGTH = $9120; + GL_BUFFER_MAP_OFFSET = $9121; + { Reuse tokens from ARB_depth_buffer_float } + { reuse GL_DEPTH_COMPONENT32F } + { reuse GL_DEPTH32F_STENCIL8 } + { reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV } + { Reuse tokens from ARB_framebuffer_object } + { reuse GL_INVALID_FRAMEBUFFER_OPERATION } + { reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING } + { reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE } + { reuse GL_FRAMEBUFFER_DEFAULT } + { reuse GL_FRAMEBUFFER_UNDEFINED } + { reuse GL_DEPTH_STENCIL_ATTACHMENT } + { reuse GL_INDEX } + { reuse GL_MAX_RENDERBUFFER_SIZE } + { reuse GL_DEPTH_STENCIL } + { reuse GL_UNSIGNED_INT_24_8 } + { reuse GL_DEPTH24_STENCIL8 } + { reuse GL_TEXTURE_STENCIL_SIZE } + { reuse GL_TEXTURE_RED_TYPE } + { reuse GL_TEXTURE_GREEN_TYPE } + { reuse GL_TEXTURE_BLUE_TYPE } + { reuse GL_TEXTURE_ALPHA_TYPE } + { reuse GL_TEXTURE_DEPTH_TYPE } + { reuse GL_UNSIGNED_NORMALIZED } + { reuse GL_FRAMEBUFFER_BINDING } + { reuse GL_DRAW_FRAMEBUFFER_BINDING } + { reuse GL_RENDERBUFFER_BINDING } + { reuse GL_READ_FRAMEBUFFER } + { reuse GL_DRAW_FRAMEBUFFER } + { reuse GL_READ_FRAMEBUFFER_BINDING } + { reuse GL_RENDERBUFFER_SAMPLES } + { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME } + { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL } + { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE } + { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } + { reuse GL_FRAMEBUFFER_COMPLETE } + { reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT } + { reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT } + { reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER } + { reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER } + { reuse GL_FRAMEBUFFER_UNSUPPORTED } + { reuse GL_MAX_COLOR_ATTACHMENTS } + { reuse GL_COLOR_ATTACHMENT0 } + { reuse GL_COLOR_ATTACHMENT1 } + { reuse GL_COLOR_ATTACHMENT2 } + { reuse GL_COLOR_ATTACHMENT3 } + { reuse GL_COLOR_ATTACHMENT4 } + { reuse GL_COLOR_ATTACHMENT5 } + { reuse GL_COLOR_ATTACHMENT6 } + { reuse GL_COLOR_ATTACHMENT7 } + { reuse GL_COLOR_ATTACHMENT8 } + { reuse GL_COLOR_ATTACHMENT9 } + { reuse GL_COLOR_ATTACHMENT10 } + { reuse GL_COLOR_ATTACHMENT11 } + { reuse GL_COLOR_ATTACHMENT12 } + { reuse GL_COLOR_ATTACHMENT13 } + { reuse GL_COLOR_ATTACHMENT14 } + { reuse GL_COLOR_ATTACHMENT15 } + { reuse GL_DEPTH_ATTACHMENT } + { reuse GL_STENCIL_ATTACHMENT } + { reuse GL_FRAMEBUFFER } + { reuse GL_RENDERBUFFER } + { reuse GL_RENDERBUFFER_WIDTH } + { reuse GL_RENDERBUFFER_HEIGHT } + { reuse GL_RENDERBUFFER_INTERNAL_FORMAT } + { reuse GL_STENCIL_INDEX1 } + { reuse GL_STENCIL_INDEX4 } + { reuse GL_STENCIL_INDEX8 } + { reuse GL_STENCIL_INDEX16 } + { reuse GL_RENDERBUFFER_RED_SIZE } + { reuse GL_RENDERBUFFER_GREEN_SIZE } + { reuse GL_RENDERBUFFER_BLUE_SIZE } + { reuse GL_RENDERBUFFER_ALPHA_SIZE } + { reuse GL_RENDERBUFFER_DEPTH_SIZE } + { reuse GL_RENDERBUFFER_STENCIL_SIZE } + { reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE } + { reuse GL_MAX_SAMPLES } + { Reuse tokens from ARB_framebuffer_sRGB } + { reuse GL_FRAMEBUFFER_SRGB } + { Reuse tokens from ARB_half_float_vertex } + { reuse GL_HALF_FLOAT } + { Reuse tokens from ARB_map_buffer_range } + { reuse GL_MAP_READ_BIT } + { reuse GL_MAP_WRITE_BIT } + { reuse GL_MAP_INVALIDATE_RANGE_BIT } + { reuse GL_MAP_INVALIDATE_BUFFER_BIT } + { reuse GL_MAP_FLUSH_EXPLICIT_BIT } + { reuse GL_MAP_UNSYNCHRONIZED_BIT } + { Reuse tokens from ARB_texture_compression_rgtc } + { reuse GL_COMPRESSED_RED_RGTC1 } + { reuse GL_COMPRESSED_SIGNED_RED_RGTC1 } + { reuse GL_COMPRESSED_RG_RGTC2 } + { reuse GL_COMPRESSED_SIGNED_RG_RGTC2 } + { Reuse tokens from ARB_texture_rg } + { reuse GL_RG } + { reuse GL_RG_INTEGER } + { reuse GL_R8 } + { reuse GL_R16 } + { reuse GL_RG8 } + { reuse GL_RG16 } + { reuse GL_R16F } + { reuse GL_R32F } + { reuse GL_RG16F } + { reuse GL_RG32F } + { reuse GL_R8I } + { reuse GL_R8UI } + { reuse GL_R16I } + { reuse GL_R16UI } + { reuse GL_R32I } + { reuse GL_R32UI } + { reuse GL_RG8I } + { reuse GL_RG8UI } + { reuse GL_RG16I } + { reuse GL_RG16UI } + { reuse GL_RG32I } + { reuse GL_RG32UI } + { Reuse tokens from ARB_vertex_array_object } + { reuse GL_VERTEX_ARRAY_BINDING } +{$ifdef DGL_DEPRECATED} + GL_CLAMP_VERTEX_COLOR = $891A; + GL_CLAMP_FRAGMENT_COLOR = $891B; + GL_ALPHA_INTEGER = $8D97; + { Reuse tokens from ARB_framebuffer_object } + { reuse GL_TEXTURE_LUMINANCE_TYPE } + { reuse GL_TEXTURE_INTENSITY_TYPE } +{$endif} + + // GL_VERSION_3_1 + GL_SAMPLER_2D_RECT = $8B63; + GL_SAMPLER_2D_RECT_SHADOW = $8B64; + GL_SAMPLER_BUFFER = $8DC2; + GL_INT_SAMPLER_2D_RECT = $8DCD; + GL_INT_SAMPLER_BUFFER = $8DD0; + GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5; + GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8; + GL_TEXTURE_BUFFER = $8C2A; + GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B; + GL_TEXTURE_BINDING_BUFFER = $8C2C; + GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D; + GL_TEXTURE_BUFFER_FORMAT = $8C2E; + GL_TEXTURE_RECTANGLE = $84F5; + GL_TEXTURE_BINDING_RECTANGLE = $84F6; + GL_PROXY_TEXTURE_RECTANGLE = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8; + GL_RED_SNORM = $8F90; + GL_RG_SNORM = $8F91; + GL_RGB_SNORM = $8F92; + GL_RGBA_SNORM = $8F93; + GL_R8_SNORM = $8F94; + GL_RG8_SNORM = $8F95; + GL_RGB8_SNORM = $8F96; + GL_RGBA8_SNORM = $8F97; + GL_R16_SNORM = $8F98; + GL_RG16_SNORM = $8F99; + GL_RGB16_SNORM = $8F9A; + GL_RGBA16_SNORM = $8F9B; + GL_SIGNED_NORMALIZED = $8F9C; + GL_PRIMITIVE_RESTART = $8F9D; + GL_PRIMITIVE_RESTART_INDEX = $8F9E; + { Reuse tokens from ARB_copy_buffer } + { reuse GL_COPY_READ_BUFFER } + { reuse GL_COPY_WRITE_BUFFER } + { Reuse tokens from ARB_draw_instanced (none) } + { Reuse tokens from ARB_uniform_buffer_object } + { reuse GL_UNIFORM_BUFFER } + { reuse GL_UNIFORM_BUFFER_BINDING } + { reuse GL_UNIFORM_BUFFER_START } + { reuse GL_UNIFORM_BUFFER_SIZE } + { reuse GL_MAX_VERTEX_UNIFORM_BLOCKS } + { reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS } + { reuse GL_MAX_COMBINED_UNIFORM_BLOCKS } + { reuse GL_MAX_UNIFORM_BUFFER_BINDINGS } + { reuse GL_MAX_UNIFORM_BLOCK_SIZE } + { reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS } + { reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS } + { reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT } + { reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH } + { reuse GL_ACTIVE_UNIFORM_BLOCKS } + { reuse GL_UNIFORM_TYPE } + { reuse GL_UNIFORM_SIZE } + { reuse GL_UNIFORM_NAME_LENGTH } + { reuse GL_UNIFORM_BLOCK_INDEX } + { reuse GL_UNIFORM_OFFSET } + { reuse GL_UNIFORM_ARRAY_STRIDE } + { reuse GL_UNIFORM_MATRIX_STRIDE } + { reuse GL_UNIFORM_IS_ROW_MAJOR } + { reuse GL_UNIFORM_BLOCK_BINDING } + { reuse GL_UNIFORM_BLOCK_DATA_SIZE } + { reuse GL_UNIFORM_BLOCK_NAME_LENGTH } + { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS } + { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES } + { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER } + { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER } + { reuse GL_INVALID_INDEX } + + // GL_VERSION_3_2 + GL_CONTEXT_CORE_PROFILE_BIT = $00000001; + GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002; + GL_LINES_ADJACENCY = $000A; + GL_LINE_STRIP_ADJACENCY = $000B; + GL_TRIANGLES_ADJACENCY = $000C; + GL_TRIANGLE_STRIP_ADJACENCY = $000D; + GL_PROGRAM_POINT_SIZE = $8642; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8; + GL_GEOMETRY_SHADER = $8DD9; + GL_GEOMETRY_VERTICES_OUT = $8916; + GL_GEOMETRY_INPUT_TYPE = $8917; + GL_GEOMETRY_OUTPUT_TYPE = $8918; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1; + GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122; + GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123; + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124; + GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125; + GL_CONTEXT_PROFILE_MASK = $9126; + { reuse GL_MAX_VARYING_COMPONENTS } + { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } + { Reuse tokens from ARB_depth_clamp } + { reuse GL_DEPTH_CLAMP } + { Reuse tokens from ARB_draw_elements_base_vertex (none) } + { Reuse tokens from ARB_fragment_coord_conventions (none) } + { Reuse tokens from ARB_provoking_vertex } + { reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION } + { reuse GL_FIRST_VERTEX_CONVENTION } + { reuse GL_LAST_VERTEX_CONVENTION } + { reuse GL_PROVOKING_VERTEX } + { Reuse tokens from ARB_seamless_cube_map } + { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS } + { Reuse tokens from ARB_sync } + { reuse GL_MAX_SERVER_WAIT_TIMEOUT } + { reuse GL_OBJECT_TYPE } + { reuse GL_SYNC_CONDITION } + { reuse GL_SYNC_STATUS } + { reuse GL_SYNC_FLAGS } + { reuse GL_SYNC_FENCE } + { reuse GL_SYNC_GPU_COMMANDS_COMPLETE } + { reuse GL_UNSIGNALED } + { reuse GL_SIGNALED } + { reuse GL_ALREADY_SIGNALED } + { reuse GL_TIMEOUT_EXPIRED } + { reuse GL_CONDITION_SATISFIED } + { reuse GL_WAIT_FAILED } + { reuse GL_TIMEOUT_IGNORED } + { reuse GL_SYNC_FLUSH_COMMANDS_BIT } + { reuse GL_TIMEOUT_IGNORED } + { Reuse tokens from ARB_texture_multisample } + { reuse GL_SAMPLE_POSITION } + { reuse GL_SAMPLE_MASK } + { reuse GL_SAMPLE_MASK_VALUE } + { reuse GL_MAX_SAMPLE_MASK_WORDS } + { reuse GL_TEXTURE_2D_MULTISAMPLE } + { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE } + { reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY } + { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY } + { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE } + { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY } + { reuse GL_TEXTURE_SAMPLES } + { reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS } + { reuse GL_SAMPLER_2D_MULTISAMPLE } + { reuse GL_INT_SAMPLER_2D_MULTISAMPLE } + { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE } + { reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY } + { reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY } + { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY } + { reuse GL_MAX_COLOR_TEXTURE_SAMPLES } + { reuse GL_MAX_DEPTH_TEXTURE_SAMPLES } + { reuse GL_MAX_INTEGER_SAMPLES } + { Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core } + + // GL_VERSION_3_3 + GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE; + { Reuse tokens from ARB_blend_func_extended } + { reuse GL_SRC1_COLOR } + { reuse GL_ONE_MINUS_SRC1_COLOR } + { reuse GL_ONE_MINUS_SRC1_ALPHA } + { reuse GL_MAX_DUAL_SOURCE_DRAW_BUFFERS } + { Reuse tokens from ARB_explicit_attrib_location (none) } + { Reuse tokens from ARB_occlusion_query2 } + { reuse GL_ANY_SAMPLES_PASSED } + { Reuse tokens from ARB_sampler_objects } + { reuse GL_SAMPLER_BINDING } + { Reuse tokens from ARB_shader_bit_encoding (none) } + { Reuse tokens from ARB_texture_rgb10_a2ui } + { reuse GL_RGB10_A2UI } + { Reuse tokens from ARB_texture_swizzle } + { reuse GL_TEXTURE_SWIZZLE_R } + { reuse GL_TEXTURE_SWIZZLE_G } + { reuse GL_TEXTURE_SWIZZLE_B } + { reuse GL_TEXTURE_SWIZZLE_A } + { reuse GL_TEXTURE_SWIZZLE_RGBA } + { Reuse tokens from ARB_timer_query } + { reuse GL_TIME_ELAPSED } + { reuse GL_TIMESTAMP } + { Reuse tokens from ARB_vertex_type_2_10_10_10_rev } + { reuse GL_INT_2_10_10_10_REV } + + // GL_VERSION_4_0 + GL_SAMPLE_SHADING = $8C36; + GL_MIN_SAMPLE_SHADING_VALUE = $8C37; + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F; + GL_TEXTURE_CUBE_MAP_ARRAY = $9009; + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A; + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B; + 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; + { Reuse tokens from ARB_texture_query_lod (none) } + { Reuse tokens from ARB_draw_buffers_blend (none) } + { Reuse tokens from ARB_draw_indirect } + { reuse GL_DRAW_INDIRECT_BUFFER } + { reuse GL_DRAW_INDIRECT_BUFFER_BINDING } + { Reuse tokens from ARB_gpu_shader5 } + { reuse GL_GEOMETRY_SHADER_INVOCATIONS } + { reuse GL_MAX_GEOMETRY_SHADER_INVOCATIONS } + { reuse GL_MIN_FRAGMENT_INTERPOLATION_OFFSET } + { reuse GL_MAX_FRAGMENT_INTERPOLATION_OFFSET } + { reuse GL_FRAGMENT_INTERPOLATION_OFFSET_BITS } + { reuse GL_MAX_VERTEX_STREAMS } + { Reuse tokens from ARB_gpu_shader_fp64 } + { reuse GL_DOUBLE_VEC2 } + { reuse GL_DOUBLE_VEC3 } + { reuse GL_DOUBLE_VEC4 } + { reuse GL_DOUBLE_MAT2 } + { reuse GL_DOUBLE_MAT3 } + { reuse GL_DOUBLE_MAT4 } + { reuse GL_DOUBLE_MAT2x3 } + { reuse GL_DOUBLE_MAT2x4 } + { reuse GL_DOUBLE_MAT3x2 } + { reuse GL_DOUBLE_MAT3x4 } + { reuse GL_DOUBLE_MAT4x2 } + { reuse GL_DOUBLE_MAT4x3 } + { Reuse tokens from ARB_shader_subroutine } + { reuse GL_ACTIVE_SUBROUTINES } + { reuse GL_ACTIVE_SUBROUTINE_UNIFORMS } + { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS } + { reuse GL_ACTIVE_SUBROUTINE_MAX_LENGTH } + { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH } + { reuse GL_MAX_SUBROUTINES } + { reuse GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS } + { reuse GL_NUM_COMPATIBLE_SUBROUTINES } + { reuse GL_COMPATIBLE_SUBROUTINES } + { Reuse tokens from ARB_tessellation_shader } + { reuse GL_PATCHES } + { reuse GL_PATCH_VERTICES } + { reuse GL_PATCH_DEFAULT_INNER_LEVEL } + { reuse GL_PATCH_DEFAULT_OUTER_LEVEL } + { reuse GL_TESS_CONTROL_OUTPUT_VERTICES } + { reuse GL_TESS_GEN_MODE } + { reuse GL_TESS_GEN_SPACING } + { reuse GL_TESS_GEN_VERTEX_ORDER } + { reuse GL_TESS_GEN_POINT_MODE } + { reuse GL_ISOLINES } + { reuse GL_FRACTIONAL_ODD } + { reuse GL_FRACTIONAL_EVEN } + { reuse GL_MAX_PATCH_VERTICES } + { reuse GL_MAX_TESS_GEN_LEVEL } + { reuse GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS } + { reuse GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS } + { reuse GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS } + { reuse GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS } + { reuse GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS } + { reuse GL_MAX_TESS_PATCH_COMPONENTS } + { reuse GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS } + { reuse GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS } + { reuse GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS } + { reuse GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS } + { reuse GL_MAX_TESS_CONTROL_INPUT_COMPONENTS } + { reuse GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS } + { reuse GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS } + { reuse GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS } + { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER } + { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER } + { reuse GL_TESS_EVALUATION_SHADER } + { reuse GL_TESS_CONTROL_SHADER } + { Reuse tokens from ARB_texture_buffer_object_rgb32 (none) } + { Reuse tokens from ARB_transform_feedback2 } + { reuse GL_TRANSFORM_FEEDBACK } + { reuse GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED } + { reuse GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE } + { reuse GL_TRANSFORM_FEEDBACK_BINDING } + { Reuse tokens from ARB_transform_feedback3 } + { reuse GL_MAX_TRANSFORM_FEEDBACK_BUFFERS } + { reuse GL_MAX_VERTEX_STREAMS } + + // GL_VERSION_4_1 + { Reuse tokens from ARB_ES2_compatibility } + { reuse GL_FIXED } + { reuse GL_IMPLEMENTATION_COLOR_READ_TYPE } + { reuse GL_IMPLEMENTATION_COLOR_READ_FORMAT } + { reuse GL_LOW_FLOAT } + { reuse GL_MEDIUM_FLOAT } + { reuse GL_HIGH_FLOAT } + { reuse GL_LOW_INT } + { reuse GL_MEDIUM_INT } + { reuse GL_HIGH_INT } + { reuse GL_SHADER_COMPILER } + { reuse GL_NUM_SHADER_BINARY_FORMATS } + { reuse GL_MAX_VERTEX_UNIFORM_VECTORS } + { reuse GL_MAX_VARYING_VECTORS } + { reuse GL_MAX_FRAGMENT_UNIFORM_VECTORS } + { reuse GL_RGB565 } + { Reuse tokens from ARB_get_program_binary } + { reuse GL_PROGRAM_BINARY_RETRIEVABLE_HINT } + { reuse GL_PROGRAM_BINARY_LENGTH } + { reuse GL_NUM_PROGRAM_BINARY_FORMATS } + { reuse GL_PROGRAM_BINARY_FORMATS } + { Reuse tokens from ARB_separate_shader_objects } + { reuse GL_VERTEX_SHADER_BIT } + { reuse GL_FRAGMENT_SHADER_BIT } + { reuse GL_GEOMETRY_SHADER_BIT } + { reuse GL_TESS_CONTROL_SHADER_BIT } + { reuse GL_TESS_EVALUATION_SHADER_BIT } + { reuse GL_ALL_SHADER_BITS } + { reuse GL_PROGRAM_SEPARABLE } + { reuse GL_ACTIVE_PROGRAM } + { reuse GL_PROGRAM_PIPELINE_BINDING } + { Reuse tokens from ARB_shader_precision (none) } + { Reuse tokens from ARB_vertex_attrib_64bit - all are in GL 3.0 and 4.0 already } + { Reuse tokens from ARB_viewport_array - some are in GL 1.1 and ARB_provoking_vertex already } + { reuse GL_MAX_VIEWPORTS } + { reuse GL_VIEWPORT_SUBPIXEL_BITS } + { reuse GL_VIEWPORT_BOUNDS_RANGE } + { reuse GL_LAYER_PROVOKING_VERTEX } + { reuse GL_VIEWPORT_INDEX_PROVOKING_VERTEX } + { reuse GL_UNDEFINED_VERTEX } + + // GL_VERSION_4_2 + { Reuse tokens from ARB_base_instance (none) } + { Reuse tokens from ARB_shading_language_420pack (none) } + { Reuse tokens from ARB_transform_feedback_instanced (none) } + { Reuse tokens from ARB_compressed_texture_pixel_storage } + { reuse GL_UNPACK_COMPRESSED_BLOCK_WIDTH } + { reuse GL_UNPACK_COMPRESSED_BLOCK_HEIGHT } + { reuse GL_UNPACK_COMPRESSED_BLOCK_DEPTH } + { reuse GL_UNPACK_COMPRESSED_BLOCK_SIZE } + { reuse GL_PACK_COMPRESSED_BLOCK_WIDTH } + { reuse GL_PACK_COMPRESSED_BLOCK_HEIGHT } + { reuse GL_PACK_COMPRESSED_BLOCK_DEPTH } + { reuse GL_PACK_COMPRESSED_BLOCK_SIZE } + { Reuse tokens from ARB_conservative_depth (none) } + { Reuse tokens from ARB_internalformat_query } + { reuse GL_NUM_SAMPLE_COUNTS } + { Reuse tokens from ARB_map_buffer_alignment } + { reuse GL_MIN_MAP_BUFFER_ALIGNMENT } + { Reuse tokens from ARB_shader_atomic_counters } + { reuse GL_ATOMIC_COUNTER_BUFFER } + { reuse GL_ATOMIC_COUNTER_BUFFER_BINDING } + { reuse GL_ATOMIC_COUNTER_BUFFER_START } + { reuse GL_ATOMIC_COUNTER_BUFFER_SIZE } + { reuse GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE } + { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS } + { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER } + { reuse GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_VERTEX_ATOMIC_COUNTERS } + { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS } + { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS } + { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTERS } + { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTERS } + { reuse GL_MAX_COMBINED_ATOMIC_COUNTERS } + { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE } + { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS } + { reuse GL_ACTIVE_ATOMIC_COUNTER_BUFFERS } + { reuse GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX } + { reuse GL_UNSIGNED_INT_ATOMIC_COUNTER } + { Reuse tokens from ARB_shader_image_load_store } + { reuse GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT } + { reuse GL_ELEMENT_ARRAY_BARRIER_BIT } + { reuse GL_UNIFORM_BARRIER_BIT } + { reuse GL_TEXTURE_FETCH_BARRIER_BIT } + { reuse GL_SHADER_IMAGE_ACCESS_BARRIER_BIT } + { reuse GL_COMMAND_BARRIER_BIT } + { reuse GL_PIXEL_BUFFER_BARRIER_BIT } + { reuse GL_TEXTURE_UPDATE_BARRIER_BIT } + { reuse GL_BUFFER_UPDATE_BARRIER_BIT } + { reuse GL_FRAMEBUFFER_BARRIER_BIT } + { reuse GL_TRANSFORM_FEEDBACK_BARRIER_BIT } + { reuse GL_ATOMIC_COUNTER_BARRIER_BIT } + { reuse GL_ALL_BARRIER_BITS } + { reuse GL_MAX_IMAGE_UNITS } + { reuse GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS } + { reuse GL_IMAGE_BINDING_NAME } + { reuse GL_IMAGE_BINDING_LEVEL } + { reuse GL_IMAGE_BINDING_LAYERED } + { reuse GL_IMAGE_BINDING_LAYER } + { reuse GL_IMAGE_BINDING_ACCESS } + { reuse GL_IMAGE_1D } + { reuse GL_IMAGE_2D } + { reuse GL_IMAGE_3D } + { reuse GL_IMAGE_2D_RECT } + { reuse GL_IMAGE_CUBE } + { reuse GL_IMAGE_BUFFER } + { reuse GL_IMAGE_1D_ARRAY } + { reuse GL_IMAGE_2D_ARRAY } + { reuse GL_IMAGE_CUBE_MAP_ARRAY } + { reuse GL_IMAGE_2D_MULTISAMPLE } + { reuse GL_IMAGE_2D_MULTISAMPLE_ARRAY } + { reuse GL_INT_IMAGE_1D } + { reuse GL_INT_IMAGE_2D } + { reuse GL_INT_IMAGE_3D } + { reuse GL_INT_IMAGE_2D_RECT } + { reuse GL_INT_IMAGE_CUBE } + { reuse GL_INT_IMAGE_BUFFER } + { reuse GL_INT_IMAGE_1D_ARRAY } + { reuse GL_INT_IMAGE_2D_ARRAY } + { reuse GL_INT_IMAGE_CUBE_MAP_ARRAY } + { reuse GL_INT_IMAGE_2D_MULTISAMPLE } + { reuse GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY } + { reuse GL_UNSIGNED_INT_IMAGE_1D } + { reuse GL_UNSIGNED_INT_IMAGE_2D } + { reuse GL_UNSIGNED_INT_IMAGE_3D } + { reuse GL_UNSIGNED_INT_IMAGE_2D_RECT } + { reuse GL_UNSIGNED_INT_IMAGE_CUBE } + { reuse GL_UNSIGNED_INT_IMAGE_BUFFER } + { reuse GL_UNSIGNED_INT_IMAGE_1D_ARRAY } + { reuse GL_UNSIGNED_INT_IMAGE_2D_ARRAY } + { reuse GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY } + { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE } + { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY } + { reuse GL_MAX_IMAGE_SAMPLES } + { reuse GL_IMAGE_BINDING_FORMAT } + { reuse GL_IMAGE_FORMAT_COMPATIBILITY_TYPE } + { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE } + { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS } + { reuse GL_MAX_VERTEX_IMAGE_UNIFORMS } + { reuse GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS } + { reuse GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS } + { reuse GL_MAX_GEOMETRY_IMAGE_UNIFORMS } + { reuse GL_MAX_FRAGMENT_IMAGE_UNIFORMS } + { reuse GL_MAX_COMBINED_IMAGE_UNIFORMS } + { Reuse tokens from ARB_shading_language_packing (none) } + { Reuse tokens from ARB_texture_storage } + { reuse GL_TEXTURE_IMMUTABLE_FORMAT } + + // GL_VERSION_4_3 + GL_NUM_SHADING_LANGUAGE_VERSIONS = $82E9; + GL_VERTEX_ATTRIB_ARRAY_LONG = $874E; + { Reuse tokens from ARB_arrays_of_arrays (none, GLSL only) } + { Reuse tokens from ARB_fragment_layer_viewport (none, GLSL only) } + { Reuse tokens from ARB_shader_image_size (none, GLSL only) } + { Reuse tokens from ARB_ES3_compatibility } + { reuse GL_COMPRESSED_RGB8_ETC2 } + { reuse GL_COMPRESSED_SRGB8_ETC2 } + { reuse GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 } + { reuse GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 } + { reuse GL_COMPRESSED_RGBA8_ETC2_EAC } + { reuse GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC } + { reuse GL_COMPRESSED_R11_EAC } + { reuse GL_COMPRESSED_SIGNED_R11_EAC } + { reuse GL_COMPRESSED_RG11_EAC } + { reuse GL_COMPRESSED_SIGNED_RG11_EAC } + { reuse GL_PRIMITIVE_RESTART_FIXED_INDEX } + { reuse GL_ANY_SAMPLES_PASSED_CONSERVATIVE } + { reuse GL_MAX_ELEMENT_INDEX } + { Reuse tokens from ARB_clear_buffer_object (none) } + { Reuse tokens from ARB_compute_shader } + { reuse GL_COMPUTE_SHADER } + { reuse GL_MAX_COMPUTE_UNIFORM_BLOCKS } + { reuse GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS } + { reuse GL_MAX_COMPUTE_IMAGE_UNIFORMS } + { reuse GL_MAX_COMPUTE_SHARED_MEMORY_SIZE } + { reuse GL_MAX_COMPUTE_UNIFORM_COMPONENTS } + { reuse GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS } + { reuse GL_MAX_COMPUTE_ATOMIC_COUNTERS } + { reuse GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS } + { reuse GL_MAX_COMPUTE_LOCAL_INVOCATIONS } + { reuse GL_MAX_COMPUTE_WORK_GROUP_COUNT } + { reuse GL_MAX_COMPUTE_WORK_GROUP_SIZE } + { reuse GL_COMPUTE_LOCAL_WORK_SIZE } + { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER } + { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER } + { reuse GL_DISPATCH_INDIRECT_BUFFER } + { reuse GL_DISPATCH_INDIRECT_BUFFER_BINDING } + { Reuse tokens from ARB_copy_image (none) } + { Reuse tokens from KHR_debug } + { reuse GL_DEBUG_OUTPUT_SYNCHRONOUS } + { reuse GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH } + { reuse GL_DEBUG_CALLBACK_FUNCTION } + { reuse GL_DEBUG_CALLBACK_USER_PARAM } + { reuse GL_DEBUG_SOURCE_API } + { reuse GL_DEBUG_SOURCE_WINDOW_SYSTEM } + { reuse GL_DEBUG_SOURCE_SHADER_COMPILER } + { reuse GL_DEBUG_SOURCE_THIRD_PARTY } + { reuse GL_DEBUG_SOURCE_APPLICATION } + { reuse GL_DEBUG_SOURCE_OTHER } + { reuse GL_DEBUG_TYPE_ERROR } + { reuse GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR } + { reuse GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR } + { reuse GL_DEBUG_TYPE_PORTABILITY } + { reuse GL_DEBUG_TYPE_PERFORMANCE } + { reuse GL_DEBUG_TYPE_OTHER } + { reuse GL_MAX_DEBUG_MESSAGE_LENGTH } + { reuse GL_MAX_DEBUG_LOGGED_MESSAGES } + { reuse GL_DEBUG_LOGGED_MESSAGES } + { reuse GL_DEBUG_SEVERITY_HIGH } + { reuse GL_DEBUG_SEVERITY_MEDIUM } + { reuse GL_DEBUG_SEVERITY_LOW } + { reuse GL_DEBUG_TYPE_MARKER } + { reuse GL_DEBUG_TYPE_PUSH_GROUP } + { reuse GL_DEBUG_TYPE_POP_GROUP } + { reuse GL_DEBUG_SEVERITY_NOTIFICATION } + { reuse GL_MAX_DEBUG_GROUP_STACK_DEPTH } + { reuse GL_DEBUG_GROUP_STACK_DEPTH } + { reuse GL_BUFFER } + { reuse GL_SHADER } + { reuse GL_PROGRAM } + { reuse GL_QUERY } + { reuse GL_PROGRAM_PIPELINE } + { reuse GL_SAMPLER } + { reuse GL_DISPLAY_LIST } + { reuse GL_MAX_LABEL_LENGTH } + { reuse GL_DEBUG_OUTPUT } + { reuse GL_CONTEXT_FLAG_DEBUG_BIT } + { reuse GL_STACK_UNDERFLOW } + { reuse GL_STACK_OVERFLOW } + { Reuse tokens from ARB_explicit_uniform_location } + { reuse GL_MAX_UNIFORM_LOCATIONS } + { Reuse tokens from ARB_framebuffer_no_attachments } + { reuse GL_FRAMEBUFFER_DEFAULT_WIDTH } + { reuse GL_FRAMEBUFFER_DEFAULT_HEIGHT } + { reuse GL_FRAMEBUFFER_DEFAULT_LAYERS } + { reuse GL_FRAMEBUFFER_DEFAULT_SAMPLES } + { reuse GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS } + { reuse GL_MAX_FRAMEBUFFER_WIDTH } + { reuse GL_MAX_FRAMEBUFFER_HEIGHT } + { reuse GL_MAX_FRAMEBUFFER_LAYERS } + { reuse GL_MAX_FRAMEBUFFER_SAMPLES } + { Reuse tokens from ARB_internalformat_query2 } + { reuse GL_INTERNALFORMAT_SUPPORTED } + { reuse GL_INTERNALFORMAT_PREFERRED } + { reuse GL_INTERNALFORMAT_RED_SIZE } + { reuse GL_INTERNALFORMAT_GREEN_SIZE } + { reuse GL_INTERNALFORMAT_BLUE_SIZE } + { reuse GL_INTERNALFORMAT_ALPHA_SIZE } + { reuse GL_INTERNALFORMAT_DEPTH_SIZE } + { reuse GL_INTERNALFORMAT_STENCIL_SIZE } + { reuse GL_INTERNALFORMAT_SHARED_SIZE } + { reuse GL_INTERNALFORMAT_RED_TYPE } + { reuse GL_INTERNALFORMAT_GREEN_TYPE } + { reuse GL_INTERNALFORMAT_BLUE_TYPE } + { reuse GL_INTERNALFORMAT_ALPHA_TYPE } + { reuse GL_INTERNALFORMAT_DEPTH_TYPE } + { reuse GL_INTERNALFORMAT_STENCIL_TYPE } + { reuse GL_MAX_WIDTH } + { reuse GL_MAX_HEIGHT } + { reuse GL_MAX_DEPTH } + { reuse GL_MAX_LAYERS } + { reuse GL_MAX_COMBINED_DIMENSIONS } + { reuse GL_COLOR_COMPONENTS } + { reuse GL_DEPTH_COMPONENTS } + { reuse GL_STENCIL_COMPONENTS } + { reuse GL_COLOR_RENDERABLE } + { reuse GL_DEPTH_RENDERABLE } + { reuse GL_STENCIL_RENDERABLE } + { reuse GL_FRAMEBUFFER_RENDERABLE } + { reuse GL_FRAMEBUFFER_RENDERABLE_LAYERED } + { reuse GL_FRAMEBUFFER_BLEND } + { reuse GL_READ_PIXELS } + { reuse GL_READ_PIXELS_FORMAT } + { reuse GL_READ_PIXELS_TYPE } + { reuse GL_TEXTURE_IMAGE_FORMAT } + { reuse GL_TEXTURE_IMAGE_TYPE } + { reuse GL_GET_TEXTURE_IMAGE_FORMAT } + { reuse GL_GET_TEXTURE_IMAGE_TYPE } + { reuse GL_MIPMAP } + { reuse GL_MANUAL_GENERATE_MIPMAP } + { reuse GL_AUTO_GENERATE_MIPMAP } + { reuse GL_COLOR_ENCODING } + { reuse GL_SRGB_READ } + { reuse GL_SRGB_WRITE } + { reuse GL_FILTER } + { reuse GL_VERTEX_TEXTURE } + { reuse GL_TESS_CONTROL_TEXTURE } + { reuse GL_TESS_EVALUATION_TEXTURE } + { reuse GL_GEOMETRY_TEXTURE } + { reuse GL_FRAGMENT_TEXTURE } + { reuse GL_COMPUTE_TEXTURE } + { reuse GL_TEXTURE_SHADOW } + { reuse GL_TEXTURE_GATHER } + { reuse GL_TEXTURE_GATHER_SHADOW } + { reuse GL_SHADER_IMAGE_LOAD } + { reuse GL_SHADER_IMAGE_STORE } + { reuse GL_SHADER_IMAGE_ATOMIC } + { reuse GL_IMAGE_TEXEL_SIZE } + { reuse GL_IMAGE_COMPATIBILITY_CLASS } + { reuse GL_IMAGE_PIXEL_FORMAT } + { reuse GL_IMAGE_PIXEL_TYPE } + { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST } + { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST } + { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE } + { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE } + { reuse GL_TEXTURE_COMPRESSED_BLOCK_WIDTH } + { reuse GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT } + { reuse GL_TEXTURE_COMPRESSED_BLOCK_SIZE } + { reuse GL_CLEAR_BUFFER } + { reuse GL_TEXTURE_VIEW } + { reuse GL_VIEW_COMPATIBILITY_CLASS } + { reuse GL_FULL_SUPPORT } + { reuse GL_CAVEAT_SUPPORT } + { reuse GL_IMAGE_CLASS_4_X_32 } + { reuse GL_IMAGE_CLASS_2_X_32 } + { reuse GL_IMAGE_CLASS_1_X_32 } + { reuse GL_IMAGE_CLASS_4_X_16 } + { reuse GL_IMAGE_CLASS_2_X_16 } + { reuse GL_IMAGE_CLASS_1_X_16 } + { reuse GL_IMAGE_CLASS_4_X_8 } + { reuse GL_IMAGE_CLASS_2_X_8 } + { reuse GL_IMAGE_CLASS_1_X_8 } + { reuse GL_IMAGE_CLASS_11_11_10 } + { reuse GL_IMAGE_CLASS_10_10_10_2 } + { reuse GL_VIEW_CLASS_128_BITS } + { reuse GL_VIEW_CLASS_96_BITS } + { reuse GL_VIEW_CLASS_64_BITS } + { reuse GL_VIEW_CLASS_48_BITS } + { reuse GL_VIEW_CLASS_32_BITS } + { reuse GL_VIEW_CLASS_24_BITS } + { reuse GL_VIEW_CLASS_16_BITS } + { reuse GL_VIEW_CLASS_8_BITS } + { reuse GL_VIEW_CLASS_S3TC_DXT1_RGB } + { reuse GL_VIEW_CLASS_S3TC_DXT1_RGBA } + { reuse GL_VIEW_CLASS_S3TC_DXT3_RGBA } + { reuse GL_VIEW_CLASS_S3TC_DXT5_RGBA } + { reuse GL_VIEW_CLASS_RGTC1_RED } + { reuse GL_VIEW_CLASS_RGTC2_RG } + { reuse GL_VIEW_CLASS_BPTC_UNORM } + { reuse GL_VIEW_CLASS_BPTC_FLOAT } + { Reuse tokens from ARB_invalidate_subdata (none) } + { Reuse tokens from ARB_multi_draw_indirect (none) } + { Reuse tokens from ARB_program_interface_query } + { reuse GL_UNIFORM } + { reuse GL_UNIFORM_BLOCK } + { reuse GL_PROGRAM_INPUT } + { reuse GL_PROGRAM_OUTPUT } + { reuse GL_BUFFER_VARIABLE } + { reuse GL_SHADER_STORAGE_BLOCK } + { reuse GL_VERTEX_SUBROUTINE } + { reuse GL_TESS_CONTROL_SUBROUTINE } + { reuse GL_TESS_EVALUATION_SUBROUTINE } + { reuse GL_GEOMETRY_SUBROUTINE } + { reuse GL_FRAGMENT_SUBROUTINE } + { reuse GL_COMPUTE_SUBROUTINE } + { reuse GL_VERTEX_SUBROUTINE_UNIFORM } + { reuse GL_TESS_CONTROL_SUBROUTINE_UNIFORM } + { reuse GL_TESS_EVALUATION_SUBROUTINE_UNIFORM } + { reuse GL_GEOMETRY_SUBROUTINE_UNIFORM } + { reuse GL_FRAGMENT_SUBROUTINE_UNIFORM } + { reuse GL_COMPUTE_SUBROUTINE_UNIFORM } + { reuse GL_TRANSFORM_FEEDBACK_VARYING } + { reuse GL_ACTIVE_RESOURCES } + { reuse GL_MAX_NAME_LENGTH } + { reuse GL_MAX_NUM_ACTIVE_VARIABLES } + { reuse GL_MAX_NUM_COMPATIBLE_SUBROUTINES } + { reuse GL_NAME_LENGTH } + { reuse GL_TYPE } + { reuse GL_ARRAY_SIZE } + { reuse GL_OFFSET } + { reuse GL_BLOCK_INDEX } + { reuse GL_ARRAY_STRIDE } + { reuse GL_MATRIX_STRIDE } + { reuse GL_IS_ROW_MAJOR } + { reuse GL_ATOMIC_COUNTER_BUFFER_INDEX } + { reuse GL_BUFFER_BINDING } + { reuse GL_BUFFER_DATA_SIZE } + { reuse GL_NUM_ACTIVE_VARIABLES } + { reuse GL_ACTIVE_VARIABLES } + { reuse GL_REFERENCED_BY_VERTEX_SHADER } + { reuse GL_REFERENCED_BY_TESS_CONTROL_SHADER } + { reuse GL_REFERENCED_BY_TESS_EVALUATION_SHADER } + { reuse GL_REFERENCED_BY_GEOMETRY_SHADER } + { reuse GL_REFERENCED_BY_FRAGMENT_SHADER } + { reuse GL_REFERENCED_BY_COMPUTE_SHADER } + { reuse GL_TOP_LEVEL_ARRAY_SIZE } + { reuse GL_TOP_LEVEL_ARRAY_STRIDE } + { reuse GL_LOCATION } + { reuse GL_LOCATION_INDEX } + { reuse GL_IS_PER_PATCH } + { Reuse tokens from ARB_robust_buffer_access_behavior (none) } + { Reuse tokens from ARB_shader_storage_buffer_object } + { reuse GL_SHADER_STORAGE_BUFFER } + { reuse GL_SHADER_STORAGE_BUFFER_BINDING } + { reuse GL_SHADER_STORAGE_BUFFER_START } + { reuse GL_SHADER_STORAGE_BUFFER_SIZE } + { reuse GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS } + { reuse GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS } + { reuse GL_MAX_SHADER_STORAGE_BLOCK_SIZE } + { reuse GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT } + { reuse GL_SHADER_STORAGE_BARRIER_BIT } + { reuse GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES } + { Reuse tokens from ARB_stencil_texturing } + { reuse GL_DEPTH_STENCIL_TEXTURE_MODE } + { Reuse tokens from ARB_texture_buffer_range } + { reuse GL_TEXTURE_BUFFER_OFFSET } + { reuse GL_TEXTURE_BUFFER_SIZE } + { reuse GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT } + { Reuse tokens from ARB_texture_query_levels (none) } + { Reuse tokens from ARB_texture_storage_multisample (none) } + { Reuse tokens from ARB_texture_view } + { reuse GL_TEXTURE_VIEW_MIN_LEVEL } + { reuse GL_TEXTURE_VIEW_NUM_LEVELS } + { reuse GL_TEXTURE_VIEW_MIN_LAYER } + { reuse GL_TEXTURE_VIEW_NUM_LAYERS } + { reuse GL_TEXTURE_IMMUTABLE_LEVELS } + { Reuse tokens from ARB_vertex_attrib_binding } + { reuse GL_VERTEX_ATTRIB_BINDING } + { reuse GL_VERTEX_ATTRIB_RELATIVE_OFFSET } + { reuse GL_VERTEX_BINDING_DIVISOR } + { reuse GL_VERTEX_BINDING_OFFSET } + { reuse GL_VERTEX_BINDING_STRIDE } + { reuse GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET } + { reuse GL_MAX_VERTEX_ATTRIB_BINDINGS } + + + // GL_3DFX_multisample + GL_MULTISAMPLE_3DFX = $86B2; + GL_SAMPLE_BUFFERS_3DFX = $86B3; + GL_SAMPLES_3DFX = $86B4; + GL_MULTISAMPLE_BIT_3DFX = $20000000; + + // GL_3DFX_texture_compression_FXT1 + GL_COMPRESSED_RGB_FXT1_3DFX = $86B0; + GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1; + + // GL_APPLE_client_storage + GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2; + + // GL_APPLE_element_array + GL_ELEMENT_ARRAY_APPLE = $8A0C; + GL_ELEMENT_ARRAY_TYPE_APPLE = $8A0D; + GL_ELEMENT_ARRAY_POINTER_APPLE = $8A0E; + + // GL_APPLE_fence + GL_DRAW_PIXELS_APPLE = $8A0A; + GL_FENCE_APPLE = $8A0B; + + // GL_APPLE_specular_vector + GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0; + + // GL_APPLE_transform_hint + GL_TRANSFORM_HINT_APPLE = $85B1; + + // GL_APPLE_vertex_array_object + GL_VERTEX_ARRAY_BINDING_APPLE = $85B5; + + // GL_APPLE_vertex_array_range + GL_VERTEX_ARRAY_RANGE_APPLE = $851D; + GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E; + GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F; + GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521; + GL_STORAGE_CLIENT_APPLE = $85B4; + GL_STORAGE_CACHED_APPLE = $85BE; + GL_STORAGE_SHARED_APPLE = $85BF; + + // GL_APPLE_ycbcr_422 + GL_YCBCR_422_APPLE = $85B9; + GL_UNSIGNED_SHORT_8_8_APPLE = $85BA; + GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB; + + // GL_APPLE_texture_range + GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7; + GL_TEXTURE_RANGE_POINTER_APPLE = $85B8; + GL_TEXTURE_STORAGE_HINT_APPLE = $85BC; + GL_STORAGE_PRIVATE_APPLE = $85BD; + { reuse GL_STORAGE_CACHED_APPLE } + { reuse GL_STORAGE_SHARED_APPLE } + + // GL_APPLE_float_pixels + GL_HALF_APPLE = $140B; + GL_RGBA_FLOAT32_APPLE = $8814; + GL_RGB_FLOAT32_APPLE = $8815; + GL_ALPHA_FLOAT32_APPLE = $8816; + GL_INTENSITY_FLOAT32_APPLE = $8817; + GL_LUMINANCE_FLOAT32_APPLE = $8818; + GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819; + GL_RGBA_FLOAT16_APPLE = $881A; + GL_RGB_FLOAT16_APPLE = $881B; + GL_ALPHA_FLOAT16_APPLE = $881C; + GL_INTENSITY_FLOAT16_APPLE = $881D; + GL_LUMINANCE_FLOAT16_APPLE = $881E; + GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F; + GL_COLOR_FLOAT_APPLE = $8A0F; + + // GL_APPLE_vertex_program_evaluators + GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00; + GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01; + GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02; + GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03; + GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04; + GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05; + GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06; + GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07; + GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08; + GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09; + + // GL_APPLE_aux_depth_stencil + GL_AUX_DEPTH_STENCIL_APPLE = $8A14; + + // GL_APPLE_object_purgeable + GL_BUFFER_OBJECT_APPLE = $85B3; + GL_RELEASED_APPLE = $8A19; + GL_VOLATILE_APPLE = $8A1A; + GL_RETAINED_APPLE = $8A1B; + GL_UNDEFINED_APPLE = $8A1C; + GL_PURGEABLE_APPLE = $8A1D; + + // GL_APPLE_row_bytes + GL_PACK_ROW_BYTES_APPLE = $8A15; + GL_UNPACK_ROW_BYTES_APPLE = $8A16; + + // GL_APPLE_rgb_422 + { reuse GL_UNSIGNED_SHORT_8_8_APPLE } + { reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE } + + // GL_ARB_depth_texture + GL_DEPTH_COMPONENT16_ARB = $81A5; + GL_DEPTH_COMPONENT24_ARB = $81A6; + GL_DEPTH_COMPONENT32_ARB = $81A7; + GL_TEXTURE_DEPTH_SIZE_ARB = $884A; + GL_DEPTH_TEXTURE_MODE_ARB = $884B; + + // GL_ARB_fragment_program + GL_FRAGMENT_PROGRAM_ARB = $8804; + GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805; + GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806; + GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807; + GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808; + GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809; + GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A; + GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B; + GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C; + GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D; + GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E; + GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F; + GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810; + GL_MAX_TEXTURE_COORDS_ARB = $8871; + GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872; + + // GL_ARB_imaging + GL_CONSTANT_COLOR_ARB = $8001; + 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_FUNC_ADD = $8006; + GL_MIN = $8007; + GL_MAX = $8008; + GL_BLEND_EQUATION = $8009; + GL_FUNC_SUBTRACT = $800A; + GL_FUNC_REVERSE_SUBTRACT = $800B; +{$ifdef DGL_DEPRECATED} + GL_CONVOLUTION_1D = $8010; + GL_CONVOLUTION_2D = $8011; + GL_SEPARABLE_2D = $8012; + GL_CONVOLUTION_BORDER_MODE = $8013; + GL_CONVOLUTION_FILTER_SCALE = $8014; + GL_CONVOLUTION_FILTER_BIAS = $8015; + GL_REDUCE = $8016; + GL_CONVOLUTION_FORMAT = $8017; + GL_CONVOLUTION_WIDTH = $8018; + GL_CONVOLUTION_HEIGHT = $8019; + GL_MAX_CONVOLUTION_WIDTH = $801A; + GL_MAX_CONVOLUTION_HEIGHT = $801B; + GL_POST_CONVOLUTION_RED_SCALE = $801C; + GL_POST_CONVOLUTION_GREEN_SCALE = $801D; + GL_POST_CONVOLUTION_BLUE_SCALE = $801E; + GL_POST_CONVOLUTION_ALPHA_SCALE = $801F; + GL_POST_CONVOLUTION_RED_BIAS = $8020; + GL_POST_CONVOLUTION_GREEN_BIAS = $8021; + GL_POST_CONVOLUTION_BLUE_BIAS = $8022; + GL_POST_CONVOLUTION_ALPHA_BIAS = $8023; + GL_HISTOGRAM = $8024; + GL_PROXY_HISTOGRAM = $8025; + GL_HISTOGRAM_WIDTH = $8026; + GL_HISTOGRAM_FORMAT = $8027; + GL_HISTOGRAM_RED_SIZE = $8028; + GL_HISTOGRAM_GREEN_SIZE = $8029; + GL_HISTOGRAM_BLUE_SIZE = $802A; + GL_HISTOGRAM_ALPHA_SIZE = $802B; + GL_HISTOGRAM_LUMINANCE_SIZE = $802C; + GL_HISTOGRAM_SINK = $802D; + GL_MINMAX = $802E; + GL_MINMAX_FORMAT = $802F; + GL_MINMAX_SINK = $8030; + GL_TABLE_TOO_LARGE = $8031; + GL_COLOR_MATRIX = $80B1; + GL_COLOR_MATRIX_STACK_DEPTH = $80B2; + GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3; + GL_POST_COLOR_MATRIX_RED_SCALE = $80B4; + GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5; + GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6; + GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7; + GL_POST_COLOR_MATRIX_RED_BIAS = $80B8; + GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9; + GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA; + GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB; + GL_COLOR_TABLE = $80D0; + GL_POST_CONVOLUTION_COLOR_TABLE = $80D1; + GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2; + GL_PROXY_COLOR_TABLE = $80D3; + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4; + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5; + GL_COLOR_TABLE_SCALE = $80D6; + GL_COLOR_TABLE_BIAS = $80D7; + GL_COLOR_TABLE_FORMAT = $80D8; + GL_COLOR_TABLE_WIDTH = $80D9; + GL_COLOR_TABLE_RED_SIZE = $80DA; + GL_COLOR_TABLE_GREEN_SIZE = $80DB; + GL_COLOR_TABLE_BLUE_SIZE = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE = $80DF; + GL_CONSTANT_BORDER = $8151; + GL_REPLICATE_BORDER = $8153; + GL_CONVOLUTION_BORDER_COLOR = $8154; +{$endif} + + // GL_ARB_matrix_palette + GL_MATRIX_PALETTE_ARB = $8840; + GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841; + GL_MAX_PALETTE_MATRICES_ARB = $8842; + GL_CURRENT_PALETTE_MATRIX_ARB = $8843; + GL_MATRIX_INDEX_ARRAY_ARB = $8844; + GL_CURRENT_MATRIX_INDEX_ARB = $8845; + GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846; + GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847; + GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848; + GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849; + + // GL_ARB_multisample + GL_MULTISAMPLE_ARB = $809D; + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E; + GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F; + GL_SAMPLE_COVERAGE_ARB = $80A0; + GL_SAMPLE_BUFFERS_ARB = $80A8; + GL_SAMPLES_ARB = $80A9; + GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA; + GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB; + GL_MULTISAMPLE_BIT_ARB = $20000000; + + // GL_ARB_multitexture + GL_TEXTURE0_ARB = $84C0; + GL_TEXTURE1_ARB = $84C1; + GL_TEXTURE2_ARB = $84C2; + GL_TEXTURE3_ARB = $84C3; + GL_TEXTURE4_ARB = $84C4; + GL_TEXTURE5_ARB = $84C5; + GL_TEXTURE6_ARB = $84C6; + GL_TEXTURE7_ARB = $84C7; + GL_TEXTURE8_ARB = $84C8; + GL_TEXTURE9_ARB = $84C9; + GL_TEXTURE10_ARB = $84CA; + GL_TEXTURE11_ARB = $84CB; + GL_TEXTURE12_ARB = $84CC; + GL_TEXTURE13_ARB = $84CD; + GL_TEXTURE14_ARB = $84CE; + GL_TEXTURE15_ARB = $84CF; + GL_TEXTURE16_ARB = $84D0; + GL_TEXTURE17_ARB = $84D1; + GL_TEXTURE18_ARB = $84D2; + GL_TEXTURE19_ARB = $84D3; + GL_TEXTURE20_ARB = $84D4; + GL_TEXTURE21_ARB = $84D5; + GL_TEXTURE22_ARB = $84D6; + GL_TEXTURE23_ARB = $84D7; + GL_TEXTURE24_ARB = $84D8; + GL_TEXTURE25_ARB = $84D9; + GL_TEXTURE26_ARB = $84DA; + GL_TEXTURE27_ARB = $84DB; + GL_TEXTURE28_ARB = $84DC; + GL_TEXTURE29_ARB = $84DD; + GL_TEXTURE30_ARB = $84DE; + GL_TEXTURE31_ARB = $84DF; + GL_ACTIVE_TEXTURE_ARB = $84E0; + GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1; + GL_MAX_TEXTURE_UNITS_ARB = $84E2; + + // GL_ARB_point_parameters + GL_POINT_SIZE_MIN_ARB = $8126; + GL_POINT_SIZE_MAX_ARB = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128; + GL_POINT_DISTANCE_ATTENUATION_ARB = $8129; + + // GL_ARB_shadow + GL_TEXTURE_COMPARE_MODE_ARB = $884C; + GL_TEXTURE_COMPARE_FUNC_ARB = $884D; + GL_COMPARE_R_TO_TEXTURE_ARB = $884E; + + // GL_ARB_shadow_ambient + GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF; + + // GL_ARB_texture_border_clamp + GL_CLAMP_TO_BORDER_ARB = $812D; + + // GL_ARB_texture_compression + GL_COMPRESSED_ALPHA_ARB = $84E9; + GL_COMPRESSED_LUMINANCE_ARB = $84EA; + GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB; + GL_COMPRESSED_INTENSITY_ARB = $84EC; + GL_COMPRESSED_RGB_ARB = $84ED; + GL_COMPRESSED_RGBA_ARB = $84EE; + GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF; + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0; + GL_TEXTURE_COMPRESSED_ARB = $86A1; + GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2; + GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3; + + // GL_ARB_texture_cube_map + GL_NORMAL_MAP_ARB = $8511; + GL_REFLECTION_MAP_ARB = $8512; + GL_TEXTURE_CUBE_MAP_ARB = $8513; + GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514; + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A; + GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C; + + // GL_ARB_texture_env_combine + GL_COMBINE_ARB = $8570; + GL_COMBINE_RGB_ARB = $8571; + GL_COMBINE_ALPHA_ARB = $8572; + GL_SOURCE0_RGB_ARB = $8580; + GL_SOURCE1_RGB_ARB = $8581; + GL_SOURCE2_RGB_ARB = $8582; + GL_SOURCE0_ALPHA_ARB = $8588; + GL_SOURCE1_ALPHA_ARB = $8589; + GL_SOURCE2_ALPHA_ARB = $858A; + GL_OPERAND0_RGB_ARB = $8590; + GL_OPERAND1_RGB_ARB = $8591; + GL_OPERAND2_RGB_ARB = $8592; + GL_OPERAND0_ALPHA_ARB = $8598; + GL_OPERAND1_ALPHA_ARB = $8599; + GL_OPERAND2_ALPHA_ARB = $859A; + GL_RGB_SCALE_ARB = $8573; + GL_ADD_SIGNED_ARB = $8574; + GL_INTERPOLATE_ARB = $8575; + GL_SUBTRACT_ARB = $84E7; + GL_CONSTANT_ARB = $8576; + GL_PRIMARY_COLOR_ARB = $8577; + GL_PREVIOUS_ARB = $8578; + + // GL_ARB_texture_env_dot3 + GL_DOT3_RGB_ARB = $86AE; + GL_DOT3_RGBA_ARB = $86AF; + + // GL_ARB_texture_mirrored_repeat + GL_MIRRORED_REPEAT_ARB = $8370; + + // GL_ARB_transpose_matrix + GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3; + GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4; + GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5; + GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6; + + // GL_ARB_vertex_blend + GL_MAX_VERTEX_UNITS_ARB = $86A4; + GL_ACTIVE_VERTEX_UNITS_ARB = $86A5; + GL_WEIGHT_SUM_UNITY_ARB = $86A6; + GL_VERTEX_BLEND_ARB = $86A7; + GL_CURRENT_WEIGHT_ARB = $86A8; + GL_WEIGHT_ARRAY_TYPE_ARB = $86A9; + GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA; + GL_WEIGHT_ARRAY_SIZE_ARB = $86AB; + GL_WEIGHT_ARRAY_POINTER_ARB = $86AC; + GL_WEIGHT_ARRAY_ARB = $86AD; + GL_MODELVIEW0_ARB = $1700; + GL_MODELVIEW1_ARB = $850A; + GL_MODELVIEW2_ARB = $8722; + GL_MODELVIEW3_ARB = $8723; + GL_MODELVIEW4_ARB = $8724; + GL_MODELVIEW5_ARB = $8725; + GL_MODELVIEW6_ARB = $8726; + GL_MODELVIEW7_ARB = $8727; + GL_MODELVIEW8_ARB = $8728; + GL_MODELVIEW9_ARB = $8729; + GL_MODELVIEW10_ARB = $872A; + GL_MODELVIEW11_ARB = $872B; + GL_MODELVIEW12_ARB = $872C; + GL_MODELVIEW13_ARB = $872D; + GL_MODELVIEW14_ARB = $872E; + GL_MODELVIEW15_ARB = $872F; + GL_MODELVIEW16_ARB = $8730; + GL_MODELVIEW17_ARB = $8731; + GL_MODELVIEW18_ARB = $8732; + GL_MODELVIEW19_ARB = $8733; + GL_MODELVIEW20_ARB = $8734; + GL_MODELVIEW21_ARB = $8735; + GL_MODELVIEW22_ARB = $8736; + GL_MODELVIEW23_ARB = $8737; + GL_MODELVIEW24_ARB = $8738; + GL_MODELVIEW25_ARB = $8739; + GL_MODELVIEW26_ARB = $873A; + GL_MODELVIEW27_ARB = $873B; + GL_MODELVIEW28_ARB = $873C; + GL_MODELVIEW29_ARB = $873D; + GL_MODELVIEW30_ARB = $873E; + GL_MODELVIEW31_ARB = $873F; + + // GL_ARB_vertex_buffer_object + GL_BUFFER_SIZE_ARB = $8764; + GL_BUFFER_USAGE_ARB = $8765; + GL_ARRAY_BUFFER_ARB = $8892; + GL_ELEMENT_ARRAY_BUFFER_ARB = $8893; + GL_ARRAY_BUFFER_BINDING_ARB = $8894; + GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895; + GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896; + GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897; + GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898; + GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899; + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A; + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B; + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C; + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D; + GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E; + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F; + GL_READ_ONLY_ARB = $88B8; + GL_WRITE_ONLY_ARB = $88B9; + GL_READ_WRITE_ARB = $88BA; + GL_BUFFER_ACCESS_ARB = $88BB; + GL_BUFFER_MAPPED_ARB = $88BC; + GL_BUFFER_MAP_POINTER_ARB = $88BD; + GL_STREAM_DRAW_ARB = $88E0; + GL_STREAM_READ_ARB = $88E1; + GL_STREAM_COPY_ARB = $88E2; + GL_STATIC_DRAW_ARB = $88E4; + GL_STATIC_READ_ARB = $88E5; + GL_STATIC_COPY_ARB = $88E6; + GL_DYNAMIC_DRAW_ARB = $88E8; + GL_DYNAMIC_READ_ARB = $88E9; + GL_DYNAMIC_COPY_ARB = $88EA; + + // GL_ARB_vertex_program + GL_COLOR_SUM_ARB = $8458; + GL_VERTEX_PROGRAM_ARB = $8620; + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622; + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623; + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624; + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625; + GL_CURRENT_VERTEX_ATTRIB_ARB = $8626; + GL_PROGRAM_LENGTH_ARB = $8627; + GL_PROGRAM_STRING_ARB = $8628; + GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E; + GL_MAX_PROGRAM_MATRICES_ARB = $862F; + GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640; + GL_CURRENT_MATRIX_ARB = $8641; + GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642; + GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643; + GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645; + GL_PROGRAM_ERROR_POSITION_ARB = $864B; + GL_PROGRAM_BINDING_ARB = $8677; + GL_MAX_VERTEX_ATTRIBS_ARB = $8869; + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A; + GL_PROGRAM_ERROR_STRING_ARB = $8874; + GL_PROGRAM_FORMAT_ASCII_ARB = $8875; + GL_PROGRAM_FORMAT_ARB = $8876; + GL_PROGRAM_INSTRUCTIONS_ARB = $88A0; + GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1; + GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2; + GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3; + GL_PROGRAM_TEMPORARIES_ARB = $88A4; + GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5; + GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6; + GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7; + GL_PROGRAM_PARAMETERS_ARB = $88A8; + GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9; + GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA; + GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB; + GL_PROGRAM_ATTRIBS_ARB = $88AC; + GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD; + GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE; + GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF; + GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0; + GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1; + GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2; + GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3; + GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4; + GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5; + GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6; + GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7; + GL_MATRIX0_ARB = $88C0; + GL_MATRIX1_ARB = $88C1; + GL_MATRIX2_ARB = $88C2; + GL_MATRIX3_ARB = $88C3; + GL_MATRIX4_ARB = $88C4; + GL_MATRIX5_ARB = $88C5; + GL_MATRIX6_ARB = $88C6; + GL_MATRIX7_ARB = $88C7; + GL_MATRIX8_ARB = $88C8; + GL_MATRIX9_ARB = $88C9; + GL_MATRIX10_ARB = $88CA; + GL_MATRIX11_ARB = $88CB; + GL_MATRIX12_ARB = $88CC; + GL_MATRIX13_ARB = $88CD; + GL_MATRIX14_ARB = $88CE; + GL_MATRIX15_ARB = $88CF; + GL_MATRIX16_ARB = $88D0; + GL_MATRIX17_ARB = $88D1; + GL_MATRIX18_ARB = $88D2; + GL_MATRIX19_ARB = $88D3; + GL_MATRIX20_ARB = $88D4; + GL_MATRIX21_ARB = $88D5; + GL_MATRIX22_ARB = $88D6; + GL_MATRIX23_ARB = $88D7; + GL_MATRIX24_ARB = $88D8; + GL_MATRIX25_ARB = $88D9; + GL_MATRIX26_ARB = $88DA; + GL_MATRIX27_ARB = $88DB; + GL_MATRIX28_ARB = $88DC; + GL_MATRIX29_ARB = $88DD; + GL_MATRIX30_ARB = $88DE; + GL_MATRIX31_ARB = $88DF; + + // GL_ARB_draw_buffers + GL_MAX_DRAW_BUFFERS_ARB = $8824; + GL_DRAW_BUFFER0_ARB = $8825; + GL_DRAW_BUFFER1_ARB = $8826; + GL_DRAW_BUFFER2_ARB = $8827; + GL_DRAW_BUFFER3_ARB = $8828; + GL_DRAW_BUFFER4_ARB = $8829; + GL_DRAW_BUFFER5_ARB = $882A; + GL_DRAW_BUFFER6_ARB = $882B; + GL_DRAW_BUFFER7_ARB = $882C; + GL_DRAW_BUFFER8_ARB = $882D; + GL_DRAW_BUFFER9_ARB = $882E; + GL_DRAW_BUFFER10_ARB = $882F; + GL_DRAW_BUFFER11_ARB = $8830; + GL_DRAW_BUFFER12_ARB = $8831; + GL_DRAW_BUFFER13_ARB = $8832; + GL_DRAW_BUFFER14_ARB = $8833; + GL_DRAW_BUFFER15_ARB = $8834; + + // GL_ARB_texture_rectangle + GL_TEXTURE_RECTANGLE_ARB = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8; + + // GL_ARB_color_buffer_float + GL_RGBA_FLOAT_MODE_ARB = $8820; + GL_CLAMP_VERTEX_COLOR_ARB = $891A; + GL_CLAMP_FRAGMENT_COLOR_ARB = $891B; + GL_CLAMP_READ_COLOR_ARB = $891C; + GL_FIXED_ONLY_ARB = $891D; + WGL_TYPE_RGBA_FLOAT_ARB = $21A0; + GLX_RGBA_FLOAT_TYPE = $20B9; + GLX_RGBA_FLOAT_BIT = $00000004; + + // GL_ARB_half_float_pixel + GL_HALF_FLOAT_ARB = $140B; + + // GL_ARB_texture_float + GL_TEXTURE_RED_TYPE_ARB = $8C10; + GL_TEXTURE_GREEN_TYPE_ARB = $8C11; + GL_TEXTURE_BLUE_TYPE_ARB = $8C12; + GL_TEXTURE_ALPHA_TYPE_ARB = $8C13; + GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14; + GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15; + GL_TEXTURE_DEPTH_TYPE_ARB = $8C16; + GL_UNSIGNED_NORMALIZED_ARB = $8C17; + GL_RGBA32F_ARB = $8814; + GL_RGB32F_ARB = $8815; + GL_ALPHA32F_ARB = $8816; + GL_INTENSITY32F_ARB = $8817; + GL_LUMINANCE32F_ARB = $8818; + GL_LUMINANCE_ALPHA32F_ARB = $8819; + GL_RGBA16F_ARB = $881A; + GL_RGB16F_ARB = $881B; + GL_ALPHA16F_ARB = $881C; + GL_INTENSITY16F_ARB = $881D; + GL_LUMINANCE16F_ARB = $881E; + GL_LUMINANCE_ALPHA16F_ARB = $881F; + + // GL_ARB_pixel_buffer_object + GL_PIXEL_PACK_BUFFER_ARB = $88EB; + GL_PIXEL_UNPACK_BUFFER_ARB = $88EC; + GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED; + GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF; + + // GL_ARB_depth_buffer_float + GL_DEPTH_COMPONENT32F = $8CAC; + GL_DEPTH32F_STENCIL8 = $8CAD; + GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD; + + // GL_ARB_framebuffer_object + GL_INVALID_FRAMEBUFFER_OPERATION = $0506; + 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_MAX_RENDERBUFFER_SIZE = $84E8; + GL_DEPTH_STENCIL = $84F9; + GL_UNSIGNED_INT_24_8 = $84FA; + GL_DEPTH24_STENCIL8 = $88F0; + GL_TEXTURE_STENCIL_SIZE = $88F1; + 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_UNSIGNED_NORMALIZED = $8C17; + GL_FRAMEBUFFER_BINDING = $8CA6; + GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING; + GL_RENDERBUFFER_BINDING = $8CA7; + GL_READ_FRAMEBUFFER = $8CA8; + GL_DRAW_FRAMEBUFFER = $8CA9; + GL_READ_FRAMEBUFFER_BINDING = $8CAA; + GL_RENDERBUFFER_SAMPLES = $8CAB; + 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_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4; + GL_FRAMEBUFFER_COMPLETE = $8CD5; + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6; + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7; + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB; + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC; + GL_FRAMEBUFFER_UNSUPPORTED = $8CDD; + GL_MAX_COLOR_ATTACHMENTS = $8CDF; + GL_COLOR_ATTACHMENT0 = $8CE0; + 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_DEPTH_ATTACHMENT = $8D00; + GL_STENCIL_ATTACHMENT = $8D20; + GL_FRAMEBUFFER = $8D40; + GL_RENDERBUFFER = $8D41; + GL_RENDERBUFFER_WIDTH = $8D42; + GL_RENDERBUFFER_HEIGHT = $8D43; + GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44; + GL_STENCIL_INDEX1 = $8D46; + GL_STENCIL_INDEX4 = $8D47; + GL_STENCIL_INDEX8 = $8D48; + GL_STENCIL_INDEX16 = $8D49; + 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_INCOMPLETE_MULTISAMPLE = $8D56; + GL_MAX_SAMPLES = $8D57; +{$ifdef DGL_DEPRECATED} + GL_INDEX = $8222; + GL_TEXTURE_LUMINANCE_TYPE = $8C14; + GL_TEXTURE_INTENSITY_TYPE = $8C15; +{$endif} + + // GL_ARB_framebuffer_sRGB + GL_FRAMEBUFFER_SRGB = $8DB9; + + // GL_ARB_geometry_shader4 + GL_LINES_ADJACENCY_ARB = $000A; + GL_LINE_STRIP_ADJACENCY_ARB = $000B; + GL_TRIANGLES_ADJACENCY_ARB = $000C; + GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D; + GL_PROGRAM_POINT_SIZE_ARB = $8642; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9; + GL_GEOMETRY_SHADER_ARB = $8DD9; + GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA; + GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB; + GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC; + GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD; + GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1; + { reuse GL_MAX_VARYING_COMPONENTS } + { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } + + // GL_ARB_half_float_vertex + GL_HALF_FLOAT = $140B; + + // GL_ARB_instanced_arrays + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE; + + // GL_ARB_map_buffer_range + 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_ARB_texture_buffer_object + GL_TEXTURE_BUFFER_ARB = $8C2A; + GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B; + GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C; + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D; + GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E; + + // GL_ARB_texture_compression_rgtc + GL_COMPRESSED_RED_RGTC1 = $8DBB; + GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC; + GL_COMPRESSED_RG_RGTC2 = $8DBD; + GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE; + + // GL_ARB_texture_rg + GL_RG = $8227; + GL_RG_INTEGER = $8228; + GL_R8 = $8229; + GL_R16 = $822A; + GL_RG8 = $822B; + GL_RG16 = $822C; + 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_ARB_vertex_array_object + GL_VERTEX_ARRAY_BINDING = $85B5; + + // GL_ARB_uniform_buffer_object + 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_GEOMETRY_UNIFORM_BLOCKS = $8A2C; + 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_GEOMETRY_UNIFORM_COMPONENTS = $8A32; + 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_GEOMETRY_SHADER = $8A45; + GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46; + GL_INVALID_INDEX = $FFFFFFFF; + + // GL_ARB_compatibility + { ARB_compatibility just defines tokens from core 3.0 } + + // GL_ARB_copy_buffer + GL_COPY_READ_BUFFER_BINDING = $8F36; + GL_COPY_READ_BUFFER = GL_COPY_READ_BUFFER_BINDING; + GL_COPY_WRITE_BUFFER_BINDING = $8F37; + GL_COPY_WRITE_BUFFER = GL_COPY_WRITE_BUFFER_BINDING; + + // GL_ARB_depth_clamp + GL_DEPTH_CLAMP = $864F; + + // GL_ARB_provoking_vertex + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C; + GL_FIRST_VERTEX_CONVENTION = $8E4D; + GL_LAST_VERTEX_CONVENTION = $8E4E; + GL_PROVOKING_VERTEX = $8E4F; + + // GL_ARB_seamless_cube_map + GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F; + + // GL_ARB_sync + 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_ARB_texture_multisample + GL_SAMPLE_POSITION = $8E50; + GL_SAMPLE_MASK = $8E51; + GL_SAMPLE_MASK_VALUE = $8E52; + GL_MAX_SAMPLE_MASK_WORDS = $8E59; + GL_TEXTURE_2D_MULTISAMPLE = $9100; + GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101; + GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102; + GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103; + GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104; + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105; + GL_TEXTURE_SAMPLES = $9106; + GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107; + GL_SAMPLER_2D_MULTISAMPLE = $9108; + GL_INT_SAMPLER_2D_MULTISAMPLE = $9109; + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A; + GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B; + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C; + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D; + GL_MAX_COLOR_TEXTURE_SAMPLES = $910E; + GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F; + GL_MAX_INTEGER_SAMPLES = $9110; + + // GL_ARB_vertex_array_bgra + { reuse GL_BGRA } + + // GL_ARB_sample_shading + GL_SAMPLE_SHADING_ARB = $8C36; + GL_MIN_SAMPLE_SHADING_VALUE_ARB = $8C37; + + // GL_ARB_texture_cube_map_array + GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009; + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A; + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B; + GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C; + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D; + GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E; + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F; + + // GL_ARB_texture_gather + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F; + + // GL_ARB_shading_language_include + GL_SHADER_INCLUDE_ARB = $8DAE; + GL_NAMED_STRING_LENGTH_ARB = $8DE9; + GL_NAMED_STRING_TYPE_ARB = $8DEA; + + // GL_ARB_texture_compression_bptc + GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C; + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D; + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E; + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F; + + // GL_ARB_blend_func_extended + GL_SRC1_COLOR = $88F9; + { reuse GL_SRC1_ALPHA } + GL_ONE_MINUS_SRC1_COLOR = $88FA; + GL_ONE_MINUS_SRC1_ALPHA = $88FB; + GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC; + + // GL_ARB_occlusion_query2 + GL_ANY_SAMPLES_PASSED = $8C2F; + + // GL_ARB_sampler_objects + GL_SAMPLER_BINDING = $8919; + + // GL_ARB_texture_rgb10_a2ui + GL_RGB10_A2UI = $906F; + + // GL_ARB_texture_swizzle + GL_TEXTURE_SWIZZLE_R = $8E42; + GL_TEXTURE_SWIZZLE_G = $8E43; + GL_TEXTURE_SWIZZLE_B = $8E44; + GL_TEXTURE_SWIZZLE_A = $8E45; + GL_TEXTURE_SWIZZLE_RGBA = $8E46; + + // GL_ARB_timer_query + GL_TIME_ELAPSED = $88BF; + GL_TIMESTAMP = $8E28; + + // GL_ARB_vertex_type_2_10_10_10_rev + { reuse GL_UNSIGNED_INT_2_10_10_10_REV } + GL_INT_2_10_10_10_REV = $8D9F; + + // GL_ARB_draw_indirect + GL_DRAW_INDIRECT_BUFFER = $8F3F; + GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43; + + // GL_ARB_gpu_shader5 + GL_GEOMETRY_SHADER_INVOCATIONS = $887F; + GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A; + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B; + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C; + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D; + { reuse GL_MAX_VERTEX_STREAMS } + + // GL_ARB_gpu_shader_fp64 + { reuse GL_DOUBLE } + GL_DOUBLE_VEC2 = $8FFC; + GL_DOUBLE_VEC3 = $8FFD; + GL_DOUBLE_VEC4 = $8FFE; + GL_DOUBLE_MAT2 = $8F46; + GL_DOUBLE_MAT3 = $8F47; + GL_DOUBLE_MAT4 = $8F48; + GL_DOUBLE_MAT2x3 = $8F49; + GL_DOUBLE_MAT2x4 = $8F4A; + GL_DOUBLE_MAT3x2 = $8F4B; + GL_DOUBLE_MAT3x4 = $8F4C; + GL_DOUBLE_MAT4x2 = $8F4D; + GL_DOUBLE_MAT4x3 = $8F4E; + + // GL_ARB_shader_subroutine + GL_ACTIVE_SUBROUTINES = $8DE5; + GL_ACTIVE_SUBROUTINE_UNIFORMS = $8DE6; + GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = $8E47; + GL_ACTIVE_SUBROUTINE_MAX_LENGTH = $8E48; + GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = $8E49; + GL_MAX_SUBROUTINES = $8DE7; + GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = $8DE8; + GL_NUM_COMPATIBLE_SUBROUTINES = $8E4A; + GL_COMPATIBLE_SUBROUTINES = $8E4B; + { reuse GL_UNIFORM_SIZE } + { reuse GL_UNIFORM_NAME_LENGTH } + + // GL_ARB_tessellation_shader + GL_PATCHES = $000E; + GL_PATCH_VERTICES = $8E72; + GL_PATCH_DEFAULT_INNER_LEVEL = $8E73; + GL_PATCH_DEFAULT_OUTER_LEVEL = $8E74; + 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; + { reuse GL_TRIANGLES } + { reuse GL_QUADS } + GL_ISOLINES = $8E7A; + { reuse GL_EQUAL } + GL_FRACTIONAL_ODD = $8E7B; + GL_FRACTIONAL_EVEN = $8E7C; + { reuse GL_CCW } + { reuse GL_CW } + 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_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = $84F0; + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = $84F1; + GL_TESS_EVALUATION_SHADER = $8E87; + GL_TESS_CONTROL_SHADER = $8E88; + + // GL_ARB_texture_buffer_object_rgb32 + { reuse GL_RGB32F } + { reuse GL_RGB32UI } + { reuse GL_RGB32I } + + // GL_ARB_transform_feedback2 + GL_TRANSFORM_FEEDBACK = $8E22; + GL_TRANSFORM_FEEDBACK_PAUSED = $8E23; + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = GL_TRANSFORM_FEEDBACK_PAUSED; + GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24; + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = GL_TRANSFORM_FEEDBACK_ACTIVE; + GL_TRANSFORM_FEEDBACK_BINDING = $8E25; + + // GL_ARB_transform_feedback3 + GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = $8E70; + GL_MAX_VERTEX_STREAMS = $8E71; + + // GL_ARB_ES2_compatibility + GL_FIXED = $140C; + GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A; + GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B; + 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_SHADER_COMPILER = $8DFA; + GL_NUM_SHADER_BINARY_FORMATS = $8DF9; + GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB; + GL_MAX_VARYING_VECTORS = $8DFC; + GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD; + GL_RGB565 = $8D62; + + // GL_ARB_get_program_binary + GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257; + GL_PROGRAM_BINARY_LENGTH = $8741; + GL_NUM_PROGRAM_BINARY_FORMATS = $87FE; + GL_PROGRAM_BINARY_FORMATS = $87FF; + + // GL_ARB_separate_shader_objects + GL_VERTEX_SHADER_BIT = $00000001; + GL_FRAGMENT_SHADER_BIT = $00000002; + GL_GEOMETRY_SHADER_BIT = $00000004; + GL_TESS_CONTROL_SHADER_BIT = $00000008; + GL_TESS_EVALUATION_SHADER_BIT = $00000010; + GL_ALL_SHADER_BITS = $FFFFFFFF; + GL_PROGRAM_SEPARABLE = $8258; + GL_ACTIVE_PROGRAM = $8259; + GL_PROGRAM_PIPELINE_BINDING = $825A; + + // GL_ARB_vertex_attrib_64bit + { reuse GL_RGB32I } + { reuse GL_DOUBLE_VEC2 } + { reuse GL_DOUBLE_VEC3 } + { reuse GL_DOUBLE_VEC4 } + { reuse GL_DOUBLE_MAT2 } + { reuse GL_DOUBLE_MAT3 } + { reuse GL_DOUBLE_MAT4 } + { reuse GL_DOUBLE_MAT2x3 } + { reuse GL_DOUBLE_MAT2x4 } + { reuse GL_DOUBLE_MAT3x2 } + { reuse GL_DOUBLE_MAT3x4 } + { reuse GL_DOUBLE_MAT4x2 } + { reuse GL_DOUBLE_MAT4x3 } + + // GL_ARB_viewport_array + { reuse GL_SCISSOR_BOX } + { reuse GL_VIEWPORT } + { reuse GL_DEPTH_RANGE } + { reuse GL_SCISSOR_TEST } + GL_MAX_VIEWPORTS = $825B; + GL_VIEWPORT_SUBPIXEL_BITS = $825C; + GL_VIEWPORT_BOUNDS_RANGE = $825D; + GL_LAYER_PROVOKING_VERTEX = $825E; + GL_VIEWPORT_INDEX_PROVOKING_VERTEX = $825F; + GL_UNDEFINED_VERTEX = $8260; + { reuse GL_FIRST_VERTEX_CONVENTION } + { reuse GL_LAST_VERTEX_CONVENTION } + { reuse GL_PROVOKING_VERTEX } + + // GL_ARB_cl_event + GL_SYNC_CL_EVENT_ARB = $8240; + GL_SYNC_CL_EVENT_COMPLETE_ARB = $8241; + + // GL_ARB_debug_output + GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = $8242; + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = $8243; + GL_DEBUG_CALLBACK_FUNCTION_ARB = $8244; + GL_DEBUG_CALLBACK_USER_PARAM_ARB = $8245; + GL_DEBUG_SOURCE_API_ARB = $8246; + GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = $8247; + GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = $8248; + GL_DEBUG_SOURCE_THIRD_PARTY_ARB = $8249; + GL_DEBUG_SOURCE_APPLICATION_ARB = $824A; + GL_DEBUG_SOURCE_OTHER_ARB = $824B; + GL_DEBUG_TYPE_ERROR_ARB = $824C; + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = $824D; + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = $824E; + GL_DEBUG_TYPE_PORTABILITY_ARB = $824F; + GL_DEBUG_TYPE_PERFORMANCE_ARB = $8250; + GL_DEBUG_TYPE_OTHER_ARB = $8251; + GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = $9143; + GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = $9144; + GL_DEBUG_LOGGED_MESSAGES_ARB = $9145; + GL_DEBUG_SEVERITY_HIGH_ARB = $9146; + GL_DEBUG_SEVERITY_MEDIUM_ARB = $9147; + GL_DEBUG_SEVERITY_LOW_ARB = $9148; + + // GL_ARB_robustness + { reuse GL_NO_ERROR } + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = $00000004; + GL_LOSE_CONTEXT_ON_RESET_ARB = $8252; + GL_GUILTY_CONTEXT_RESET_ARB = $8253; + GL_INNOCENT_CONTEXT_RESET_ARB = $8254; + GL_UNKNOWN_CONTEXT_RESET_ARB = $8255; + GL_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + GL_NO_RESET_NOTIFICATION_ARB = $8261; + + // GL_ARB_compressed_texture_pixel_storage + GL_UNPACK_COMPRESSED_BLOCK_WIDTH = $09127; + GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = $09128; + GL_UNPACK_COMPRESSED_BLOCK_DEPTH = $09129; + GL_UNPACK_COMPRESSED_BLOCK_SIZE = $0912A; + GL_PACK_COMPRESSED_BLOCK_WIDTH = $0912B; + GL_PACK_COMPRESSED_BLOCK_HEIGHT = $0912C; + GL_PACK_COMPRESSED_BLOCK_DEPTH = $0912D; + GL_PACK_COMPRESSED_BLOCK_SIZE = $0912E; + + // GL_ARB_internalformat_query + GL_NUM_SAMPLE_COUNTS = $09380; + + // GL_ARB_map_buffer_alignment + GL_MIN_MAP_BUFFER_ALIGNMENT = $090BC; + + // GL_ARB_shader_atomic_counters + GL_ATOMIC_COUNTER_BUFFER = $92C0; + GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1; + GL_ATOMIC_COUNTER_BUFFER_START = $92C2; + GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3; + GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = $92C4; + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = $92C5; + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = $92C6; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = $92C7; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = $92C8; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = $92C9; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = $92CA; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = $92CB; + GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC; + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD; + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE; + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF; + GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0; + GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1; + GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2; + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3; + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4; + GL_MAX_GEOMETRY_ATOMIC_COUNTERS = $92D5; + 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_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = $92DA; + GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB; + + // GL_ARB_shader_image_load_store + 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_MAX_IMAGE_UNITS = $8F38; + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = $8F39; + 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_1D = $904C; + GL_IMAGE_2D = $904D; + GL_IMAGE_3D = $904E; + GL_IMAGE_2D_RECT = $904F; + GL_IMAGE_CUBE = $9050; + GL_IMAGE_BUFFER = $9051; + GL_IMAGE_1D_ARRAY = $9052; + GL_IMAGE_2D_ARRAY = $9053; + GL_IMAGE_CUBE_MAP_ARRAY = $9054; + GL_IMAGE_2D_MULTISAMPLE = $9055; + GL_IMAGE_2D_MULTISAMPLE_ARRAY = $9056; + GL_INT_IMAGE_1D = $9057; + GL_INT_IMAGE_2D = $9058; + GL_INT_IMAGE_3D = $9059; + GL_INT_IMAGE_2D_RECT = $905A; + GL_INT_IMAGE_CUBE = $905B; + GL_INT_IMAGE_BUFFER = $905C; + GL_INT_IMAGE_1D_ARRAY = $905D; + GL_INT_IMAGE_2D_ARRAY = $905E; + GL_INT_IMAGE_CUBE_MAP_ARRAY = $905F; + GL_INT_IMAGE_2D_MULTISAMPLE = $9060; + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $9061; + GL_UNSIGNED_INT_IMAGE_1D = $9062; + GL_UNSIGNED_INT_IMAGE_2D = $9063; + GL_UNSIGNED_INT_IMAGE_3D = $9064; + GL_UNSIGNED_INT_IMAGE_2D_RECT = $9065; + GL_UNSIGNED_INT_IMAGE_CUBE = $9066; + GL_UNSIGNED_INT_IMAGE_BUFFER = $9067; + GL_UNSIGNED_INT_IMAGE_1D_ARRAY = $9068; + GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069; + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = $906B; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $906C; + GL_MAX_IMAGE_SAMPLES = $906D; + GL_IMAGE_BINDING_FORMAT = $906E; + GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7; + GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8; + GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9; + GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA; + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB; + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC; + GL_MAX_GEOMETRY_IMAGE_UNIFORMS = $90CD; + GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE; + GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF; + + // GL_ARB_texture_storage + GL_TEXTURE_IMMUTABLE_FORMAT = $912F; + + // 4.3 + 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_105_KHR = $93B8; + GL_COMPRESSED_RGBA_ASTC_106_KHR = $93B9; + GL_COMPRESSED_RGBA_ASTC_108_KHR = $93BA; + GL_COMPRESSED_RGBA_ASTC_110_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; + // (4.3) GL_KHR_debug + 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_QUERY = $82E3; + GL_PROGRAM_PIPELINE = $82E4; + GL_SAMPLER = $82E6; + GL_DISPLAY_LIST = $82E7; + 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_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_LOCAL_INVOCATIONS = $90EB; + GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE; + GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF; + GL_COMPUTE_LOCAL_WORK_SIZE = $8267; + GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = $90EC; + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = $90ED; + GL_DISPATCH_INDIRECT_BUFFER = $90EE; + GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF; + GL_COMPUTE_SHADER_BIT = $00000020; + 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_COMPRESSED_R11_EAC = $9270; + GL_COMPRESSED_SIGNED_R11_EAC = $9271; + GL_COMPRESSED_RG11_EAC = $9272; + GL_COMPRESSED_SIGNED_RG11_EAC = $9273; + GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69; + GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A; + GL_MAX_ELEMENT_INDEX = $8D6B; + GL_MAX_UNIFORM_LOCATIONS = $826E; + GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310; + GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311; + GL_FRAMEBUFFER_DEFAULT_LAYERS = $9312; + 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_LAYERS = $9317; + GL_MAX_FRAMEBUFFER_SAMPLES = $9318; + GL_INTERNALFORMAT_SUPPORTED = $826F; + GL_INTERNALFORMAT_PREFERRED = $8270; + GL_INTERNALFORMAT_RED_SIZE = $8271; + GL_INTERNALFORMAT_GREEN_SIZE = $8272; + GL_INTERNALFORMAT_BLUE_SIZE = $8273; + GL_INTERNALFORMAT_ALPHA_SIZE = $8274; + GL_INTERNALFORMAT_DEPTH_SIZE = $8275; + GL_INTERNALFORMAT_STENCIL_SIZE = $8276; + GL_INTERNALFORMAT_SHARED_SIZE = $8277; + GL_INTERNALFORMAT_RED_TYPE = $8278; + GL_INTERNALFORMAT_GREEN_TYPE = $8279; + GL_INTERNALFORMAT_BLUE_TYPE = $827A; + GL_INTERNALFORMAT_ALPHA_TYPE = $827B; + GL_INTERNALFORMAT_DEPTH_TYPE = $827C; + GL_INTERNALFORMAT_STENCIL_TYPE = $827D; + GL_MAX_WIDTH = $827E; + GL_MAX_HEIGHT = $827F; + GL_MAX_DEPTH = $8280; + GL_MAX_LAYERS = $8281; + GL_MAX_COMBINED_DIMENSIONS = $8282; + GL_COLOR_COMPONENTS = $8283; + GL_DEPTH_COMPONENTS = $8284; + GL_STENCIL_COMPONENTS = $8285; + GL_COLOR_RENDERABLE = $8286; + GL_DEPTH_RENDERABLE = $8287; + GL_STENCIL_RENDERABLE = $8288; + GL_FRAMEBUFFER_RENDERABLE = $8289; + GL_FRAMEBUFFER_RENDERABLE_LAYERED = $828A; + GL_FRAMEBUFFER_BLEND = $828B; + GL_READ_PIXELS = $828C; + GL_READ_PIXELS_FORMAT = $828D; + GL_READ_PIXELS_TYPE = $828E; + GL_TEXTURE_IMAGE_FORMAT = $828F; + GL_TEXTURE_IMAGE_TYPE = $8290; + GL_GET_TEXTURE_IMAGE_FORMAT = $8291; + GL_GET_TEXTURE_IMAGE_TYPE = $8292; + GL_MIPMAP = $8293; + GL_MANUAL_GENERATE_MIPMAP = $8294; + GL_AUTO_GENERATE_MIPMAP = $8295; + GL_COLOR_ENCODING = $8296; + GL_SRGB_READ = $8297; + GL_SRGB_WRITE = $8298; + GL_SRGB_DECODE_ARB = $8299; + GL_FILTER = $829A; + GL_VERTEX_TEXTURE = $829B; + GL_TESS_CONTROL_TEXTURE = $829C; + GL_TESS_EVALUATION_TEXTURE = $829D; + GL_GEOMETRY_TEXTURE = $829E; + GL_FRAGMENT_TEXTURE = $829F; + GL_COMPUTE_TEXTURE = $82A0; + GL_TEXTURE_SHADOW = $82A1; + GL_TEXTURE_GATHER = $82A2; + GL_TEXTURE_GATHER_SHADOW = $82A3; + GL_SHADER_IMAGE_LOAD = $82A4; + GL_SHADER_IMAGE_STORE = $82A5; + GL_SHADER_IMAGE_ATOMIC = $82A6; + GL_IMAGE_TEXEL_SIZE = $82A7; + GL_IMAGE_COMPATIBILITY_CLASS = $82A8; + GL_IMAGE_PIXEL_FORMAT = $82A9; + GL_IMAGE_PIXEL_TYPE = $82AA; + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = $82AC; + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = $82AD; + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = $82AE; + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = $82AF; + GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = $82B1; + GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = $82B2; + GL_TEXTURE_COMPRESSED_BLOCK_SIZE = $82B3; + GL_CLEAR_BUFFER = $82B4; + GL_TEXTURE_VIEW = $82B5; + GL_VIEW_COMPATIBILITY_CLASS = $82B6; + GL_FULL_SUPPORT = $82B7; + GL_CAVEAT_SUPPORT = $82B8; + GL_IMAGE_CLASS_4_X_32 = $82B9; + GL_IMAGE_CLASS_2_X_32 = $82BA; + GL_IMAGE_CLASS_1_X_32 = $82BB; + GL_IMAGE_CLASS_4_X_16 = $82BC; + GL_IMAGE_CLASS_2_X_16 = $82BD; + GL_IMAGE_CLASS_1_X_16 = $82BE; + GL_IMAGE_CLASS_4_X_8 = $82BF; + GL_IMAGE_CLASS_2_X_8 = $82C0; + GL_IMAGE_CLASS_1_X_8 = $82C1; + GL_IMAGE_CLASS_11_11_10 = $82C2; + GL_IMAGE_CLASS_10_10_10_2 = $82C3; + GL_VIEW_CLASS_128_BITS = $82C4; + GL_VIEW_CLASS_96_BITS = $82C5; + GL_VIEW_CLASS_64_BITS = $82C6; + GL_VIEW_CLASS_48_BITS = $82C7; + GL_VIEW_CLASS_32_BITS = $82C8; + GL_VIEW_CLASS_24_BITS = $82C9; + GL_VIEW_CLASS_16_BITS = $82CA; + GL_VIEW_CLASS_8_BITS = $82CB; + GL_VIEW_CLASS_S3TC_DXT1_RGB = $82CC; + GL_VIEW_CLASS_S3TC_DXT1_RGBA = $82CD; + GL_VIEW_CLASS_S3TC_DXT3_RGBA = $82CE; + GL_VIEW_CLASS_S3TC_DXT5_RGBA = $82CF; + GL_VIEW_CLASS_RGTC1_RED = $82D0; + GL_VIEW_CLASS_RGTC2_RG = $82D1; + GL_VIEW_CLASS_BPTC_UNORM = $82D2; + GL_VIEW_CLASS_BPTC_FLOAT = $82D3; + 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_VERTEX_SUBROUTINE = $92E8; + GL_TESS_CONTROL_SUBROUTINE = $92E9; + GL_TESS_EVALUATION_SUBROUTINE = $92EA; + GL_GEOMETRY_SUBROUTINE = $92EB; + GL_FRAGMENT_SUBROUTINE = $92EC; + GL_COMPUTE_SUBROUTINE = $92ED; + GL_VERTEX_SUBROUTINE_UNIFORM = $92EE; + GL_TESS_CONTROL_SUBROUTINE_UNIFORM = $92EF; + GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = $92F0; + GL_GEOMETRY_SUBROUTINE_UNIFORM = $92F1; + GL_FRAGMENT_SUBROUTINE_UNIFORM = $92F2; + GL_COMPUTE_SUBROUTINE_UNIFORM = $92F3; + GL_TRANSFORM_FEEDBACK_VARYING = $92F4; + GL_ACTIVE_RESOURCES = $92F5; + GL_MAX_NAME_LENGTH = $92F6; + GL_MAX_NUM_ACTIVE_VARIABLES = $92F7; + GL_MAX_NUM_COMPATIBLE_SUBROUTINES = $92F8; + 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_TESS_CONTROL_SHADER = $9307; + GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308; + GL_REFERENCED_BY_GEOMETRY_SHADER = $9309; + 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_LOCATION_INDEX = $930F; + GL_IS_PER_PATCH = $92E7; + 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_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7; + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8; + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9; + 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 = $2000; + GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS; + GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA; + GL_TEXTURE_BUFFER_OFFSET = $919D; + GL_TEXTURE_BUFFER_SIZE = $919E; + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F; + GL_TEXTURE_VIEW_MIN_LEVEL = $82DB; + GL_TEXTURE_VIEW_NUM_LEVELS = $82DC; + GL_TEXTURE_VIEW_MIN_LAYER = $82DD; + GL_TEXTURE_VIEW_NUM_LAYERS = $82DE; + GL_TEXTURE_IMMUTABLE_LEVELS = $82DF; + 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_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9; + GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA; + // END 4.3 + + // GL 4.4 + GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5; + GL_MAP_PERSISTENT_BIT = $0040; + GL_MAP_COHERENT_BIT = $0080; + GL_DYNAMIC_STORAGE_BIT = $0100; + GL_CLIENT_STORAGE_BIT = $0200; + GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = $00004000; + GL_BUFFER_IMMUTABLE_STORAGE = $821F; + GL_BUFFER_STORAGE_FLAGS = $8220; + GL_CLEAR_TEXTURE = $9365; + GL_LOCATION_COMPONENT = $934A; + GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = $934B; + GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = $934C; + GL_QUERY_BUFFER = $9192; + GL_QUERY_BUFFER_BARRIER_BIT = $00008000; + GL_QUERY_BUFFER_BINDING = $9193; + GL_QUERY_RESULT_NO_WAIT = $9194; + GL_MIRROR_CLAMP_TO_EDGE = $8743; + // END GL 4.4 + + // GL_ATI_draw_buffers + GL_MAX_DRAW_BUFFERS_ATI = $8824; + GL_DRAW_BUFFER0_ATI = $8825; + GL_DRAW_BUFFER1_ATI = $8826; + GL_DRAW_BUFFER2_ATI = $8827; + GL_DRAW_BUFFER3_ATI = $8828; + GL_DRAW_BUFFER4_ATI = $8829; + GL_DRAW_BUFFER5_ATI = $882A; + GL_DRAW_BUFFER6_ATI = $882B; + GL_DRAW_BUFFER7_ATI = $882C; + GL_DRAW_BUFFER8_ATI = $882D; + GL_DRAW_BUFFER9_ATI = $882E; + GL_DRAW_BUFFER10_ATI = $882F; + GL_DRAW_BUFFER11_ATI = $8830; + GL_DRAW_BUFFER12_ATI = $8831; + GL_DRAW_BUFFER13_ATI = $8832; + GL_DRAW_BUFFER14_ATI = $8833; + GL_DRAW_BUFFER15_ATI = $8834; + + // GL_ATI_element_array + GL_ELEMENT_ARRAY_ATI = $8768; + GL_ELEMENT_ARRAY_TYPE_ATI = $8769; + GL_ELEMENT_ARRAY_POINTER_ATI = $876A; + + // GL_ATI_envmap_bumpmap + GL_BUMP_ROT_MATRIX_ATI = $8775; + GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776; + GL_BUMP_NUM_TEX_UNITS_ATI = $8777; + GL_BUMP_TEX_UNITS_ATI = $8778; + GL_DUDV_ATI = $8779; + GL_DU8DV8_ATI = $877A; + GL_BUMP_ENVMAP_ATI = $877B; + GL_BUMP_TARGET_ATI = $877C; + + // GL_ATI_fragment_shader + GL_FRAGMENT_SHADER_ATI = $8920; + GL_REG_0_ATI = $8921; + GL_REG_1_ATI = $8922; + GL_REG_2_ATI = $8923; + GL_REG_3_ATI = $8924; + GL_REG_4_ATI = $8925; + GL_REG_5_ATI = $8926; + GL_REG_6_ATI = $8927; + GL_REG_7_ATI = $8928; + GL_REG_8_ATI = $8929; + GL_REG_9_ATI = $892A; + GL_REG_10_ATI = $892B; + GL_REG_11_ATI = $892C; + GL_REG_12_ATI = $892D; + GL_REG_13_ATI = $892E; + GL_REG_14_ATI = $892F; + GL_REG_15_ATI = $8930; + GL_REG_16_ATI = $8931; + GL_REG_17_ATI = $8932; + GL_REG_18_ATI = $8933; + GL_REG_19_ATI = $8934; + GL_REG_20_ATI = $8935; + GL_REG_21_ATI = $8936; + GL_REG_22_ATI = $8937; + GL_REG_23_ATI = $8938; + GL_REG_24_ATI = $8939; + GL_REG_25_ATI = $893A; + GL_REG_26_ATI = $893B; + GL_REG_27_ATI = $893C; + GL_REG_28_ATI = $893D; + GL_REG_29_ATI = $893E; + GL_REG_30_ATI = $893F; + GL_REG_31_ATI = $8940; + GL_CON_0_ATI = $8941; + GL_CON_1_ATI = $8942; + GL_CON_2_ATI = $8943; + GL_CON_3_ATI = $8944; + GL_CON_4_ATI = $8945; + GL_CON_5_ATI = $8946; + GL_CON_6_ATI = $8947; + GL_CON_7_ATI = $8948; + GL_CON_8_ATI = $8949; + GL_CON_9_ATI = $894A; + GL_CON_10_ATI = $894B; + GL_CON_11_ATI = $894C; + GL_CON_12_ATI = $894D; + GL_CON_13_ATI = $894E; + GL_CON_14_ATI = $894F; + GL_CON_15_ATI = $8950; + GL_CON_16_ATI = $8951; + GL_CON_17_ATI = $8952; + GL_CON_18_ATI = $8953; + GL_CON_19_ATI = $8954; + GL_CON_20_ATI = $8955; + GL_CON_21_ATI = $8956; + GL_CON_22_ATI = $8957; + GL_CON_23_ATI = $8958; + GL_CON_24_ATI = $8959; + GL_CON_25_ATI = $895A; + GL_CON_26_ATI = $895B; + GL_CON_27_ATI = $895C; + GL_CON_28_ATI = $895D; + GL_CON_29_ATI = $895E; + GL_CON_30_ATI = $895F; + GL_CON_31_ATI = $8960; + GL_MOV_ATI = $8961; + GL_ADD_ATI = $8963; + GL_MUL_ATI = $8964; + GL_SUB_ATI = $8965; + GL_DOT3_ATI = $8966; + GL_DOT4_ATI = $8967; + GL_MAD_ATI = $8968; + GL_LERP_ATI = $8969; + GL_CND_ATI = $896A; + GL_CND0_ATI = $896B; + GL_DOT2_ADD_ATI = $896C; + GL_SECONDARY_INTERPOLATOR_ATI = $896D; + GL_NUM_FRAGMENT_REGISTERS_ATI = $896E; + GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F; + GL_NUM_PASSES_ATI = $8970; + GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971; + GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972; + GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973; + GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974; + GL_COLOR_ALPHA_PAIRING_ATI = $8975; + GL_SWIZZLE_STR_ATI = $8976; + GL_SWIZZLE_STQ_ATI = $8977; + GL_SWIZZLE_STR_DR_ATI = $8978; + GL_SWIZZLE_STQ_DQ_ATI = $8979; + GL_SWIZZLE_STRQ_ATI = $897A; + GL_SWIZZLE_STRQ_DQ_ATI = $897B; + GL_RED_BIT_ATI = $00000001; + GL_GREEN_BIT_ATI = $00000002; + GL_BLUE_BIT_ATI = $00000004; + GL_2X_BIT_ATI = $00000001; + GL_4X_BIT_ATI = $00000002; + GL_8X_BIT_ATI = $00000004; + GL_HALF_BIT_ATI = $00000008; + GL_QUARTER_BIT_ATI = $00000010; + GL_EIGHTH_BIT_ATI = $00000020; + GL_SATURATE_BIT_ATI = $00000040; + GL_COMP_BIT_ATI = $00000002; + GL_NEGATE_BIT_ATI = $00000004; + GL_BIAS_BIT_ATI = $00000008; + + // GL_ATI_pn_triangles + GL_PN_TRIANGLES_ATI = $87F0; + GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1; + GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2; + GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3; + GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4; + GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5; + GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6; + GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7; + GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8; + + // GL_ATI_separate_stencil + GL_STENCIL_BACK_FUNC_ATI = $8800; + GL_STENCIL_BACK_FAIL_ATI = $8801; + GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802; + GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803; + + // GL_ATI_text_fragment_shader + GL_TEXT_FRAGMENT_SHADER_ATI = $8200; + + // GL_ATI_texture_env_combine3 + GL_MODULATE_ADD_ATI = $8744; + GL_MODULATE_SIGNED_ADD_ATI = $8745; + GL_MODULATE_SUBTRACT_ATI = $8746; + + // GL_ATI_texture_float + GL_RGBA_FLOAT32_ATI = $8814; + GL_RGB_FLOAT32_ATI = $8815; + GL_ALPHA_FLOAT32_ATI = $8816; + GL_INTENSITY_FLOAT32_ATI = $8817; + GL_LUMINANCE_FLOAT32_ATI = $8818; + GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819; + GL_RGBA_FLOAT16_ATI = $881A; + GL_RGB_FLOAT16_ATI = $881B; + GL_ALPHA_FLOAT16_ATI = $881C; + GL_INTENSITY_FLOAT16_ATI = $881D; + GL_LUMINANCE_FLOAT16_ATI = $881E; + GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F; + + // GL_ATI_texture_mirror_once + GL_MIRROR_CLAMP_ATI = $8742; + GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743; + + // GL_ATI_vertex_array_object + GL_STATIC_ATI = $8760; + GL_DYNAMIC_ATI = $8761; + GL_PRESERVE_ATI = $8762; + GL_DISCARD_ATI = $8763; + GL_OBJECT_BUFFER_SIZE_ATI = $8764; + GL_OBJECT_BUFFER_USAGE_ATI = $8765; + GL_ARRAY_OBJECT_BUFFER_ATI = $8766; + GL_ARRAY_OBJECT_OFFSET_ATI = $8767; + + // GL_ATI_vertex_streams + GL_MAX_VERTEX_STREAMS_ATI = $876B; + GL_VERTEX_STREAM0_ATI = $876C; + GL_VERTEX_STREAM1_ATI = $876D; + GL_VERTEX_STREAM2_ATI = $876E; + GL_VERTEX_STREAM3_ATI = $876F; + GL_VERTEX_STREAM4_ATI = $8770; + GL_VERTEX_STREAM5_ATI = $8771; + GL_VERTEX_STREAM6_ATI = $8772; + GL_VERTEX_STREAM7_ATI = $8773; + GL_VERTEX_SOURCE_ATI = $8774; + + // GL_ATI_meminfo + GL_VBO_FREE_MEMORY_ATI = $87FB; + GL_TEXTURE_FREE_MEMORY_ATI = $87FC; + GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD; + + // 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_vertex_shader_tesselator + GL_SAMPLER_BUFFER_AMD = $9001; + GL_INT_SAMPLER_BUFFER_AMD = $9002; + GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003; + GL_TESSELLATION_MODE_AMD = $9004; + GL_TESSELLATION_FACTOR_AMD = $9005; + GL_DISCRETE_AMD = $9006; + GL_CONTINUOUS_AMD = $9007; + + // GL_AMD_seamless_cubemap_per_texture + { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS } + + // GL_AMD_name_gen_delete + GL_DATA_BUFFER_AMD = $9151; + GL_PERFORMANCE_MONITOR_AMD = $9152; + GL_QUERY_OBJECT_AMD = $9153; + GL_VERTEX_ARRAY_OBJECT_AMD = $9154; + GL_SAMPLER_OBJECT_AMD = $9155; + + // GL_AMD_debug_output + GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = $9144; + GL_DEBUG_LOGGED_MESSAGES_AMD = $9145; + GL_DEBUG_SEVERITY_HIGH_AMD = $9146; + GL_DEBUG_SEVERITY_MEDIUM_AMD = $9147; + GL_DEBUG_SEVERITY_LOW_AMD = $9148; + GL_DEBUG_CATEGORY_API_ERROR_AMD = $9149; + GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = $914A; + GL_DEBUG_CATEGORY_DEPRECATION_AMD = $914B; + GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = $914C; + GL_DEBUG_CATEGORY_PERFORMANCE_AMD = $914D; + GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = $914E; + GL_DEBUG_CATEGORY_APPLICATION_AMD = $914F; + GL_DEBUG_CATEGORY_OTHER_AMD = $9150; + + // GL_AMD_depth_clamp_separate + GL_DEPTH_CLAMP_NEAR_AMD = $901E; + GL_DEPTH_CLAMP_FAR_AMD = $901F; + + // GL_EXT_422_pixels + GL_422_EXT = $80CC; + GL_422_REV_EXT = $80CD; + GL_422_AVERAGE_EXT = $80CE; + GL_422_REV_AVERAGE_EXT = $80CF; + + // GL_EXT_abgr + GL_ABGR_EXT = $8000; + + // GL_EXT_bgra + GL_BGR_EXT = $80E0; + GL_BGRA_EXT = $80E1; + + // GL_EXT_blend_color + GL_CONSTANT_COLOR_EXT = $8001; + GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002; + GL_CONSTANT_ALPHA_EXT = $8003; + GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004; + GL_BLEND_COLOR_EXT = $8005; + + // GL_EXT_blend_func_separate + GL_BLEND_DST_RGB_EXT = $80C8; + GL_BLEND_SRC_RGB_EXT = $80C9; + GL_BLEND_DST_ALPHA_EXT = $80CA; + GL_BLEND_SRC_ALPHA_EXT = $80CB; + + // GL_EXT_blend_minmax + GL_FUNC_ADD_EXT = $8006; + GL_MIN_EXT = $8007; + GL_MAX_EXT = $8008; + GL_BLEND_EQUATION_EXT = $8009; + + // GL_EXT_blend_subtract + GL_FUNC_SUBTRACT_EXT = $800A; + GL_FUNC_REVERSE_SUBTRACT_EXT = $800B; + + // GL_EXT_clip_volume_hint + GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0; + + // GL_EXT_cmyka + GL_CMYK_EXT = $800C; + GL_CMYKA_EXT = $800D; + GL_PACK_CMYK_HINT_EXT = $800E; + GL_UNPACK_CMYK_HINT_EXT = $800F; + + // GL_EXT_compiled_vertex_array + GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8; + GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9; + + // GL_EXT_convolution + GL_CONVOLUTION_1D_EXT = $8010; + GL_CONVOLUTION_2D_EXT = $8011; + GL_SEPARABLE_2D_EXT = $8012; + GL_CONVOLUTION_BORDER_MODE_EXT = $8013; + GL_CONVOLUTION_FILTER_SCALE_EXT = $8014; + GL_CONVOLUTION_FILTER_BIAS_EXT = $8015; + GL_REDUCE_EXT = $8016; + GL_CONVOLUTION_FORMAT_EXT = $8017; + GL_CONVOLUTION_WIDTH_EXT = $8018; + GL_CONVOLUTION_HEIGHT_EXT = $8019; + GL_MAX_CONVOLUTION_WIDTH_EXT = $801A; + GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B; + GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C; + GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D; + GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E; + GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F; + GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020; + GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021; + GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022; + GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023; + + // GL_EXT_coordinate_frame + GL_TANGENT_ARRAY_EXT = $8439; + GL_BINORMAL_ARRAY_EXT = $843A; + GL_CURRENT_TANGENT_EXT = $843B; + GL_CURRENT_BINORMAL_EXT = $843C; + GL_TANGENT_ARRAY_TYPE_EXT = $843E; + GL_TANGENT_ARRAY_STRIDE_EXT = $843F; + GL_BINORMAL_ARRAY_TYPE_EXT = $8440; + GL_BINORMAL_ARRAY_STRIDE_EXT = $8441; + GL_TANGENT_ARRAY_POINTER_EXT = $8442; + GL_BINORMAL_ARRAY_POINTER_EXT = $8443; + GL_MAP1_TANGENT_EXT = $8444; + GL_MAP2_TANGENT_EXT = $8445; + GL_MAP1_BINORMAL_EXT = $8446; + GL_MAP2_BINORMAL_EXT = $8447; + + // GL_EXT_cull_vertex + GL_CULL_VERTEX_EXT = $81AA; + GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB; + GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC; + + // GL_EXT_draw_range_elements + GL_MAX_ELEMENTS_VERTICES_EXT = $80E8; + GL_MAX_ELEMENTS_INDICES_EXT = $80E9; + + // GL_EXT_fog_coord + GL_FOG_COORDINATE_SOURCE_EXT = $8450; + GL_FOG_COORDINATE_EXT = $8451; + GL_FRAGMENT_DEPTH_EXT = $8452; + GL_CURRENT_FOG_COORDINATE_EXT = $8453; + GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454; + GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455; + GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456; + GL_FOG_COORDINATE_ARRAY_EXT = $8457; + + // GL_EXT_framebuffer_object + GL_FRAMEBUFFER_EXT = $8D40; + GL_RENDERBUFFER_EXT = $8D41; + GL_STENCIL_INDEX_EXT = $8D45; + GL_STENCIL_INDEX1_EXT = $8D46; + GL_STENCIL_INDEX4_EXT = $8D47; + GL_STENCIL_INDEX8_EXT = $8D48; + GL_STENCIL_INDEX16_EXT = $8D49; + GL_RENDERBUFFER_WIDTH_EXT = $8D42; + GL_RENDERBUFFER_HEIGHT_EXT = $8D43; + GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0; + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4; + 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; + GL_DEPTH_ATTACHMENT_EXT = $8D00; + GL_STENCIL_ATTACHMENT_EXT = $8D20; + GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5; + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6; + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7; + GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8; + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9; + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA; + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB; + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC; + GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD; + GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE; + GL_FRAMEBUFFER_BINDING_EXT = $8CA6; + GL_RENDERBUFFER_BINDING_EXT = $8CA7; + GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF; + GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8; + GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506; + + // GL_EXT_histogram + GL_HISTOGRAM_EXT = $8024; + GL_PROXY_HISTOGRAM_EXT = $8025; + GL_HISTOGRAM_WIDTH_EXT = $8026; + GL_HISTOGRAM_FORMAT_EXT = $8027; + GL_HISTOGRAM_RED_SIZE_EXT = $8028; + GL_HISTOGRAM_GREEN_SIZE_EXT = $8029; + GL_HISTOGRAM_BLUE_SIZE_EXT = $802A; + GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B; + GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C; + GL_HISTOGRAM_SINK_EXT = $802D; + GL_MINMAX_EXT = $802E; + GL_MINMAX_FORMAT_EXT = $802F; + GL_MINMAX_SINK_EXT = $8030; + GL_TABLE_TOO_LARGE_EXT = $8031; + + // GL_EXT_index_array_formats + GL_IUI_V2F_EXT = $81AD; + GL_IUI_V3F_EXT = $81AE; + GL_IUI_N3F_V2F_EXT = $81AF; + GL_IUI_N3F_V3F_EXT = $81B0; + GL_T2F_IUI_V2F_EXT = $81B1; + GL_T2F_IUI_V3F_EXT = $81B2; + GL_T2F_IUI_N3F_V2F_EXT = $81B3; + GL_T2F_IUI_N3F_V3F_EXT = $81B4; + + // GL_EXT_index_func + GL_INDEX_TEST_EXT = $81B5; + GL_INDEX_TEST_FUNC_EXT = $81B6; + GL_INDEX_TEST_REF_EXT = $81B7; + + // GL_EXT_index_material + GL_INDEX_MATERIAL_EXT = $81B8; + GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9; + GL_INDEX_MATERIAL_FACE_EXT = $81BA; + + // GL_EXT_light_texture + GL_FRAGMENT_MATERIAL_EXT = $8349; + GL_FRAGMENT_NORMAL_EXT = $834A; + GL_FRAGMENT_COLOR_EXT = $834C; + GL_ATTENUATION_EXT = $834D; + GL_SHADOW_ATTENUATION_EXT = $834E; + GL_TEXTURE_APPLICATION_MODE_EXT = $834F; + GL_TEXTURE_LIGHT_EXT = $8350; + GL_TEXTURE_MATERIAL_FACE_EXT = $8351; + GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352; + + // GL_EXT_multisample + GL_MULTISAMPLE_EXT = $809D; + GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E; + GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F; + GL_SAMPLE_MASK_EXT = $80A0; + GL_1PASS_EXT = $80A1; + GL_2PASS_0_EXT = $80A2; + GL_2PASS_1_EXT = $80A3; + GL_4PASS_0_EXT = $80A4; + GL_4PASS_1_EXT = $80A5; + GL_4PASS_2_EXT = $80A6; + GL_4PASS_3_EXT = $80A7; + GL_SAMPLE_BUFFERS_EXT = $80A8; + GL_SAMPLES_EXT = $80A9; + GL_SAMPLE_MASK_VALUE_EXT = $80AA; + GL_SAMPLE_MASK_INVERT_EXT = $80AB; + GL_SAMPLE_PATTERN_EXT = $80AC; + GL_MULTISAMPLE_BIT_EXT = $20000000; + + // GL_EXT_packed_pixels + GL_UNSIGNED_BYTE_3_3_2_EXT = $8032; + GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033; + GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034; + GL_UNSIGNED_INT_8_8_8_8_EXT = $8035; + GL_UNSIGNED_INT_10_10_10_2_EXT = $8036; + + // GL_EXT_paletted_texture + GL_COLOR_INDEX1_EXT = $80E2; + GL_COLOR_INDEX2_EXT = $80E3; + GL_COLOR_INDEX4_EXT = $80E4; + GL_COLOR_INDEX8_EXT = $80E5; + GL_COLOR_INDEX12_EXT = $80E6; + GL_COLOR_INDEX16_EXT = $80E7; + GL_TEXTURE_INDEX_SIZE_EXT = $80ED; + + // GL_EXT_pixel_transform + GL_PIXEL_TRANSFORM_2D_EXT = $8330; + GL_PIXEL_MAG_FILTER_EXT = $8331; + GL_PIXEL_MIN_FILTER_EXT = $8332; + GL_PIXEL_CUBIC_WEIGHT_EXT = $8333; + GL_CUBIC_EXT = $8334; + GL_AVERAGE_EXT = $8335; + GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336; + GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337; + GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338; + + // GL_EXT_point_parameters + GL_POINT_SIZE_MIN_EXT = $8126; + GL_POINT_SIZE_MAX_EXT = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128; + GL_DISTANCE_ATTENUATION_EXT = $8129; + + // GL_EXT_polygon_offset + GL_POLYGON_OFFSET_EXT = $8037; + GL_POLYGON_OFFSET_FACTOR_EXT = $8038; + GL_POLYGON_OFFSET_BIAS_EXT = $8039; + + // GL_EXT_rescale_normal + GL_RESCALE_NORMAL_EXT = $803A; + + // GL_EXT_secondary_color + GL_COLOR_SUM_EXT = $8458; + GL_CURRENT_SECONDARY_COLOR_EXT = $8459; + GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A; + GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B; + GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C; + GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D; + GL_SECONDARY_COLOR_ARRAY_EXT = $845E; + + // GL_EXT_separate_specular_color + GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8; + GL_SINGLE_COLOR_EXT = $81F9; + GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA; + + // GL_EXT_shared_texture_palette + GL_SHARED_TEXTURE_PALETTE_EXT = $81FB; + + // GL_EXT_stencil_two_side + GL_STENCIL_TEST_TWO_SIDE_EXT = $8910; + GL_ACTIVE_STENCIL_FACE_EXT = $8911; + + // GL_EXT_stencil_wrap + GL_INCR_WRAP_EXT = $8507; + GL_DECR_WRAP_EXT = $8508; + + // GL_EXT_texture + GL_ALPHA4_EXT = $803B; + GL_ALPHA8_EXT = $803C; + GL_ALPHA12_EXT = $803D; + GL_ALPHA16_EXT = $803E; + GL_LUMINANCE4_EXT = $803F; + GL_LUMINANCE8_EXT = $8040; + GL_LUMINANCE12_EXT = $8041; + GL_LUMINANCE16_EXT = $8042; + GL_LUMINANCE4_ALPHA4_EXT = $8043; + GL_LUMINANCE6_ALPHA2_EXT = $8044; + GL_LUMINANCE8_ALPHA8_EXT = $8045; + GL_LUMINANCE12_ALPHA4_EXT = $8046; + GL_LUMINANCE12_ALPHA12_EXT = $8047; + GL_LUMINANCE16_ALPHA16_EXT = $8048; + GL_INTENSITY_EXT = $8049; + GL_INTENSITY4_EXT = $804A; + GL_INTENSITY8_EXT = $804B; + GL_INTENSITY12_EXT = $804C; + GL_INTENSITY16_EXT = $804D; + GL_RGB2_EXT = $804E; + GL_RGB4_EXT = $804F; + GL_RGB5_EXT = $8050; + GL_RGB8_EXT = $8051; + GL_RGB10_EXT = $8052; + GL_RGB12_EXT = $8053; + GL_RGB16_EXT = $8054; + GL_RGBA2_EXT = $8055; + GL_RGBA4_EXT = $8056; + GL_RGB5_A1_EXT = $8057; + GL_RGBA8_EXT = $8058; + GL_RGB10_A2_EXT = $8059; + GL_RGBA12_EXT = $805A; + GL_RGBA16_EXT = $805B; + GL_TEXTURE_RED_SIZE_EXT = $805C; + GL_TEXTURE_GREEN_SIZE_EXT = $805D; + GL_TEXTURE_BLUE_SIZE_EXT = $805E; + GL_TEXTURE_ALPHA_SIZE_EXT = $805F; + GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060; + GL_TEXTURE_INTENSITY_SIZE_EXT = $8061; + GL_REPLACE_EXT = $8062; + GL_PROXY_TEXTURE_1D_EXT = $8063; + GL_PROXY_TEXTURE_2D_EXT = $8064; + GL_TEXTURE_TOO_LARGE_EXT = $8065; + + // GL_EXT_texture3D + GL_PACK_SKIP_IMAGES_EXT = $806B; + GL_PACK_IMAGE_HEIGHT_EXT = $806C; + GL_UNPACK_SKIP_IMAGES_EXT = $806D; + GL_UNPACK_IMAGE_HEIGHT_EXT = $806E; + GL_TEXTURE_3D_EXT = $806F; + GL_PROXY_TEXTURE_3D_EXT = $8070; + GL_TEXTURE_DEPTH_EXT = $8071; + GL_TEXTURE_WRAP_R_EXT = $8072; + GL_MAX_3D_TEXTURE_SIZE_EXT = $8073; + + // GL_EXT_texture_compression_s3tc + GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0; + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1; + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2; + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3; + + // GL_EXT_texture_cube_map + GL_NORMAL_MAP_EXT = $8511; + GL_REFLECTION_MAP_EXT = $8512; + GL_TEXTURE_CUBE_MAP_EXT = $8513; + GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514; + GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A; + GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B; + GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C; + + // GL_EXT_texture_edge_clamp + GL_CLAMP_TO_EDGE_EXT = $812F; + + // GL_EXT_texture_env_combine + GL_COMBINE_EXT = $8570; + GL_COMBINE_RGB_EXT = $8571; + GL_COMBINE_ALPHA_EXT = $8572; + GL_RGB_SCALE_EXT = $8573; + GL_ADD_SIGNED_EXT = $8574; + GL_INTERPOLATE_EXT = $8575; + GL_CONSTANT_EXT = $8576; + GL_PRIMARY_COLOR_EXT = $8577; + GL_PREVIOUS_EXT = $8578; + GL_SOURCE0_RGB_EXT = $8580; + GL_SOURCE1_RGB_EXT = $8581; + GL_SOURCE2_RGB_EXT = $8582; + GL_SOURCE0_ALPHA_EXT = $8588; + GL_SOURCE1_ALPHA_EXT = $8589; + GL_SOURCE2_ALPHA_EXT = $858A; + GL_OPERAND0_RGB_EXT = $8590; + GL_OPERAND1_RGB_EXT = $8591; + GL_OPERAND2_RGB_EXT = $8592; + GL_OPERAND0_ALPHA_EXT = $8598; + GL_OPERAND1_ALPHA_EXT = $8599; + GL_OPERAND2_ALPHA_EXT = $859A; + + // GL_EXT_texture_env_dot3 + GL_DOT3_RGB_EXT = $8740; + GL_DOT3_RGBA_EXT = $8741; + + // GL_EXT_texture_filter_anisotropic + GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; + + // 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_EXT_texture_object + GL_TEXTURE_PRIORITY_EXT = $8066; + GL_TEXTURE_RESIDENT_EXT = $8067; + GL_TEXTURE_1D_BINDING_EXT = $8068; + GL_TEXTURE_2D_BINDING_EXT = $8069; + GL_TEXTURE_3D_BINDING_EXT = $806A; + + // GL_EXT_texture_perturb_normal + GL_PERTURB_EXT = $85AE; + GL_TEXTURE_NORMAL_EXT = $85AF; + + // GL_EXT_texture_rectangle + GL_TEXTURE_RECTANGLE_EXT = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8; + + // GL_EXT_vertex_array + GL_VERTEX_ARRAY_EXT = $8074; + GL_NORMAL_ARRAY_EXT = $8075; + GL_COLOR_ARRAY_EXT = $8076; + GL_INDEX_ARRAY_EXT = $8077; + GL_TEXTURE_COORD_ARRAY_EXT = $8078; + GL_EDGE_FLAG_ARRAY_EXT = $8079; + GL_VERTEX_ARRAY_SIZE_EXT = $807A; + GL_VERTEX_ARRAY_TYPE_EXT = $807B; + GL_VERTEX_ARRAY_STRIDE_EXT = $807C; + GL_VERTEX_ARRAY_COUNT_EXT = $807D; + GL_NORMAL_ARRAY_TYPE_EXT = $807E; + GL_NORMAL_ARRAY_STRIDE_EXT = $807F; + GL_NORMAL_ARRAY_COUNT_EXT = $8080; + GL_COLOR_ARRAY_SIZE_EXT = $8081; + GL_COLOR_ARRAY_TYPE_EXT = $8082; + GL_COLOR_ARRAY_STRIDE_EXT = $8083; + GL_COLOR_ARRAY_COUNT_EXT = $8084; + GL_INDEX_ARRAY_TYPE_EXT = $8085; + GL_INDEX_ARRAY_STRIDE_EXT = $8086; + GL_INDEX_ARRAY_COUNT_EXT = $8087; + GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088; + GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089; + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A; + GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B; + GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C; + GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D; + GL_VERTEX_ARRAY_POINTER_EXT = $808E; + GL_NORMAL_ARRAY_POINTER_EXT = $808F; + GL_COLOR_ARRAY_POINTER_EXT = $8090; + GL_INDEX_ARRAY_POINTER_EXT = $8091; + GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092; + GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093; + + // GL_EXT_vertex_shader + GL_VERTEX_SHADER_EXT = $8780; + GL_VERTEX_SHADER_BINDING_EXT = $8781; + GL_OP_INDEX_EXT = $8782; + GL_OP_NEGATE_EXT = $8783; + GL_OP_DOT3_EXT = $8784; + GL_OP_DOT4_EXT = $8785; + GL_OP_MUL_EXT = $8786; + GL_OP_ADD_EXT = $8787; + GL_OP_MADD_EXT = $8788; + GL_OP_FRAC_EXT = $8789; + GL_OP_MAX_EXT = $878A; + GL_OP_MIN_EXT = $878B; + GL_OP_SET_GE_EXT = $878C; + GL_OP_SET_LT_EXT = $878D; + GL_OP_CLAMP_EXT = $878E; + GL_OP_FLOOR_EXT = $878F; + GL_OP_ROUND_EXT = $8790; + GL_OP_EXP_BASE_2_EXT = $8791; + GL_OP_LOG_BASE_2_EXT = $8792; + GL_OP_POWER_EXT = $8793; + GL_OP_RECIP_EXT = $8794; + GL_OP_RECIP_SQRT_EXT = $8795; + GL_OP_SUB_EXT = $8796; + GL_OP_CROSS_PRODUCT_EXT = $8797; + GL_OP_MULTIPLY_MATRIX_EXT = $8798; + GL_OP_MOV_EXT = $8799; + GL_OUTPUT_VERTEX_EXT = $879A; + GL_OUTPUT_COLOR0_EXT = $879B; + GL_OUTPUT_COLOR1_EXT = $879C; + GL_OUTPUT_TEXTURE_COORD0_EXT = $879D; + GL_OUTPUT_TEXTURE_COORD1_EXT = $879E; + GL_OUTPUT_TEXTURE_COORD2_EXT = $879F; + GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0; + GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1; + GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2; + GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3; + GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4; + GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5; + GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6; + GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7; + GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8; + GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9; + GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA; + GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB; + GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC; + GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD; + GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE; + GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF; + GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0; + GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1; + GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2; + GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3; + GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4; + GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5; + GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6; + GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7; + GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8; + GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9; + GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA; + GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB; + GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC; + GL_OUTPUT_FOG_EXT = $87BD; + GL_SCALAR_EXT = $87BE; + GL_VECTOR_EXT = $87BF; + GL_MATRIX_EXT = $87C0; + GL_VARIANT_EXT = $87C1; + GL_INVARIANT_EXT = $87C2; + GL_LOCAL_CONSTANT_EXT = $87C3; + GL_LOCAL_EXT = $87C4; + GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5; + GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6; + GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7; + GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8; + GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9; + GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA; + GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB; + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC; + GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD; + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE; + GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF; + GL_VERTEX_SHADER_VARIANTS_EXT = $87D0; + GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1; + GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2; + GL_VERTEX_SHADER_LOCALS_EXT = $87D3; + GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4; + GL_X_EXT = $87D5; + GL_Y_EXT = $87D6; + GL_Z_EXT = $87D7; + GL_W_EXT = $87D8; + GL_NEGATIVE_X_EXT = $87D9; + GL_NEGATIVE_Y_EXT = $87DA; + GL_NEGATIVE_Z_EXT = $87DB; + GL_NEGATIVE_W_EXT = $87DC; + GL_ZERO_EXT = $87DD; + GL_ONE_EXT = $87DE; + GL_NEGATIVE_ONE_EXT = $87DF; + GL_NORMALIZED_RANGE_EXT = $87E0; + GL_FULL_RANGE_EXT = $87E1; + GL_CURRENT_VERTEX_EXT = $87E2; + GL_MVP_MATRIX_EXT = $87E3; + GL_VARIANT_VALUE_EXT = $87E4; + GL_VARIANT_DATATYPE_EXT = $87E5; + GL_VARIANT_ARRAY_STRIDE_EXT = $87E6; + GL_VARIANT_ARRAY_TYPE_EXT = $87E7; + GL_VARIANT_ARRAY_EXT = $87E8; + GL_VARIANT_ARRAY_POINTER_EXT = $87E9; + GL_INVARIANT_VALUE_EXT = $87EA; + GL_INVARIANT_DATATYPE_EXT = $87EB; + GL_LOCAL_CONSTANT_VALUE_EXT = $87EC; + GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED; + + // GL_EXT_vertex_weighting + GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3; + GL_MODELVIEW1_STACK_DEPTH_EXT = $8502; + GL_MODELVIEW0_MATRIX_EXT = $0BA6; + GL_MODELVIEW1_MATRIX_EXT = $8506; + GL_VERTEX_WEIGHTING_EXT = $8509; + GL_MODELVIEW0_EXT = $1700; + GL_MODELVIEW1_EXT = $850A; + GL_CURRENT_VERTEX_WEIGHT_EXT = $850B; + GL_VERTEX_WEIGHT_ARRAY_EXT = $850C; + GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D; + GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E; + GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F; + GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510; + + // GL_EXT_depth_bounds_test + GL_DEPTH_BOUNDS_TEST_EXT = $8890; + GL_DEPTH_BOUNDS_EXT = $8891; + + // GL_EXT_texture_mirror_clamp + GL_MIRROR_CLAMP_EXT = $8742; + GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743; + GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912; + + // GL_EXT_blend_equation_separate + GL_BLEND_EQUATION_RGB_EXT = $8009; + GL_BLEND_EQUATION_ALPHA_EXT = $883D; + + // GL_EXT_pixel_buffer_object + GL_PIXEL_PACK_BUFFER_EXT = $88EB; + GL_PIXEL_UNPACK_BUFFER_EXT = $88EC; + GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED; + GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF; + + // GL_EXT_stencil_clear_tag + GL_STENCIL_TAG_BITS_EXT = $88F2; + GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3; + + // GL_EXT_packed_depth_stencil + GL_DEPTH_STENCIL_EXT = $84F9; + GL_UNSIGNED_INT_24_8_EXT = $84FA; + GL_DEPTH24_STENCIL8_EXT = $88F0; + GL_TEXTURE_STENCIL_SIZE_EXT = $88F1; + + // GL_EXT_texture_sRGB + GL_SRGB_EXT = $8C40; + GL_SRGB8_EXT = $8C41; + GL_SRGB_ALPHA_EXT = $8C42; + GL_SRGB8_ALPHA8_EXT = $8C43; + GL_SLUMINANCE_ALPHA_EXT = $8C44; + GL_SLUMINANCE8_ALPHA8_EXT = $8C45; + GL_SLUMINANCE_EXT = $8C46; + GL_SLUMINANCE8_EXT = $8C47; + GL_COMPRESSED_SRGB_EXT = $8C48; + GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49; + GL_COMPRESSED_SLUMINANCE_EXT = $8C4A; + GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B; + 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_framebuffer_blit + GL_READ_FRAMEBUFFER_EXT = $8CA8; + GL_DRAW_FRAMEBUFFER_EXT = $8CA9; + GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT; + GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA; + + // GL_EXT_framebuffer_multisample + GL_RENDERBUFFER_SAMPLES_EXT = $8CAB; + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56; + GL_MAX_SAMPLES_EXT = $8D57; + + // GL_EXT_timer_query + GL_TIME_ELAPSED_EXT = $88BF; + + // GL_EXT_bindable_uniform + GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2; + GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3; + GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4; + GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED; + GL_UNIFORM_BUFFER_EXT = $8DEE; + GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF; + + // GL_EXT_framebuffer_sRGB + GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; + WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9; + GL_FRAMEBUFFER_SRGB_EXT = $8DB9; + GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA; + + // GL_EXT_geometry_shader4 + GL_GEOMETRY_SHADER_EXT = $8DD9; + GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA; + GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB; + GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC; + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29; + GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD; + GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE; + GL_MAX_VARYING_COMPONENTS_EXT = $8B4B; + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF; + GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0; + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1; + GL_LINES_ADJACENCY_EXT = $A; + GL_LINE_STRIP_ADJACENCY_EXT = $B; + GL_TRIANGLES_ADJACENCY_EXT = $C; + GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8; + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9; + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7; + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4; + GL_PROGRAM_POINT_SIZE_EXT = $8642; + + // GL_EXT_gpu_shader4 + GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD; + GL_SAMPLER_1D_ARRAY_EXT = $8DC0; + GL_SAMPLER_2D_ARRAY_EXT = $8DC1; + GL_SAMPLER_BUFFER_EXT = $8DC2; + GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3; + GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4; + GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5; + GL_UNSIGNED_INT_VEC2_EXT = $8DC6; + GL_UNSIGNED_INT_VEC3_EXT = $8DC7; + GL_UNSIGNED_INT_VEC4_EXT = $8DC8; + GL_INT_SAMPLER_1D_EXT = $8DC9; + GL_INT_SAMPLER_2D_EXT = $8DCA; + GL_INT_SAMPLER_3D_EXT = $8DCB; + GL_INT_SAMPLER_CUBE_EXT = $8DCC; + GL_INT_SAMPLER_2D_RECT_EXT = $8DCD; + GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE; + GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF; + GL_INT_SAMPLER_BUFFER_EXT = $8DD0; + GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1; + GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2; + GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3; + GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4; + GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5; + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6; + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7; + GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8; + GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904; + GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905; + + // GL_EXT_packed_float + GL_R11F_G11F_B10F_EXT = $8C3A; + GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B; + RGBA_SIGNED_COMPONENTS_EXT = $8C3C; + WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8; + GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; + GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; + + // GL_EXT_texture_array + GL_TEXTURE_1D_ARRAY_EXT = $8C18; + GL_TEXTURE_2D_ARRAY_EXT = $8C1A; + GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B; + GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19; + GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C; + GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D; + GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF; + GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E; + + // GL_EXT_texture_buffer_object + GL_TEXTURE_BUFFER_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_FORMAT_EXT = $8C2E; + + // GL_EXT_texture_compression_latc + GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70; + GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71; + GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72; + GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73; + + // 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_integer + GL_RGBA_INTEGER_MODE_EXT = $8D9E; + GL_RGBA32UI_EXT = $8D70; + GL_RGB32UI_EXT = $8D71; + GL_ALPHA32UI_EXT = $8D72; + GL_INTENSITY32UI_EXT = $8D73; + GL_LUMINANCE32UI_EXT = $8D74; + GL_LUMINANCE_ALPHA32UI_EXT = $8D75; + GL_RGBA16UI_EXT = $8D76; + GL_RGB16UI_EXT = $8D77; + GL_ALPHA16UI_EXT = $8D78; + GL_INTENSITY16UI_EXT = $8D79; + GL_LUMINANCE16UI_EXT = $8D7A; + GL_LUMINANCE_ALPHA16UI_EXT = $8D7B; + GL_RGBA8UI_EXT = $8D7C; + GL_RGB8UI_EXT = $8D7D; + GL_ALPHA8UI_EXT = $8D7E; + GL_INTENSITY8UI_EXT = $8D7F; + GL_LUMINANCE8UI_EXT = $8D80; + GL_LUMINANCE_ALPHA8UI_EXT = $8D81; + GL_RGBA32I_EXT = $8D82; + GL_RGB32I_EXT = $8D83; + GL_ALPHA32I_EXT = $8D84; + GL_INTENSITY32I_EXT = $8D85; + GL_LUMINANCE32I_EXT = $8D86; + GL_LUMINANCE_ALPHA32I_EXT = $8D87; + GL_RGBA16I_EXT = $8D88; + GL_RGB16I_EXT = $8D89; + GL_ALPHA16I_EXT = $8D8A; + GL_INTENSITY16I_EXT = $8D8B; + GL_LUMINANCE16I_EXT = $8D8C; + GL_LUMINANCE_ALPHA16I_EXT = $8D8D; + GL_RGBA8I_EXT = $8D8E; + GL_RGB8I_EXT = $8D8F; + GL_ALPHA8I_EXT = $8D90; + GL_INTENSITY8I_EXT = $8D91; + GL_LUMINANCE8I_EXT = $8D92; + GL_LUMINANCE_ALPHA8I_EXT = $8D93; + GL_RED_INTEGER_EXT = $8D94; + GL_GREEN_INTEGER_EXT = $8D95; + GL_BLUE_INTEGER_EXT = $8D96; + GL_ALPHA_INTEGER_EXT = $8D97; + GL_RGB_INTEGER_EXT = $8D98; + GL_RGBA_INTEGER_EXT = $8D99; + GL_BGR_INTEGER_EXT = $8D9A; + GL_BGRA_INTEGER_EXT = $8D9B; + GL_LUMINANCE_INTEGER_EXT = $8D9C; + GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D; + + // GL_EXT_texture_shared_exponent + GL_RGB9_E5_EXT = $8C3D; + GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E; + GL_TEXTURE_SHARED_SIZE_EXT = $8C3F; + + // GL_EXT_transform_feedback + GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E; + GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84; + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85; + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F; + GL_INTERLEAVED_ATTRIBS_EXT = $8C8C; + GL_SEPARATE_ATTRIBS_EXT = $8C8D; + GL_PRIMITIVES_GENERATED_EXT = $8C87; + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88; + GL_RASTERIZER_DISCARD_EXT = $8C89; + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80; + GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83; + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F; + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76; + + // GL_EXT_direct_state_access + GL_PROGRAM_MATRIX_EXT = $8E2D; + GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E; + GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F; + + // GL_EXT_texture_swizzle + GL_TEXTURE_SWIZZLE_R_EXT = $8E42; + GL_TEXTURE_SWIZZLE_G_EXT = $8E43; + GL_TEXTURE_SWIZZLE_B_EXT = $8E44; + GL_TEXTURE_SWIZZLE_A_EXT = $8E45; + GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46; + + // GL_EXT_provoking_vertex + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C; + GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D; + GL_LAST_VERTEX_CONVENTION_EXT = $8E4E; + GL_PROVOKING_VERTEX_EXT = $8E4F; + + // GL_EXT_texture_snorm + GL_ALPHA_SNORM = $9010; + GL_LUMINANCE_SNORM = $9011; + GL_LUMINANCE_ALPHA_SNORM = $9012; + GL_INTENSITY_SNORM = $9013; + GL_ALPHA8_SNORM = $9014; + GL_LUMINANCE8_SNORM = $9015; + GL_LUMINANCE8_ALPHA8_SNORM = $9016; + GL_INTENSITY8_SNORM = $9017; + GL_ALPHA16_SNORM = $9018; + GL_LUMINANCE16_SNORM = $9019; + GL_LUMINANCE16_ALPHA16_SNORM = $901A; + GL_INTENSITY16_SNORM = $901B; + { reuse GL_RED_SNORM } + { reuse GL_RG_SNORM } + { reuse GL_RGB_SNORM } + { reuse GL_RGBA_SNORM } + { reuse GL_R8_SNORM } + { reuse GL_RG8_SNORM } + { reuse GL_RGB8_SNORM } + { reuse GL_RGBA8_SNORM } + { reuse GL_R16_SNORM } + { reuse GL_RG16_SNORM } + { reuse GL_RGB16_SNORM } + { reuse GL_RGBA16_SNORM } + { reuse GL_SIGNED_NORMALIZED } + + // GL_EXT_separate_shader_objects + GL_ACTIVE_PROGRAM_EXT = $8B8D; + + // GL_EXT_shader_image_load_store + GL_MAX_IMAGE_UNITS_EXT = $8F38; + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = $8F39; + GL_IMAGE_BINDING_NAME_EXT = $8F3A; + GL_IMAGE_BINDING_LEVEL_EXT = $8F3B; + GL_IMAGE_BINDING_LAYERED_EXT = $8F3C; + GL_IMAGE_BINDING_LAYER_EXT = $8F3D; + GL_IMAGE_BINDING_ACCESS_EXT = $8F3E; + GL_IMAGE_1D_EXT = $904C; + GL_IMAGE_2D_EXT = $904D; + GL_IMAGE_3D_EXT = $904E; + GL_IMAGE_2D_RECT_EXT = $904F; + GL_IMAGE_CUBE_EXT = $9050; + GL_IMAGE_BUFFER_EXT = $9051; + GL_IMAGE_1D_ARRAY_EXT = $9052; + GL_IMAGE_2D_ARRAY_EXT = $9053; + GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054; + GL_IMAGE_2D_MULTISAMPLE_EXT = $9055; + GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9056; + GL_INT_IMAGE_1D_EXT = $9057; + GL_INT_IMAGE_2D_EXT = $9058; + GL_INT_IMAGE_3D_EXT = $9059; + GL_INT_IMAGE_2D_RECT_EXT = $905A; + GL_INT_IMAGE_CUBE_EXT = $905B; + GL_INT_IMAGE_BUFFER_EXT = $905C; + GL_INT_IMAGE_1D_ARRAY_EXT = $905D; + GL_INT_IMAGE_2D_ARRAY_EXT = $905E; + GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F; + GL_INT_IMAGE_2D_MULTISAMPLE_EXT = $9060; + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9061; + GL_UNSIGNED_INT_IMAGE_1D_EXT = $9062; + GL_UNSIGNED_INT_IMAGE_2D_EXT = $9063; + GL_UNSIGNED_INT_IMAGE_3D_EXT = $9064; + GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = $9065; + GL_UNSIGNED_INT_IMAGE_CUBE_EXT = $9066; + GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067; + GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = $9068; + GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = $9069; + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = $906B; + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $906C; + GL_MAX_IMAGE_SAMPLES_EXT = $906D; + GL_IMAGE_BINDING_FORMAT_EXT = $906E; + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = $00000001; + GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = $00000002; + GL_UNIFORM_BARRIER_BIT_EXT = $00000004; + GL_TEXTURE_FETCH_BARRIER_BIT_EXT = $00000008; + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = $00000020; + GL_COMMAND_BARRIER_BIT_EXT = $00000040; + GL_PIXEL_BUFFER_BARRIER_BIT_EXT = $00000080; + GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = $00000100; + GL_BUFFER_UPDATE_BARRIER_BIT_EXT = $00000200; + GL_FRAMEBUFFER_BARRIER_BIT_EXT = $00000400; + GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = $00000800; + GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = $00001000; + GL_ALL_BARRIER_BITS_EXT = $FFFFFFFF; + + // GL_EXT_vertex_attrib_64bit + { reuse GL_DOUBLE } + GL_DOUBLE_VEC2_EXT = $8FFC; + GL_DOUBLE_VEC3_EXT = $8FFD; + GL_DOUBLE_VEC4_EXT = $8FFE; + GL_DOUBLE_MAT2_EXT = $8F46; + GL_DOUBLE_MAT3_EXT = $8F47; + GL_DOUBLE_MAT4_EXT = $8F48; + GL_DOUBLE_MAT2x3_EXT = $8F49; + GL_DOUBLE_MAT2x4_EXT = $8F4A; + GL_DOUBLE_MAT3x2_EXT = $8F4B; + GL_DOUBLE_MAT3x4_EXT = $8F4C; + GL_DOUBLE_MAT4x2_EXT = $8F4D; + GL_DOUBLE_MAT4x3_EXT = $8F4E; + + // GL_EXT_texture_sRGB_decode + GL_TEXTURE_SRGB_DECODE_EXT = $8A48; + GL_DECODE_EXT = $8A49; + GL_SKIP_DECODE_EXT = $8A4A; + + // GL_NV_texture_multisample + GL_TEXTURE_COVERAGE_SAMPLES_NV = $9045; + GL_TEXTURE_COLOR_SAMPLES_NV = $9046; + + // GL_AMD_blend_minmax_factor + GL_FACTOR_MIN_AMD = $901C; + GL_FACTOR_MAX_AMD = $901D; + + // GL_AMD_sample_positions + GL_SUBSAMPLE_DISTANCE_AMD = $883F; + + // GL_EXT_x11_sync_object + GL_SYNC_X11_FENCE_EXT = $90E1; + + // GL_EXT_framebuffer_multisample_blit_scaled + GL_SCALED_RESOLVE_FASTEST_EXT = $90BA; + GL_SCALED_RESOLVE_NICEST_EXT = $90BB; + + // (4.3) 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_PATH_SAMPLE_QUALITY_NV = $9085; + GL_PATH_STROKE_BOUND_NV = $9086; + GL_PATH_STROKE_OVERSAMPLE_COUNT_NV= $9087; + GL_COUNT_UP_NV = $9088; + GL_COUNT_DOWN_NV = $9089; + GL_PATH_OBJECT_BOUNDING_BOX_NV = $908A; + GL_CONVEX_HULL_NV = $908B; + GL_MULTI_HULLS_NV = $908C; + 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_PROJECTIVE_2D_NV = $9093; + GL_AFFINE_3D_NV = $9094; + GL_PROJECTIVE_3D_NV = $9095; + GL_TRANSPOSE_AFFINE_2D_NV = $9096; + GL_TRANSPOSE_PROJECTIVE_2D_NV = $9097; + GL_TRANSPOSE_AFFINE_3D_NV = $9098; + GL_TRANSPOSE_PROJECTIVE_3D_NV = $9099; + 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_PATH_FOG_GEN_MODE_NV = $90AC; + 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_COLOR_FORMAT_NV = $90B2; + 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_NV = $100; + GL_FONT_X_MIN_BOUNDS_NV = $00010000; + GL_FONT_Y_MIN_BOUNDS_NV = $00020000; + GL_FONT_X_MAX_BOUNDS_NV = $00040000; + GL_FONT_Y_MAX_BOUNDS_NV = $00080000; + GL_FONT_UNITS_PER_EM_NV = $00100000; + GL_FONT_ASCENDER_NV = $00200000; + GL_FONT_DESCENDER_NV = $00400000; + GL_FONT_HEIGHT_NV = $00800000; + GL_FONT_MAX_ADVANCE_WIDTH_NV = $01000000; + GL_FONT_MAX_ADVANCE_HEIGHT_NV = $02000000; + GL_FONT_UNDERLINE_POSITION_NV = $04000000; + GL_FONT_UNDERLINE_THICKNESS_NV = $08000000; + GL_FONT_HAS_KERNING_NV = $10000000; + + // (4.3) GL_AMD_pinned_memory + GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD= $9160; + + // (4.3) GL_AMD_stencil_operation_extended + GL_SET_AMD = $874A; + GL_REPLACE_VALUE_AMD = $874B; + GL_STENCIL_OP_VALUE_AMD = $874C; + GL_STENCIL_BACK_OP_VALUE_AMD = $874D; + + // (4.3) GL_AMD_vertex_shader_viewport_index + + // (4.3) GL_AMD_vertex_shader_layer + + // (4.3) GL_NV_bindless_texture + + // (4.3) GL_NV_shader_atomic_float + + // (4.3) GL_AMD_query_buffer_object + GL_QUERY_BUFFER_AMD = $9192; + GL_QUERY_BUFFER_BINDING_AMD = $9193; + GL_QUERY_RESULT_NO_WAIT_AMD = $9194; + + // GL_FfdMaskSGIX + GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001; + GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002; + + // GL_HP_convolution_border_modes + GL_IGNORE_BORDER_HP = $8150; + GL_CONSTANT_BORDER_HP = $8151; + GL_REPLICATE_BORDER_HP = $8153; + GL_CONVOLUTION_BORDER_COLOR_HP = $8154; + + // GL_HP_image_transform + GL_IMAGE_SCALE_X_HP = $8155; + GL_IMAGE_SCALE_Y_HP = $8156; + GL_IMAGE_TRANSLATE_X_HP = $8157; + GL_IMAGE_TRANSLATE_Y_HP = $8158; + GL_IMAGE_ROTATE_ANGLE_HP = $8159; + GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A; + GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B; + GL_IMAGE_MAG_FILTER_HP = $815C; + GL_IMAGE_MIN_FILTER_HP = $815D; + GL_IMAGE_CUBIC_WEIGHT_HP = $815E; + GL_CUBIC_HP = $815F; + GL_AVERAGE_HP = $8160; + GL_IMAGE_TRANSFORM_2D_HP = $8161; + GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162; + GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163; + + // GL_HP_occlusion_test + GL_OCCLUSION_TEST_HP = $8165; + GL_OCCLUSION_TEST_RESULT_HP = $8166; + + // GL_HP_texture_lighting + GL_TEXTURE_LIGHTING_MODE_HP = $8167; + GL_TEXTURE_POST_SPECULAR_HP = $8168; + GL_TEXTURE_PRE_SPECULAR_HP = $8169; + + // GL_IBM_cull_vertex + GL_CULL_VERTEX_IBM = 103050; + + // GL_IBM_rasterpos_clip + GL_RASTER_POSITION_UNCLIPPED_IBM = $19262; + + // GL_IBM_texture_mirrored_repeat + GL_MIRRORED_REPEAT_IBM = $8370; + + // GL_IBM_vertex_array_lists + GL_VERTEX_ARRAY_LIST_IBM = 103070; + GL_NORMAL_ARRAY_LIST_IBM = 103071; + GL_COLOR_ARRAY_LIST_IBM = 103072; + GL_INDEX_ARRAY_LIST_IBM = 103073; + GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074; + GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075; + GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076; + GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077; + GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080; + GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081; + GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082; + GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083; + GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084; + GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085; + GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086; + GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087; + + // GL_INGR_color_clamp + GL_RED_MIN_CLAMP_INGR = $8560; + GL_GREEN_MIN_CLAMP_INGR = $8561; + GL_BLUE_MIN_CLAMP_INGR = $8562; + GL_ALPHA_MIN_CLAMP_INGR = $8563; + GL_RED_MAX_CLAMP_INGR = $8564; + GL_GREEN_MAX_CLAMP_INGR = $8565; + GL_BLUE_MAX_CLAMP_INGR = $8566; + GL_ALPHA_MAX_CLAMP_INGR = $8567; + + // GL_INGR_interlace_read + GL_INTERLACE_READ_INGR = $8568; + + // GL_INTEL_parallel_arrays + GL_PARALLEL_ARRAYS_INTEL = $83F4; + GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5; + GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6; + GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7; + GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8; + + // GL_NV_copy_depth_to_color + GL_DEPTH_STENCIL_TO_RGBA_NV = $886E; + GL_DEPTH_STENCIL_TO_BGRA_NV = $886F; + + // GL_NV_depth_clamp + GL_DEPTH_CLAMP_NV = $864F; + + // GL_NV_evaluators + GL_EVAL_2D_NV = $86C0; + GL_EVAL_TRIANGULAR_2D_NV = $86C1; + GL_MAP_TESSELLATION_NV = $86C2; + GL_MAP_ATTRIB_U_ORDER_NV = $86C3; + GL_MAP_ATTRIB_V_ORDER_NV = $86C4; + GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5; + GL_EVAL_VERTEX_ATTRIB0_NV = $86C6; + GL_EVAL_VERTEX_ATTRIB1_NV = $86C7; + GL_EVAL_VERTEX_ATTRIB2_NV = $86C8; + GL_EVAL_VERTEX_ATTRIB3_NV = $86C9; + GL_EVAL_VERTEX_ATTRIB4_NV = $86CA; + GL_EVAL_VERTEX_ATTRIB5_NV = $86CB; + GL_EVAL_VERTEX_ATTRIB6_NV = $86CC; + GL_EVAL_VERTEX_ATTRIB7_NV = $86CD; + GL_EVAL_VERTEX_ATTRIB8_NV = $86CE; + GL_EVAL_VERTEX_ATTRIB9_NV = $86CF; + GL_EVAL_VERTEX_ATTRIB10_NV = $86D0; + GL_EVAL_VERTEX_ATTRIB11_NV = $86D1; + GL_EVAL_VERTEX_ATTRIB12_NV = $86D2; + GL_EVAL_VERTEX_ATTRIB13_NV = $86D3; + GL_EVAL_VERTEX_ATTRIB14_NV = $86D4; + GL_EVAL_VERTEX_ATTRIB15_NV = $86D5; + GL_MAX_MAP_TESSELLATION_NV = $86D6; + GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7; + + // GL_NV_fence + GL_ALL_COMPLETED_NV = $84F2; + GL_FENCE_STATUS_NV = $84F3; + GL_FENCE_CONDITION_NV = $84F4; + + // GL_NV_float_buffer + GL_FLOAT_R_NV = $8880; + GL_FLOAT_RG_NV = $8881; + GL_FLOAT_RGB_NV = $8882; + GL_FLOAT_RGBA_NV = $8883; + GL_FLOAT_R16_NV = $8884; + GL_FLOAT_R32_NV = $8885; + GL_FLOAT_RG16_NV = $8886; + GL_FLOAT_RG32_NV = $8887; + GL_FLOAT_RGB16_NV = $8888; + GL_FLOAT_RGB32_NV = $8889; + GL_FLOAT_RGBA16_NV = $888A; + GL_FLOAT_RGBA32_NV = $888B; + GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C; + GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D; + GL_FLOAT_RGBA_MODE_NV = $888E; + + // GL_NV_fog_distance + GL_FOG_DISTANCE_MODE_NV = $855A; + GL_EYE_RADIAL_NV = $855B; + GL_EYE_PLANE_ABSOLUTE_NV = $855C; + + // GL_NV_fragment_program + GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868; + GL_FRAGMENT_PROGRAM_NV = $8870; + GL_MAX_TEXTURE_COORDS_NV = $8871; + GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872; + GL_FRAGMENT_PROGRAM_BINDING_NV = $8873; + GL_PROGRAM_ERROR_STRING_NV = $8874; + + // GL_NV_half_float + GL_HALF_FLOAT_NV = $140B; + + // GL_NV_light_max_exponent + GL_MAX_SHININESS_NV = $8504; + GL_MAX_SPOT_EXPONENT_NV = $8505; + + // GL_NV_multisample_filter_hint + GL_MULTISAMPLE_FILTER_HINT_NV = $8534; + + // GL_NV_occlusion_query + GL_PIXEL_COUNTER_BITS_NV = $8864; + GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865; + GL_PIXEL_COUNT_NV = $8866; + GL_PIXEL_COUNT_AVAILABLE_NV = $8867; + + // GL_NV_packed_depth_stencil + GL_DEPTH_STENCIL_NV = $84F9; + GL_UNSIGNED_INT_24_8_NV = $84FA; + + // GL_NV_pixel_data_range + GL_WRITE_PIXEL_DATA_RANGE_NV = $8878; + GL_READ_PIXEL_DATA_RANGE_NV = $8879; + GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A; + GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B; + GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C; + GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D; + + // GL_NV_point_sprite + GL_POINT_SPRITE_NV = $8861; + GL_COORD_REPLACE_NV = $8862; + GL_POINT_SPRITE_R_MODE_NV = $8863; + + // GL_NV_primitive_restart + GL_PRIMITIVE_RESTART_NV = $8558; + GL_PRIMITIVE_RESTART_INDEX_NV = $8559; + + // GL_NV_register_combiners + GL_REGISTER_COMBINERS_NV = $8522; + GL_VARIABLE_A_NV = $8523; + GL_VARIABLE_B_NV = $8524; + GL_VARIABLE_C_NV = $8525; + GL_VARIABLE_D_NV = $8526; + GL_VARIABLE_E_NV = $8527; + GL_VARIABLE_F_NV = $8528; + GL_VARIABLE_G_NV = $8529; + GL_CONSTANT_COLOR0_NV = $852A; + GL_CONSTANT_COLOR1_NV = $852B; + GL_PRIMARY_COLOR_NV = $852C; + GL_SECONDARY_COLOR_NV = $852D; + GL_SPARE0_NV = $852E; + GL_SPARE1_NV = $852F; + GL_DISCARD_NV = $8530; + GL_E_TIMES_F_NV = $8531; + GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532; + GL_UNSIGNED_IDENTITY_NV = $8536; + GL_UNSIGNED_INVERT_NV = $8537; + GL_EXPAND_NORMAL_NV = $8538; + GL_EXPAND_NEGATE_NV = $8539; + GL_HALF_BIAS_NORMAL_NV = $853A; + GL_HALF_BIAS_NEGATE_NV = $853B; + GL_SIGNED_IDENTITY_NV = $853C; + GL_SIGNED_NEGATE_NV = $853D; + GL_SCALE_BY_TWO_NV = $853E; + GL_SCALE_BY_FOUR_NV = $853F; + GL_SCALE_BY_ONE_HALF_NV = $8540; + GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541; + GL_COMBINER_INPUT_NV = $8542; + GL_COMBINER_MAPPING_NV = $8543; + GL_COMBINER_COMPONENT_USAGE_NV = $8544; + GL_COMBINER_AB_DOT_PRODUCT_NV = $8545; + GL_COMBINER_CD_DOT_PRODUCT_NV = $8546; + GL_COMBINER_MUX_SUM_NV = $8547; + GL_COMBINER_SCALE_NV = $8548; + GL_COMBINER_BIAS_NV = $8549; + GL_COMBINER_AB_OUTPUT_NV = $854A; + GL_COMBINER_CD_OUTPUT_NV = $854B; + GL_COMBINER_SUM_OUTPUT_NV = $854C; + GL_MAX_GENERAL_COMBINERS_NV = $854D; + GL_NUM_GENERAL_COMBINERS_NV = $854E; + GL_COLOR_SUM_CLAMP_NV = $854F; + GL_COMBINER0_NV = $8550; + GL_COMBINER1_NV = $8551; + GL_COMBINER2_NV = $8552; + GL_COMBINER3_NV = $8553; + GL_COMBINER4_NV = $8554; + GL_COMBINER5_NV = $8555; + GL_COMBINER6_NV = $8556; + GL_COMBINER7_NV = $8557; + + // GL_NV_register_combiners2 + GL_PER_STAGE_CONSTANTS_NV = $8535; + + // GL_NV_texgen_emboss + GL_EMBOSS_LIGHT_NV = $855D; + GL_EMBOSS_CONSTANT_NV = $855E; + GL_EMBOSS_MAP_NV = $855F; + + // GL_NV_texgen_reflection + GL_NORMAL_MAP_NV = $8511; + GL_REFLECTION_MAP_NV = $8512; + + // GL_NV_texture_env_combine4 + GL_COMBINE4_NV = $8503; + GL_SOURCE3_RGB_NV = $8583; + GL_SOURCE3_ALPHA_NV = $858B; + GL_OPERAND3_RGB_NV = $8593; + GL_OPERAND3_ALPHA_NV = $859B; + + // GL_NV_texture_expand_normal + GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F; + + // GL_NV_texture_rectangle + GL_TEXTURE_RECTANGLE_NV = $84F5; + GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6; + GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7; + GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8; + + // GL_NV_texture_shader + GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C; + GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D; + GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E; + GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9; + GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA; + GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB; + GL_DSDT_MAG_INTENSITY_NV = $86DC; + GL_SHADER_CONSISTENT_NV = $86DD; + GL_TEXTURE_SHADER_NV = $86DE; + GL_SHADER_OPERATION_NV = $86DF; + GL_CULL_MODES_NV = $86E0; + GL_OFFSET_TEXTURE_MATRIX_NV = $86E1; + GL_OFFSET_TEXTURE_SCALE_NV = $86E2; + GL_OFFSET_TEXTURE_BIAS_NV = $86E3; + GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV; + GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV; + GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV; + GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4; + GL_CONST_EYE_NV = $86E5; + GL_PASS_THROUGH_NV = $86E6; + GL_CULL_FRAGMENT_NV = $86E7; + GL_OFFSET_TEXTURE_2D_NV = $86E8; + GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9; + GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA; + GL_DOT_PRODUCT_NV = $86EC; + GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED; + GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE; + GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0; + GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1; + GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2; + GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3; + GL_HILO_NV = $86F4; + GL_DSDT_NV = $86F5; + GL_DSDT_MAG_NV = $86F6; + GL_DSDT_MAG_VIB_NV = $86F7; + GL_HILO16_NV = $86F8; + GL_SIGNED_HILO_NV = $86F9; + GL_SIGNED_HILO16_NV = $86FA; + GL_SIGNED_RGBA_NV = $86FB; + GL_SIGNED_RGBA8_NV = $86FC; + GL_SIGNED_RGB_NV = $86FE; + GL_SIGNED_RGB8_NV = $86FF; + GL_SIGNED_LUMINANCE_NV = $8701; + GL_SIGNED_LUMINANCE8_NV = $8702; + GL_SIGNED_LUMINANCE_ALPHA_NV = $8703; + GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704; + GL_SIGNED_ALPHA_NV = $8705; + GL_SIGNED_ALPHA8_NV = $8706; + GL_SIGNED_INTENSITY_NV = $8707; + GL_SIGNED_INTENSITY8_NV = $8708; + GL_DSDT8_NV = $8709; + GL_DSDT8_MAG8_NV = $870A; + GL_DSDT8_MAG8_INTENSITY8_NV = $870B; + GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C; + GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D; + GL_HI_SCALE_NV = $870E; + GL_LO_SCALE_NV = $870F; + GL_DS_SCALE_NV = $8710; + GL_DT_SCALE_NV = $8711; + GL_MAGNITUDE_SCALE_NV = $8712; + GL_VIBRANCE_SCALE_NV = $8713; + GL_HI_BIAS_NV = $8714; + GL_LO_BIAS_NV = $8715; + GL_DS_BIAS_NV = $8716; + GL_DT_BIAS_NV = $8717; + GL_MAGNITUDE_BIAS_NV = $8718; + GL_VIBRANCE_BIAS_NV = $8719; + GL_TEXTURE_BORDER_VALUES_NV = $871A; + GL_TEXTURE_HI_SIZE_NV = $871B; + GL_TEXTURE_LO_SIZE_NV = $871C; + GL_TEXTURE_DS_SIZE_NV = $871D; + GL_TEXTURE_DT_SIZE_NV = $871E; + GL_TEXTURE_MAG_SIZE_NV = $871F; + + // GL_NV_texture_shader2 + GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF; + + // GL_NV_texture_shader3 + GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850; + GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851; + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852; + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853; + GL_OFFSET_HILO_TEXTURE_2D_NV = $8854; + GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855; + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856; + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857; + GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858; + GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859; + GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A; + GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B; + GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C; + GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D; + GL_HILO8_NV = $885E; + GL_SIGNED_HILO8_NV = $885F; + GL_FORCE_BLUE_TO_ONE_NV = $8860; + + // GL_NV_vertex_array_range + GL_VERTEX_ARRAY_RANGE_NV = $851D; + GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E; + GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F; + GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520; + GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521; + + // GL_NV_vertex_array_range2 + GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533; + + // GL_NV_vertex_program + GL_VERTEX_PROGRAM_NV = $8620; + GL_VERTEX_STATE_PROGRAM_NV = $8621; + GL_ATTRIB_ARRAY_SIZE_NV = $8623; + GL_ATTRIB_ARRAY_STRIDE_NV = $8624; + GL_ATTRIB_ARRAY_TYPE_NV = $8625; + GL_CURRENT_ATTRIB_NV = $8626; + GL_PROGRAM_LENGTH_NV = $8627; + GL_PROGRAM_STRING_NV = $8628; + GL_MODELVIEW_PROJECTION_NV = $8629; + GL_IDENTITY_NV = $862A; + GL_INVERSE_NV = $862B; + GL_TRANSPOSE_NV = $862C; + GL_INVERSE_TRANSPOSE_NV = $862D; + GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E; + GL_MAX_TRACK_MATRICES_NV = $862F; + GL_MATRIX0_NV = $8630; + GL_MATRIX1_NV = $8631; + GL_MATRIX2_NV = $8632; + GL_MATRIX3_NV = $8633; + GL_MATRIX4_NV = $8634; + GL_MATRIX5_NV = $8635; + GL_MATRIX6_NV = $8636; + GL_MATRIX7_NV = $8637; + GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640; + GL_CURRENT_MATRIX_NV = $8641; + GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642; + GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643; + GL_PROGRAM_PARAMETER_NV = $8644; + GL_ATTRIB_ARRAY_POINTER_NV = $8645; + GL_PROGRAM_TARGET_NV = $8646; + GL_PROGRAM_RESIDENT_NV = $8647; + GL_TRACK_MATRIX_NV = $8648; + GL_TRACK_MATRIX_TRANSFORM_NV = $8649; + GL_VERTEX_PROGRAM_BINDING_NV = $864A; + GL_PROGRAM_ERROR_POSITION_NV = $864B; + GL_VERTEX_ATTRIB_ARRAY0_NV = $8650; + GL_VERTEX_ATTRIB_ARRAY1_NV = $8651; + GL_VERTEX_ATTRIB_ARRAY2_NV = $8652; + GL_VERTEX_ATTRIB_ARRAY3_NV = $8653; + GL_VERTEX_ATTRIB_ARRAY4_NV = $8654; + GL_VERTEX_ATTRIB_ARRAY5_NV = $8655; + GL_VERTEX_ATTRIB_ARRAY6_NV = $8656; + GL_VERTEX_ATTRIB_ARRAY7_NV = $8657; + GL_VERTEX_ATTRIB_ARRAY8_NV = $8658; + GL_VERTEX_ATTRIB_ARRAY9_NV = $8659; + GL_VERTEX_ATTRIB_ARRAY10_NV = $865A; + GL_VERTEX_ATTRIB_ARRAY11_NV = $865B; + GL_VERTEX_ATTRIB_ARRAY12_NV = $865C; + GL_VERTEX_ATTRIB_ARRAY13_NV = $865D; + GL_VERTEX_ATTRIB_ARRAY14_NV = $865E; + GL_VERTEX_ATTRIB_ARRAY15_NV = $865F; + GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660; + GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661; + GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662; + GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663; + GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664; + GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665; + GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666; + GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667; + GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668; + GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669; + GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A; + GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B; + GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C; + GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D; + GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E; + GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F; + GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670; + GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671; + GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672; + GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673; + GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674; + GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675; + GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676; + GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677; + GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678; + GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679; + GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A; + GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B; + GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C; + GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D; + GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E; + GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F; + + // GL_NV_fragment_program2 and GL_NV_vertex_program2_option + GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4; + GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5; + + // GL_NV_fragment_program2 + GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6; + GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7; + GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8; + + // GL_NV_vertex_program3 + MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; + + // GL_NV_depth_buffer_float + GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD; + GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF; + + // GL_NV_framebuffer_multisample_coverage + GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB; + GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10; + + // GL_NV_geometry_program4 + GL_GEOMETRY_PROGRAM_NV = $8C26; + GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27; + GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28; + + // GL_NV_gpu_program4 + GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906; + GL_PROGRAM_RESULT_COMPONENTS_NV = $8907; + GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908; + GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909; + GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5; + GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6; + + // GL_NV_parameter_buffer_object + GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0; + GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1; + GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2; + GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3; + GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4; + + // GL_NV_transform_feedback + GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E; + GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84; + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85; + GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86; + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F; + GL_INTERLEAVED_ATTRIBS_NV = $8C8C; + GL_SEPARATE_ATTRIBS_NV = $8C8D; + GL_PRIMITIVES_GENERATED_NV = $8C87; + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88; + GL_RASTERIZER_DISCARD_NV = $8C89; + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B; + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80; + GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E; + GL_ACTIVE_VARYINGS_NV = $8C81; + GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82; + GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83; + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F; + GL_BACK_PRIMARY_COLOR_NV = $8C77; + GL_BACK_SECONDARY_COLOR_NV = $8C78; + GL_TEXTURE_COORD_NV = $8C79; + GL_CLIP_DISTANCE_NV = $8C7A; + GL_VERTEX_ID_NV = $8C7B; + GL_PRIMITIVE_ID_NV = $8C7C; + GL_GENERIC_ATTRIB_NV = $8C7D; + GL_LAYER_NV = $8DAA; + GL_NEXT_BUFFER_NV = -2; + GL_SKIP_COMPONENTS4_NV = -3; + GL_SKIP_COMPONENTS3_NV = -4; + GL_SKIP_COMPONENTS2_NV = -5; + GL_SKIP_COMPONENTS1_NV = -6; + + // 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_present_video + GL_FRAME_NV = $8E26; + GL_FIELDS_NV = $8E27; + GL_CURRENT_TIME_NV = $8E28; + GL_NUM_FILL_STREAMS_NV = $8E29; + GL_PRESENT_TIME_NV = $8E2A; + GL_PRESENT_DURATION_NV = $8E2B; + + // GL_NV_explicit_multisample + GL_SAMPLE_POSITION_NV = $8E50; + GL_SAMPLE_MASK_NV = $8E51; + GL_SAMPLE_MASK_VALUE_NV = $8E52; + GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53; + GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54; + GL_TEXTURE_RENDERBUFFER_NV = $8E55; + GL_SAMPLER_RENDERBUFFER_NV = $8E56; + GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57; + GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58; + GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59; + + // GL_NV_transform_feedback2 + GL_TRANSFORM_FEEDBACK_NV = $8E22; + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23; + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24; + GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25; + + // GL_NV_video_capture + GL_VIDEO_BUFFER_NV = $9020; + GL_VIDEO_BUFFER_BINDING_NV = $9021; + GL_FIELD_UPPER_NV = $9022; + GL_FIELD_LOWER_NV = $9023; + GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024; + GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025; + GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026; + GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027; + GL_VIDEO_BUFFER_PITCH_NV = $9028; + GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029; + GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A; + GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B; + GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C; + GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D; + GL_PARTIAL_SUCCESS_NV = $902E; + GL_SUCCESS_NV = $902F; + GL_FAILURE_NV = $9030; + GL_YCBYCR8_422_NV = $9031; + GL_YCBAYCR8A_4224_NV = $9032; + GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033; + GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034; + GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035; + GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036; + GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037; + GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038; + GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039; + GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A; + GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B; + GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C; + + // GL_NV_shader_buffer_load + GL_BUFFER_GPU_ADDRESS_NV = $8F1D; + GL_GPU_ADDRESS_NV = $8F34; + GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35; + + // GL_NV_vertex_buffer_unified_memory + GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E; + GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F; + GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20; + GL_VERTEX_ARRAY_ADDRESS_NV = $8F21; + GL_NORMAL_ARRAY_ADDRESS_NV = $8F22; + GL_COLOR_ARRAY_ADDRESS_NV = $8F23; + GL_INDEX_ARRAY_ADDRESS_NV = $8F24; + GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25; + GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26; + GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27; + GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28; + GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29; + GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A; + GL_VERTEX_ARRAY_LENGTH_NV = $8F2B; + GL_NORMAL_ARRAY_LENGTH_NV = $8F2C; + GL_COLOR_ARRAY_LENGTH_NV = $8F2D; + GL_INDEX_ARRAY_LENGTH_NV = $8F2E; + GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F; + GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30; + GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31; + GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32; + GL_ELEMENT_ARRAY_LENGTH_NV = $8F33; + GL_DRAW_INDIRECT_UNIFIED_NV = $8F40; + GL_DRAW_INDIRECT_ADDRESS_NV = $8F41; + GL_DRAW_INDIRECT_LENGTH_NV = $8F42; + + // GL_NV_gpu_program5 + GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A; + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B; + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C; + GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D; + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E; + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F; + GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44; + GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45; + + // 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; + { reuse GL_PATCHES } + + // GL_NV_shader_buffer_store + GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010; + { reuse GL_READ_WRITE } + { reuse GL_WRITE_ONLY } + + // GL_NV_tessellation_program5 + GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8; + GL_TESS_CONTROL_PROGRAM_NV = $891E; + GL_TESS_EVALUATION_PROGRAM_NV = $891F; + GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74; + GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75; + + // GL_NV_vertex_attrib_integer_64bit + { reuse GL_INT64_NV } + { reuse GL_UNSIGNED_INT64_NV } + + // GL_NV_multisample_coverage + GL_COVERAGE_SAMPLES_NV = $80A9; + GL_COLOR_SAMPLES_NV = $8E20; + + // GL_NV_vdpau_interop + GL_SURFACE_STATE_NV = $86EB; + GL_SURFACE_REGISTERED_NV = $86FD; + GL_SURFACE_MAPPED_NV = $8700; + GL_WRITE_DISCARD_NV = $88BE; + + // GL_OML_interlace + GL_INTERLACE_OML = $8980; + GL_INTERLACE_READ_OML = $8981; + + // GL_OML_resample + GL_PACK_RESAMPLE_OML = $8984; + GL_UNPACK_RESAMPLE_OML = $8985; + GL_RESAMPLE_REPLICATE_OML = $8986; + GL_RESAMPLE_ZERO_FILL_OML = $8987; + GL_RESAMPLE_AVERAGE_OML = $8988; + GL_RESAMPLE_DECIMATE_OML = $8989; + + // GL_OML_subsample + GL_FORMAT_SUBSAMPLE_24_24_OML = $8982; + GL_FORMAT_SUBSAMPLE_244_244_OML = $8983; + + // GL_PGI_misc_hints + GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8; + GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD; + GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE; + GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202; + GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203; + GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204; + GL_ALWAYS_FAST_HINT_PGI = $1A20C; + GL_ALWAYS_SOFT_HINT_PGI = $1A20D; + GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E; + GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F; + GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210; + GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211; + GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216; + GL_STRICT_LIGHTING_HINT_PGI = $1A217; + GL_STRICT_SCISSOR_HINT_PGI = $1A218; + GL_FULL_STIPPLE_HINT_PGI = $1A219; + GL_CLIP_NEAR_HINT_PGI = $1A220; + GL_CLIP_FAR_HINT_PGI = $1A221; + GL_WIDE_LINE_HINT_PGI = $1A222; + GL_BACK_NORMALS_HINT_PGI = $1A223; + + // GL_PGI_vertex_hints + GL_VERTEX_DATA_HINT_PGI = $1A22A; + GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B; + GL_MATERIAL_SIDE_HINT_PGI = $1A22C; + GL_MAX_VERTEX_HINT_PGI = $1A22D; + GL_COLOR3_BIT_PGI = $00010000; + GL_COLOR4_BIT_PGI = $00020000; + GL_EDGEFLAG_BIT_PGI = $00040000; + GL_INDEX_BIT_PGI = $00080000; + GL_MAT_AMBIENT_BIT_PGI = $00100000; + GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000; + GL_MAT_DIFFUSE_BIT_PGI = $00400000; + GL_MAT_EMISSION_BIT_PGI = $00800000; + GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000; + GL_MAT_SHININESS_BIT_PGI = $02000000; + GL_MAT_SPECULAR_BIT_PGI = $04000000; + GL_NORMAL_BIT_PGI = $08000000; + GL_TEXCOORD1_BIT_PGI = $10000000; + GL_TEXCOORD2_BIT_PGI = $20000000; + GL_TEXCOORD3_BIT_PGI = $40000000; + GL_TEXCOORD4_BIT_PGI = $80000000; + GL_VERTEX23_BIT_PGI = $00000004; + GL_VERTEX4_BIT_PGI = $00000008; + + // GL_REND_screen_coordinates + GL_SCREEN_COORDINATES_REND = $8490; + GL_INVERTED_SCREEN_W_REND = $8491; + + // GL_S3_s3tc + GL_RGB_S3TC = $83A0; + GL_RGB4_S3TC = $83A1; + GL_RGBA_S3TC = $83A2; + GL_RGBA4_S3TC = $83A3; + + // GL_SGIS_detail_texture + GL_DETAIL_TEXTURE_2D_SGIS = $8095; + GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096; + GL_LINEAR_DETAIL_SGIS = $8097; + GL_LINEAR_DETAIL_ALPHA_SGIS = $8098; + GL_LINEAR_DETAIL_COLOR_SGIS = $8099; + GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A; + GL_DETAIL_TEXTURE_MODE_SGIS = $809B; + GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C; + + // GL_SGIS_fog_function + GL_FOG_FUNC_SGIS = $812A; + GL_FOG_FUNC_POINTS_SGIS = $812B; + GL_MAX_FOG_FUNC_POINTS_SGIS = $812C; + + // GL_SGIS_generate_mipmap + GL_GENERATE_MIPMAP_SGIS = $8191; + GL_GENERATE_MIPMAP_HINT_SGIS = $8192; + + // GL_SGIS_multisample + GL_MULTISAMPLE_SGIS = $809D; + GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E; + GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F; + GL_SAMPLE_MASK_SGIS = $80A0; + GL_1PASS_SGIS = $80A1; + GL_2PASS_0_SGIS = $80A2; + GL_2PASS_1_SGIS = $80A3; + GL_4PASS_0_SGIS = $80A4; + GL_4PASS_1_SGIS = $80A5; + GL_4PASS_2_SGIS = $80A6; + GL_4PASS_3_SGIS = $80A7; + GL_SAMPLE_BUFFERS_SGIS = $80A8; + GL_SAMPLES_SGIS = $80A9; + GL_SAMPLE_MASK_VALUE_SGIS = $80AA; + GL_SAMPLE_MASK_INVERT_SGIS = $80AB; + GL_SAMPLE_PATTERN_SGIS = $80AC; + + // GL_SGIS_pixel_texture + GL_PIXEL_TEXTURE_SGIS = $8353; + GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354; + GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355; + GL_PIXEL_GROUP_COLOR_SGIS = $8356; + + // GL_SGIS_point_line_texgen + GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0; + GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1; + GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2; + GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3; + GL_EYE_POINT_SGIS = $81F4; + GL_OBJECT_POINT_SGIS = $81F5; + GL_EYE_LINE_SGIS = $81F6; + GL_OBJECT_LINE_SGIS = $81F7; + + // GL_SGIS_point_parameters + GL_POINT_SIZE_MIN_SGIS = $8126; + GL_POINT_SIZE_MAX_SGIS = $8127; + GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128; + GL_DISTANCE_ATTENUATION_SGIS = $8129; + + // GL_SGIS_sharpen_texture + GL_LINEAR_SHARPEN_SGIS = $80AD; + GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE; + GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF; + GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0; + + // GL_SGIS_texture4D + GL_PACK_SKIP_VOLUMES_SGIS = $8130; + GL_PACK_IMAGE_DEPTH_SGIS = $8131; + GL_UNPACK_SKIP_VOLUMES_SGIS = $8132; + GL_UNPACK_IMAGE_DEPTH_SGIS = $8133; + GL_TEXTURE_4D_SGIS = $8134; + GL_PROXY_TEXTURE_4D_SGIS = $8135; + GL_TEXTURE_4DSIZE_SGIS = $8136; + GL_TEXTURE_WRAP_Q_SGIS = $8137; + GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138; + GL_TEXTURE_4D_BINDING_SGIS = $814F; + + // GL_SGIS_texture_color_mask + GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF; + + // GL_SGIS_texture_edge_clamp + GL_CLAMP_TO_EDGE_SGIS = $812F; + + // GL_SGIS_texture_filter4 + GL_FILTER4_SGIS = $8146; + GL_TEXTURE_FILTER4_SIZE_SGIS = $8147; + + // GL_SGIS_texture_lod + GL_TEXTURE_MIN_LOD_SGIS = $813A; + GL_TEXTURE_MAX_LOD_SGIS = $813B; + GL_TEXTURE_BASE_LEVEL_SGIS = $813C; + GL_TEXTURE_MAX_LEVEL_SGIS = $813D; + + // GL_SGIS_texture_select + GL_DUAL_ALPHA4_SGIS = $8110; + GL_DUAL_ALPHA8_SGIS = $8111; + GL_DUAL_ALPHA12_SGIS = $8112; + GL_DUAL_ALPHA16_SGIS = $8113; + GL_DUAL_LUMINANCE4_SGIS = $8114; + GL_DUAL_LUMINANCE8_SGIS = $8115; + GL_DUAL_LUMINANCE12_SGIS = $8116; + GL_DUAL_LUMINANCE16_SGIS = $8117; + GL_DUAL_INTENSITY4_SGIS = $8118; + GL_DUAL_INTENSITY8_SGIS = $8119; + GL_DUAL_INTENSITY12_SGIS = $811A; + GL_DUAL_INTENSITY16_SGIS = $811B; + GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C; + GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D; + GL_QUAD_ALPHA4_SGIS = $811E; + GL_QUAD_ALPHA8_SGIS = $811F; + GL_QUAD_LUMINANCE4_SGIS = $8120; + GL_QUAD_LUMINANCE8_SGIS = $8121; + GL_QUAD_INTENSITY4_SGIS = $8122; + GL_QUAD_INTENSITY8_SGIS = $8123; + GL_DUAL_TEXTURE_SELECT_SGIS = $8124; + GL_QUAD_TEXTURE_SELECT_SGIS = $8125; + + // GL_SGIX_async + GL_ASYNC_MARKER_SGIX = $8329; + + // GL_SGIX_async_histogram + GL_ASYNC_HISTOGRAM_SGIX = $832C; + GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D; + + // GL_SGIX_async_pixel + GL_ASYNC_TEX_IMAGE_SGIX = $835C; + GL_ASYNC_DRAW_PIXELS_SGIX = $835D; + GL_ASYNC_READ_PIXELS_SGIX = $835E; + GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F; + GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360; + GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361; + + // GL_SGIX_blend_alpha_minmax + GL_ALPHA_MIN_SGIX = $8320; + GL_ALPHA_MAX_SGIX = $8321; + + // GL_SGIX_calligraphic_fragment + GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183; + + // GL_SGIX_clipmap + GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170; + GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171; + GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172; + GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173; + GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174; + GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175; + GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176; + GL_MAX_CLIPMAP_DEPTH_SGIX = $8177; + GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178; + GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D; + GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E; + GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F; + + // GL_SGIX_convolution_accuracy + GL_CONVOLUTION_HINT_SGIX = $8316; + + // GL_SGIX_depth_texture + GL_DEPTH_COMPONENT16_SGIX = $81A5; + GL_DEPTH_COMPONENT24_SGIX = $81A6; + GL_DEPTH_COMPONENT32_SGIX = $81A7; + + // GL_SGIX_fog_offset + GL_FOG_OFFSET_SGIX = $8198; + GL_FOG_OFFSET_VALUE_SGIX = $8199; + + // GL_SGIX_fog_scale + GL_FOG_SCALE_SGIX = $81FC; + GL_FOG_SCALE_VALUE_SGIX = $81FD; + + // GL_SGIX_fragment_lighting + GL_FRAGMENT_LIGHTING_SGIX = $8400; + GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401; + GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402; + GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403; + GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404; + GL_MAX_ACTIVE_LIGHTS_SGIX = $8405; + GL_CURRENT_RASTER_NORMAL_SGIX = $8406; + GL_LIGHT_ENV_MODE_SGIX = $8407; + GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408; + GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409; + GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A; + GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B; + GL_FRAGMENT_LIGHT0_SGIX = $840C; + GL_FRAGMENT_LIGHT1_SGIX = $840D; + GL_FRAGMENT_LIGHT2_SGIX = $840E; + GL_FRAGMENT_LIGHT3_SGIX = $840F; + GL_FRAGMENT_LIGHT4_SGIX = $8410; + GL_FRAGMENT_LIGHT5_SGIX = $8411; + GL_FRAGMENT_LIGHT6_SGIX = $8412; + GL_FRAGMENT_LIGHT7_SGIX = $8413; + + // GL_SGIX_framezoom + GL_FRAMEZOOM_SGIX = $818B; + GL_FRAMEZOOM_FACTOR_SGIX = $818C; + GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D; + + // GL_SGIX_impact_pixel_texture + GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184; + GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185; + GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186; + GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187; + GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188; + GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189; + GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A; + + // GL_SGIX_instruments + GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180; + GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181; + + // GL_SGIX_interlace + GL_INTERLACE_SGIX = $8094; + + // GL_SGIX_ir_instrument1 + GL_IR_INSTRUMENT1_SGIX = $817F; + + // GL_SGIX_list_priority + GL_LIST_PRIORITY_SGIX = $8182; + + // GL_SGIX_pixel_texture + GL_PIXEL_TEX_GEN_SGIX = $8139; + GL_PIXEL_TEX_GEN_MODE_SGIX = $832B; + + // GL_SGIX_pixel_tiles + GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E; + GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F; + GL_PIXEL_TILE_WIDTH_SGIX = $8140; + GL_PIXEL_TILE_HEIGHT_SGIX = $8141; + GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142; + GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143; + GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144; + GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145; + + // GL_SGIX_polynomial_ffd + GL_GEOMETRY_DEFORMATION_SGIX = $8194; + GL_TEXTURE_DEFORMATION_SGIX = $8195; + GL_DEFORMATIONS_MASK_SGIX = $8196; + GL_MAX_DEFORMATION_ORDER_SGIX = $8197; + + // GL_SGIX_reference_plane + GL_REFERENCE_PLANE_SGIX = $817D; + GL_REFERENCE_PLANE_EQUATION_SGIX = $817E; + + // GL_SGIX_resample + GL_PACK_RESAMPLE_SGIX = $842C; + GL_UNPACK_RESAMPLE_SGIX = $842D; + GL_RESAMPLE_REPLICATE_SGIX = $842E; + GL_RESAMPLE_ZERO_FILL_SGIX = $842F; + GL_RESAMPLE_DECIMATE_SGIX = $8430; + + // GL_SGIX_scalebias_hint + GL_SCALEBIAS_HINT_SGIX = $8322; + + // GL_SGIX_shadow + GL_TEXTURE_COMPARE_SGIX = $819A; + GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B; + GL_TEXTURE_LEQUAL_R_SGIX = $819C; + GL_TEXTURE_GEQUAL_R_SGIX = $819D; + + // GL_SGIX_shadow_ambient + GL_SHADOW_AMBIENT_SGIX = $80BF; + + // GL_SGIX_sprite + GL_SPRITE_SGIX = $8148; + GL_SPRITE_MODE_SGIX = $8149; + GL_SPRITE_AXIS_SGIX = $814A; + GL_SPRITE_TRANSLATION_SGIX = $814B; + GL_SPRITE_AXIAL_SGIX = $814C; + GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D; + GL_SPRITE_EYE_ALIGNED_SGIX = $814E; + + // GL_SGIX_subsample + GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0; + GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1; + GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2; + GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3; + GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4; + + // GL_SGIX_texture_add_env + GL_TEXTURE_ENV_BIAS_SGIX = $80BE; + + // GL_SGIX_texture_coordinate_clamp + GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369; + GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A; + GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B; + + // GL_SGIX_texture_lod_bias + GL_TEXTURE_LOD_BIAS_S_SGIX = $818E; + GL_TEXTURE_LOD_BIAS_T_SGIX = $818F; + GL_TEXTURE_LOD_BIAS_R_SGIX = $8190; + + // GL_SGIX_texture_multi_buffer + GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E; + + // GL_SGIX_texture_scale_bias + GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179; + GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A; + GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B; + GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C; + + // GL_SGIX_vertex_preclip + GL_VERTEX_PRECLIP_SGIX = $83EE; + GL_VERTEX_PRECLIP_HINT_SGIX = $83EF; + + // GL_SGIX_ycrcb + GL_YCRCB_422_SGIX = $81BB; + GL_YCRCB_444_SGIX = $81BC; + + // GL_SGIX_ycrcba + GL_YCRCB_SGIX = $8318; + GL_YCRCBA_SGIX = $8319; + + // GL_SGI_color_matrix + GL_COLOR_MATRIX_SGI = $80B1; + GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2; + GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3; + GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4; + GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5; + GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6; + GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7; + GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8; + GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9; + GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA; + GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB; + + // GL_SGI_color_table + GL_COLOR_TABLE_SGI = $80D0; + GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1; + GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2; + GL_PROXY_COLOR_TABLE_SGI = $80D3; + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4; + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5; + GL_COLOR_TABLE_SCALE_SGI = $80D6; + GL_COLOR_TABLE_BIAS_SGI = $80D7; + GL_COLOR_TABLE_FORMAT_SGI = $80D8; + GL_COLOR_TABLE_WIDTH_SGI = $80D9; + GL_COLOR_TABLE_RED_SIZE_SGI = $80DA; + GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB; + GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC; + GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD; + GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE; + GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF; + + // GL_SGI_depth_pass_instrument + GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310; + GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311; + GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312; + + // GL_SGI_texture_color_table + GL_TEXTURE_COLOR_TABLE_SGI = $80BC; + GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD; + + // GL_SUNX_constant_data + GL_UNPACK_CONSTANT_DATA_SUNX = $81D5; + GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6; + + // GL_SUN_convolution_border_modes + GL_WRAP_BORDER_SUN = $81D4; + + // GL_SUN_global_alpha + GL_GLOBAL_ALPHA_SUN = $81D9; + GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA; + + // GL_SUN_mesh_array + GL_QUAD_MESH_SUN = $8614; + GL_TRIANGLE_MESH_SUN = $8615; + + // GL_SUN_slice_accum + GL_SLICE_ACCUM_SUN = $85CC; + + // GL_SUN_triangle_list + GL_RESTART_SUN = $0001; + GL_REPLACE_MIDDLE_SUN = $0002; + GL_REPLACE_OLDEST_SUN = $0003; + GL_TRIANGLE_LIST_SUN = $81D7; + GL_REPLACEMENT_CODE_SUN = $81D8; + GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0; + GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1; + GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2; + GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3; + GL_R1UI_V3F_SUN = $85C4; + GL_R1UI_C4UB_V3F_SUN = $85C5; + GL_R1UI_C3F_V3F_SUN = $85C6; + GL_R1UI_N3F_V3F_SUN = $85C7; + GL_R1UI_C4F_N3F_V3F_SUN = $85C8; + GL_R1UI_T2F_V3F_SUN = $85C9; + GL_R1UI_T2F_N3F_V3F_SUN = $85CA; + GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB; + + // GL_WIN_phong_shading + GL_PHONG_WIN = $80EA; + GL_PHONG_HINT_WIN = $80EB; + + // GL_WIN_specular_fog + GL_FOG_SPECULAR_TEXTURE_WIN = $80EC; + + // GL_ARB_vertex_shader + GL_VERTEX_SHADER_ARB = $8B31; + GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A; + GL_MAX_VARYING_FLOATS_ARB = $8B4B; + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D; + GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89; + GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A; + + // GL_ARB_fragment_shader + GL_FRAGMENT_SHADER_ARB = $8B30; + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4 + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4 + + // GL_ARB_occlusion_query + GL_SAMPLES_PASSED_ARB = $8914; + GL_QUERY_COUNTER_BITS_ARB = $8864; + GL_CURRENT_QUERY_ARB = $8865; + GL_QUERY_RESULT_ARB = $8866; + GL_QUERY_RESULT_AVAILABLE_ARB = $8867; + + // GL_ARB_point_sprite + GL_POINT_SPRITE_ARB = $8861; + GL_COORD_REPLACE_ARB = $8862; + + // GL_ARB_shading_language_100 + GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4 + + // GL_ARB_shader_objects + GL_PROGRAM_OBJECT_ARB = $8B40; + + GL_OBJECT_TYPE_ARB = $8B4E; + GL_OBJECT_SUBTYPE_ARB = $8B4F; + GL_OBJECT_DELETE_STATUS_ARB = $8B80; + GL_OBJECT_COMPILE_STATUS_ARB = $8B81; + GL_OBJECT_LINK_STATUS_ARB = $8B82; + GL_OBJECT_VALIDATE_STATUS_ARB = $8B83; + GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84; + GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85; + GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86; + GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87; + GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88; + + GL_SHADER_OBJECT_ARB = $8B48; + + GL_FLOAT_VEC2_ARB = $8B50; + GL_FLOAT_VEC3_ARB = $8B51; + GL_FLOAT_VEC4_ARB = $8B52; + GL_INT_VEC2_ARB = $8B53; + GL_INT_VEC3_ARB = $8B54; + GL_INT_VEC4_ARB = $8B55; + GL_BOOL_ARB = $8B56; + GL_BOOL_VEC2_ARB = $8B57; + GL_BOOL_VEC3_ARB = $8B58; + GL_BOOL_VEC4_ARB = $8B59; + GL_FLOAT_MAT2_ARB = $8B5A; + GL_FLOAT_MAT3_ARB = $8B5B; + GL_FLOAT_MAT4_ARB = $8B5C; + GL_SAMPLER_1D_ARB = $8B5D; + GL_SAMPLER_2D_ARB = $8B5E; + GL_SAMPLER_3D_ARB = $8B5F; + GL_SAMPLER_CUBE_ARB = $8B60; + GL_SAMPLER_1D_SHADOW_ARB = $8B61; + GL_SAMPLER_2D_SHADOW_ARB = $8B62; + GL_SAMPLER_2D_RECT_ARB = $8B63; + GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64; + + // WGL_3DFX_multisample + WGL_SAMPLE_BUFFERS_3DFX = $2060; + WGL_SAMPLES_3DFX = $2061; + + // WGL_ARB_buffer_region + WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001; + WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002; + WGL_DEPTH_BUFFER_BIT_ARB = $00000004; + WGL_STENCIL_BUFFER_BIT_ARB = $00000008; + + // WGL_ARB_make_current_read + ERROR_INVALID_PIXEL_TYPE_ARB = $2043; + ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054; + + // WGL_ARB_multisample + WGL_SAMPLE_BUFFERS_ARB = $2041; + WGL_SAMPLES_ARB = $2042; + + // WGL_ARB_pbuffer + WGL_DRAW_TO_PBUFFER_ARB = $202D; + WGL_MAX_PBUFFER_PIXELS_ARB = $202E; + WGL_MAX_PBUFFER_WIDTH_ARB = $202F; + WGL_MAX_PBUFFER_HEIGHT_ARB = $2030; + WGL_PBUFFER_LARGEST_ARB = $2033; + WGL_PBUFFER_WIDTH_ARB = $2034; + WGL_PBUFFER_HEIGHT_ARB = $2035; + WGL_PBUFFER_LOST_ARB = $2036; + + // WGL_ARB_pixel_format + WGL_NUMBER_PIXEL_FORMATS_ARB = $2000; + WGL_DRAW_TO_WINDOW_ARB = $2001; + WGL_DRAW_TO_BITMAP_ARB = $2002; + WGL_ACCELERATION_ARB = $2003; + WGL_NEED_PALETTE_ARB = $2004; + WGL_NEED_SYSTEM_PALETTE_ARB = $2005; + WGL_SWAP_LAYER_BUFFERS_ARB = $2006; + WGL_SWAP_METHOD_ARB = $2007; + WGL_NUMBER_OVERLAYS_ARB = $2008; + WGL_NUMBER_UNDERLAYS_ARB = $2009; + WGL_TRANSPARENT_ARB = $200A; + WGL_TRANSPARENT_RED_VALUE_ARB = $2037; + WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038; + WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039; + WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A; + WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B; + WGL_SHARE_DEPTH_ARB = $200C; + WGL_SHARE_STENCIL_ARB = $200D; + WGL_SHARE_ACCUM_ARB = $200E; + WGL_SUPPORT_GDI_ARB = $200F; + WGL_SUPPORT_OPENGL_ARB = $2010; + WGL_DOUBLE_BUFFER_ARB = $2011; + WGL_STEREO_ARB = $2012; + WGL_PIXEL_TYPE_ARB = $2013; + WGL_COLOR_BITS_ARB = $2014; + WGL_RED_BITS_ARB = $2015; + WGL_RED_SHIFT_ARB = $2016; + WGL_GREEN_BITS_ARB = $2017; + WGL_GREEN_SHIFT_ARB = $2018; + WGL_BLUE_BITS_ARB = $2019; + WGL_BLUE_SHIFT_ARB = $201A; + WGL_ALPHA_BITS_ARB = $201B; + WGL_ALPHA_SHIFT_ARB = $201C; + WGL_ACCUM_BITS_ARB = $201D; + WGL_ACCUM_RED_BITS_ARB = $201E; + WGL_ACCUM_GREEN_BITS_ARB = $201F; + WGL_ACCUM_BLUE_BITS_ARB = $2020; + WGL_ACCUM_ALPHA_BITS_ARB = $2021; + WGL_DEPTH_BITS_ARB = $2022; + WGL_STENCIL_BITS_ARB = $2023; + WGL_AUX_BUFFERS_ARB = $2024; + WGL_NO_ACCELERATION_ARB = $2025; + WGL_GENERIC_ACCELERATION_ARB = $2026; + WGL_FULL_ACCELERATION_ARB = $2027; + WGL_SWAP_EXCHANGE_ARB = $2028; + WGL_SWAP_COPY_ARB = $2029; + WGL_SWAP_UNDEFINED_ARB = $202A; + WGL_TYPE_RGBA_ARB = $202B; + WGL_TYPE_COLORINDEX_ARB = $202C; + + // WGL_ARB_pixel_format_float + WGL_RGBA_FLOAT_MODE_ARB = $8820; + WGL_CLAMP_VERTEX_COLOR_ARB = $891A; + WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B; + WGL_CLAMP_READ_COLOR_ARB = $891C; + WGL_FIXED_ONLY_ARB = $891D; + + // WGL_ARB_render_texture + WGL_BIND_TO_TEXTURE_RGB_ARB = $2070; + WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071; + WGL_TEXTURE_FORMAT_ARB = $2072; + WGL_TEXTURE_TARGET_ARB = $2073; + WGL_MIPMAP_TEXTURE_ARB = $2074; + WGL_TEXTURE_RGB_ARB = $2075; + WGL_TEXTURE_RGBA_ARB = $2076; + WGL_NO_TEXTURE_ARB = $2077; + WGL_TEXTURE_CUBE_MAP_ARB = $2078; + WGL_TEXTURE_1D_ARB = $2079; + WGL_TEXTURE_2D_ARB = $207A; + WGL_MIPMAP_LEVEL_ARB = $207B; + WGL_CUBE_MAP_FACE_ARB = $207C; + WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E; + WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080; + WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081; + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082; + WGL_FRONT_LEFT_ARB = $2083; + WGL_FRONT_RIGHT_ARB = $2084; + WGL_BACK_LEFT_ARB = $2085; + WGL_BACK_RIGHT_ARB = $2086; + WGL_AUX0_ARB = $2087; + WGL_AUX1_ARB = $2088; + WGL_AUX2_ARB = $2089; + WGL_AUX3_ARB = $208A; + WGL_AUX4_ARB = $208B; + WGL_AUX5_ARB = $208C; + WGL_AUX6_ARB = $208D; + WGL_AUX7_ARB = $208E; + WGL_AUX8_ARB = $208F; + WGL_AUX9_ARB = $2090; + + // WGL_ARB_create_context + WGL_CONTEXT_DEBUG_BIT_ARB = $00000001; + WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; + WGL_CONTEXT_MAJOR_VERSION_ARB = $2091; + WGL_CONTEXT_MINOR_VERSION_ARB = $2092; + WGL_CONTEXT_LAYER_PLANE_ARB = $2093; + WGL_CONTEXT_FLAGS_ARB = $2094; + ERROR_INVALID_VERSION_ARB = $2095; + + // WGL_ARB_create_context_profile + WGL_CONTEXT_PROFILE_MASK_ARB = $9126; + WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; + WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; + ERROR_INVALID_PROFILE_ARB = $2096; + + // WGL_ARB_framebuffer_sRGB + WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20A9; + + // WGL_ARB_create_context_robustness + WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; + WGL_LOSE_CONTEXT_ON_RESET_ARB = $8252; + WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + WGL_NO_RESET_NOTIFICATION_ARB = $8261; + + // WGL_ATI_pixel_format_float + WGL_TYPE_RGBA_FLOAT_ATI = $21A0; + GL_TYPE_RGBA_FLOAT_ATI = $8820; + GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835; + + // WGL_AMD_gpu_association + WGL_GPU_VENDOR_AMD = $1F00; + WGL_GPU_RENDERER_STRING_AMD = $1F01; + WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02; + WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2; + WGL_GPU_RAM_AMD = $21A3; + WGL_GPU_CLOCK_AMD = $21A4; + WGL_GPU_NUM_PIPES_AMD = $21A5; + WGL_GPU_NUM_SIMD_AMD = $21A6; + WGL_GPU_NUM_RB_AMD = $21A7; + WGL_GPU_NUM_SPI_AMD = $21A8; + + // WGL_EXT_depth_float + WGL_DEPTH_FLOAT_EXT = $2040; + + // WGL_EXT_make_current_read + ERROR_INVALID_PIXEL_TYPE_EXT = $2043; + + // WGL_EXT_multisample + WGL_SAMPLE_BUFFERS_EXT = $2041; + WGL_SAMPLES_EXT = $2042; + + // WGL_EXT_pbuffer + WGL_DRAW_TO_PBUFFER_EXT = $202D; + WGL_MAX_PBUFFER_PIXELS_EXT = $202E; + WGL_MAX_PBUFFER_WIDTH_EXT = $202F; + WGL_MAX_PBUFFER_HEIGHT_EXT = $2030; + WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031; + WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032; + WGL_PBUFFER_LARGEST_EXT = $2033; + WGL_PBUFFER_WIDTH_EXT = $2034; + WGL_PBUFFER_HEIGHT_EXT = $2035; + + // WGL_EXT_pixel_format + WGL_NUMBER_PIXEL_FORMATS_EXT = $2000; + WGL_DRAW_TO_WINDOW_EXT = $2001; + WGL_DRAW_TO_BITMAP_EXT = $2002; + WGL_ACCELERATION_EXT = $2003; + WGL_NEED_PALETTE_EXT = $2004; + WGL_NEED_SYSTEM_PALETTE_EXT = $2005; + WGL_SWAP_LAYER_BUFFERS_EXT = $2006; + WGL_SWAP_METHOD_EXT = $2007; + WGL_NUMBER_OVERLAYS_EXT = $2008; + WGL_NUMBER_UNDERLAYS_EXT = $2009; + WGL_TRANSPARENT_EXT = $200A; + WGL_TRANSPARENT_VALUE_EXT = $200B; + WGL_SHARE_DEPTH_EXT = $200C; + WGL_SHARE_STENCIL_EXT = $200D; + WGL_SHARE_ACCUM_EXT = $200E; + WGL_SUPPORT_GDI_EXT = $200F; + WGL_SUPPORT_OPENGL_EXT = $2010; + WGL_DOUBLE_BUFFER_EXT = $2011; + WGL_STEREO_EXT = $2012; + WGL_PIXEL_TYPE_EXT = $2013; + WGL_COLOR_BITS_EXT = $2014; + WGL_RED_BITS_EXT = $2015; + WGL_RED_SHIFT_EXT = $2016; + WGL_GREEN_BITS_EXT = $2017; + WGL_GREEN_SHIFT_EXT = $2018; + WGL_BLUE_BITS_EXT = $2019; + WGL_BLUE_SHIFT_EXT = $201A; + WGL_ALPHA_BITS_EXT = $201B; + WGL_ALPHA_SHIFT_EXT = $201C; + WGL_ACCUM_BITS_EXT = $201D; + WGL_ACCUM_RED_BITS_EXT = $201E; + WGL_ACCUM_GREEN_BITS_EXT = $201F; + WGL_ACCUM_BLUE_BITS_EXT = $2020; + WGL_ACCUM_ALPHA_BITS_EXT = $2021; + WGL_DEPTH_BITS_EXT = $2022; + WGL_STENCIL_BITS_EXT = $2023; + WGL_AUX_BUFFERS_EXT = $2024; + WGL_NO_ACCELERATION_EXT = $2025; + WGL_GENERIC_ACCELERATION_EXT = $2026; + WGL_FULL_ACCELERATION_EXT = $2027; + WGL_SWAP_EXCHANGE_EXT = $2028; + WGL_SWAP_COPY_EXT = $2029; + WGL_SWAP_UNDEFINED_EXT = $202A; + WGL_TYPE_RGBA_EXT = $202B; + WGL_TYPE_COLORINDEX_EXT = $202C; + + // WGL_I3D_digital_video_control + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050; + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051; + WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052; + WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053; + + // WGL_I3D_gamma + WGL_GAMMA_TABLE_SIZE_I3D = $204E; + WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F; + + // WGL_I3D_genlock + WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044; + WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045; + WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046; + WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047; + WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048; + WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049; + WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A; + WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B; + WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C; + + // WGL_I3D_image_buffer + WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001; + WGL_IMAGE_BUFFER_LOCK_I3D = $00000002; + + // WGL_NV_float_buffer + WGL_FLOAT_COMPONENTS_NV = $20B0; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3; + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4; + WGL_TEXTURE_FLOAT_R_NV = $20B5; + WGL_TEXTURE_FLOAT_RG_NV = $20B6; + WGL_TEXTURE_FLOAT_RGB_NV = $20B7; + WGL_TEXTURE_FLOAT_RGBA_NV = $20B8; + + // WGL_NV_render_depth_texture + WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3; + WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4; + WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5; + WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6; + WGL_DEPTH_COMPONENT_NV = $20A7; + + // WGL_NV_render_texture_rectangle + WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0; + WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1; + WGL_TEXTURE_RECTANGLE_NV = $20A2; + + // WGL_NV_present_video + WGL_NUM_VIDEO_SLOTS_NV = $20F0; + + // WGL_NV_video_output + WGL_BIND_TO_VIDEO_RGB_NV = $20C0; + WGL_BIND_TO_VIDEO_RGBA_NV = $20C1; + WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2; + WGL_VIDEO_OUT_COLOR_NV = $20C3; + WGL_VIDEO_OUT_ALPHA_NV = $20C4; + WGL_VIDEO_OUT_DEPTH_NV = $20C5; + WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6; + WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7; + WGL_VIDEO_OUT_FRAME = $20C8; + WGL_VIDEO_OUT_FIELD_1 = $20C9; + WGL_VIDEO_OUT_FIELD_2 = $20CA; + WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB; + WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC; + + // WGL_NV_gpu_affinity + WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0; + WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1; + + // WGL_NV_video_capture + WGL_UNIQUE_ID_NV = $20CE; + WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = $20CF; + + // WGL_NV_multisample_coverage + WGL_COVERAGE_SAMPLES_NV = $2042; + WGL_COLOR_SAMPLES_NV = $20B9; + + // WGL_EXT_create_context_es2_profile + WGL_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; + + // WGL_NV_DX_interop + WGL_ACCESS_READ_ONLY_NV = $00000000; + WGL_ACCESS_READ_WRITE_NV = $00000001; + WGL_ACCESS_WRITE_DISCARD_NV = $00000002; + + // WIN_draw_range_elements + GL_MAX_ELEMENTS_VERTICES_WIN = $80E8; + GL_MAX_ELEMENTS_INDICES_WIN = $80E9; + + // GLX 1.1 and later: + GLX_VENDOR = 1; + GLX_VERSION = 2; + GLX_EXTENSIONS = 3; + + GLX_USE_GL = 1; + GLX_BUFFER_SIZE = 2; + GLX_LEVEL = 3; + GLX_RGBA = 4; + GLX_DOUBLEBUFFER = 5; + GLX_STEREO = 6; + GLX_AUX_BUFFERS = 7; + GLX_RED_SIZE = 8; + GLX_GREEN_SIZE = 9; + GLX_BLUE_SIZE = 10; + GLX_ALPHA_SIZE = 11; + GLX_DEPTH_SIZE = 12; + GLX_STENCIL_SIZE = 13; + GLX_ACCUM_RED_SIZE = 14; + GLX_ACCUM_GREEN_SIZE = 15; + GLX_ACCUM_BLUE_SIZE = 16; + GLX_ACCUM_ALPHA_SIZE = 17; + + // GLX_VERSION_1_3 + GLX_WINDOW_BIT = $00000001; + GLX_PIXMAP_BIT = $00000002; + GLX_PBUFFER_BIT = $00000004; + GLX_RGBA_BIT = $00000001; + GLX_COLOR_INDEX_BIT = $00000002; + GLX_PBUFFER_CLOBBER_MASK = $08000000; + GLX_FRONT_LEFT_BUFFER_BIT = $00000001; + GLX_FRONT_RIGHT_BUFFER_BIT = $00000002; + GLX_BACK_LEFT_BUFFER_BIT = $00000004; + GLX_BACK_RIGHT_BUFFER_BIT = $00000008; + GLX_AUX_BUFFERS_BIT = $00000010; + GLX_DEPTH_BUFFER_BIT = $00000020; + GLX_STENCIL_BUFFER_BIT = $00000040; + GLX_ACCUM_BUFFER_BIT = $00000080; + GLX_CONFIG_CAVEAT = $20; + GLX_X_VISUAL_TYPE = $22; + GLX_TRANSPARENT_TYPE = $23; + GLX_TRANSPARENT_INDEX_VALUE = $24; + GLX_TRANSPARENT_RED_VALUE = $25; + GLX_TRANSPARENT_GREEN_VALUE = $26; + GLX_TRANSPARENT_BLUE_VALUE = $27; + GLX_TRANSPARENT_ALPHA_VALUE = $28; + GLX_DONT_CARE = $FFFFFFFF; + GLX_NONE = $8000; + GLX_SLOW_CONFIG = $8001; + GLX_TRUE_COLOR = $8002; + GLX_DIRECT_COLOR = $8003; + GLX_PSEUDO_COLOR = $8004; + GLX_STATIC_COLOR = $8005; + GLX_GRAY_SCALE = $8006; + GLX_STATIC_GRAY = $8007; + GLX_TRANSPARENT_RGB = $8008; + GLX_TRANSPARENT_INDEX = $8009; + GLX_VISUAL_ID = $800B; + GLX_SCREEN = $800C; + GLX_NON_CONFORMANT_CONFIG = $800D; + GLX_DRAWABLE_TYPE = $8010; + GLX_RENDER_TYPE = $8011; + GLX_X_RENDERABLE = $8012; + GLX_FBCONFIG_ID = $8013; + GLX_RGBA_TYPE = $8014; + GLX_COLOR_INDEX_TYPE = $8015; + GLX_MAX_PBUFFER_WIDTH = $8016; + GLX_MAX_PBUFFER_HEIGHT = $8017; + GLX_MAX_PBUFFER_PIXELS = $8018; + GLX_PRESERVED_CONTENTS = $801B; + GLX_LARGEST_PBUFFER = $801C; + GLX_WIDTH = $801D; + GLX_HEIGHT = $801E; + GLX_EVENT_MASK = $801F; + GLX_DAMAGED = $8020; + GLX_SAVED = $8021; + GLX_WINDOW = $8022; + GLX_PBUFFER = $8023; + GLX_PBUFFER_HEIGHT = $8040; + GLX_PBUFFER_WIDTH = $8041; + + // GLX_VERSION_1_4 + GLX_SAMPLE_BUFFERS = 100000; + GLX_SAMPLES = 100001; + + // GLX_ARB_multisample + GLX_SAMPLE_BUFFERS_ARB = 100000; + GLX_SAMPLES_ARB = 100001; + + // GLX_ARB_fbconfig_float + GLX_RGBA_FLOAT_TYPE_ARB = $20B9; + GLX_RGBA_FLOAT_BIT_ARB = $00000004; + + // GLX_ARB_create_context + GLX_CONTEXT_DEBUG_BIT_ARB = $00000001; + GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; + GLX_CONTEXT_MAJOR_VERSION_ARB = $2091; + GLX_CONTEXT_MINOR_VERSION_ARB = $2092; + GLX_CONTEXT_FLAGS_ARB = $2094; + + // GLX_ARB_create_context_profile + GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; + GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; + GLX_CONTEXT_PROFILE_MASK_ARB = $9126; + + // GLX_ARB_vertex_buffer_object + GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = $2095; + + // GLX_ARB_framebuffer_sRGB + GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20B2; + + // GLX_ARB_create_context_robustness + GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; + GLX_LOSE_CONTEXT_ON_RESET_ARB = $8252; + GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; + GLX_NO_RESET_NOTIFICATION_ARB = $8261; + + // GLX_EXT_visual_info + GLX_X_VISUAL_TYPE_EXT = $22; + GLX_TRANSPARENT_TYPE_EXT = $23; + GLX_TRANSPARENT_INDEX_VALUE_EXT = $24; + GLX_TRANSPARENT_RED_VALUE_EXT = $25; + GLX_TRANSPARENT_GREEN_VALUE_EXT = $26; + GLX_TRANSPARENT_BLUE_VALUE_EXT = $27; + GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28; + GLX_NONE_EXT = $8000; + GLX_TRUE_COLOR_EXT = $8002; + GLX_DIRECT_COLOR_EXT = $8003; + GLX_PSEUDO_COLOR_EXT = $8004; + GLX_STATIC_COLOR_EXT = $8005; + GLX_GRAY_SCALE_EXT = $8006; + GLX_STATIC_GRAY_EXT = $8007; + GLX_TRANSPARENT_RGB_EXT = $8008; + GLX_TRANSPARENT_INDEX_EXT = $8009; + + // GLX_EXT_visual_rating + GLX_VISUAL_CAVEAT_EXT = $20; + GLX_SLOW_VISUAL_EXT = $8001; + GLX_NON_CONFORMANT_VISUAL_EXT = $800D; + (* reuse GLX_NONE_EXT ) + + // GLX_EXT_import_context + GLX_SHARE_CONTEXT_EXT = $800A; + GLX_VISUAL_ID_EXT = $800B; + GLX_SCREEN_EXT = $800C; + + // GLX_EXT_fbconfig_packed_float +// GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; +// GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; + + // GLX_EXT_framebuffer_sRGB +// GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; + + // GLX_EXT_texture_from_pixmap + GLX_TEXTURE_1D_BIT_EXT = $00000001; + GLX_TEXTURE_2D_BIT_EXT = $00000002; + GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004; + GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0; + GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1; + GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2; + GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3; + GLX_Y_INVERTED_EXT = $20D4; + GLX_TEXTURE_FORMAT_EXT = $20D5; + GLX_TEXTURE_TARGET_EXT = $20D6; + GLX_MIPMAP_TEXTURE_EXT = $20D7; + GLX_TEXTURE_FORMAT_NONE_EXT = $20D8; + GLX_TEXTURE_FORMAT_RGB_EXT = $20D9; + GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA; + GLX_TEXTURE_1D_EXT = $20DB; + GLX_TEXTURE_2D_EXT = $20DC; + GLX_TEXTURE_RECTANGLE_EXT = $20DD; + GLX_FRONT_LEFT_EXT = $20DE; + GLX_FRONT_RIGHT_EXT = $20DF; + GLX_BACK_LEFT_EXT = $20E0; + GLX_BACK_RIGHT_EXT = $20E1; + GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT; + GLX_BACK_EXT = GLX_BACK_LEFT_EXT; + GLX_AUX0_EXT = $20E2; + GLX_AUX1_EXT = $20E3; + GLX_AUX2_EXT = $20E4; + GLX_AUX3_EXT = $20E5; + GLX_AUX4_EXT = $20E6; + GLX_AUX5_EXT = $20E7; + GLX_AUX6_EXT = $20E8; + GLX_AUX7_EXT = $20E9; + GLX_AUX8_EXT = $20EA; + GLX_AUX9_EXT = $20EB; + + // GLX_EXT_swap_control + GLX_SWAP_INTERVAL_EXT = $20F1; + GLX_MAX_SWAP_INTERVAL_EXT = $20F2; + + // GLX_EXT_create_context_es2_profile + GLX_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; + + // GL_EXT_Late_Swaps + GLX_LATE_SWAPS_TEAR_EXT = $20F3; + + // GLU + GLU_INVALID_ENUM = 100900; + GLU_INVALID_VALUE = 100901; + GLU_OUT_OF_MEMORY = 100902; + GLU_INCOMPATIBLE_GL_VERSION = 100903; + GLU_VERSION = 100800; + GLU_EXTENSIONS = 100801; + GLU_TRUE = GL_TRUE; + GLU_FALSE = GL_FALSE; + GLU_SMOOTH = 100000; + GLU_FLAT = 100001; + GLU_NONE = 100002; + GLU_POINT = 100010; + GLU_LINE = 100011; + GLU_FILL = 100012; + GLU_SILHOUETTE = 100013; + GLU_OUTSIDE = 100020; + GLU_INSIDE = 100021; + GLU_TESS_MAX_COORD = 1.0E150; + GLU_TESS_WINDING_RULE = 100140; + GLU_TESS_BOUNDARY_ONLY = 100141; + GLU_TESS_TOLERANCE = 100142; + GLU_TESS_WINDING_ODD = 100130; + GLU_TESS_WINDING_NONZERO = 100131; + GLU_TESS_WINDING_POSITIVE = 100132; + GLU_TESS_WINDING_NEGATIVE = 100133; + GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; + GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc + GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc + GLU_TESS_END = 100102; // TGLUTessEndProc + GLU_TESS_ERROR = 100103; // TGLUTessErrorProc + GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc + GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc + GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc + GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc + GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc + GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc + GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc + GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc + GLU_TESS_ERROR1 = 100151; + GLU_TESS_ERROR2 = 100152; + GLU_TESS_ERROR3 = 100153; + GLU_TESS_ERROR4 = 100154; + GLU_TESS_ERROR5 = 100155; + GLU_TESS_ERROR6 = 100156; + GLU_TESS_ERROR7 = 100157; + GLU_TESS_ERROR8 = 100158; + GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1; + GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2; + GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3; + GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4; + GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5; + GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6; + GLU_AUTO_LOAD_MATRIX = 100200; + GLU_CULLING = 100201; + GLU_SAMPLING_TOLERANCE = 100203; + GLU_DISPLAY_MODE = 100204; + GLU_PARAMETRIC_TOLERANCE = 100202; + GLU_SAMPLING_METHOD = 100205; + GLU_U_STEP = 100206; + GLU_V_STEP = 100207; + GLU_PATH_LENGTH = 100215; + GLU_PARAMETRIC_ERROR = 100216; + GLU_DOMAIN_DISTANCE = 100217; + GLU_MAP1_TRIM_2 = 100210; + GLU_MAP1_TRIM_3 = 100211; + GLU_OUTLINE_POLYGON = 100240; + GLU_OUTLINE_PATCH = 100241; + GLU_NURBS_ERROR1 = 100251; + GLU_NURBS_ERROR2 = 100252; + GLU_NURBS_ERROR3 = 100253; + GLU_NURBS_ERROR4 = 100254; + GLU_NURBS_ERROR5 = 100255; + GLU_NURBS_ERROR6 = 100256; + GLU_NURBS_ERROR7 = 100257; + GLU_NURBS_ERROR8 = 100258; + GLU_NURBS_ERROR9 = 100259; + GLU_NURBS_ERROR10 = 100260; + GLU_NURBS_ERROR11 = 100261; + GLU_NURBS_ERROR12 = 100262; + GLU_NURBS_ERROR13 = 100263; + GLU_NURBS_ERROR14 = 100264; + GLU_NURBS_ERROR15 = 100265; + GLU_NURBS_ERROR16 = 100266; + GLU_NURBS_ERROR17 = 100267; + GLU_NURBS_ERROR18 = 100268; + GLU_NURBS_ERROR19 = 100269; + GLU_NURBS_ERROR20 = 100270; + GLU_NURBS_ERROR21 = 100271; + GLU_NURBS_ERROR22 = 100272; + GLU_NURBS_ERROR23 = 100273; + GLU_NURBS_ERROR24 = 100274; + GLU_NURBS_ERROR25 = 100275; + GLU_NURBS_ERROR26 = 100276; + GLU_NURBS_ERROR27 = 100277; + GLU_NURBS_ERROR28 = 100278; + GLU_NURBS_ERROR29 = 100279; + GLU_NURBS_ERROR30 = 100280; + GLU_NURBS_ERROR31 = 100281; + GLU_NURBS_ERROR32 = 100282; + GLU_NURBS_ERROR33 = 100283; + GLU_NURBS_ERROR34 = 100284; + GLU_NURBS_ERROR35 = 100285; + GLU_NURBS_ERROR36 = 100286; + GLU_NURBS_ERROR37 = 100287; + GLU_CW = 100120; + GLU_CCW = 100121; + GLU_INTERIOR = 100122; + GLU_EXTERIOR = 100123; + GLU_UNKNOWN = 100124; + GLU_BEGIN = GLU_TESS_BEGIN; + GLU_VERTEX = GLU_TESS_VERTEX; + GLU_END = GLU_TESS_END; + GLU_ERROR = GLU_TESS_ERROR; + GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG; + +type + // GL_VERSION_1_0 + TglCullFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFrontFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglHint = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLineWidth = procedure(width: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointSize = procedure(size: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPolygonMode = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissor = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClear = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearStencil = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearDepth = procedure(depth: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorMask = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthMask = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinish = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlush = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFunc = procedure(sfactor: GLenum; dfactor: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLogicOp = procedure(opcode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFunc = procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilOp = procedure(fail: GLenum; zfail: GLenum; zpass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthFunc = procedure(func: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelStoref = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBooleanv = procedure(pname: GLenum; params: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDoublev = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetError = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFloatv = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsEnabled = function(cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRange = procedure(zNear: GLclampd; zFar: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglViewport = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_1_1 + TglDrawArrays = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElements = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPointerv = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPolygonOffset = procedure(factor: GLfloat; units: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexImage1D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexImage2D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +{$ifdef DGL_DEPRECATED} + TglAccum = procedure(op: GLenum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAlphaFunc = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglArrayElement = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBegin = procedure(mode: GLenum); {$IFNDEF CLR}{$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}{$ENDIF} + TglBitmap = procedure(width: GLsizei; height: GLsizei; xorig: GLfloat; yorig: GLfloat; xmove: GLfloat; ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCallList = procedure(list: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCallLists = procedure(n: GLsizei; _type: GLenum; const lists: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearAccum = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearIndex = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClipPlane = procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte; alpha: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble; alpha: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4i = procedure(red: GLint; green: GLint; blue: GLint; alpha: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4s = procedure(red: GLshort; green: GLshort; blue: GLshort; alpha: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte; alpha: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ui = procedure(red: GLuint; green: GLuint; blue: GLuint; alpha: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4us = procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorMaterial = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; _type: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteLists = procedure(list: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawPixels = procedure(width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlag = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlagPointer = procedure(stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlagv = procedure(const flag: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnd = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndList = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord1d = procedure(u: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord1dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord1f = procedure(u: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord1fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord2d = procedure(u: GLdouble; v: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord2dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord2f = procedure(u: GLfloat; v: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalCoord2fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalMesh1 = procedure(mode: GLenum; i1: GLint; i2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalMesh2 = procedure(mode: GLenum; i1: GLint; i2: GLint; j1: GLint; j2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalPoint1 = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalPoint2 = procedure(i: GLint; j: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFeedbackBuffer = procedure(size: GLsizei; _type: GLenum; buffer: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogiv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFrustum = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenLists = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetClipPlane = procedure(plane: GLenum; equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetLightfv = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetLightiv = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapdv = procedure(target: GLenum; query: GLenum; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapfv = procedure(target: GLenum; query: GLenum; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapiv = procedure(target: GLenum; query: GLenum; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMaterialfv = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMaterialiv = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPixelMapfv = procedure(map: GLenum; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPixelMapuiv = procedure(map: GLenum; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPixelMapusv = procedure(map: GLenum; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPolygonStipple = procedure(mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexEnvfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexEnviv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexGendv = procedure(coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexGenfv = procedure(coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexGeniv = procedure(coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexd = procedure(c: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexdv = procedure(const c: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexf = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexfv = procedure(const c: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexi = procedure(c: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexiv = procedure(const c: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexs = procedure(c: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexsv = procedure(const c: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexub = procedure(c: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexubv = procedure(const c: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInitNames = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInterleavedArrays = procedure(format: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsList = function(list: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTexture = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightModelf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightModelfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightModeli = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightModeliv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightf = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightfv = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLighti = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightiv = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLineStipple = procedure(factor: GLint; pattern: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglListBase = procedure(base: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadIdentity = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMap1d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMap1f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMap2d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMap2f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapGrid1d = procedure(un: GLint; u1: GLdouble; u2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapGrid1f = procedure(un: GLint; u1: GLfloat; u2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapGrid2d = procedure(un: GLint; u1: GLdouble; u2: GLdouble; vn: GLint; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapGrid2f = procedure(un: GLint; u1: GLfloat; u2: GLfloat; vn: GLint; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMaterialf = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMaterialfv = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMateriali = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMaterialiv = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixMode = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNewList = procedure(list: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3b = procedure(nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3d = procedure(nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3f = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3i = procedure(nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3s = procedure(nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglOrtho = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPassThrough = procedure(token: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelMapfv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelMapuiv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelMapusv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTransferf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTransferi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelZoom = procedure(xfactor: GLfloat; yfactor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPolygonStipple = procedure(const mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPopAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPopClientAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPopMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPopName = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPrioritizeTextures = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushClientAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRasterPos4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectd = procedure(x1: GLdouble; y1: GLdouble; x2: GLdouble; y2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectdv = procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectf = procedure(x1: GLfloat; y1: GLfloat; x2: GLfloat; y2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectfv = procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRecti = procedure(x1: GLint; y1: GLint; x2: GLint; y2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectiv = procedure(const v1: PGLint; const v2: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRects = procedure(x1: GLshort; y1: GLshort; x2: GLshort; y2: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRectsv = procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderMode = function(mode: GLenum): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRotated = procedure(angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRotatef = procedure(angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScaled = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScalef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSelectBuffer = procedure(size: GLsizei; buffer: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShadeModel = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1d = procedure(s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1f = procedure(s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1i = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1s = procedure(s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2d = procedure(s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2f = procedure(s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2i = procedure(s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2s = procedure(s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3d = procedure(s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3f = procedure(s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3i = procedure(s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3s = procedure(s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4d = procedure(s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4f = procedure(s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4i = procedure(s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4s = procedure(s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexEnvf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexEnvfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexEnvi = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexEnviv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGend = procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGendv = procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGenf = procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGenfv = procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGeniv = procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + + TglTranslated = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTranslatef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$endif} + + // GL_VERSION_1_2 + TglBlendColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquation = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElements = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$ifdef DGL_DEPRECATED} + TglColorTable = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorTable = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTable = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorSubTable = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorSubTable = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterf = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameteri = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSeparableFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSeparableFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogram = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmax = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglHistogram = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMinmax = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetHistogram = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetMinmax = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$endif} + + // GL_VERSION_1_3 + TglActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleCoverage = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$ifdef DGL_DEPRECATED} + TglClientActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1d = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1f = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1i = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1s = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2d = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2f = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2i = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2s = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$endif} + + // GL_VERSION_1_4 + TglBlendFuncSeparate = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawArrays = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElements = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameteri = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameteriv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$ifdef DGL_DEPRECATED} + TglFogCoordf = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordd = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +{$endif} + + // GL_VERSION_1_5 + TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffer = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteBuffers = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenBuffers = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsBuffer = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferData = procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapBuffer = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapBuffer = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferPointerv = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_2_0 + TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFuncSeparate = procedure(face: GLenum; func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveAttrib = procedure(programObj: GLhandle; index: GLuint; maxlength: GLsizei; var length: GLint; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniform = procedure(programObj: GLhandle; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttribLocation = function(programObj: GLhandle; char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramiv = procedure(programObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; var length: GLint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; var length: glint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgram = function(programObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsShader = function(shaderObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; const _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_2_1 + TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_0 + { OpenGL 3.0 also reuses entry points from these extensions: } + { ARB_framebuffer_object } + { ARB_map_buffer_range } + { ARB_vertex_array_object } + TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_2_1 + TglEnableVertexArrayEXT = procedure(vaobj: GLuint; array_: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexArrayAttribEXT = procedure(vaobj: GLuint; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; normalized: GLboolean; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_1 + { OpenGL 3.1 also reuses entry points from these extensions: } + { ARB_copy_buffer } + { ARB_uniform_buffer_object } + TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_2 + { OpenGL 3.2 also reuses entry points from these extensions: } + { ARB_draw_elements_base_vertex } + { ARB_provoking_vertex } + { ARB_sync } + { ARB_texture_multisample } + TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +// TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_3_3 + { OpenGL 3.3 also reuses entry points from these extensions: } + { ARB_blend_func_extended } + { ARB_sampler_objects } + { ARB_explicit_attrib_location, but it has none } + { ARB_occlusion_query2 (no entry points) } + { ARB_shader_bit_encoding (no entry points) } + { ARB_texture_rgb10_a2ui (no entry points) } + { ARB_texture_swizzle (no entry points) } + { ARB_timer_query } + { ARB_vertex_type_2_10_10_10_rev } + TglVertexAttribDivisor = procedure(index: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_4_0 + { OpenGL 4.0 also reuses entry points from these extensions: } + { ARB_texture_query_lod (no entry points) } + { ARB_draw_indirect } + { ARB_gpu_shader5 (no entry points) } + { ARB_gpu_shader_fp64 } + { ARB_shader_subroutine } + { ARB_tessellation_shader } + { ARB_texture_buffer_object_rgb32 (no entry points) } + { ARB_texture_cube_map_array (no entry points) } + { ARB_texture_gather (no entry points) } + { ARB_transform_feedback2 } + { ARB_transform_feedback3 } + TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_VERSION_4_1 + { OpenGL 4.1 also reuses entry points from these extensions: } + { ARB_ES2_compatibility } + { ARB_get_program_binary } + { ARB_separate_shader_objects } + { ARB_shader_precision (no entry points) } + { ARB_vertex_attrib_64bit } + { ARB_viewport_array } + + // GL_3DFX_tbuffer + TglTbufferMask3DFX = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_element_array + TglElementPointerAPPLE = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementArrayAPPLE = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementArrayAPPLE = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_fence + TglGenFencesAPPLE = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteFencesAPPLE = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSetFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTestFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinishFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTestObjectAPPLE = function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinishObjectAPPLE = procedure(_object: GLenum; name: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_vertex_array_object + TglBindVertexArrayAPPLE = procedure(_array: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsVertexArrayAPPLE = function(_array: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_vertex_array_range + TglVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayParameteriAPPLE = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_texture_range + TglTextureRangeAPPLE = procedure(target: GLenum; length: GLsizei; const Pointer_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterPointervAPPLE = procedure(target: GLenum; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_vertex_program_evaluators + TglEnableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsVertexAttribEnabledAPPLE = function(index_: GLuint; pname: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapVertexAttrib1dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapVertexAttrib1fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapVertexAttrib2dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapVertexAttrib2fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; ustride: GLint; order: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_APPLE_object_purgeable + TglObjectPurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglObjectUnpurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectParameterivAPPLE = procedure(objectType: GLenum; name: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_matrix_palette + TglCurrentPaletteMatrixARB = procedure(index: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixIndexubvARB = procedure(size: GLint; const indices: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixIndexusvARB = procedure(size: GLint; const indices: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixIndexuivARB = procedure(size: GLint; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixIndexPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_multisample + TglSampleCoverageARB = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_multitexture + TglActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClientActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1dARB = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1fARB = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1iARB = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1sARB = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2iARB = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2sARB = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_point_parameters + TglPointParameterfARB = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterfvARB = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_compression + TglCompressedTexImage3DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage2DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage1DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage3DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage2DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexSubImage1DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTexImageARB = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transpose_matrix + TglLoadTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_blend + TglWeightbvARB = procedure(size: GLint; const weights: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightsvARB = procedure(size: GLint; const weights: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightivARB = procedure(size: GLint; const weights: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightfvARB = procedure(size: GLint; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightdvARB = procedure(size: GLint; const weights: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightubvARB = procedure(size: GLint; const weights: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightusvARB = procedure(size: GLint; const weights: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightuivARB = procedure(size: GLint; const weights: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexBlendARB = procedure(count: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_buffer_object + TglBindBufferARB = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteBuffersARB = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenBuffersARB = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsBufferARB = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferDataARB = procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapBufferARB = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapBufferARB = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameterivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferPointervARB = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_program + TglVertexAttrib1dARB = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fARB = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1sARB = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2sARB = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NbvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NsvARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NubARB = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NuivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4NusvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4bvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4uivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4usvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribPointerARB = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramStringARB = procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindProgramARB = procedure(target: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgramsARB = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenProgramsARB = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramEnvParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramEnvParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramLocalParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramLocalParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramStringARB = procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribdvARB = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribfvARB = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribivARB = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribPointervARB = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgramARB = function(_program: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_window_pos + TglWindowPos2dARB = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fARB = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2iARB = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2sARB = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dARB = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fARB = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3iARB = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3sARB = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_buffers + TglDrawBuffersARB = procedure(n: GLsizei; bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_color_buffer_float + TglClampColorARB = procedure(target: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_shader + TglGetActiveAttribARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttribLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindAttribLocationARB = procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shader_objects + TglDeleteObjectARB = procedure(Obj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHandleARB = function(pname: GlEnum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDetachObjectARB = procedure(container, attached: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShaderObjectARB = function(shaderType: glenum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderSourceARB = procedure(shaderObj: GLHandleARB; count: glsizei; const _string: PPGLCharARB; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompileShaderARB = procedure(shaderObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateProgramObjectARB = function: GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAttachObjectARB = procedure(programObj, shaderObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLinkProgramARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUseProgramObjectARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglValidateProgramARB = procedure(programObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1fARB = procedure(location: glint; v0: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2fARB = procedure(location: glint; v0, v1: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3fARB = procedure(location: glint; v0, v1, v2: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4fARB = procedure(location: glint; v0, v1, v2, v3: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1iARB = procedure(location: glint; v0: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2iARB = procedure(location: glint; v0, v1: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3iARB = procedure(location: glint; v0, v1, v2: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4iARB = procedure(location: glint; v0, v1, v2, v3: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectParameterfvARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectParameterivARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInfoLogARB = procedure(shaderObj: GLHandleARB; maxLength: glsizei; var length: glint; infoLog: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetAttachedObjectsARB = procedure(programobj: GLhandleARB; maxCount: GLsizei; var count: GLsizei; objects: PGLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformfvARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformivARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderSourceARB = procedure(shader: GLhandleARB; maxLength: GLsizei; var length: GLsizei; source: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_Occlusion_Query + TglGenQueriesARB = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteQueriesARB = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsQueryARB = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginQueryARB = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndQueryARB = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryivARB = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectivARB = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectuivARB = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_instanced + TglDrawArraysInstancedARB = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedARB = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_framebuffer_object + TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_geometry_shader4 + TglProgramParameteriARB = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureLayerARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureFaceARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_instanced_arrays + TglVertexAttribDivisorARB = procedure(index_: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_map_buffer_range + TglMapBufferRange = function(target: GLenum; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_buffer_object + TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_array_object + TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_uniform_buffer_object + TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_copy_buffer + TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_elements_base_vertex + TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_provoking_vertex + TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_sync + TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_multisample + TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_buffers_blend + TglBlendEquationiARB = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationSeparateiARB = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFunciARB = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFuncSeparateiARB = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_sample_shading + TglMinSampleShadingARB = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shading_language_include + TglNamedStringARB = procedure(type_: GLenum; namelen: GLint; const name: PGLchar; stringlen: GLint; const string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteNamedStringARB = procedure(namelen: GLint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompileShaderIncludeARB = procedure (shader: GLuint; count: GLsizei; const path: PPGLchar; const length: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsNamedStringARB = function(namelen: GLint; const name: PGLchar): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedStringARB = procedure(namelen: GLint; const name: PGLchar; bufSize: GLsizei; stringlen: GLint; string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedStringivARB = procedure(namelen: GLint; const name: PGLchar; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_blend_func_extended + TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_sampler_objects + TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_timer_query + TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_type_2_10_10_10_rev + TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_draw_indirect + TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_gpu_shader_fp64 + TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shader_subroutine + TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_tessellation_shader + TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback2 + TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback3 + TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_ES2_compatibility + TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_get_program_binary + TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_separate_shader_objects + TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_attrib_64bit + TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_viewport_array + TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.2 + + // GL_ARB_base_instance + TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_transform_feedback_instanced + TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_internalformat_query + TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_shader_atomic_counters + TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + /// GL_ARB_shader_image_load_store + TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_storage + TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage1DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage2DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage3DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + + // GL 4.3 + + // GL_KHR_debug + TglDebugMessageControl = procedure(source : GLenum; type_ : GLenum; severity : TGLenum; count : GLsizei; const ids : PGLUInt; enabled : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageInsert = procedure(source : GLenum; type_ : GLenum; id : GLuint; sverity : GLenum; length : GLsizei; const buf : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageCallback = procedure(callback : TGLDEBUGPROC; const userParam : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDebugMessageLog = function(count : GLuint; bufsize : GLsizei; sources : PGLenum; types : PGLenum; ids : PGLuint; sverities : PGLenum; lengths : PGLSizei; messagelog : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushDebugGroup = procedure(source : GLenum; id : GLuint; length : GLsizei; const message_ : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPopDebugGroup = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglObjectLabel = procedure(identifier : GLenum; name : GLuint; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectLabel = procedure(identifier : GLenum; name : GLuint; bufsize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglObjectPtrLabel = procedure(const ptr : Pointer; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectPtrLabel = procedure(const ptr : Pointer; bufSize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_clear_buffer_object + TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedBufferDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearNamedBufferSubDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLenum; type_ : GLenum; offset : GLsizeiptr; size : GLsizeiptr; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_compute_shader 1 + TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_copy_image + TglCopyImageSubData = 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); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_debug_group + // ARB_debug_group reuses entry points from KHR_debug + + // GL_ARB_debug_label + // ARB_debug_label reuses entry points from KHR_debug + + // GL_ARB_debug_output2 + + // GL_ARB_ES3_compatibility + + // GL_ARB_explicit_uniform_location + + // GL_ARB_fragment_layer_viewport + + // GL_ARB_framebuffer_no_attachments + TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferParameteriEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedFramebufferParameterivEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_internalformat_query2 + TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_invalidate_subdata + TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_multi_draw_indirect + TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_program_interface_query + TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_robust_buffer_access_behavior + + // GL_ARB_shader_image_size + + // GL_ARB_shader_storage_buffer_object + TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_stencil_texturing + + // GL_ARB_texture_buffer_range + TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureBufferRangeEXT = procedure(texture : GLuint; target : GLenum; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_texture_query_levels + + // GL_ARB_texture_storage_multisample + TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage2DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureStorage3DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL 4.4 + + TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // END GL 4.4 + + + // GL_ARB_texture_view + TglTextureView = procedure(texture : GLuint; target : GLenum; origtexture : GLuint; internalformat : GLenum; minlevel : GLuint; numlevels : GLuint; minlayer : GLuint; numlayers : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_vertex_attrib_binding + TglBindVertexBuffer = procedure(bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribBinding = procedure(attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexBindingDivisor = procedure(bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayBindVertexBufferEXT = procedure(vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribIFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribLFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribBindingEXT = procedure(vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexBindingDivisorEXT = procedure(vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_robustness_isolation + + // + + // GL_ARB_cl_event + TglCreateSyncFromCLeventARB = function(context: p_cl_context; event: p_cl_event; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_debug_output + TglDebugMessageControlARB = procedure(source: GLenum; type_: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageInsertARB = procedure(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageCallbackARB = procedure(callback: TglDebugProcARB; const userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDebugMessageLogARB = function(count: GLuint; bufsize: GLsizei; sources: PGLenum; types: PGLenum; ids: PGLuint; severities: PGLenum; lengths: PGLsizei; messageLog: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ARB_robustness + TglGetGraphicsResetStatusARB = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapdvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapfvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMapivARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapfvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapuivARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPixelMapusvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnPolygonStippleARB = procedure(bufSize: GLsizei; pattern: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnColorTableARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnConvolutionFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnSeparableFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; rowBufSize: GLsizei; row: PGLvoid; columnBufSize: GLsizei; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnHistogramARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnMinmaxARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnTexImageARB = procedure(target: GLenum; level: GLint; format: GLenum; type_: GLenum; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadnPixelsARB = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; bufSize: GLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnCompressedTexImageARB = procedure(target: GLenum; lod: GLint; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformfvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformuivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetnUniformdvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_draw_buffers + TglDrawBuffersATI = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_element_array + TglElementPointerATI = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementArrayATI = procedure(mode: GLenum; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawRangeElementArrayATI = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_envmap_bumpmap + TglTexBumpParameterivATI = procedure(pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexBumpParameterfvATI = procedure(pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexBumpParameterivATI = procedure(pname: GLenum; param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexBumpParameterfvATI = procedure(pname: GLenum; param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_fragment_shader + TglGenFragmentShadersATI = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPassTexCoordATI = procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleMapATI = procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAlphaFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAlphaFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglAlphaFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSetFragmentShaderConstantATI = procedure(dst: GLuint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_map_object_buffer + TglMapObjectBufferATI = function(buffer: GLuint): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_pn_triangles + TglPNTrianglesiATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPNTrianglesfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_separate_stencil + TglStencilOpSeparateATI = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFuncSeparateATI = procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_vertex_array_object + TglNewObjectBufferATI = function(size: GLsizei; const _pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsObjectBufferATI = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUpdateObjectBufferATI = procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const _pointer: PGLvoid; preserve: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectBufferfvATI = procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetObjectBufferivATI = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFreeObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglArrayObjectATI = procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetArrayObjectfvATI = procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetArrayObjectivATI = procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantArrayObjectATI = procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantArrayObjectfvATI = procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantArrayObjectivATI = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_vertex_attrib_array_object + TglVertexAttribArrayObjectATI = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribArrayObjectfvATI = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribArrayObjectivATI = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_ATI_vertex_streams + TglVertexStream1sATI = procedure(stream: GLenum; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1iATI = procedure(stream: GLenum; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1fATI = procedure(stream: GLenum; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1dATI = procedure(stream: GLenum; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream1dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2sATI = procedure(stream: GLenum; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2iATI = procedure(stream: GLenum; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream2dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexStream4dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3bATI = procedure(stream: GLenum; nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3bvATI = procedure(stream: GLenum; const coords: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3sATI = procedure(stream: GLenum; nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3iATI = procedure(stream: GLenum; nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3fATI = procedure(stream: GLenum; nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3dATI = procedure(stream: GLenum; nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClientActiveVertexStreamATI = procedure(stream: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexBlendEnviATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexBlendEnvfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_performance_monitor + TglGetPerfMonitorGroupsAMD = procedure(numGroups: PGLint; groupsSize: GLsizei; groups: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPerfMonitorCountersAMD = procedure(group: GLuint; numCounters: PGLint; maxActiveCouters: PGLint; counterSize: GLsizei; counters: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPerfMonitorGroupStringAMD = procedure(group: GLuint; bufSize: GLsizei; length: PGLsizei; groupString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPerfMonitorCounterStringAMD = procedure(group: GLuint; counter: GLuint; bufSize: GLsizei; length: PGLsizei; counterString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPerfMonitorCounterInfoAMD = procedure(group: GLuint; counter: GLuint; pname: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenPerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeletePerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSelectPerfMonitorCountersAMD = procedure(monitor: GLuint; enable: GLboolean; group: GLuint; numCounters: GLint; counterList: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPerfMonitorCounterDataAMD = procedure(monitor: GLuint; pname: GLenum; dataSize: GLsizei; data: PGLuint; bytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_vertex_shader_tesselator + TglTessellationFactorAMD = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTessellationModeAMD = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_draw_buffers_blend + TglBlendFuncIndexedAMD = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendFuncSeparateIndexedAMD = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationIndexedAMD = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBlendEquationSeparateIndexedAMD = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_name_gen_delete + TglGenNamesAMD = procedure(identifier: GLenum; num: GLuint; names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteNamesAMD = procedure(identifier: GLenum; num: GLuint; const names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsNameAMD = function(identifier: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_debug_output + TglDebugMessageEnableAMD = procedure(category: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageInsertAMD = procedure(category: GLenum; severity: GLenum; id: GLuint; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDebugMessageCallbackAMD = procedure(callback: TGLDebugProcAMD; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDebugMessageLogAMD = function(count: GLuint; bufsize: GLsizei; categories: PGLenum; severities: PGLuint; ids: PGLuint; lengths: PGLsizei; message: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_blend_color + TglBlendColorEXT = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_blend_func_separate + TglBlendFuncSeparateEXT = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_blend_minmax + TglBlendEquationEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_color_subtable + TglColorSubTableEXT = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorSubTableEXT = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_compiled_vertex_array + TglLockArraysEXT = procedure(first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnlockArraysEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_convolution + TglConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterfEXT = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameteriEXT = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSeparableFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSeparableFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_coordinate_frame + TglTangent3bEXT = procedure(tx: GLbyte; ty: GLbyte; tz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3dEXT = procedure(tx: GLdouble; ty: GLdouble; tz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3fEXT = procedure(tx: GLfloat; ty: GLfloat; tz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3iEXT = procedure(tx: GLint; ty: GLint; tz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3sEXT = procedure(tx: GLshort; ty: GLshort; tz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangent3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3bEXT = procedure(bx: GLbyte; by: GLbyte; bz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3dEXT = procedure(bx: GLdouble; by: GLdouble; bz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3fEXT = procedure(bx: GLfloat; by: GLfloat; bz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3iEXT = procedure(bx: GLint; by: GLint; bz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3sEXT = procedure(bx: GLshort; by: GLshort; bz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormal3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTangentPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBinormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_copy_texture + TglCopyTexImage1DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexImage2DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_cull_vertex + TglCullParameterdvEXT = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCullParameterfvEXT = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_draw_range_elements + TglDrawRangeElementsEXT = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_fog_coord + TglFogCoordfEXT = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordfvEXT = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoorddEXT = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoorddvEXT = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_framebuffer_object + TglIsRenderbufferEXT = function(renderbuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindRenderbufferEXT = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteRenderbuffersEXT = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenRenderbuffersEXT = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRenderbufferStorageEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetRenderbufferParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsFramebufferEXT = function(framebuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFramebufferEXT = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteFramebuffersEXT = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenFramebuffersEXT = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCheckFramebufferStatusEXT = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture1DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture2DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTexture3DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferRenderbufferEXT = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferAttachmentParameterivEXT = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateMipmapEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_histogram + TglGetHistogramEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetHistogramParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMinmaxParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglHistogramEXT = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMinmaxEXT = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetHistogramEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResetMinmaxEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_index_func + TglIndexFuncEXT = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_index_material + TglIndexMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_light_texture + TglApplyTextureEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureLightEXT = procedure(pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_multi_draw_arrays + TglMultiDrawArraysEXT = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiDrawElementsEXT = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_multisample + TglSampleMaskEXT = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplePatternEXT = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_paletted_texture + TglColorTableEXT = procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_pixel_transform + TglPixelTransformParameteriEXT = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTransformParameterfEXT = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTransformParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTransformParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_point_parameters + TglPointParameterfEXT = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterfvEXT = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_polygon_offset + TglPolygonOffsetEXT = procedure(factor: GLfloat; bias: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_secondary_color + TglSecondaryColor3bEXT = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3dEXT = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3fEXT = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3iEXT = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3sEXT = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ubEXT = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3ubvEXT = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3uiEXT = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3uivEXT = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3usEXT = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3usvEXT = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_stencil_two_side + TglActiveStencilFaceEXT = procedure(face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_subtexture + TglTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_texture3D + TglTexImage3DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_texture_object + TglAreTexturesResidentEXT = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTextureEXT = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTexturesEXT = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTexturesEXT = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTextureEXT = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPrioritizeTexturesEXT = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_texture_perturb_normal + TglTextureNormalEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_vertex_array + TglArrayElementEXT = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawArraysEXT = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlagPointerEXT = procedure(stride: GLsizei; count: GLsizei; const _pointer: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPointervEXT = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_vertex_shader + TglBeginVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenVertexShadersEXT = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderOp1EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderOp2EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglShaderOp3EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSwizzleEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWriteMaskEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInsertComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglExtractComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenSymbolsEXT = function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSetInvariantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSetLocalConstantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantbvEXT = procedure(id: GLuint; const addr: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantsvEXT = procedure(id: GLuint; const addr: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantivEXT = procedure(id: GLuint; const addr: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantfvEXT = procedure(id: GLuint; const addr: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantdvEXT = procedure(id: GLuint; const addr: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantubvEXT = procedure(id: GLuint; const addr: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantusvEXT = procedure(id: GLuint; const addr: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantuivEXT = procedure(id: GLuint; const addr: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVariantPointerEXT = procedure(id: GLuint; _type: GLenum; stride: GLuint; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindLightParameterEXT = function(light: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindMaterialParameterEXT = function(face: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTexGenParameterEXT = function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTextureUnitParameterEXT = function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindParameterEXT = function(value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsVariantEnabledEXT = function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVariantPointervEXT = procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInvariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInvariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetInvariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetLocalConstantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetLocalConstantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetLocalConstantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_vertex_weighting + TglVertexWeightfEXT = procedure(weight: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexWeightfvEXT = procedure(const weight: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexWeightPointerEXT = procedure(size: GLsizei; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_stencil_clear_tag + TglStencilClearTagEXT = procedure(stencilTagBits: GLsizei; stencilClearTag: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_framebuffer_blit + TglBlitFramebufferEXT = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_framebuffer_multisample + TglRenderbufferStorageMultisampleEXT = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_timer_query + TglGetQueryObjecti64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetQueryObjectui64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_gpu_program_parameters + TglProgramEnvParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_bindable_uniform + TglUniformBufferEXT = procedure(_program: GLuint; location: GLint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformBufferSizeEXT = function(_program: GLuint; location: GLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformOffsetEXT = function(_program: GLuint; location: GLint): GLintptr; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_draw_buffers2 + TglColorMaskIndexedEXT = procedure(buf: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBooleanIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegerIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsEnabledIndexedEXT = function(target: GLenum; index: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_draw_instanced + TglDrawArraysInstancedEXT = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawElementsInstancedEXT = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: Pointer; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_geometry_shader4 + TglProgramParameteriEXT = procedure (_program: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +// TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferTextureFaceEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_gpu_shader4 + TglVertexAttribI1iEXT = procedure(index: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2iEXT = procedure(index: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1uiEXT = procedure(index: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI1uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI2uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI3uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4bvEXT = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4svEXT = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4ubvEXT = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribI4usvEXT = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIPointerEXT = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const _pointer: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIivEXT = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribIuivEXT = procedure(index: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1uiEXT = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformuivEXT = procedure(_program: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindFragDataLocationEXT = procedure(_program: GLuint; colorNumber: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragDataLocationEXT = function(_program: GLuint; const name: PGLchar): GLint; + + // GL_EXT_texture_array + TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_texture_buffer_object + TglTexBufferEXT = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_texture_integer + TglClearColorIiEXT = procedure(r: GLint; g: GLint; b: GLint; a: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearColorIuiEXT = procedure(r: GLuint; g: GLuint; b: GLuint; a: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterIuivEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterIiuvEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_HP_image_transform + TglImageTransformParameteriHP = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglImageTransformParameterfHP = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_depth_bounds_test + TglDepthBoundsEXT = procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_blend_equation_separate + TglBlendEquationSeparateEXT = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_transform_feedback + TglBeginTransformFeedbackEXT = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndTransformFeedbackEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferRangeEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferOffsetEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferBaseEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackVaryingsEXT = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbackVaryingEXT = procedure(program_: GLuint; index_: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_direct_state_access + TglClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPushClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixLoadfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixLoaddEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixMultfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixMultdEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixLoadIdentityEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixRotatefEXT = procedure(mode: GLenum; angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixRotatedEXT = procedure(mode: GLenum; angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixScalefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixScaledEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixTranslatefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixTranslatedEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixFrustumEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixOrthoEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixPopEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixPushEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixLoadTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixLoadTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixMultTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMatrixMultTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterfEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameteriEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureImageEXT = procedure(texture: GLuint; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureLevelParameterfvEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureLevelParameterivEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameterfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameteriEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexLevelParameterfvEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexLevelParameterivEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels:PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindMultiTextureEXT = procedure(texunit: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEnableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoordPointerEXT = procedure(texunit: GLenum; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexEnvfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexEnviEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGendEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGendvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGenfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGenfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGeniEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexGenivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexGendvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexGenfvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexGenivEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFloatIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDoubleIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPointerIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTextureImageEXT = procedure(texture: GLuint; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; format: GLenum; len: GLsizei; const string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameter4dEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameter4dvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameter4fEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameter4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramLocalParameterdvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramLocalParameterfvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramivEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameters4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameterI4iEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameterI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParametersI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameterI4uiEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParameterI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedProgramLocalParametersI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramLocalParameterIivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedProgramLocalParameterIuivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1iEXT = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedBufferDataEXT = procedure(buffer: GLuint; size: GLsizei; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapNamedBufferEXT = function(buffer: GLuint; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUnmapNamedBufferEXT = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapNamedBufferRangeEXT = function(buffer: GLuint; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushMappedNamedBufferRangeEXT = procedure(buffer: GLuint; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedCopyBufferSubDataEXT = procedure(readBuffer: GLuint; writeBuffer: GLuint; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferParameterivEXT = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferPointervEXT = procedure(buffer: GLuint; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureBufferEXT = procedure(texture: GLuint; target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexBufferEXT = procedure(texunit: GLenum; target: GLenum; interformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedRenderbufferStorageEXT = procedure(renderbuffer: GLuint; interformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedRenderbufferParameterivEXT = procedure(renderbuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCheckNamedFramebufferStatusEXT = function(framebuffer: GLuint; target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTexture1DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTexture2DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTexture3DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferRenderbufferEXT = procedure(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedFramebufferAttachmentParameterivEXT = procedure(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateTextureMipmapEXT = procedure(texture: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenerateMultiTexMipmapEXT = procedure(texunit: GLenum; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferDrawBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferDrawBuffersEXT = procedure(framebuffer: GLuint; n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFramebufferReadBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFramebufferParameterivEXT = procedure(framebuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedRenderbufferStorageMultisampleEXT = procedure(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedRenderbufferStorageMultisampleCoverageEXT = procedure(renderbuffer: GLuint; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTextureEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTextureLayerEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNamedFramebufferTextureFaceEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTextureRenderbufferEXT = procedure(texture: GLuint; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexRenderbufferEXT = procedure(texunit: GLenum; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix2x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix3x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformMatrix4x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_separate_shader_objects + TglUseShaderProgramEXT = procedure(_type: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglActiveProgramEXT = procedure(_program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCreateShaderProgramEXT = function(_type: GLenum; const _string: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_shader_image_load_store + TglBindImageTextureEXT = procedure(index: GLuint; texture: GLuint; level: GLint; layered: GLboolean; layer: GLint; access: GLenum; format: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMemoryBarrierEXT = procedure(barriers: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_EXT_vertex_attrib_64bit + TglVertexAttribL1dEXT = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLPointerEXT = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribLdvEXT = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayVertexAttribLOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_IBM_multimode_draw_arrays + TglMultiModeDrawArraysIBM = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiModeDrawElementsIBM = procedure(const mode: PGLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_IBM_vertex_array_lists + TglColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlagPointerListIBM = procedure(stride: GLint; const _pointer: PGLboolean; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_INGR_blend_func_separate + TglBlendFuncSeparateINGR = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_INTEL_parallel_arrays + TglVertexPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalPointervINTEL = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_MESA_resize_buffers + TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_MESA_window_pos + TglWindowPos2dMESA = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fMESA = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2iMESA = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2sMESA = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3iMESA = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3sMESA = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4iMESA = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4sMESA = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_evaluators + TglMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapParameterivNV = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMapParameterfvNV = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapParameterivNV = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapParameterfvNV = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapAttribParameterivNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetMapAttribParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEvalMapsNV = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_fence + TglDeleteFencesNV = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenFencesNV = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTestFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFenceivNV = procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinishFenceNV = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSetFenceNV = procedure(fence: GLuint; condition: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_fragment_program + TglProgramNamedParameter4fNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramNamedParameter4dNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramNamedParameter4fvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramNamedParameter4dvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramNamedParameterfvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramNamedParameterdvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_half_float + TglVertex2hNV = procedure(x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3hNV = procedure(nx: GLhalfNV; ny: GLhalfNV; nz: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV; alpha: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1hNV = procedure(s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2hNV = procedure(s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1hNV = procedure(target: GLenum; s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord1hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord2hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord3hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMultiTexCoord4hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordhNV = procedure(fog: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexWeighthNV = procedure(weight: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1hNV = procedure(index: GLuint; x: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs1hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs2hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs3hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs4hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_occlusion_query + TglGenOcclusionQueriesNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteOcclusionQueriesNV = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsOcclusionQueryNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBeginOcclusionQueryNV = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetOcclusionQueryivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetOcclusionQueryuivNV = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_pixel_data_range + TglPixelDataRangeNV = procedure(target: GLenum; length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFlushPixelDataRangeNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_point_sprite + TglPointParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_primitive_restart + TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPrimitiveRestartIndexNV = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_register_combiners + TglCombinerParameterfvNV = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCombinerParameterfNV = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCombinerParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCombinerParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCombinerInputNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCombinerOutputNV = procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinalCombinerInputNV = procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCombinerInputParameterfvNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCombinerInputParameterivNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCombinerOutputParameterfvNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCombinerOutputParameterivNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFinalCombinerInputParameterfvNV = procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFinalCombinerInputParameterivNV = procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_register_combiners2 + TglCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vertex_array_range + TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexArrayRangeNV = procedure(length: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vertex_program + TglAreProgramsResidentNV = function(n: GLsizei; const programs: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindProgramNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglExecuteProgramNV = procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenProgramsNV = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramParameterdvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramStringNV = procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTrackMatrixivNV = procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribdvNV = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribfvNV = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribivNV = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribPointervNV = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsProgramNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadProgramNV = procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameter4dNV = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameter4dvNV = procedure(target: GLenum; index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameter4fNV = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameter4fvNV = procedure(target: GLenum; index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameters4dvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramParameters4fvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglRequestResidentProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTrackMatrixNV = procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribPointerNV = procedure(index: GLuint; fsize: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1dNV = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fNV = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1sNV = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib1svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2sNV = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib2svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib3svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ubNV = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttrib4ubvNV = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs1dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs1fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs1svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs2dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs2fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs2svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs3dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs3fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs3svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs4dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs4fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs4svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribs4ubvNV = procedure(index: GLuint; count: GLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_depth_buffer_float + TglDepthRangedNV = procedure(n: GLdouble; f: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglClearDepthdNV = procedure(d: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDepthBoundsdNV = procedure(zmin: GLdouble; zmax: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_framebuffer_multisample_coverage + TglRenderbufferStorageMultsampleCoverageNV = procedure(target: GLenum; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_geometry_program4 + TglProgramVertexLimitNV = procedure(target: GLenum; limit: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_gpu_program4 + TglProgramLocalParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramLocalParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramEnvParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramLocalParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramLocalParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramEnvParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramEnvParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_parameter_buffer_object + TglProgramBufferParametersfvNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramBufferParametersIivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramBufferParametersIuivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_transform_feedback + TglBeginTransformFeedbackNV = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackAttribsNV = procedure(count: GLsizei; const attribs: GLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackVaryingsNV = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglActiveVaryingNV = procedure(program_: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVaryingLocationNV = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetActiveVaryingNV = procedure(program_: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTransformFeedbackVaryingNV = procedure(program_: GLuint; index: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformFeedbackStreamAttribsNV = procedure(count: GLsizei; const attribs: PGLint; nbuffers: GLsizei; const bufstreams: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_conditional_render + TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_present_video + TglPresentFrameKeyedNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDuratioId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; key0: GLuint; target1: GLenum; fill1: GLuint; key1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPresentFrameDualFillNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDurationId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; target1: GLenum; fill1: GLuint; target2: GLenum; fill2: GLuint; target3: GLenum; fill3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} +// TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_explicit_multisample + TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_transform_feedback2 + TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_video_capture + TglBeginVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindVideoCaptureStreamBufferNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; offset: GLintptrARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindVideoCaptureStreamTextureNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEndVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoCaptureivNV = procedure(video_capture_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoCaptureStreamivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoCaptureStreamfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVideoCaptureStreamdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVideoCaptureNV = function(video_capture_slot: GLuint; sequence_num: PGLuint; capture_time: PGLuint64EXT): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVideoCaptureStreamParameterivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVideoCaptureStreamParameterfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVideoCaptureStreamParameterdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_copy_image + TglCopyImageSubDataNV = 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; width: GLsizei; height: GLsizei; depth: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_shader_buffer_load + TglMakeBufferResidentNV = procedure(target: GLenum; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeBufferNonResidentNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsBufferResidentNV = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeNamedBufferResidentNV = procedure(buffer: GLuint; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeNamedBufferNonResidentNV = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsNamedBufferResidentNV = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetBufferParameterui64vNV = procedure(target: GLenum; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetNamedBufferParameterui64vNV = procedure(buffer: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegerui64vNV = procedure(value: GLenum; result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformui64NV = procedure(location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformui64vNV = procedure(_program: GLuint; location: GLint; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformui64NV = procedure(_program: GLuint; location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformui64vNV = procedure(_program: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vertex_buffer_unified_memory + TglBufferAddressRangeNV = procedure(pname: GLenum; index: GLuint; adress: GLuint64EXT; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormalFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIndexFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoordFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglEdgeFlagFormatNV = procedure(stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSecondaryColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFogCoordFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribIFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegerui64i_vNV = procedure(value: GLenum; index: GLuint; Result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_gpu_program5 + TglProgramSubroutineParametersuivNV = procedure(target: GLenum; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetProgramSubroutineParameteruivNV = procedure(target: GLenum; index: GLuint; param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_gpu_shader5 + TglUniform1i64NV = procedure(location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1ui64NV = procedure(location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform1ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform2ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform3ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniform4ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetUniformi64vNV = procedure(program_: GLuint; location: GLint; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform1ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform2ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform3ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniform4ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vertex_attrib_integer_64bit + TglVertexAttribL1i64NV = procedure(index: GLuint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1ui64NV = procedure(index: GLuint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL1ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL2ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL3ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribL4ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribLi64vNV = procedure(index: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetVertexAttribLui64vNV = procedure(index: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVertexAttribLFormatNV = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_vdpau_interop + TglVDPAUInitNV = procedure(const vdpDevice: PGLvoid; const getProcAddress: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUFiniNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAURegisterVideoSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAURegisterOutputSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUIsSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUUnregisterSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUGetSurfaceivNV = procedure(surface: GLvdpauSurfaceNV; pname: GLenum; bufSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUSurfaceAccessNV = procedure(surface: GLvdpauSurfaceNV; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUMapSurfacesNV = procedure(numSurfaces: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglVDPAUUnmapSurfacesNV = procedure(numSurface: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_texture_barrier + TglTextureBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // (4.3) + // GL_NV_path_rendering + TglGenPathsNV = function(range : GLsizei) : GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeletePathsNV = procedure(path : GLUInt; range : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsPathNV = function(path : GLUInt) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathCommandsNV = procedure(path : GLUInt; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLsizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathCoordsNV = procedure(path : GLUInt; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathSubCommandsNV = procedure(path : GLUInt; commandStart : GLsizei; commandsToDelete : GLsizei; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathSubCoordsNV = procedure(path : GLUInt; coordStart : GLsizei; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathStringNV = procedure(path : GLUInt; format : GLenum; length : GLsizei; const pathString : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathGlyphsNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; numGlyphs : GLsizei; type_ : GLenum; const charcodes : PGLvoid; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathGlyphRangeNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; firstGlyph : GLuint; numGlyphs : GLsizei; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglWeightPathsNV = procedure(resultPath : GLUInt; numPaths : GLSizei; const paths : PGLuint; const weights : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyPathNV = procedure(resultPath : GLUInt; srcPath : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInterpolatePathsNV = procedure(resultPath : GLUInt; pathA : GLUInt; pathB : GLUInt; weight : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTransformPathNV = procedure(resultPath : GLUInt; srcPath : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathParameteriNV = procedure(path : GLUInt; pname : GLEnum; value : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathParameterfNV = procedure(path : GLUInt; pname : GLEnum; value : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathDashArrayNV = procedure(path : GLUInt; dashCount : GLsizei; const dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathStencilFuncNV = procedure(func : GLenum; ref : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathStencilDepthOffsetNV = procedure(factor : GLfloat; units : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFillPathNV = procedure(path : GLUInt; fillMode : GLenum; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilStrokePathNV = procedure(path : GLUInt; reference : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; fillMode : GLenum; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStencilStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; reference : GLint; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathCoverDepthFuncNV = procedure(func : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathColorGenNV = procedure(color : GLenum; genMode : GLenum; colorFormat : GLenum; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathTexGenNV = procedure(texCoordSet : GLenum; genMode : GLenum; components : GLint; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPathFogGenNV = procedure(genMode : GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCoverFillPathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCoverStrokePathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCoverFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCoverStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathCommandsNV = procedure(path : GLUInt; commands : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathCoordsNV = procedure(path : GLUInt; coords : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathDashArrayNV = procedure(path : GLUInt; dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathMetricsNV = procedure(metricQueryMask : GLbitfield; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathMetricRangeNV = procedure(metricQueryMask : GLbitfield; firstPathName : GLuint; numPaths : GLSizei; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathSpacingNV = procedure(pathListMode : GLenum; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; advanceScale : GLfloat; kerningScale : GLfloat; transformType : GLenum; returnedSpacing : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathColorGenivNV = procedure(color : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathColorGenfvNV = procedure(color : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathTexGenivNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathTexGenfvNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsPointInFillPathNV = function(path : GLUInt; mask : GLuint; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsPointInStrokePathNV = function (path : GLUInt; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPathLengthNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei) : GLfloat; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointAlongPathNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei; distance : GLfloat; x : PGLfloat; y : PGLfloat; tangentX : PGLfloat; tangentY : PGLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_pinned_memory + + // GL_AMD_stencil_operation_extended + TglStencilOpValueAMD = procedure(face : GLEnum; value : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_AMD_vertex_shader_viewport_index + + // GL_AMD_vertex_shader_layer + + // GL_NV_bindless_texture + TglGetTextureHandleNV = function(texture : GLuint ) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTextureSamplerHandleNV = function(texture : GLuint; sampler : GLuint) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeTextureHandleResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeTextureHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetImageHandleNV = function(texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeImageHandleResidentNV = procedure(handle : GLUint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglMakeImageHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformHandleui64NV = procedure(location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglUniformHandleui64vNV = procedure(location : GLint; cowunt : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformHandleui64NV = procedure(program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglProgramUniformHandleui64vNV = procedure(program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsTextureHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsImageHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_NV_shader_atomic_float + + // GL_AMD_query_buffer_object + + // + + // GL_PGI_misc_hints + TglHintPGI = procedure(target: GLenum; mode: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_detail_texture + TglDetailTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetDetailTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_fog_function + TglFogFuncSGIS = procedure(n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFogFuncSGIS = procedure(points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_multisample + TglSampleMaskSGIS = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSamplePatternSGIS = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_pixel_texture + TglPixelTexGenParameteriSGIS = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTexGenParameterivSGIS = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTexGenParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelTexGenParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPixelTexGenParameterivSGIS = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetPixelTexGenParameterfvSGIS = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_point_parameters + TglPointParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPointParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_sharpen_texture + TglSharpenTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetSharpenTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_texture4D + TglTexImage4DSGIS = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexSubImage4DSGIS = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; woffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_texture_color_mask + TglTextureColorMaskSGIS = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIS_texture_filter4 + TglGetTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; n: GLsizei; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_async + TglAsyncMarkerSGIX = procedure(marker: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFinishAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPollAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenAsyncMarkersSGIX = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteAsyncMarkersSGIX = procedure(marker: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglIsAsyncMarkerSGIX = function(marker: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_flush_raster + TglFlushRasterSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_fragment_lighting + TglFragmentColorMaterialSGIX = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightfSGIX = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightiSGIX = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightModelfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightModelfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightModeliSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentLightModelivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentMaterialfSGIX = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentMaterialiSGIX = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLightEnviSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_framezoom + TglFrameZoomSGIX = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_igloo_interface + TglIglooInterfaceSGIX = procedure(pname: GLenum; const params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_instruments + TglGetInstrumentsSGIX = function(): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglInstrumentsBufferSGIX = procedure(size: GLsizei; buffer: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPollInstrumentsSGIX = function(marker_p: PGLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStartInstrumentsSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglStopInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_list_priority + TglGetListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetListParameterivSGIX = procedure(list: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglListParameterfSGIX = procedure(list: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglListParameteriSGIX = procedure(list: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglListParameterivSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_pixel_texture + TglPixelTexGenSGIX = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_polynomial_ffd + TglDeformationMap3dSGIX = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; w1: GLdouble; w2: GLdouble; wstride: GLint; worder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeformationMap3fSGIX = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; w1: GLfloat; w2: GLfloat; wstride: GLint; worder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeformSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglLoadIdentityDeformationMapSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_reference_plane + TglReferencePlaneSGIX = procedure(const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_sprite + TglSpriteParameterfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSpriteParameterfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSpriteParameteriSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglSpriteParameterivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGIX_tag_sample_buffer + TglTagSampleBufferSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SGI_color_table + TglColorTableSGI = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCopyColorTableSGI = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableSGI = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SUNX_constant_data + TglFinishTextureSUNX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SUN_global_alpha + TglGlobalAlphaFactorbSUN = procedure(factor: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactorsSUN = procedure(factor: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactoriSUN = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactorfSUN = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactordSUN = procedure(factor: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactorubSUN = procedure(factor: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactorusSUN = procedure(factor: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGlobalAlphaFactoruiSUN = procedure(factor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SUN_mesh_array + TglDrawMeshArraysSUN = procedure(mode: GLenum; first: GLint; count: GLsizei; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SUN_triangle_list + TglReplacementCodeuiSUN = procedure(code: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeusSUN = procedure(code: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeubSUN = procedure(code: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuivSUN = procedure(const code: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeusvSUN = procedure(const code: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeubvSUN = procedure(const code: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodePointerSUN = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // GL_SUN_vertex + TglColor4ubVertex2fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ubVertex2fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ubVertex3fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4ubVertex3fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor3fVertex3fvSUN = procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3fVertex3fSUN = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglNormal3fVertex3fvSUN = procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4fNormal3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglColor4fNormal3fVertex3fvSUN = procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fVertex3fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4fVertex4fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor4ubVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor4ubVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor4fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4fColor4fNormal3fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexCoord4fColor4fNormal3fVertex4fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiVertex3fSUN = procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiVertex3fvSUN = procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor4ubVertex3fSUN = procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor4ubVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiNormal3fVertex3fSUN = procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + // window support functions +{$IFDEF DGL_WIN} + TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall; + TwglCopyContext = function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall; + TwglCreateContext = function(DC: HDC): HGLRC; stdcall; + TwglCreateLayerContext = function(p1: HDC; p2: Integer): HGLRC; stdcall; + TwglDeleteContext = function(p1: HGLRC): BOOL; stdcall; + TwglDescribeLayerPlane = function(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall; + TwglGetCurrentContext = function: HGLRC; stdcall; + TwglGetCurrentDC = function: HDC; stdcall; + TwglGetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; + TwglMakeCurrent = function(DC: HDC; p2: HGLRC): BOOL; stdcall; + TwglRealizeLayerPalette = function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall; + TwglSetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; + TwglShareLists = function(p1, p2: HGLRC): BOOL; stdcall; + TwglSwapLayerBuffers = function(p1: HDC; p2: Cardinal): BOOL; stdcall; + TwglSwapMultipleBuffers = function(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall; + TwglUseFontBitmapsA = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; + TwglUseFontBitmapsW = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; + TwglUseFontBitmaps = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; + + TwglUseFontOutlinesA = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; + TwglUseFontOutlinesW = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; + TwglUseFontOutlines = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; + + + // WGL_ARB_buffer_region + TwglCreateBufferRegionARB = function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; stdcall; + TwglDeleteBufferRegionARB = procedure(hRegion: THandle); stdcall; + TwglSaveBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): Boolean; stdcall; + TwglRestoreBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): Boolean; stdcall; + + // WGL_ARB_extensions_string + TwglGetExtensionsStringARB = function(hdc: HDC): PAnsiChar; stdcall; + + // WGL_ARB_make_current_read + TwglMakeContextCurrentARB = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall; + TwglGetCurrentReadDCARB = function(): HDC; stdcall; + + // WGL_ARB_pbuffer + TwglCreatePbufferARB = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFERARB; stdcall; + TwglGetPbufferDCARB = function(hPbuffer: HPBUFFERARB): HDC; stdcall; + TwglReleasePbufferDCARB = function(hPbuffer: HPBUFFERARB; hDC: HDC): GLint; stdcall; + TwglDestroyPbufferARB = function(hPbuffer: HPBUFFERARB): Boolean; stdcall; + TwglQueryPbufferARB = function(hPbuffer: HPBUFFERARB; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; + + // WGL_ARB_pixel_format + TwglGetPixelFormatAttribivARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): Boolean; stdcall; + TwglGetPixelFormatAttribfvARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall; + TwglChoosePixelFormatARB = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; stdcall; + + // WGL_ARB_color_buffer_float + TwglClampColorARB = procedure(target: GLenum; clamp: GLenum); stdcall; + + // WGL_ARB_render_texture + TwglBindTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall; + TwglReleaseTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall; + TwglSetPbufferAttribARB = function(hPbuffer: HPBUFFERARB; const piAttribList: PGLint): Boolean; stdcall; + + // WGL_ARB_create_context + TwglCreateContextAttribsARB = function(hDC: HDC; hShareContext: HGLRC; const attribList: PGLint): HGLRC; stdcall; + + // WGL_AMD_gpu_association + TwglGetGPUIDsAMD = function(maxCount: Cardinal; ids: PCardinal): Cardinal; stdcall; + TwglGetGPUInfoAMD = function(id: Cardinal; property_: Integer; dataType: GLenum; size: Cardinal; data: Pointer): Integer; stdcall; + TwglGetContextGPUIDAMD = function(hglrc: HGLRC): Cardinal; stdcall; + TwglCreateAssociatedContextAMD = function(id: Cardinal): HGLRC; stdcall; + TwglCreateAssociatedContextAttribsAMD = function(id: Cardinal; hShareContext: HGLRC; const attribList: PInteger): HGLRC; stdcall; + TwglDeleteAssociatedContextAMD = function(hglrc: HGLRC): Boolean; stdcall; + TwglMakeAssociatedContextCurrentAMD = function(hglrc: HGLRC): Boolean; stdcall; + TwglGetCurrentAssociatedContextAMD = function(): HGLRC; stdcall; + TwglBlitContextFramebufferAMD = procedure(dstCtx: HGLRC; srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); stdcall; + + // WGL_EXT_display_color_table + TwglCreateDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall; + TwglLoadDisplayColorTableEXT = function(const table: PGLushort; length: GLuint): GLboolean; stdcall; + TwglBindDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall; + TwglDestroyDisplayColorTableEXT = procedure(id: GLushort); stdcall; + + // WGL_EXT_extensions_string + TwglGetExtensionsStringEXT = function(): PAnsiChar; stdcall; + + // WGL_EXT_make_current_read + TwglMakeContextCurrentEXT = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall; + TwglGetCurrentReadDCEXT = function(): HDC; stdcall; + + // WGL_EXT_pbuffer + TwglCreatePbufferEXT = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFEREXT; stdcall; + TwglGetPbufferDCEXT = function(hPbuffer: HPBUFFEREXT): HDC; stdcall; + TwglReleasePbufferDCEXT = function(hPbuffer: HPBUFFEREXT; hDC: HDC): GLint; stdcall; + TwglDestroyPbufferEXT = function(hPbuffer: HPBUFFEREXT): Boolean; stdcall; + TwglQueryPbufferEXT = function(hPbuffer: HPBUFFEREXT; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; + + // WGL_EXT_pixel_format + TwglGetPixelFormatAttribivEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): Boolean; stdcall; + TwglGetPixelFormatAttribfvEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall; + TwglChoosePixelFormatEXT = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): Boolean; stdcall; + + // WGL_EXT_swap_control + TwglSwapIntervalEXT = function(interval: GLint): Boolean; stdcall; + TwglGetSwapIntervalEXT = function(): GLint; stdcall; + + // WGL_I3D_digital_video_control + TwglGetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; + TwglSetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall; + + // WGL_I3D_gamma + TwglGetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; + TwglSetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall; + TwglGetGammaTableI3D = function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): Boolean; stdcall; + TwglSetGammaTableI3D = function(hDC: HDC; iEntries: GLint; const puRed: PGLushort; const puGreen: PGLushort; const puBlue: PGLushort): Boolean; stdcall; + + // WGL_I3D_genlock + TwglEnableGenlockI3D = function(hDC: HDC): Boolean; stdcall; + TwglDisableGenlockI3D = function(hDC: HDC): Boolean; stdcall; + TwglIsEnabledGenlockI3D = function(hDC: HDC; pFlag: Boolean): Boolean; stdcall; + TwglGenlockSourceI3D = function(hDC: HDC; uSource: GLuint): Boolean; stdcall; + TwglGetGenlockSourceI3D = function(hDC: HDC; uSource: PGLuint): Boolean; stdcall; + TwglGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: GLuint): Boolean; stdcall; + TwglGetGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: PGLuint): Boolean; stdcall; + TwglGenlockSampleRateI3D = function(hDC: HDC; uRate: GLuint): Boolean; stdcall; + TwglGetGenlockSampleRateI3D = function(hDC: HDC; uRate: PGLuint): Boolean; stdcall; + TwglGenlockSourceDelayI3D = function(hDC: HDC; uDelay: GLuint): Boolean; stdcall; + TwglGetGenlockSourceDelayI3D = function(hDC: HDC; uDelay: PGLuint): Boolean; stdcall; + TwglQueryGenlockMaxSourceDelayI3D = function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): Boolean; stdcall; + + // WGL_I3D_image_buffer + TwglCreateImageBufferI3D = function(hDC: HDC; dwSize: GLuint; uFlags: GLuint): GLvoid; stdcall; + TwglDestroyImageBufferI3D = function(hDC: HDC; pAddress: GLvoid): Boolean; stdcall; + TwglAssociateImageBufferEventsI3D = function(hDC: HDC; const pEvent: THandle; const pAddress: PGLvoid; const pSize: PGLuint; count: GLuint): Boolean; stdcall; + TwglReleaseImageBufferEventsI3D = function(hDC: HDC; const pAddress: PGLvoid; count: GLuint): Boolean; stdcall; + + // WGL_I3D_swap_frame_lock + TwglEnableFrameLockI3D = function(): Boolean; stdcall; + TwglDisableFrameLockI3D = function(): Boolean; stdcall; + TwglIsEnabledFrameLockI3D = function(pFlag: Boolean): Boolean; stdcall; + TwglQueryFrameLockMasterI3D = function(pFlag: Boolean): Boolean; stdcall; + + // WGL_I3D_swap_frame_usage + TwglGetFrameUsageI3D = function(pUsage: PGLfloat): Boolean; stdcall; + TwglBeginFrameTrackingI3D = function(): Boolean; stdcall; + TwglEndFrameTrackingI3D = function(): Boolean; stdcall; + TwglQueryFrameTrackingI3D = function(pFrameCount: PGLuint; pMissedFrames: PGLuint; pLastMissedUsage: PGLfloat): Boolean; stdcall; + + // WGL_NV_vertex_array_range + TwglAllocateMemoryNV = procedure(size: GLsizei; readfreq: GLfloat; writefreq: GLfloat; priority: GLfloat); stdcall; + TwglFreeMemoryNV = procedure(_pointer: Pointer); stdcall; + + // WGL_NV_present_video + TwglEnumerateVideoDevicesNV = function(hdc: HDC; phDeviceList: PHVIDEOOUTPUTDEVICENV): Integer; stdcall; + TwglBindVideoDeviceNV = function(hd: HDC; uVideoSlot: Cardinal; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: PInteger): Boolean; stdcall; + TwglQueryCurrentContextNV = function(iAttribute: Integer; piValue: PInteger): Boolean; stdcall; + + // WGL_NV_video_output + TwglGetVideoDeviceNV = function(hDC: HDC; numDevices: Integer; hVideoDevice: PHPVIDEODEV): Boolean; stdcall; + TwglReleaseVideoDeviceNV = function(hVideoDevice: HPVIDEODEV): Boolean; stdcall; + TwglBindVideoImageNV = function(hVideoDevice: HPVIDEODEV; hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall; + TwglReleaseVideoImageNV = function(hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall; + TwglSendPbufferToVideoNV = function(hPbuffer: HPBUFFERARB; iBufferType: Integer; pulCounterPbuffer: PCardinal; bBlock: Boolean): Boolean; stdcall; + TwglGetVideoInfoNV = function(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: PCardinal; pulCounterOutputVideo: PCardinal): Boolean; stdcall; + + // WGL_NV_swap_group + TwglJoinSwapGroupNV = function(hDC: HDC; group: GLuint): Boolean; stdcall; + TwglBindSwapBarrierNV = function(group: GLuint; barrier: GLuint): Boolean; stdcall; + TwglQuerySwapGroupNV = function(hDC: HDC; group: PGLuint; barrier: PGLuint): Boolean; stdcall; + TwglQueryMaxSwapGroupsNV = function(hDC: HDC; mxGroups: PGLuint; maxBarriers: PGLuint): Boolean; stdcall; + TwglQueryFrameCountNV = function(hDC: HDC; count: PGLuint): Boolean; stdcall; + TwglResetFrameCountNV = function(hDC: HDC): Boolean; stdcall; + + // WGL_NV_gpu_affinity + TwglEnumGpusNV = function(iGpuIndex: Cardinal; phGpu: PHGPUNV): Boolean; stdcall; + TwglEnumGpuDevicesNV = function(hGpu: HGPUNV; iDeviceIndex: Cardinal; lpGpuDevice: PGPU_DEVICE): Boolean; stdcall; + TwglCreateAffinityDCNV = function(const phGpuList: PHGPUNV): HDC; stdcall; + TwglEnumGpusFromAffinityDCNV = function(hAffinityDC: HDC; iGpuIndex: Cardinal; hGpu: PHGPUNV): Boolean; stdcall; + TwglDeleteDCNV = function(hDC: HDC): Boolean; stdcall; + + // WGL_NV_video_capture + TwglBindVideoCaptureDeviceNV = function(uVideoSlot: Cardinal; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; + TwglEnumerateVideoCaptureDevicesNV = function(hDc: HDC; phDeviceList: PHVIDEOINPUTDEVICENV): Cardinal; stdcall; + TwglLockVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; + TwglQueryVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Integer; piValue: PInteger): Boolean; stdcall; + TwglReleaseVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; + + // WGL_NV_copy_image + TwglCopyImageSubDataNV = function(hSrcRc: HGLRC; srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; hDstRC: HGLRC; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei): Boolean; stdcall; + + // WGL_NV_DX_interop + TwglDXSetResourceShareHandleNV = function(dxObject : PGLVoid; hareHandle : Cardinal) : Boolean; stdcall; + TwglDXOpenDeviceNV = function(dxDevice : PGLVoid) : Cardinal; stdcall; + TwglDXCloseDeviceNV = function(hDevice : Cardinal) : Boolean; stdcall; + TwglDXRegisterObjectNV = function(hDevice : Cardinal; dxObject : PGLVoid; name : GLUInt; _type : TGLEnum; access : TGLenum) : Cardinal; stdcall; + TwglDXUnregisterObjectNV = function(hDevice : Cardinal; hObject : Cardinal) : Boolean; stdcall; + TwglDXObjectAccessNV = function(hObject : Cardinal; access : GLenum) : Boolean; stdcall; + TwglDXLockObjectsNV = function(hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall; + TwglDXUnlockObjectsNV = function (hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall; + + // WGL_OML_sync_control + TwglGetSyncValuesOML = function(hdc: HDC; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; + TwglGetMscRateOML = function(hdc: HDC; numerator: PGLint; denominator: PGLint): Boolean; stdcall; + TwglSwapBuffersMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall; + TwglSwapLayerBuffersMscOML = function(hdc: HDC; fuPlanes: GLint; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall; + TwglWaitForMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; + TwglWaitForSbcOML = function(hdc: HDC; target_sbc: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; + + // WGL_3DL_stereo_control + TwglSetStereoEmitterState3DL = function(hDC: HDC; uState: UINT): Boolean; stdcall; + + // WIN_draw_range_elements + TglDrawRangeElementsWIN = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); stdcall; + + // WIN_swap_hint + TglAddSwapHintRectWIN = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall; +{$ENDIF} + +{$IFDEF DGL_LINUX} + TglXChooseVisual = function(dpy: PDisplay; screen: GLint; attribList: PGLint): PXVisualInfo; cdecl; + TglXCopyContext = procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: GLuint); cdecl; + TglXCreateContext = function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: GLboolean): GLXContext; cdecl; + TglXCreateGLXPixmap = function(dpy: PDisplay; vis: PXVisualInfo; pixmap: Pixmap): GLXPixmap cdecl; + TglXDestroyContext = procedure(dpy: PDisplay; ctx: GLXContext); cdecl; + TglXDestroyGLXPixmap = procedure(dpy : PDisplay; pix: GLXPixmap); cdecl; + TglXGetConfig = function(dpy : PDisplay; vis: PXVisualInfo; attrib: GLint; value: PGLint): GLint; cdecl; + TglXGetCurrentContext = function: GLXContext cdecl; + TglXGetCurrentDrawable = function: GLXDrawable cdecl; + TglXIsDirect = function(dpy: PDisplay; ctx: GLXContext): glboolean; cdecl; + TglXMakeCurrent = function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): GLboolean cdecl; + TglXQueryExtension = function(dpy: PDisplay; errorBase: PGLint; eventBase: PGLint): GLboolean; cdecl; + TglXQueryVersion = function(dpy: PDisplay; major: PGLint; minor: PGLint): GLboolean cdecl; + TglXSwapBuffers = procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl; + TglXUseXFont = procedure(font: Font; first: GLint; count: GLint; listBase: GLint); cdecl; + TglXWaitGL = procedure; cdecl; + TglXWaitX = procedure; cdecl; + + TglXGetClientString = function(dpy: PDisplay; name: GLint): PGLchar; cdecl; + TglXQueryServerString = function(dpy: PDisplay; screen: GLint; name: GLint): PGLchar; cdecl; + TglXQueryExtensionsString = function(dpy: PDisplay; screen: GLint): PGLchar; cdecl; + + // GLX_VERSION_1_3 + TglXGetFBConfigs = function(dpy: PDisplay; screen: GLint; nelements: PGLint): GLXFBConfig; cdecl; + TglXChooseFBConfig = function(dpy: PDisplay; screen: GLint; attrib_list: PGLint; nelements: PGLint): GLXFBConfig; cdecl; + TglXGetFBConfigAttrib = function(dpy: PDisplay; config: GLXFBConfig; attribute: GLint; value: PGLint): glint; cdecl; + TglXGetVisualFromFBConfig = function(dpy: PDisplay; config: GLXFBConfig) : PXVisualInfo; cdecl; + TglXCreateWindow = function(dpy: PDisplay; config: GLXFBConfig; win: Window; attrib_list: PGLint): GLXWindow; cdecl; + TglXDestroyWindow = procedure(dpy: PDisplay; win: GLXWindow); cdecl; + TglXCreatePixmap = function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attrib_list: PGLint): GLXPixmap; cdecl; + + TglXDestroyPixmap = procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl; + TglXCreatePbuffer = function(dpy: PDisplay; config: GLXFBConfig; attrib_list: PGLint): GLXPbuffer; cdecl; + TglXDestroyPbuffer = procedure(dpy: PDisplay; pbuf: GLXPbuffer); cdecl; + TglXQueryDrawable = procedure(dpy: PDisplay; draw: GLXDrawable; attribute: GLint; value: PGLuint); cdecl; + TglXCreateNewContext = function(dpy: PDisplay; config: GLXFBConfig; render_type: GLint; share_list: GLXContext; direct: GLboolean): GLXContext cdecl; + TglXMakeContextCurrent = function(display: PDisplay; draw: GLXDrawable; read_: GLXDrawable; ctx: GLXContext): GLboolean; cdecl; + TglXGetCurrentReadDrawable = function: GLXDrawable; cdecl; + TglXGetCurreentDisplay = function: PDisplay; + + TglXQueryContext = function(dpy: PDisplay; ctx: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl; + TglXSelectEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: GLuint); cdecl; + TglXGetSelectedEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: PGLuint); cdecl; + + // GLX_VERSION_1_4 + TglXGetProcAddress = function(const name: PAnsiChar): pointer; cdecl; + + // GLX_ARB_get_proc_address + TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl; + + // GLX_ARB_create_context + TglXCreateContextAttribsARB = function(dpy: PDisplay; config: GLXFBConfig; share_context: GLXContext; direct: GLboolean; const attrib_list: PGLint): GLXContext; cdecl; + + // GLX_EXT_import_context + TglXGetCurrentDisplayEXT = function: PDisplay; cdecl; + TglXQueryContextInfoEXT = function(dpy: PDisplay; context: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl; + TglXGetContextIDEXT = function(const context: GLXContext): GLXContextID; cdecl; + TglXImportContextEXT = function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl; + TglXFreeContextEXT = procedure(dpy: PDisplay; context: GLXContext); cdecl; + + // GLX_EXT_texture_from_pixmap + TglXBindTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint; const attrib_list: PGLint); cdecl; + TglXReleaseTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint); cdecl; + + // GLX_EXT_swap_control + TglXSwapIntervalEXT = procedure (dpy: PDisplay; drawable: GLXDrawable; interval: GLint); cdecl; +{$ENDIF} + + // GL utility functions and procedures + TgluErrorString = function(errCode: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluGetString = function(name: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluOrtho2D = procedure(left, right, bottom, top: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluPerspective = procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluPickMatrix = procedure(x, y, width, height: GLdouble; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluLookAt = procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluProject = function(objx, objy, objz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; winx, winy, winz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluUnProject = function(winx, winy, winz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; objx, objy, objz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluScaleImage = function(format: GLEnum; widthin, heightin: GLint; typein: GLEnum; datain: Pointer; widthout, heightout: GLint; typeout: GLEnum; const dataout: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNewQuadric = function: PGLUquadric; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluDeleteQuadric = procedure(state: PGLUquadric); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluQuadricNormals = procedure(quadObject: PGLUquadric; normals: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluQuadricTexture = procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluQuadricOrientation = procedure(quadObject: PGLUquadric; orientation: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluQuadricDrawStyle = procedure(quadObject: PGLUquadric; drawStyle: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluCylinder = procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluPartialDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluSphere = procedure(quadObject: PGLUquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluQuadricCallback = procedure(quadObject: PGLUquadric; which: GLEnum; fn: TGLUQuadricErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNewTess = function: PGLUtesselator; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluDeleteTess = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessBeginPolygon = procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessBeginContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessVertex = procedure(tess: PGLUtesselator; const coords: TGLArrayd3; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessEndContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessNormal = procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluTessCallback = procedure(tess: PGLUtesselator; which: GLEnum; fn: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluGetTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNewNurbsRenderer = function: PGLUnurbs; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluDeleteNurbsRenderer = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBeginSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBeginCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluEndCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluEndSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBeginTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluEndTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluPwlCurve = procedure(nobj: PGLUnurbs; count: GLint; points: PGLfloat; stride: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNurbsCurve = procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNurbsSurface = procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluLoadSamplingMatrices = procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: TGLMatrixf4; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluGetNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNurbsCallback = procedure(nobj: PGLUnurbs; which: GLEnum; fn: TGLUNurbsErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBeginPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluNextContour = procedure(tess: PGLUtesselator; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +var + // GL_VERSION_1_0 + glCullFace: TglCullFace; + glFrontFace: TglFrontFace; + glHint: TglHint; + glLineWidth: TglLineWidth; + glPointSize: TglPointSize; + glPolygonMode: TglPolygonMode; + glScissor: TglScissor; + glTexParameterf: TglTexParameterf; + glTexParameterfv: TglTexParameterfv; + glTexParameteri: TglTexParameteri; + glTexParameteriv: TglTexParameteriv; + glTexImage1D: TglTexImage1D; + glTexImage2D: TglTexImage2D; + glDrawBuffer: TglDrawBuffer; + glClear: TglClear; + glClearColor: TglClearColor; + glClearStencil: TglClearStencil; + glClearDepth: TglClearDepth; + glStencilMask: TglStencilMask; + glColorMask: TglColorMask; + glDepthMask: TglDepthMask; + glDisable: TglDisable; + glEnable: TglEnable; + glFinish: TglFinish; + glFlush: TglFlush; + glBlendFunc: TglBlendFunc; + glLogicOp: TglLogicOp; + glStencilFunc: TglStencilFunc; + glStencilOp: TglStencilOp; + glDepthFunc: TglDepthFunc; + glPixelStoref: TglPixelStoref; + glPixelStorei: TglPixelStorei; + glReadBuffer: TglReadBuffer; + glReadPixels: TglReadPixels; + glGetBooleanv: TglGetBooleanv; + glGetDoublev: TglGetDoublev; + glGetError: TglGetError; + glGetFloatv: TglGetFloatv; + glGetIntegerv: TglGetIntegerv; + glGetString: TglGetString; + glGetTexImage: TglGetTexImage; + glGetTexParameteriv: TglGetTexParameteriv; + glGetTexParameterfv: TglGetTexParameterfv; + glGetTexLevelParameterfv: TglGetTexLevelParameterfv; + glGetTexLevelParameteriv: TglGetTexLevelParameteriv; + glIsEnabled: TglIsEnabled; + glDepthRange: TglDepthRange; + glViewport: TglViewport; + + // GL_VERSION_1_1 + glDrawArrays: TglDrawArrays; + glDrawElements: TglDrawElements; + glGetPointerv: TglGetPointerv; + glPolygonOffset: TglPolygonOffset; + glCopyTexImage1D: TglCopyTexImage1D; + glCopyTexImage2D: TglCopyTexImage2D; + glCopyTexSubImage1D: TglCopyTexSubImage1D; + glCopyTexSubImage2D: TglCopyTexSubImage2D; + glTexSubImage1D: TglTexSubImage1D; + glTexSubImage2D: TglTexSubImage2D; + glBindTexture: TglBindTexture; + glDeleteTextures: TglDeleteTextures; + glGenTextures: TglGenTextures; +{$ifdef DGL_DEPRECATED} + glAccum: TglAccum; + glAlphaFunc: TglAlphaFunc; + glAreTexturesResident: TglAreTexturesResident; + glArrayElement: TglArrayElement; + glBegin: TglBegin; + glBitmap: TglBitmap; + glCallList: TglCallList; + glCallLists: TglCallLists; + glClearAccum: TglClearAccum; + glClearIndex: TglClearIndex; + glClipPlane: TglClipPlane; + glColor3b: TglColor3b; + glColor3bv: TglColor3bv; + glColor3d: TglColor3d; + glColor3dv: TglColor3dv; + glColor3f: TglColor3f; + glColor3fv: TglColor3fv; + glColor3i: TglColor3i; + glColor3iv: TglColor3iv; + glColor3s: TglColor3s; + glColor3sv: TglColor3sv; + glColor3ub: TglColor3ub; + glColor3ubv: TglColor3ubv; + glColor3ui: TglColor3ui; + glColor3uiv: TglColor3uiv; + glColor3us: TglColor3us; + glColor3usv: TglColor3usv; + glColor4b: TglColor4b; + glColor4bv: TglColor4bv; + glColor4d: TglColor4d; + glColor4dv: TglColor4dv; + glColor4f: TglColor4f; + glColor4fv: TglColor4fv; + glColor4i: TglColor4i; + glColor4iv: TglColor4iv; + glColor4s: TglColor4s; + glColor4sv: TglColor4sv; + glColor4ub: TglColor4ub; + glColor4ubv: TglColor4ubv; + glColor4ui: TglColor4ui; + glColor4uiv: TglColor4uiv; + glColor4us: TglColor4us; + glColor4usv: TglColor4usv; + glColorMaterial: TglColorMaterial; + glColorPointer: TglColorPointer; + glCopyPixels: TglCopyPixels; + glDeleteLists: TglDeleteLists; + glDisableClientState: TglDisableClientState; + glDrawPixels: TglDrawPixels; + glEdgeFlag: TglEdgeFlag; + glEdgeFlagPointer: TglEdgeFlagPointer; + glEdgeFlagv: TglEdgeFlagv; + glEnableClientState: TglEnableClientState; + glEnd: TglEnd; + glEndList: TglEndList; + glEvalCoord1d: TglEvalCoord1d; + glEvalCoord1dv: TglEvalCoord1dv; + glEvalCoord1f: TglEvalCoord1f; + glEvalCoord1fv: TglEvalCoord1fv; + glEvalCoord2d: TglEvalCoord2d; + glEvalCoord2dv: TglEvalCoord2dv; + glEvalCoord2f: TglEvalCoord2f; + glEvalCoord2fv: TglEvalCoord2fv; + glEvalMesh1: TglEvalMesh1; + glEvalMesh2: TglEvalMesh2; + glEvalPoint1: TglEvalPoint1; + glEvalPoint2: TglEvalPoint2; + glFeedbackBuffer: TglFeedbackBuffer; + glFogf: TglFogf; + glFogfv: TglFogfv; + glFogi: TglFogi; + glFogiv: TglFogiv; + glFrustum: TglFrustum; + glGenLists: TglGenLists; + glGetClipPlane: TglGetClipPlane; + glGetLightfv: TglGetLightfv; + glGetLightiv: TglGetLightiv; + glGetMapdv: TglGetMapdv; + glGetMapfv: TglGetMapfv; + glGetMapiv: TglGetMapiv; + glGetMaterialfv: TglGetMaterialfv; + glGetMaterialiv: TglGetMaterialiv; + glGetPixelMapfv: TglGetPixelMapfv; + glGetPixelMapuiv: TglGetPixelMapuiv; + glGetPixelMapusv: TglGetPixelMapusv; + glGetPolygonStipple: TglGetPolygonStipple; + glGetTexEnvfv: TglGetTexEnvfv; + glGetTexEnviv: TglGetTexEnviv; + glGetTexGendv: TglGetTexGendv; + glGetTexGenfv: TglGetTexGenfv; + glGetTexGeniv: TglGetTexGeniv; + glIndexMask: TglIndexMask; + glIndexPointer: TglIndexPointer; + glIndexd: TglIndexd; + glIndexdv: TglIndexdv; + glIndexf: TglIndexf; + glIndexfv: TglIndexfv; + glIndexi: TglIndexi; + glIndexiv: TglIndexiv; + glIndexs: TglIndexs; + glIndexsv: TglIndexsv; + glIndexub: TglIndexub; + glIndexubv: TglIndexubv; + glInitNames: TglInitNames; + glInterleavedArrays: TglInterleavedArrays; + glIsList: TglIsList; + glIsTexture: TglIsTexture; + glLightModelf: TglLightModelf; + glLightModelfv: TglLightModelfv; + glLightModeli: TglLightModeli; + glLightModeliv: TglLightModeliv; + glLightf: TglLightf; + glLightfv: TglLightfv; + glLighti: TglLighti; + glLightiv: TglLightiv; + glLineStipple: TglLineStipple; + glListBase: TglListBase; + glLoadIdentity: TglLoadIdentity; + glLoadMatrixd: TglLoadMatrixd; + glLoadMatrixf: TglLoadMatrixf; + glLoadName: TglLoadName; + glMap1d: TglMap1d; + glMap1f: TglMap1f; + glMap2d: TglMap2d; + glMap2f: TglMap2f; + glMapGrid1d: TglMapGrid1d; + glMapGrid1f: TglMapGrid1f; + glMapGrid2d: TglMapGrid2d; + glMapGrid2f: TglMapGrid2f; + glMaterialf: TglMaterialf; + glMaterialfv: TglMaterialfv; + glMateriali: TglMateriali; + glMaterialiv: TglMaterialiv; + glMatrixMode: TglMatrixMode; + glMultMatrixd: TglMultMatrixd; + glMultMatrixf: TglMultMatrixf; + glNewList: TglNewList; + glNormal3b: TglNormal3b; + glNormal3bv: TglNormal3bv; + glNormal3d: TglNormal3d; + glNormal3dv: TglNormal3dv; + glNormal3f: TglNormal3f; + glNormal3fv: TglNormal3fv; + glNormal3i: TglNormal3i; + glNormal3iv: TglNormal3iv; + glNormal3s: TglNormal3s; + glNormal3sv: TglNormal3sv; + glNormalPointer: TglNormalPointer; + glOrtho: TglOrtho; + glPassThrough: TglPassThrough; + glPixelMapfv: TglPixelMapfv; + glPixelMapuiv: TglPixelMapuiv; + glPixelMapusv: TglPixelMapusv; + glPixelTransferf: TglPixelTransferf; + glPixelTransferi: TglPixelTransferi; + glPixelZoom: TglPixelZoom; + glPolygonStipple: TglPolygonStipple; + glPopAttrib: TglPopAttrib; + glPopClientAttrib: TglPopClientAttrib; + glPopMatrix: TglPopMatrix; + glPopName: TglPopName; + glPrioritizeTextures: TglPrioritizeTextures; + glPushAttrib: TglPushAttrib; + glPushClientAttrib: TglPushClientAttrib; + glPushMatrix: TglPushMatrix; + glPushName: TglPushName; + glRasterPos2d: TglRasterPos2d; + glRasterPos2dv: TglRasterPos2dv; + glRasterPos2f: TglRasterPos2f; + glRasterPos2fv: TglRasterPos2fv; + glRasterPos2i: TglRasterPos2i; + glRasterPos2iv: TglRasterPos2iv; + glRasterPos2s: TglRasterPos2s; + glRasterPos2sv: TglRasterPos2sv; + glRasterPos3d: TglRasterPos3d; + glRasterPos3dv: TglRasterPos3dv; + glRasterPos3f: TglRasterPos3f; + glRasterPos3fv: TglRasterPos3fv; + glRasterPos3i: TglRasterPos3i; + glRasterPos3iv: TglRasterPos3iv; + glRasterPos3s: TglRasterPos3s; + glRasterPos3sv: TglRasterPos3sv; + glRasterPos4d: TglRasterPos4d; + glRasterPos4dv: TglRasterPos4dv; + glRasterPos4f: TglRasterPos4f; + glRasterPos4fv: TglRasterPos4fv; + glRasterPos4i: TglRasterPos4i; + glRasterPos4iv: TglRasterPos4iv; + glRasterPos4s: TglRasterPos4s; + glRasterPos4sv: TglRasterPos4sv; + glRectd: TglRectd; + glRectdv: TglRectdv; + glRectf: TglRectf; + glRectfv: TglRectfv; + glRecti: TglRecti; + glRectiv: TglRectiv; + glRects: TglRects; + glRectsv: TglRectsv; + glRenderMode: TglRenderMode; + glRotated: TglRotated; + glRotatef: TglRotatef; + glScaled: TglScaled; + glScalef: TglScalef; + glSelectBuffer: TglSelectBuffer; + glShadeModel: TglShadeModel; + glTexCoord1d: TglTexCoord1d; + glTexCoord1dv: TglTexCoord1dv; + glTexCoord1f: TglTexCoord1f; + glTexCoord1fv: TglTexCoord1fv; + glTexCoord1i: TglTexCoord1i; + glTexCoord1iv: TglTexCoord1iv; + glTexCoord1s: TglTexCoord1s; + glTexCoord1sv: TglTexCoord1sv; + glTexCoord2d: TglTexCoord2d; + glTexCoord2dv: TglTexCoord2dv; + glTexCoord2f: TglTexCoord2f; + glTexCoord2fv: TglTexCoord2fv; + glTexCoord2i: TglTexCoord2i; + glTexCoord2iv: TglTexCoord2iv; + glTexCoord2s: TglTexCoord2s; + glTexCoord2sv: TglTexCoord2sv; + glTexCoord3d: TglTexCoord3d; + glTexCoord3dv: TglTexCoord3dv; + glTexCoord3f: TglTexCoord3f; + glTexCoord3fv: TglTexCoord3fv; + glTexCoord3i: TglTexCoord3i; + glTexCoord3iv: TglTexCoord3iv; + glTexCoord3s: TglTexCoord3s; + glTexCoord3sv: TglTexCoord3sv; + glTexCoord4d: TglTexCoord4d; + glTexCoord4dv: TglTexCoord4dv; + glTexCoord4f: TglTexCoord4f; + glTexCoord4fv: TglTexCoord4fv; + glTexCoord4i: TglTexCoord4i; + glTexCoord4iv: TglTexCoord4iv; + glTexCoord4s: TglTexCoord4s; + glTexCoord4sv: TglTexCoord4sv; + glTexCoordPointer: TglTexCoordPointer; + glTexEnvf: TglTexEnvf; + glTexEnvfv: TglTexEnvfv; + glTexEnvi: TglTexEnvi; + glTexEnviv: TglTexEnviv; + glTexGend: TglTexGend; + glTexGendv: TglTexGendv; + glTexGenf: TglTexGenf; + glTexGenfv: TglTexGenfv; + glTexGeni: TglTexGeni; + glTexGeniv: TglTexGeniv; + glTranslated: TglTranslated; + glTranslatef: TglTranslatef; + glVertex2d: TglVertex2d; + glVertex2dv: TglVertex2dv; + glVertex2f: TglVertex2f; + glVertex2fv: TglVertex2fv; + glVertex2i: TglVertex2i; + glVertex2iv: TglVertex2iv; + glVertex2s: TglVertex2s; + glVertex2sv: TglVertex2sv; + glVertex3d: TglVertex3d; + glVertex3dv: TglVertex3dv; + glVertex3f: TglVertex3f; + glVertex3fv: TglVertex3fv; + glVertex3i: TglVertex3i; + glVertex3iv: TglVertex3iv; + glVertex3s: TglVertex3s; + glVertex3sv: TglVertex3sv; + glVertex4d: TglVertex4d; + glVertex4dv: TglVertex4dv; + glVertex4f: TglVertex4f; + glVertex4fv: TglVertex4fv; + glVertex4i: TglVertex4i; + glVertex4iv: TglVertex4iv; + glVertex4s: TglVertex4s; + glVertex4sv: TglVertex4sv; + glVertexPointer: TglVertexPointer; +{$endif} + + // GL_VERSION_1_2 + glBlendColor: TglBlendColor; + glBlendEquation: TglBlendEquation; + glDrawRangeElements: TglDrawRangeElements; + glTexImage3D: TglTexImage3D; + glTexSubImage3D: TglTexSubImage3D; + glCopyTexSubImage3D: TglCopyTexSubImage3D; +{$ifdef DGL_DEPRECATED} + glColorTable: TglColorTable; + glColorTableParameterfv: TglColorTableParameterfv; + glColorTableParameteriv: TglColorTableParameteriv; + glCopyColorTable: TglCopyColorTable; + glGetColorTable: TglGetColorTable; + glGetColorTableParameterfv: TglGetColorTableParameterfv; + glGetColorTableParameteriv: TglGetColorTableParameteriv; + glColorSubTable: TglColorSubTable; + glCopyColorSubTable: TglCopyColorSubTable; + glConvolutionFilter1D: TglConvolutionFilter1D; + glConvolutionFilter2D: TglConvolutionFilter2D; + glConvolutionParameterf: TglConvolutionParameterf; + glConvolutionParameterfv: TglConvolutionParameterfv; + glConvolutionParameteri: TglConvolutionParameteri; + glConvolutionParameteriv: TglConvolutionParameteriv; + glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D; + glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D; + glGetConvolutionFilter: TglGetConvolutionFilter; + glGetConvolutionParameterfv: TglGetConvolutionParameterfv; + glGetConvolutionParameteriv: TglGetConvolutionParameteriv; + glGetSeparableFilter: TglGetSeparableFilter; + glSeparableFilter2D: TglSeparableFilter2D; + glGetHistogram: TglGetHistogram; + glGetHistogramParameterfv: TglGetHistogramParameterfv; + glGetHistogramParameteriv: TglGetHistogramParameteriv; + glGetMinmax: TglGetMinmax; + glGetMinmaxParameterfv: TglGetMinmaxParameterfv; + glGetMinmaxParameteriv: TglGetMinmaxParameteriv; + glHistogram: TglHistogram; + glMinmax: TglMinmax; + glResetHistogram: TglResetHistogram; + glResetMinmax: TglResetMinmax; +{$endif} + + // GL_VERSION_1_3 + glActiveTexture: TglActiveTexture; + glSampleCoverage: TglSampleCoverage; + glCompressedTexImage3D: TglCompressedTexImage3D; + glCompressedTexImage2D: TglCompressedTexImage2D; + glCompressedTexImage1D: TglCompressedTexImage1D; + glCompressedTexSubImage3D: TglCompressedTexSubImage3D; + glCompressedTexSubImage2D: TglCompressedTexSubImage2D; + glCompressedTexSubImage1D: TglCompressedTexSubImage1D; + glGetCompressedTexImage: TglGetCompressedTexImage; +{$ifdef DGL_DEPRECATED} + glClientActiveTexture: TglClientActiveTexture; + glMultiTexCoord1d: TglMultiTexCoord1d; + glMultiTexCoord1dv: TglMultiTexCoord1dv; + glMultiTexCoord1f: TglMultiTexCoord1f; + glMultiTexCoord1fv: TglMultiTexCoord1fv; + glMultiTexCoord1i: TglMultiTexCoord1i; + glMultiTexCoord1iv: TglMultiTexCoord1iv; + glMultiTexCoord1s: TglMultiTexCoord1s; + glMultiTexCoord1sv: TglMultiTexCoord1sv; + glMultiTexCoord2d: TglMultiTexCoord2d; + glMultiTexCoord2dv: TglMultiTexCoord2dv; + glMultiTexCoord2f: TglMultiTexCoord2f; + glMultiTexCoord2fv: TglMultiTexCoord2fv; + glMultiTexCoord2i: TglMultiTexCoord2i; + glMultiTexCoord2iv: TglMultiTexCoord2iv; + glMultiTexCoord2s: TglMultiTexCoord2s; + glMultiTexCoord2sv: TglMultiTexCoord2sv; + glMultiTexCoord3d: TglMultiTexCoord3d; + glMultiTexCoord3dv: TglMultiTexCoord3dv; + glMultiTexCoord3f: TglMultiTexCoord3f; + glMultiTexCoord3fv: TglMultiTexCoord3fv; + glMultiTexCoord3i: TglMultiTexCoord3i; + glMultiTexCoord3iv: TglMultiTexCoord3iv; + glMultiTexCoord3s: TglMultiTexCoord3s; + glMultiTexCoord3sv: TglMultiTexCoord3sv; + glMultiTexCoord4d: TglMultiTexCoord4d; + glMultiTexCoord4dv: TglMultiTexCoord4dv; + glMultiTexCoord4f: TglMultiTexCoord4f; + glMultiTexCoord4fv: TglMultiTexCoord4fv; + glMultiTexCoord4i: TglMultiTexCoord4i; + glMultiTexCoord4iv: TglMultiTexCoord4iv; + glMultiTexCoord4s: TglMultiTexCoord4s; + glMultiTexCoord4sv: TglMultiTexCoord4sv; + glLoadTransposeMatrixf: TglLoadTransposeMatrixf; + glLoadTransposeMatrixd: TglLoadTransposeMatrixd; + glMultTransposeMatrixf: TglMultTransposeMatrixf; + glMultTransposeMatrixd: TglMultTransposeMatrixd; +{$endif} + + // GL_VERSION_1_4 + glBlendFuncSeparate: TglBlendFuncSeparate; + glMultiDrawArrays: TglMultiDrawArrays; + glMultiDrawElements: TglMultiDrawElements; + glPointParameterf: TglPointParameterf; + glPointParameterfv: TglPointParameterfv; + glPointParameteri: TglPointParameteri; + glPointParameteriv: TglPointParameteriv; +{$ifdef DGL_DEPRECATED} + glFogCoordf: TglFogCoordf; + glFogCoordfv: TglFogCoordfv; + glFogCoordd: TglFogCoordd; + glFogCoorddv: TglFogCoorddv; + glFogCoordPointer: TglFogCoordPointer; + glSecondaryColor3b: TglSecondaryColor3b; + glSecondaryColor3bv: TglSecondaryColor3bv; + glSecondaryColor3d: TglSecondaryColor3d; + glSecondaryColor3dv: TglSecondaryColor3dv; + glSecondaryColor3f: TglSecondaryColor3f; + glSecondaryColor3fv: TglSecondaryColor3fv; + glSecondaryColor3i: TglSecondaryColor3i; + glSecondaryColor3iv: TglSecondaryColor3iv; + glSecondaryColor3s: TglSecondaryColor3s; + glSecondaryColor3sv: TglSecondaryColor3sv; + glSecondaryColor3ub: TglSecondaryColor3ub; + glSecondaryColor3ubv: TglSecondaryColor3ubv; + glSecondaryColor3ui: TglSecondaryColor3ui; + glSecondaryColor3uiv: TglSecondaryColor3uiv; + glSecondaryColor3us: TglSecondaryColor3us; + glSecondaryColor3usv: TglSecondaryColor3usv; + glSecondaryColorPointer: TglSecondaryColorPointer; + glWindowPos2d: TglWindowPos2d; + glWindowPos2dv: TglWindowPos2dv; + glWindowPos2f: TglWindowPos2f; + glWindowPos2fv: TglWindowPos2fv; + glWindowPos2i: TglWindowPos2i; + glWindowPos2iv: TglWindowPos2iv; + glWindowPos2s: TglWindowPos2s; + glWindowPos2sv: TglWindowPos2sv; + glWindowPos3d: TglWindowPos3d; + glWindowPos3dv: TglWindowPos3dv; + glWindowPos3f: TglWindowPos3f; + glWindowPos3fv: TglWindowPos3fv; + glWindowPos3i: TglWindowPos3i; + glWindowPos3iv: TglWindowPos3iv; + glWindowPos3s: TglWindowPos3s; + glWindowPos3sv: TglWindowPos3sv; +{$endif} + + // GL_VERSION_1_5 + glGenQueries: TglGenQueries; + glDeleteQueries: TglDeleteQueries; + glIsQuery: TglIsQuery; + glBeginQuery: TglBeginQuery; + glEndQuery: TglEndQuery; + glGetQueryiv: TglGetQueryiv; + glGetQueryObjectiv: TglGetQueryObjectiv; + glGetQueryObjectuiv: TglGetQueryObjectuiv; + glBindBuffer: TglBindBuffer; + glDeleteBuffers: TglDeleteBuffers; + glGenBuffers: TglGenBuffers; + glIsBuffer: TglIsBuffer; + glBufferData: TglBufferData; + glBufferSubData: TglBufferSubData; + glGetBufferSubData: TglGetBufferSubData; + glMapBuffer: TglMapBuffer; + glUnmapBuffer: TglUnmapBuffer; + glGetBufferParameteriv: TglGetBufferParameteriv; + glGetBufferPointerv: TglGetBufferPointerv; + + // GL_VERSION_2_0 + glBlendEquationSeparate: TglBlendEquationSeparate; + glDrawBuffers: TglDrawBuffers; + glStencilOpSeparate: TglStencilOpSeparate; + glStencilFuncSeparate: TglStencilFuncSeparate; + glStencilMaskSeparate: TglStencilMaskSeparate; + glAttachShader: TglAttachShader; + glBindAttribLocation: TglBindAttribLocation; + glCompileShader: TglCompileShader; + glCreateProgram: TglCreateProgram; + glCreateShader: TglCreateShader; + glDeleteProgram: TglDeleteProgram; + glDeleteShader: TglDeleteShader; + glDetachShader: TglDetachShader; + glDisableVertexAttribArray: TglDisableVertexAttribArray; + glEnableVertexAttribArray: TglEnableVertexAttribArray; + glGetActiveAttrib: TglGetActiveAttrib; + glGetActiveUniform: TglGetActiveUniform; + glGetAttachedShaders: TglGetAttachedShaders; + glGetAttribLocation: TglGetAttribLocation; + glGetProgramiv: TglGetProgramiv; + glGetProgramInfoLog: TglGetProgramInfoLog; + glGetShaderiv: TglGetShaderiv; + glGetShaderInfoLog: TglGetShaderInfoLog; + glGetShaderSource: TglGetShaderSource; + glGetUniformLocation: TglGetUniformLocation; + glGetUniformfv: TglGetUniformfv; + glGetUniformiv: TglGetUniformiv; + glGetVertexAttribfv: TglGetVertexAttribfv; + glGetVertexAttribiv: TglGetVertexAttribiv; + glGetVertexAttribPointerv: TglGetVertexAttribPointerv; + glIsProgram: TglIsProgram; + glIsShader: TglIsShader; + glLinkProgram: TglLinkProgram; + glShaderSource: TglShaderSource; + glUseProgram: TglUseProgram; + glUniform1f: TglUniform1f; + glUniform2f: TglUniform2f; + glUniform3f: TglUniform3f; + glUniform4f: TglUniform4f; + glUniform1i: TglUniform1i; + glUniform2i: TglUniform2i; + glUniform3i: TglUniform3i; + glUniform4i: TglUniform4i; + glUniform1fv: TglUniform1fv; + glUniform2fv: TglUniform2fv; + glUniform3fv: TglUniform3fv; + glUniform4fv: TglUniform4fv; + glUniform1iv: TglUniform1iv; + glUniform2iv: TglUniform2iv; + glUniform3iv: TglUniform3iv; + glUniform4iv: TglUniform4iv; + glUniformMatrix2fv: TglUniformMatrix2fv; + glUniformMatrix3fv: TglUniformMatrix3fv; + glUniformMatrix4fv: TglUniformMatrix4fv; + glValidateProgram: TglValidateProgram; + glVertexAttrib1d: TglVertexAttrib1d; + glVertexAttrib1dv: TglVertexAttrib1dv; + glVertexAttrib1f: TglVertexAttrib1f; + glVertexAttrib1fv: TglVertexAttrib1fv; + glVertexAttrib1s: TglVertexAttrib1s; + glVertexAttrib1sv: TglVertexAttrib1sv; + glVertexAttrib2d: TglVertexAttrib2d; + glVertexAttrib2dv: TglVertexAttrib2dv; + glVertexAttrib2f: TglVertexAttrib2f; + glVertexAttrib2fv: TglVertexAttrib2fv; + glVertexAttrib2s: TglVertexAttrib2s; + glVertexAttrib2sv: TglVertexAttrib2sv; + glVertexAttrib3d: TglVertexAttrib3d; + glVertexAttrib3dv: TglVertexAttrib3dv; + glVertexAttrib3f: TglVertexAttrib3f; + glVertexAttrib3fv: TglVertexAttrib3fv; + glVertexAttrib3s: TglVertexAttrib3s; + glVertexAttrib3sv: TglVertexAttrib3sv; + glVertexAttrib4Nbv: TglVertexAttrib4Nbv; + glVertexAttrib4Niv: TglVertexAttrib4Niv; + glVertexAttrib4Nsv: TglVertexAttrib4Nsv; + glVertexAttrib4Nub: TglVertexAttrib4Nub; + glVertexAttrib4Nubv: TglVertexAttrib4Nubv; + glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv; + glVertexAttrib4Nusv: TglVertexAttrib4Nusv; + glVertexAttrib4bv: TglVertexAttrib4bv; + glVertexAttrib4d: TglVertexAttrib4d; + glVertexAttrib4dv: TglVertexAttrib4dv; + glVertexAttrib4f: TglVertexAttrib4f; + glVertexAttrib4fv: TglVertexAttrib4fv; + glVertexAttrib4iv: TglVertexAttrib4iv; + glVertexAttrib4s: TglVertexAttrib4s; + glVertexAttrib4sv: TglVertexAttrib4sv; + glVertexAttrib4ubv: TglVertexAttrib4ubv; + glVertexAttrib4uiv: TglVertexAttrib4uiv; + glVertexAttrib4usv: TglVertexAttrib4usv; + glVertexAttribPointer: TglVertexAttribPointer; + + // GL_VERSION_2_1 + glUniformMatrix2x3fv: TglUniformMatrix2x3fv; + glUniformMatrix3x2fv: TglUniformMatrix3x2fv; + glUniformMatrix2x4fv: TglUniformMatrix2x4fv; + glUniformMatrix4x2fv: TglUniformMatrix4x2fv; + glUniformMatrix3x4fv: TglUniformMatrix3x4fv; + glUniformMatrix4x3fv: TglUniformMatrix4x3fv; + + // GL_VERSION_3_0 + glColorMaski: TglColorMaski; + glGetBooleani_v: TglGetBooleani_v; + glGetIntegeri_v: TglGetIntegeri_v; + glEnablei: TglEnablei; + glDisablei: TglDisablei; + glIsEnabledi: TglIsEnabledi; + glBeginTransformFeedback: TglBeginTransformFeedback; + glEndTransformFeedback: TglEndTransformFeedback; + glBindBufferRange: TglBindBufferRange; + glBindBufferBase: TglBindBufferBase; + glTransformFeedbackVaryings: TglTransformFeedbackVaryings; + glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying; + glClampColor: TglClampColor; + glBeginConditionalRender: TglBeginConditionalRender; + glEndConditionalRender: TglEndConditionalRender; + glVertexAttribI1i: TglVertexAttribI1i; + glVertexAttribI2i: TglVertexAttribI2i; + glVertexAttribI3i: TglVertexAttribI3i; + glVertexAttribI4i: TglVertexAttribI4i; + glVertexAttribI1ui: TglVertexAttribI1ui; + glVertexAttribI2ui: TglVertexAttribI2ui; + glVertexAttribI3ui: TglVertexAttribI3ui; + glVertexAttribI4ui: TglVertexAttribI4ui; + glVertexAttribI1iv: TglVertexAttribI1iv; + glVertexAttribI2iv: TglVertexAttribI2iv; + glVertexAttribI3iv: TglVertexAttribI3iv; + glVertexAttribI4iv: TglVertexAttribI4iv; + glVertexAttribI1uiv: TglVertexAttribI1uiv; + glVertexAttribI2uiv: TglVertexAttribI2uiv; + glVertexAttribI3uiv: TglVertexAttribI3uiv; + glVertexAttribI4uiv: TglVertexAttribI4uiv; + glVertexAttribI4bv: TglVertexAttribI4bv; + glVertexAttribI4sv: TglVertexAttribI4sv; + glVertexAttribI4ubv: TglVertexAttribI4ubv; + glVertexAttribI4usv: TglVertexAttribI4usv; + glVertexAttribIPointer: TglVertexAttribIPointer; + glGetVertexAttribIiv: TglGetVertexAttribIiv; + glGetVertexAttribIuiv: TglGetVertexAttribIuiv; + glGetUniformuiv: TglGetUniformuiv; + glBindFragDataLocation: TglBindFragDataLocation; + glGetFragDataLocation: TglGetFragDataLocation; + glUniform1ui: TglUniform1ui; + glUniform2ui: TglUniform2ui; + glUniform3ui: TglUniform3ui; + glUniform4ui: TglUniform4ui; + glUniform1uiv: TglUniform1uiv; + glUniform2uiv: TglUniform2uiv; + glUniform3uiv: TglUniform3uiv; + glUniform4uiv: TglUniform4uiv; + glTexParameterIiv: TglTexParameterIiv; + glTexParameterIuiv: TglTexParameterIuiv; + glGetTexParameterIiv: TglGetTexParameterIiv; + glGetTexParameterIuiv: TglGetTexParameterIuiv; + glClearBufferiv: TglClearBufferiv; + glClearBufferuiv: TglClearBufferuiv; + glClearBufferfv: TglClearBufferfv; + glClearBufferfi: TglClearBufferfi; + glGetStringi: TglGetStringi; + + // GL_VERSION_2_1 + glEnableVertexArrayEXT : TglEnableVertexArrayEXT; + glEnableVertexArrayAttribEXT : TglEnableVertexArrayAttribEXT; + glVertexArrayVertexAttribOffsetEXT : TglVertexArrayVertexAttribOffsetEXT; + + // GL_VERSION_3_1 + glDrawArraysInstanced: TglDrawArraysInstanced; + glDrawElementsInstanced: TglDrawElementsInstanced; + glTexBuffer: TglTexBuffer; + glPrimitiveRestartIndex: TglPrimitiveRestartIndex; + + // GL_VERSION_3_2 + glGetInteger64i_v: TglGetInteger64i_v; + glGetBufferParameteri64v: TglGetBufferParameteri64v; + glFramebufferTexture: TglFramebufferTexture; + + // GL_VERSION_3_3 + glVertexAttribDivisor: TglVertexAttribDivisor; + + // GL_VERSION_4_0 + { OpenGL 4.0 also reuses entry points from these extensions: } + { ARB_texture_query_lod (no entry points) } + { ARB_draw_indirect } + { ARB_gpu_shader5 (no entry points) } + { ARB_gpu_shader_fp64 } + { ARB_shader_subroutine } + { ARB_tessellation_shader } + { ARB_texture_buffer_object_rgb32 (no entry points) } + { ARB_texture_cube_map_array (no entry points) } + { ARB_texture_gather (no entry points) } + { ARB_transform_feedback2 } + { ARB_transform_feedback3 } + glMinSampleShading: TglMinSampleShading; + glBlendEquationi: TglBlendEquationi; + glBlendEquationSeparatei: TglBlendEquationSeparatei; + glBlendFunci: TglBlendFunci; + glBlendFuncSeparatei: TglBlendFuncSeparatei; + + // GL_3DFX_tbuffer + glTbufferMask3DFX: TglTbufferMask3DFX; + + // GL_APPLE_element_array + glElementPointerAPPLE: TglElementPointerAPPLE; + glDrawElementArrayAPPLE: TglDrawElementArrayAPPLE; + glDrawRangeElementArrayAPPLE: TglDrawRangeElementArrayAPPLE; + glMultiDrawElementArrayAPPLE: TglMultiDrawElementArrayAPPLE; + glMultiDrawRangeElementArrayAPPLE: TglMultiDrawRangeElementArrayAPPLE; + + // GL_APPLE_fence + glGenFencesAPPLE: TglGenFencesAPPLE; + glDeleteFencesAPPLE: TglDeleteFencesAPPLE; + glSetFenceAPPLE: TglSetFenceAPPLE; + glIsFenceAPPLE: TglIsFenceAPPLE; + glTestFenceAPPLE: TglTestFenceAPPLE; + glFinishFenceAPPLE: TglFinishFenceAPPLE; + glTestObjectAPPLE: TglTestObjectAPPLE; + glFinishObjectAPPLE: TglFinishObjectAPPLE; + + // GL_APPLE_vertex_array_object + glBindVertexArrayAPPLE: TglBindVertexArrayAPPLE; + glDeleteVertexArraysAPPLE: TglDeleteVertexArraysAPPLE; + glGenVertexArraysAPPLE: TglGenVertexArraysAPPLE; + glIsVertexArrayAPPLE: TglIsVertexArrayAPPLE; + + // GL_APPLE_vertex_array_range + glVertexArrayRangeAPPLE: TglVertexArrayRangeAPPLE; + glFlushVertexArrayRangeAPPLE: TglFlushVertexArrayRangeAPPLE; + glVertexArrayParameteriAPPLE: TglVertexArrayParameteriAPPLE; + + // GL_APPLE_texture_range + glTextureRangeAPPLE: TglTextureRangeAPPLE; + glGetTexParameterPointervAPPLE: TglGetTexParameterPointervAPPLE; + + // GL_APPLE_vertex_program_evaluators + glEnableVertexAttribAPPLE: TglEnableVertexAttribAPPLE; + glDisableVertexAttribAPPLE: TglDisableVertexAttribAPPLE; + glIsVertexAttribEnabledAPPLE: TglIsVertexAttribEnabledAPPLE; + glMapVertexAttrib1dAPPLE: TglMapVertexAttrib1dAPPLE; + glMapVertexAttrib1fAPPLE: TglMapVertexAttrib1fAPPLE; + glMapVertexAttrib2dAPPLE: TglMapVertexAttrib2dAPPLE; + glMapVertexAttrib2fAPPLE: TglMapVertexAttrib2fAPPLE; + + // GL_APPLE_object_purgeable + glObjectPurgeableAPPLE: TglObjectPurgeableAPPLE; + glObjectUnpurgeableAPPLE: TglObjectUnpurgeableAPPLE; + glGetObjectParameterivAPPLE: TglGetObjectParameterivAPPLE; + + // GL_ARB_matrix_palette + glCurrentPaletteMatrixARB: TglCurrentPaletteMatrixARB; + glMatrixIndexubvARB: TglMatrixIndexubvARB; + glMatrixIndexusvARB: TglMatrixIndexusvARB; + glMatrixIndexuivARB: TglMatrixIndexuivARB; + glMatrixIndexPointerARB: TglMatrixIndexPointerARB; + + // GL_ARB_multisample + glSampleCoverageARB: TglSampleCoverageARB; + + // GL_ARB_multitexture + glActiveTextureARB: TglActiveTextureARB; + glClientActiveTextureARB: TglClientActiveTextureARB; + glMultiTexCoord1dARB: TglMultiTexCoord1dARB; + glMultiTexCoord1dvARB: TglMultiTexCoord1dvARB; + glMultiTexCoord1fARB: TglMultiTexCoord1fARB; + glMultiTexCoord1fvARB: TglMultiTexCoord1fvARB; + glMultiTexCoord1iARB: TglMultiTexCoord1iARB; + glMultiTexCoord1ivARB: TglMultiTexCoord1ivARB; + glMultiTexCoord1sARB: TglMultiTexCoord1sARB; + glMultiTexCoord1svARB: TglMultiTexCoord1svARB; + glMultiTexCoord2dARB: TglMultiTexCoord2dARB; + glMultiTexCoord2dvARB: TglMultiTexCoord2dvARB; + glMultiTexCoord2fARB: TglMultiTexCoord2fARB; + glMultiTexCoord2fvARB: TglMultiTexCoord2fvARB; + glMultiTexCoord2iARB: TglMultiTexCoord2iARB; + glMultiTexCoord2ivARB: TglMultiTexCoord2ivARB; + glMultiTexCoord2sARB: TglMultiTexCoord2sARB; + glMultiTexCoord2svARB: TglMultiTexCoord2svARB; + glMultiTexCoord3dARB: TglMultiTexCoord3dARB; + glMultiTexCoord3dvARB: TglMultiTexCoord3dvARB; + glMultiTexCoord3fARB: TglMultiTexCoord3fARB; + glMultiTexCoord3fvARB: TglMultiTexCoord3fvARB; + glMultiTexCoord3iARB: TglMultiTexCoord3iARB; + glMultiTexCoord3ivARB: TglMultiTexCoord3ivARB; + glMultiTexCoord3sARB: TglMultiTexCoord3sARB; + glMultiTexCoord3svARB: TglMultiTexCoord3svARB; + glMultiTexCoord4dARB: TglMultiTexCoord4dARB; + glMultiTexCoord4dvARB: TglMultiTexCoord4dvARB; + glMultiTexCoord4fARB: TglMultiTexCoord4fARB; + glMultiTexCoord4fvARB: TglMultiTexCoord4fvARB; + glMultiTexCoord4iARB: TglMultiTexCoord4iARB; + glMultiTexCoord4ivARB: TglMultiTexCoord4ivARB; + glMultiTexCoord4sARB: TglMultiTexCoord4sARB; + glMultiTexCoord4svARB: TglMultiTexCoord4svARB; + + // GL_ARB_point_parameters + glPointParameterfARB: TglPointParameterfARB; + glPointParameterfvARB: TglPointParameterfvARB; + + // GL_ARB_texture_compression + glCompressedTexImage3DARB: TglCompressedTexImage3DARB; + glCompressedTexImage2DARB: TglCompressedTexImage2DARB; + glCompressedTexImage1DARB: TglCompressedTexImage1DARB; + glCompressedTexSubImage3DARB: TglCompressedTexSubImage3DARB; + glCompressedTexSubImage2DARB: TglCompressedTexSubImage2DARB; + glCompressedTexSubImage1DARB: TglCompressedTexSubImage1DARB; + glGetCompressedTexImageARB: TglGetCompressedTexImageARB; + + // GL_ARB_transpose_matrix + glLoadTransposeMatrixfARB: TglLoadTransposeMatrixfARB; + glLoadTransposeMatrixdARB: TglLoadTransposeMatrixdARB; + glMultTransposeMatrixfARB: TglMultTransposeMatrixfARB; + glMultTransposeMatrixdARB: TglMultTransposeMatrixdARB; + + // GL_ARB_vertex_blend + glWeightbvARB: TglWeightbvARB; + glWeightsvARB: TglWeightsvARB; + glWeightivARB: TglWeightivARB; + glWeightfvARB: TglWeightfvARB; + glWeightdvARB: TglWeightdvARB; + glWeightubvARB: TglWeightubvARB; + glWeightusvARB: TglWeightusvARB; + glWeightuivARB: TglWeightuivARB; + glWeightPointerARB: TglWeightPointerARB; + glVertexBlendARB: TglVertexBlendARB; + + // GL_ARB_vertex_buffer_object + glBindBufferARB: TglBindBufferARB; + glDeleteBuffersARB: TglDeleteBuffersARB; + glGenBuffersARB: TglGenBuffersARB; + glIsBufferARB: TglIsBufferARB; + glBufferDataARB: TglBufferDataARB; + glBufferSubDataARB: TglBufferSubData; + glGetBufferSubDataARB: TglGetBufferSubDataARB; + glMapBufferARB: TglMapBufferARB; + glUnmapBufferARB: TglUnmapBufferARB; + glGetBufferParameterivARB: TglGetBufferParameterivARB; + glGetBufferPointervARB: TglGetBufferPointervARB; + + // GL_ARB_vertex_program + glVertexAttrib1dARB: TglVertexAttrib1dARB; + glVertexAttrib1dvARB: TglVertexAttrib1dvARB; + glVertexAttrib1fARB: TglVertexAttrib1fARB; + glVertexAttrib1fvARB: TglVertexAttrib1fvARB; + glVertexAttrib1sARB: TglVertexAttrib1sARB; + glVertexAttrib1svARB: TglVertexAttrib1svARB; + glVertexAttrib2dARB: TglVertexAttrib2dARB; + glVertexAttrib2dvARB: TglVertexAttrib2dvARB; + glVertexAttrib2fARB: TglVertexAttrib2fARB; + glVertexAttrib2fvARB: TglVertexAttrib2fvARB; + glVertexAttrib2sARB: TglVertexAttrib2sARB; + glVertexAttrib2svARB: TglVertexAttrib2svARB; + glVertexAttrib3dARB: TglVertexAttrib3dARB; + glVertexAttrib3dvARB: TglVertexAttrib3dvARB; + glVertexAttrib3fARB: TglVertexAttrib3fARB; + glVertexAttrib3fvARB: TglVertexAttrib3fvARB; + glVertexAttrib3sARB: TglVertexAttrib3sARB; + glVertexAttrib3svARB: TglVertexAttrib3svARB; + glVertexAttrib4NbvARB: TglVertexAttrib4NbvARB; + glVertexAttrib4NivARB: TglVertexAttrib4NivARB; + glVertexAttrib4NsvARB: TglVertexAttrib4NsvARB; + glVertexAttrib4NubARB: TglVertexAttrib4NubARB; + glVertexAttrib4NubvARB: TglVertexAttrib4NubvARB; + glVertexAttrib4NuivARB: TglVertexAttrib4NuivARB; + glVertexAttrib4NusvARB: TglVertexAttrib4NusvARB; + glVertexAttrib4bvARB: TglVertexAttrib4bvARB; + glVertexAttrib4dARB: TglVertexAttrib4dARB; + glVertexAttrib4dvARB: TglVertexAttrib4dvARB; + glVertexAttrib4fARB: TglVertexAttrib4fARB; + glVertexAttrib4fvARB: TglVertexAttrib4fvARB; + glVertexAttrib4ivARB: TglVertexAttrib4ivARB; + glVertexAttrib4sARB: TglVertexAttrib4sARB; + glVertexAttrib4svARB: TglVertexAttrib4svARB; + glVertexAttrib4ubvARB: TglVertexAttrib4ubvARB; + glVertexAttrib4uivARB: TglVertexAttrib4uivARB; + glVertexAttrib4usvARB: TglVertexAttrib4usvARB; + glVertexAttribPointerARB: TglVertexAttribPointerARB; + glEnableVertexAttribArrayARB: TglEnableVertexAttribArrayARB; + glDisableVertexAttribArrayARB: TglDisableVertexAttribArrayARB; + glProgramStringARB: TglProgramStringARB; + glBindProgramARB: TglBindProgramARB; + glDeleteProgramsARB: TglDeleteProgramsARB; + glGenProgramsARB: TglGenProgramsARB; + + glProgramEnvParameter4dARB: TglProgramEnvParameter4dARB; + glProgramEnvParameter4dvARB: TglProgramEnvParameter4dvARB; + glProgramEnvParameter4fARB: TglProgramEnvParameter4fARB; + glProgramEnvParameter4fvARB: TglProgramEnvParameter4fvARB; + glProgramLocalParameter4dARB: TglProgramLocalParameter4dARB; + glProgramLocalParameter4dvARB: TglProgramLocalParameter4dvARB; + glProgramLocalParameter4fARB: TglProgramLocalParameter4fARB; + glProgramLocalParameter4fvARB: TglProgramLocalParameter4fvARB; + glGetProgramEnvParameterdvARB: TglGetProgramEnvParameterdvARB; + glGetProgramEnvParameterfvARB: TglGetProgramEnvParameterfvARB; + glGetProgramLocalParameterdvARB: TglGetProgramLocalParameterdvARB; + glGetProgramLocalParameterfvARB: TglGetProgramLocalParameterfvARB; + glGetProgramivARB: TglGetProgramivARB; + glGetProgramStringARB: TglGetProgramStringARB; + glGetVertexAttribdvARB: TglGetVertexAttribdvARB; + glGetVertexAttribfvARB: TglGetVertexAttribfvARB; + glGetVertexAttribivARB: TglGetVertexAttribivARB; + glGetVertexAttribPointervARB: TglGetVertexAttribPointervARB; + glIsProgramARB: TglIsProgramARB; + + // GL_ARB_window_pos + glWindowPos2dARB: TglWindowPos2dARB; + glWindowPos2dvARB: TglWindowPos2dvARB; + glWindowPos2fARB: TglWindowPos2fARB; + glWindowPos2fvARB: TglWindowPos2fvARB; + glWindowPos2iARB: TglWindowPos2iARB; + glWindowPos2ivARB: TglWindowPos2ivARB; + glWindowPos2sARB: TglWindowPos2sARB; + glWindowPos2svARB: TglWindowPos2svARB; + glWindowPos3dARB: TglWindowPos3dARB; + glWindowPos3dvARB: TglWindowPos3dvARB; + glWindowPos3fARB: TglWindowPos3fARB; + glWindowPos3fvARB: TglWindowPos3fvARB; + glWindowPos3iARB: TglWindowPos3iARB; + glWindowPos3ivARB: TglWindowPos3ivARB; + glWindowPos3sARB: TglWindowPos3sARB; + glWindowPos3svARB: TglWindowPos3svARB; + + // GL_ARB_draw_buffers + glDrawBuffersARB: TglDrawBuffersARB; + + // GL_ARB_color_buffer_float + glClampColorARB: TglClampColorARB; + + // GL_ARB_vertex_shader + glGetActiveAttribARB: TglGetActiveAttribARB; + glGetAttribLocationARB: TglGetAttribLocationARB; + glBindAttribLocationARB: TglBindAttribLocationARB; + + // GL_ARB_shader_objects + glDeleteObjectARB: TglDeleteObjectARB; + glGetHandleARB: TglGetHandleARB; + glDetachObjectARB: TglDetachObjectARB; + glCreateShaderObjectARB: TglCreateShaderObjectARB; + glShaderSourceARB: TglShaderSourceARB; + glCompileShaderARB: TglCompileShaderARB; + glCreateProgramObjectARB: TglCreateProgramObjectARB; + glAttachObjectARB: TglAttachObjectARB; + glLinkProgramARB: TglLinkProgramARB; + glUseProgramObjectARB: TglUseProgramObjectARB; + glValidateProgramARB: TglValidateProgramARB; + glUniform1fARB: TglUniform1fARB; + glUniform2fARB: TglUniform2fARB; + glUniform3fARB: TglUniform3fARB; + glUniform4fARB: TglUniform4fARB; + glUniform1iARB: TglUniform1iARB; + glUniform2iARB: TglUniform2iARB; + glUniform3iARB: TglUniform3iARB; + glUniform4iARB: TglUniform4iARB; + glUniform1fvARB: TglUniform1fvARB; + glUniform2fvARB: TglUniform2fvARB; + glUniform3fvARB: TglUniform3fvARB; + glUniform4fvARB: TglUniform4fvARB; + glUniform1ivARB: TglUniform1ivARB; + glUniform2ivARB: TglUniform2ivARB; + glUniform3ivARB: TglUniform3ivARB; + glUniform4ivARB: TglUniform4ivARB; + glUniformMatrix2fvARB: TglUniformMatrix2fvARB; + glUniformMatrix3fvARB: TglUniformMatrix3fvARB; + glUniformMatrix4fvARB: TglUniformMatrix4fvARB; + glGetObjectParameterfvARB: TglGetObjectParameterfvARB; + glGetObjectParameterivARB: TglGetObjectParameterivARB; + glGetInfoLogARB: TglGetInfoLogARB; + glGetAttachedObjectsARB: TglGetAttachedObjectsARB; + glGetUniformLocationARB: TglGetUniformLocationARB; + glGetActiveUniformARB: TglGetActiveUniformARB; + glGetUniformfvARB: TglGetUniformfvARB; + glGetUniformivARB: TglGetUniformivARB; + glGetShaderSourceARB: TglGetShaderSourceARB; + + // GL_ARB_Occlusion_Query + glGenQueriesARB: TglGenQueriesARB; + glDeleteQueriesARB: TglDeleteQueriesARB; + glIsQueryARB: TglIsQueryARB; + glBeginQueryARB: TglBeginQueryARB; + glEndQueryARB: TglEndQueryARB; + glGetQueryivARB: TglGetQueryivARB; + glGetQueryObjectivARB: TglGetQueryObjectivARB; + glGetQueryObjectuivARB: TglGetQueryObjectuivARB; + + // GL_ARB_draw_instanced + glDrawArraysInstancedARB: TglDrawArraysInstancedARB; + glDrawElementsInstancedARB: TglDrawElementsInstancedARB; + + // GL_ARB_framebuffer_object + glIsRenderbuffer: TglIsRenderbuffer; + glBindRenderbuffer: TglBindRenderbuffer; + glDeleteRenderbuffers: TglDeleteRenderbuffers; + glGenRenderbuffers: TglGenRenderbuffers; + glRenderbufferStorage: TglRenderbufferStorage; + glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv; + glIsFramebuffer: TglIsFramebuffer; + glBindFramebuffer: TglBindFramebuffer; + glDeleteFramebuffers: TglDeleteFramebuffers; + glGenFramebuffers: TglGenFramebuffers; + glCheckFramebufferStatus: TglCheckFramebufferStatus; + glFramebufferTexture1D: TglFramebufferTexture1D; + glFramebufferTexture2D: TglFramebufferTexture2D; + glFramebufferTexture3D: TglFramebufferTexture3D; + glFramebufferRenderbuffer: TglFramebufferRenderbuffer; + glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv; + glGenerateMipmap: TglGenerateMipmap; + glBlitFramebuffer: TglBlitFramebuffer; + glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample; + glFramebufferTextureLayer: TglFramebufferTextureLayer; + + // GL_ARB_geometry_shader4 + glProgramParameteriARB: TglProgramParameteriARB; + glFramebufferTextureARB: TglFramebufferTextureARB; + glFramebufferTextureLayerARB: TglFramebufferTextureLayerARB; + glFramebufferTextureFaceARB: TglFramebufferTextureFaceARB; + + // GL_ARB_instanced_arrays + glVertexAttribDivisorARB: TglVertexAttribDivisorARB; + + // GL_ARB_map_buffer_range + glMapBufferRange: TglMapBufferRange; + glFlushMappedBufferRange: TglFlushMappedBufferRange; + + // GL_ARB_texture_buffer_object + glTexBufferARB: TglTexBufferARB; + + // GL_ARB_vertex_array_object + glBindVertexArray: TglBindVertexArray; + glDeleteVertexArrays: TglDeleteVertexArrays; + glGenVertexArrays: TglGenVertexArrays; + glIsVertexArray: TglIsVertexArray; + + // GL_ARB_uniform_buffer_object + glGetUniformIndices: TglGetUniformIndices; + glGetActiveUniformsiv: TglGetActiveUniformsiv; + glGetActiveUniformName: TglGetActiveUniformName; + glGetUniformBlockIndex: TglGetUniformBlockIndex; + glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv; + glGetActiveUniformBlockName: TglGetActiveUniformBlockName; + glUniformBlockBinding: TglUniformBlockBinding; + + // GL_ARB_copy_buffer + glCopyBufferSubData: TglCopyBufferSubData; + + // GL_ARB_draw_elements_base_vertex + glDrawElementsBaseVertex: TglDrawElementsBaseVertex; + glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex; + glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex; + glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex; + + // GL_ARB_provoking_vertex + glProvokingVertex: TglProvokingVertex; + + // GL_ARB_sync + glFenceSync: TglFenceSync; + glIsSync: TglIsSync; + glDeleteSync: TglDeleteSync; + glClientWaitSync: TglClientWaitSync; + glWaitSync: TglWaitSync; + glGetInteger64v: TglGetInteger64v; + glGetSynciv: TglGetSynciv; + + // GL_ARB_texture_multisample + glTexImage2DMultisample: TglTexImage2DMultisample; + glTexImage3DMultisample: TglTexImage3DMultisample; + glGetMultisamplefv: TglGetMultisamplefv; + glSampleMaski: TglSampleMaski; + + // GL_ARB_draw_buffers_blend + glBlendEquationiARB: TglBlendEquationiARB; + glBlendEquationSeparateiARB: TglBlendEquationSeparateiARB; + glBlendFunciARB: TglBlendFunciARB; + glBlendFuncSeparateiARB: TglBlendFuncSeparateiARB; + + // GL_ARB_sample_shading + glMinSampleShadingARB: TglMinSampleShadingARB; + + // GL_ARB_shading_language_include + glNamedStringARB: TglNamedStringARB; + glDeleteNamedStringARB: TglDeleteNamedStringARB; + glCompileShaderIncludeARB: TglCompileShaderIncludeARB; + glIsNamedStringARB: TglIsNamedStringARB; + glGetNamedStringARB: TglGetNamedStringARB; + glGetNamedStringivARB: TglGetNamedStringivARB; + + // GL_ARB_blend_func_extended + glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed; + glGetFragDataIndex: TglGetFragDataIndex; + + // GL_ARB_sampler_objects + glGenSamplers: TglGenSamplers; + glDeleteSamplers: TglDeleteSamplers; + glIsSampler: TglIsSampler; + glBindSampler: TglBindSampler; + glSamplerParameteri: TglSamplerParameteri; + glSamplerParameteriv: TglSamplerParameteriv; + glSamplerParameterf: TglSamplerParameterf; + glSamplerParameterfv: TglSamplerParameterfv; + glSamplerParameterIiv: TglSamplerParameterIiv; + glSamplerParameterIuiv: TglSamplerParameterIuiv; + glGetSamplerParameteriv: TglGetSamplerParameteriv; + glGetSamplerParameterIiv: TglGetSamplerParameterIiv; + glGetSamplerParameterfv: TglGetSamplerParameterfv; + glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv; + + // GL_ARB_timer_query + glQueryCounter: TglQueryCounter; + glGetQueryObjecti64v: TglGetQueryObjecti64v; + glGetQueryObjectui64v: TglGetQueryObjectui64v; + + // GL_ARB_vertex_type_2_10_10_10_rev + glVertexP2ui: TglVertexP2ui; + glVertexP2uiv: TglVertexP2uiv; + glVertexP3ui: TglVertexP3ui; + glVertexP3uiv: TglVertexP3uiv; + glVertexP4ui: TglVertexP4ui; + glVertexP4uiv: TglVertexP4uiv; + glTexCoordP1ui: TglTexCoordP1ui; + glTexCoordP1uiv: TglTexCoordP1uiv; + glTexCoordP2ui: TglTexCoordP2ui; + glTexCoordP2uiv: TglTexCoordP2uiv; + glTexCoordP3ui: TglTexCoordP3ui; + glTexCoordP3uiv: TglTexCoordP3uiv; + glTexCoordP4ui: TglTexCoordP4ui; + glTexCoordP4uiv: TglTexCoordP4uiv; + glMultiTexCoordP1ui: TglMultiTexCoordP1ui; + glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv; + glMultiTexCoordP2ui: TglMultiTexCoordP2ui; + glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv; + glMultiTexCoordP3ui: TglMultiTexCoordP3ui; + glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv; + glMultiTexCoordP4ui: TglMultiTexCoordP4ui; + glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv; + glNormalP3ui: TglNormalP3ui; + glNormalP3uiv: TglNormalP3uiv; + glColorP3ui: TglColorP3ui; + glColorP3uiv: TglColorP3uiv; + glColorP4ui: TglColorP4ui; + glColorP4uiv: TglColorP4uiv; + glSecondaryColorP3ui: TglSecondaryColorP3ui; + glSecondaryColorP3uiv: TglSecondaryColorP3uiv; + glVertexAttribP1ui: TglVertexAttribP1ui; + glVertexAttribP1uiv: TglVertexAttribP1uiv; + glVertexAttribP2ui: TglVertexAttribP2ui; + glVertexAttribP2uiv: TglVertexAttribP2uiv; + glVertexAttribP3ui: TglVertexAttribP3ui; + glVertexAttribP3uiv: TglVertexAttribP3uiv; + glVertexAttribP4ui: TglVertexAttribP4ui; + glVertexAttribP4uiv: TglVertexAttribP4uiv; + + // GL_ARB_draw_indirect + glDrawArraysIndirect: TglDrawArraysIndirect; + glDrawElementsIndirect: TglDrawElementsIndirect; + + // GL_ARB_gpu_shader_fp64 + glUniform1d: TglUniform1d; + glUniform2d: TglUniform2d; + glUniform3d: TglUniform3d; + glUniform4d: TglUniform4d; + glUniform1dv: TglUniform1dv; + glUniform2dv: TglUniform2dv; + glUniform3dv: TglUniform3dv; + glUniform4dv: TglUniform4dv; + glUniformMatrix2dv: TglUniformMatrix2dv; + glUniformMatrix3dv: TglUniformMatrix3dv; + glUniformMatrix4dv: TglUniformMatrix4dv; + glUniformMatrix2x3dv: TglUniformMatrix2x3dv; + glUniformMatrix2x4dv: TglUniformMatrix2x4dv; + glUniformMatrix3x2dv: TglUniformMatrix3x2dv; + glUniformMatrix3x4dv: TglUniformMatrix3x4dv; + glUniformMatrix4x2dv: TglUniformMatrix4x2dv; + glUniformMatrix4x3dv: TglUniformMatrix4x3dv; + glGetUniformdv: TglGetUniformdv; + + // GL_ARB_shader_subroutine + glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation; + glGetSubroutineIndex: TglGetSubroutineIndex; + glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv; + glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName; + glGetActiveSubroutineName: TglGetActiveSubroutineName; + glUniformSubroutinesuiv: TglUniformSubroutinesuiv; + glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv; + glGetProgramStageiv: TglGetProgramStageiv; + + // GL_ARB_tessellation_shader + glPatchParameteri: TglPatchParameteri; + glPatchParameterfv: TglPatchParameterfv; + + // GL_ARB_transform_feedback2 + glBindTransformFeedback: TglBindTransformFeedback; + glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks; + glGenTransformFeedbacks: TglGenTransformFeedbacks; + glIsTransformFeedback: TglIsTransformFeedback; + glPauseTransformFeedback: TglPauseTransformFeedback; + glResumeTransformFeedback: TglResumeTransformFeedback; + glDrawTransformFeedback: TglDrawTransformFeedback; + + // GL_ARB_transform_feedback3 + glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream; + glBeginQueryIndexed: TglBeginQueryIndexed; + glEndQueryIndexed: TglEndQueryIndexed; + glGetQueryIndexediv: TglGetQueryIndexediv; + + // GL_ARB_ES2_compatibility + glReleaseShaderCompiler: TglReleaseShaderCompiler; + glShaderBinary: TglShaderBinary; + glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat; + glDepthRangef: TglDepthRangef; + glClearDepthf: TglClearDepthf; + + // GL_ARB_get_program_binary + glGetProgramBinary: TglGetProgramBinary; + glProgramBinary: TglProgramBinary; + glProgramParameteri: TglProgramParameteri; + + // GL_ARB_separate_shader_objects + glUseProgramStages: TglUseProgramStages; + glActiveShaderProgram: TglActiveShaderProgram; + glCreateShaderProgramv: TglCreateShaderProgramv; + glBindProgramPipeline: TglBindProgramPipeline; + glDeleteProgramPipelines: TglDeleteProgramPipelines; + glGenProgramPipelines: TglGenProgramPipelines; + glIsProgramPipeline: TglIsProgramPipeline; + glGetProgramPipelineiv: TglGetProgramPipelineiv; + glProgramUniform1i: TglProgramUniform1i; + glProgramUniform1iv: TglProgramUniform1iv; + glProgramUniform1f: TglProgramUniform1f; + glProgramUniform1fv: TglProgramUniform1fv; + glProgramUniform1d: TglProgramUniform1d; + glProgramUniform1dv: TglProgramUniform1dv; + glProgramUniform1ui: TglProgramUniform1ui; + glProgramUniform1uiv: TglProgramUniform1uiv; + glProgramUniform2i: TglProgramUniform2i; + glProgramUniform2iv: TglProgramUniform2iv; + glProgramUniform2f: TglProgramUniform2f; + glProgramUniform2fv: TglProgramUniform2fv; + glProgramUniform2d: TglProgramUniform2d; + glProgramUniform2dv: TglProgramUniform2dv; + glProgramUniform2ui: TglProgramUniform2ui; + glProgramUniform2uiv: TglProgramUniform2uiv; + glProgramUniform3i: TglProgramUniform3i; + glProgramUniform3iv: TglProgramUniform3iv; + glProgramUniform3f: TglProgramUniform3f; + glProgramUniform3fv: TglProgramUniform3fv; + glProgramUniform3d: TglProgramUniform3d; + glProgramUniform3dv: TglProgramUniform3dv; + glProgramUniform3ui: TglProgramUniform3ui; + glProgramUniform3uiv: TglProgramUniform3uiv; + glProgramUniform4i: TglProgramUniform4i; + glProgramUniform4iv: TglProgramUniform4iv; + glProgramUniform4f: TglProgramUniform4f; + glProgramUniform4fv: TglProgramUniform4fv; + glProgramUniform4d: TglProgramUniform4d; + glProgramUniform4dv: TglProgramUniform4dv; + glProgramUniform4ui: TglProgramUniform4ui; + glProgramUniform4uiv: TglProgramUniform4uiv; + glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv; + glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv; + glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv; + glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv; + glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv; + glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv; + glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv; + glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv; + glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv; + glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv; + glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv; + glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv; + glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv; + glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv; + glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv; + glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv; + glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv; + glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv; + glValidateProgramPipeline: TglValidateProgramPipeline; + glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog; + + // GL_ARB_vertex_attrib_64bit + glVertexAttribL1d: TglVertexAttribL1d; + glVertexAttribL2d: TglVertexAttribL2d; + glVertexAttribL3d: TglVertexAttribL3d; + glVertexAttribL4d: TglVertexAttribL4d; + glVertexAttribL1dv: TglVertexAttribL1dv; + glVertexAttribL2dv: TglVertexAttribL2dv; + glVertexAttribL3dv: TglVertexAttribL3dv; + glVertexAttribL4dv: TglVertexAttribL4dv; + glVertexAttribLPointer: TglVertexAttribLPointer; + glGetVertexAttribLdv: TglGetVertexAttribLdv; + + // GL_ARB_viewport_array + glViewportArrayv: TglViewportArrayv; + glViewportIndexedf: TglViewportIndexedf; + glViewportIndexedfv: TglViewportIndexedfv; + glScissorArrayv: TglScissorArrayv; + glScissorIndexed: TglScissorIndexed; + glScissorIndexedv: TglScissorIndexedv; + glDepthRangeArrayv: TglDepthRangeArrayv; + glDepthRangeIndexed: TglDepthRangeIndexed; + glGetFloati_v: TglGetFloati_v; + glGetDoublei_v: TglGetDoublei_v; + + // GL 4.2 + + // GL_ARB_base_instance + glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance; + glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance; + glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance; + + // GL_ARB_transform_feedback_instanced + glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced; + glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced; + + // GL_ARB_internalformat_query + glGetInternalformativ : TglGetInternalformativ; + + // GL_ARB_shader_atomic_counters + glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv; + + /// GL_ARB_shader_image_load_store + glBindImageTexture : TglBindImageTexture; + glMemoryBarrier : TglMemoryBarrier; + + // GL_ARB_texture_storage + glTexStorage1D : TglTexStorage1D; + glTexStorage2D : TglTexStorage2D; + glTexStorage3D : TglTexStorage3D; + glTextureStorage1DEXT : TglTextureStorage1DEXT; + glTextureStorage2DEXT : TglTextureStorage2DEXT; + glTextureStorage3DEXT : TglTextureStorage3DEXT; + + + // GL 4.3 + // GL_KHR_debug + glDebugMessageControl : TglDebugMessageControl; + glDebugMessageInsert : TglDebugMessageInsert; + glDebugMessageCallback : TglDebugMessageCallback; + glGetDebugMessageLog : TglGetDebugMessageLog; + glPushDebugGroup : TglPushDebugGroup; + glPopDebugGroup : TglPopDebugGroup; + glObjectLabel : TglObjectLabel; + glGetObjectLabel : TglGetObjectLabel; + glObjectPtrLabel : TglObjectPtrLabel; + glGetObjectPtrLabel : TglGetObjectPtrLabel; + // GL_ARB_clear_buffer_object + glClearBufferData : TglClearBufferData; + glClearBufferSubData : TglClearBufferSubData; + glClearNamedBufferDataEXT : TglClearNamedBufferDataEXT; + glClearNamedBufferSubDataEXT : TglClearNamedBufferSubDataEXT; + // GL_ARB_compute_shader + glDispatchCompute : TglDispatchCompute; + glDispatchComputeIndirect : TglDispatchComputeIndirect; + // GL_ARB_copy_image + glCopyImageSubData : TglCopyImageSubData; + // GL_ARB_framebuffer_no_attachments + glFramebufferParameteri : TglFramebufferParameteri; + glGetFramebufferParameteriv : TglGetFramebufferParameteriv; + glNamedFramebufferParameteriEXT : TglNamedFramebufferParameteriEXT; + glGetNamedFramebufferParameterivEXT : TglGetNamedFramebufferParameterivEXT; + // GL_ARB_internalformat_query2 + glGetInternalformati64v : TglGetInternalformati64v; + // GL_ARB_invalidate_subdata + glInvalidateTexSubImage : TglInvalidateTexSubImage; + glInvalidateTexImage : TglInvalidateTexImage; + glInvalidateBufferSubData : TglInvalidateBufferSubData; + glInvalidateBufferData : TglInvalidateBufferData; + glInvalidateFramebuffer : TglInvalidateFramebuffer; + glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer; + // GL_ARB_multi_draw_indirect + glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect; + glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect; + // GL_ARB_program_interface_query + glGetProgramInterfaceiv : TglGetProgramInterfaceiv; + glGetProgramResourceIndex : TglGetProgramResourceIndex; + glGetProgramResourceName : TglGetProgramResourceName; + glGetProgramResourceiv : TglGetProgramResourceiv; + glGetProgramResourceLocation : TglGetProgramResourceLocation; + glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex; + // GL_ARB_shader_storage_buffer_object + glShaderStorageBlockBinding : TglShaderStorageBlockBinding; + // GL_ARB_texture_buffer_range + glTexBufferRange : TglTexBufferRange; + glTextureBufferRangeEXT : TglTextureBufferRangeEXT; + // GL_ARB_texture_storage_multisample + glTexStorage2DMultisample : TglTexStorage2DMultisample; + glTexStorage3DMultisample : TglTexStorage3DMultisample; + glTextureStorage2DMultisampleEXT : TglTextureStorage2DMultisampleEXT; + glTextureStorage3DMultisampleEXT : TglTextureStorage3DMultisampleEXT; + // GL_ARB_texture_view + glTextureView : TglTextureView; + // GL_ARB_vertex_attrib_binding + glBindVertexBuffer : TglBindVertexBuffer; + glVertexAttribFormat : TglVertexAttribFormat; + glVertexAttribIFormat : TglVertexAttribIFormat; + glVertexAttribLFormat : TglVertexAttribLFormat; + glVertexAttribBinding : TglVertexAttribBinding; + glVertexBindingDivisor : TglVertexBindingDivisor; + glVertexArrayBindVertexBufferEXT : TglVertexArrayBindVertexBufferEXT; + glVertexArrayVertexAttribFormatEXT : TglVertexArrayVertexAttribFormatEXT; + glVertexArrayVertexAttribIFormatEXT : TglVertexArrayVertexAttribIFormatEXT; + glVertexArrayVertexAttribLFormatEXT : TglVertexArrayVertexAttribLFormatEXT; + glVertexArrayVertexAttribBindingEXT : TglVertexArrayVertexAttribBindingEXT; + glVertexArrayVertexBindingDivisorEXT : TglVertexArrayVertexBindingDivisorEXT; + // END GL 4.3 + + + // GL 4.4 + glBufferStorage : TglBufferStorage; + glClearTexImage : TglClearTexImage; + glClearTexSubImage : TglClearTexSubImage; + glBindBuffersBase : TglBindBuffersBase; + glBindBuffersRange : TglBindBuffersRange; + glBindTextures : TglBindTextures; + glBindSamplers : TglBindSamplers; + glBindImageTextures : TglBindImageTextures; + glBindVertexBuffers : TglBindVertexBuffers; + // END GL 4.4 + + + // GL_ARB_cl_event + glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB; + + // GL_ARB_debug_output + glDebugMessageControlARB: TglDebugMessageControlARB; + glDebugMessageInsertARB: TglDebugMessageInsertARB; + glDebugMessageCallbackARB: TglDebugMessageCallbackARB; + glGetDebugMessageLogARB: TglGetDebugMessageLogARB; + + // GL_ARB_robustness + glGetGraphicsResetStatusARB: TglGetGraphicsResetStatusARB; + glGetnMapdvARB: TglGetnMapdvARB; + glGetnMapfvARB: TglGetnMapfvARB; + glGetnMapivARB: TglGetnMapivARB; + glGetnPixelMapfvARB: TglGetnPixelMapfvARB; + glGetnPixelMapuivARB: TglGetnPixelMapuivARB; + glGetnPixelMapusvARB: TglGetnPixelMapusvARB; + glGetnPolygonStippleARB: TglGetnPolygonStippleARB; + glGetnColorTableARB: TglGetnColorTableARB; + glGetnConvolutionFilterARB: TglGetnConvolutionFilterARB; + glGetnSeparableFilterARB: TglGetnSeparableFilterARB; + glGetnHistogramARB: TglGetnHistogramARB; + glGetnMinmaxARB: TglGetnMinmaxARB; + glGetnTexImageARB: TglGetnTexImageARB; + glReadnPixelsARB: TglReadnPixelsARB; + glGetnCompressedTexImageARB: TglGetnCompressedTexImageARB; + glGetnUniformfvARB: TglGetnUniformfvARB; + glGetnUniformivARB: TglGetnUniformivARB; + glGetnUniformuivARB: TglGetnUniformuivARB; + glGetnUniformdvARB: TglGetnUniformdvARB; + + // GL_ATI_draw_buffers + glDrawBuffersATI: TglDrawBuffersATI; + + // GL_ATI_element_array + glElementPointerATI: TglElementPointerATI; + glDrawElementArrayATI: TglDrawElementArrayATI; + glDrawRangeElementArrayATI: TglDrawRangeElementArrayATI; + + // GL_ATI_envmap_bumpmap + glTexBumpParameterivATI: TglTexBumpParameterivATI; + glTexBumpParameterfvATI: TglTexBumpParameterfvATI; + glGetTexBumpParameterivATI: TglGetTexBumpParameterivATI; + glGetTexBumpParameterfvATI: TglGetTexBumpParameterfvATI; + + // GL_ATI_fragment_shader + glGenFragmentShadersATI: TglGenFragmentShadersATI; + glBindFragmentShaderATI: TglBindFragmentShaderATI; + glDeleteFragmentShaderATI: TglDeleteFragmentShaderATI; + glBeginFragmentShaderATI: TglBeginFragmentShaderATI; + glEndFragmentShaderATI: TglEndFragmentShaderATI; + glPassTexCoordATI: TglPassTexCoordATI; + glSampleMapATI: TglSampleMapATI; + glColorFragmentOp1ATI: TglColorFragmentOp1ATI; + glColorFragmentOp2ATI: TglColorFragmentOp2ATI; + glColorFragmentOp3ATI: TglColorFragmentOp3ATI; + glAlphaFragmentOp1ATI: TglAlphaFragmentOp1ATI; + glAlphaFragmentOp2ATI: TglAlphaFragmentOp2ATI; + glAlphaFragmentOp3ATI: TglAlphaFragmentOp3ATI; + glSetFragmentShaderConstantATI: TglSetFragmentShaderConstantATI; + + // GL_ATI_map_object_buffer + glMapObjectBufferATI: TglMapObjectBufferATI; + glUnmapObjectBufferATI: TglUnmapObjectBufferATI; + + // GL_ATI_pn_triangles + glPNTrianglesiATI: TglPNTrianglesiATI; + glPNTrianglesfATI: TglPNTrianglesfATI; + + // GL_ATI_separate_stencil + glStencilOpSeparateATI: TglStencilOpSeparateATI; + glStencilFuncSeparateATI: TglStencilFuncSeparateATI; + + // GL_ATI_vertex_array_object + glNewObjectBufferATI: TglNewObjectBufferATI; + glIsObjectBufferATI: TglIsObjectBufferATI; + glUpdateObjectBufferATI: TglUpdateObjectBufferATI; + glGetObjectBufferfvATI: TglGetObjectBufferfvATI; + glGetObjectBufferivATI: TglGetObjectBufferivATI; + glFreeObjectBufferATI: TglFreeObjectBufferATI; + glArrayObjectATI: TglArrayObjectATI; + glGetArrayObjectfvATI: TglGetArrayObjectfvATI; + glGetArrayObjectivATI: TglGetArrayObjectivATI; + glVariantArrayObjectATI: TglVariantArrayObjectATI; + glGetVariantArrayObjectfvATI: TglGetVariantArrayObjectfvATI; + glGetVariantArrayObjectivATI: TglGetVariantArrayObjectivATI; + glVertexAttribArrayObjectATI: TglVertexAttribArrayObjectATI; + glGetVertexAttribArrayObjectfvATI: TglGetVertexAttribArrayObjectfvATI; + glGetVertexAttribArrayObjectivATI: TglGetVertexAttribArrayObjectivATI; + + // GL_ATI_vertex_streams + glVertexStream1sATI: TglVertexStream1sATI; + glVertexStream1svATI: TglVertexStream1svATI; + glVertexStream1iATI: TglVertexStream1iATI; + glVertexStream1ivATI: TglVertexStream1ivATI; + glVertexStream1fATI: TglVertexStream1fATI; + glVertexStream1fvATI: TglVertexStream1fvATI; + glVertexStream1dATI: TglVertexStream1dATI; + glVertexStream1dvATI: TglVertexStream1dvATI; + glVertexStream2sATI: TglVertexStream2sATI; + glVertexStream2svATI: TglVertexStream2svATI; + glVertexStream2iATI: TglVertexStream2iATI; + glVertexStream2ivATI: TglVertexStream2ivATI; + glVertexStream2fATI: TglVertexStream2fATI; + glVertexStream2fvATI: TglVertexStream2fvATI; + glVertexStream2dATI: TglVertexStream2dATI; + glVertexStream2dvATI: TglVertexStream2dvATI; + glVertexStream3sATI: TglVertexStream3sATI; + glVertexStream3svATI: TglVertexStream3svATI; + glVertexStream3iATI: TglVertexStream3iATI; + glVertexStream3ivATI: TglVertexStream3ivATI; + glVertexStream3fATI: TglVertexStream3fATI; + glVertexStream3fvATI: TglVertexStream3fvATI; + glVertexStream3dATI: TglVertexStream3dATI; + glVertexStream3dvATI: TglVertexStream3dvATI; + glVertexStream4sATI: TglVertexStream4sATI; + glVertexStream4svATI: TglVertexStream4svATI; + glVertexStream4iATI: TglVertexStream4iATI; + glVertexStream4ivATI: TglVertexStream4ivATI; + glVertexStream4fATI: TglVertexStream4fATI; + glVertexStream4fvATI: TglVertexStream4fvATI; + glVertexStream4dATI: TglVertexStream4dATI; + glVertexStream4dvATI: TglVertexStream4dvATI; + glNormalStream3bATI: TglNormalStream3bATI; + glNormalStream3bvATI: TglNormalStream3bvATI; + glNormalStream3sATI: TglNormalStream3sATI; + glNormalStream3svATI: TglNormalStream3svATI; + glNormalStream3iATI: TglNormalStream3iATI; + glNormalStream3ivATI: TglNormalStream3ivATI; + glNormalStream3fATI: TglNormalStream3fATI; + glNormalStream3fvATI: TglNormalStream3fvATI; + glNormalStream3dATI: TglNormalStream3dATI; + glNormalStream3dvATI: TglNormalStream3dvATI; + glClientActiveVertexStreamATI: TglClientActiveVertexStreamATI; + glVertexBlendEnviATI: TglVertexBlendEnviATI; + glVertexBlendEnvfATI: TglVertexBlendEnvfATI; + + // GL_AMD_performance_monitor + glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD; + glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD; + glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD; + glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD; + glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD; + glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD; + glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD; + glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD; + glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD; + glEndPerfMonitorAMD: TglEndPerfMonitorAMD; + glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD; + + // GL_AMD_vertex_shader_tesselator + glTessellationFactorAMD: TglTessellationFactorAMD; + glTessellationModeAMD: TglTessellationModeAMD; + + // GL_AMD_draw_buffers_blend + glBlendFuncIndexedAMD: TglBlendFuncIndexedAMD; + glBlendFuncSeparateIndexedAMD: TglBlendFuncSeparateIndexedAMD; + glBlendEquationIndexedAMD: TglBlendEquationIndexedAMD; + glBlendEquationSeparateIndexedAMD: TglBlendEquationSeparateIndexedAMD; + + // GL_AMD_name_gen_delete + glGenNamesAMD: TglGenNamesAMD; + glDeleteNamesAMD: TglDeleteNamesAMD; + glIsNameAMD: TglIsNameAMD; + + // GL_AMD_debug_output + glDebugMessageEnableAMD: TglDebugMessageEnableAMD; + glDebugMessageInsertAMD: TglDebugMessageInsertAMD; + glDebugMessageCallbackAMD: TglDebugMessageCallbackAMD; + glGetDebugMessageLogAMD: TglGetDebugMessageLogAMD; + + // GL_EXT_blend_color + glBlendColorEXT: TglBlendColorEXT; + + // GL_EXT_blend_func_separate + glBlendFuncSeparateEXT: TglBlendFuncSeparateEXT; + + // GL_EXT_blend_minmax + glBlendEquationEXT: TglBlendEquationEXT; + + // GL_EXT_color_subtable + glColorSubTableEXT: TglColorSubTableEXT; + glCopyColorSubTableEXT: TglCopyColorSubTableEXT; + + // GL_EXT_compiled_vertex_array + glLockArraysEXT: TglLockArraysEXT; + glUnlockArraysEXT: TglUnlockArraysEXT; + + // GL_EXT_convolution + glConvolutionFilter1DEXT: TglConvolutionFilter1DEXT; + glConvolutionFilter2DEXT: TglConvolutionFilter2DEXT; + glConvolutionParameterfEXT: TglConvolutionParameterfEXT; + glConvolutionParameterfvEXT: TglConvolutionParameterfvEXT; + glConvolutionParameteriEXT: TglConvolutionParameteriEXT; + glConvolutionParameterivEXT: TglConvolutionParameterivEXT; + glCopyConvolutionFilter1DEXT: TglCopyConvolutionFilter1DEXT; + glCopyConvolutionFilter2DEXT: TglCopyConvolutionFilter2DEXT; + glGetConvolutionFilterEXT: TglGetConvolutionFilterEXT; + glGetConvolutionParameterfvEXT: TglGetConvolutionParameterfvEXT; + glGetConvolutionParameterivEXT: TglGetConvolutionParameterivEXT; + glGetSeparableFilterEXT: TglGetSeparableFilterEXT; + glSeparableFilter2DEXT: TglSeparableFilter2DEXT; + + // GL_EXT_coordinate_frame + glTangent3bEXT: TglTangent3bEXT; + glTangent3bvEXT: TglTangent3bvEXT; + glTangent3dEXT: TglTangent3dEXT; + glTangent3dvEXT: TglTangent3dvEXT; + glTangent3fEXT: TglTangent3fEXT; + glTangent3fvEXT: TglTangent3fvEXT; + glTangent3iEXT: TglTangent3iEXT; + glTangent3ivEXT: TglTangent3ivEXT; + glTangent3sEXT: TglTangent3sEXT; + glTangent3svEXT: TglTangent3svEXT; + glBinormal3bEXT: TglBinormal3bEXT; + glBinormal3bvEXT: TglBinormal3bvEXT; + glBinormal3dEXT: TglBinormal3dEXT; + glBinormal3dvEXT: TglBinormal3dvEXT; + glBinormal3fEXT: TglBinormal3fEXT; + glBinormal3fvEXT: TglBinormal3fvEXT; + glBinormal3iEXT: TglBinormal3iEXT; + glBinormal3ivEXT: TglBinormal3ivEXT; + glBinormal3sEXT: TglBinormal3sEXT; + glBinormal3svEXT: TglBinormal3svEXT; + glTangentPointerEXT: TglTangentPointerEXT; + glBinormalPointerEXT: TglBinormalPointerEXT; + + // GL_EXT_copy_texture + glCopyTexImage1DEXT: TglCopyTexImage1DEXT; + glCopyTexImage2DEXT: TglCopyTexImage2DEXT; + glCopyTexSubImage1DEXT: TglCopyTexSubImage1DEXT; + glCopyTexSubImage2DEXT: TglCopyTexSubImage2DEXT; + glCopyTexSubImage3DEXT: TglCopyTexSubImage3DEXT; + + // GL_EXT_cull_vertex + glCullParameterdvEXT: TglCullParameterdvEXT; + glCullParameterfvEXT: TglCullParameterfvEXT; + + // GL_EXT_draw_range_elements + glDrawRangeElementsEXT: TglDrawRangeElementsEXT; + + // GL_EXT_fog_coord + glFogCoordfEXT: TglFogCoordfEXT; + glFogCoordfvEXT: TglFogCoordfvEXT; + glFogCoorddEXT: TglFogCoorddEXT; + glFogCoorddvEXT: TglFogCoorddvEXT; + glFogCoordPointerEXT: TglFogCoordPointerEXT; + + // GL_EXT_framebuffer_object + glIsRenderbufferEXT: TglIsRenderbufferEXT; + glBindRenderbufferEXT: TglBindRenderbufferEXT; + glDeleteRenderbuffersEXT: TglDeleteRenderbuffersEXT; + glGenRenderbuffersEXT: TglGenRenderbuffersEXT; + glRenderbufferStorageEXT: TglRenderbufferStorageEXT; + glGetRenderbufferParameterivEXT: TglGetRenderbufferParameterivEXT; + glIsFramebufferEXT: TglIsFramebufferEXT; + glBindFramebufferEXT: TglBindFramebufferEXT; + glDeleteFramebuffersEXT: TglDeleteFramebuffersEXT; + glGenFramebuffersEXT: TglGenFramebuffersEXT; + glCheckFramebufferStatusEXT: TglCheckFramebufferStatusEXT; + glFramebufferTexture1DEXT: TglFramebufferTexture1DEXT; + glFramebufferTexture2DEXT: TglFramebufferTexture2DEXT; + glFramebufferTexture3DEXT: TglFramebufferTexture3DEXT; + glFramebufferRenderbufferEXT: TglFramebufferRenderbufferEXT; + glGetFramebufferAttachmentParameterivEXT: TglGetFramebufferAttachmentParameterivEXT; + glGenerateMipmapEXT: TglGenerateMipmapEXT; + + // GL_EXT_histogram + glGetHistogramEXT: TglGetHistogramEXT; + glGetHistogramParameterfvEXT: TglGetHistogramParameterfvEXT; + glGetHistogramParameterivEXT: TglGetHistogramParameterivEXT; + glGetMinmaxEXT: TglGetMinmaxEXT; + glGetMinmaxParameterfvEXT: TglGetMinmaxParameterfvEXT; + glGetMinmaxParameterivEXT: TglGetMinmaxParameterivEXT; + glHistogramEXT: TglHistogramEXT; + glMinmaxEXT: TglMinmaxEXT; + glResetHistogramEXT: TglResetHistogramEXT; + glResetMinmaxEXT: TglResetMinmaxEXT; + + // GL_EXT_index_func + glIndexFuncEXT: TglIndexFuncEXT; + + // GL_EXT_index_material + glIndexMaterialEXT: TglIndexMaterialEXT; + + // GL_EXT_light_texture + glApplyTextureEXT: TglApplyTextureEXT; + glTextureLightEXT: TglTextureLightEXT; + glTextureMaterialEXT: TglTextureMaterialEXT; + + // GL_EXT_multi_draw_arrays + glMultiDrawArraysEXT: TglMultiDrawArraysEXT; + glMultiDrawElementsEXT: TglMultiDrawElementsEXT; + + // GL_EXT_multisample + glSampleMaskEXT: TglSampleMaskEXT; + glSamplePatternEXT: TglSamplePatternEXT; + + // GL_EXT_paletted_texture + glColorTableEXT: TglColorTableEXT; + glGetColorTableEXT: TglGetColorTableEXT; + glGetColorTableParameterivEXT: TglGetColorTableParameterivEXT; + glGetColorTableParameterfvEXT: TglGetColorTableParameterfvEXT; + + // GL_EXT_pixel_transform + glPixelTransformParameteriEXT: TglPixelTransformParameteriEXT; + glPixelTransformParameterfEXT: TglPixelTransformParameterfEXT; + glPixelTransformParameterivEXT: TglPixelTransformParameterivEXT; + glPixelTransformParameterfvEXT: TglPixelTransformParameterfvEXT; + + // GL_EXT_point_parameters + glPointParameterfEXT: TglPointParameterfEXT; + glPointParameterfvEXT: TglPointParameterfvEXT; + + // GL_EXT_polygon_offset + glPolygonOffsetEXT: TglPolygonOffsetEXT; + + // GL_EXT_secondary_color + glSecondaryColor3bEXT: TglSecondaryColor3bEXT; + glSecondaryColor3bvEXT: TglSecondaryColor3bvEXT; + glSecondaryColor3dEXT: TglSecondaryColor3dEXT; + glSecondaryColor3dvEXT: TglSecondaryColor3dvEXT; + glSecondaryColor3fEXT: TglSecondaryColor3fEXT; + glSecondaryColor3fvEXT: TglSecondaryColor3fvEXT; + glSecondaryColor3iEXT: TglSecondaryColor3iEXT; + glSecondaryColor3ivEXT: TglSecondaryColor3ivEXT; + glSecondaryColor3sEXT: TglSecondaryColor3sEXT; + glSecondaryColor3svEXT: TglSecondaryColor3svEXT; + glSecondaryColor3ubEXT: TglSecondaryColor3ubEXT; + glSecondaryColor3ubvEXT: TglSecondaryColor3ubvEXT; + glSecondaryColor3uiEXT: TglSecondaryColor3uiEXT; + glSecondaryColor3uivEXT: TglSecondaryColor3uivEXT; + glSecondaryColor3usEXT: TglSecondaryColor3usEXT; + glSecondaryColor3usvEXT: TglSecondaryColor3usvEXT; + glSecondaryColorPointerEXT: TglSecondaryColorPointerEXT; + + // GL_EXT_stencil_two_side + glActiveStencilFaceEXT: TglActiveStencilFaceEXT; + + // GL_EXT_subtexture + glTexSubImage1DEXT: TglTexSubImage1DEXT; + glTexSubImage2DEXT: TglTexSubImage2DEXT; + + // GL_EXT_texture3D + glTexImage3DEXT: TglTexImage3DEXT; + glTexSubImage3DEXT: TglTexSubImage3DEXT; + + // GL_EXT_texture_object + glAreTexturesResidentEXT: TglAreTexturesResidentEXT; + glBindTextureEXT: TglBindTextureEXT; + glDeleteTexturesEXT: TglDeleteTexturesEXT; + glGenTexturesEXT: TglGenTexturesEXT; + glIsTextureEXT: TglIsTextureEXT; + glPrioritizeTexturesEXT: TglPrioritizeTexturesEXT; + + // GL_EXT_texture_perturb_normal + glTextureNormalEXT: TglTextureNormalEXT; + + // GL_EXT_vertex_array + glArrayElementEXT: TglArrayElementEXT; + glColorPointerEXT: TglColorPointerEXT; + glDrawArraysEXT: TglDrawArraysEXT; + glEdgeFlagPointerEXT: TglEdgeFlagPointerEXT; + glGetPointervEXT: TglGetPointervEXT; + glIndexPointerEXT: TglIndexPointerEXT; + glNormalPointerEXT: TglNormalPointerEXT; + glTexCoordPointerEXT: TglTexCoordPointerEXT; + glVertexPointerEXT: TglVertexPointerEXT; + + // GL_EXT_vertex_shader + glBeginVertexShaderEXT: TglBeginVertexShaderEXT; + glEndVertexShaderEXT: TglEndVertexShaderEXT; + glBindVertexShaderEXT: TglBindVertexShaderEXT; + glGenVertexShadersEXT: TglGenVertexShadersEXT; + glDeleteVertexShaderEXT: TglDeleteVertexShaderEXT; + glShaderOp1EXT: TglShaderOp1EXT; + glShaderOp2EXT: TglShaderOp2EXT; + glShaderOp3EXT: TglShaderOp3EXT; + glSwizzleEXT: TglSwizzleEXT; + glWriteMaskEXT: TglWriteMaskEXT; + glInsertComponentEXT: TglInsertComponentEXT; + glExtractComponentEXT: TglExtractComponentEXT; + glGenSymbolsEXT: TglGenSymbolsEXT; + glSetInvariantEXT: TglSetInvariantEXT; + glSetLocalConstantEXT: TglSetLocalConstantEXT; + glVariantbvEXT: TglVariantbvEXT; + glVariantsvEXT: TglVariantsvEXT; + glVariantivEXT: TglVariantivEXT; + glVariantfvEXT: TglVariantfvEXT; + glVariantdvEXT: TglVariantdvEXT; + glVariantubvEXT: TglVariantubvEXT; + glVariantusvEXT: TglVariantusvEXT; + glVariantuivEXT: TglVariantuivEXT; + glVariantPointerEXT: TglVariantPointerEXT; + glEnableVariantClientStateEXT: TglEnableVariantClientStateEXT; + glDisableVariantClientStateEXT: TglDisableVariantClientStateEXT; + glBindLightParameterEXT: TglBindLightParameterEXT; + glBindMaterialParameterEXT: TglBindMaterialParameterEXT; + glBindTexGenParameterEXT: TglBindTexGenParameterEXT; + glBindTextureUnitParameterEXT: TglBindTextureUnitParameterEXT; + glBindParameterEXT: TglBindParameterEXT; + glIsVariantEnabledEXT: TglIsVariantEnabledEXT; + glGetVariantBooleanvEXT: TglGetVariantBooleanvEXT; + glGetVariantIntegervEXT: TglGetVariantIntegervEXT; + glGetVariantFloatvEXT: TglGetVariantFloatvEXT; + glGetVariantPointervEXT: TglGetVariantPointervEXT; + glGetInvariantBooleanvEXT: TglGetInvariantBooleanvEXT; + glGetInvariantIntegervEXT: TglGetInvariantIntegervEXT; + glGetInvariantFloatvEXT: TglGetInvariantFloatvEXT; + glGetLocalConstantBooleanvEXT: TglGetLocalConstantBooleanvEXT; + glGetLocalConstantIntegervEXT: TglGetLocalConstantIntegervEXT; + glGetLocalConstantFloatvEXT: TglGetLocalConstantFloatvEXT; + + // GL_EXT_vertex_weighting + glVertexWeightfEXT: TglVertexWeightfEXT; + glVertexWeightfvEXT: TglVertexWeightfvEXT; + glVertexWeightPointerEXT: TglVertexWeightPointerEXT; + + // GL_EXT_stencil_clear_tag + glStencilClearTagEXT: TglStencilClearTagEXT; + + // GL_EXT_framebuffer_blit + glBlitFramebufferEXT: TglBlitFramebufferEXT; + + // GL_EXT_framebuffer_multisample + glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT; + + // GL_EXT_timer_query + glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT; + glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT; + + // GL_EXT_gpu_program_parameters + glProgramEnvParameters4fvEXT: TglProgramEnvParameters4fvEXT; + glProgramLocalParameters4fvEXT: TglProgramLocalParameters4fvEXT; + + // GL_EXT_bindable_uniform + glUniformBufferEXT: TglUniformBufferEXT; + glGetUniformBufferSizeEXT: TglGetUniformBufferSizeEXT; + glGetUniformOffsetEXT: TglGetUniformOffsetEXT; + + // GL_EXT_draw_buffers2 + glColorMaskIndexedEXT: TglColorMaskIndexedEXT; + glGetBooleanIndexedvEXT: TglGetBooleanIndexedvEXT; + glGetIntegerIndexedvEXT: TglGetIntegerIndexedvEXT; + glEnableIndexedEXT: TglEnableIndexedEXT; + glDisableIndexedEXT: TglDisableIndexedEXT; + glIsEnabledIndexedEXT: TglIsEnabledIndexedEXT; + + // GL_EXT_draw_instanced + glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT; + glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT; + + // GL_EXT_geometry_shader4 + glProgramParameteriEXT: TglProgramParameteriEXT; + glFramebufferTextureEXT: TglFramebufferTextureEXT; +// glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT; + glFramebufferTextureFaceEXT: TglFramebufferTextureFaceEXT; + + // GL_EXT_gpu_shader4 + glVertexAttribI1iEXT: TglVertexAttribI1iEXT; + glVertexAttribI2iEXT: TglVertexAttribI2iEXT; + glVertexAttribI3iEXT: TglVertexAttribI3iEXT; + glVertexAttribI4iEXT: TglVertexAttribI4iEXT; + glVertexAttribI1uiEXT: TglVertexAttribI1uiEXT; + glVertexAttribI2uiEXT: TglVertexAttribI2uiEXT; + glVertexAttribI3uiEXT: TglVertexAttribI3uiEXT; + glVertexAttribI4uiEXT: TglVertexAttribI4uiEXT; + glVertexAttribI1ivEXT: TglVertexAttribI1ivEXT; + glVertexAttribI2ivEXT: TglVertexAttribI2ivEXT; + glVertexAttribI3ivEXT: TglVertexAttribI3ivEXT; + glVertexAttribI4ivEXT: TglVertexAttribI4ivEXT; + glVertexAttribI1uivEXT: TglVertexAttribI1uivEXT; + glVertexAttribI2uivEXT: TglVertexAttribI2uivEXT; + glVertexAttribI3uivEXT: TglVertexAttribI3uivEXT; + glVertexAttribI4uivEXT: TglVertexAttribI4uivEXT; + glVertexAttribI4bvEXT: TglVertexAttribI4bvEXT; + glVertexAttribI4svEXT: TglVertexAttribI4svEXT; + glVertexAttribI4ubvEXT: TglVertexAttribI4ubvEXT; + glVertexAttribI4usvEXT: TglVertexAttribI4usvEXT; + glVertexAttribIPointerEXT: TglVertexAttribIPointerEXT; + glGetVertexAttribIivEXT: TglGetVertexAttribIivEXT; + glGetVertexAttribIuivEXT: TglGetVertexAttribIuivEXT; + glUniform1uiEXT: TglUniform1uiEXT; + glUniform2uiEXT: TglUniform2uiEXT; + glUniform3uiEXT: TglUniform3uiEXT; + glUniform4uiEXT: TglUniform4uiEXT; + glUniform1uivEXT: TglUniform1uivEXT; + glUniform2uivEXT: TglUniform2uivEXT; + glUniform3uivEXT: TglUniform3uivEXT; + glUniform4uivEXT: TglUniform4uivEXT; + glGetUniformuivEXT: TglGetUniformuivEXT; + glBindFragDataLocationEXT: TglBindFragDataLocationEXT; + glGetFragDataLocationEXT: TglGetFragDataLocationEXT; + + // GL_EXT_texture_array + glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT; + + // GL_EXT_texture_buffer_object + glTexBufferEXT: TglTexBufferEXT; + + // GL_EXT_texture_integer + glClearColorIiEXT: TglClearColorIiEXT; + glClearColorIuiEXT: TglClearColorIuiEXT; + glTexParameterIivEXT: TglTexParameterIivEXT; + glTexParameterIuivEXT: TglTexParameterIuivEXT; + glGetTexParameterIivEXT: TglGetTexParameterIivEXT; + glGetTexParameterIiuvEXT: TglGetTexParameterIiuvEXT; + + // GL_EXT_transform_feedback + glBeginTransformFeedbackEXT: TglBeginTransformFeedbackEXT; + glEndTransformFeedbackEXT: TglEndTransformFeedbackEXT; + glBindBufferRangeEXT: TglBindBufferRangeEXT; + glBindBufferOffsetEXT: TglBindBufferOffsetEXT; + glBindBufferBaseEXT: TglBindBufferBaseEXT; + glTransformFeedbackVaryingsEXT: TglTransformFeedbackVaryingsEXT; + glGetTransformFeedbackVaryingEXT: TglGetTransformFeedbackVaryingEXT; + + // GL_EXT_direct_state_access + glClientAttribDefaultEXT: TglClientAttribDefaultEXT; + glPushClientAttribDefaultEXT: TglPushClientAttribDefaultEXT; + glMatrixLoadfEXT: TglMatrixLoadfEXT; + glMatrixLoaddEXT: TglMatrixLoaddEXT; + glMatrixMultfEXT: TglMatrixMultfEXT; + glMatrixMultdEXT: TglMatrixMultdEXT; + glMatrixLoadIdentityEXT: TglMatrixLoadIdentityEXT; + glMatrixRotatefEXT: TglMatrixRotatefEXT; + glMatrixRotatedEXT: TglMatrixRotatedEXT; + glMatrixScalefEXT: TglMatrixScalefEXT; + glMatrixScaledEXT: TglMatrixScaledEXT; + glMatrixTranslatefEXT: TglMatrixTranslatefEXT; + glMatrixTranslatedEXT: TglMatrixTranslatedEXT; + glMatrixFrustumEXT: TglMatrixFrustumEXT; + glMatrixOrthoEXT: TglMatrixOrthoEXT; + glMatrixPopEXT: TglMatrixPopEXT; + glMatrixPushEXT: TglMatrixPushEXT; + glMatrixLoadTransposefEXT: TglMatrixLoadTransposefEXT; + glMatrixLoadTransposedEXT: TglMatrixLoadTransposedEXT; + glMatrixMultTransposefEXT: TglMatrixMultTransposefEXT; + glMatrixMultTransposedEXT: TglMatrixMultTransposedEXT; + glTextureParameterfEXT: TglTextureParameterfEXT; + glTextureParameterfvEXT: TglTextureParameterfvEXT; + glTextureParameteriEXT: TglTextureParameteriEXT; + glTextureParameterivEXT: TglTextureParameterivEXT; + glTextureImage1DEXT: TglTextureImage1DEXT; + glTextureImage2DEXT: TglTextureImage2DEXT; + glTextureSubImage1DEXT: TglTextureSubImage1DEXT; + glTextureSubImage2DEXT: TglTextureSubImage2DEXT; + glCopyTextureImage1DEXT: TglCopyTextureImage1DEXT; + glCopyTextureImage2DEXT: TglCopyTextureImage2DEXT; + glCopyTextureSubImage1DEXT: TglCopyTextureSubImage1DEXT; + glCopyTextureSubImage2DEXT: TglCopyTextureSubImage2DEXT; + glGetTextureImageEXT: TglGetTextureImageEXT; + glGetTextureParameterfvEXT: TglGetTextureParameterfvEXT; + glGetTextureParameterivEXT: TglGetTextureParameterivEXT; + glGetTextureLevelParameterfvEXT: TglGetTextureLevelParameterfvEXT; + glGetTextureLevelParameterivEXT: TglGetTextureLevelParameterivEXT; + glTextureImage3DEXT: TglTextureImage3DEXT; + glTextureSubImage3DEXT: TglTextureSubImage3DEXT; + glCopyTextureSubImage3DEXT: TglCopyTextureSubImage3DEXT; + glMultiTexParameterfEXT: TglMultiTexParameterfEXT; + glMultiTexParameterfvEXT: TglMultiTexParameterfvEXT; + glMultiTexParameteriEXT: TglMultiTexParameteriEXT; + glMultiTexParameterivEXT: TglMultiTexParameterivEXT; + glMultiTexImage1DEXT: TglMultiTexImage1DEXT; + glMultiTexImage2DEXT: TglMultiTexImage2DEXT; + glMultiTexSubImage1DEXT: TglMultiTexSubImage1DEXT; + glMultiTexSubImage2DEXT: TglMultiTexSubImage2DEXT; + glCopyMultiTexImage1DEXT: TglCopyMultiTexImage1DEXT; + glCopyMultiTexImage2DEXT: TglCopyMultiTexImage2DEXT; + glCopyMultiTexSubImage1DEXT: TglCopyMultiTexSubImage1DEXT; + glCopyMultiTexSubImage2DEXT: TglCopyMultiTexSubImage2DEXT; + glGetMultiTexImageEXT: TglGetMultiTexImageEXT; + glGetMultiTexParameterfvEXT: TglGetMultiTexParameterfvEXT; + glGetMultiTexParameterivEXT: TglGetMultiTexParameterivEXT; + glGetMultiTexLevelParameterfvEXT: TglGetMultiTexLevelParameterfvEXT; + glGetMultiTexLevelParameterivEXT: TglGetMultiTexLevelParameterivEXT; + glMultiTexImage3DEXT: TglMultiTexImage3DEXT; + glMultiTexSubImage3DEXT: TglMultiTexSubImage3DEXT; + glCopyMultiTexSubImage3DEXT: TglCopyMultiTexSubImage3DEXT; + glBindMultiTextureEXT: TglBindMultiTextureEXT; + glEnableClientStateIndexedEXT: TglEnableClientStateIndexedEXT; + glDisableClientStateIndexedEXT: TglDisableClientStateIndexedEXT; + glMultiTexCoordPointerEXT: TglMultiTexCoordPointerEXT; + glMultiTexEnvfEXT: TglMultiTexEnvfEXT; + glMultiTexEnvfvEXT: TglMultiTexEnvfvEXT; + glMultiTexEnviEXT: TglMultiTexEnviEXT; + glMultiTexEnvivEXT: TglMultiTexEnvivEXT; + glMultiTexGendEXT: TglMultiTexGendEXT; + glMultiTexGendvEXT: TglMultiTexGendvEXT; + glMultiTexGenfEXT: TglMultiTexGenfEXT; + glMultiTexGenfvEXT: TglMultiTexGenfvEXT; + glMultiTexGeniEXT: TglMultiTexGeniEXT; + glMultiTexGenivEXT: TglMultiTexGenivEXT; + glGetMultiTexEnvfvEXT: TglGetMultiTexEnvfvEXT; + glGetMultiTexEnvivEXT: TglGetMultiTexEnvivEXT; + glGetMultiTexGendvEXT: TglGetMultiTexGendvEXT; + glGetMultiTexGenfvEXT: TglGetMultiTexGenfvEXT; + glGetMultiTexGenivEXT: TglGetMultiTexGenivEXT; + glGetFloatIndexedvEXT: TglGetFloatIndexedvEXT; + glGetDoubleIndexedvEXT: TglGetDoubleIndexedvEXT; + glGetPointerIndexedvEXT: TglGetPointerIndexedvEXT; + glCompressedTextureImage3DEXT: TglCompressedTextureImage3DEXT; + glCompressedTextureImage2DEXT: TglCompressedTextureImage2DEXT; + glCompressedTextureImage1DEXT: TglCompressedTextureImage1DEXT; + glCompressedTextureSubImage3DEXT: TglCompressedTextureSubImage3DEXT; + glCompressedTextureSubImage2DEXT: TglCompressedTextureSubImage2DEXT; + glCompressedTextureSubImage1DEXT: TglCompressedTextureSubImage1DEXT; + glGetCompressedTextureImageEXT: TglGetCompressedTextureImageEXT; + glCompressedMultiTexImage3DEXT: TglCompressedMultiTexImage3DEXT; + glCompressedMultiTexImage2DEXT: TglCompressedMultiTexImage2DEXT; + glCompressedMultiTexImage1DEXT: TglCompressedMultiTexImage1DEXT; + glCompressedMultiTexSubImage3DEXT: TglCompressedMultiTexSubImage3DEXT; + glCompressedMultiTexSubImage2DEXT: TglCompressedMultiTexSubImage2DEXT; + glCompressedMultiTexSubImage1DEXT: TglCompressedMultiTexSubImage1DEXT; + glGetCompressedMultiTexImageEXT: TglGetCompressedMultiTexImageEXT; + glNamedProgramStringEXT: TglNamedProgramStringEXT; + glNamedProgramLocalParameter4dEXT: TglNamedProgramLocalParameter4dEXT; + glNamedProgramLocalParameter4dvEXT: TglNamedProgramLocalParameter4dvEXT; + glNamedProgramLocalParameter4fEXT: TglNamedProgramLocalParameter4fEXT; + glNamedProgramLocalParameter4fvEXT: TglNamedProgramLocalParameter4fvEXT; + glGetNamedProgramLocalParameterdvEXT: TglGetNamedProgramLocalParameterdvEXT; + glGetNamedProgramLocalParameterfvEXT: TglGetNamedProgramLocalParameterfvEXT; + glGetNamedProgramivEXT: TglGetNamedProgramivEXT; + glGetNamedProgramStringEXT: TglGetNamedProgramStringEXT; + glNamedProgramLocalParameters4fvEXT: TglNamedProgramLocalParameters4fvEXT; + glNamedProgramLocalParameterI4iEXT: TglNamedProgramLocalParameterI4iEXT; + glNamedProgramLocalParameterI4ivEXT: TglNamedProgramLocalParameterI4ivEXT; + glNamedProgramLocalParametersI4ivEXT: TglNamedProgramLocalParametersI4ivEXT; + glNamedProgramLocalParameterI4uiEXT: TglNamedProgramLocalParameterI4uiEXT; + glNamedProgramLocalParameterI4uivEXT: TglNamedProgramLocalParameterI4uivEXT; + glNamedProgramLocalParametersI4uivEXT: TglNamedProgramLocalParametersI4uivEXT; + glGetNamedProgramLocalParameterIivEXT: TglGetNamedProgramLocalParameterIivEXT; + glGetNamedProgramLocalParameterIuivEXT: TglGetNamedProgramLocalParameterIuivEXT; + glTextureParameterIivEXT: TglTextureParameterIivEXT; + glTextureParameterIuivEXT: TglTextureParameterIuivEXT; + glGetTextureParameterIivEXT: TglGetTextureParameterIivEXT; + glGetTextureParameterIuivEXT: TglGetTextureParameterIuivEXT; + glMultiTexParameterIivEXT: TglMultiTexParameterIivEXT; + glMultiTexParameterIuivEXT: TglMultiTexParameterIuivEXT; + glGetMultiTexParameterIivEXT: TglGetMultiTexParameterIivEXT; + glGetMultiTexParameterIuivEXT: TglGetMultiTexParameterIuivEXT; + glProgramUniform1fEXT: TglProgramUniform1fEXT; + glProgramUniform2fEXT: TglProgramUniform2fEXT; + glProgramUniform3fEXT: TglProgramUniform3fEXT; + glProgramUniform4fEXT: TglProgramUniform4fEXT; + glProgramUniform1iEXT: TglProgramUniform1iEXT; + glProgramUniform2iEXT: TglProgramUniform2iEXT; + glProgramUniform3iEXT: TglProgramUniform3iEXT; + glProgramUniform4iEXT: TglProgramUniform4iEXT; + glProgramUniform1fvEXT: TglProgramUniform1fvEXT; + glProgramUniform2fvEXT: TglProgramUniform2fvEXT; + glProgramUniform3fvEXT: TglProgramUniform3fvEXT; + glProgramUniform4fvEXT: TglProgramUniform4fvEXT; + glProgramUniform1ivEXT: TglProgramUniform1ivEXT; + glProgramUniform2ivEXT: TglProgramUniform2ivEXT; + glProgramUniform3ivEXT: TglProgramUniform3ivEXT; + glProgramUniform4ivEXT: TglProgramUniform4ivEXT; + glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT; + glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT; + glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT; + glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT; + glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT; + glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT; + glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT; + glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT; + glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT; + glProgramUniform1uiEXT: TglProgramUniform1uiEXT; + glProgramUniform2uiEXT: TglProgramUniform2uiEXT; + glProgramUniform3uiEXT: TglProgramUniform3uiEXT; + glProgramUniform4uiEXT: TglProgramUniform4uiEXT; + glProgramUniform1uivEXT: TglProgramUniform1uivEXT; + glProgramUniform2uivEXT: TglProgramUniform2uivEXT; + glProgramUniform3uivEXT: TglProgramUniform3uivEXT; + glProgramUniform4uivEXT: TglProgramUniform4uivEXT; + glNamedBufferDataEXT: TglNamedBufferDataEXT; + glNamedBufferSubDataEXT: TglNamedBufferSubDataEXT; + glMapNamedBufferEXT: TglMapNamedBufferEXT; + glUnmapNamedBufferEXT: TglUnmapNamedBufferEXT; + glMapNamedBufferRangeEXT: TglMapNamedBufferRangeEXT; + glFlushMappedNamedBufferRangeEXT: TglFlushMappedNamedBufferRangeEXT; + glNamedCopyBufferSubDataEXT: TglNamedCopyBufferSubDataEXT; + glGetNamedBufferParameterivEXT: TglGetNamedBufferParameterivEXT; + glGetNamedBufferPointervEXT: TglGetNamedBufferPointervEXT; + glGetNamedBufferSubDataEXT: TglGetNamedBufferSubDataEXT; + glTextureBufferEXT: TglTextureBufferEXT; + glMultiTexBufferEXT: TglMultiTexBufferEXT; + glNamedRenderbufferStorageEXT: TglNamedRenderbufferStorageEXT; + glGetNamedRenderbufferParameterivEXT: TglGetNamedRenderbufferParameterivEXT; + glCheckNamedFramebufferStatusEXT: TglCheckNamedFramebufferStatusEXT; + glNamedFramebufferTexture1DEXT: TglNamedFramebufferTexture1DEXT; + glNamedFramebufferTexture2DEXT: TglNamedFramebufferTexture2DEXT; + glNamedFramebufferTexture3DEXT: TglNamedFramebufferTexture3DEXT; + glNamedFramebufferRenderbufferEXT: TglNamedFramebufferRenderbufferEXT; + glGetNamedFramebufferAttachmentParameterivEXT: TglGetNamedFramebufferAttachmentParameterivEXT; + glGenerateTextureMipmapEXT: TglGenerateTextureMipmapEXT; + glGenerateMultiTexMipmapEXT: TglGenerateMultiTexMipmapEXT; + glFramebufferDrawBufferEXT: TglFramebufferDrawBufferEXT; + glFramebufferDrawBuffersEXT: TglFramebufferDrawBuffersEXT; + glFramebufferReadBufferEXT: TglFramebufferReadBufferEXT; + glGetFramebufferParameterivEXT: TglGetFramebufferParameterivEXT; + glNamedRenderbufferStorageMultisampleEXT: TglNamedRenderbufferStorageMultisampleEXT; + glNamedRenderbufferStorageMultisampleCoverageEXT: TglNamedRenderbufferStorageMultisampleCoverageEXT; + glNamedFramebufferTextureEXT: TglNamedFramebufferTextureEXT; + glNamedFramebufferTextureLayerEXT: TglNamedFramebufferTextureLayerEXT; + glNamedFramebufferTextureFaceEXT: TglNamedFramebufferTextureFaceEXT; + glTextureRenderbufferEXT: TglTextureRenderbufferEXT; + glMultiTexRenderbufferEXT: TglMultiTexRenderbufferEXT; + glProgramUniform1dEXT: TglProgramUniform1dEXT; + glProgramUniform2dEXT: TglProgramUniform2dEXT; + glProgramUniform3dEXT: TglProgramUniform3dEXT; + glProgramUniform4dEXT: TglProgramUniform4dEXT; + glProgramUniform1dvEXT: TglProgramUniform1dvEXT; + glProgramUniform2dvEXT: TglProgramUniform2dvEXT; + glProgramUniform3dvEXT: TglProgramUniform3dvEXT; + glProgramUniform4dvEXT: TglProgramUniform4dvEXT; + glProgramUniformMatrix2dvEXT: TglProgramUniformMatrix2dvEXT; + glProgramUniformMatrix3dvEXT: TglProgramUniformMatrix3dvEXT; + glProgramUniformMatrix4dvEXT: TglProgramUniformMatrix4dvEXT; + glProgramUniformMatrix2x3dvEXT: TglProgramUniformMatrix2x3dvEXT; + glProgramUniformMatrix2x4dvEXT: TglProgramUniformMatrix2x4dvEXT; + glProgramUniformMatrix3x2dvEXT: TglProgramUniformMatrix3x2dvEXT; + glProgramUniformMatrix3x4dvEXT: TglProgramUniformMatrix3x4dvEXT; + glProgramUniformMatrix4x2dvEXT: TglProgramUniformMatrix4x2dvEXT; + glProgramUniformMatrix4x3dvEXT: TglProgramUniformMatrix4x3dvEXT; + + // GL_EXT_separate_shader_objects + glUseShaderProgramEXT: TglUseShaderProgramEXT; + glActiveProgramEXT: TglActiveProgramEXT; + glCreateShaderProgramEXT: TglCreateShaderProgramEXT; + + // GL_EXT_shader_image_load_store + glBindImageTextureEXT: TglBindImageTextureEXT; + glMemoryBarrierEXT: TglMemoryBarrierEXT; + + // GL_EXT_vertex_attrib_64bit + glVertexAttribL1dEXT: TglVertexAttribL1dEXT; + glVertexAttribL2dEXT: TglVertexAttribL2dEXT; + glVertexAttribL3dEXT: TglVertexAttribL3dEXT; + glVertexAttribL4dEXT: TglVertexAttribL4dEXT; + glVertexAttribL1dvEXT: TglVertexAttribL1dvEXT; + glVertexAttribL2dvEXT: TglVertexAttribL2dvEXT; + glVertexAttribL3dvEXT: TglVertexAttribL3dvEXT; + glVertexAttribL4dvEXT: TglVertexAttribL4dvEXT; + glVertexAttribLPointerEXT: TglVertexAttribLPointerEXT; + glGetVertexAttribLdvEXT: TglGetVertexAttribLdvEXT; + glVertexArrayVertexAttribLOffsetEXT: TglVertexArrayVertexAttribLOffsetEXT; + + // GL_HP_image_transform + glImageTransformParameteriHP: TglImageTransformParameteriHP; + glImageTransformParameterfHP: TglImageTransformParameterfHP; + glImageTransformParameterivHP: TglImageTransformParameterivHP; + glImageTransformParameterfvHP: TglImageTransformParameterfvHP; + glGetImageTransformParameterivHP: TglGetImageTransformParameterivHP; + glGetImageTransformParameterfvHP: TglGetImageTransformParameterfvHP; + + // GL_EXT_depth_bounds_test + glDepthBoundsEXT: TglDepthBoundsEXT; + + // GL_EXT_blend_equation_separate + glBlendEquationSeparateEXT: TglBlendEquationSeparateEXT; + + // GL_IBM_multimode_draw_arrays + glMultiModeDrawArraysIBM: TglMultiModeDrawArraysIBM; + glMultiModeDrawElementsIBM: TglMultiModeDrawElementsIBM; + + // GL_IBM_vertex_array_lists + glColorPointerListIBM: TglColorPointerListIBM; + glSecondaryColorPointerListIBM: TglSecondaryColorPointerListIBM; + glEdgeFlagPointerListIBM: TglEdgeFlagPointerListIBM; + glFogCoordPointerListIBM: TglFogCoordPointerListIBM; + glIndexPointerListIBM: TglIndexPointerListIBM; + glNormalPointerListIBM: TglNormalPointerListIBM; + glTexCoordPointerListIBM: TglTexCoordPointerListIBM; + glVertexPointerListIBM: TglVertexPointerListIBM; + + // GL_INGR_blend_func_separate + glBlendFuncSeparateINGR: TglBlendFuncSeparateINGR; + + // GL_INTEL_parallel_arrays + glVertexPointervINTEL: TglVertexPointervINTEL; + glNormalPointervINTEL: TglNormalPointervINTEL; + glColorPointervINTEL: TglColorPointervINTEL; + glTexCoordPointervINTEL: TglTexCoordPointervINTEL; + + // GL_MESA_resize_buffers + glResizeBuffersMESA: TglResizeBuffersMESA; + + // GL_MESA_window_pos + glWindowPos2dMESA: TglWindowPos2dMESA; + glWindowPos2dvMESA: TglWindowPos2dvMESA; + glWindowPos2fMESA: TglWindowPos2fMESA; + glWindowPos2fvMESA: TglWindowPos2fvMESA; + glWindowPos2iMESA: TglWindowPos2iMESA; + glWindowPos2ivMESA: TglWindowPos2ivMESA; + glWindowPos2sMESA: TglWindowPos2sMESA; + glWindowPos2svMESA: TglWindowPos2svMESA; + glWindowPos3dMESA: TglWindowPos3dMESA; + glWindowPos3dvMESA: TglWindowPos3dvMESA; + glWindowPos3fMESA: TglWindowPos3fMESA; + glWindowPos3fvMESA: TglWindowPos3fvMESA; + glWindowPos3iMESA: TglWindowPos3iMESA; + glWindowPos3ivMESA: TglWindowPos3ivMESA; + glWindowPos3sMESA: TglWindowPos3sMESA; + glWindowPos3svMESA: TglWindowPos3svMESA; + glWindowPos4dMESA: TglWindowPos4dMESA; + glWindowPos4dvMESA: TglWindowPos4dvMESA; + glWindowPos4fMESA: TglWindowPos4fMESA; + glWindowPos4fvMESA: TglWindowPos4fvMESA; + glWindowPos4iMESA: TglWindowPos4iMESA; + glWindowPos4ivMESA: TglWindowPos4ivMESA; + glWindowPos4sMESA: TglWindowPos4sMESA; + glWindowPos4svMESA: TglWindowPos4svMESA; + + // GL_NV_evaluators + glMapControlPointsNV: TglMapControlPointsNV; + glMapParameterivNV: TglMapParameterivNV; + glMapParameterfvNV: TglMapParameterfvNV; + glGetMapControlPointsNV: TglGetMapControlPointsNV; + glGetMapParameterivNV: TglGetMapParameterivNV; + glGetMapParameterfvNV: TglGetMapParameterfvNV; + glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV; + glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV; + glEvalMapsNV: TglEvalMapsNV; + + // GL_NV_fence + glDeleteFencesNV: TglDeleteFencesNV; + glGenFencesNV: TglGenFencesNV; + glIsFenceNV: TglIsFenceNV; + glTestFenceNV: TglTestFenceNV; + glGetFenceivNV: TglGetFenceivNV; + glFinishFenceNV: TglFinishFenceNV; + glSetFenceNV: TglSetFenceNV; + + // GL_NV_fragment_program + glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV; + glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV; + glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV; + glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV; + glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV; + glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV; + + // GL_NV_half_float + glVertex2hNV: TglVertex2hNV; + glVertex2hvNV: TglVertex2hvNV; + glVertex3hNV: TglVertex3hNV; + glVertex3hvNV: TglVertex3hvNV; + glVertex4hNV: TglVertex4hNV; + glVertex4hvNV: TglVertex4hvNV; + glNormal3hNV: TglNormal3hNV; + glNormal3hvNV: TglNormal3hvNV; + glColor3hNV: TglColor3hNV; + glColor3hvNV: TglColor3hvNV; + glColor4hNV: TglColor4hNV; + glColor4hvNV: TglColor4hvNV; + glTexCoord1hNV: TglTexCoord1hNV; + glTexCoord1hvNV: TglTexCoord1hvNV; + glTexCoord2hNV: TglTexCoord2hNV; + glTexCoord2hvNV: TglTexCoord2hvNV; + glTexCoord3hNV: TglTexCoord3hNV; + glTexCoord3hvNV: TglTexCoord3hvNV; + glTexCoord4hNV: TglTexCoord4hNV; + glTexCoord4hvNV: TglTexCoord4hvNV; + glMultiTexCoord1hNV: TglMultiTexCoord1hNV; + glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV; + glMultiTexCoord2hNV: TglMultiTexCoord2hNV; + glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV; + glMultiTexCoord3hNV: TglMultiTexCoord3hNV; + glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV; + glMultiTexCoord4hNV: TglMultiTexCoord4hNV; + glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV; + glFogCoordhNV: TglFogCoordhNV; + glFogCoordhvNV: TglFogCoordhvNV; + glSecondaryColor3hNV: TglSecondaryColor3hNV; + glSecondaryColor3hvNV: TglSecondaryColor3hvNV; + glVertexWeighthNV: TglVertexWeighthNV; + glVertexWeighthvNV: TglVertexWeighthvNV; + glVertexAttrib1hNV: TglVertexAttrib1hNV; + glVertexAttrib1hvNV: TglVertexAttrib1hvNV; + glVertexAttrib2hNV: TglVertexAttrib2hNV; + glVertexAttrib2hvNV: TglVertexAttrib2hvNV; + glVertexAttrib3hNV: TglVertexAttrib3hNV; + glVertexAttrib3hvNV: TglVertexAttrib3hvNV; + glVertexAttrib4hNV: TglVertexAttrib4hNV; + glVertexAttrib4hvNV: TglVertexAttrib4hvNV; + glVertexAttribs1hvNV: TglVertexAttribs1hvNV; + glVertexAttribs2hvNV: TglVertexAttribs2hvNV; + glVertexAttribs3hvNV: TglVertexAttribs3hvNV; + glVertexAttribs4hvNV: TglVertexAttribs4hvNV; + + // GL_NV_occlusion_query + glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV; + glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV; + glIsOcclusionQueryNV: TglIsOcclusionQueryNV; + glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV; + glEndOcclusionQueryNV: TglEndOcclusionQueryNV; + glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV; + glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV; + + // GL_NV_pixel_data_range + glPixelDataRangeNV: TglPixelDataRangeNV; + glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV; + + // GL_NV_point_sprite + glPointParameteriNV: TglPointParameteriNV; + glPointParameterivNV: TglPointParameterivNV; + + // GL_NV_primitive_restart + glPrimitiveRestartNV: TglPrimitiveRestartNV; + glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV; + + // GL_NV_register_combiners + glCombinerParameterfvNV: TglCombinerParameterfvNV; + glCombinerParameterfNV: TglCombinerParameterfNV; + glCombinerParameterivNV: TglCombinerParameterivNV; + glCombinerParameteriNV: TglCombinerParameteriNV; + glCombinerInputNV: TglCombinerInputNV; + glCombinerOutputNV: TglCombinerOutputNV; + glFinalCombinerInputNV: TglFinalCombinerInputNV; + glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV; + glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV; + glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV; + glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV; + glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV; + glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV; + + // GL_NV_register_combiners2 + glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV; + glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV; + + // GL_NV_vertex_array_range + glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV; + glVertexArrayRangeNV: TglVertexArrayRangeNV; + + // GL_NV_vertex_program + glAreProgramsResidentNV: TglAreProgramsResidentNV; + glBindProgramNV: TglBindProgramNV; + glDeleteProgramsNV: TglDeleteProgramsNV; + glExecuteProgramNV: TglExecuteProgramNV; + glGenProgramsNV: TglGenProgramsNV; + glGetProgramParameterdvNV: TglGetProgramParameterdvNV; + glGetProgramParameterfvNV: TglGetProgramParameterfvNV; + glGetProgramivNV: TglGetProgramivNV; + glGetProgramStringNV: TglGetProgramStringNV; + glGetTrackMatrixivNV: TglGetTrackMatrixivNV; + glGetVertexAttribdvNV: TglGetVertexAttribdvNV; + glGetVertexAttribfvNV: TglGetVertexAttribfvNV; + glGetVertexAttribivNV: TglGetVertexAttribivNV; + glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV; + glIsProgramNV: TglIsProgramNV; + glLoadProgramNV: TglLoadProgramNV; + glProgramParameter4dNV: TglProgramParameter4dNV; + glProgramParameter4dvNV: TglProgramParameter4dvNV; + glProgramParameter4fNV: TglProgramParameter4fNV; + glProgramParameter4fvNV: TglProgramParameter4fvNV; + glProgramParameters4dvNV: TglProgramParameters4dvNV; + glProgramParameters4fvNV: TglProgramParameters4fvNV; + glRequestResidentProgramsNV: TglRequestResidentProgramsNV; + glTrackMatrixNV: TglTrackMatrixNV; + glVertexAttribPointerNV: TglVertexAttribPointerNV; + glVertexAttrib1dNV: TglVertexAttrib1dNV; + glVertexAttrib1dvNV: TglVertexAttrib1dvNV; + glVertexAttrib1fNV: TglVertexAttrib1fNV; + glVertexAttrib1fvNV: TglVertexAttrib1fvNV; + glVertexAttrib1sNV: TglVertexAttrib1sNV; + glVertexAttrib1svNV: TglVertexAttrib1svNV; + glVertexAttrib2dNV: TglVertexAttrib2dNV; + glVertexAttrib2dvNV: TglVertexAttrib2dvNV; + glVertexAttrib2fNV: TglVertexAttrib2fNV; + glVertexAttrib2fvNV: TglVertexAttrib2fvNV; + glVertexAttrib2sNV: TglVertexAttrib2sNV; + glVertexAttrib2svNV: TglVertexAttrib2svNV; + glVertexAttrib3dNV: TglVertexAttrib3dNV; + glVertexAttrib3dvNV: TglVertexAttrib3dvNV; + glVertexAttrib3fNV: TglVertexAttrib3fNV; + glVertexAttrib3fvNV: TglVertexAttrib3fvNV; + glVertexAttrib3sNV: TglVertexAttrib3sNV; + glVertexAttrib3svNV: TglVertexAttrib3svNV; + glVertexAttrib4dNV: TglVertexAttrib4dNV; + glVertexAttrib4dvNV: TglVertexAttrib4dvNV; + glVertexAttrib4fNV: TglVertexAttrib4fNV; + glVertexAttrib4fvNV: TglVertexAttrib4fvNV; + glVertexAttrib4sNV: TglVertexAttrib4sNV; + glVertexAttrib4svNV: TglVertexAttrib4svNV; + glVertexAttrib4ubNV: TglVertexAttrib4ubNV; + glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV; + glVertexAttribs1dvNV: TglVertexAttribs1dvNV; + glVertexAttribs1fvNV: TglVertexAttribs1fvNV; + glVertexAttribs1svNV: TglVertexAttribs1svNV; + glVertexAttribs2dvNV: TglVertexAttribs2dvNV; + glVertexAttribs2fvNV: TglVertexAttribs2fvNV; + glVertexAttribs2svNV: TglVertexAttribs2svNV; + glVertexAttribs3dvNV: TglVertexAttribs3dvNV; + glVertexAttribs3fvNV: TglVertexAttribs3fvNV; + glVertexAttribs3svNV: TglVertexAttribs3svNV; + glVertexAttribs4dvNV: TglVertexAttribs4dvNV; + glVertexAttribs4fvNV: TglVertexAttribs4fvNV; + glVertexAttribs4svNV: TglVertexAttribs4svNV; + glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV; + + // GL_NV_depth_buffer_float + glDepthRangedNV: TglDepthRangedNV; + glClearDepthdNV: TglClearDepthdNV; + glDepthBoundsdNV: TglDepthBoundsdNV; + + // GL_NV_framebuffer_multisample_coverage + glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV; + + // GL_NV_geometry_program4 + glProgramVertexLimitNV: TglProgramVertexLimitNV; + + // GL_NV_gpu_program4 + glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV; + glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV; + glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV; + glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV; + glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV; + glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV; + glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV; + glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV; + glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV; + glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV; + glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV; + glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV; + glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV; + glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV; + glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV; + glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV; + + // GL_NV_parameter_buffer_object + glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV; + glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV; + glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV; + + // GL_NV_transform_feedback + glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV; + glEndTransformFeedbackNV: TglEndTransformFeedbackNV; + glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV; + glBindBufferRangeNV: TglBindBufferRangeNV; + glBindBufferOffsetNV: TglBindBufferOffsetNV; + glBindBufferBaseNV: TglBindBufferBaseNV; + glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV; + glActiveVaryingNV: TglActiveVaryingNV; + glGetVaryingLocationNV: TglGetVaryingLocationNV; + glGetActiveVaryingNV: TglGetActiveVaryingNV; + glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV; + glTransformFeedbackStreamAttribsNV: TglTransformFeedbackStreamAttribsNV; + + // GL_NV_conditional_render + glBeginConditionalRenderNV: TglBeginConditionalRenderNV; + glEndConditionalRenderNV: TglEndConditionalRenderNV; + + // GL_NV_present_video + glPresentFrameKeyedNV: TglPresentFrameKeyedNV; + glPresentFrameDualFillNV: TglPresentFrameDualFillNV; + glGetVideoivNV: TglGetVideoivNV; + glGetVideouivNV: TglGetVideouivNV; + glGetVideoi64vNV: TglGetVideoi64vNV; + glGetVideoui64vNV: TglGetVideoui64vNV; +// glVideoParameterivNV: TglVideoParameterivNV; + + // GL_NV_explicit_multisample + glGetMultisamplefvNV: TglGetMultisamplefvNV; + glSampleMaskIndexedNV: TglSampleMaskIndexedNV; + glTexRenderbufferNV: TglTexRenderbufferNV; + + // GL_NV_transform_feedback2 + glBindTransformFeedbackNV: TglBindTransformFeedbackNV; + glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV; + glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV; + glIsTransformFeedbackNV: TglIsTransformFeedbackNV; + glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV; + glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV; + glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV; + + // GL_NV_video_capture + glBeginVideoCaptureNV: TglBeginVideoCaptureNV; + glBindVideoCaptureStreamBufferNV: TglBindVideoCaptureStreamBufferNV; + glBindVideoCaptureStreamTextureNV: TglBindVideoCaptureStreamTextureNV; + glEndVideoCaptureNV: TglEndVideoCaptureNV; + glGetVideoCaptureivNV: TglGetVideoCaptureivNV; + glGetVideoCaptureStreamivNV: TglGetVideoCaptureStreamivNV; + glGetVideoCaptureStreamfvNV: TglGetVideoCaptureStreamfvNV; + glGetVideoCaptureStreamdvNV: TglGetVideoCaptureStreamdvNV; + glVideoCaptureNV: TglVideoCaptureNV; + glVideoCaptureStreamParameterivNV: TglVideoCaptureStreamParameterivNV; + glVideoCaptureStreamParameterfvNV: TglVideoCaptureStreamParameterfvNV; + glVideoCaptureStreamParameterdvNV: TglVideoCaptureStreamParameterdvNV; + + // GL_NV_copy_image + glCopyImageSubDataNV: TglCopyImageSubDataNV; + + // GL_NV_shader_buffer_load + glMakeBufferResidentNV: TglMakeBufferResidentNV; + glMakeBufferNonResidentNV: TglMakeBufferNonResidentNV; + glIsBufferResidentNV: TglIsBufferResidentNV; + glMakeNamedBufferResidentNV: TglMakeNamedBufferResidentNV; + glMakeNamedBufferNonResidentNV: TglMakeNamedBufferNonResidentNV; + glIsNamedBufferResidentNV: TglIsNamedBufferResidentNV; + glGetBufferParameterui64vNV: TglGetBufferParameterui64vNV; + glGetNamedBufferParameterui64vNV: TglGetNamedBufferParameterui64vNV; + glGetIntegerui64vNV: TglGetIntegerui64vNV; + glUniformui64NV: TglUniformui64NV; + glUniformui64vNV: TglUniformui64vNV; + glGetUniformui64vNV: TglGetUniformui64vNV; + glProgramUniformui64NV: TglProgramUniformui64NV; + glProgramUniformui64vNV: TglProgramUniformui64vNV; + + // GL_NV_vertex_buffer_unified_memory + glBufferAddressRangeNV: TglBufferAddressRangeNV; + glVertexFormatNV: TglVertexFormatNV; + glNormalFormatNV: TglNormalFormatNV; + glColorFormatNV: TglColorFormatNV; + glIndexFormatNV: TglIndexFormatNV; + glTexCoordFormatNV: TglTexCoordFormatNV; + glEdgeFlagFormatNV: TglEdgeFlagFormatNV; + glSecondaryColorFormatNV: TglSecondaryColorFormatNV; + glFogCoordFormatNV: TglFogCoordFormatNV; + glVertexAttribFormatNV: TglVertexAttribFormatNV; + glVertexAttribIFormatNV: TglVertexAttribIFormatNV; + glGetIntegerui64i_vNV: TglGetIntegerui64i_vNV; + + // GL_NV_gpu_program5 + glProgramSubroutineParametersuivNV: TglProgramSubroutineParametersuivNV; + glGetProgramSubroutineParameteruivNV: TglGetProgramSubroutineParameteruivNV; + + // GL_NV_gpu_shader5 + glUniform1i64NV: TglUniform1i64NV; + glUniform2i64NV: TglUniform2i64NV; + glUniform3i64NV: TglUniform3i64NV; + glUniform4i64NV: TglUniform4i64NV; + glUniform1i64vNV: TglUniform1i64vNV; + glUniform2i64vNV: TglUniform2i64vNV; + glUniform3i64vNV: TglUniform3i64vNV; + glUniform4i64vNV: TglUniform4i64vNV; + glUniform1ui64NV: TglUniform1ui64NV; + glUniform2ui64NV: TglUniform2ui64NV; + glUniform3ui64NV: TglUniform3ui64NV; + glUniform4ui64NV: TglUniform4ui64NV; + glUniform1ui64vNV: TglUniform1ui64vNV; + glUniform2ui64vNV: TglUniform2ui64vNV; + glUniform3ui64vNV: TglUniform3ui64vNV; + glUniform4ui64vNV: TglUniform4ui64vNV; + glGetUniformi64vNV: TglGetUniformi64vNV; + glProgramUniform1i64NV: TglProgramUniform1i64NV; + glProgramUniform2i64NV: TglProgramUniform2i64NV; + glProgramUniform3i64NV: TglProgramUniform3i64NV; + glProgramUniform4i64NV: TglProgramUniform4i64NV; + glProgramUniform1i64vNV: TglProgramUniform1i64vNV; + glProgramUniform2i64vNV: TglProgramUniform2i64vNV; + glProgramUniform3i64vNV: TglProgramUniform3i64vNV; + glProgramUniform4i64vNV: TglProgramUniform4i64vNV; + glProgramUniform1ui64NV: TglProgramUniform1ui64NV; + glProgramUniform2ui64NV: TglProgramUniform2ui64NV; + glProgramUniform3ui64NV: TglProgramUniform3ui64NV; + glProgramUniform4ui64NV: TglProgramUniform4ui64NV; + glProgramUniform1ui64vNV: TglProgramUniform1ui64vNV; + glProgramUniform2ui64vNV: TglProgramUniform2ui64vNV; + glProgramUniform3ui64vNV: TglProgramUniform3ui64vNV; + glProgramUniform4ui64vNV: TglProgramUniform4ui64vNV; + + // GL_NV_vertex_attrib_integer_64bit + glVertexAttribL1i64NV: TglVertexAttribL1i64NV; + glVertexAttribL2i64NV: TglVertexAttribL2i64NV; + glVertexAttribL3i64NV: TglVertexAttribL3i64NV; + glVertexAttribL4i64NV: TglVertexAttribL4i64NV; + glVertexAttribL1i64vNV: TglVertexAttribL1i64vNV; + glVertexAttribL2i64vNV: TglVertexAttribL2i64vNV; + glVertexAttribL3i64vNV: TglVertexAttribL3i64vNV; + glVertexAttribL4i64vNV: TglVertexAttribL4i64vNV; + glVertexAttribL1ui64NV: TglVertexAttribL1ui64NV; + glVertexAttribL2ui64NV: TglVertexAttribL2ui64NV; + glVertexAttribL3ui64NV: TglVertexAttribL3ui64NV; + glVertexAttribL4ui64NV: TglVertexAttribL4ui64NV; + glVertexAttribL1ui64vNV: TglVertexAttribL1ui64vNV; + glVertexAttribL2ui64vNV: TglVertexAttribL2ui64vNV; + glVertexAttribL3ui64vNV: TglVertexAttribL3ui64vNV; + glVertexAttribL4ui64vNV: TglVertexAttribL4ui64vNV; + glGetVertexAttribLi64vNV: TglGetVertexAttribLi64vNV; + glGetVertexAttribLui64vNV: TglGetVertexAttribLui64vNV; + glVertexAttribLFormatNV: TglVertexAttribLFormatNV; + + // GL_NV_vdpau_interop + glVDPAUInitNV: TglVDPAUInitNV; + glVDPAUFiniNV: TglVDPAUFiniNV; + glVDPAURegisterVideoSurfaceNV: TglVDPAURegisterVideoSurfaceNV; + glVDPAURegisterOutputSurfaceNV: TglVDPAURegisterOutputSurfaceNV; + glVDPAUIsSurfaceNV: TglVDPAUIsSurfaceNV; + glVDPAUUnregisterSurfaceNV: TglVDPAUUnregisterSurfaceNV; + glVDPAUGetSurfaceivNV: TglVDPAUGetSurfaceivNV; + glVDPAUSurfaceAccessNV: TglVDPAUSurfaceAccessNV; + glVDPAUMapSurfacesNV: TglVDPAUMapSurfacesNV; + glVDPAUUnmapSurfacesNV: TglVDPAUUnmapSurfacesNV; + + // GL_NV_texture_barrier + glTextureBarrierNV: TglTextureBarrierNV; + + // (4.3) GL_NV_path_rendering + glGenPathsNV : TglGenPathsNV; + glDeletePathsNV : TglDeletePathsNV; + glIsPathNV : TglIsPathNV; + glPathCommandsNV : TglPathCommandsNV; + glPathCoordsNV : TglPathCoordsNV; + glPathSubCommandsNV : TglPathSubCommandsNV; + glPathSubCoordsNV : TglPathSubCoordsNV; + glPathStringNV : TglPathStringNV; + glPathGlyphsNV : TglPathGlyphsNV; + glPathGlyphRangeNV : TglPathGlyphRangeNV; + glWeightPathsNV : TglWeightPathsNV; + glCopyPathNV : TglCopyPathNV; + glInterpolatePathsNV : TglInterpolatePathsNV; + glTransformPathNV : TglTransformPathNV; + glPathParameterivNV : TglPathParameterivNV; + glPathParameteriNV : TglPathParameteriNV; + glPathParameterfvNV : TglPathParameterfvNV; + glPathParameterfNV : TglPathParameterfNV; + glPathDashArrayNV : TglPathDashArrayNV; + glPathStencilFuncNV : TglPathStencilFuncNV; + glPathStencilDepthOffsetNV : TglPathStencilDepthOffsetNV; + glStencilFillPathNV : TglStencilFillPathNV; + glStencilStrokePathNV : TglStencilStrokePathNV; + glStencilFillPathInstancedNV : TglStencilFillPathInstancedNV; + glStencilStrokePathInstancedNV : TglStencilStrokePathInstancedNV; + glPathCoverDepthFuncNV : TglPathCoverDepthFuncNV; + glPathColorGenNV : TglPathColorGenNV; + glPathTexGenNV : TglPathTexGenNV; + glPathFogGenNV : TglPathFogGenNV; + glCoverFillPathNV : TglCoverFillPathNV; + glCoverStrokePathNV : TglCoverStrokePathNV; + glCoverFillPathInstancedNV : TglCoverFillPathInstancedNV; + glCoverStrokePathInstancedNV : TglCoverStrokePathInstancedNV; + glGetPathParameterivNV : TglGetPathParameterivNV; + glGetPathParameterfvNV : TglGetPathParameterfvNV; + glGetPathCommandsNV : TglGetPathCommandsNV; + glGetPathCoordsNV : TglGetPathCoordsNV; + glGetPathDashArrayNV : TglGetPathDashArrayNV; + glGetPathMetricsNV : TglGetPathMetricsNV; + glGetPathMetricRangeNV : TglGetPathMetricRangeNV; + glGetPathSpacingNV : TglGetPathSpacingNV; + glGetPathColorGenivNV : TglGetPathColorGenivNV; + glGetPathColorGenfvNV : TglGetPathColorGenfvNV; + glGetPathTexGenivNV : TglGetPathTexGenivNV; + glGetPathTexGenfvNV : TglGetPathTexGenfvNV; + glIsPointInFillPathNV : TglIsPointInFillPathNV; + glIsPointInStrokePathNV : TglIsPointInStrokePathNV; + glGetPathLengthNV : TglGetPathLengthNV; + glPointAlongPathNV : TglPointAlongPathNV; + + // GL_AMD_pinned_memory + + // GL_AMD_stencil_operation_extended + glStencilOpValueAMD : TglStencilOpValueAMD; + + // GL_AMD_vertex_shader_viewport_index + + // GL_AMD_vertex_shader_layer + + // GL_NV_bindless_texture + glGetTextureHandleNV : TglGetTextureHandleNV; + glGetTextureSamplerHandleNV : TglGetTextureSamplerHandleNV; + glMakeTextureHandleResidentNV : TglMakeTextureHandleResidentNV; + glMakeTextureHandleNonResidentNV : TglMakeTextureHandleNonResidentNV; + glGetImageHandleNV : TglGetImageHandleNV; + glMakeImageHandleResidentNV : TglMakeImageHandleResidentNV; + glMakeImageHandleNonResidentNV : TglMakeImageHandleNonResidentNV; + glUniformHandleui64NV : TglUniformHandleui64NV; + glUniformHandleui64vNV : TglUniformHandleui64vNV; + glProgramUniformHandleui64NV : TglProgramUniformHandleui64NV; + glProgramUniformHandleui64vNV : TglProgramUniformHandleui64vNV; + glIsTextureHandleResidentNV : TglIsTextureHandleResidentNV; + glIsImageHandleResidentNV : TglIsImageHandleResidentNV; + + // + + // GL_PGI_misc_hints + glHintPGI: TglHintPGI; + + // GL_SGIS_detail_texture + glDetailTexFuncSGIS: TglDetailTexFuncSGIS; + glGetDetailTexFuncSGIS: TglGetDetailTexFuncSGIS; + + // GL_SGIS_fog_function + glFogFuncSGIS: TglFogFuncSGIS; + glGetFogFuncSGIS: TglGetFogFuncSGIS; + + // GL_SGIS_multisample + glSampleMaskSGIS: TglSampleMaskSGIS; + glSamplePatternSGIS: TglSamplePatternSGIS; + + // GL_SGIS_pixel_texture + glPixelTexGenParameteriSGIS: TglPixelTexGenParameteriSGIS; + glPixelTexGenParameterivSGIS: TglPixelTexGenParameterivSGIS; + glPixelTexGenParameterfSGIS: TglPixelTexGenParameterfSGIS; + glPixelTexGenParameterfvSGIS: TglPixelTexGenParameterfvSGIS; + glGetPixelTexGenParameterivSGIS: TglGetPixelTexGenParameterivSGIS; + glGetPixelTexGenParameterfvSGIS: TglGetPixelTexGenParameterfvSGIS; + + // GL_SGIS_point_parameters + glPointParameterfSGIS: TglPointParameterfSGIS; + glPointParameterfvSGIS: TglPointParameterfvSGIS; + + // GL_SGIS_sharpen_texture + glSharpenTexFuncSGIS: TglSharpenTexFuncSGIS; + glGetSharpenTexFuncSGIS: TglGetSharpenTexFuncSGIS; + + // GL_SGIS_texture4D + glTexImage4DSGIS: TglTexImage4DSGIS; + glTexSubImage4DSGIS: TglTexSubImage4DSGIS; + + // GL_SGIS_texture_color_mask + glTextureColorMaskSGIS: TglTextureColorMaskSGIS; + + // GL_SGIS_texture_filter4 + glGetTexFilterFuncSGIS: TglGetTexFilterFuncSGIS; + glTexFilterFuncSGIS: TglTexFilterFuncSGIS; + + // GL_SGIX_async + glAsyncMarkerSGIX: TglAsyncMarkerSGIX; + glFinishAsyncSGIX: TglFinishAsyncSGIX; + glPollAsyncSGIX: TglPollAsyncSGIX; + glGenAsyncMarkersSGIX: TglGenAsyncMarkersSGIX; + glDeleteAsyncMarkersSGIX: TglDeleteAsyncMarkersSGIX; + glIsAsyncMarkerSGIX: TglIsAsyncMarkerSGIX; + + // GL_SGIX_flush_raster + glFlushRasterSGIX: TglFlushRasterSGIX; + + // GL_SGIX_fragment_lighting + glFragmentColorMaterialSGIX: TglFragmentColorMaterialSGIX; + glFragmentLightfSGIX: TglFragmentLightfSGIX; + glFragmentLightfvSGIX: TglFragmentLightfvSGIX; + glFragmentLightiSGIX: TglFragmentLightiSGIX; + glFragmentLightivSGIX: TglFragmentLightivSGIX; + glFragmentLightModelfSGIX: TglFragmentLightModelfSGIX; + glFragmentLightModelfvSGIX: TglFragmentLightModelfvSGIX; + glFragmentLightModeliSGIX: TglFragmentLightModeliSGIX; + glFragmentLightModelivSGIX: TglFragmentLightModelivSGIX; + glFragmentMaterialfSGIX: TglFragmentMaterialfSGIX; + glFragmentMaterialfvSGIX: TglFragmentMaterialfvSGIX; + glFragmentMaterialiSGIX: TglFragmentMaterialiSGIX; + glFragmentMaterialivSGIX: TglFragmentMaterialivSGIX; + glGetFragmentLightfvSGIX: TglGetFragmentLightfvSGIX; + glGetFragmentLightivSGIX: TglGetFragmentLightivSGIX; + glGetFragmentMaterialfvSGIX: TglGetFragmentMaterialfvSGIX; + glGetFragmentMaterialivSGIX: TglGetFragmentMaterialivSGIX; + glLightEnviSGIX: TglLightEnviSGIX; + + // GL_SGIX_framezoom + glFrameZoomSGIX: TglFrameZoomSGIX; + + // GL_SGIX_igloo_interface + glIglooInterfaceSGIX: TglIglooInterfaceSGIX; + + // GL_SGIX_instruments + glGetInstrumentsSGIX: TglGetInstrumentsSGIX; + glInstrumentsBufferSGIX: TglInstrumentsBufferSGIX; + glPollInstrumentsSGIX: TglPollInstrumentsSGIX; + glReadInstrumentsSGIX: TglReadInstrumentsSGIX; + glStartInstrumentsSGIX: TglStartInstrumentsSGIX; + glStopInstrumentsSGIX: TglStopInstrumentsSGIX; + + // GL_SGIX_list_priority + glGetListParameterfvSGIX: TglGetListParameterfvSGIX; + glGetListParameterivSGIX: TglGetListParameterivSGIX; + glListParameterfSGIX: TglListParameterfSGIX; + glListParameterfvSGIX: TglListParameterfvSGIX; + glListParameteriSGIX: TglListParameteriSGIX; + glListParameterivSGIX: TglListParameterivSGIX; + + // GL_SGIX_pixel_texture + glPixelTexGenSGIX: TglPixelTexGenSGIX; + + // GL_SGIX_polynomial_ffd + glDeformationMap3dSGIX: TglDeformationMap3dSGIX; + glDeformationMap3fSGIX: TglDeformationMap3fSGIX; + glDeformSGIX: TglDeformSGIX; + glLoadIdentityDeformationMapSGIX: TglLoadIdentityDeformationMapSGIX; + + // GL_SGIX_reference_plane + glReferencePlaneSGIX: TglReferencePlaneSGIX; + + // GL_SGIX_sprite + glSpriteParameterfSGIX: TglSpriteParameterfSGIX; + glSpriteParameterfvSGIX: TglSpriteParameterfvSGIX; + glSpriteParameteriSGIX: TglSpriteParameteriSGIX; + glSpriteParameterivSGIX: TglSpriteParameterivSGIX; + + // GL_SGIX_tag_sample_buffer + glTagSampleBufferSGIX: TglTagSampleBufferSGIX; + + // GL_SGI_color_table + glColorTableSGI: TglColorTableSGI; + glColorTableParameterfvSGI: TglColorTableParameterfvSGI; + glColorTableParameterivSGI: TglColorTableParameterivSGI; + glCopyColorTableSGI: TglCopyColorTableSGI; + glGetColorTableSGI: TglGetColorTableSGI; + glGetColorTableParameterfvSGI: TglGetColorTableParameterfvSGI; + glGetColorTableParameterivSGI: TglGetColorTableParameterivSGI; + + // GL_SUNX_constant_data + glFinishTextureSUNX: TglFinishTextureSUNX; + + // GL_SUN_global_alpha + glGlobalAlphaFactorbSUN: TglGlobalAlphaFactorbSUN; + glGlobalAlphaFactorsSUN: TglGlobalAlphaFactorsSUN; + glGlobalAlphaFactoriSUN: TglGlobalAlphaFactoriSUN; + glGlobalAlphaFactorfSUN: TglGlobalAlphaFactorfSUN; + glGlobalAlphaFactordSUN: TglGlobalAlphaFactordSUN; + glGlobalAlphaFactorubSUN: TglGlobalAlphaFactorubSUN; + glGlobalAlphaFactorusSUN: TglGlobalAlphaFactorusSUN; + glGlobalAlphaFactoruiSUN: TglGlobalAlphaFactoruiSUN; + + // GL_SUN_mesh_array + glDrawMeshArraysSUN: TglDrawMeshArraysSUN; + + // GL_SUN_triangle_list + glReplacementCodeuiSUN: TglReplacementCodeuiSUN; + glReplacementCodeusSUN: TglReplacementCodeusSUN; + glReplacementCodeubSUN: TglReplacementCodeubSUN; + glReplacementCodeuivSUN: TglReplacementCodeuivSUN; + glReplacementCodeusvSUN: TglReplacementCodeusvSUN; + glReplacementCodeubvSUN: TglReplacementCodeubvSUN; + glReplacementCodePointerSUN: TglReplacementCodePointerSUN; + + // GL_SUN_vertex + glColor4ubVertex2fSUN: TglColor4ubVertex2fSUN; + glColor4ubVertex2fvSUN: TglColor4ubVertex2fvSUN; + glColor4ubVertex3fSUN: TglColor4ubVertex3fSUN; + glColor4ubVertex3fvSUN: TglColor4ubVertex3fvSUN; + glColor3fVertex3fSUN: TglColor3fVertex3fSUN; + glColor3fVertex3fvSUN: TglColor3fVertex3fvSUN; + glNormal3fVertex3fSUN: TglNormal3fVertex3fSUN; + glNormal3fVertex3fvSUN: TglNormal3fVertex3fvSUN; + glColor4fNormal3fVertex3fSUN: TglColor4fNormal3fVertex3fSUN; + glColor4fNormal3fVertex3fvSUN: TglColor4fNormal3fVertex3fvSUN; + glTexCoord2fVertex3fSUN: TglTexCoord2fVertex3fSUN; + glTexCoord2fVertex3fvSUN: TglTexCoord2fVertex3fvSUN; + glTexCoord4fVertex4fSUN: TglTexCoord4fVertex4fSUN; + glTexCoord4fVertex4fvSUN: TglTexCoord4fVertex4fvSUN; + glTexCoord2fColor4ubVertex3fSUN: TglTexCoord2fColor4ubVertex3fSUN; + glTexCoord2fColor4ubVertex3fvSUN: TglTexCoord2fColor4ubVertex3fvSUN; + glTexCoord2fColor3fVertex3fSUN: TglTexCoord2fColor3fVertex3fSUN; + glTexCoord2fColor3fVertex3fvSUN: TglTexCoord2fColor3fVertex3fvSUN; + glTexCoord2fNormal3fVertex3fSUN: TglTexCoord2fNormal3fVertex3fSUN; + glTexCoord2fNormal3fVertex3fvSUN: TglTexCoord2fNormal3fVertex3fvSUN; + glTexCoord2fColor4fNormal3fVertex3fSUN: TglTexCoord2fColor4fNormal3fVertex3fSUN; + glTexCoord2fColor4fNormal3fVertex3fvSUN: TglTexCoord2fColor4fNormal3fVertex3fvSUN; + glTexCoord4fColor4fNormal3fVertex4fSUN: TglTexCoord4fColor4fNormal3fVertex4fSUN; + glTexCoord4fColor4fNormal3fVertex4fvSUN: TglTexCoord4fColor4fNormal3fVertex4fvSUN; + glReplacementCodeuiVertex3fSUN: TglReplacementCodeuiVertex3fSUN; + glReplacementCodeuiVertex3fvSUN: TglReplacementCodeuiVertex3fvSUN; + glReplacementCodeuiColor4ubVertex3fSUN: TglReplacementCodeuiColor4ubVertex3fSUN; + glReplacementCodeuiColor4ubVertex3fvSUN: TglReplacementCodeuiColor4ubVertex3fvSUN; + glReplacementCodeuiColor3fVertex3fSUN: TglReplacementCodeuiColor3fVertex3fSUN; + glReplacementCodeuiColor3fVertex3fvSUN: TglReplacementCodeuiColor3fVertex3fvSUN; + glReplacementCodeuiNormal3fVertex3fSUN: TglReplacementCodeuiNormal3fVertex3fSUN; + glReplacementCodeuiNormal3fVertex3fvSUN: TglReplacementCodeuiNormal3fVertex3fvSUN; + glReplacementCodeuiColor4fNormal3fVertex3fSUN: TglReplacementCodeuiColor4fNormal3fVertex3fSUN; + glReplacementCodeuiColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiColor4fNormal3fVertex3fvSUN; + glReplacementCodeuiTexCoord2fVertex3fSUN: TglReplacementCodeuiTexCoord2fVertex3fSUN; + glReplacementCodeuiTexCoord2fVertex3fvSUN: TglReplacementCodeuiTexCoord2fVertex3fvSUN; + glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; + glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; + +{$IFDEF DGL_WIN} + wglGetProcAddress: TwglGetProcAddress; + wglCopyContext: TwglCopyContext; + wglCreateContext: TwglCreateContext; + wglCreateLayerContext: TwglCreateLayerContext; + wglDeleteContext: TwglDeleteContext; + wglDescribeLayerPlane: TwglDescribeLayerPlane; + wglGetCurrentContext: TwglGetCurrentContext; + wglGetCurrentDC: TwglGetCurrentDC; + wglGetLayerPaletteEntries: TwglGetLayerPaletteEntries; + wglMakeCurrent: TwglMakeCurrent; + wglRealizeLayerPalette: TwglRealizeLayerPalette; + wglSetLayerPaletteEntries: TwglSetLayerPaletteEntries; + wglShareLists: TwglShareLists; + wglSwapLayerBuffers: TwglSwapLayerBuffers; + wglSwapMultipleBuffers: TwglSwapMultipleBuffers; + wglUseFontBitmapsA: TwglUseFontBitmapsA; + wglUseFontOutlinesA: TwglUseFontOutlinesA; + wglUseFontBitmapsW: TwglUseFontBitmapsW; + wglUseFontOutlinesW: TwglUseFontOutlinesW; + wglUseFontBitmaps: TwglUseFontBitmaps; + wglUseFontOutlines: TwglUseFontOutlines; + + // WGL_ARB_buffer_region + wglCreateBufferRegionARB: TwglCreateBufferRegionARB; + wglDeleteBufferRegionARB: TwglDeleteBufferRegionARB; + wglSaveBufferRegionARB: TwglSaveBufferRegionARB; + wglRestoreBufferRegionARB: TwglRestoreBufferRegionARB; + + // WGL_ARB_extensions_string + wglGetExtensionsStringARB: TwglGetExtensionsStringARB; + + // WGL_ARB_make_current_read + wglMakeContextCurrentARB: TwglMakeContextCurrentARB; + wglGetCurrentReadDCARB: TwglGetCurrentReadDCARB; + + // WGL_ARB_pbuffer + wglCreatePbufferARB: TwglCreatePbufferARB; + wglGetPbufferDCARB: TwglGetPbufferDCARB; + wglReleasePbufferDCARB: TwglReleasePbufferDCARB; + wglDestroyPbufferARB: TwglDestroyPbufferARB; + wglQueryPbufferARB: TwglQueryPbufferARB; + + // WGL_ARB_pixel_format + wglGetPixelFormatAttribivARB: TwglGetPixelFormatAttribivARB; + wglGetPixelFormatAttribfvARB: TwglGetPixelFormatAttribfvARB; + wglChoosePixelFormatARB: TwglChoosePixelFormatARB; + // WGL_ARB_color_buffer_float + wglClampColorARB: TwglClampColorARB; + + // WGL_ARB_render_texture + wglBindTexImageARB: TwglBindTexImageARB; + wglReleaseTexImageARB: TwglReleaseTexImageARB; + wglSetPbufferAttribARB: TwglSetPbufferAttribARB; + + // WGL_ARB_create_context + wglCreateContextAttribsARB: TwglCreateContextAttribsARB; + + // WGL_AMD_gpu_association + wglGetGPUIDsAMD: TwglGetGPUIDsAMD; + wglGetGPUInfoAMD: TwglGetGPUInfoAMD; + wglGetContextGPUIDAMD: TwglGetContextGPUIDAMD; + wglCreateAssociatedContextAMD: TwglCreateAssociatedContextAMD; + wglCreateAssociatedContextAttribsAMD: TwglCreateAssociatedContextAttribsAMD; + wglDeleteAssociatedContextAMD: TwglDeleteAssociatedContextAMD; + wglMakeAssociatedContextCurrentAMD: TwglMakeAssociatedContextCurrentAMD; + wglGetCurrentAssociatedContextAMD: TwglGetCurrentAssociatedContextAMD; + wglBlitContextFramebufferAMD: TwglBlitContextFramebufferAMD; + + // WGL_EXT_display_color_table + wglCreateDisplayColorTableEXT: TwglCreateDisplayColorTableEXT; + wglLoadDisplayColorTableEXT: TwglLoadDisplayColorTableEXT; + wglBindDisplayColorTableEXT: TwglBindDisplayColorTableEXT; + wglDestroyDisplayColorTableEXT: TwglDestroyDisplayColorTableEXT; + + // WGL_EXT_extensions_string + wglGetExtensionsStringEXT: TwglGetExtensionsStringEXT; + + // WGL_EXT_make_current_read + wglMakeContextCurrentEXT: TwglMakeContextCurrentEXT; + wglGetCurrentReadDCEXT: TwglGetCurrentReadDCEXT; + + // WGL_EXT_pbuffer + wglCreatePbufferEXT: TwglCreatePbufferEXT; + wglGetPbufferDCEXT: TwglGetPbufferDCEXT; + wglReleasePbufferDCEXT: TwglReleasePbufferDCEXT; + wglDestroyPbufferEXT: TwglDestroyPbufferEXT; + wglQueryPbufferEXT: TwglQueryPbufferEXT; + + // WGL_EXT_pixel_format + wglGetPixelFormatAttribivEXT: TwglGetPixelFormatAttribivEXT; + wglGetPixelFormatAttribfvEXT: TwglGetPixelFormatAttribfvEXT; + wglChoosePixelFormatEXT: TwglChoosePixelFormatEXT; + + // WGL_EXT_swap_control + wglSwapIntervalEXT: TwglSwapIntervalEXT; + wglGetSwapIntervalEXT: TwglGetSwapIntervalEXT; + + // WGL_I3D_digital_video_control + wglGetDigitalVideoParametersI3D: TwglGetDigitalVideoParametersI3D; + wglSetDigitalVideoParametersI3D: TwglSetDigitalVideoParametersI3D; + + // WGL_I3D_gamma + wglGetGammaTableParametersI3D: TwglGetGammaTableParametersI3D; + wglSetGammaTableParametersI3D: TwglSetGammaTableParametersI3D; + wglGetGammaTableI3D: TwglGetGammaTableI3D; + wglSetGammaTableI3D: TwglSetGammaTableI3D; + + // WGL_I3D_genlock + wglEnableGenlockI3D: TwglEnableGenlockI3D; + wglDisableGenlockI3D: TwglDisableGenlockI3D; + wglIsEnabledGenlockI3D: TwglIsEnabledGenlockI3D; + wglGenlockSourceI3D: TwglGenlockSourceI3D; + wglGetGenlockSourceI3D: TwglGetGenlockSourceI3D; + wglGenlockSourceEdgeI3D: TwglGenlockSourceEdgeI3D; + wglGetGenlockSourceEdgeI3D: TwglGetGenlockSourceEdgeI3D; + wglGenlockSampleRateI3D: TwglGenlockSampleRateI3D; + wglGetGenlockSampleRateI3D: TwglGetGenlockSampleRateI3D; + wglGenlockSourceDelayI3D: TwglGenlockSourceDelayI3D; + wglGetGenlockSourceDelayI3D: TwglGetGenlockSourceDelayI3D; + wglQueryGenlockMaxSourceDelayI3D: TwglQueryGenlockMaxSourceDelayI3D; + + // WGL_I3D_image_buffer + wglCreateImageBufferI3D: TwglCreateImageBufferI3D; + wglDestroyImageBufferI3D: TwglDestroyImageBufferI3D; + wglAssociateImageBufferEventsI3D: TwglAssociateImageBufferEventsI3D; + wglReleaseImageBufferEventsI3D: TwglReleaseImageBufferEventsI3D; + + // WGL_I3D_swap_frame_lock + wglEnableFrameLockI3D: TwglEnableFrameLockI3D; + wglDisableFrameLockI3D: TwglDisableFrameLockI3D; + wglIsEnabledFrameLockI3D: TwglIsEnabledFrameLockI3D; + wglQueryFrameLockMasterI3D: TwglQueryFrameLockMasterI3D; + + // WGL_I3D_swap_frame_usage + wglGetFrameUsageI3D: TwglGetFrameUsageI3D; + wglBeginFrameTrackingI3D: TwglBeginFrameTrackingI3D; + wglEndFrameTrackingI3D: TwglEndFrameTrackingI3D; + wglQueryFrameTrackingI3D: TwglQueryFrameTrackingI3D; + + // WGL_NV_vertex_array_range + wglAllocateMemoryNV: TwglAllocateMemoryNV; + wglFreeMemoryNV: TwglFreeMemoryNV; + + // WGL_NV_present_video + wglEnumerateVideoDevicesNV: TwglEnumerateVideoDevicesNV; + wglBindVideoDeviceNV: TwglBindVideoDeviceNV; + wglQueryCurrentContextNV: TwglQueryCurrentContextNV; + + // WGL_NV_video_output + wglGetVideoDeviceNV: TwglGetVideoDeviceNV; + wglReleaseVideoDeviceNV: TwglReleaseVideoDeviceNV; + wglBindVideoImageNV: TwglBindVideoImageNV; + wglReleaseVideoImageNV: TwglReleaseVideoImageNV; + wglSendPbufferToVideoNV: TwglSendPbufferToVideoNV; + wglGetVideoInfoNV: TwglGetVideoInfoNV; + + // WGL_NV_swap_group + wglJoinSwapGroupNV: TwglJoinSwapGroupNV; + wglBindSwapBarrierNV: TwglBindSwapBarrierNV; + wglQuerySwapGroupNV: TwglQuerySwapGroupNV; + wglQueryMaxSwapGroupsNV: TwglQueryMaxSwapGroupsNV; + wglQueryFrameCountNV: TwglQueryFrameCountNV; + wglResetFrameCountNV: TwglResetFrameCountNV; + + // WGL_NV_gpu_affinity + wglEnumGpusNV: TwglEnumGpusNV; + wglEnumGpuDevicesNV: TwglEnumGpuDevicesNV; + wglCreateAffinityDCNV: TwglCreateAffinityDCNV; + wglEnumGpusFromAffinityDCNV: TwglEnumGpusFromAffinityDCNV; + wglDeleteDCNV: TwglDeleteDCNV; + + // WGL_NV_video_capture + wglBindVideoCaptureDeviceNV: TwglBindVideoCaptureDeviceNV; + wglEnumerateVideoCaptureDevicesNV: TwglEnumerateVideoCaptureDevicesNV; + wglLockVideoCaptureDeviceNV: TwglLockVideoCaptureDeviceNV; + wglQueryVideoCaptureDeviceNV: TwglQueryVideoCaptureDeviceNV; + wglReleaseVideoCaptureDeviceNV: TwglReleaseVideoCaptureDeviceNV; + + // WGL_NV_copy_image + wglCopyImageSubDataNV: TwglCopyImageSubDataNV; + + // WGL_NV_DX_interop + wglDXSetResourceShareHandleNV : TwglDXSetResourceShareHandleNV; + wglDXOpenDeviceNV : TwglDXOpenDeviceNV; + wglDXCloseDeviceNV : TwglDXCloseDeviceNV; + wglDXRegisterObjectNV : TwglDXRegisterObjectNV; + wglDXUnregisterObjectNV : TwglDXUnregisterObjectNV; + wglDXObjectAccessNV : TwglDXObjectAccessNV; + wglDXLockObjectsNV : TwglDXLockObjectsNV; + wglDXUnlockObjectsNV : TwglDXUnlockObjectsNV; + + // WGL_OML_sync_control + wglGetSyncValuesOML: TwglGetSyncValuesOML; + wglGetMscRateOML: TwglGetMscRateOML; + wglSwapBuffersMscOML: TwglSwapBuffersMscOML; + wglSwapLayerBuffersMscOML: TwglSwapLayerBuffersMscOML; + wglWaitForMscOML: TwglWaitForMscOML; + wglWaitForSbcOML: TwglWaitForSbcOML; + + // WGL_3DL_stereo_control + wglSetStereoEmitterState3DL: TwglSetStereoEmitterState3DL; + + // WIN_draw_range_elements + glDrawRangeElementsWIN: TglDrawRangeElementsWIN; + + // WIN_swap_hint + glAddSwapHintRectWIN: TglAddSwapHintRectWIN; +{$ENDIF} + +{$IFDEF DGL_LINUX} + glXChooseVisual: TglXChooseVisual; + glXCopyContext: TglXCopyContext; + glXCreateContext: TglXCreateContext; + glXCreateGLXPixmap: TglXCreateGLXPixmap; + glXDestroyContext: TglXDestroyContext; + glXDestroyGLXPixmap: TglXDestroyGLXPixmap; + glXGetConfig: TglXGetConfig; + glXGetCurrentContext: TglXGetCurrentContext; + glXGetCurrentDrawable: TglXGetCurrentDrawable; + glXIsDirect: TglXIsDirect; + glXMakeCurrent: TglXMakeCurrent; + glXQueryExtension: TglXQueryExtension; + glXQueryVersion: TglXQueryVersion; + glXSwapBuffers: TglXSwapBuffers; + glXUseXFont: TglXUseXFont; + glXWaitGL: TglXWaitGL; + glXWaitX: TglXWaitX; + + glXGetClientString: TglXGetClientString; + glXQueryServerString: TglXQueryServerString; + glXQueryExtensionsString: TglXQueryExtensionsString; + + // GLX_VERSION_1_3 + glXGetFBConfigs: TglXGetFBConfigs; + glXChooseFBConfig: TglXChooseFBConfig; + glXGetFBConfigAttrib: TglXGetFBConfigAttrib; + glXGetVisualFromFBConfig: TglXGetVisualFromFBConfig; + glXCreateWindow: TglXCreateWindow; + glXDestroyWindow: TglXDestroyWindow; + glXCreatePixmap: TglXCreatePixmap; + + glXDestroyPixmap: TglXDestroyPixmap; + glXCreatePbuffer: TglXCreatePbuffer; + glXDestroyPbuffer: TglXDestroyPbuffer; + glXQueryDrawable: TglXQueryDrawable; + glXCreateNewContext: TglXCreateNewContext; + glXMakeContextCurrent: TglXMakeContextCurrent; + glXGetCurrentReadDrawable: TglXGetCurrentReadDrawable; + glXGetCurreentDisplay: TglXGetCurreentDisplay; + + glXQueryContext: TglXQueryContext; + glXSelectEvent: TglXSelectEvent; + glXGetSelectedEvent: TglXGetSelectedEvent; + + // GLX_VERSION_1_4 + glXGetProcAddress: TglXGetProcAddress; + + // GLX_ARB_get_proc_address + glXGetProcAddressARB: TglXGetProcAddressARB; + + // GLX_ARB_create_context + glXCreateContextAttribsARB: TglXCreateContextAttribsARB; + + // GLX_EXT_import_context + glXGetCurrentDisplayEXT: TglXGetCurrentDisplayEXT; + glXQueryContextInfoEXT: TglXQueryContextInfoEXT; + glXGetContextIDEXT: TglXGetContextIDEXT; + glXImportContextEXT: TglXImportContextEXT; + glXFreeContextEXT: TglXFreeContextEXT; + + // GLX_EXT_texture_from_pixmap + glXBindTexImageEXT: TglXBindTexImageEXT; + glXReleaseTexImageEXT: TglXReleaseTexImageEXT; + + // GLX_EXT_swap_control + glXSwapIntervalEXT: TglXSwapIntervalEXT; +{$ENDIF} + + // GL utility functions and procedures + gluErrorString: TgluErrorString; + gluGetString: TgluGetString; + gluOrtho2D: TgluOrtho2D; + gluPerspective: TgluPerspective; + gluPickMatrix: TgluPickMatrix; + gluLookAt: TgluLookAt; + gluProject: TgluProject; + gluUnProject: TgluUnProject; + gluScaleImage: TgluScaleImage; + gluBuild1DMipmaps: TgluBuild1DMipmaps; + gluBuild2DMipmaps: TgluBuild2DMipmaps; + gluNewQuadric: TgluNewQuadric; + gluDeleteQuadric: TgluDeleteQuadric; + gluQuadricNormals: TgluQuadricNormals; + gluQuadricTexture: TgluQuadricTexture; + gluQuadricOrientation: TgluQuadricOrientation; + gluQuadricDrawStyle: TgluQuadricDrawStyle; + gluCylinder: TgluCylinder; + gluDisk: TgluDisk; + gluPartialDisk: TgluPartialDisk; + gluSphere: TgluSphere; + gluQuadricCallback: TgluQuadricCallback; + gluNewTess: TgluNewTess; + gluDeleteTess: TgluDeleteTess; + gluTessBeginPolygon: TgluTessBeginPolygon; + gluTessBeginContour: TgluTessBeginContour; + gluTessVertex: TgluTessVertex; + gluTessEndContour: TgluTessEndContour; + gluTessEndPolygon: TgluTessEndPolygon; + gluTessProperty: TgluTessProperty; + gluTessNormal: TgluTessNormal; + gluTessCallback: TgluTessCallback; + gluGetTessProperty: TgluGetTessProperty; + gluNewNurbsRenderer: TgluNewNurbsRenderer; + gluDeleteNurbsRenderer: TgluDeleteNurbsRenderer; + gluBeginSurface: TgluBeginSurface; + gluBeginCurve: TgluBeginCurve; + gluEndCurve: TgluEndCurve; + gluEndSurface: TgluEndSurface; + gluBeginTrim: TgluBeginTrim; + gluEndTrim: TgluEndTrim; + gluPwlCurve: TgluPwlCurve; + gluNurbsCurve: TgluNurbsCurve; + gluNurbsSurface: TgluNurbsSurface; + gluLoadSamplingMatrices: TgluLoadSamplingMatrices; + gluNurbsProperty: TgluNurbsProperty; + gluGetNurbsProperty: TgluGetNurbsProperty; + gluNurbsCallback: TgluNurbsCallback; + gluBeginPolygon: TgluBeginPolygon; + gluNextContour: TgluNextContour; + gluEndPolygon: TgluEndPolygon; + + +type + TRCOptions = set of (opDoubleBuffered, opGDI, opStereo); + +var + GL_LibHandle: Pointer = nil; + GLU_LibHandle: Pointer = nil; + + LastPixelFormat: Integer; + ExtensionsRead: Boolean; + ImplementationRead: Boolean; + + +const +{$IFDEF DGL_WIN} + OPENGL_LIBNAME = 'OpenGL32.dll'; + GLU_LIBNAME = 'GLU32.dll'; +{$ELSE} + {$IFDEF darwin} + OPENGL_LIBNAME = 'libGL.dylib'; + GLU_LIBNAME = 'libGLU.dylib'; + {$ELSE} + OPENGL_LIBNAME = 'libGL.so.1'; + GLU_LIBNAME = 'libGLU.so.1'; + {$ENDIF} +{$ENDIF} + +function InitOpenGL(LibName: String = OPENGL_LIBNAME; GLULibName: String = GLU_LIBNAME): Boolean; + +function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer; +function dglCheckExtension(Extension: AnsiString): Boolean; + +procedure ReadExtensions; +procedure ReadImplementationProperties; + +// ============================================================================= +// Helper-Functions +// ============================================================================= +{$IFDEF DGL_WIN} + function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; + function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; + procedure DestroyRenderingContext(RC: HGLRC); + + procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true); + procedure DeactivateRenderingContext; +{$ENDIF} + + +procedure ReadOpenGLCore; +procedure Read_GL_3DFX_tbuffer; +procedure Read_GL_APPLE_element_array; +procedure Read_GL_APPLE_fence; +procedure Read_GL_APPLE_vertex_array_object; +procedure Read_GL_APPLE_vertex_array_range; +procedure Read_GL_APPLE_texture_range; +procedure Read_GL_APPLE_vertex_program_evaluators; +procedure Read_GL_APPLE_object_purgeable; +procedure Read_GL_ARB_matrix_palette; +procedure Read_GL_ARB_multitexture; +procedure Read_GL_ARB_point_parameters; +procedure Read_GL_ARB_texture_compression; +procedure Read_GL_ARB_transpose_matrix; +procedure Read_GL_ARB_vertex_blend; +procedure Read_GL_ARB_vertex_buffer_object; +procedure Read_GL_ARB_vertex_program; +procedure Read_GL_ARB_window_pos; +procedure Read_GL_ARB_color_buffer_float; +procedure Read_GL_ARB_Shader_Objects; +procedure Read_GL_ARB_occlusion_query; +procedure Read_GL_ARB_draw_instanced; +procedure Read_GL_ARB_framebuffer_object; +procedure Read_GL_ARB_geometry_shader4; +procedure Read_GL_ARB_instanced_arrays; +procedure Read_GL_ARB_map_buffer_range; +procedure Read_GL_ARB_texture_buffer_object; +procedure Read_GL_ARB_vertex_array_object; +procedure Read_GL_ARB_uniform_buffer_object; +procedure Read_GL_ARB_copy_buffer; +procedure Read_GL_ARB_draw_elements_base_vertex; +procedure Read_GL_ARB_provoking_vertex; +procedure Read_GL_ARB_sync; +procedure Read_GL_ARB_texture_multisample; +procedure Read_GL_ARB_draw_buffers_blend; +procedure Read_GL_ARB_sample_shading; +procedure Read_GL_ARB_shading_language_include; +procedure Read_GL_ARB_blend_func_extended; +procedure Read_GL_ARB_sampler_objects; +procedure Read_GL_ARB_timer_query; +procedure Read_GL_ARB_vertex_type_2_10_10_10_rev; +procedure Read_GL_ARB_draw_indirect; +procedure Read_GL_ARB_gpu_shader_fp64; +procedure Read_GL_ARB_shader_subroutine; +procedure Read_GL_ARB_tessellation_shader; +procedure Read_GL_ARB_transform_feedback2; +procedure Read_GL_ARB_transform_feedback3; +procedure Read_GL_ARB_ES2_compatibility; +procedure Read_GL_ARB_get_program_binary; +procedure Read_GL_ARB_separate_shader_objects; +procedure Read_GL_ARB_vertex_attrib_64bit; +procedure Read_GL_ARB_viewport_array; +// GL 4.2 +procedure Read_GL_ARB_base_instance; +procedure Read_GL_ARB_transform_feedback_instanced; +procedure Read_GL_ARB_internalformat_query; +procedure Read_GL_ARB_shader_atomic_counters; +procedure Read_GL_ARB_shader_image_load_store; +procedure Read_GL_ARB_texture_storage; +// GL 4.3 +procedure Read_GL_KHR_debug; +procedure Read_GL_ARB_clear_buffer_object; +procedure Read_GL_ARB_compute_shader; +procedure Read_GL_ARB_copy_image; +procedure Read_GL_ARB_framebuffer_no_attachments; +procedure Read_GL_ARB_internalformat_query2; +procedure Read_GL_ARB_invalidate_subdata; +procedure Read_GL_ARB_multi_draw_indirect; +procedure Read_GL_ARB_program_interface_query; +procedure Read_GL_ARB_shader_storage_buffer_object; +procedure Read_GL_ARB_texture_buffer_range; +procedure Read_GL_ARB_texture_storage_multisample; +procedure Read_GL_ARB_texture_view; +procedure Read_GL_ARB_vertex_attrib_binding; + +// GL 4.4 +procedure Read_GL_4_4; + +// +procedure Read_GL_ARB_cl_event; +procedure Read_GL_ARB_debug_output; +procedure Read_GL_ARB_robustness; +procedure Read_GL_ATI_draw_buffers; +procedure Read_GL_ATI_element_array; +procedure Read_GL_ATI_envmap_bumpmap; +procedure Read_GL_ATI_fragment_shader; +procedure Read_GL_ATI_map_object_buffer; +procedure Read_GL_ATI_pn_triangles; +procedure Read_GL_ATI_separate_stencil; +procedure Read_GL_ATI_vertex_array_object; +procedure Read_GL_ATI_vertex_attrib_array_object; +procedure Read_GL_ATI_vertex_streams; +procedure Read_GL_AMD_performance_monitor; +procedure Read_GL_AMD_vertex_shader_tesselator; +procedure Read_GL_AMD_draw_buffers_blend; +procedure Read_GL_AMD_name_gen_delete; +procedure Read_GL_AMD_debug_output; +procedure Read_GL_EXT_blend_color; +procedure Read_GL_EXT_blend_func_separate; +procedure Read_GL_EXT_blend_minmax; +procedure Read_GL_EXT_color_subtable; +procedure Read_GL_EXT_compiled_vertex_array; +procedure Read_GL_EXT_convolution; +procedure Read_GL_EXT_coordinate_frame; +procedure Read_GL_EXT_copy_texture; +procedure Read_GL_EXT_cull_vertex; +procedure Read_GL_EXT_draw_range_elements; +procedure Read_GL_EXT_fog_coord; +procedure Read_GL_EXT_framebuffer_object; +procedure Read_GL_EXT_histogram; +procedure Read_GL_EXT_index_func; +procedure Read_GL_EXT_index_material; +procedure Read_GL_EXT_multi_draw_arrays; +procedure Read_GL_EXT_multisample; +procedure Read_GL_EXT_paletted_texture; +procedure Read_GL_EXT_pixel_transform; +procedure Read_GL_EXT_point_parameters; +procedure Read_GL_EXT_polygon_offset; +procedure Read_GL_EXT_secondary_color; +procedure Read_GL_EXT_stencil_two_side; +procedure Read_GL_EXT_subtexture; +procedure Read_GL_EXT_texture3D; +procedure Read_GL_EXT_texture_object; +procedure Read_GL_EXT_texture_perturb_normal; +procedure Read_GL_EXT_vertex_array; +procedure Read_GL_EXT_vertex_shader; +procedure Read_GL_EXT_vertex_weighting; +procedure Read_GL_EXT_depth_bounds_test; +procedure Read_GL_EXT_blend_equation_separate; +procedure Read_GL_EXT_stencil_clear_tag; +procedure Read_GL_EXT_framebuffer_blit; +procedure Read_GL_EXT_framebuffer_multisample; +procedure Read_GL_EXT_timer_query; +procedure Read_GL_EXT_gpu_program_parameters; +procedure Read_GL_EXT_bindable_uniform; +procedure Read_GL_EXT_draw_buffers2; +procedure Read_GL_EXT_draw_instanced; +procedure Read_GL_EXT_geometry_shader4; +procedure Read_GL_EXT_gpu_shader4; +procedure Read_GL_EXT_texture_array; +procedure Read_GL_EXT_texture_buffer_object; +procedure Read_GL_EXT_texture_integer; +procedure Read_GL_EXT_transform_feedback; +procedure Read_GL_EXT_direct_state_access; +procedure Read_GL_EXT_separate_shader_objects; +procedure Read_GL_EXT_shader_image_load_store; +procedure Read_GL_EXT_vertex_attrib_64bit; +procedure Read_GL_HP_image_transform; +procedure Read_GL_IBM_multimode_draw_arrays; +procedure Read_GL_IBM_vertex_array_lists; +procedure Read_GL_INGR_blend_func_separate; +procedure Read_GL_INTEL_parallel_arrays; +procedure Read_GL_MESA_resize_buffers; +procedure Read_GL_MESA_window_pos; +procedure Read_GL_NV_evaluators; +procedure Read_GL_NV_fence; +procedure Read_GL_NV_fragment_program; +procedure Read_GL_NV_half_float; +procedure Read_GL_NV_occlusion_query; +procedure Read_GL_NV_pixel_data_range; +procedure Read_GL_NV_point_sprite; +procedure Read_GL_NV_primitive_restart; +procedure Read_GL_NV_register_combiners; +procedure Read_GL_NV_register_combiners2; +procedure Read_GL_NV_vertex_array_range; +procedure Read_GL_NV_vertex_program; +procedure Read_GL_NV_depth_buffer_float; +procedure Read_GL_NV_framebuffer_multisample_coverage; +procedure Read_GL_NV_geometry_program4; +procedure Read_GL_NV_gpu_program4; +procedure Read_GL_NV_parameter_buffer_object; +procedure Read_GL_NV_transform_feedback; +procedure Read_GL_NV_conditional_render; +procedure Read_GL_NV_present_video; +procedure Read_GL_NV_explicit_multisample; +procedure Read_GL_NV_transform_feedback2; +procedure Read_GL_NV_video_capture; +procedure Read_GL_NV_copy_image; +procedure Read_GL_NV_shader_buffer_load; +procedure Read_GL_NV_vertex_buffer_unified_memory; +procedure Read_GL_NV_gpu_program5; +procedure Read_GL_NV_gpu_shader5; +procedure Read_GL_NV_vertex_attrib_integer_64bit; +procedure Read_GL_NV_vdpau_interop; +procedure Read_GL_NV_texture_barrier; +procedure Read_GL_PGI_misc_hints; +procedure Read_GL_SGIS_detail_texture; +procedure Read_GL_SGIS_fog_function; +procedure Read_GL_SGIS_multisample; +procedure Read_GL_SGIS_pixel_texture; +procedure Read_GL_SGIS_point_parameters; +procedure Read_GL_SGIS_sharpen_texture; +procedure Read_GL_SGIS_texture4D; +procedure Read_GL_SGIS_texture_color_mask; +procedure Read_GL_SGIS_texture_filter4; +procedure Read_GL_SGIX_async; +procedure Read_GL_SGIX_flush_raster; +procedure Read_GL_SGIX_fragment_lighting; +procedure Read_GL_SGIX_framezoom; +procedure Read_GL_SGIX_igloo_interface; +procedure Read_GL_SGIX_instruments; +procedure Read_GL_SGIX_list_priority; +procedure Read_GL_SGIX_pixel_texture; +procedure Read_GL_SGIX_polynomial_ffd; +procedure Read_GL_SGIX_reference_plane; +procedure Read_GL_SGIX_sprite; +procedure Read_GL_SGIX_tag_sample_buffer; +procedure Read_GL_SGI_color_table; +procedure Read_GL_SUNX_constant_data; +procedure Read_GL_SUN_global_alpha; +procedure Read_GL_SUN_mesh_array; +procedure Read_GL_SUN_triangle_list; +procedure Read_GL_SUN_vertex; + +{$IFDEF DGL_WIN} +procedure Read_WGL_ARB_buffer_region; +procedure Read_WGL_ARB_extensions_string; +procedure Read_WGL_ARB_make_current_read; +procedure Read_WGL_ARB_pbuffer; +procedure Read_WGL_ARB_pixel_format; +procedure Read_WGL_ARB_pixel_format_float; +procedure Read_WGL_ARB_render_texture; +procedure Read_WGL_ARB_create_context; +procedure Read_WGL_AMD_gpu_association; +procedure Read_WGL_EXT_display_color_table; +procedure Read_WGL_EXT_extensions_string; +procedure Read_WGL_EXT_make_current_read; +procedure Read_WGL_EXT_pbuffer; +procedure Read_WGL_EXT_pixel_format; +procedure Read_WGL_EXT_swap_control; +procedure Read_WGL_I3D_digital_video_control; +procedure Read_WGL_I3D_gamma; +procedure Read_WGL_I3D_genlock; +procedure Read_WGL_I3D_image_buffer; +procedure Read_WGL_I3D_swap_frame_lock; +procedure Read_WGL_I3D_swap_frame_usage; +procedure Read_WGL_NV_vertex_array_range; +procedure Read_WGL_NV_present_video; +procedure Read_WGL_NV_video_output; +procedure Read_WGL_NV_swap_group; +procedure Read_WGL_NV_gpu_affinity; +procedure Read_WGL_NV_video_capture; +procedure Read_WGL_NV_copy_image; +procedure Read_WGL_OML_sync_control; +procedure Read_WGL_3DL_stereo_control; + +procedure Read_WIN_draw_range_elements; +procedure Read_WIN_swap_hint; +{$ENDIF} + + +implementation + + +{$IFDEF DGL_LINUX} +const + RTLD_LAZY = $001; + RTLD_NOW = $002; + RTLD_BINDING_MASK = $003; + + // Seems to work on Debian / Fedora + LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF}; + +function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen'; +function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose'; + +function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym'; +{$ENDIF} + +{$IFDEF DGL_MAC}{$IFDEF OPENGL_FRAMEWORK} // OpenGL framework used +const + RTLD_DEFAULT = Pointer(-2); +{$ENDIF}{$ENDIF} + +function dglLoadLibrary(Name: PChar): Pointer; +begin + {$IFDEF DGL_WIN} + Result := {%H-}Pointer(LoadLibrary(Name)); + {$ENDIF} + + {$IFDEF DGL_LINUX} + Result := dlopen(Name, RTLD_LAZY); + {$ENDIF} + + {$IFDEF DGL_MAC} + {$IFDEF OPENGL_FRAMEWORK} + Result := RTLD_DEFAULT; + {$ELSE} + Result := Pointer(LoadLibrary(Name)); + {$ENDIF} + {$ENDIF} +end; + + +function dglFreeLibrary(LibHandle: Pointer): Boolean; +begin + if LibHandle = nil then + Result := False + else + {$IFDEF DGL_WIN} + Result := FreeLibrary({%H-}HMODULE(LibHandle)); + {$ENDIF} + + {$IFDEF DGL_LINUX} + Result := dlclose(LibHandle) = 0; + {$ENDIF} + + {$IFDEF DGL_MAC} + {$IFDEF OPENGL_FRAMEWORK} + Result := true; + {$ELSE} + Result := FreeLibrary(HMODULE(LibHandle)); + {$ENDIF} + {$ENDIF} +end; + + +function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer; +begin + if LibHandle = nil then + LibHandle := GL_LibHandle; + + Result := nil; + + {$IFDEF DGL_WIN} + Result := GetProcAddress({%H-}HMODULE(LibHandle), ProcName); + + if result <> nil then + exit; + + if Addr(wglGetProcAddress) <> nil then + Result := wglGetProcAddress(ProcName); + {$ENDIF} + + {$IFDEF DGL_LINUX} + if not ForceDLSym then begin + if Addr(glXGetProcAddress) <> nil then + Result := glXGetProcAddress(ProcName); + + if result <> nil then + exit; + + if Addr(glXGetProcAddressARB) <> nil then + Result := glXGetProcAddressARB(ProcName); + + if result <> nil then + exit; + end; + + Result := dlsym(LibHandle, ProcName); + {$ENDIF} + + {$IFDEF DGL_MAC} + Result := GetProcAddress(HMODULE(LibHandle), ProcName); + {$ENDIF} +end; + + +function Int_GetExtensionString: AnsiString; +var + ExtensionCount : GLint; + i : Integer; +begin + if GL_VERSION_3_0 + then + begin + if not Assigned(@glGetIntegerv) then glGetIntegerv := dglGetProcAddress('glGetIntegerv'); + if not Assigned(@glGetStringi) then glGetStringi := dglGetProcAddress('glGetStringi'); + + result := ''; + + if Assigned(@glGetIntegerv) and Assigned(@glGetStringi) + then + begin + glGetIntegerv(GL_NUM_EXTENSIONS, @extensionCount); + + For I := 0 to extensionCount - 1 do + result := result + #32 + PAnsiChar(glGetStringi(GL_EXTENSIONS, I)); + end; + end + else + begin + if not Assigned(@glGetString) then glGetString := dglGetProcAddress('glGetString'); + + if Assigned(@glGetString) + then result := glGetString(GL_EXTENSIONS) + else result := ''; + end; + + if (GL_LibHandle <> nil) then begin + {$IFDEF DGL_WIN} + // wglGetExtensionsStringEXT + if not Assigned(@wglGetExtensionsStringEXT) then + wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT'); + + if Assigned(@wglGetExtensionsStringEXT) then + Result := Result + #32 + wglGetExtensionsStringEXT; + + // wglGetExtensionsStringARB + if not Assigned(@wglGetExtensionsStringARB) then + wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB'); + + if Assigned(@wglGetExtensionsStringARB) then + Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC); + {$ENDIF} + end; + + Result := #32 + Result + #32; +end; + + +function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean; +begin + Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0; +end; + + +function dglCheckExtension(Extension: AnsiString): Boolean; +var + Extensions: AnsiString; +begin + Extensions := Int_GetExtensionString; + Result := Int_CheckExtension(Extensions, Extension); +end; + + + +function InitOpenGL(LibName: String; GLULibName: String): Boolean; +begin + Result := False; + + // free opened libraries + if GL_LibHandle <> nil then + dglFreeLibrary(GL_LibHandle); + + if GLU_LibHandle <> nil then + dglFreeLibrary(GLU_LibHandle); + + // load library + GL_LibHandle := dglLoadLibrary(PChar(LibName)); + GLU_LibHandle := dglLoadLibrary(PChar(GLULibName)); + + // load GL functions + if (GL_LibHandle <> nil) then begin + {$IFDEF DGL_WIN} + wglCopyContext := dglGetProcAddress('wglCopyContext'); + wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext'); + wglCreateContext := dglGetProcAddress('wglCreateContext'); + wglDeleteContext := dglGetProcAddress('wglDeleteContext'); + wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane'); + wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext'); + wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC'); + wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries'); + wglGetProcAddress := dglGetProcAddress('wglGetProcAddress'); + wglMakeCurrent := dglGetProcAddress('wglMakeCurrent'); + wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette'); + wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries'); + wglShareLists := dglGetProcAddress('wglShareLists'); + wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers'); + wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers'); + wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA'); + wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA'); + wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW'); + wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW'); + wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA'); + wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA'); + {$ENDIF} + + {$IFDEF DGL_LINUX} + // GLX_VERSION_1_4 (needs to be first) + glXGetProcAddress := dglGetProcAddress('glXGetProcAddress', nil, True); + + // GLX_ARB_get_proc_address (also needs to be first) + glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB', nil, True); + + glXChooseVisual := dglGetProcAddress('glXChooseVisual'); + glXCopyContext := dglGetProcAddress('glXCopyContext'); + glXCreateContext := dglGetProcAddress('glXCreateContext'); + glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap'); + glXDestroyContext := dglGetProcAddress('glXDestroyContext'); + glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap'); + glXGetConfig := dglGetProcAddress('glXGetConfig'); + glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext'); + glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable'); + glXIsDirect := dglGetProcAddress('glXIsDirect'); + glXMakeCurrent := dglGetProcAddress('glXMakeCurrent'); + glXQueryExtension := dglGetProcAddress('glXQueryExtension'); + glXQueryVersion := dglGetProcAddress('glXQueryVersion'); + glXSwapBuffers := dglGetProcAddress('glXSwapBuffers'); + glXUseXFont := dglGetProcAddress('glXUseXFont'); + glXWaitGL := dglGetProcAddress('glXWaitGL'); + glXWaitX := dglGetProcAddress('glXWaitX'); + + glXGetClientString := dglGetProcAddress('glXGetClientString'); + glXQueryServerString := dglGetProcAddress('glXQueryServerString'); + glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString'); + + // GLX_VERSION_1_3 + glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs'); + glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig'); + glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib'); + glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig'); + glXCreateWindow := dglGetProcAddress('glXCreateWindow'); + glXDestroyWindow := dglGetProcAddress('glXDestroyWindow'); + glXCreatePixmap := dglGetProcAddress('glXCreatePixmap'); + + glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap'); + glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer'); + glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer'); + glXQueryDrawable := dglGetProcAddress('glXQueryDrawable'); + glXCreateNewContext := dglGetProcAddress('glXCreateNewContext'); + glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent'); + glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable'); + glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay'); + + glXQueryContext := dglGetProcAddress('glXQueryContext'); + glXSelectEvent := dglGetProcAddress('glXSelectEvent'); + glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent'); + + // GLX_ARB_create_context + glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB'); + + // GLX_EXT_import_context + glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT'); + glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT'); + glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT'); + glXImportContextEXT := dglGetProcAddress('glXImportContextEXT'); + glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT'); + + // GLX_EXT_texture_from_pixmap + glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT'); + glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT'); + + // GLX_EXT_swap_control + glXSwapIntervalEXT := dglGetProcAddress('glXSwapIntervalEXT'); + {$ENDIF} + + Result := True; + end; + + // load GLU functions + if GLU_LibHandle <> nil then begin + // GLU ======================================================================== + gluBeginCurve := dglGetProcAddress('gluBeginCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluBeginPolygon := dglGetProcAddress('gluBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluBeginSurface := dglGetProcAddress('gluBeginSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluBeginTrim := dglGetProcAddress('gluBeginTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluBuild1DMipmaps := dglGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluBuild2DMipmaps := dglGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluCylinder := dglGetProcAddress('gluCylinder', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluDeleteNurbsRenderer := dglGetProcAddress('gluDeleteNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluDeleteQuadric := dglGetProcAddress('gluDeleteQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluDeleteTess := dglGetProcAddress('gluDeleteTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluDisk := dglGetProcAddress('gluDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluEndCurve := dglGetProcAddress('gluEndCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluEndPolygon := dglGetProcAddress('gluEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluEndSurface := dglGetProcAddress('gluEndSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluEndTrim := dglGetProcAddress('gluEndTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluErrorString := dglGetProcAddress('gluErrorString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluGetNurbsProperty := dglGetProcAddress('gluGetNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluGetString := dglGetProcAddress('gluGetString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluGetTessProperty := dglGetProcAddress('gluGetTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluLoadSamplingMatrices := dglGetProcAddress('gluLoadSamplingMatrices', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluLookAt := dglGetProcAddress('gluLookAt', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNewNurbsRenderer := dglGetProcAddress('gluNewNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNewQuadric := dglGetProcAddress('gluNewQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNewTess := dglGetProcAddress('gluNewTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNextContour := dglGetProcAddress('gluNextContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNurbsCallback := dglGetProcAddress('gluNurbsCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNurbsCurve := dglGetProcAddress('gluNurbsCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNurbsProperty := dglGetProcAddress('gluNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluNurbsSurface := dglGetProcAddress('gluNurbsSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluOrtho2D := dglGetProcAddress('gluOrtho2D', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluPartialDisk := dglGetProcAddress('gluPartialDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluPerspective := dglGetProcAddress('gluPerspective', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluPickMatrix := dglGetProcAddress('gluPickMatrix', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluProject := dglGetProcAddress('gluProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluPwlCurve := dglGetProcAddress('gluPwlCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluQuadricCallback := dglGetProcAddress('gluQuadricCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluQuadricDrawStyle := dglGetProcAddress('gluQuadricDrawStyle', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluQuadricNormals := dglGetProcAddress('gluQuadricNormals', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluQuadricOrientation := dglGetProcAddress('gluQuadricOrientation', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluQuadricTexture := dglGetProcAddress('gluQuadricTexture', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluScaleImage := dglGetProcAddress('gluScaleImage', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluSphere := dglGetProcAddress('gluSphere', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessBeginContour := dglGetProcAddress('gluTessBeginContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessBeginPolygon := dglGetProcAddress('gluTessBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessCallback := dglGetProcAddress('gluTessCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessEndContour := dglGetProcAddress('gluTessEndContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessEndPolygon := dglGetProcAddress('gluTessEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessNormal := dglGetProcAddress('gluTessNormal', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessProperty := dglGetProcAddress('gluTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluTessVertex := dglGetProcAddress('gluTessVertex', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + gluUnProject := dglGetProcAddress('gluUnProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); + end; +end; + +procedure ReadOpenGLCore; +begin + // GL_VERSION_1_0 + glCullFace := dglGetProcAddress('glCullFace'); + glFrontFace := dglGetProcAddress('glFrontFace'); + glHint := dglGetProcAddress('glHint'); + glLineWidth := dglGetProcAddress('glLineWidth'); + glPointSize := dglGetProcAddress('glPointSize'); + glPolygonMode := dglGetProcAddress('glPolygonMode'); + glScissor := dglGetProcAddress('glScissor'); + glTexParameterf := dglGetProcAddress('glTexParameterf'); + glTexParameterfv := dglGetProcAddress('glTexParameterfv'); + glTexParameteri := dglGetProcAddress('glTexParameteri'); + glTexParameteriv := dglGetProcAddress('glTexParameteriv'); + glTexImage1D := dglGetProcAddress('glTexImage1D'); + glTexImage2D := dglGetProcAddress('glTexImage2D'); + glDrawBuffer := dglGetProcAddress('glDrawBuffer'); + glClear := dglGetProcAddress('glClear'); + glClearColor := dglGetProcAddress('glClearColor'); + glClearStencil := dglGetProcAddress('glClearStencil'); + glClearDepth := dglGetProcAddress('glClearDepth'); + glStencilMask := dglGetProcAddress('glStencilMask'); + glColorMask := dglGetProcAddress('glColorMask'); + glDepthMask := dglGetProcAddress('glDepthMask'); + glDisable := dglGetProcAddress('glDisable'); + glEnable := dglGetProcAddress('glEnable'); + glFinish := dglGetProcAddress('glFinish'); + glFlush := dglGetProcAddress('glFlush'); + glBlendFunc := dglGetProcAddress('glBlendFunc'); + glLogicOp := dglGetProcAddress('glLogicOp'); + glStencilFunc := dglGetProcAddress('glStencilFunc'); + glStencilOp := dglGetProcAddress('glStencilOp'); + glDepthFunc := dglGetProcAddress('glDepthFunc'); + glPixelStoref := dglGetProcAddress('glPixelStoref'); + glPixelStorei := dglGetProcAddress('glPixelStorei'); + glReadBuffer := dglGetProcAddress('glReadBuffer'); + glReadPixels := dglGetProcAddress('glReadPixels'); + glGetBooleanv := dglGetProcAddress('glGetBooleanv'); + glGetDoublev := dglGetProcAddress('glGetDoublev'); + glGetError := dglGetProcAddress('glGetError'); + glGetFloatv := dglGetProcAddress('glGetFloatv'); + glGetIntegerv := dglGetProcAddress('glGetIntegerv'); + glGetString := dglGetProcAddress('glGetString'); + glGetTexImage := dglGetProcAddress('glGetTexImage'); + glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv'); + glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv'); + glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv'); + glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv'); + glIsEnabled := dglGetProcAddress('glIsEnabled'); + glDepthRange := dglGetProcAddress('glDepthRange'); + glViewport := dglGetProcAddress('glViewport'); + + // GL_VERSION_1_1 + glDrawArrays := dglGetProcAddress('glDrawArrays'); + glDrawElements := dglGetProcAddress('glDrawElements'); + glGetPointerv := dglGetProcAddress('glGetPointerv'); + glPolygonOffset := dglGetProcAddress('glPolygonOffset'); + glCopyTexImage1D := dglGetProcAddress('glCopyTexImage1D'); + glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D'); + glCopyTexSubImage1D := dglGetProcAddress('glCopyTexSubImage1D'); + glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D'); + glTexSubImage1D := dglGetProcAddress('glTexSubImage1D'); + glTexSubImage2D := dglGetProcAddress('glTexSubImage2D'); + glBindTexture := dglGetProcAddress('glBindTexture'); + glDeleteTextures := dglGetProcAddress('glDeleteTextures'); + glGenTextures := dglGetProcAddress('glGenTextures'); + +{$ifdef DGL_DEPRECATED} + glAccum := dglGetProcAddress('glAccum'); + glAlphaFunc := dglGetProcAddress('glAlphaFunc'); + glAreTexturesResident := dglGetProcAddress('glAreTexturesResident'); + glArrayElement := dglGetProcAddress('glArrayElement'); + glBegin := dglGetProcAddress('glBegin'); + glBitmap := dglGetProcAddress('glBitmap'); + glCallList := dglGetProcAddress('glCallList'); + glCallLists := dglGetProcAddress('glCallLists'); + glClearAccum := dglGetProcAddress('glClearAccum'); + glClearIndex := dglGetProcAddress('glClearIndex'); + glClipPlane := dglGetProcAddress('glClipPlane'); + glColor3b := dglGetProcAddress('glColor3b'); + glColor3bv := dglGetProcAddress('glColor3bv'); + glColor3d := dglGetProcAddress('glColor3d'); + glColor3dv := dglGetProcAddress('glColor3dv'); + glColor3f := dglGetProcAddress('glColor3f'); + glColor3fv := dglGetProcAddress('glColor3fv'); + glColor3i := dglGetProcAddress('glColor3i'); + glColor3iv := dglGetProcAddress('glColor3iv'); + glColor3s := dglGetProcAddress('glColor3s'); + glColor3sv := dglGetProcAddress('glColor3sv'); + glColor3ub := dglGetProcAddress('glColor3ub'); + glColor3ubv := dglGetProcAddress('glColor3ubv'); + glColor3ui := dglGetProcAddress('glColor3ui'); + glColor3uiv := dglGetProcAddress('glColor3uiv'); + glColor3us := dglGetProcAddress('glColor3us'); + glColor3usv := dglGetProcAddress('glColor3usv'); + glColor4b := dglGetProcAddress('glColor4b'); + glColor4bv := dglGetProcAddress('glColor4bv'); + glColor4d := dglGetProcAddress('glColor4d'); + glColor4dv := dglGetProcAddress('glColor4dv'); + glColor4f := dglGetProcAddress('glColor4f'); + glColor4fv := dglGetProcAddress('glColor4fv'); + glColor4i := dglGetProcAddress('glColor4i'); + glColor4iv := dglGetProcAddress('glColor4iv'); + glColor4s := dglGetProcAddress('glColor4s'); + glColor4sv := dglGetProcAddress('glColor4sv'); + glColor4ub := dglGetProcAddress('glColor4ub'); + glColor4ubv := dglGetProcAddress('glColor4ubv'); + glColor4ui := dglGetProcAddress('glColor4ui'); + glColor4uiv := dglGetProcAddress('glColor4uiv'); + glColor4us := dglGetProcAddress('glColor4us'); + glColor4usv := dglGetProcAddress('glColor4usv'); + glColorMaterial := dglGetProcAddress('glColorMaterial'); + glColorPointer := dglGetProcAddress('glColorPointer'); + glCopyPixels := dglGetProcAddress('glCopyPixels'); + glDeleteLists := dglGetProcAddress('glDeleteLists'); + glDisableClientState := dglGetProcAddress('glDisableClientState'); + glDrawPixels := dglGetProcAddress('glDrawPixels'); + glEdgeFlag := dglGetProcAddress('glEdgeFlag'); + glEdgeFlagPointer := dglGetProcAddress('glEdgeFlagPointer'); + glEdgeFlagv := dglGetProcAddress('glEdgeFlagv'); + glEnableClientState := dglGetProcAddress('glEnableClientState'); + glEnd := dglGetProcAddress('glEnd'); + glEndList := dglGetProcAddress('glEndList'); + glEvalCoord1d := dglGetProcAddress('glEvalCoord1d'); + glEvalCoord1dv := dglGetProcAddress('glEvalCoord1dv'); + glEvalCoord1f := dglGetProcAddress('glEvalCoord1f'); + glEvalCoord1fv := dglGetProcAddress('glEvalCoord1fv'); + glEvalCoord2d := dglGetProcAddress('glEvalCoord2d'); + glEvalCoord2dv := dglGetProcAddress('glEvalCoord2dv'); + glEvalCoord2f := dglGetProcAddress('glEvalCoord2f'); + glEvalCoord2fv := dglGetProcAddress('glEvalCoord2fv'); + glEvalMesh1 := dglGetProcAddress('glEvalMesh1'); + glEvalMesh2 := dglGetProcAddress('glEvalMesh2'); + glEvalPoint1 := dglGetProcAddress('glEvalPoint1'); + glEvalPoint2 := dglGetProcAddress('glEvalPoint2'); + glFeedbackBuffer := dglGetProcAddress('glFeedbackBuffer'); + glFogf := dglGetProcAddress('glFogf'); + glFogfv := dglGetProcAddress('glFogfv'); + glFogi := dglGetProcAddress('glFogi'); + glFogiv := dglGetProcAddress('glFogiv'); + glFrustum := dglGetProcAddress('glFrustum'); + glGenLists := dglGetProcAddress('glGenLists'); + glGetClipPlane := dglGetProcAddress('glGetClipPlane'); + glGetLightfv := dglGetProcAddress('glGetLightfv'); + glGetLightiv := dglGetProcAddress('glGetLightiv'); + glGetMapdv := dglGetProcAddress('glGetMapdv'); + glGetMapfv := dglGetProcAddress('glGetMapfv'); + glGetMapiv := dglGetProcAddress('glGetMapiv'); + glGetMaterialfv := dglGetProcAddress('glGetMaterialfv'); + glGetMaterialiv := dglGetProcAddress('glGetMaterialiv'); + glGetPixelMapfv := dglGetProcAddress('glGetPixelMapfv'); + glGetPixelMapuiv := dglGetProcAddress('glGetPixelMapuiv'); + glGetPixelMapusv := dglGetProcAddress('glGetPixelMapusv'); + glGetPolygonStipple := dglGetProcAddress('glGetPolygonStipple'); + glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv'); + glGetTexEnviv := dglGetProcAddress('glGetTexEnviv'); + glGetTexGendv := dglGetProcAddress('glGetTexGendv'); + glGetTexGenfv := dglGetProcAddress('glGetTexGenfv'); + glGetTexGeniv := dglGetProcAddress('glGetTexGeniv'); + glIndexMask := dglGetProcAddress('glIndexMask'); + glIndexPointer := dglGetProcAddress('glIndexPointer'); + glIndexd := dglGetProcAddress('glIndexd'); + glIndexdv := dglGetProcAddress('glIndexdv'); + glIndexf := dglGetProcAddress('glIndexf'); + glIndexfv := dglGetProcAddress('glIndexfv'); + glIndexi := dglGetProcAddress('glIndexi'); + glIndexiv := dglGetProcAddress('glIndexiv'); + glIndexs := dglGetProcAddress('glIndexs'); + glIndexsv := dglGetProcAddress('glIndexsv'); + glIndexub := dglGetProcAddress('glIndexub'); + glIndexubv := dglGetProcAddress('glIndexubv'); + glInitNames := dglGetProcAddress('glInitNames'); + glInterleavedArrays := dglGetProcAddress('glInterleavedArrays'); + glIsList := dglGetProcAddress('glIsList'); + glIsTexture := dglGetProcAddress('glIsTexture'); + glLightModelf := dglGetProcAddress('glLightModelf'); + glLightModelfv := dglGetProcAddress('glLightModelfv'); + glLightModeli := dglGetProcAddress('glLightModeli'); + glLightModeliv := dglGetProcAddress('glLightModeliv'); + glLightf := dglGetProcAddress('glLightf'); + glLightfv := dglGetProcAddress('glLightfv'); + glLighti := dglGetProcAddress('glLighti'); + glLightiv := dglGetProcAddress('glLightiv'); + glLineStipple := dglGetProcAddress('glLineStipple'); + glListBase := dglGetProcAddress('glListBase'); + glLoadIdentity := dglGetProcAddress('glLoadIdentity'); + glLoadMatrixd := dglGetProcAddress('glLoadMatrixd'); + glLoadMatrixf := dglGetProcAddress('glLoadMatrixf'); + glLoadName := dglGetProcAddress('glLoadName'); + glMap1d := dglGetProcAddress('glMap1d'); + glMap1f := dglGetProcAddress('glMap1f'); + glMap2d := dglGetProcAddress('glMap2d'); + glMap2f := dglGetProcAddress('glMap2f'); + glMapGrid1d := dglGetProcAddress('glMapGrid1d'); + glMapGrid1f := dglGetProcAddress('glMapGrid1f'); + glMapGrid2d := dglGetProcAddress('glMapGrid2d'); + glMapGrid2f := dglGetProcAddress('glMapGrid2f'); + glMaterialf := dglGetProcAddress('glMaterialf'); + glMaterialfv := dglGetProcAddress('glMaterialfv'); + glMateriali := dglGetProcAddress('glMateriali'); + glMaterialiv := dglGetProcAddress('glMaterialiv'); + glMatrixMode := dglGetProcAddress('glMatrixMode'); + glMultMatrixd := dglGetProcAddress('glMultMatrixd'); + glMultMatrixf := dglGetProcAddress('glMultMatrixf'); + glNewList := dglGetProcAddress('glNewList'); + glNormal3b := dglGetProcAddress('glNormal3b'); + glNormal3bv := dglGetProcAddress('glNormal3bv'); + glNormal3d := dglGetProcAddress('glNormal3d'); + glNormal3dv := dglGetProcAddress('glNormal3dv'); + glNormal3f := dglGetProcAddress('glNormal3f'); + glNormal3fv := dglGetProcAddress('glNormal3fv'); + glNormal3i := dglGetProcAddress('glNormal3i'); + glNormal3iv := dglGetProcAddress('glNormal3iv'); + glNormal3s := dglGetProcAddress('glNormal3s'); + glNormal3sv := dglGetProcAddress('glNormal3sv'); + glNormalPointer := dglGetProcAddress('glNormalPointer'); + glOrtho := dglGetProcAddress('glOrtho'); + glPassThrough := dglGetProcAddress('glPassThrough'); + glPixelMapfv := dglGetProcAddress('glPixelMapfv'); + glPixelMapuiv := dglGetProcAddress('glPixelMapuiv'); + glPixelMapusv := dglGetProcAddress('glPixelMapusv'); + glPixelTransferf := dglGetProcAddress('glPixelTransferf'); + glPixelTransferi := dglGetProcAddress('glPixelTransferi'); + glPixelZoom := dglGetProcAddress('glPixelZoom'); + glPolygonStipple := dglGetProcAddress('glPolygonStipple'); + glPopAttrib := dglGetProcAddress('glPopAttrib'); + glPopClientAttrib := dglGetProcAddress('glPopClientAttrib'); + glPopMatrix := dglGetProcAddress('glPopMatrix'); + glPopName := dglGetProcAddress('glPopName'); + glPrioritizeTextures := dglGetProcAddress('glPrioritizeTextures'); + glPushAttrib := dglGetProcAddress('glPushAttrib'); + glPushClientAttrib := dglGetProcAddress('glPushClientAttrib'); + glPushMatrix := dglGetProcAddress('glPushMatrix'); + glPushName := dglGetProcAddress('glPushName'); + glRasterPos2d := dglGetProcAddress('glRasterPos2d'); + glRasterPos2dv := dglGetProcAddress('glRasterPos2dv'); + glRasterPos2f := dglGetProcAddress('glRasterPos2f'); + glRasterPos2fv := dglGetProcAddress('glRasterPos2fv'); + glRasterPos2i := dglGetProcAddress('glRasterPos2i'); + glRasterPos2iv := dglGetProcAddress('glRasterPos2iv'); + glRasterPos2s := dglGetProcAddress('glRasterPos2s'); + glRasterPos2sv := dglGetProcAddress('glRasterPos2sv'); + glRasterPos3d := dglGetProcAddress('glRasterPos3d'); + glRasterPos3dv := dglGetProcAddress('glRasterPos3dv'); + glRasterPos3f := dglGetProcAddress('glRasterPos3f'); + glRasterPos3fv := dglGetProcAddress('glRasterPos3fv'); + glRasterPos3i := dglGetProcAddress('glRasterPos3i'); + glRasterPos3iv := dglGetProcAddress('glRasterPos3iv'); + glRasterPos3s := dglGetProcAddress('glRasterPos3s'); + glRasterPos3sv := dglGetProcAddress('glRasterPos3sv'); + glRasterPos4d := dglGetProcAddress('glRasterPos4d'); + glRasterPos4dv := dglGetProcAddress('glRasterPos4dv'); + glRasterPos4f := dglGetProcAddress('glRasterPos4f'); + glRasterPos4fv := dglGetProcAddress('glRasterPos4fv'); + glRasterPos4i := dglGetProcAddress('glRasterPos4i'); + glRasterPos4iv := dglGetProcAddress('glRasterPos4iv'); + glRasterPos4s := dglGetProcAddress('glRasterPos4s'); + glRasterPos4sv := dglGetProcAddress('glRasterPos4sv'); + glRectd := dglGetProcAddress('glRectd'); + glRectdv := dglGetProcAddress('glRectdv'); + glRectf := dglGetProcAddress('glRectf'); + glRectfv := dglGetProcAddress('glRectfv'); + glRecti := dglGetProcAddress('glRecti'); + glRectiv := dglGetProcAddress('glRectiv'); + glRects := dglGetProcAddress('glRects'); + glRectsv := dglGetProcAddress('glRectsv'); + glRenderMode := dglGetProcAddress('glRenderMode'); + glRotated := dglGetProcAddress('glRotated'); + glRotatef := dglGetProcAddress('glRotatef'); + glScaled := dglGetProcAddress('glScaled'); + glScalef := dglGetProcAddress('glScalef'); + glSelectBuffer := dglGetProcAddress('glSelectBuffer'); + glShadeModel := dglGetProcAddress('glShadeModel'); + glTexCoord1d := dglGetProcAddress('glTexCoord1d'); + glTexCoord1dv := dglGetProcAddress('glTexCoord1dv'); + glTexCoord1f := dglGetProcAddress('glTexCoord1f'); + glTexCoord1fv := dglGetProcAddress('glTexCoord1fv'); + glTexCoord1i := dglGetProcAddress('glTexCoord1i'); + glTexCoord1iv := dglGetProcAddress('glTexCoord1iv'); + glTexCoord1s := dglGetProcAddress('glTexCoord1s'); + glTexCoord1sv := dglGetProcAddress('glTexCoord1sv'); + glTexCoord2d := dglGetProcAddress('glTexCoord2d'); + glTexCoord2dv := dglGetProcAddress('glTexCoord2dv'); + glTexCoord2f := dglGetProcAddress('glTexCoord2f'); + glTexCoord2fv := dglGetProcAddress('glTexCoord2fv'); + glTexCoord2i := dglGetProcAddress('glTexCoord2i'); + glTexCoord2iv := dglGetProcAddress('glTexCoord2iv'); + glTexCoord2s := dglGetProcAddress('glTexCoord2s'); + glTexCoord2sv := dglGetProcAddress('glTexCoord2sv'); + glTexCoord3d := dglGetProcAddress('glTexCoord3d'); + glTexCoord3dv := dglGetProcAddress('glTexCoord3dv'); + glTexCoord3f := dglGetProcAddress('glTexCoord3f'); + glTexCoord3fv := dglGetProcAddress('glTexCoord3fv'); + glTexCoord3i := dglGetProcAddress('glTexCoord3i'); + glTexCoord3iv := dglGetProcAddress('glTexCoord3iv'); + glTexCoord3s := dglGetProcAddress('glTexCoord3s'); + glTexCoord3sv := dglGetProcAddress('glTexCoord3sv'); + glTexCoord4d := dglGetProcAddress('glTexCoord4d'); + glTexCoord4dv := dglGetProcAddress('glTexCoord4dv'); + glTexCoord4f := dglGetProcAddress('glTexCoord4f'); + glTexCoord4fv := dglGetProcAddress('glTexCoord4fv'); + glTexCoord4i := dglGetProcAddress('glTexCoord4i'); + glTexCoord4iv := dglGetProcAddress('glTexCoord4iv'); + glTexCoord4s := dglGetProcAddress('glTexCoord4s'); + glTexCoord4sv := dglGetProcAddress('glTexCoord4sv'); + glTexCoordPointer := dglGetProcAddress('glTexCoordPointer'); + glTexEnvf := dglGetProcAddress('glTexEnvf'); + glTexEnvfv := dglGetProcAddress('glTexEnvfv'); + glTexEnvi := dglGetProcAddress('glTexEnvi'); + glTexEnviv := dglGetProcAddress('glTexEnviv'); + glTexGend := dglGetProcAddress('glTexGend'); + glTexGendv := dglGetProcAddress('glTexGendv'); + glTexGenf := dglGetProcAddress('glTexGenf'); + glTexGenfv := dglGetProcAddress('glTexGenfv'); + glTexGeni := dglGetProcAddress('glTexGeni'); + glTexGeniv := dglGetProcAddress('glTexGeniv'); + glTranslated := dglGetProcAddress('glTranslated'); + glTranslatef := dglGetProcAddress('glTranslatef'); + glVertex2d := dglGetProcAddress('glVertex2d'); + glVertex2dv := dglGetProcAddress('glVertex2dv'); + glVertex2f := dglGetProcAddress('glVertex2f'); + glVertex2fv := dglGetProcAddress('glVertex2fv'); + glVertex2i := dglGetProcAddress('glVertex2i'); + glVertex2iv := dglGetProcAddress('glVertex2iv'); + glVertex2s := dglGetProcAddress('glVertex2s'); + glVertex2sv := dglGetProcAddress('glVertex2sv'); + glVertex3d := dglGetProcAddress('glVertex3d'); + glVertex3dv := dglGetProcAddress('glVertex3dv'); + glVertex3f := dglGetProcAddress('glVertex3f'); + glVertex3fv := dglGetProcAddress('glVertex3fv'); + glVertex3i := dglGetProcAddress('glVertex3i'); + glVertex3iv := dglGetProcAddress('glVertex3iv'); + glVertex3s := dglGetProcAddress('glVertex3s'); + glVertex3sv := dglGetProcAddress('glVertex3sv'); + glVertex4d := dglGetProcAddress('glVertex4d'); + glVertex4dv := dglGetProcAddress('glVertex4dv'); + glVertex4f := dglGetProcAddress('glVertex4f'); + glVertex4fv := dglGetProcAddress('glVertex4fv'); + glVertex4i := dglGetProcAddress('glVertex4i'); + glVertex4iv := dglGetProcAddress('glVertex4iv'); + glVertex4s := dglGetProcAddress('glVertex4s'); + glVertex4sv := dglGetProcAddress('glVertex4sv'); + glVertexPointer := dglGetProcAddress('glVertexPointer'); +{$endif} + + // GL_VERSION_1_2 + glBlendColor := dglGetProcAddress('glBlendColor'); + glBlendEquation := dglGetProcAddress('glBlendEquation'); + glDrawRangeElements := dglGetProcAddress('glDrawRangeElements'); + glTexImage3D := dglGetProcAddress('glTexImage3D'); + glTexSubImage3D := dglGetProcAddress('glTexSubImage3D'); + glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D'); +{$ifdef DGL_DEPRECATED} + glColorTable := dglGetProcAddress('glColorTable'); + glColorTableParameterfv := dglGetProcAddress('glColorTableParameterfv'); + glColorTableParameteriv := dglGetProcAddress('glColorTableParameteriv'); + glCopyColorTable := dglGetProcAddress('glCopyColorTable'); + glGetColorTable := dglGetProcAddress('glGetColorTable'); + glGetColorTableParameterfv := dglGetProcAddress('glGetColorTableParameterfv'); + glGetColorTableParameteriv := dglGetProcAddress('glGetColorTableParameteriv'); + glColorSubTable := dglGetProcAddress('glColorSubTable'); + glCopyColorSubTable := dglGetProcAddress('glCopyColorSubTable'); + glConvolutionFilter1D := dglGetProcAddress('glConvolutionFilter1D'); + glConvolutionFilter2D := dglGetProcAddress('glConvolutionFilter2D'); + glConvolutionParameterf := dglGetProcAddress('glConvolutionParameterf'); + glConvolutionParameterfv := dglGetProcAddress('glConvolutionParameterfv'); + glConvolutionParameteri := dglGetProcAddress('glConvolutionParameteri'); + glConvolutionParameteriv := dglGetProcAddress('glConvolutionParameteriv'); + glCopyConvolutionFilter1D := dglGetProcAddress('glCopyConvolutionFilter1D'); + glCopyConvolutionFilter2D := dglGetProcAddress('glCopyConvolutionFilter2D'); + glGetConvolutionFilter := dglGetProcAddress('glGetConvolutionFilter'); + glGetConvolutionParameterfv := dglGetProcAddress('glGetConvolutionParameterfv'); + glGetConvolutionParameteriv := dglGetProcAddress('glGetConvolutionParameteriv'); + glGetSeparableFilter := dglGetProcAddress('glGetSeparableFilter'); + glSeparableFilter2D := dglGetProcAddress('glSeparableFilter2D'); + glGetHistogram := dglGetProcAddress('glGetHistogram'); + glGetHistogramParameterfv := dglGetProcAddress('glGetHistogramParameterfv'); + glGetHistogramParameteriv := dglGetProcAddress('glGetHistogramParameteriv'); + glGetMinmax := dglGetProcAddress('glGetMinmax'); + glGetMinmaxParameterfv := dglGetProcAddress('glGetMinmaxParameterfv'); + glGetMinmaxParameteriv := dglGetProcAddress('glGetMinmaxParameteriv'); + glHistogram := dglGetProcAddress('glHistogram'); + glMinmax := dglGetProcAddress('glMinmax'); + glResetHistogram := dglGetProcAddress('glResetHistogram'); + glResetMinmax := dglGetProcAddress('glResetMinmax'); +{$endif} + + // GL_VERSION_1_3 + glActiveTexture := dglGetProcAddress('glActiveTexture'); + glSampleCoverage := dglGetProcAddress('glSampleCoverage'); + glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D'); + glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D'); + glCompressedTexImage1D := dglGetProcAddress('glCompressedTexImage1D'); + glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D'); + glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D'); + glCompressedTexSubImage1D := dglGetProcAddress('glCompressedTexSubImage1D'); + glGetCompressedTexImage := dglGetProcAddress('glGetCompressedTexImage'); +{$ifdef DGL_DEPRECATED} + glClientActiveTexture := dglGetProcAddress('glClientActiveTexture'); + glMultiTexCoord1d := dglGetProcAddress('glMultiTexCoord1d'); + glMultiTexCoord1dv := dglGetProcAddress('glMultiTexCoord1dv'); + glMultiTexCoord1f := dglGetProcAddress('glMultiTexCoord1f'); + glMultiTexCoord1fv := dglGetProcAddress('glMultiTexCoord1fv'); + glMultiTexCoord1i := dglGetProcAddress('glMultiTexCoord1i'); + glMultiTexCoord1iv := dglGetProcAddress('glMultiTexCoord1iv'); + glMultiTexCoord1s := dglGetProcAddress('glMultiTexCoord1s'); + glMultiTexCoord1sv := dglGetProcAddress('glMultiTexCoord1sv'); + glMultiTexCoord2d := dglGetProcAddress('glMultiTexCoord2d'); + glMultiTexCoord2dv := dglGetProcAddress('glMultiTexCoord2dv'); + glMultiTexCoord2f := dglGetProcAddress('glMultiTexCoord2f'); + glMultiTexCoord2fv := dglGetProcAddress('glMultiTexCoord2fv'); + glMultiTexCoord2i := dglGetProcAddress('glMultiTexCoord2i'); + glMultiTexCoord2iv := dglGetProcAddress('glMultiTexCoord2iv'); + glMultiTexCoord2s := dglGetProcAddress('glMultiTexCoord2s'); + glMultiTexCoord2sv := dglGetProcAddress('glMultiTexCoord2sv'); + glMultiTexCoord3d := dglGetProcAddress('glMultiTexCoord3d'); + glMultiTexCoord3dv := dglGetProcAddress('glMultiTexCoord3dv'); + glMultiTexCoord3f := dglGetProcAddress('glMultiTexCoord3f'); + glMultiTexCoord3fv := dglGetProcAddress('glMultiTexCoord3fv'); + glMultiTexCoord3i := dglGetProcAddress('glMultiTexCoord3i'); + glMultiTexCoord3iv := dglGetProcAddress('glMultiTexCoord3iv'); + glMultiTexCoord3s := dglGetProcAddress('glMultiTexCoord3s'); + glMultiTexCoord3sv := dglGetProcAddress('glMultiTexCoord3sv'); + glMultiTexCoord4d := dglGetProcAddress('glMultiTexCoord4d'); + glMultiTexCoord4dv := dglGetProcAddress('glMultiTexCoord4dv'); + glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f'); + glMultiTexCoord4fv := dglGetProcAddress('glMultiTexCoord4fv'); + glMultiTexCoord4i := dglGetProcAddress('glMultiTexCoord4i'); + glMultiTexCoord4iv := dglGetProcAddress('glMultiTexCoord4iv'); + glMultiTexCoord4s := dglGetProcAddress('glMultiTexCoord4s'); + glMultiTexCoord4sv := dglGetProcAddress('glMultiTexCoord4sv'); + glLoadTransposeMatrixf := dglGetProcAddress('glLoadTransposeMatrixf'); + glLoadTransposeMatrixd := dglGetProcAddress('glLoadTransposeMatrixd'); + glMultTransposeMatrixf := dglGetProcAddress('glMultTransposeMatrixf'); + glMultTransposeMatrixd := dglGetProcAddress('glMultTransposeMatrixd'); +{$endif} + + // GL_VERSION_1_4 + glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate'); + glMultiDrawArrays := dglGetProcAddress('glMultiDrawArrays'); + glMultiDrawElements := dglGetProcAddress('glMultiDrawElements'); + glPointParameterf := dglGetProcAddress('glPointParameterf'); + glPointParameterfv := dglGetProcAddress('glPointParameterfv'); + glPointParameteri := dglGetProcAddress('glPointParameteri'); + glPointParameteriv := dglGetProcAddress('glPointParameteriv'); +{$ifdef DGL_DEPRECATED} + glFogCoordf := dglGetProcAddress('glFogCoordf'); + glFogCoordfv := dglGetProcAddress('glFogCoordfv'); + glFogCoordd := dglGetProcAddress('glFogCoordd'); + glFogCoorddv := dglGetProcAddress('glFogCoorddv'); + glFogCoordPointer := dglGetProcAddress('glFogCoordPointer'); + glSecondaryColor3b := dglGetProcAddress('glSecondaryColor3b'); + glSecondaryColor3bv := dglGetProcAddress('glSecondaryColor3bv'); + glSecondaryColor3d := dglGetProcAddress('glSecondaryColor3d'); + glSecondaryColor3dv := dglGetProcAddress('glSecondaryColor3dv'); + glSecondaryColor3f := dglGetProcAddress('glSecondaryColor3f'); + glSecondaryColor3fv := dglGetProcAddress('glSecondaryColor3fv'); + glSecondaryColor3i := dglGetProcAddress('glSecondaryColor3i'); + glSecondaryColor3iv := dglGetProcAddress('glSecondaryColor3iv'); + glSecondaryColor3s := dglGetProcAddress('glSecondaryColor3s'); + glSecondaryColor3sv := dglGetProcAddress('glSecondaryColor3sv'); + glSecondaryColor3ub := dglGetProcAddress('glSecondaryColor3ub'); + glSecondaryColor3ubv := dglGetProcAddress('glSecondaryColor3ubv'); + glSecondaryColor3ui := dglGetProcAddress('glSecondaryColor3ui'); + glSecondaryColor3uiv := dglGetProcAddress('glSecondaryColor3uiv'); + glSecondaryColor3us := dglGetProcAddress('glSecondaryColor3us'); + glSecondaryColor3usv := dglGetProcAddress('glSecondaryColor3usv'); + glSecondaryColorPointer := dglGetProcAddress('glSecondaryColorPointer'); + glWindowPos2d := dglGetProcAddress('glWindowPos2d'); + glWindowPos2dv := dglGetProcAddress('glWindowPos2dv'); + glWindowPos2f := dglGetProcAddress('glWindowPos2f'); + glWindowPos2fv := dglGetProcAddress('glWindowPos2fv'); + glWindowPos2i := dglGetProcAddress('glWindowPos2i'); + glWindowPos2iv := dglGetProcAddress('glWindowPos2iv'); + glWindowPos2s := dglGetProcAddress('glWindowPos2s'); + glWindowPos2sv := dglGetProcAddress('glWindowPos2sv'); + glWindowPos3d := dglGetProcAddress('glWindowPos3d'); + glWindowPos3dv := dglGetProcAddress('glWindowPos3dv'); + glWindowPos3f := dglGetProcAddress('glWindowPos3f'); + glWindowPos3fv := dglGetProcAddress('glWindowPos3fv'); + glWindowPos3i := dglGetProcAddress('glWindowPos3i'); + glWindowPos3iv := dglGetProcAddress('glWindowPos3iv'); + glWindowPos3s := dglGetProcAddress('glWindowPos3s'); + glWindowPos3sv := dglGetProcAddress('glWindowPos3sv'); +{$endif} + + // GL_VERSION_1_5 + glGenQueries := dglGetProcAddress('glGenQueries'); + glDeleteQueries := dglGetProcAddress('glDeleteQueries'); + glIsQuery := dglGetProcAddress('glIsQuery'); + glBeginQuery := dglGetProcAddress('glBeginQuery'); + glEndQuery := dglGetProcAddress('glEndQuery'); + glGetQueryiv := dglGetProcAddress('glGetQueryiv'); + glGetQueryObjectiv := dglGetProcAddress('glGetQueryObjectiv'); + glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv'); + glBindBuffer := dglGetProcAddress('glBindBuffer'); + glDeleteBuffers := dglGetProcAddress('glDeleteBuffers'); + glGenBuffers := dglGetProcAddress('glGenBuffers'); + glIsBuffer := dglGetProcAddress('glIsBuffer'); + glBufferData := dglGetProcAddress('glBufferData'); + glBufferSubData := dglGetProcAddress('glBufferSubData'); + glGetBufferSubData := dglGetProcAddress('glGetBufferSubData'); + glMapBuffer := dglGetProcAddress('glMapBuffer'); + glUnmapBuffer := dglGetProcAddress('glUnmapBuffer'); + glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv'); + glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv'); + + // GL_VERSION_2_0 + glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate'); + glDrawBuffers := dglGetProcAddress('glDrawBuffers'); + glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate'); + glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate'); + glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate'); + glAttachShader := dglGetProcAddress('glAttachShader'); + glBindAttribLocation := dglGetProcAddress('glBindAttribLocation'); + glCompileShader := dglGetProcAddress('glCompileShader'); + glCreateProgram := dglGetProcAddress('glCreateProgram'); + glCreateShader := dglGetProcAddress('glCreateShader'); + glDeleteProgram := dglGetProcAddress('glDeleteProgram'); + glDeleteShader := dglGetProcAddress('glDeleteShader'); + glDetachShader := dglGetProcAddress('glDetachShader'); + glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray'); + glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray'); + glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib'); + glGetActiveUniform := dglGetProcAddress('glGetActiveUniform'); + glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders'); + glGetAttribLocation := dglGetProcAddress('glGetAttribLocation'); + glGetProgramiv := dglGetProcAddress('glGetProgramiv'); + glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog'); + glGetShaderiv := dglGetProcAddress('glGetShaderiv'); + glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog'); + glGetShaderSource := dglGetProcAddress('glGetShaderSource'); + glGetUniformLocation := dglGetProcAddress('glGetUniformLocation'); + glGetUniformfv := dglGetProcAddress('glGetUniformfv'); + glGetUniformiv := dglGetProcAddress('glGetUniformiv'); + glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv'); + glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv'); + glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv'); + glIsProgram := dglGetProcAddress('glIsProgram'); + glIsShader := dglGetProcAddress('glIsShader'); + glLinkProgram := dglGetProcAddress('glLinkProgram'); + glShaderSource := dglGetProcAddress('glShaderSource'); + glUseProgram := dglGetProcAddress('glUseProgram'); + glUniform1f := dglGetProcAddress('glUniform1f'); + glUniform2f := dglGetProcAddress('glUniform2f'); + glUniform3f := dglGetProcAddress('glUniform3f'); + glUniform4f := dglGetProcAddress('glUniform4f'); + glUniform1i := dglGetProcAddress('glUniform1i'); + glUniform2i := dglGetProcAddress('glUniform2i'); + glUniform3i := dglGetProcAddress('glUniform3i'); + glUniform4i := dglGetProcAddress('glUniform4i'); + glUniform1fv := dglGetProcAddress('glUniform1fv'); + glUniform2fv := dglGetProcAddress('glUniform2fv'); + glUniform3fv := dglGetProcAddress('glUniform3fv'); + glUniform4fv := dglGetProcAddress('glUniform4fv'); + glUniform1iv := dglGetProcAddress('glUniform1iv'); + glUniform2iv := dglGetProcAddress('glUniform2iv'); + glUniform3iv := dglGetProcAddress('glUniform3iv'); + glUniform4iv := dglGetProcAddress('glUniform4iv'); + glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv'); + glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv'); + glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv'); + glValidateProgram := dglGetProcAddress('glValidateProgram'); + glVertexAttrib1d := dglGetProcAddress('glVertexAttrib1d'); + glVertexAttrib1dv := dglGetProcAddress('glVertexAttrib1dv'); + glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f'); + glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv'); + glVertexAttrib1s := dglGetProcAddress('glVertexAttrib1s'); + glVertexAttrib1sv := dglGetProcAddress('glVertexAttrib1sv'); + glVertexAttrib2d := dglGetProcAddress('glVertexAttrib2d'); + glVertexAttrib2dv := dglGetProcAddress('glVertexAttrib2dv'); + glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f'); + glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv'); + glVertexAttrib2s := dglGetProcAddress('glVertexAttrib2s'); + glVertexAttrib2sv := dglGetProcAddress('glVertexAttrib2sv'); + glVertexAttrib3d := dglGetProcAddress('glVertexAttrib3d'); + glVertexAttrib3dv := dglGetProcAddress('glVertexAttrib3dv'); + glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f'); + glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv'); + glVertexAttrib3s := dglGetProcAddress('glVertexAttrib3s'); + glVertexAttrib3sv := dglGetProcAddress('glVertexAttrib3sv'); + glVertexAttrib4Nbv := dglGetProcAddress('glVertexAttrib4Nbv'); + glVertexAttrib4Niv := dglGetProcAddress('glVertexAttrib4Niv'); + glVertexAttrib4Nsv := dglGetProcAddress('glVertexAttrib4Nsv'); + glVertexAttrib4Nub := dglGetProcAddress('glVertexAttrib4Nub'); + glVertexAttrib4Nubv := dglGetProcAddress('glVertexAttrib4Nubv'); + glVertexAttrib4Nuiv := dglGetProcAddress('glVertexAttrib4Nuiv'); + glVertexAttrib4Nusv := dglGetProcAddress('glVertexAttrib4Nusv'); + glVertexAttrib4bv := dglGetProcAddress('glVertexAttrib4bv'); + glVertexAttrib4d := dglGetProcAddress('glVertexAttrib4d'); + glVertexAttrib4dv := dglGetProcAddress('glVertexAttrib4dv'); + glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f'); + glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv'); + glVertexAttrib4iv := dglGetProcAddress('glVertexAttrib4iv'); + glVertexAttrib4s := dglGetProcAddress('glVertexAttrib4s'); + glVertexAttrib4sv := dglGetProcAddress('glVertexAttrib4sv'); + glVertexAttrib4ubv := dglGetProcAddress('glVertexAttrib4ubv'); + glVertexAttrib4uiv := dglGetProcAddress('glVertexAttrib4uiv'); + glVertexAttrib4usv := dglGetProcAddress('glVertexAttrib4usv'); + glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer'); + + // GL_VERSION_2_1 + glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv'); + glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv'); + glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv'); + glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv'); + glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv'); + glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv'); + + // GL_VERSION_3_0 + { OpenGL 3.0 also reuses entry points from these extensions: } + Read_GL_ARB_framebuffer_object; + Read_GL_ARB_map_buffer_range; + Read_GL_ARB_vertex_array_object; + + glColorMaski := dglGetProcAddress('glColorMaski'); + glGetBooleani_v := dglGetProcAddress('glGetBooleani_v'); + glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v'); + glEnablei := dglGetProcAddress('glEnablei'); + glDisablei := dglGetProcAddress('glDisablei'); + glIsEnabledi := dglGetProcAddress('glIsEnabledi'); + glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback'); + glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback'); + glBindBufferRange := dglGetProcAddress('glBindBufferRange'); + glBindBufferBase := dglGetProcAddress('glBindBufferBase'); + glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings'); + glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying'); + glClampColor := dglGetProcAddress('glClampColor'); + glBeginConditionalRender := dglGetProcAddress('glBeginConditionalRender'); + glEndConditionalRender := dglGetProcAddress('glEndConditionalRender'); + glVertexAttribI1i := dglGetProcAddress('glVertexAttribI1i'); + glVertexAttribI2i := dglGetProcAddress('glVertexAttribI2i'); + glVertexAttribI3i := dglGetProcAddress('glVertexAttribI3i'); + glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i'); + glVertexAttribI1ui := dglGetProcAddress('glVertexAttribI1ui'); + glVertexAttribI2ui := dglGetProcAddress('glVertexAttribI2ui'); + glVertexAttribI3ui := dglGetProcAddress('glVertexAttribI3ui'); + glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui'); + glVertexAttribI1iv := dglGetProcAddress('glVertexAttribI1iv'); + glVertexAttribI2iv := dglGetProcAddress('glVertexAttribI2iv'); + glVertexAttribI3iv := dglGetProcAddress('glVertexAttribI3iv'); + glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv'); + glVertexAttribI1uiv := dglGetProcAddress('glVertexAttribI1uiv'); + glVertexAttribI2uiv := dglGetProcAddress('glVertexAttribI2uiv'); + glVertexAttribI3uiv := dglGetProcAddress('glVertexAttribI3uiv'); + glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv'); + glVertexAttribI4bv := dglGetProcAddress('glVertexAttribI4bv'); + glVertexAttribI4sv := dglGetProcAddress('glVertexAttribI4sv'); + glVertexAttribI4ubv := dglGetProcAddress('glVertexAttribI4ubv'); + glVertexAttribI4usv := dglGetProcAddress('glVertexAttribI4usv'); + glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer'); + glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv'); + glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv'); + glGetUniformuiv := dglGetProcAddress('glGetUniformuiv'); + glBindFragDataLocation := dglGetProcAddress('glBindFragDataLocation'); + glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation'); + glUniform1ui := dglGetProcAddress('glUniform1ui'); + glUniform2ui := dglGetProcAddress('glUniform2ui'); + glUniform3ui := dglGetProcAddress('glUniform3ui'); + glUniform4ui := dglGetProcAddress('glUniform4ui'); + glUniform1uiv := dglGetProcAddress('glUniform1uiv'); + glUniform2uiv := dglGetProcAddress('glUniform2uiv'); + glUniform3uiv := dglGetProcAddress('glUniform3uiv'); + glUniform4uiv := dglGetProcAddress('glUniform4uiv'); + glTexParameterIiv := dglGetProcAddress('glTexParameterIiv'); + glTexParameterIuiv := dglGetProcAddress('glTexParameterIuiv'); + glGetTexParameterIiv := dglGetProcAddress('glGetTexParameterIiv'); + glGetTexParameterIuiv := dglGetProcAddress('glGetTexParameterIuiv'); + glClearBufferiv := dglGetProcAddress('glClearBufferiv'); + glClearBufferuiv := dglGetProcAddress('glClearBufferuiv'); + glClearBufferfv := dglGetProcAddress('glClearBufferfv'); + glClearBufferfi := dglGetProcAddress('glClearBufferfi'); + glGetStringi := dglGetProcAddress('glGetStringi'); + + // GL_VERSION_2_1 + glEnableVertexArrayEXT := dglGetProcAddress('glEnableVertexArrayEXT'); + glEnableVertexArrayAttribEXT := dglGetProcAddress('glEnableVertexArrayAttribEXT'); + glVertexArrayVertexAttribOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribOffsetEXT'); + + // GL_VERSION_3_1 + { OpenGL 3.1 also reuses entry points from these extensions: } + Read_GL_ARB_copy_buffer; + Read_GL_ARB_uniform_buffer_object; + + glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced'); + glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced'); + glTexBuffer := dglGetProcAddress('glTexBuffer'); + glPrimitiveRestartIndex := dglGetProcAddress('glPrimitiveRestartIndex'); + + // GL_VERSION_3_2 + { OpenGL 3.2 also reuses entry points from these extensions: } + Read_GL_ARB_draw_elements_base_vertex; + Read_GL_ARB_provoking_vertex; + Read_GL_ARB_sync; + Read_GL_ARB_texture_multisample; + + glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v'); + glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v'); + glFramebufferTexture := dglGetProcAddress('glFramebufferTexture'); +// glFramebufferTextureFace := dglGetProcAddress('glFramebufferTextureFace'); + + // GL_VERSION_3_3 + { OpenGL 3.3 also reuses entry points from these extensions: } + Read_GL_ARB_blend_func_extended; + Read_GL_ARB_sampler_objects; + { ARB_explicit_attrib_location, but it has none } + { ARB_occlusion_query2 (no entry points) } + { ARB_shader_bit_encoding (no entry points) } + { ARB_texture_rgb10_a2ui (no entry points) } + { ARB_texture_swizzle (no entry points) } + Read_GL_ARB_timer_query; + Read_GL_ARB_vertex_type_2_10_10_10_rev; + + glVertexAttribDivisor := dglGetProcAddress('glVertexAttribDivisor'); + + // GL_VERSION_4_0 + { OpenGL 4.0 also reuses entry points from these extensions: } + { ARB_texture_query_lod (no entry points) } + Read_GL_ARB_draw_indirect; + { ARB_gpu_shader5 (no entry points) } + Read_GL_ARB_gpu_shader_fp64; + Read_GL_ARB_shader_subroutine; + Read_GL_ARB_tessellation_shader; + { ARB_texture_buffer_object_rgb32 (no entry points) } + { ARB_texture_cube_map_array (no entry points) } + { ARB_texture_gather (no entry points) } + Read_GL_ARB_transform_feedback2; + Read_GL_ARB_transform_feedback3; + + glMinSampleShading := dglGetProcAddress('glMinSampleShading'); + glBlendEquationi := dglGetProcAddress('glBlendEquationi'); + glBlendEquationSeparatei := dglGetProcAddress('glBlendEquationSeparatei'); + glBlendFunci := dglGetProcAddress('glBlendFunci'); + glBlendFuncSeparatei := dglGetProcAddress('glBlendFuncSeparatei'); + + // GL_VERSION_4_1 + { OpenGL 4.1 also reuses entry points from these extensions: } + Read_GL_ARB_ES2_compatibility; + Read_GL_ARB_get_program_binary; + Read_GL_ARB_separate_shader_objects; + { ARB_shader_precision (no entry points) } + Read_GL_ARB_vertex_attrib_64bit; + Read_GL_ARB_viewport_array; + + // GL_VERSION_4_2 + { OpenGL 4.2 reuses entry points from these extensions: } + Read_GL_ARB_base_instance; + //Read_GL_ARB_shading_language_420pack (no entry points) + Read_GL_ARB_transform_feedback_instanced; + //Read_GL_ARB_compressed_texture_pixel_storage (no entry points) + //Read_GL_ARB_conservative_depth; + Read_GL_ARB_internalformat_query; + //Read_GL_ARB_map_buffer_alignment; + Read_GL_ARB_shader_atomic_counters; + Read_GL_ARB_shader_image_load_store; + //Read_GL_ARB_shading_language_packing; + Read_GL_ARB_texture_storage; + + // GL_VERSION_4_3 + // OpenGL 4.3 reuses entry points from these extensions: + // Read_GL_ARB_arrays_of_arrays (none, GLSL only) (no entry points) + // Read_GL_ARB_fragment_layer_viewport (none, GLSL only) (no entry points) + // Read_GL_ARB_shader_image_size (none, GLSL only) (no entry points) + // Read_GL_ARB_ES3_compatibility (no entry points) + Read_GL_ARB_clear_buffer_object; + Read_GL_ARB_compute_shader; + Read_GL_ARB_copy_image; + Read_GL_KHR_debug; + // Read_GL_ARB_explicit_uniform_location (no entry points) + Read_GL_ARB_framebuffer_no_attachments; + Read_GL_ARB_internalformat_query2; + Read_GL_ARB_invalidate_subdata; + Read_GL_ARB_multi_draw_indirect; + Read_GL_ARB_program_interface_query; + // Read_GL_ARB_robust_buffer_access_behavior (none) (no entry points) + Read_GL_ARB_shader_storage_buffer_object; + // Read_GL_ARB_stencil_texturing (no entry points) + Read_GL_ARB_texture_buffer_range; + // Read_GL_ARB_texture_query_levels (none) (no entry points) + Read_GL_ARB_texture_storage_multisample; + Read_GL_ARB_texture_view; + Read_GL_ARB_vertex_attrib_binding; + + // GL_VERSION_4_4 + // Note (Due to Khronos' change in header conventions, no more single read_ functions) + Read_GL_4_4; +end; + +procedure Read_GL_3DFX_tbuffer; +begin + glTbufferMask3DFX := dglGetProcAddress('glTbufferMask3DFX'); +end; + +procedure Read_GL_APPLE_element_array; +begin + glElementPointerAPPLE := dglGetProcAddress('glElementPointerAPPLE'); + glDrawElementArrayAPPLE := dglGetProcAddress('glDrawElementArrayAPPLE'); + glDrawRangeElementArrayAPPLE := dglGetProcAddress('glDrawRangeElementArrayAPPLE'); + glMultiDrawElementArrayAPPLE := dglGetProcAddress('glMultiDrawElementArrayAPPLE'); + glMultiDrawRangeElementArrayAPPLE := dglGetProcAddress('glMultiDrawRangeElementArrayAPPLE'); +end; + +procedure Read_GL_APPLE_fence; +begin + glGenFencesAPPLE := dglGetProcAddress('glGenFencesAPPLE'); + glDeleteFencesAPPLE := dglGetProcAddress('glDeleteFencesAPPLE'); + glSetFenceAPPLE := dglGetProcAddress('glSetFenceAPPLE'); + glIsFenceAPPLE := dglGetProcAddress('glIsFenceAPPLE'); + glTestFenceAPPLE := dglGetProcAddress('glTestFenceAPPLE'); + glFinishFenceAPPLE := dglGetProcAddress('glFinishFenceAPPLE'); + glTestObjectAPPLE := dglGetProcAddress('glTestObjectAPPLE'); + glFinishObjectAPPLE := dglGetProcAddress('glFinishObjectAPPLE'); +end; + +procedure Read_GL_APPLE_vertex_array_object; +begin + glBindVertexArrayAPPLE := dglGetProcAddress('glBindVertexArrayAPPLE'); + glDeleteVertexArraysAPPLE := dglGetProcAddress('glDeleteVertexArraysAPPLE'); + glGenVertexArraysAPPLE := dglGetProcAddress('glGenVertexArraysAPPLE'); + glIsVertexArrayAPPLE := dglGetProcAddress('glIsVertexArrayAPPLE'); +end; + +procedure Read_GL_APPLE_vertex_array_range; +begin + glVertexArrayRangeAPPLE := dglGetProcAddress('glVertexArrayRangeAPPLE'); + glFlushVertexArrayRangeAPPLE := dglGetProcAddress('glFlushVertexArrayRangeAPPLE'); + glVertexArrayParameteriAPPLE := dglGetProcAddress('glVertexArrayParameteriAPPLE'); +end; + +procedure Read_GL_APPLE_texture_range; +begin + glTextureRangeAPPLE := dglGetProcAddress('glTextureRangeAPPLE'); + glGetTexParameterPointervAPPLE := dglGetProcAddress('glGetTexParameterPointervAPPLE'); +end; + +procedure Read_GL_APPLE_vertex_program_evaluators; +begin + glEnableVertexAttribAPPLE := dglGetProcAddress('glEnableVertexAttribAPPLE'); + glDisableVertexAttribAPPLE := dglGetProcAddress('glDisableVertexAttribAPPLE'); + glIsVertexAttribEnabledAPPLE := dglGetProcAddress('glIsVertexAttribEnabledAPPLE'); + glMapVertexAttrib1dAPPLE := dglGetProcAddress('glMapVertexAttrib1dAPPLE'); + glMapVertexAttrib1fAPPLE := dglGetProcAddress('glMapVertexAttrib1fAPPLE'); + glMapVertexAttrib2dAPPLE := dglGetProcAddress('glMapVertexAttrib2dAPPLE'); + glMapVertexAttrib2fAPPLE := dglGetProcAddress('glMapVertexAttrib2fAPPLE'); +end; + +procedure Read_GL_APPLE_object_purgeable; +begin + glObjectPurgeableAPPLE := dglGetProcAddress('glObjectPurgeableAPPLE'); + glObjectUnpurgeableAPPLE := dglGetProcAddress('glObjectUnpurgeableAPPLE'); + glGetObjectParameterivAPPLE := dglGetProcAddress('glGetObjectParameterivAPPLE'); +end; + +procedure Read_GL_ARB_matrix_palette; +begin + glCurrentPaletteMatrixARB := dglGetProcAddress('glCurrentPaletteMatrixARB'); + glMatrixIndexubvARB := dglGetProcAddress('glMatrixIndexubvARB'); + glMatrixIndexusvARB := dglGetProcAddress('glMatrixIndexusvARB'); + glMatrixIndexuivARB := dglGetProcAddress('glMatrixIndexuivARB'); + glMatrixIndexPointerARB := dglGetProcAddress('glMatrixIndexPointerARB'); +end; + +procedure Read_GL_ARB_multisample; +begin + glSampleCoverageARB := dglGetProcAddress('glSampleCoverageARB'); +end; + +procedure Read_GL_ARB_multitexture; +begin + glActiveTextureARB := dglGetProcAddress('glActiveTextureARB'); + glClientActiveTextureARB := dglGetProcAddress('glClientActiveTextureARB'); + glMultiTexCoord1dARB := dglGetProcAddress('glMultiTexCoord1dARB'); + glMultiTexCoord1dvARB := dglGetProcAddress('glMultiTexCoord1dvARB'); + glMultiTexCoord1fARB := dglGetProcAddress('glMultiTexCoord1fARB'); + glMultiTexCoord1fvARB := dglGetProcAddress('glMultiTexCoord1fvARB'); + glMultiTexCoord1iARB := dglGetProcAddress('glMultiTexCoord1iARB'); + glMultiTexCoord1ivARB := dglGetProcAddress('glMultiTexCoord1ivARB'); + glMultiTexCoord1sARB := dglGetProcAddress('glMultiTexCoord1sARB'); + glMultiTexCoord1svARB := dglGetProcAddress('glMultiTexCoord1svARB'); + glMultiTexCoord2dARB := dglGetProcAddress('glMultiTexCoord2dARB'); + glMultiTexCoord2dvARB := dglGetProcAddress('glMultiTexCoord2dvARB'); + glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB'); + glMultiTexCoord2fvARB := dglGetProcAddress('glMultiTexCoord2fvARB'); + glMultiTexCoord2iARB := dglGetProcAddress('glMultiTexCoord2iARB'); + glMultiTexCoord2ivARB := dglGetProcAddress('glMultiTexCoord2ivARB'); + glMultiTexCoord2sARB := dglGetProcAddress('glMultiTexCoord2sARB'); + glMultiTexCoord2svARB := dglGetProcAddress('glMultiTexCoord2svARB'); + glMultiTexCoord3dARB := dglGetProcAddress('glMultiTexCoord3dARB'); + glMultiTexCoord3dvARB := dglGetProcAddress('glMultiTexCoord3dvARB'); + glMultiTexCoord3fARB := dglGetProcAddress('glMultiTexCoord3fARB'); + glMultiTexCoord3fvARB := dglGetProcAddress('glMultiTexCoord3fvARB'); + glMultiTexCoord3iARB := dglGetProcAddress('glMultiTexCoord3iARB'); + glMultiTexCoord3ivARB := dglGetProcAddress('glMultiTexCoord3ivARB'); + glMultiTexCoord3sARB := dglGetProcAddress('glMultiTexCoord3sARB'); + glMultiTexCoord3svARB := dglGetProcAddress('glMultiTexCoord3svARB'); + glMultiTexCoord4dARB := dglGetProcAddress('glMultiTexCoord4dARB'); + glMultiTexCoord4dvARB := dglGetProcAddress('glMultiTexCoord4dvARB'); + glMultiTexCoord4fARB := dglGetProcAddress('glMultiTexCoord4fARB'); + glMultiTexCoord4fvARB := dglGetProcAddress('glMultiTexCoord4fvARB'); + glMultiTexCoord4iARB := dglGetProcAddress('glMultiTexCoord4iARB'); + glMultiTexCoord4ivARB := dglGetProcAddress('glMultiTexCoord4ivARB'); + glMultiTexCoord4sARB := dglGetProcAddress('glMultiTexCoord4sARB'); + glMultiTexCoord4svARB := dglGetProcAddress('glMultiTexCoord4svARB'); +end; + +procedure Read_GL_ARB_point_parameters; +begin + glPointParameterfARB := dglGetProcAddress('glPointParameterfARB'); + glPointParameterfvARB := dglGetProcAddress('glPointParameterfvARB'); +end; + +procedure Read_GL_ARB_texture_compression; +begin + glCompressedTexImage3DARB := dglGetProcAddress('glCompressedTexImage3DARB'); + glCompressedTexImage2DARB := dglGetProcAddress('glCompressedTexImage2DARB'); + glCompressedTexImage1DARB := dglGetProcAddress('glCompressedTexImage1DARB'); + glCompressedTexSubImage3DARB := dglGetProcAddress('glCompressedTexSubImage3DARB'); + glCompressedTexSubImage2DARB := dglGetProcAddress('glCompressedTexSubImage2DARB'); + glCompressedTexSubImage1DARB := dglGetProcAddress('glCompressedTexSubImage1DARB'); + glGetCompressedTexImageARB := dglGetProcAddress('glGetCompressedTexImageARB'); +end; + +procedure Read_GL_ARB_transpose_matrix; +begin + glLoadTransposeMatrixfARB := dglGetProcAddress('glLoadTransposeMatrixfARB'); + glLoadTransposeMatrixdARB := dglGetProcAddress('glLoadTransposeMatrixdARB'); + glMultTransposeMatrixfARB := dglGetProcAddress('glMultTransposeMatrixfARB'); + glMultTransposeMatrixdARB := dglGetProcAddress('glMultTransposeMatrixdARB'); +end; + +procedure Read_GL_ARB_vertex_blend; +begin + glWeightbvARB := dglGetProcAddress('glWeightbvARB'); + glWeightsvARB := dglGetProcAddress('glWeightsvARB'); + glWeightivARB := dglGetProcAddress('glWeightivARB'); + glWeightfvARB := dglGetProcAddress('glWeightfvARB'); + glWeightdvARB := dglGetProcAddress('glWeightdvARB'); + glWeightubvARB := dglGetProcAddress('glWeightubvARB'); + glWeightusvARB := dglGetProcAddress('glWeightusvARB'); + glWeightuivARB := dglGetProcAddress('glWeightuivARB'); + glWeightPointerARB := dglGetProcAddress('glWeightPointerARB'); + glVertexBlendARB := dglGetProcAddress('glVertexBlendARB'); +end; + +procedure Read_GL_ARB_vertex_buffer_object; +begin + glBindBufferARB := dglGetProcAddress('glBindBufferARB'); + glDeleteBuffersARB := dglGetProcAddress('glDeleteBuffersARB'); + glGenBuffersARB := dglGetProcAddress('glGenBuffersARB'); + glIsBufferARB := dglGetProcAddress('glIsBufferARB'); + glBufferDataARB := dglGetProcAddress('glBufferDataARB'); + glBufferSubDataARB := dglGetProcAddress('glBufferSubDataARB'); + glGetBufferSubDataARB := dglGetProcAddress('glGetBufferSubDataARB'); + glMapBufferARB := dglGetProcAddress('glMapBufferARB'); + glUnmapBufferARB := dglGetProcAddress('glUnmapBufferARB'); + glGetBufferParameterivARB := dglGetProcAddress('glGetBufferParameterivARB'); + glGetBufferPointervARB := dglGetProcAddress('glGetBufferPointervARB'); +end; + +procedure Read_GL_ARB_vertex_program; +begin + glVertexAttrib1dARB := dglGetProcAddress('glVertexAttrib1dARB'); + glVertexAttrib1dvARB := dglGetProcAddress('glVertexAttrib1dvARB'); + glVertexAttrib1fARB := dglGetProcAddress('glVertexAttrib1fARB'); + glVertexAttrib1fvARB := dglGetProcAddress('glVertexAttrib1fvARB'); + glVertexAttrib1sARB := dglGetProcAddress('glVertexAttrib1sARB'); + glVertexAttrib1svARB := dglGetProcAddress('glVertexAttrib1svARB'); + glVertexAttrib2dARB := dglGetProcAddress('glVertexAttrib2dARB'); + glVertexAttrib2dvARB := dglGetProcAddress('glVertexAttrib2dvARB'); + glVertexAttrib2fARB := dglGetProcAddress('glVertexAttrib2fARB'); + glVertexAttrib2fvARB := dglGetProcAddress('glVertexAttrib2fvARB'); + glVertexAttrib2sARB := dglGetProcAddress('glVertexAttrib2sARB'); + glVertexAttrib2svARB := dglGetProcAddress('glVertexAttrib2svARB'); + glVertexAttrib3dARB := dglGetProcAddress('glVertexAttrib3dARB'); + glVertexAttrib3dvARB := dglGetProcAddress('glVertexAttrib3dvARB'); + glVertexAttrib3fARB := dglGetProcAddress('glVertexAttrib3fARB'); + glVertexAttrib3fvARB := dglGetProcAddress('glVertexAttrib3fvARB'); + glVertexAttrib3sARB := dglGetProcAddress('glVertexAttrib3sARB'); + glVertexAttrib3svARB := dglGetProcAddress('glVertexAttrib3svARB'); + glVertexAttrib4NbvARB := dglGetProcAddress('glVertexAttrib4NbvARB'); + glVertexAttrib4NivARB := dglGetProcAddress('glVertexAttrib4NivARB'); + glVertexAttrib4NsvARB := dglGetProcAddress('glVertexAttrib4NsvARB'); + glVertexAttrib4NubARB := dglGetProcAddress('glVertexAttrib4NubARB'); + glVertexAttrib4NubvARB := dglGetProcAddress('glVertexAttrib4NubvARB'); + glVertexAttrib4NuivARB := dglGetProcAddress('glVertexAttrib4NuivARB'); + glVertexAttrib4NusvARB := dglGetProcAddress('glVertexAttrib4NusvARB'); + glVertexAttrib4bvARB := dglGetProcAddress('glVertexAttrib4bvARB'); + glVertexAttrib4dARB := dglGetProcAddress('glVertexAttrib4dARB'); + glVertexAttrib4dvARB := dglGetProcAddress('glVertexAttrib4dvARB'); + glVertexAttrib4fARB := dglGetProcAddress('glVertexAttrib4fARB'); + glVertexAttrib4fvARB := dglGetProcAddress('glVertexAttrib4fvARB'); + glVertexAttrib4ivARB := dglGetProcAddress('glVertexAttrib4ivARB'); + glVertexAttrib4sARB := dglGetProcAddress('glVertexAttrib4sARB'); + glVertexAttrib4svARB := dglGetProcAddress('glVertexAttrib4svARB'); + glVertexAttrib4ubvARB := dglGetProcAddress('glVertexAttrib4ubvARB'); + glVertexAttrib4uivARB := dglGetProcAddress('glVertexAttrib4uivARB'); + glVertexAttrib4usvARB := dglGetProcAddress('glVertexAttrib4usvARB'); + glVertexAttribPointerARB := dglGetProcAddress('glVertexAttribPointerARB'); + glEnableVertexAttribArrayARB := dglGetProcAddress('glEnableVertexAttribArrayARB'); + glDisableVertexAttribArrayARB := dglGetProcAddress('glDisableVertexAttribArrayARB'); + glProgramStringARB := dglGetProcAddress('glProgramStringARB'); + glBindProgramARB := dglGetProcAddress('glBindProgramARB'); + glDeleteProgramsARB := dglGetProcAddress('glDeleteProgramsARB'); + glGenProgramsARB := dglGetProcAddress('glGenProgramsARB'); + glProgramEnvParameter4dARB := dglGetProcAddress('glProgramEnvParameter4dARB'); + glProgramEnvParameter4dvARB := dglGetProcAddress('glProgramEnvParameter4dvARB'); + glProgramEnvParameter4fARB := dglGetProcAddress('glProgramEnvParameter4fARB'); + glProgramEnvParameter4fvARB := dglGetProcAddress('glProgramEnvParameter4fvARB'); + glProgramLocalParameter4dARB := dglGetProcAddress('glProgramLocalParameter4dARB'); + glProgramLocalParameter4dvARB := dglGetProcAddress('glProgramLocalParameter4dvARB'); + glProgramLocalParameter4fARB := dglGetProcAddress('glProgramLocalParameter4fARB'); + glProgramLocalParameter4fvARB := dglGetProcAddress('glProgramLocalParameter4fvARB'); + glGetProgramEnvParameterdvARB := dglGetProcAddress('glGetProgramEnvParameterdvARB'); + glGetProgramEnvParameterfvARB := dglGetProcAddress('glGetProgramEnvParameterfvARB'); + glGetProgramLocalParameterdvARB := dglGetProcAddress('glGetProgramLocalParameterdvARB'); + glGetProgramLocalParameterfvARB := dglGetProcAddress('glGetProgramLocalParameterfvARB'); + glGetProgramivARB := dglGetProcAddress('glGetProgramivARB'); + glGetProgramStringARB := dglGetProcAddress('glGetProgramStringARB'); + glGetVertexAttribdvARB := dglGetProcAddress('glGetVertexAttribdvARB'); + glGetVertexAttribfvARB := dglGetProcAddress('glGetVertexAttribfvARB'); + glGetVertexAttribivARB := dglGetProcAddress('glGetVertexAttribivARB'); + glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB'); + glIsProgramARB := dglGetProcAddress('glIsProgramARB'); +end; + +procedure Read_GL_ARB_window_pos; +begin + glWindowPos2dARB := dglGetProcAddress('glWindowPos2dARB'); + glWindowPos2dvARB := dglGetProcAddress('glWindowPos2dvARB'); + glWindowPos2fARB := dglGetProcAddress('glWindowPos2fARB'); + glWindowPos2fvARB := dglGetProcAddress('glWindowPos2fvARB'); + glWindowPos2iARB := dglGetProcAddress('glWindowPos2iARB'); + glWindowPos2ivARB := dglGetProcAddress('glWindowPos2ivARB'); + glWindowPos2sARB := dglGetProcAddress('glWindowPos2sARB'); + glWindowPos2svARB := dglGetProcAddress('glWindowPos2svARB'); + glWindowPos3dARB := dglGetProcAddress('glWindowPos3dARB'); + glWindowPos3dvARB := dglGetProcAddress('glWindowPos3dvARB'); + glWindowPos3fARB := dglGetProcAddress('glWindowPos3fARB'); + glWindowPos3fvARB := dglGetProcAddress('glWindowPos3fvARB'); + glWindowPos3iARB := dglGetProcAddress('glWindowPos3iARB'); + glWindowPos3ivARB := dglGetProcAddress('glWindowPos3ivARB'); + glWindowPos3sARB := dglGetProcAddress('glWindowPos3sARB'); + glWindowPos3svARB := dglGetProcAddress('glWindowPos3svARB'); +end; + +procedure Read_GL_ARB_draw_buffers; +begin + glDrawBuffersARB := dglGetProcAddress('glDrawBuffersARB'); +end; + +procedure Read_GL_ARB_color_buffer_float; +begin + glClampColorARB := dglGetProcAddress('glClampColorARB'); +end; + +procedure Read_GL_ARB_Shader_Objects; +begin + // GL_ARB_Shader_Objects + glCreateShaderObjectARB := dglGetProcAddress('glCreateShaderObjectARB'); + glShaderSourceARB := dglGetProcAddress('glShaderSourceARB'); + glCompileShaderARB := dglGetProcAddress('glCompileShaderARB'); + glDeleteObjectARB := dglGetProcAddress('glDeleteObjectARB'); + glGetHandleARB := dglGetProcAddress('glGetHandleARB'); + glDetachObjectARB := dglGetProcAddress('glDetachObjectARB'); + glCreateProgramObjectARB := dglGetProcAddress('glCreateProgramObjectARB'); + glAttachObjectARB := dglGetProcAddress('glAttachObjectARB'); + glLinkProgramARB := dglGetProcAddress('glLinkProgramARB'); + glUseProgramObjectARB := dglGetProcAddress('glUseProgramObjectARB'); + glValidateProgramARB := dglGetProcAddress('glValidateProgramARB'); + glGetObjectParameterfvARB := dglGetProcAddress('glGetObjectParameterfvARB'); + glGetObjectParameterivARB := dglGetProcAddress('glGetObjectParameterivARB'); + glGetActiveUniformARB := dglGetProcAddress('glGetActiveUniformARB'); + glGetAttachedObjectsARB := dglGetProcAddress('glGetAttachedObjectsARB'); + glGetShaderSourceARB := dglGetProcAddress('glGetShaderSourceARB'); + glGetUniformfvARB := dglGetProcAddress('glGetUniformfvARB'); + glGetUniformivARB := dglGetProcAddress('glGetUniformivARB'); + glGetUniformLocationARB := dglGetProcAddress('glGetUniformLocationARB'); + glGetInfoLogARB := dglGetProcAddress('glGetInfoLogARB'); + glUniform1fARB := dglGetProcAddress('glUniform1fARB'); + glUniform2fARB := dglGetProcAddress('glUniform2fARB'); + glUniform3fARB := dglGetProcAddress('glUniform3fARB'); + glUniform4fARB := dglGetProcAddress('glUniform4fARB'); + glUniform1iARB := dglGetProcAddress('glUniform1iARB'); + glUniform2iARB := dglGetProcAddress('glUniform2iARB'); + glUniform3iARB := dglGetProcAddress('glUniform3iARB'); + glUniform4iARB := dglGetProcAddress('glUniform4iARB'); + glUniform1fvARB := dglGetProcAddress('glUniform1fvARB'); + glUniform2fvARB := dglGetProcAddress('glUniform2fvARB'); + glUniform3fvARB := dglGetProcAddress('glUniform3fvARB'); + glUniform4fvARB := dglGetProcAddress('glUniform4fvARB'); + glUniform1ivARB := dglGetProcAddress('glUniform1ivARB'); + glUniform2ivARB := dglGetProcAddress('glUniform2ivARB'); + glUniform3ivARB := dglGetProcAddress('glUniform3ivARB'); + glUniform4ivARB := dglGetProcAddress('glUniform4ivARB'); + glUniformMatrix2fvARB := dglGetProcAddress('glUniformMatrix2fvARB'); + glUniformMatrix3fvARB := dglGetProcAddress('glUniformMatrix3fvARB'); + glUniformMatrix4fvARB := dglGetProcAddress('glUniformMatrix4fvARB'); + + // GL_ARB_vertex_shader + glGetActiveAttribARB := dglGetProcAddress('glGetActiveAttribARB'); + glGetAttribLocationARB := dglGetProcAddress('glGetAttribLocationARB'); + glBindAttribLocationARB := dglGetProcAddress('glBindAttribLocationARB'); + glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB'); +end; + +procedure Read_GL_ARB_occlusion_query; +begin + glGenQueriesARB := dglGetProcAddress('glGenQueriesARB'); + glDeleteQueriesARB := dglGetProcAddress('glDeleteQueriesARB'); + glIsQueryARB := dglGetProcAddress('glIsQueryARB'); + glBeginQueryARB := dglGetProcAddress('glBeginQueryARB'); + glEndQueryARB := dglGetProcAddress('glEndQueryARB'); + glGetQueryivARB := dglGetProcAddress('glGetQueryivARB'); + glGetQueryObjectivARB := dglGetProcAddress('glGetQueryObjectivARB'); + glGetQueryObjectuivARB := dglGetProcAddress('glGetQueryObjectuivARB'); +end; + +procedure Read_GL_ARB_draw_instanced; +begin + glDrawArraysInstancedARB := dglGetProcAddress('glDrawArraysInstancedARB'); + glDrawElementsInstancedARB := dglGetProcAddress('glDrawElementsInstancedARB'); +end; + +procedure Read_GL_ARB_framebuffer_object; +begin + glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer'); + glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer'); + glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers'); + glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers'); + glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage'); + glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv'); + glIsFramebuffer := dglGetProcAddress('glIsFramebuffer'); + glBindFramebuffer := dglGetProcAddress('glBindFramebuffer'); + glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers'); + glGenFramebuffers := dglGetProcAddress('glGenFramebuffers'); + glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus'); + glFramebufferTexture1D := dglGetProcAddress('glFramebufferTexture1D'); + glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D'); + glFramebufferTexture3D := dglGetProcAddress('glFramebufferTexture3D'); + glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer'); + glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv'); + glGenerateMipmap := dglGetProcAddress('glGenerateMipmap'); + glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer'); + glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample'); + glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer'); +end; + +procedure Read_GL_ARB_geometry_shader4; +begin + glProgramParameteriARB := dglGetProcAddress('glProgramParameteriARB'); + glFramebufferTextureARB := dglGetProcAddress('glFramebufferTextureARB'); + glFramebufferTextureLayerARB := dglGetProcAddress('glFramebufferTextureLayerARB'); + glFramebufferTextureFaceARB := dglGetProcAddress('glFramebufferTextureFaceARB'); +end; + +procedure Read_GL_ARB_instanced_arrays; +begin + glVertexAttribDivisorARB := dglGetProcAddress('glVertexAttribDivisorARB'); +end; + +procedure Read_GL_ARB_map_buffer_range; +begin + glMapBufferRange := dglGetProcAddress('glMapBufferRange'); + glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange'); +end; + +procedure Read_GL_ARB_texture_buffer_object; +begin + glTexBufferARB := dglGetProcAddress('glTexBufferARB'); +end; + +procedure Read_GL_ARB_vertex_array_object; +begin + glBindVertexArray := dglGetProcAddress('glBindVertexArray'); + glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays'); + glGenVertexArrays := dglGetProcAddress('glGenVertexArrays'); + glIsVertexArray := dglGetProcAddress('glIsVertexArray'); +end; + +procedure Read_GL_ARB_uniform_buffer_object; +begin + glGetUniformIndices := dglGetProcAddress('glGetUniformIndices'); + glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv'); + glGetActiveUniformName := dglGetProcAddress('glGetActiveUniformName'); + glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex'); + glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv'); + glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName'); + glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding'); +end; + +procedure Read_GL_ARB_copy_buffer; +begin + glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData'); +end; + +procedure Read_GL_ARB_draw_elements_base_vertex; +begin + glDrawElementsBaseVertex := dglGetProcAddress('glDrawElementsBaseVertex'); + glDrawRangeElementsBaseVertex := dglGetProcAddress('glDrawRangeElementsBaseVertex'); + glDrawElementsInstancedBaseVertex := dglGetProcAddress('glDrawElementsInstancedBaseVertex'); + glMultiDrawElementsBaseVertex := dglGetProcAddress('glMultiDrawElementsBaseVertex'); +end; + +procedure Read_GL_ARB_provoking_vertex; +begin + glProvokingVertex := dglGetProcAddress('glProvokingVertex'); +end; + +procedure Read_GL_ARB_sync; +begin + glFenceSync := dglGetProcAddress('glFenceSync'); + glIsSync := dglGetProcAddress('glIsSync'); + glDeleteSync := dglGetProcAddress('glDeleteSync'); + glClientWaitSync := dglGetProcAddress('glClientWaitSync'); + glWaitSync := dglGetProcAddress('glWaitSync'); + glGetInteger64v := dglGetProcAddress('glGetInteger64v'); + glGetSynciv := dglGetProcAddress('glGetSynciv'); +end; + +procedure Read_GL_ARB_texture_multisample; +begin + glTexImage2DMultisample := dglGetProcAddress('glTexImage2DMultisample'); + glTexImage3DMultisample := dglGetProcAddress('glTexImage3DMultisample'); + glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv'); + glSampleMaski := dglGetProcAddress('glSampleMaski'); +end; + +procedure Read_GL_ARB_draw_buffers_blend; +begin + glBlendEquationiARB := dglGetProcAddress('glBlendEquationiARB'); + glBlendEquationSeparateiARB := dglGetProcAddress('glBlendEquationSeparateiARB'); + glBlendFunciARB := dglGetProcAddress('glBlendFunciARB'); + glBlendFuncSeparateiARB := dglGetProcAddress('glBlendFuncSeparateiARB'); +end; + +procedure Read_GL_ARB_sample_shading; +begin + glMinSampleShadingARB := dglGetProcAddress('glMinSampleShadingARB'); +end; + +procedure Read_GL_ARB_shading_language_include; +begin + glNamedStringARB := dglGetProcAddress('glNamedStringARB'); + glDeleteNamedStringARB := dglGetProcAddress('glDeleteNamedStringARB'); + glCompileShaderIncludeARB := dglGetProcAddress('glCompileShaderIncludeARB'); + glIsNamedStringARB := dglGetProcAddress('glIsNamedStringARB'); + glGetNamedStringARB := dglGetProcAddress('glGetNamedStringARB'); + glGetNamedStringivARB := dglGetProcAddress('glGetNamedStringivARB'); +end; + +procedure Read_GL_ARB_blend_func_extended; +begin + glBindFragDataLocationIndexed := dglGetProcAddress('glBindFragDataLocationIndexed'); + glGetFragDataIndex := dglGetProcAddress('glGetFragDataIndex'); +end; + +procedure Read_GL_ARB_sampler_objects; +begin + glGenSamplers := dglGetProcAddress('glGenSamplers'); + glDeleteSamplers := dglGetProcAddress('glDeleteSamplers'); + glIsSampler := dglGetProcAddress('glIsSampler'); + glBindSampler := dglGetProcAddress('glBindSampler'); + glSamplerParameteri := dglGetProcAddress('glSamplerParameteri'); + glSamplerParameteriv := dglGetProcAddress('glSamplerParameteriv'); + glSamplerParameterf := dglGetProcAddress('glSamplerParameterf'); + glSamplerParameterfv := dglGetProcAddress('glSamplerParameterfv'); + glSamplerParameterIiv := dglGetProcAddress('glSamplerParameterIiv'); + glSamplerParameterIuiv := dglGetProcAddress('glSamplerParameterIuiv'); + glGetSamplerParameteriv := dglGetProcAddress('glGetSamplerParameteriv'); + glGetSamplerParameterIiv := dglGetProcAddress('glGetSamplerParameterIiv'); + glGetSamplerParameterfv := dglGetProcAddress('glGetSamplerParameterfv'); + glGetSamplerParameterIuiv := dglGetProcAddress('glGetSamplerParameterIuiv'); +end; + +procedure Read_GL_ARB_timer_query; +begin + glQueryCounter := dglGetProcAddress('glQueryCounter'); + glGetQueryObjecti64v := dglGetProcAddress('glGetQueryObjecti64v'); + glGetQueryObjectui64v := dglGetProcAddress('glGetQueryObjectui64v'); +end; + +procedure Read_GL_ARB_vertex_type_2_10_10_10_rev; +begin + glVertexP2ui := dglGetProcAddress('glVertexP2ui'); + glVertexP2uiv := dglGetProcAddress('glVertexP2uiv'); + glVertexP3ui := dglGetProcAddress('glVertexP3ui'); + glVertexP3uiv := dglGetProcAddress('glVertexP3uiv'); + glVertexP4ui := dglGetProcAddress('glVertexP4ui'); + glVertexP4uiv := dglGetProcAddress('glVertexP4uiv'); + glTexCoordP1ui := dglGetProcAddress('glTexCoordP1ui'); + glTexCoordP1uiv := dglGetProcAddress('glTexCoordP1uiv'); + glTexCoordP2ui := dglGetProcAddress('glTexCoordP2ui'); + glTexCoordP2uiv := dglGetProcAddress('glTexCoordP2uiv'); + glTexCoordP3ui := dglGetProcAddress('glTexCoordP3ui'); + glTexCoordP3uiv := dglGetProcAddress('glTexCoordP3uiv'); + glTexCoordP4ui := dglGetProcAddress('glTexCoordP4ui'); + glTexCoordP4uiv := dglGetProcAddress('glTexCoordP4uiv'); + glMultiTexCoordP1ui := dglGetProcAddress('glMultiTexCoordP1ui'); + glMultiTexCoordP1uiv := dglGetProcAddress('glMultiTexCoordP1uiv'); + glMultiTexCoordP2ui := dglGetProcAddress('glMultiTexCoordP2ui'); + glMultiTexCoordP2uiv := dglGetProcAddress('glMultiTexCoordP2uiv'); + glMultiTexCoordP3ui := dglGetProcAddress('glMultiTexCoordP3ui'); + glMultiTexCoordP3uiv := dglGetProcAddress('glMultiTexCoordP3uiv'); + glMultiTexCoordP4ui := dglGetProcAddress('glMultiTexCoordP4ui'); + glMultiTexCoordP4uiv := dglGetProcAddress('glMultiTexCoordP4uiv'); + glNormalP3ui := dglGetProcAddress('glNormalP3ui'); + glNormalP3uiv := dglGetProcAddress('glNormalP3uiv'); + glColorP3ui := dglGetProcAddress('glColorP3ui'); + glColorP3uiv := dglGetProcAddress('glColorP3uiv'); + glColorP4ui := dglGetProcAddress('glColorP4ui'); + glColorP4uiv := dglGetProcAddress('glColorP4uiv'); + glSecondaryColorP3ui := dglGetProcAddress('glSecondaryColorP3ui'); + glSecondaryColorP3uiv := dglGetProcAddress('glSecondaryColorP3uiv'); + glVertexAttribP1ui := dglGetProcAddress('glVertexAttribP1ui'); + glVertexAttribP1uiv := dglGetProcAddress('glVertexAttribP1uiv'); + glVertexAttribP2ui := dglGetProcAddress('glVertexAttribP2ui'); + glVertexAttribP2uiv := dglGetProcAddress('glVertexAttribP2uiv'); + glVertexAttribP3ui := dglGetProcAddress('glVertexAttribP3ui'); + glVertexAttribP3uiv := dglGetProcAddress('glVertexAttribP3uiv'); + glVertexAttribP4ui := dglGetProcAddress('glVertexAttribP4ui'); + glVertexAttribP4uiv := dglGetProcAddress('glVertexAttribP4uiv'); +end; + +procedure Read_GL_ARB_draw_indirect; +begin + glDrawArraysIndirect := dglGetProcAddress('glDrawArraysIndirect'); + glDrawElementsIndirect := dglGetProcAddress('glDrawElementsIndirect'); +end; + +procedure Read_GL_ARB_gpu_shader_fp64; +begin + glUniform1d := dglGetProcAddress('glUniform1d'); + glUniform2d := dglGetProcAddress('glUniform2d'); + glUniform3d := dglGetProcAddress('glUniform3d'); + glUniform4d := dglGetProcAddress('glUniform4d'); + glUniform1dv := dglGetProcAddress('glUniform1dv'); + glUniform2dv := dglGetProcAddress('glUniform2dv'); + glUniform3dv := dglGetProcAddress('glUniform3dv'); + glUniform4dv := dglGetProcAddress('glUniform4dv'); + glUniformMatrix2dv := dglGetProcAddress('glUniformMatrix2dv'); + glUniformMatrix3dv := dglGetProcAddress('glUniformMatrix3dv'); + glUniformMatrix4dv := dglGetProcAddress('glUniformMatrix4dv'); + glUniformMatrix2x3dv := dglGetProcAddress('glUniformMatrix2x3dv'); + glUniformMatrix2x4dv := dglGetProcAddress('glUniformMatrix2x4dv'); + glUniformMatrix3x2dv := dglGetProcAddress('glUniformMatrix3x2dv'); + glUniformMatrix3x4dv := dglGetProcAddress('glUniformMatrix3x4dv'); + glUniformMatrix4x2dv := dglGetProcAddress('glUniformMatrix4x2dv'); + glUniformMatrix4x3dv := dglGetProcAddress('glUniformMatrix4x3dv'); + glGetUniformdv := dglGetProcAddress('glGetUniformdv'); +end; + +procedure Read_GL_ARB_shader_subroutine; +begin + glGetSubroutineUniformLocation := dglGetProcAddress('glGetSubroutineUniformLocation'); + glGetSubroutineIndex := dglGetProcAddress('glGetSubroutineIndex'); + glGetActiveSubroutineUniformiv := dglGetProcAddress('glGetActiveSubroutineUniformiv'); + glGetActiveSubroutineUniformName := dglGetProcAddress('glGetActiveSubroutineUniformName'); + glGetActiveSubroutineName := dglGetProcAddress('glGetActiveSubroutineName'); + glUniformSubroutinesuiv := dglGetProcAddress('glUniformSubroutinesuiv'); + glGetUniformSubroutineuiv := dglGetProcAddress('glGetUniformSubroutineuiv'); + glGetProgramStageiv := dglGetProcAddress('glGetProgramStageiv'); +end; + +procedure Read_GL_ARB_tessellation_shader; +begin + glPatchParameteri := dglGetProcAddress('glPatchParameteri'); + glPatchParameterfv := dglGetProcAddress('glPatchParameterfv'); +end; + +procedure Read_GL_ARB_transform_feedback2; +begin + glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback'); + glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks'); + glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks'); + glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback'); + glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback'); + glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback'); + glDrawTransformFeedback := dglGetProcAddress('glDrawTransformFeedback'); +end; + +procedure Read_GL_ARB_transform_feedback3; +begin + glDrawTransformFeedbackStream := dglGetProcAddress('glDrawTransformFeedbackStream'); + glBeginQueryIndexed := dglGetProcAddress('glBeginQueryIndexed'); + glEndQueryIndexed := dglGetProcAddress('glEndQueryIndexed'); + glGetQueryIndexediv := dglGetProcAddress('glGetQueryIndexediv'); +end; + +procedure Read_GL_ARB_ES2_compatibility; +begin + glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler'); + glShaderBinary := dglGetProcAddress('glShaderBinary'); + glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat'); + glDepthRangef := dglGetProcAddress('glDepthRangef'); + glClearDepthf := dglGetProcAddress('glClearDepthf'); +end; + +procedure Read_GL_ARB_get_program_binary; +begin + glGetProgramBinary := dglGetProcAddress('glGetProgramBinary'); + glProgramBinary := dglGetProcAddress('glProgramBinary'); + glProgramParameteri := dglGetProcAddress('glProgramParameteri'); +end; + +procedure Read_GL_ARB_separate_shader_objects; +begin + glUseProgramStages := dglGetProcAddress('glUseProgramStages'); + glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram'); + glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv'); + glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline'); + glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines'); + glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines'); + glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline'); + glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv'); + glProgramUniform1i := dglGetProcAddress('glProgramUniform1i'); + glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv'); + glProgramUniform1f := dglGetProcAddress('glProgramUniform1f'); + glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv'); + glProgramUniform1d := dglGetProcAddress('glProgramUniform1d'); + glProgramUniform1dv := dglGetProcAddress('glProgramUniform1dv'); + glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui'); + glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv'); + glProgramUniform2i := dglGetProcAddress('glProgramUniform2i'); + glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv'); + glProgramUniform2f := dglGetProcAddress('glProgramUniform2f'); + glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv'); + glProgramUniform2d := dglGetProcAddress('glProgramUniform2d'); + glProgramUniform2dv := dglGetProcAddress('glProgramUniform2dv'); + glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui'); + glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv'); + glProgramUniform3i := dglGetProcAddress('glProgramUniform3i'); + glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv'); + glProgramUniform3f := dglGetProcAddress('glProgramUniform3f'); + glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv'); + glProgramUniform3d := dglGetProcAddress('glProgramUniform3d'); + glProgramUniform3dv := dglGetProcAddress('glProgramUniform3dv'); + glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui'); + glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv'); + glProgramUniform4i := dglGetProcAddress('glProgramUniform4i'); + glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv'); + glProgramUniform4f := dglGetProcAddress('glProgramUniform4f'); + glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv'); + glProgramUniform4d := dglGetProcAddress('glProgramUniform4d'); + glProgramUniform4dv := dglGetProcAddress('glProgramUniform4dv'); + glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui'); + glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv'); + glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv'); + glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv'); + glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv'); + glProgramUniformMatrix2dv := dglGetProcAddress('glProgramUniformMatrix2dv'); + glProgramUniformMatrix3dv := dglGetProcAddress('glProgramUniformMatrix3dv'); + glProgramUniformMatrix4dv := dglGetProcAddress('glProgramUniformMatrix4dv'); + glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv'); + glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv'); + glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv'); + glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv'); + glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv'); + glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv'); + glProgramUniformMatrix2x3dv := dglGetProcAddress('glProgramUniformMatrix2x3dv'); + glProgramUniformMatrix3x2dv := dglGetProcAddress('glProgramUniformMatrix3x2dv'); + glProgramUniformMatrix2x4dv := dglGetProcAddress('glProgramUniformMatrix2x4dv'); + glProgramUniformMatrix4x2dv := dglGetProcAddress('glProgramUniformMatrix4x2dv'); + glProgramUniformMatrix3x4dv := dglGetProcAddress('glProgramUniformMatrix3x4dv'); + glProgramUniformMatrix4x3dv := dglGetProcAddress('glProgramUniformMatrix4x3dv'); + glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline'); + glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog'); +end; + +procedure Read_GL_ARB_vertex_attrib_64bit; +begin + glVertexAttribL1d := dglGetProcAddress('glVertexAttribL1d'); + glVertexAttribL2d := dglGetProcAddress('glVertexAttribL2d'); + glVertexAttribL3d := dglGetProcAddress('glVertexAttribL3d'); + glVertexAttribL4d := dglGetProcAddress('glVertexAttribL4d'); + glVertexAttribL1dv := dglGetProcAddress('glVertexAttribL1dv'); + glVertexAttribL2dv := dglGetProcAddress('glVertexAttribL2dv'); + glVertexAttribL3dv := dglGetProcAddress('glVertexAttribL3dv'); + glVertexAttribL4dv := dglGetProcAddress('glVertexAttribL4dv'); + glVertexAttribLPointer := dglGetProcAddress('glVertexAttribLPointer'); + glGetVertexAttribLdv := dglGetProcAddress('glGetVertexAttribLdv'); +end; + +procedure Read_GL_ARB_viewport_array; +begin + glViewportArrayv := dglGetProcAddress('glViewportArrayv'); + glViewportIndexedf := dglGetProcAddress('glViewportIndexedf'); + glViewportIndexedfv := dglGetProcAddress('glViewportIndexedfv'); + glScissorArrayv := dglGetProcAddress('glScissorArrayv'); + glScissorIndexed := dglGetProcAddress('glScissorIndexed'); + glScissorIndexedv := dglGetProcAddress('glScissorIndexedv'); + glDepthRangeArrayv := dglGetProcAddress('glDepthRangeArrayv'); + glDepthRangeIndexed := dglGetProcAddress('glDepthRangeIndexed'); + glGetFloati_v := dglGetProcAddress('glGetFloati_v'); + glGetDoublei_v := dglGetProcAddress('glGetDoublei_v'); +end; + +// GL 4.2 + +procedure Read_GL_ARB_base_instance; +begin +glDrawArraysInstancedBaseInstance := dglGetProcAddress('glDrawArraysInstancedBaseInstance'); +glDrawElementsInstancedBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseInstance'); +glDrawElementsInstancedBaseVertexBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstance'); +end; + +procedure Read_GL_ARB_transform_feedback_instanced; +begin +glDrawTransformFeedbackInstanced := dglGetProcAddress('glDrawTransformFeedbackInstanced'); +glDrawTransformFeedbackStreamInstanced := dglGetProcAddress('glDrawTransformFeedbackStreamInstanced'); +end; + +procedure Read_GL_ARB_internalformat_query; +begin +glGetInternalformativ := dglGetProcAddress('glGetInternalformativ'); +end; + +procedure Read_GL_ARB_shader_atomic_counters; +begin +glGetActiveAtomicCounterBufferiv := dglGetProcAddress('glGetActiveAtomicCounterBufferiv'); +end; + +procedure Read_GL_ARB_shader_image_load_store; +begin +glBindImageTexture := dglGetProcAddress('glBindImageTexture'); +glMemoryBarrier := dglGetProcAddress('glMemoryBarrier'); +end; + +procedure Read_GL_ARB_texture_storage; +begin +glTexStorage1D := dglGetProcAddress('glTexStorage1D'); +glTexStorage2D := dglGetProcAddress('glTexStorage2D'); +glTexStorage3D := dglGetProcAddress('glTexStorage3D'); +glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT'); +glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT'); +glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT'); +end; + + +// GL 4.3 +procedure Read_GL_KHR_debug; +begin + glDebugMessageControl := dglGetProcAddress('glDebugMessageControl'); + glDebugMessageInsert := dglGetProcAddress('glDebugMessageInsert'); + glDebugMessageCallback := dglGetProcAddress('glDebugMessageCallback'); + glGetDebugMessageLog := dglGetProcAddress('glGetDebugMessageLog'); + glPushDebugGroup := dglGetProcAddress('glPushDebugGroup'); + glPopDebugGroup := dglGetProcAddress('glPopDebugGroup'); + glObjectLabel := dglGetProcAddress('glObjectLabel'); + glGetObjectLabel := dglGetProcAddress('glGetObjectLabel'); + glObjectPtrLabel := dglGetProcAddress('glObjectPtrLabel'); + glGetObjectPtrLabel := dglGetProcAddress('glGetObjectPtrLabel'); +end; + +procedure Read_GL_ARB_clear_buffer_object; +begin + glClearBufferData := dglGetProcAddress('glClearBufferData'); + glClearBufferSubData := dglGetProcAddress('glClearBufferSubData'); + glClearNamedBufferDataEXT := dglGetProcAddress('glClearNamedBufferDataEXT'); + glClearNamedBufferSubDataEXT := dglGetProcAddress('glClearNamedBufferSubDataEXT'); +end; + +procedure Read_GL_ARB_compute_shader; +begin + glDispatchCompute := dglGetProcAddress('glDispatchCompute'); + glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect'); +end; + +procedure Read_GL_ARB_copy_image; +begin + glCopyImageSubData := dglGetProcAddress('glCopyImageSubData'); +end; + +procedure Read_GL_ARB_framebuffer_no_attachments; +begin + glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri'); + glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv'); + glNamedFramebufferParameteriEXT := dglGetProcAddress('glNamedFramebufferParameteriEXT'); + glGetNamedFramebufferParameterivEXT := dglGetProcAddress('glGetNamedFramebufferParameterivEXT'); +end; + +procedure Read_GL_ARB_internalformat_query2; +begin + glGetInternalformati64v := dglGetProcAddress('glGetInternalformati64v');; +end; + +procedure Read_GL_ARB_invalidate_subdata; +begin + glInvalidateTexSubImage := dglGetProcAddress('glInvalidateTexSubImage'); + glInvalidateTexImage := dglGetProcAddress('glInvalidateTexImage'); + glInvalidateBufferSubData := dglGetProcAddress('glInvalidateBufferSubData'); + glInvalidateBufferData := dglGetProcAddress('glInvalidateBufferData'); + glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer'); + glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer'); +end; + +procedure Read_GL_ARB_multi_draw_indirect; +begin + glMultiDrawArraysIndirect := dglGetProcAddress('glMultiDrawArraysIndirect'); + glMultiDrawElementsIndirect := dglGetProcAddress('glMultiDrawElementsIndirect'); +end; + +procedure Read_GL_ARB_program_interface_query; +begin + glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv'); + glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex'); + glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName'); + glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv'); + glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation'); + glGetProgramResourceLocationIndex := dglGetProcAddress('glGetProgramResourceLocationIndex'); +end; + +procedure Read_GL_ARB_shader_storage_buffer_object; +begin + glShaderStorageBlockBinding := dglGetProcAddress('glShaderStorageBlockBinding'); +end; + +procedure Read_GL_ARB_texture_buffer_range; +begin + glTexBufferRange := dglGetProcAddress('glTexBufferRange'); + glTextureBufferRangeEXT := dglGetProcAddress('glTextureBufferRangeEXT'); +end; + +procedure Read_GL_ARB_texture_storage_multisample; +begin + glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample'); + glTexStorage3DMultisample := dglGetProcAddress('glTexStorage3DMultisample'); + glTextureStorage2DMultisampleEXT := dglGetProcAddress('glTextureStorage2DMultisampleEXT'); + glTextureStorage3DMultisampleEXT := dglGetProcAddress('glTextureStorage3DMultisampleEXT'); +end; + +procedure Read_GL_ARB_texture_view; +begin + glTextureView := dglGetProcAddress('glTextureView'); +end; + +procedure Read_GL_ARB_vertex_attrib_binding; +begin + glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer'); + glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat'); + glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat'); + glVertexAttribLFormat := dglGetProcAddress('glVertexAttribLFormat'); + glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding'); + glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor'); + glVertexArrayBindVertexBufferEXT := dglGetProcAddress('glVertexArrayBindVertexBufferEXT'); + glVertexArrayVertexAttribFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribFormatEXT'); + glVertexArrayVertexAttribIFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribIFormatEXT'); + glVertexArrayVertexAttribLFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribLFormatEXT'); + glVertexArrayVertexAttribBindingEXT := dglGetProcAddress('glVertexArrayVertexAttribBindingEXT'); + glVertexArrayVertexBindingDivisorEXT := dglGetProcAddress('glVertexArrayVertexBindingDivisorEXT'); +end; + +procedure Read_GL_4_4; +begin + glBufferStorage := dglGetProcAddress('glBufferStorage'); + glClearTexImage := dglGetProcAddress('glClearTexImage'); + glClearTexSubImage := dglGetProcAddress('glClearTexSubImage'); + glBindBuffersBase := dglGetProcAddress('glBindBuffersBase'); + glBindBuffersRange := dglGetProcAddress('glBindBuffersRange'); + glBindTextures := dglGetProcAddress('glBindTextures'); + glBindSamplers := dglGetProcAddress('glBindSamplers'); + glBindImageTextures := dglGetProcAddress('glBindImageTextures'); + glBindVertexBuffers := dglGetProcAddress('glBindVertexBuffers'); +end; + + +procedure Read_GL_NV_path_rendering; +begin + glGenPathsNV := dglGetProcAddress('glGenPathsNV'); + glDeletePathsNV := dglGetProcAddress('glDeletePathsNV'); + glIsPathNV := dglGetProcAddress('glIsPathNV'); + glPathCommandsNV := dglGetProcAddress('glPathCommandsNV'); + glPathCoordsNV := dglGetProcAddress('glPathCoordsNV'); + glPathSubCommandsNV := dglGetProcAddress('glPathSubCommandsNV'); + glPathSubCoordsNV := dglGetProcAddress('glPathSubCoordsNV'); + glPathStringNV := dglGetProcAddress('glPathStringNV'); + glPathGlyphsNV := dglGetProcAddress('glPathGlyphsNV'); + glPathGlyphRangeNV := dglGetProcAddress('glPathGlyphRangeNV'); + glWeightPathsNV := dglGetProcAddress('glWeightPathsNV'); + glCopyPathNV := dglGetProcAddress('glCopyPathNV'); + glInterpolatePathsNV := dglGetProcAddress('glInterpolatePathsNV'); + glTransformPathNV := dglGetProcAddress('glTransformPathNV'); + glPathParameterivNV := dglGetProcAddress('glPathParameterivNV'); + glPathParameteriNV := dglGetProcAddress('glPathParameteriNV'); + glPathParameterfvNV := dglGetProcAddress('glPathParameterfvNV'); + glPathParameterfNV := dglGetProcAddress('glPathParameterfNV'); + glPathDashArrayNV := dglGetProcAddress('glPathDashArrayNV'); + glPathStencilFuncNV := dglGetProcAddress('glPathStencilFuncNV'); + glPathStencilDepthOffsetNV := dglGetProcAddress('glPathStencilDepthOffsetNV'); + glStencilFillPathNV := dglGetProcAddress('glStencilFillPathNV'); + glStencilStrokePathNV := dglGetProcAddress('glStencilStrokePathNV'); + glStencilFillPathInstancedNV := dglGetProcAddress('glStencilFillPathInstancedNV'); + glStencilStrokePathInstancedNV := dglGetProcAddress('glStencilStrokePathInstancedNV'); + glPathCoverDepthFuncNV := dglGetProcAddress('glPathCoverDepthFuncNV'); + glPathColorGenNV := dglGetProcAddress('glPathColorGenNV'); + glPathTexGenNV := dglGetProcAddress('glPathTexGenNV'); + glPathFogGenNV := dglGetProcAddress('glPathFogGenNV'); + glCoverFillPathNV := dglGetProcAddress('glCoverFillPathNV'); + glCoverStrokePathNV := dglGetProcAddress('glCoverStrokePathNV'); + glCoverFillPathInstancedNV := dglGetProcAddress('glCoverFillPathInstancedNV'); + glCoverStrokePathInstancedNV := dglGetProcAddress('glCoverStrokePathInstancedNV'); + glGetPathParameterivNV := dglGetProcAddress('glGetPathParameterivNV'); + glGetPathParameterfvNV := dglGetProcAddress('glGetPathParameterfvNV'); + glGetPathCommandsNV := dglGetProcAddress('glGetPathCommandsNV'); + glGetPathCoordsNV := dglGetProcAddress('glGetPathCoordsNV'); + glGetPathDashArrayNV := dglGetProcAddress('glGetPathDashArrayNV'); + glGetPathMetricsNV := dglGetProcAddress('glGetPathMetricsNV'); + glGetPathMetricRangeNV := dglGetProcAddress('glGetPathMetricRangeNV'); + glGetPathSpacingNV := dglGetProcAddress('glGetPathSpacingNV'); + glGetPathColorGenivNV := dglGetProcAddress('glGetPathColorGenivNV'); + glGetPathColorGenfvNV := dglGetProcAddress('glGetPathColorGenfvNV'); + glGetPathTexGenivNV := dglGetProcAddress('glGetPathTexGenivNV'); + glGetPathTexGenfvNV := dglGetProcAddress('glGetPathTexGenfvNV'); + glIsPointInFillPathNV := dglGetProcAddress('glIsPointInFillPathNV'); + glIsPointInStrokePathNV := dglGetProcAddress('glIsPointInStrokePathNV'); + glGetPathLengthNV := dglGetProcAddress('glGetPathLengthNV'); + glPointAlongPathNV := dglGetProcAddress('glPointAlongPathNV'); +end; + +procedure Read_GL_AMD_stencil_operation_extended; +begin + glStencilOpValueAMD := dglGetProcAddress('glStencilOpValueAMD'); +end; + +procedure Read_GL_NV_bindless_texture; +begin + glGetTextureHandleNV := dglGetProcAddress('glGetTextureHandleNV'); + glGetTextureSamplerHandleNV := dglGetProcAddress('glGetTextureSamplerHandleNV'); + glMakeTextureHandleResidentNV := dglGetProcAddress('glMakeTextureHandleResidentNV'); + glMakeTextureHandleNonResidentNV := dglGetProcAddress('glMakeTextureHandleNonResidentNV'); + glGetImageHandleNV := dglGetProcAddress('glGetImageHandleNV'); + glMakeImageHandleResidentNV := dglGetProcAddress('glMakeImageHandleResidentNV'); + glMakeImageHandleNonResidentNV := dglGetProcAddress('glMakeImageHandleNonResidentNV'); + glUniformHandleui64NV := dglGetProcAddress('glUniformHandleui64NV'); + glUniformHandleui64vNV := dglGetProcAddress('glUniformHandleui64vNV'); + glProgramUniformHandleui64NV := dglGetProcAddress('glProgramUniformHandleui64NV'); + glProgramUniformHandleui64vNV := dglGetProcAddress('glProgramUniformHandleui64vNV'); + glIsTextureHandleResidentNV := dglGetProcAddress('glIsTextureHandleResidentNV'); + glIsImageHandleResidentNV := dglGetProcAddress('glIsImageHandleResidentNV'); +end; + +procedure Read_GL_ARB_cl_event; +begin + glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB'); +end; + +procedure Read_GL_ARB_debug_output; +begin + glDebugMessageControlARB := dglGetProcAddress('glDebugMessageControlARB'); + glDebugMessageInsertARB := dglGetProcAddress('glDebugMessageInsertARB'); + glDebugMessageCallbackARB := dglGetProcAddress('glDebugMessageCallbackARB'); + glGetDebugMessageLogARB := dglGetProcAddress('glGetDebugMessageLogARB'); +end; + +procedure Read_GL_ARB_robustness; +begin + glGetGraphicsResetStatusARB := dglGetProcAddress('glGetGraphicsResetStatusARB'); + glGetnMapdvARB := dglGetProcAddress('glGetnMapdvARB'); + glGetnMapfvARB := dglGetProcAddress('glGetnMapfvARB'); + glGetnMapivARB := dglGetProcAddress('glGetnMapivARB'); + glGetnPixelMapfvARB := dglGetProcAddress('glGetnPixelMapfvARB'); + glGetnPixelMapuivARB := dglGetProcAddress('glGetnPixelMapuivARB'); + glGetnPixelMapusvARB := dglGetProcAddress('glGetnPixelMapusvARB'); + glGetnPolygonStippleARB := dglGetProcAddress('glGetnPolygonStippleARB'); + glGetnColorTableARB := dglGetProcAddress('glGetnColorTableARB'); + glGetnConvolutionFilterARB := dglGetProcAddress('glGetnConvolutionFilterARB'); + glGetnSeparableFilterARB := dglGetProcAddress('glGetnSeparableFilterARB'); + glGetnHistogramARB := dglGetProcAddress('glGetnHistogramARB'); + glGetnMinmaxARB := dglGetProcAddress('glGetnMinmaxARB'); + glGetnTexImageARB := dglGetProcAddress('glGetnTexImageARB'); + glReadnPixelsARB := dglGetProcAddress('glReadnPixelsARB'); + glGetnCompressedTexImageARB := dglGetProcAddress('glGetnCompressedTexImageARB'); + glGetnUniformfvARB := dglGetProcAddress('glGetnUniformfvARB'); + glGetnUniformivARB := dglGetProcAddress('glGetnUniformivARB'); + glGetnUniformuivARB := dglGetProcAddress('glGetnUniformuivARB'); + glGetnUniformdvARB := dglGetProcAddress('glGetnUniformdvARB'); +end; + +procedure Read_GL_ATI_draw_buffers; +begin + glDrawBuffersATI := dglGetProcAddress('glDrawBuffersATI'); +end; + +procedure Read_GL_ATI_element_array; +begin + glElementPointerATI := dglGetProcAddress('glElementPointerATI'); + glDrawElementArrayATI := dglGetProcAddress('glDrawElementArrayATI'); + glDrawRangeElementArrayATI := dglGetProcAddress('glDrawRangeElementArrayATI'); +end; + +procedure Read_GL_ATI_envmap_bumpmap; +begin + glTexBumpParameterivATI := dglGetProcAddress('glTexBumpParameterivATI'); + glTexBumpParameterfvATI := dglGetProcAddress('glTexBumpParameterfvATI'); + glGetTexBumpParameterivATI := dglGetProcAddress('glGetTexBumpParameterivATI'); + glGetTexBumpParameterfvATI := dglGetProcAddress('glGetTexBumpParameterfvATI'); +end; + +procedure Read_GL_ATI_fragment_shader; +begin + glGenFragmentShadersATI := dglGetProcAddress('glGenFragmentShadersATI'); + glBindFragmentShaderATI := dglGetProcAddress('glBindFragmentShaderATI'); + glDeleteFragmentShaderATI := dglGetProcAddress('glDeleteFragmentShaderATI'); + glBeginFragmentShaderATI := dglGetProcAddress('glBeginFragmentShaderATI'); + glEndFragmentShaderATI := dglGetProcAddress('glEndFragmentShaderATI'); + glPassTexCoordATI := dglGetProcAddress('glPassTexCoordATI'); + glSampleMapATI := dglGetProcAddress('glSampleMapATI'); + glColorFragmentOp1ATI := dglGetProcAddress('glColorFragmentOp1ATI'); + glColorFragmentOp2ATI := dglGetProcAddress('glColorFragmentOp2ATI'); + glColorFragmentOp3ATI := dglGetProcAddress('glColorFragmentOp3ATI'); + glAlphaFragmentOp1ATI := dglGetProcAddress('glAlphaFragmentOp1ATI'); + glAlphaFragmentOp2ATI := dglGetProcAddress('glAlphaFragmentOp2ATI'); + glAlphaFragmentOp3ATI := dglGetProcAddress('glAlphaFragmentOp3ATI'); + glSetFragmentShaderConstantATI := dglGetProcAddress('glSetFragmentShaderConstantATI'); +end; + +procedure Read_GL_ATI_map_object_buffer; +begin + glMapObjectBufferATI := dglGetProcAddress('glMapObjectBufferATI'); + glUnmapObjectBufferATI := dglGetProcAddress('glUnmapObjectBufferATI'); +end; + +procedure Read_GL_ATI_pn_triangles; +begin + glPNTrianglesiATI := dglGetProcAddress('glPNTrianglesiATI'); + glPNTrianglesfATI := dglGetProcAddress('glPNTrianglesfATI'); +end; + +procedure Read_GL_ATI_separate_stencil; +begin + glStencilOpSeparateATI := dglGetProcAddress('glStencilOpSeparateATI'); + glStencilFuncSeparateATI := dglGetProcAddress('glStencilFuncSeparateATI'); +end; + +procedure Read_GL_ATI_vertex_array_object; +begin + glNewObjectBufferATI := dglGetProcAddress('glNewObjectBufferATI'); + glIsObjectBufferATI := dglGetProcAddress('glIsObjectBufferATI'); + glUpdateObjectBufferATI := dglGetProcAddress('glUpdateObjectBufferATI'); + glGetObjectBufferfvATI := dglGetProcAddress('glGetObjectBufferfvATI'); + glGetObjectBufferivATI := dglGetProcAddress('glGetObjectBufferivATI'); + glFreeObjectBufferATI := dglGetProcAddress('glFreeObjectBufferATI'); + glArrayObjectATI := dglGetProcAddress('glArrayObjectATI'); + glGetArrayObjectfvATI := dglGetProcAddress('glGetArrayObjectfvATI'); + glGetArrayObjectivATI := dglGetProcAddress('glGetArrayObjectivATI'); + glVariantArrayObjectATI := dglGetProcAddress('glVariantArrayObjectATI'); + glGetVariantArrayObjectfvATI := dglGetProcAddress('glGetVariantArrayObjectfvATI'); + glGetVariantArrayObjectivATI := dglGetProcAddress('glGetVariantArrayObjectivATI'); + +end; + +procedure Read_GL_ATI_vertex_attrib_array_object; +begin + glVertexAttribArrayObjectATI := dglGetProcAddress('glVertexAttribArrayObjectATI'); + glGetVertexAttribArrayObjectfvATI := dglGetProcAddress('glGetVertexAttribArrayObjectfvATI'); + glGetVertexAttribArrayObjectivATI := dglGetProcAddress('glGetVertexAttribArrayObjectivATI'); +end; + +procedure Read_GL_ATI_vertex_streams; +begin + glVertexStream1sATI := dglGetProcAddress('glVertexStream1sATI'); + glVertexStream1svATI := dglGetProcAddress('glVertexStream1svATI'); + glVertexStream1iATI := dglGetProcAddress('glVertexStream1iATI'); + glVertexStream1ivATI := dglGetProcAddress('glVertexStream1ivATI'); + glVertexStream1fATI := dglGetProcAddress('glVertexStream1fATI'); + glVertexStream1fvATI := dglGetProcAddress('glVertexStream1fvATI'); + glVertexStream1dATI := dglGetProcAddress('glVertexStream1dATI'); + glVertexStream1dvATI := dglGetProcAddress('glVertexStream1dvATI'); + glVertexStream2sATI := dglGetProcAddress('glVertexStream2sATI'); + glVertexStream2svATI := dglGetProcAddress('glVertexStream2svATI'); + glVertexStream2iATI := dglGetProcAddress('glVertexStream2iATI'); + glVertexStream2ivATI := dglGetProcAddress('glVertexStream2ivATI'); + glVertexStream2fATI := dglGetProcAddress('glVertexStream2fATI'); + glVertexStream2fvATI := dglGetProcAddress('glVertexStream2fvATI'); + glVertexStream2dATI := dglGetProcAddress('glVertexStream2dATI'); + glVertexStream2dvATI := dglGetProcAddress('glVertexStream2dvATI'); + glVertexStream3sATI := dglGetProcAddress('glVertexStream3sATI'); + glVertexStream3svATI := dglGetProcAddress('glVertexStream3svATI'); + glVertexStream3iATI := dglGetProcAddress('glVertexStream3iATI'); + glVertexStream3ivATI := dglGetProcAddress('glVertexStream3ivATI'); + glVertexStream3fATI := dglGetProcAddress('glVertexStream3fATI'); + glVertexStream3fvATI := dglGetProcAddress('glVertexStream3fvATI'); + glVertexStream3dATI := dglGetProcAddress('glVertexStream3dATI'); + glVertexStream3dvATI := dglGetProcAddress('glVertexStream3dvATI'); + glVertexStream4sATI := dglGetProcAddress('glVertexStream4sATI'); + glVertexStream4svATI := dglGetProcAddress('glVertexStream4svATI'); + glVertexStream4iATI := dglGetProcAddress('glVertexStream4iATI'); + glVertexStream4ivATI := dglGetProcAddress('glVertexStream4ivATI'); + glVertexStream4fATI := dglGetProcAddress('glVertexStream4fATI'); + glVertexStream4fvATI := dglGetProcAddress('glVertexStream4fvATI'); + glVertexStream4dATI := dglGetProcAddress('glVertexStream4dATI'); + glVertexStream4dvATI := dglGetProcAddress('glVertexStream4dvATI'); + glNormalStream3bATI := dglGetProcAddress('glNormalStream3bATI'); + glNormalStream3bvATI := dglGetProcAddress('glNormalStream3bvATI'); + glNormalStream3sATI := dglGetProcAddress('glNormalStream3sATI'); + glNormalStream3svATI := dglGetProcAddress('glNormalStream3svATI'); + glNormalStream3iATI := dglGetProcAddress('glNormalStream3iATI'); + glNormalStream3ivATI := dglGetProcAddress('glNormalStream3ivATI'); + glNormalStream3fATI := dglGetProcAddress('glNormalStream3fATI'); + glNormalStream3fvATI := dglGetProcAddress('glNormalStream3fvATI'); + glNormalStream3dATI := dglGetProcAddress('glNormalStream3dATI'); + glNormalStream3dvATI := dglGetProcAddress('glNormalStream3dvATI'); + glClientActiveVertexStreamATI := dglGetProcAddress('glClientActiveVertexStreamATI'); + glVertexBlendEnviATI := dglGetProcAddress('glVertexBlendEnviATI'); + glVertexBlendEnvfATI := dglGetProcAddress('glVertexBlendEnvfATI'); +end; + +procedure Read_GL_AMD_performance_monitor; +begin + glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD'); + glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD'); + glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD'); + glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD'); + glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD'); + glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD'); + glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD'); + glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD'); + glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD'); + glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD'); + glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD'); +end; + +procedure Read_GL_AMD_vertex_shader_tesselator; +begin + glTessellationFactorAMD := dglGetProcAddress('glTessellationFactorAMD'); + glTessellationModeAMD := dglGetProcAddress('glTessellationModeAMD'); +end; + +procedure Read_GL_AMD_draw_buffers_blend; +begin + glBlendFuncIndexedAMD := dglGetProcAddress('glBlendFuncIndexedAMD'); + glBlendFuncSeparateIndexedAMD := dglGetProcAddress('glBlendFuncSeparateIndexedAMD'); + glBlendEquationIndexedAMD := dglGetProcAddress('glBlendEquationIndexedAMD'); + glBlendEquationSeparateIndexedAMD := dglGetProcAddress('glBlendEquationSeparateIndexedAMD'); +end; + +procedure Read_GL_AMD_name_gen_delete; +begin + glGenNamesAMD := dglGetProcAddress('glGenNamesAMD'); + glDeleteNamesAMD := dglGetProcAddress('glDeleteNamesAMD'); + glIsNameAMD := dglGetProcAddress('glIsNameAMD'); +end; + +procedure Read_GL_AMD_debug_output; +begin + glDebugMessageEnableAMD := dglGetProcAddress('glDebugMessageEnableAMD'); + glDebugMessageInsertAMD := dglGetProcAddress('glDebugMessageInsertAMD'); + glDebugMessageCallbackAMD := dglGetProcAddress('glDebugMessageCallbackAMD'); + glGetDebugMessageLogAMD := dglGetProcAddress('glGetDebugMessageLogAMD'); +end; + +procedure Read_GL_EXT_blend_color; +begin + glBlendColorEXT := dglGetProcAddress('glBlendColorEXT'); +end; + +procedure Read_GL_EXT_blend_func_separate; +begin + glBlendFuncSeparateEXT := dglGetProcAddress('glBlendFuncSeparateEXT'); +end; + +procedure Read_GL_EXT_blend_minmax; +begin + glBlendEquationEXT := dglGetProcAddress('glBlendEquationEXT'); +end; + +procedure Read_GL_EXT_color_subtable; +begin + glColorSubTableEXT := dglGetProcAddress('glColorSubTableEXT'); + glCopyColorSubTableEXT := dglGetProcAddress('glCopyColorSubTableEXT'); +end; + +procedure Read_GL_EXT_compiled_vertex_array; +begin + glLockArraysEXT := dglGetProcAddress('glLockArraysEXT'); + glUnlockArraysEXT := dglGetProcAddress('glUnlockArraysEXT'); +end; + +procedure Read_GL_EXT_convolution; +begin + glConvolutionFilter1DEXT := dglGetProcAddress('glConvolutionFilter1DEXT'); + glConvolutionFilter2DEXT := dglGetProcAddress('glConvolutionFilter2DEXT'); + glConvolutionParameterfEXT := dglGetProcAddress('glConvolutionParameterfEXT'); + glConvolutionParameterfvEXT := dglGetProcAddress('glConvolutionParameterfvEXT'); + glConvolutionParameteriEXT := dglGetProcAddress('glConvolutionParameteriEXT'); + glConvolutionParameterivEXT := dglGetProcAddress('glConvolutionParameterivEXT'); + glCopyConvolutionFilter1DEXT := dglGetProcAddress('glCopyConvolutionFilter1DEXT'); + glCopyConvolutionFilter2DEXT := dglGetProcAddress('glCopyConvolutionFilter2DEXT'); + glGetConvolutionFilterEXT := dglGetProcAddress('glGetConvolutionFilterEXT'); + glGetConvolutionParameterfvEXT := dglGetProcAddress('glGetConvolutionParameterfvEXT'); + glGetConvolutionParameterivEXT := dglGetProcAddress('glGetConvolutionParameterivEXT'); + glGetSeparableFilterEXT := dglGetProcAddress('glGetSeparableFilterEXT'); + glSeparableFilter2DEXT := dglGetProcAddress('glSeparableFilter2DEXT'); +end; + +procedure Read_GL_EXT_coordinate_frame; +begin + glTangent3bEXT := dglGetProcAddress('glTangent3bEXT'); + glTangent3bvEXT := dglGetProcAddress('glTangent3bvEXT'); + glTangent3dEXT := dglGetProcAddress('glTangent3dEXT'); + glTangent3dvEXT := dglGetProcAddress('glTangent3dvEXT'); + glTangent3fEXT := dglGetProcAddress('glTangent3fEXT'); + glTangent3fvEXT := dglGetProcAddress('glTangent3fvEXT'); + glTangent3iEXT := dglGetProcAddress('glTangent3iEXT'); + glTangent3ivEXT := dglGetProcAddress('glTangent3ivEXT'); + glTangent3sEXT := dglGetProcAddress('glTangent3sEXT'); + glTangent3svEXT := dglGetProcAddress('glTangent3svEXT'); + glBinormal3bEXT := dglGetProcAddress('glBinormal3bEXT'); + glBinormal3bvEXT := dglGetProcAddress('glBinormal3bvEXT'); + glBinormal3dEXT := dglGetProcAddress('glBinormal3dEXT'); + glBinormal3dvEXT := dglGetProcAddress('glBinormal3dvEXT'); + glBinormal3fEXT := dglGetProcAddress('glBinormal3fEXT'); + glBinormal3fvEXT := dglGetProcAddress('glBinormal3fvEXT'); + glBinormal3iEXT := dglGetProcAddress('glBinormal3iEXT'); + glBinormal3ivEXT := dglGetProcAddress('glBinormal3ivEXT'); + glBinormal3sEXT := dglGetProcAddress('glBinormal3sEXT'); + glBinormal3svEXT := dglGetProcAddress('glBinormal3svEXT'); + glTangentPointerEXT := dglGetProcAddress('glTangentPointerEXT'); + glBinormalPointerEXT := dglGetProcAddress('glBinormalPointerEXT'); +end; + +procedure Read_GL_EXT_copy_texture; +begin + glCopyTexImage1DEXT := dglGetProcAddress('glCopyTexImage1DEXT'); + glCopyTexImage2DEXT := dglGetProcAddress('glCopyTexImage2DEXT'); + glCopyTexSubImage1DEXT := dglGetProcAddress('glCopyTexSubImage1DEXT'); + glCopyTexSubImage2DEXT := dglGetProcAddress('glCopyTexSubImage2DEXT'); + glCopyTexSubImage3DEXT := dglGetProcAddress('glCopyTexSubImage3DEXT'); +end; + +procedure Read_GL_EXT_cull_vertex; +begin + glCullParameterdvEXT := dglGetProcAddress('glCullParameterdvEXT'); + glCullParameterfvEXT := dglGetProcAddress('glCullParameterfvEXT'); +end; + +procedure Read_GL_EXT_draw_range_elements; +begin + glDrawRangeElementsEXT := dglGetProcAddress('glDrawRangeElementsEXT'); +end; + +procedure Read_GL_EXT_fog_coord; +begin + glFogCoordfEXT := dglGetProcAddress('glFogCoordfEXT'); + glFogCoordfvEXT := dglGetProcAddress('glFogCoordfvEXT'); + glFogCoorddEXT := dglGetProcAddress('glFogCoorddEXT'); + glFogCoorddvEXT := dglGetProcAddress('glFogCoorddvEXT'); + glFogCoordPointerEXT := dglGetProcAddress('glFogCoordPointerEXT'); +end; + +procedure Read_GL_EXT_framebuffer_object; +begin + glIsRenderbufferEXT := dglGetProcAddress('glIsRenderbufferEXT'); + glBindRenderbufferEXT := dglGetProcAddress('glBindRenderbufferEXT'); + glDeleteRenderbuffersEXT := dglGetProcAddress('glDeleteRenderbuffersEXT'); + glGenRenderbuffersEXT := dglGetProcAddress('glGenRenderbuffersEXT'); + glRenderbufferStorageEXT := dglGetProcAddress('glRenderbufferStorageEXT'); + glGetRenderbufferParameterivEXT := dglGetProcAddress('glGetRenderbufferParameterivEXT'); + glIsFramebufferEXT := dglGetProcAddress('glIsFramebufferEXT'); + glBindFramebufferEXT := dglGetProcAddress('glBindFramebufferEXT'); + glDeleteFramebuffersEXT := dglGetProcAddress('glDeleteFramebuffersEXT'); + glGenFramebuffersEXT := dglGetProcAddress('glGenFramebuffersEXT'); + glCheckFramebufferStatusEXT := dglGetProcAddress('glCheckFramebufferStatusEXT'); + glFramebufferTexture1DEXT := dglGetProcAddress('glFramebufferTexture1DEXT'); + glFramebufferTexture2DEXT := dglGetProcAddress('glFramebufferTexture2DEXT'); + glFramebufferTexture3DEXT := dglGetProcAddress('glFramebufferTexture3DEXT'); + glFramebufferRenderbufferEXT := dglGetProcAddress('glFramebufferRenderbufferEXT'); + glGetFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetFramebufferAttachmentParameterivEXT'); + glGenerateMipmapEXT := dglGetProcAddress('glGenerateMipmapEXT'); +end; + +procedure Read_GL_EXT_histogram; +begin + glGetHistogramEXT := dglGetProcAddress('glGetHistogramEXT'); + glGetHistogramParameterfvEXT := dglGetProcAddress('glGetHistogramParameterfvEXT'); + glGetHistogramParameterivEXT := dglGetProcAddress('glGetHistogramParameterivEXT'); + glGetMinmaxEXT := dglGetProcAddress('glGetMinmaxEXT'); + glGetMinmaxParameterfvEXT := dglGetProcAddress('glGetMinmaxParameterfvEXT'); + glGetMinmaxParameterivEXT := dglGetProcAddress('glGetMinmaxParameterivEXT'); + glHistogramEXT := dglGetProcAddress('glHistogramEXT'); + glMinmaxEXT := dglGetProcAddress('glMinmaxEXT'); + glResetHistogramEXT := dglGetProcAddress('glResetHistogramEXT'); + glResetMinmaxEXT := dglGetProcAddress('glResetMinmaxEXT'); +end; + +procedure Read_GL_EXT_index_func; +begin + glIndexFuncEXT := dglGetProcAddress('glIndexFuncEXT'); +end; + +procedure Read_GL_EXT_index_material; +begin + glIndexMaterialEXT := dglGetProcAddress('glIndexMaterialEXT'); +end; + +procedure Read_GL_EXT_light_texture; +begin + glApplyTextureEXT := dglGetProcAddress('glApplyTextureEXT'); + glTextureLightEXT := dglGetProcAddress('glTextureLightEXT'); + glTextureMaterialEXT := dglGetProcAddress('glTextureMaterialEXT'); +end; + +procedure Read_GL_EXT_multi_draw_arrays; +begin + glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT'); + glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT'); +end; + +procedure Read_GL_EXT_multisample; +begin + glSampleMaskEXT := dglGetProcAddress('glSampleMaskEXT'); + glSamplePatternEXT := dglGetProcAddress('glSamplePatternEXT'); +end; + +procedure Read_GL_EXT_paletted_texture; +begin + glColorTableEXT := dglGetProcAddress('glColorTableEXT'); + glGetColorTableEXT := dglGetProcAddress('glGetColorTableEXT'); + glGetColorTableParameterivEXT := dglGetProcAddress('glGetColorTableParameterivEXT'); + glGetColorTableParameterfvEXT := dglGetProcAddress('glGetColorTableParameterfvEXT'); +end; + +procedure Read_GL_EXT_pixel_transform; +begin + glPixelTransformParameteriEXT := dglGetProcAddress('glPixelTransformParameteriEXT'); + glPixelTransformParameterfEXT := dglGetProcAddress('glPixelTransformParameterfEXT'); + glPixelTransformParameterivEXT := dglGetProcAddress('glPixelTransformParameterivEXT'); + glPixelTransformParameterfvEXT := dglGetProcAddress('glPixelTransformParameterfvEXT'); +end; + +procedure Read_GL_EXT_point_parameters; +begin + glPointParameterfEXT := dglGetProcAddress('glPointParameterfEXT'); + glPointParameterfvEXT := dglGetProcAddress('glPointParameterfvEXT'); +end; + +procedure Read_GL_EXT_polygon_offset; +begin + glPolygonOffsetEXT := dglGetProcAddress('glPolygonOffsetEXT'); +end; + +procedure Read_GL_EXT_secondary_color; +begin + glSecondaryColor3bEXT := dglGetProcAddress('glSecondaryColor3bEXT'); + glSecondaryColor3bvEXT := dglGetProcAddress('glSecondaryColor3bvEXT'); + glSecondaryColor3dEXT := dglGetProcAddress('glSecondaryColor3dEXT'); + glSecondaryColor3dvEXT := dglGetProcAddress('glSecondaryColor3dvEXT'); + glSecondaryColor3fEXT := dglGetProcAddress('glSecondaryColor3fEXT'); + glSecondaryColor3fvEXT := dglGetProcAddress('glSecondaryColor3fvEXT'); + glSecondaryColor3iEXT := dglGetProcAddress('glSecondaryColor3iEXT'); + glSecondaryColor3ivEXT := dglGetProcAddress('glSecondaryColor3ivEXT'); + glSecondaryColor3sEXT := dglGetProcAddress('glSecondaryColor3sEXT'); + glSecondaryColor3svEXT := dglGetProcAddress('glSecondaryColor3svEXT'); + glSecondaryColor3ubEXT := dglGetProcAddress('glSecondaryColor3ubEXT'); + glSecondaryColor3ubvEXT := dglGetProcAddress('glSecondaryColor3ubvEXT'); + glSecondaryColor3uiEXT := dglGetProcAddress('glSecondaryColor3uiEXT'); + glSecondaryColor3uivEXT := dglGetProcAddress('glSecondaryColor3uivEXT'); + glSecondaryColor3usEXT := dglGetProcAddress('glSecondaryColor3usEXT'); + glSecondaryColor3usvEXT := dglGetProcAddress('glSecondaryColor3usvEXT'); + glSecondaryColorPointerEXT := dglGetProcAddress('glSecondaryColorPointerEXT'); +end; + +procedure Read_GL_EXT_stencil_two_side; +begin + glActiveStencilFaceEXT := dglGetProcAddress('glActiveStencilFaceEXT'); +end; + +procedure Read_GL_EXT_subtexture; +begin + glTexSubImage1DEXT := dglGetProcAddress('glTexSubImage1DEXT'); + glTexSubImage2DEXT := dglGetProcAddress('glTexSubImage2DEXT'); +end; + +procedure Read_GL_EXT_texture3D; +begin + glTexImage3DEXT := dglGetProcAddress('glTexImage3DEXT'); + glTexSubImage3DEXT := dglGetProcAddress('glTexSubImage3DEXT'); +end; + +procedure Read_GL_EXT_texture_object; +begin + glAreTexturesResidentEXT := dglGetProcAddress('glAreTexturesResidentEXT'); + glBindTextureEXT := dglGetProcAddress('glBindTextureEXT'); + glDeleteTexturesEXT := dglGetProcAddress('glDeleteTexturesEXT'); + glGenTexturesEXT := dglGetProcAddress('glGenTexturesEXT'); + glIsTextureEXT := dglGetProcAddress('glIsTextureEXT'); + glPrioritizeTexturesEXT := dglGetProcAddress('glPrioritizeTexturesEXT'); +end; + +procedure Read_GL_EXT_texture_perturb_normal; +begin + glTextureNormalEXT := dglGetProcAddress('glTextureNormalEXT'); +end; + +procedure Read_GL_EXT_vertex_array; +begin + glArrayElementEXT := dglGetProcAddress('glArrayElementEXT'); + glColorPointerEXT := dglGetProcAddress('glColorPointerEXT'); + glDrawArraysEXT := dglGetProcAddress('glDrawArraysEXT'); + glEdgeFlagPointerEXT := dglGetProcAddress('glEdgeFlagPointerEXT'); + glGetPointervEXT := dglGetProcAddress('glGetPointervEXT'); + glIndexPointerEXT := dglGetProcAddress('glIndexPointerEXT'); + glNormalPointerEXT := dglGetProcAddress('glNormalPointerEXT'); + glTexCoordPointerEXT := dglGetProcAddress('glTexCoordPointerEXT'); + glVertexPointerEXT := dglGetProcAddress('glVertexPointerEXT'); +end; + +procedure Read_GL_EXT_vertex_shader; +begin + glBeginVertexShaderEXT := dglGetProcAddress('glBeginVertexShaderEXT'); + glEndVertexShaderEXT := dglGetProcAddress('glEndVertexShaderEXT'); + glBindVertexShaderEXT := dglGetProcAddress('glBindVertexShaderEXT'); + glGenVertexShadersEXT := dglGetProcAddress('glGenVertexShadersEXT'); + glDeleteVertexShaderEXT := dglGetProcAddress('glDeleteVertexShaderEXT'); + glShaderOp1EXT := dglGetProcAddress('glShaderOp1EXT'); + glShaderOp2EXT := dglGetProcAddress('glShaderOp2EXT'); + glShaderOp3EXT := dglGetProcAddress('glShaderOp3EXT'); + glSwizzleEXT := dglGetProcAddress('glSwizzleEXT'); + glWriteMaskEXT := dglGetProcAddress('glWriteMaskEXT'); + glInsertComponentEXT := dglGetProcAddress('glInsertComponentEXT'); + glExtractComponentEXT := dglGetProcAddress('glExtractComponentEXT'); + glGenSymbolsEXT := dglGetProcAddress('glGenSymbolsEXT'); + glSetInvariantEXT := dglGetProcAddress('glSetInvariantEXT'); + glSetLocalConstantEXT := dglGetProcAddress('glSetLocalConstantEXT'); + glVariantbvEXT := dglGetProcAddress('glVariantbvEXT'); + glVariantsvEXT := dglGetProcAddress('glVariantsvEXT'); + glVariantivEXT := dglGetProcAddress('glVariantivEXT'); + glVariantfvEXT := dglGetProcAddress('glVariantfvEXT'); + glVariantdvEXT := dglGetProcAddress('glVariantdvEXT'); + glVariantubvEXT := dglGetProcAddress('glVariantubvEXT'); + glVariantusvEXT := dglGetProcAddress('glVariantusvEXT'); + glVariantuivEXT := dglGetProcAddress('glVariantuivEXT'); + glVariantPointerEXT := dglGetProcAddress('glVariantPointerEXT'); + glEnableVariantClientStateEXT := dglGetProcAddress('glEnableVariantClientStateEXT'); + glDisableVariantClientStateEXT := dglGetProcAddress('glDisableVariantClientStateEXT'); + glBindLightParameterEXT := dglGetProcAddress('glBindLightParameterEXT'); + glBindMaterialParameterEXT := dglGetProcAddress('glBindMaterialParameterEXT'); + glBindTexGenParameterEXT := dglGetProcAddress('glBindTexGenParameterEXT'); + glBindTextureUnitParameterEXT := dglGetProcAddress('glBindTextureUnitParameterEXT'); + glBindParameterEXT := dglGetProcAddress('glBindParameterEXT'); + glIsVariantEnabledEXT := dglGetProcAddress('glIsVariantEnabledEXT'); + glGetVariantBooleanvEXT := dglGetProcAddress('glGetVariantBooleanvEXT'); + glGetVariantIntegervEXT := dglGetProcAddress('glGetVariantIntegervEXT'); + glGetVariantFloatvEXT := dglGetProcAddress('glGetVariantFloatvEXT'); + glGetVariantPointervEXT := dglGetProcAddress('glGetVariantPointervEXT'); + glGetInvariantBooleanvEXT := dglGetProcAddress('glGetInvariantBooleanvEXT'); + glGetInvariantIntegervEXT := dglGetProcAddress('glGetInvariantIntegervEXT'); + glGetInvariantFloatvEXT := dglGetProcAddress('glGetInvariantFloatvEXT'); + glGetLocalConstantBooleanvEXT := dglGetProcAddress('glGetLocalConstantBooleanvEXT'); + glGetLocalConstantIntegervEXT := dglGetProcAddress('glGetLocalConstantIntegervEXT'); + glGetLocalConstantFloatvEXT := dglGetProcAddress('glGetLocalConstantFloatvEXT'); +end; + +procedure Read_GL_EXT_vertex_weighting; +begin + glVertexWeightfEXT := dglGetProcAddress('glVertexWeightfEXT'); + glVertexWeightfvEXT := dglGetProcAddress('glVertexWeightfvEXT'); + glVertexWeightPointerEXT := dglGetProcAddress('glVertexWeightPointerEXT'); +end; + +procedure Read_GL_EXT_depth_bounds_test; +begin + glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP'); + glDepthBoundsEXT := dglGetProcAddress('glDepthBoundsEXT'); +end; + +procedure Read_GL_EXT_blend_equation_separate; +begin + glBlendEquationSeparateEXT := dglGetProcAddress('glBlendEquationSeparateEXT'); +end; + +procedure Read_GL_EXT_stencil_clear_tag; +begin + glStencilClearTagEXT := dglGetProcAddress('glStencilClearTagEXT'); +end; + +procedure Read_GL_EXT_framebuffer_blit; +begin + glBlitFramebufferEXT := dglGetProcAddress('glBlitFramebufferEXT'); +end; + +procedure Read_GL_EXT_framebuffer_multisample; +begin + glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT'); +end; + +procedure Read_GL_EXT_timer_query; +begin + glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT'); + glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT'); +end; + +procedure Read_GL_EXT_gpu_program_parameters; +begin + glProgramEnvParameters4fvEXT := dglGetProcAddress('glProgramEnvParameters4fvEXT'); + glProgramLocalParameters4fvEXT := dglGetProcAddress('glProgramLocalParameters4fvEXT'); +end; + +procedure Read_GL_EXT_bindable_uniform; +begin + glUniformBufferEXT := dglGetProcAddress('glUniformBufferEXT'); + glGetUniformBufferSizeEXT := dglGetProcAddress('glGetUniformBufferSizeEXT'); + glGetUniformOffsetEXT := dglGetProcAddress('glGetUniformOffsetEXT'); +end; + +procedure Read_GL_EXT_draw_buffers2; +begin + glColorMaskIndexedEXT := dglGetProcAddress('glColorMaskIndexedEXT'); + glGetBooleanIndexedvEXT := dglGetProcAddress('glGetBooleanIndexedvEXT'); + glGetIntegerIndexedvEXT := dglGetProcAddress('glGetIntegerIndexedvEXT'); + glEnableIndexedEXT := dglGetProcAddress('glEnableIndexedEXT'); + glDisableIndexedEXT := dglGetProcAddress('glDisableIndexedEXT'); + glIsEnabledIndexedEXT := dglGetProcAddress('glIsEnabledIndexedEXT'); +end; + +procedure Read_GL_EXT_draw_instanced; +begin + glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT'); + glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT'); +end; + +procedure Read_GL_EXT_geometry_shader4; +begin + glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT'); + glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT'); +// glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT'); + glFramebufferTextureFaceEXT := dglGetProcAddress('glFramebufferTextureFaceEXT'); +end; + +procedure Read_GL_EXT_gpu_shader4; +begin + glVertexAttribI1iEXT := dglGetProcAddress('glVertexAttribI1iEXT'); + glVertexAttribI2iEXT := dglGetProcAddress('glVertexAttribI2iEXT'); + glVertexAttribI3iEXT := dglGetProcAddress('glVertexAttribI3iEXT'); + glVertexAttribI4iEXT := dglGetProcAddress('glVertexAttribI4iEXT'); + glVertexAttribI1uiEXT := dglGetProcAddress('glVertexAttribI1uiEXT'); + glVertexAttribI2uiEXT := dglGetProcAddress('glVertexAttribI2uiEXT'); + glVertexAttribI3uiEXT := dglGetProcAddress('glVertexAttribI3uiEXT'); + glVertexAttribI4uiEXT := dglGetProcAddress('glVertexAttribI4uiEXT'); + glVertexAttribI1ivEXT := dglGetProcAddress('glVertexAttribI1ivEXT'); + glVertexAttribI2ivEXT := dglGetProcAddress('glVertexAttribI2ivEXT'); + glVertexAttribI3ivEXT := dglGetProcAddress('glVertexAttribI3ivEXT'); + glVertexAttribI4ivEXT := dglGetProcAddress('glVertexAttribI4ivEXT'); + glVertexAttribI1uivEXT := dglGetProcAddress('glVertexAttribI1uivEXT'); + glVertexAttribI2uivEXT := dglGetProcAddress('glVertexAttribI2uivEXT'); + glVertexAttribI3uivEXT := dglGetProcAddress('glVertexAttribI3uivEXT'); + glVertexAttribI4uivEXT := dglGetProcAddress('glVertexAttribI4uivEXT'); + glVertexAttribI4bvEXT := dglGetProcAddress('glVertexAttribI4bvEXT'); + glVertexAttribI4svEXT := dglGetProcAddress('glVertexAttribI4svEXT'); + glVertexAttribI4ubvEXT := dglGetProcAddress('glVertexAttribI4ubvEXT'); + glVertexAttribI4usvEXT := dglGetProcAddress('glVertexAttribI4usvEXT'); + glVertexAttribIPointerEXT := dglGetProcAddress('glVertexAttribIPointerEXT'); + glGetVertexAttribIivEXT := dglGetProcAddress('glGetVertexAttribIivEXT'); + glGetVertexAttribIuivEXT := dglGetProcAddress('glGetVertexAttribIuivEXT'); + glUniform1uiEXT := dglGetProcAddress('glUniform1uiEXT'); + glUniform2uiEXT := dglGetProcAddress('glUniform2uiEXT'); + glUniform3uiEXT := dglGetProcAddress('glUniform3uiEXT'); + glUniform4uiEXT := dglGetProcAddress('glUniform4uiEXT'); + glUniform1uivEXT := dglGetProcAddress('glUniform1uivEXT'); + glUniform2uivEXT := dglGetProcAddress('glUniform2uivEXT'); + glUniform3uivEXT := dglGetProcAddress('glUniform3uivEXT'); + glUniform4uivEXT := dglGetProcAddress('glUniform4uivEXT'); + glGetUniformuivEXT := dglGetProcAddress('glGetUniformuivEXT'); + glBindFragDataLocationEXT := dglGetProcAddress('glBindFragDataLocationEXT'); + glGetFragDataLocationEXT := dglGetProcAddress('glGetFragDataLocationEXT'); +end; + +procedure Read_GL_EXT_texture_array; +begin + glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT'); +end; + +procedure Read_GL_EXT_texture_buffer_object; +begin + glTexBufferEXT := dglGetProcAddress('glTexBufferEXT'); +end; + +procedure Read_GL_EXT_texture_integer; +begin + glClearColorIiEXT := dglGetProcAddress('glClearColorIiEXT'); + glClearColorIuiEXT := dglGetProcAddress('glClearColorIuiEXT'); + glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT'); + glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT'); + glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT'); + glGetTexParameterIiuvEXT := dglGetProcAddress('glGetTexParameterIiuvEXT'); +end; + +procedure Read_GL_EXT_transform_feedback; +begin + glBeginTransformFeedbackEXT := dglGetProcAddress('lBeginTransformFeedbackEXT'); + glEndTransformFeedbackEXT := dglGetProcAddress('glEndTransformFeedbackEXT'); + glBindBufferRangeEXT := dglGetProcAddress('glBindBufferRangeEXT'); + glBindBufferOffsetEXT := dglGetProcAddress('glBindBufferOffsetEXT'); + glBindBufferBaseEXT := dglGetProcAddress('glBindBufferBaseEXT'); + glTransformFeedbackVaryingsEXT := dglGetProcAddress('glTransformFeedbackVaryingsEXT'); + glGetTransformFeedbackVaryingEXT := dglGetProcAddress('glGetTransformFeedbackVaryingEXT'); +end; + +procedure Read_GL_EXT_direct_state_access; +begin + glClientAttribDefaultEXT := dglGetProcAddress('glClientAttribDefaultEXT'); + glPushClientAttribDefaultEXT := dglGetProcAddress('glPushClientAttribDefaultEXT'); + glMatrixLoadfEXT := dglGetProcAddress('glMatrixLoadfEXT'); + glMatrixLoaddEXT := dglGetProcAddress('glMatrixLoaddEXT'); + glMatrixMultfEXT := dglGetProcAddress('glMatrixMultfEXT'); + glMatrixMultdEXT := dglGetProcAddress('glMatrixMultdEXT'); + glMatrixLoadIdentityEXT := dglGetProcAddress('glMatrixLoadIdentityEXT'); + glMatrixRotatefEXT := dglGetProcAddress('glMatrixRotatefEXT'); + glMatrixRotatedEXT := dglGetProcAddress('glMatrixRotatedEXT'); + glMatrixScalefEXT := dglGetProcAddress('glMatrixScalefEXT'); + glMatrixScaledEXT := dglGetProcAddress('glMatrixScaledEXT'); + glMatrixTranslatefEXT := dglGetProcAddress('glMatrixTranslatefEXT'); + glMatrixTranslatedEXT := dglGetProcAddress('glMatrixTranslatedEXT'); + glMatrixFrustumEXT := dglGetProcAddress('glMatrixFrustumEXT'); + glMatrixOrthoEXT := dglGetProcAddress('glMatrixOrthoEXT'); + glMatrixPopEXT := dglGetProcAddress('glMatrixPopEXT'); + glMatrixPushEXT := dglGetProcAddress('glMatrixPushEXT'); + glMatrixLoadTransposefEXT := dglGetProcAddress('glMatrixLoadTransposefEXT'); + glMatrixLoadTransposedEXT := dglGetProcAddress('glMatrixLoadTransposedEXT'); + glMatrixMultTransposefEXT := dglGetProcAddress('glMatrixMultTransposefEXT'); + glMatrixMultTransposedEXT := dglGetProcAddress('glMatrixMultTransposedEXT'); + glTextureParameterfEXT := dglGetProcAddress('glTextureParameterfEXT'); + glTextureParameterfvEXT := dglGetProcAddress('glTextureParameterfvEXT'); + glTextureParameteriEXT := dglGetProcAddress('glTextureParameteriEXT'); + glTextureParameterivEXT := dglGetProcAddress('glTextureParameterivEXT'); + glTextureImage1DEXT := dglGetProcAddress('glTextureImage1DEXT'); + glTextureImage2DEXT := dglGetProcAddress('glTextureImage2DEXT'); + glTextureSubImage1DEXT := dglGetProcAddress('glTextureSubImage1DEXT'); + glTextureSubImage2DEXT := dglGetProcAddress('glTextureSubImage2DEXT'); + glCopyTextureImage1DEXT := dglGetProcAddress('glCopyTextureImage1DEXT'); + glCopyTextureImage2DEXT := dglGetProcAddress('glCopyTextureImage2DEXT'); + glCopyTextureSubImage1DEXT := dglGetProcAddress('glCopyTextureSubImage1DEXT'); + glCopyTextureSubImage2DEXT := dglGetProcAddress('glCopyTextureSubImage2DEXT'); + glGetTextureImageEXT := dglGetProcAddress('glGetTextureImageEXT'); + glGetTextureParameterfvEXT := dglGetProcAddress('glGetTextureParameterfvEXT'); + glGetTextureParameterivEXT := dglGetProcAddress('glGetTextureParameterivEXT'); + glGetTextureLevelParameterfvEXT := dglGetProcAddress('glGetTextureLevelParameterfvEXT'); + glGetTextureLevelParameterivEXT := dglGetProcAddress('glGetTextureLevelParameterivEXT'); + glTextureImage3DEXT := dglGetProcAddress('glTextureImage3DEXT'); + glTextureSubImage3DEXT := dglGetProcAddress('glTextureSubImage3DEXT'); + glCopyTextureSubImage3DEXT := dglGetProcAddress('glCopyTextureSubImage3DEXT'); + glMultiTexParameterfEXT := dglGetProcAddress('glMultiTexParameterfEXT'); + glMultiTexParameterfvEXT := dglGetProcAddress('glMultiTexParameterfvEXT'); + glMultiTexParameteriEXT := dglGetProcAddress('glMultiTexParameteriEXT'); + glMultiTexParameterivEXT := dglGetProcAddress('glMultiTexParameterivEXT'); + glMultiTexImage1DEXT := dglGetProcAddress('glMultiTexImage1DEXT'); + glMultiTexImage2DEXT := dglGetProcAddress('glMultiTexImage2DEXT'); + glMultiTexSubImage1DEXT := dglGetProcAddress('glMultiTexSubImage1DEXT'); + glMultiTexSubImage2DEXT := dglGetProcAddress('glMultiTexSubImage2DEXT'); + glCopyMultiTexImage1DEXT := dglGetProcAddress('glCopyMultiTexImage1DEXT'); + glCopyMultiTexImage2DEXT := dglGetProcAddress('glCopyMultiTexImage2DEXT'); + glCopyMultiTexSubImage1DEXT := dglGetProcAddress('glCopyMultiTexSubImage1DEXT'); + glCopyMultiTexSubImage2DEXT := dglGetProcAddress('glCopyMultiTexSubImage2DEXT'); + glGetMultiTexImageEXT := dglGetProcAddress('glGetMultiTexImageEXT'); + glGetMultiTexParameterfvEXT := dglGetProcAddress('glGetMultiTexParameterfvEXT'); + glGetMultiTexParameterivEXT := dglGetProcAddress('glGetMultiTexParameterivEXT'); + glGetMultiTexLevelParameterfvEXT := dglGetProcAddress('glGetMultiTexLevelParameterfvEXT'); + glGetMultiTexLevelParameterivEXT := dglGetProcAddress('glGetMultiTexLevelParameterivEXT'); + glMultiTexImage3DEXT := dglGetProcAddress('glMultiTexImage3DEXT'); + glMultiTexSubImage3DEXT := dglGetProcAddress('glMultiTexSubImage3DEXT'); + glCopyMultiTexSubImage3DEXT := dglGetProcAddress('glCopyMultiTexSubImage3DEXT'); + glBindMultiTextureEXT := dglGetProcAddress('glBindMultiTextureEXT'); + glEnableClientStateIndexedEXT := dglGetProcAddress('glEnableClientStateIndexedEXT'); + glDisableClientStateIndexedEXT := dglGetProcAddress('glDisableClientStateIndexedEXT'); + glMultiTexCoordPointerEXT := dglGetProcAddress('glMultiTexCoordPointerEXT'); + glMultiTexEnvfEXT := dglGetProcAddress('glMultiTexEnvfEXT'); + glMultiTexEnvfvEXT := dglGetProcAddress('glMultiTexEnvfvEXT'); + glMultiTexEnviEXT := dglGetProcAddress('glMultiTexEnviEXT'); + glMultiTexEnvivEXT := dglGetProcAddress('glMultiTexEnvivEXT'); + glMultiTexGendEXT := dglGetProcAddress('glMultiTexGendEXT'); + glMultiTexGendvEXT := dglGetProcAddress('glMultiTexGendvEXT'); + glMultiTexGenfEXT := dglGetProcAddress('glMultiTexGenfEXT'); + glMultiTexGenfvEXT := dglGetProcAddress('glMultiTexGenfvEXT'); + glMultiTexGeniEXT := dglGetProcAddress('glMultiTexGeniEXT'); + glMultiTexGenivEXT := dglGetProcAddress('glMultiTexGenivEXT'); + glGetMultiTexEnvfvEXT := dglGetProcAddress('glGetMultiTexEnvfvEXT'); + glGetMultiTexEnvivEXT := dglGetProcAddress('glGetMultiTexEnvivEXT'); + glGetMultiTexGendvEXT := dglGetProcAddress('glGetMultiTexGendvEXT'); + glGetMultiTexGenfvEXT := dglGetProcAddress('glGetMultiTexGenfvEXT'); + glGetMultiTexGenivEXT := dglGetProcAddress('glGetMultiTexGenivEXT'); + glGetFloatIndexedvEXT := dglGetProcAddress('glGetFloatIndexedvEXT'); + glGetDoubleIndexedvEXT := dglGetProcAddress('glGetDoubleIndexedvEXT'); + glGetPointerIndexedvEXT := dglGetProcAddress('glGetPointerIndexedvEXT'); + glCompressedTextureImage3DEXT := dglGetProcAddress('glCompressedTextureImage3DEXT'); + glCompressedTextureImage2DEXT := dglGetProcAddress('glCompressedTextureImage2DEXT'); + glCompressedTextureImage1DEXT := dglGetProcAddress('glCompressedTextureImage1DEXT'); + glCompressedTextureSubImage3DEXT := dglGetProcAddress('glCompressedTextureSubImage3DEXT'); + glCompressedTextureSubImage2DEXT := dglGetProcAddress('glCompressedTextureSubImage2DEXT'); + glCompressedTextureSubImage1DEXT := dglGetProcAddress('glCompressedTextureSubImage1DEXT'); + glGetCompressedTextureImageEXT := dglGetProcAddress('glGetCompressedTextureImageEXT'); + glCompressedMultiTexImage3DEXT := dglGetProcAddress('glCompressedMultiTexImage3DEXT'); + glCompressedMultiTexImage2DEXT := dglGetProcAddress('glCompressedMultiTexImage2DEXT'); + glCompressedMultiTexImage1DEXT := dglGetProcAddress('glCompressedMultiTexImage1DEXT'); + glCompressedMultiTexSubImage3DEXT := dglGetProcAddress('glCompressedMultiTexSubImage3DEXT'); + glCompressedMultiTexSubImage2DEXT := dglGetProcAddress('glCompressedMultiTexSubImage2DEXT'); + glCompressedMultiTexSubImage1DEXT := dglGetProcAddress('glCompressedMultiTexSubImage1DEXT'); + glGetCompressedMultiTexImageEXT := dglGetProcAddress('glGetCompressedMultiTexImageEXT'); + glNamedProgramStringEXT := dglGetProcAddress('glNamedProgramStringEXT'); + glNamedProgramLocalParameter4dEXT := dglGetProcAddress('glNamedProgramLocalParameter4dEXT'); + glNamedProgramLocalParameter4dvEXT := dglGetProcAddress('glNamedProgramLocalParameter4dvEXT'); + glNamedProgramLocalParameter4fEXT := dglGetProcAddress('glNamedProgramLocalParameter4fEXT'); + glNamedProgramLocalParameter4fvEXT := dglGetProcAddress('glNamedProgramLocalParameter4fvEXT'); + glGetNamedProgramLocalParameterdvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterdvEXT'); + glGetNamedProgramLocalParameterfvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterfvEXT'); + glGetNamedProgramivEXT := dglGetProcAddress('glGetNamedProgramivEXT'); + glGetNamedProgramStringEXT := dglGetProcAddress('glGetNamedProgramStringEXT'); + glNamedProgramLocalParameters4fvEXT := dglGetProcAddress('glNamedProgramLocalParameters4fvEXT'); + glNamedProgramLocalParameterI4iEXT := dglGetProcAddress('glNamedProgramLocalParameterI4iEXT'); + glNamedProgramLocalParameterI4ivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4ivEXT'); + glNamedProgramLocalParametersI4ivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4ivEXT'); + glNamedProgramLocalParameterI4uiEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uiEXT'); + glNamedProgramLocalParameterI4uivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uivEXT'); + glNamedProgramLocalParametersI4uivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4uivEXT'); + glGetNamedProgramLocalParameterIivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIivEXT'); + glGetNamedProgramLocalParameterIuivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIuivEXT'); + glTextureParameterIivEXT := dglGetProcAddress('glTextureParameterIivEXT'); + glTextureParameterIuivEXT := dglGetProcAddress('glTextureParameterIuivEXT'); + glGetTextureParameterIivEXT := dglGetProcAddress('glGetTextureParameterIivEXT'); + glGetTextureParameterIuivEXT := dglGetProcAddress('glGetTextureParameterIuivEXT'); + glMultiTexParameterIivEXT := dglGetProcAddress('glMultiTexParameterIivEXT'); + glMultiTexParameterIuivEXT := dglGetProcAddress('glMultiTexParameterIuivEXT'); + glGetMultiTexParameterIivEXT := dglGetProcAddress('glGetMultiTexParameterIivEXT'); + glGetMultiTexParameterIuivEXT := dglGetProcAddress('glGetMultiTexParameterIuivEXT'); + glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT'); + glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT'); + glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT'); + glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT'); + glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT'); + glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT'); + glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT'); + glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT'); + glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT'); + glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT'); + glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT'); + glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT'); + glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT'); + glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT'); + glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT'); + glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT'); + glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT'); + glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT'); + glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT'); + glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT'); + glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT'); + glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT'); + glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT'); + glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT'); + glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT'); + glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT'); + glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT'); + glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT'); + glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT'); + glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT'); + glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT'); + glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT'); + glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT'); + glNamedBufferDataEXT := dglGetProcAddress('glNamedBufferDataEXT'); + glNamedBufferSubDataEXT := dglGetProcAddress('glNamedBufferSubDataEXT'); + glMapNamedBufferEXT := dglGetProcAddress('glMapNamedBufferEXT'); + glUnmapNamedBufferEXT := dglGetProcAddress('glUnmapNamedBufferEXT'); + glMapNamedBufferRangeEXT := dglGetProcAddress('glMapNamedBufferRangeEXT'); + glFlushMappedNamedBufferRangeEXT := dglGetProcAddress('glFlushMappedNamedBufferRangeEXT'); + glNamedCopyBufferSubDataEXT := dglGetProcAddress('glNamedCopyBufferSubDataEXT'); + glGetNamedBufferParameterivEXT := dglGetProcAddress('glGetNamedBufferParameterivEXT'); + glGetNamedBufferPointervEXT := dglGetProcAddress('glGetNamedBufferPointervEXT'); + glGetNamedBufferSubDataEXT := dglGetProcAddress('glGetNamedBufferSubDataEXT'); + glTextureBufferEXT := dglGetProcAddress('glTextureBufferEXT'); + glMultiTexBufferEXT := dglGetProcAddress('glMultiTexBufferEXT'); + glNamedRenderbufferStorageEXT := dglGetProcAddress('glNamedRenderbufferStorageEXT'); + glGetNamedRenderbufferParameterivEXT := dglGetProcAddress('glGetNamedRenderbufferParameterivEXT'); + glCheckNamedFramebufferStatusEXT := dglGetProcAddress('glCheckNamedFramebufferStatusEXT'); + glNamedFramebufferTexture1DEXT := dglGetProcAddress('glNamedFramebufferTexture1DEXT'); + glNamedFramebufferTexture2DEXT := dglGetProcAddress('glNamedFramebufferTexture2DEXT'); + glNamedFramebufferTexture3DEXT := dglGetProcAddress('glNamedFramebufferTexture3DEXT'); + glNamedFramebufferRenderbufferEXT := dglGetProcAddress('glNamedFramebufferRenderbufferEXT'); + glGetNamedFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetNamedFramebufferAttachmentParameterivEXT'); + glGenerateTextureMipmapEXT := dglGetProcAddress('glGenerateTextureMipmapEXT'); + glGenerateMultiTexMipmapEXT := dglGetProcAddress('glGenerateMultiTexMipmapEXT'); + glFramebufferDrawBufferEXT := dglGetProcAddress('glFramebufferDrawBufferEXT'); + glFramebufferDrawBuffersEXT := dglGetProcAddress('glFramebufferDrawBuffersEXT'); + glFramebufferReadBufferEXT := dglGetProcAddress('glFramebufferReadBufferEXT'); + glGetFramebufferParameterivEXT := dglGetProcAddress('glGetFramebufferParameterivEXT'); + glNamedRenderbufferStorageMultisampleEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleEXT'); + glNamedRenderbufferStorageMultisampleCoverageEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleCoverageEXT'); + glNamedFramebufferTextureEXT := dglGetProcAddress('glNamedFramebufferTextureEXT'); + glNamedFramebufferTextureLayerEXT := dglGetProcAddress('glNamedFramebufferTextureLayerEXT'); + glNamedFramebufferTextureFaceEXT := dglGetProcAddress('glNamedFramebufferTextureFaceEXT'); + glTextureRenderbufferEXT := dglGetProcAddress('glTextureRenderbufferEXT'); + glMultiTexRenderbufferEXT := dglGetProcAddress('glMultiTexRenderbufferEXT'); + glProgramUniform1dEXT := dglGetProcAddress('glProgramUniform1dEXT'); + glProgramUniform2dEXT := dglGetProcAddress('glProgramUniform2dEXT'); + glProgramUniform3dEXT := dglGetProcAddress('glProgramUniform3dEXT'); + glProgramUniform4dEXT := dglGetProcAddress('glProgramUniform4dEXT'); + glProgramUniform1dvEXT := dglGetProcAddress('glProgramUniform1dvEXT'); + glProgramUniform2dvEXT := dglGetProcAddress('glProgramUniform2dvEXT'); + glProgramUniform3dvEXT := dglGetProcAddress('glProgramUniform3dvEXT'); + glProgramUniform4dvEXT := dglGetProcAddress('glProgramUniform4dvEXT'); + glProgramUniformMatrix2dvEXT := dglGetProcAddress('glProgramUniformMatrix2dvEXT'); + glProgramUniformMatrix3dvEXT := dglGetProcAddress('glProgramUniformMatrix3dvEXT'); + glProgramUniformMatrix4dvEXT := dglGetProcAddress('glProgramUniformMatrix4dvEXT'); + glProgramUniformMatrix2x3dvEXT := dglGetProcAddress('glProgramUniformMatrix2x3dvEXT'); + glProgramUniformMatrix2x4dvEXT := dglGetProcAddress('glProgramUniformMatrix2x4dvEXT'); + glProgramUniformMatrix3x2dvEXT := dglGetProcAddress('glProgramUniformMatrix3x2dvEXT'); + glProgramUniformMatrix3x4dvEXT := dglGetProcAddress('glProgramUniformMatrix3x4dvEXT'); + glProgramUniformMatrix4x2dvEXT := dglGetProcAddress('glProgramUniformMatrix4x2dvEXT'); + glProgramUniformMatrix4x3dvEXT := dglGetProcAddress('glProgramUniformMatrix4x3dvEXT'); +end; + +procedure Read_GL_EXT_separate_shader_objects; +begin + glUseShaderProgramEXT := dglGetProcAddress('glUseShaderProgramEXT'); + glActiveProgramEXT := dglGetProcAddress('glActiveProgramEXT'); + glCreateShaderProgramEXT := dglGetProcAddress('glCreateShaderProgramEXT'); +end; + +procedure Read_GL_EXT_shader_image_load_store; +begin + glBindImageTextureEXT := dglGetProcAddress('glBindImageTextureEXT'); + glMemoryBarrierEXT := dglGetProcAddress('glMemoryBarrierEXT'); +end; + +procedure Read_GL_EXT_vertex_attrib_64bit; +begin + glVertexAttribL1dEXT := dglGetProcAddress('glVertexAttribL1dEXT'); + glVertexAttribL2dEXT := dglGetProcAddress('glVertexAttribL2dEXT'); + glVertexAttribL3dEXT := dglGetProcAddress('glVertexAttribL3dEXT'); + glVertexAttribL4dEXT := dglGetProcAddress('glVertexAttribL4dEXT'); + glVertexAttribL1dvEXT := dglGetProcAddress('glVertexAttribL1dvEXT'); + glVertexAttribL2dvEXT := dglGetProcAddress('glVertexAttribL2dvEXT'); + glVertexAttribL3dvEXT := dglGetProcAddress('glVertexAttribL3dvEXT'); + glVertexAttribL4dvEXT := dglGetProcAddress('glVertexAttribL4dvEXT'); + glVertexAttribLPointerEXT := dglGetProcAddress('glVertexAttribLPointerEXT'); + glGetVertexAttribLdvEXT := dglGetProcAddress('glGetVertexAttribLdvEXT'); + glVertexArrayVertexAttribLOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribLOffsetEXT'); +end; + +procedure Read_GL_HP_image_transform; +begin + glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP'); + glImageTransformParameterfHP := dglGetProcAddress('glImageTransformParameterfHP'); + glImageTransformParameterivHP := dglGetProcAddress('glImageTransformParameterivHP'); + glImageTransformParameterfvHP := dglGetProcAddress('glImageTransformParameterfvHP'); + glGetImageTransformParameterivHP := dglGetProcAddress('glGetImageTransformParameterivHP'); + glGetImageTransformParameterfvHP := dglGetProcAddress('glGetImageTransformParameterfvHP'); +end; + +procedure Read_GL_IBM_multimode_draw_arrays; +begin + glMultiModeDrawArraysIBM := dglGetProcAddress('glMultiModeDrawArraysIBM'); + glMultiModeDrawElementsIBM := dglGetProcAddress('glMultiModeDrawElementsIBM'); +end; + +procedure Read_GL_IBM_vertex_array_lists; +begin + glColorPointerListIBM := dglGetProcAddress('glColorPointerListIBM'); + glSecondaryColorPointerListIBM := dglGetProcAddress('glSecondaryColorPointerListIBM'); + glEdgeFlagPointerListIBM := dglGetProcAddress('glEdgeFlagPointerListIBM'); + glFogCoordPointerListIBM := dglGetProcAddress('glFogCoordPointerListIBM'); + glIndexPointerListIBM := dglGetProcAddress('glIndexPointerListIBM'); + glNormalPointerListIBM := dglGetProcAddress('glNormalPointerListIBM'); + glTexCoordPointerListIBM := dglGetProcAddress('glTexCoordPointerListIBM'); + glVertexPointerListIBM := dglGetProcAddress('glVertexPointerListIBM'); +end; + +procedure Read_GL_INGR_blend_func_separate; +begin + glBlendFuncSeparateINGR := dglGetProcAddress('glBlendFuncSeparateINGR'); +end; + +procedure Read_GL_INTEL_parallel_arrays; +begin + glVertexPointervINTEL := dglGetProcAddress('glVertexPointervINTEL'); + glNormalPointervINTEL := dglGetProcAddress('glNormalPointervINTEL'); + glColorPointervINTEL := dglGetProcAddress('glColorPointervINTEL'); + glTexCoordPointervINTEL := dglGetProcAddress('glTexCoordPointervINTEL'); +end; + +procedure Read_GL_MESA_resize_buffers; +begin + glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA'); +end; + +procedure Read_GL_MESA_window_pos; +begin + glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA'); + glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA'); + glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA'); + glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA'); + glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA'); + glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA'); + glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA'); + glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA'); + glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA'); + glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA'); + glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA'); + glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA'); + glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA'); + glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA'); + glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA'); + glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA'); + glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA'); + glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA'); + glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA'); + glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA'); + glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA'); + glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA'); + glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA'); + glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA'); +end; + +procedure Read_GL_NV_evaluators; +begin + glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV'); + glMapParameterivNV := dglGetProcAddress('glMapParameterivNV'); + glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV'); + glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV'); + glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV'); + glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV'); + glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV'); + glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV'); + glEvalMapsNV := dglGetProcAddress('glEvalMapsNV'); +end; + +procedure Read_GL_NV_fence; +begin + glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV'); + glGenFencesNV := dglGetProcAddress('glGenFencesNV'); + glIsFenceNV := dglGetProcAddress('glIsFenceNV'); + glTestFenceNV := dglGetProcAddress('glTestFenceNV'); + glGetFenceivNV := dglGetProcAddress('glGetFenceivNV'); + glFinishFenceNV := dglGetProcAddress('glFinishFenceNV'); + glSetFenceNV := dglGetProcAddress('glSetFenceNV'); +end; + +procedure Read_GL_NV_fragment_program; +begin + glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV'); + glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV'); + glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV'); + glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV'); + glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV'); + glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV'); +end; + +procedure Read_GL_NV_half_float; +begin + glVertex2hNV := dglGetProcAddress('glVertex2hNV'); + glVertex2hvNV := dglGetProcAddress('glVertex2hvNV'); + glVertex3hNV := dglGetProcAddress('glVertex3hNV'); + glVertex3hvNV := dglGetProcAddress('glVertex3hvNV'); + glVertex4hNV := dglGetProcAddress('glVertex4hNV'); + glVertex4hvNV := dglGetProcAddress('glVertex4hvNV'); + glNormal3hNV := dglGetProcAddress('glNormal3hNV'); + glNormal3hvNV := dglGetProcAddress('glNormal3hvNV'); + glColor3hNV := dglGetProcAddress('glColor3hNV'); + glColor3hvNV := dglGetProcAddress('glColor3hvNV'); + glColor4hNV := dglGetProcAddress('glColor4hNV'); + glColor4hvNV := dglGetProcAddress('glColor4hvNV'); + glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV'); + glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV'); + glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV'); + glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV'); + glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV'); + glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV'); + glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV'); + glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV'); + glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV'); + glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV'); + glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV'); + glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV'); + glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV'); + glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV'); + glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV'); + glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV'); + glFogCoordhNV := dglGetProcAddress('glFogCoordhNV'); + glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV'); + glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV'); + glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV'); + glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV'); + glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV'); + glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV'); + glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV'); + glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV'); + glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV'); + glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV'); + glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV'); + glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV'); + glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV'); + glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV'); + glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV'); + glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV'); + glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV'); +end; + +procedure Read_GL_NV_occlusion_query; +begin + glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV'); + glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV'); + glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV'); + glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV'); + glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV'); + glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV'); + glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV'); +end; + +procedure Read_GL_NV_pixel_data_range; +begin + glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV'); + glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV'); +end; + +procedure Read_GL_NV_point_sprite; +begin + glPointParameteriNV := dglGetProcAddress('glPointParameteriNV'); + glPointParameterivNV := dglGetProcAddress('glPointParameterivNV'); +end; + +procedure Read_GL_NV_primitive_restart; +begin + glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV'); + glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV'); +end; + +procedure Read_GL_NV_register_combiners; +begin + glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV'); + glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV'); + glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV'); + glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV'); + glCombinerInputNV := dglGetProcAddress('glCombinerInputNV'); + glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV'); + glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV'); + glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV'); + glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV'); + glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV'); + glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV'); + glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV'); + glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV'); +end; + +procedure Read_GL_NV_register_combiners2; +begin + glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV'); + glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV'); +end; + +procedure Read_GL_NV_vertex_array_range; +begin + glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV'); + glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV'); +end; + +procedure Read_GL_NV_vertex_program; +begin + glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV'); + glBindProgramNV := dglGetProcAddress('glBindProgramNV'); + glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV'); + glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV'); + glGenProgramsNV := dglGetProcAddress('glGenProgramsNV'); + glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV'); + glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV'); + glGetProgramivNV := dglGetProcAddress('glGetProgramivNV'); + glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV'); + glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV'); + glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV'); + glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV'); + glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV'); + glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV'); + glIsProgramNV := dglGetProcAddress('glIsProgramNV'); + glLoadProgramNV := dglGetProcAddress('glLoadProgramNV'); + glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV'); + glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV'); + glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV'); + glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV'); + glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV'); + glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV'); + glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV'); + glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV'); + glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV'); + glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV'); + glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV'); + glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV'); + glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV'); + glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV'); + glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV'); + glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV'); + glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV'); + glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV'); + glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV'); + glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV'); + glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV'); + glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV'); + glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV'); + glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV'); + glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV'); + glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV'); + glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV'); + glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV'); + glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV'); + glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV'); + glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV'); + glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV'); + glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV'); + glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV'); + glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV'); + glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV'); + glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV'); + glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV'); + glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV'); + glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV'); + glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV'); + glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV'); + glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV'); + glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV'); + glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV'); + glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV'); + glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV'); + glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV'); +end; + +procedure Read_GL_NV_depth_buffer_float; +begin + glDepthRangedNV := dglGetProcAddress('glDepthRangedNV'); + glClearDepthdNV := dglGetProcAddress('glClearDepthdNV'); + glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV'); +end; + +procedure Read_GL_NV_framebuffer_multisample_coverage; +begin + glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV'); +end; + +procedure Read_GL_NV_geometry_program4; +begin + glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV'); +end; + +procedure Read_GL_NV_gpu_program4; +begin + glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV'); + glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV'); + glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV'); + glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV'); + glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV'); + glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV'); + glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV'); + glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV'); + glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV'); + glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV'); + glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV'); + glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV'); + glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV'); + glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV'); + glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV'); + glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV'); +end; + +procedure Read_GL_NV_parameter_buffer_object; +begin + glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV'); + glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV'); + glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV'); +end; + +procedure Read_GL_NV_transform_feedback; +begin + glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV'); + glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV'); + glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV'); + glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV'); + glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV'); + glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV'); + glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV'); + glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV'); + glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV'); + glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV'); + glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV'); + glTransformFeedbackStreamAttribsNV := dglGetProcAddress('glTransformFeedbackStreamAttribsNV'); +end; + +procedure Read_GL_NV_conditional_render; +begin + glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV'); + glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV'); +end; + +procedure Read_GL_NV_present_video; +begin + glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV'); + glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV'); + glGetVideoivNV := dglGetProcAddress('glGetVideoivNV'); + glGetVideouivNV := dglGetProcAddress('glGetVideouivNV'); + glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV'); + glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV'); +// glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV'); +end; + +procedure Read_GL_NV_explicit_multisample; +begin + glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV'); + glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV'); + glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV'); +end; + +procedure Read_GL_NV_transform_feedback2; +begin + glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV'); + glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV'); + glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV'); + glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV'); + glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV'); + glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV'); + glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV'); +end; + +procedure Read_GL_NV_video_capture; +begin + glBeginVideoCaptureNV := dglGetProcAddress('glBeginVideoCaptureNV'); + glBindVideoCaptureStreamBufferNV := dglGetProcAddress('glBindVideoCaptureStreamBufferNV'); + glBindVideoCaptureStreamTextureNV := dglGetProcAddress('glBindVideoCaptureStreamTextureNV'); + glEndVideoCaptureNV := dglGetProcAddress('glEndVideoCaptureNV'); + glGetVideoCaptureivNV := dglGetProcAddress('glGetVideoCaptureivNV'); + glGetVideoCaptureStreamivNV := dglGetProcAddress('glGetVideoCaptureStreamivNV'); + glGetVideoCaptureStreamfvNV := dglGetProcAddress('glGetVideoCaptureStreamfvNV'); + glGetVideoCaptureStreamdvNV := dglGetProcAddress('glGetVideoCaptureStreamdvNV'); + glVideoCaptureNV := dglGetProcAddress('glVideoCaptureNV'); + glVideoCaptureStreamParameterivNV := dglGetProcAddress('glVideoCaptureStreamParameterivNV'); + glVideoCaptureStreamParameterfvNV := dglGetProcAddress('glVideoCaptureStreamParameterfvNV'); + glVideoCaptureStreamParameterdvNV := dglGetProcAddress('glVideoCaptureStreamParameterdvNV'); +end; + +procedure Read_GL_NV_copy_image; +begin + glCopyImageSubDataNV := dglGetProcAddress('glCopyImageSubDataNV'); +end; + +procedure Read_GL_NV_shader_buffer_load; +begin + glMakeBufferResidentNV := dglGetProcAddress('glMakeBufferResidentNV'); + glMakeBufferNonResidentNV := dglGetProcAddress('glMakeBufferNonResidentNV'); + glIsBufferResidentNV := dglGetProcAddress('glIsBufferResidentNV'); + glMakeNamedBufferResidentNV := dglGetProcAddress('glMakeNamedBufferResidentNV'); + glMakeNamedBufferNonResidentNV := dglGetProcAddress('glMakeNamedBufferNonResidentNV'); + glIsNamedBufferResidentNV := dglGetProcAddress('glIsNamedBufferResidentNV'); + glGetBufferParameterui64vNV := dglGetProcAddress('glGetBufferParameterui64vNV'); + glGetNamedBufferParameterui64vNV := dglGetProcAddress('glGetNamedBufferParameterui64vNV'); + glGetIntegerui64vNV := dglGetProcAddress('glGetIntegerui64vNV'); + glUniformui64NV := dglGetProcAddress('glUniformui64NV'); + glUniformui64vNV := dglGetProcAddress('glUniformui64vNV'); + glGetUniformui64vNV := dglGetProcAddress('glGetUniformui64vNV'); + glProgramUniformui64NV := dglGetProcAddress('glProgramUniformui64NV'); + glProgramUniformui64vNV := dglGetProcAddress('glProgramUniformui64vNV'); +end; + +procedure Read_GL_NV_vertex_buffer_unified_memory; +begin + glBufferAddressRangeNV := dglGetProcAddress('glBufferAddressRangeNV'); + glVertexFormatNV := dglGetProcAddress('glVertexFormatNV'); + glNormalFormatNV := dglGetProcAddress('glNormalFormatNV'); + glColorFormatNV := dglGetProcAddress('glColorFormatNV'); + glIndexFormatNV := dglGetProcAddress('glIndexFormatNV'); + glTexCoordFormatNV := dglGetProcAddress('glTexCoordFormatNV'); + glEdgeFlagFormatNV := dglGetProcAddress('glEdgeFlagFormatNV'); + glSecondaryColorFormatNV := dglGetProcAddress('glSecondaryColorFormatNV'); + glFogCoordFormatNV := dglGetProcAddress('glFogCoordFormatNV'); + glVertexAttribFormatNV := dglGetProcAddress('glVertexAttribFormatNV'); + glVertexAttribIFormatNV := dglGetProcAddress('glVertexAttribIFormatNV'); + glGetIntegerui64i_vNV := dglGetProcAddress('glGetIntegerui64i_vNV'); +end; + +procedure Read_GL_NV_gpu_program5; +begin + glProgramSubroutineParametersuivNV := dglGetProcAddress('glProgramSubroutineParametersuivNV'); + glGetProgramSubroutineParameteruivNV := dglGetProcAddress('glGetProgramSubroutineParameteruivNV'); +end; + +procedure Read_GL_NV_gpu_shader5; +begin + glUniform1i64NV := dglGetProcAddress('glUniform1i64NV'); + glUniform2i64NV := dglGetProcAddress('glUniform2i64NV'); + glUniform3i64NV := dglGetProcAddress('glUniform3i64NV'); + glUniform4i64NV := dglGetProcAddress('glUniform4i64NV'); + glUniform1i64vNV := dglGetProcAddress('glUniform1i64vNV'); + glUniform2i64vNV := dglGetProcAddress('glUniform2i64vNV'); + glUniform3i64vNV := dglGetProcAddress('glUniform3i64vNV'); + glUniform4i64vNV := dglGetProcAddress('glUniform4i64vNV'); + glUniform1ui64NV := dglGetProcAddress('glUniform1ui64NV'); + glUniform2ui64NV := dglGetProcAddress('glUniform2ui64NV'); + glUniform3ui64NV := dglGetProcAddress('glUniform3ui64NV'); + glUniform4ui64NV := dglGetProcAddress('glUniform4ui64NV'); + glUniform1ui64vNV := dglGetProcAddress('glUniform1ui64vNV'); + glUniform2ui64vNV := dglGetProcAddress('glUniform2ui64vNV'); + glUniform3ui64vNV := dglGetProcAddress('glUniform3ui64vNV'); + glUniform4ui64vNV := dglGetProcAddress('glUniform4ui64vNV'); + glGetUniformi64vNV := dglGetProcAddress('glGetUniformi64vNV'); + glProgramUniform1i64NV := dglGetProcAddress('glProgramUniform1i64NV'); + glProgramUniform2i64NV := dglGetProcAddress('glProgramUniform2i64NV'); + glProgramUniform3i64NV := dglGetProcAddress('glProgramUniform3i64NV'); + glProgramUniform4i64NV := dglGetProcAddress('glProgramUniform4i64NV'); + glProgramUniform1i64vNV := dglGetProcAddress('glProgramUniform1i64vNV'); + glProgramUniform2i64vNV := dglGetProcAddress('glProgramUniform2i64vNV'); + glProgramUniform3i64vNV := dglGetProcAddress('glProgramUniform3i64vNV'); + glProgramUniform4i64vNV := dglGetProcAddress('glProgramUniform4i64vNV'); + glProgramUniform1ui64NV := dglGetProcAddress('glProgramUniform1ui64NV'); + glProgramUniform2ui64NV := dglGetProcAddress('glProgramUniform2ui64NV'); + glProgramUniform3ui64NV := dglGetProcAddress('glProgramUniform3ui64NV'); + glProgramUniform4ui64NV := dglGetProcAddress('glProgramUniform4ui64NV'); + glProgramUniform1ui64vNV := dglGetProcAddress('glProgramUniform1ui64vNV'); + glProgramUniform2ui64vNV := dglGetProcAddress('glProgramUniform2ui64vNV'); + glProgramUniform3ui64vNV := dglGetProcAddress('glProgramUniform3ui64vNV'); + glProgramUniform4ui64vNV := dglGetProcAddress('glProgramUniform4ui64vNV'); +end; + +procedure Read_GL_NV_vertex_attrib_integer_64bit; +begin + glVertexAttribL1i64NV := dglGetProcAddress('glVertexAttribL1i64NV'); + glVertexAttribL2i64NV := dglGetProcAddress('glVertexAttribL2i64NV'); + glVertexAttribL3i64NV := dglGetProcAddress('glVertexAttribL3i64NV'); + glVertexAttribL4i64NV := dglGetProcAddress('glVertexAttribL4i64NV'); + glVertexAttribL1i64vNV := dglGetProcAddress('glVertexAttribL1i64vNV'); + glVertexAttribL2i64vNV := dglGetProcAddress('glVertexAttribL2i64vNV'); + glVertexAttribL3i64vNV := dglGetProcAddress('glVertexAttribL3i64vNV'); + glVertexAttribL4i64vNV := dglGetProcAddress('glVertexAttribL4i64vNV'); + glVertexAttribL1ui64NV := dglGetProcAddress('glVertexAttribL1ui64NV'); + glVertexAttribL2ui64NV := dglGetProcAddress('glVertexAttribL2ui64NV'); + glVertexAttribL3ui64NV := dglGetProcAddress('glVertexAttribL3ui64NV'); + glVertexAttribL4ui64NV := dglGetProcAddress('glVertexAttribL4ui64NV'); + glVertexAttribL1ui64vNV := dglGetProcAddress('glVertexAttribL1ui64vNV'); + glVertexAttribL2ui64vNV := dglGetProcAddress('glVertexAttribL2ui64vNV'); + glVertexAttribL3ui64vNV := dglGetProcAddress('glVertexAttribL3ui64vNV'); + glVertexAttribL4ui64vNV := dglGetProcAddress('glVertexAttribL4ui64vNV'); + glGetVertexAttribLi64vNV := dglGetProcAddress('glGetVertexAttribLi64vNV'); + glGetVertexAttribLui64vNV := dglGetProcAddress('glGetVertexAttribLui64vNV'); + glVertexAttribLFormatNV := dglGetProcAddress('glVertexAttribLFormatNV'); +end; + +procedure Read_GL_NV_vdpau_interop; +begin + glVDPAUInitNV := dglGetProcAddress('glVDPAUInitNV'); + glVDPAUFiniNV := dglGetProcAddress('glVDPAUFiniNV'); + glVDPAURegisterVideoSurfaceNV := dglGetProcAddress('glVDPAURegisterVideoSurfaceNV'); + glVDPAURegisterOutputSurfaceNV := dglGetProcAddress('glVDPAURegisterOutputSurfaceNV'); + glVDPAUIsSurfaceNV := dglGetProcAddress('glVDPAUIsSurfaceNV'); + glVDPAUUnregisterSurfaceNV := dglGetProcAddress('glVDPAUUnregisterSurfaceNV'); + glVDPAUGetSurfaceivNV := dglGetProcAddress('glVDPAUGetSurfaceivNV'); + glVDPAUSurfaceAccessNV := dglGetProcAddress('glVDPAUSurfaceAccessNV'); + glVDPAUMapSurfacesNV := dglGetProcAddress('glVDPAUMapSurfacesNV'); + glVDPAUUnmapSurfacesNV := dglGetProcAddress('glVDPAUUnmapSurfacesNV'); +end; + +procedure Read_GL_NV_texture_barrier; +begin + glTextureBarrierNV := dglGetProcAddress('glTextureBarrierNV'); +end; + +procedure Read_GL_PGI_misc_hints; +begin + glHintPGI := dglGetProcAddress('glHintPGI'); +end; + +procedure Read_GL_SGIS_detail_texture; +begin + glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS'); + glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS'); +end; + +procedure Read_GL_SGIS_fog_function; +begin + glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS'); + glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS'); +end; + +procedure Read_GL_SGIS_multisample; +begin + glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS'); + glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS'); +end; + +procedure Read_GL_SGIS_pixel_texture; +begin + glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS'); + glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS'); + glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS'); + glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS'); + glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS'); + glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS'); +end; + +procedure Read_GL_SGIS_point_parameters; +begin + glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS'); + glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS'); +end; + +procedure Read_GL_SGIS_sharpen_texture; +begin + glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS'); + glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS'); +end; + +procedure Read_GL_SGIS_texture4D; +begin + glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS'); + glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS'); +end; + +procedure Read_GL_SGIS_texture_color_mask; +begin + glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS'); +end; + +procedure Read_GL_SGIS_texture_filter4; +begin + glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS'); + glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS'); +end; + +procedure Read_GL_SGIX_async; +begin + glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX'); + glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX'); + glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX'); + glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX'); + glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX'); + glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX'); +end; + +procedure Read_GL_SGIX_flush_raster; +begin + glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX'); +end; + +procedure Read_GL_SGIX_fragment_lighting; +begin + glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX'); + glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX'); + glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX'); + glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX'); + glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX'); + glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX'); + glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX'); + glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX'); + glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX'); + glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX'); + glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX'); + glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX'); + glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX'); + glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX'); + glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX'); + glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX'); + glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX'); + glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX'); +end; + +procedure Read_GL_SGIX_framezoom; +begin + glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX'); +end; + +procedure Read_GL_SGIX_igloo_interface; +begin + glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX'); +end; + +procedure Read_GL_SGIX_instruments; +begin + glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX'); + glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX'); + glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX'); + glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX'); + glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX'); + glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX'); +end; + +procedure Read_GL_SGIX_list_priority; +begin + glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX'); + glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX'); + glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX'); + glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX'); + glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX'); + glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX'); +end; + +procedure Read_GL_SGIX_pixel_texture; +begin + glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX'); +end; + +procedure Read_GL_SGIX_polynomial_ffd; +begin + glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX'); + glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX'); + glDeformSGIX := dglGetProcAddress('glDeformSGIX'); + glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX'); +end; + +procedure Read_GL_SGIX_reference_plane; +begin + glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX'); +end; + +procedure Read_GL_SGIX_sprite; +begin + glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX'); + glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX'); + glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX'); + glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX'); +end; + +procedure Read_GL_SGIX_tag_sample_buffer; +begin + glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX'); +end; + +procedure Read_GL_SGI_color_table; +begin + glColorTableSGI := dglGetProcAddress('glColorTableSGI'); + glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI'); + glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI'); + glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI'); + glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI'); + glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI'); + glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI'); +end; + +procedure Read_GL_SUNX_constant_data; +begin + glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX'); +end; + +procedure Read_GL_SUN_global_alpha; +begin + glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN'); + glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN'); + glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN'); + glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN'); + glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN'); + glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN'); + glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN'); + glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN'); +end; + +procedure Read_GL_SUN_mesh_array; +begin + glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN'); +end; + +procedure Read_GL_SUN_triangle_list; +begin + glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN'); + glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN'); + glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN'); + glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN'); + glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN'); + glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN'); + glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN'); +end; + +procedure Read_GL_SUN_vertex; +begin + glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN'); + glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN'); + glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN'); + glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN'); + glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN'); + glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN'); + glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN'); + glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN'); + glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN'); + glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN'); + glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN'); + glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN'); + glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN'); + glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN'); + glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN'); + glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN'); + glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN'); + glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN'); + glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN'); + glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN'); + glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN'); + glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN'); + glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN'); + glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN'); + glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN'); + glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN'); + glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN'); + glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN'); + glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN'); + glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN'); + glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN'); + glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN'); + glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN'); + glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN'); + glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN'); + glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN'); + glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN'); + glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN'); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN'); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN'); +end; + +{$IFDEF DGL_WIN} +procedure Read_WGL_ARB_buffer_region; +begin + wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB'); + wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB'); + wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB'); + wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB'); +end; + +procedure Read_WGL_ARB_extensions_string; +begin + wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB'); +end; + +procedure Read_WGL_ARB_make_current_read; +begin + wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB'); + wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB'); +end; + +procedure Read_WGL_ARB_pbuffer; +begin + wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB'); + wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB'); + wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB'); + wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB'); + wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB'); +end; + +procedure Read_WGL_ARB_pixel_format; +begin + wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB'); + wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB'); + wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB'); +end; + +procedure Read_WGL_ARB_pixel_format_float; +begin + wglClampColorARB := dglGetProcAddress('wglClampColorARB'); +end; + +procedure Read_WGL_ARB_render_texture; +begin + wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB'); + wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB'); + wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB'); +end; + +procedure Read_WGL_ARB_create_context; +begin + wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB'); +end; + +procedure Read_WGL_AMD_gpu_association; +begin + wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD'); + wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD'); + wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD'); + wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD'); + wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD'); + wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD'); + wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD'); + wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD'); + wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD'); +end; + +procedure Read_WGL_EXT_display_color_table; +begin + wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT'); + wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT'); + wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT'); + wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT'); +end; + +procedure Read_WGL_EXT_extensions_string; +begin + wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT'); +end; + +procedure Read_WGL_EXT_make_current_read; +begin + wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT'); + wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT'); +end; + +procedure Read_WGL_EXT_pbuffer; +begin + wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT'); + wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT'); + wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT'); + wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT'); + wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT'); +end; + +procedure Read_WGL_EXT_pixel_format; +begin + wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT'); + wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT'); + wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT'); +end; + +procedure Read_WGL_EXT_swap_control; +begin + wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT'); + wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT'); +end; + +procedure Read_WGL_I3D_digital_video_control; +begin + wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D'); + wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D'); +end; + +procedure Read_WGL_I3D_gamma; +begin + wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D'); + wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D'); + wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D'); + wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D'); +end; + +procedure Read_WGL_I3D_genlock; +begin + wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D'); + wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D'); + wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D'); + wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D'); + wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D'); + wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D'); + wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D'); + wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D'); + wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D'); + wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D'); + wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D'); + wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D'); +end; + +procedure Read_WGL_I3D_image_buffer; +begin + wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D'); + wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D'); + wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D'); + wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D'); +end; + +procedure Read_WGL_I3D_swap_frame_lock; +begin + wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D'); + wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D'); + wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D'); + wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D'); +end; + +procedure Read_WGL_I3D_swap_frame_usage; +begin + wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D'); + wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D'); + wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D'); + wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D'); +end; + +procedure Read_WGL_NV_vertex_array_range; +begin + wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV'); + wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV'); +end; + +procedure Read_WGL_NV_present_video; +begin + wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV'); + wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV'); + wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV'); +end; + +procedure Read_WGL_NV_video_output; +begin + wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV'); + wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV'); + wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV'); + wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV'); + wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV'); + wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV'); +end; + +procedure Read_WGL_NV_swap_group; +begin + wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV'); + wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV'); + wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV'); + wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV'); + wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV'); + wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV'); +end; + +procedure Read_WGL_NV_gpu_affinity; +begin + wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV'); + wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV'); + wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV'); + wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV'); + wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV'); +end; + +procedure Read_WGL_NV_video_capture; +begin + wglBindVideoCaptureDeviceNV := dglGetProcAddress('wglBindVideoCaptureDeviceNV'); + wglEnumerateVideoCaptureDevicesNV := dglGetProcAddress('wglEnumerateVideoCaptureDevicesNV'); + wglLockVideoCaptureDeviceNV := dglGetProcAddress('wglLockVideoCaptureDeviceNV'); + wglQueryVideoCaptureDeviceNV := dglGetProcAddress('wglQueryVideoCaptureDeviceNV'); + wglReleaseVideoCaptureDeviceNV := dglGetProcAddress('wglReleaseVideoCaptureDeviceNV'); +end; + +procedure Read_WGL_NV_copy_image; +begin + wglCopyImageSubDataNV := dglGetProcAddress('wglCopyImageSubDataNV'); +end; + +procedure Read_WGL_NV_DX_interop; +begin + wglDXSetResourceShareHandleNV := dglGetProcAddress('wglDXSetResourceShareHandleNV'); + wglDXOpenDeviceNV := dglGetProcAddress('wglDXOpenDeviceNV'); + wglDXCloseDeviceNV := dglGetProcAddress('wglDXCloseDeviceNV'); + wglDXRegisterObjectNV := dglGetProcAddress('wglDXRegisterObjectNV'); + wglDXUnregisterObjectNV := dglGetProcAddress('wglDXUnregisterObjectNV'); + wglDXObjectAccessNV := dglGetProcAddress('wglDXObjectAccessNV'); + wglDXLockObjectsNV := dglGetProcAddress('wglDXLockObjectsNV'); + wglDXUnlockObjectsNV := dglGetProcAddress('wglDXUnlockObjectsNV'); +end; + + +procedure Read_WGL_OML_sync_control; +begin + wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML'); + wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML'); + wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML'); + wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML'); + wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML'); + wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML'); +end; + +procedure Read_WGL_3DL_stereo_control; +begin + wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL'); +end; + +procedure Read_WIN_draw_range_elements; +begin + glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN'); +end; + +procedure Read_WIN_swap_hint; +begin + glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN'); +end; +{$ENDIF} + + +procedure ReadExtensions; +begin + ReadOpenGLCore; + + Read_GL_3DFX_tbuffer; + Read_GL_APPLE_element_array; + Read_GL_APPLE_fence; + Read_GL_APPLE_vertex_array_object; + Read_GL_APPLE_vertex_array_range; + Read_GL_APPLE_texture_range; + Read_GL_APPLE_vertex_program_evaluators; + Read_GL_APPLE_object_purgeable; + Read_GL_ARB_matrix_palette; + Read_GL_ARB_multitexture; + Read_GL_ARB_point_parameters; + Read_GL_ARB_texture_compression; + Read_GL_ARB_transpose_matrix; + Read_GL_ARB_vertex_blend; + Read_GL_ARB_vertex_buffer_object; + Read_GL_ARB_vertex_program; + Read_GL_ARB_window_pos; + Read_GL_ARB_color_buffer_float; + Read_GL_ARB_Shader_Objects; + Read_GL_ARB_occlusion_query; + Read_GL_ARB_draw_instanced; + Read_GL_ARB_framebuffer_object; + Read_GL_ARB_geometry_shader4; + Read_GL_ARB_instanced_arrays; + Read_GL_ARB_map_buffer_range; + Read_GL_ARB_texture_buffer_object; + Read_GL_ARB_vertex_array_object; + Read_GL_ARB_uniform_buffer_object; + Read_GL_ARB_copy_buffer; + Read_GL_ARB_draw_elements_base_vertex; + Read_GL_ARB_provoking_vertex; + Read_GL_ARB_sync; + Read_GL_ARB_texture_multisample; + Read_GL_ARB_draw_buffers_blend; + Read_GL_ARB_sample_shading; + Read_GL_ARB_shading_language_include; + Read_GL_ARB_blend_func_extended; + Read_GL_ARB_sampler_objects; + Read_GL_ARB_timer_query; + Read_GL_ARB_vertex_type_2_10_10_10_rev; + Read_GL_ARB_draw_indirect; + Read_GL_ARB_gpu_shader_fp64; + Read_GL_ARB_shader_subroutine; + Read_GL_ARB_tessellation_shader; + Read_GL_ARB_transform_feedback2; + Read_GL_ARB_transform_feedback3; + Read_GL_ARB_ES2_compatibility; + Read_GL_ARB_get_program_binary; + Read_GL_ARB_separate_shader_objects; + Read_GL_ARB_vertex_attrib_64bit; + Read_GL_ARB_viewport_array; + Read_GL_ARB_cl_event; + Read_GL_ARB_debug_output; + Read_GL_ARB_robustness; + // + Read_GL_ATI_draw_buffers; + Read_GL_ATI_element_array; + Read_GL_ATI_envmap_bumpmap; + Read_GL_ATI_fragment_shader; + Read_GL_ATI_map_object_buffer; + Read_GL_ATI_pn_triangles; + Read_GL_ATI_separate_stencil; + Read_GL_ATI_vertex_array_object; + Read_GL_ATI_vertex_attrib_array_object; + Read_GL_ATI_vertex_streams; + Read_GL_AMD_performance_monitor; + Read_GL_AMD_vertex_shader_tesselator; + Read_GL_AMD_draw_buffers_blend; + Read_GL_AMD_name_gen_delete; + Read_GL_AMD_debug_output; + Read_GL_AMD_stencil_operation_extended; + Read_GL_EXT_blend_color; + Read_GL_EXT_blend_func_separate; + Read_GL_EXT_blend_minmax; + Read_GL_EXT_color_subtable; + Read_GL_EXT_compiled_vertex_array; + Read_GL_EXT_convolution; + Read_GL_EXT_coordinate_frame; + Read_GL_EXT_copy_texture; + Read_GL_EXT_cull_vertex; + Read_GL_EXT_draw_range_elements; + Read_GL_EXT_fog_coord; + Read_GL_EXT_framebuffer_object; + Read_GL_EXT_histogram; + Read_GL_EXT_index_func; + Read_GL_EXT_index_material; + Read_GL_EXT_multi_draw_arrays; + Read_GL_EXT_multisample; + Read_GL_EXT_paletted_texture; + Read_GL_EXT_pixel_transform; + Read_GL_EXT_point_parameters; + Read_GL_EXT_polygon_offset; + Read_GL_EXT_secondary_color; + Read_GL_EXT_stencil_two_side; + Read_GL_EXT_subtexture; + Read_GL_EXT_texture3D; + Read_GL_EXT_texture_object; + Read_GL_EXT_texture_perturb_normal; + Read_GL_EXT_vertex_array; + Read_GL_EXT_vertex_shader; + Read_GL_EXT_vertex_weighting; + Read_GL_EXT_depth_bounds_test; + Read_GL_EXT_blend_equation_separate; + Read_GL_EXT_stencil_clear_tag; + Read_GL_EXT_framebuffer_blit; + Read_GL_EXT_framebuffer_multisample; + Read_GL_EXT_timer_query; + Read_GL_EXT_gpu_program_parameters; + Read_GL_EXT_bindable_uniform; + Read_GL_EXT_draw_buffers2; + Read_GL_EXT_draw_instanced; + Read_GL_EXT_geometry_shader4; + Read_GL_EXT_gpu_shader4; + Read_GL_EXT_texture_array; + Read_GL_EXT_texture_buffer_object; + Read_GL_EXT_texture_integer; + Read_GL_EXT_transform_feedback; + Read_GL_EXT_direct_state_access; + Read_GL_EXT_separate_shader_objects; + Read_GL_EXT_shader_image_load_store; + Read_GL_EXT_vertex_attrib_64bit; + Read_GL_HP_image_transform; + Read_GL_IBM_multimode_draw_arrays; + Read_GL_IBM_vertex_array_lists; + Read_GL_INGR_blend_func_separate; + Read_GL_INTEL_parallel_arrays; + Read_GL_MESA_resize_buffers; + Read_GL_MESA_window_pos; + Read_GL_NV_evaluators; + Read_GL_NV_fence; + Read_GL_NV_fragment_program; + Read_GL_NV_half_float; + Read_GL_NV_occlusion_query; + Read_GL_NV_pixel_data_range; + Read_GL_NV_point_sprite; + Read_GL_NV_primitive_restart; + Read_GL_NV_register_combiners; + Read_GL_NV_register_combiners2; + Read_GL_NV_vertex_array_range; + Read_GL_NV_vertex_program; + Read_GL_NV_depth_buffer_float; + Read_GL_NV_framebuffer_multisample_coverage; + Read_GL_NV_geometry_program4; + Read_GL_NV_gpu_program4; + Read_GL_NV_parameter_buffer_object; + Read_GL_NV_transform_feedback; + Read_GL_NV_conditional_render; + Read_GL_NV_present_video; + Read_GL_NV_explicit_multisample; + Read_GL_NV_transform_feedback2; + Read_GL_NV_video_capture; + Read_GL_NV_copy_image; + Read_GL_NV_shader_buffer_load; + Read_GL_NV_vertex_buffer_unified_memory; + Read_GL_NV_gpu_program5; + Read_GL_NV_gpu_shader5; + Read_GL_NV_vertex_attrib_integer_64bit; + Read_GL_NV_vdpau_interop; + Read_GL_NV_texture_barrier; + Read_GL_NV_path_rendering; + Read_GL_NV_bindless_texture; + Read_GL_PGI_misc_hints; + Read_GL_SGIS_detail_texture; + Read_GL_SGIS_fog_function; + Read_GL_SGIS_multisample; + Read_GL_SGIS_pixel_texture; + Read_GL_SGIS_point_parameters; + Read_GL_SGIS_sharpen_texture; + Read_GL_SGIS_texture4D; + Read_GL_SGIS_texture_color_mask; + Read_GL_SGIS_texture_filter4; + Read_GL_SGIX_async; + Read_GL_SGIX_flush_raster; + Read_GL_SGIX_fragment_lighting; + Read_GL_SGIX_framezoom; + Read_GL_SGIX_igloo_interface; + Read_GL_SGIX_instruments; + Read_GL_SGIX_list_priority; + Read_GL_SGIX_pixel_texture; + Read_GL_SGIX_polynomial_ffd; + Read_GL_SGIX_reference_plane; + Read_GL_SGIX_sprite; + Read_GL_SGIX_tag_sample_buffer; + Read_GL_SGI_color_table; + Read_GL_SUNX_constant_data; + Read_GL_SUN_global_alpha; + Read_GL_SUN_mesh_array; + Read_GL_SUN_triangle_list; + Read_GL_SUN_vertex; + +{$IFDEF DGL_WIN} + Read_WGL_ARB_buffer_region; + Read_WGL_ARB_extensions_string; + Read_WGL_ARB_make_current_read; + Read_WGL_ARB_pbuffer; + Read_WGL_ARB_pixel_format; + Read_WGL_ARB_pixel_format_float; + Read_WGL_ARB_render_texture; + Read_WGL_ARB_create_context; + Read_WGL_AMD_gpu_association; + Read_WGL_EXT_display_color_table; + Read_WGL_EXT_extensions_string; + Read_WGL_EXT_make_current_read; + Read_WGL_EXT_pbuffer; + Read_WGL_EXT_pixel_format; + Read_WGL_EXT_swap_control; + Read_WGL_I3D_digital_video_control; + Read_WGL_I3D_gamma; + Read_WGL_I3D_genlock; + Read_WGL_I3D_image_buffer; + Read_WGL_I3D_swap_frame_lock; + Read_WGL_I3D_swap_frame_usage; + Read_WGL_NV_vertex_array_range; + Read_WGL_NV_present_video; + Read_WGL_NV_video_output; + Read_WGL_NV_swap_group; + Read_WGL_NV_gpu_affinity; + Read_WGL_NV_video_capture; + Read_WGL_NV_copy_image; + Read_WGL_NV_DX_interop; + Read_WGL_OML_sync_control; + Read_WGL_3DL_stereo_control; + + Read_WIN_draw_range_elements; + Read_WIN_swap_hint; +{$ENDIF} + + ExtensionsRead := True; +end; + +// ============================================================================= +// ReadCoreVersion +// ============================================================================= + +procedure ReadCoreVersion; +var + AnsiBuffer: AnsiString; + Buffer: String; + MajorVersion, MinorVersion: Integer; + + procedure TrimAndSplitVersionString(Buffer: String; out Max, Min: Integer); + // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text" + // at least however "Major.Minor". + var + Separator: Integer; + begin + try + // There must be at least one dot to separate major and minor version number. + Separator := Pos('.', Buffer); + // At least one number must be before and one after the dot. + if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and + (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then + begin + // OK, it's a valid version string. Now remove unnecessary parts. + Dec(Separator); + // Find last non-numeric character before version number. + while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do + Dec(Separator); + // Delete leading characters which do not belong to the version string. + Delete(Buffer, 1, Separator); + Separator := Pos('.', Buffer) + 1; + // Find first non-numeric character after version number + while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do + Inc(Separator); + // delete trailing characters not belonging to the version string + Delete(Buffer, Separator, 255); + // Now translate the numbers. + Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed. + Max := StrToInt(Copy(Buffer, 1, Separator - 1)); + Min := StrToInt(Copy(Buffer, Separator + 1, 1)); + end + else + Abort; + except + Min := 0; + Max := 0; + end; + end; + + +begin + // determine version of implementation + // GL + if not Assigned(@glGetString) then + glGetString := dglGetProcAddress('glGetString'); + + AnsiBuffer := glGetString(GL_VERSION); + Buffer := String(AnsiBuffer); + + TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion); + + GL_VERSION_1_0 := True; + GL_VERSION_1_1 := False; + GL_VERSION_1_2 := False; + GL_VERSION_1_3 := False; + GL_VERSION_1_4 := False; + GL_VERSION_1_5 := False; + GL_VERSION_2_0 := False; + GL_VERSION_2_1 := False; + GL_VERSION_3_0 := False; + GL_VERSION_3_1 := False; + GL_VERSION_3_2 := False; + GL_VERSION_3_3 := False; + GL_VERSION_4_0 := False; + GL_VERSION_4_1 := False; + GL_VERSION_4_2 := False; + GL_VERSION_4_3 := False; + GL_VERSION_4_4 := False; + + if MajorVersion = 1 then + begin + if MinorVersion >= 1 then + GL_VERSION_1_1 := True; + if MinorVersion >= 2 then + GL_VERSION_1_2 := True; + if MinorVersion >= 3 then + GL_VERSION_1_3 := True; + if MinorVersion >= 4 then + GL_VERSION_1_4 := True; + if MinorVersion >= 5 then + GL_VERSION_1_5 := True; + end; + + if MajorVersion >= 2 then + begin + GL_VERSION_1_1 := True; + GL_VERSION_1_2 := True; + GL_VERSION_1_3 := True; + GL_VERSION_1_4 := True; + GL_VERSION_1_5 := True; + GL_VERSION_2_0 := True; + + if MinorVersion >= 1 then + GL_VERSION_2_1 := True; + end; + + if MajorVersion >= 3 then + begin + GL_VERSION_2_1 := True; + GL_VERSION_3_0 := True; + + if MinorVersion >= 1 then + GL_VERSION_3_1 := True; + if MinorVersion >= 2 then + GL_VERSION_3_2 := True; + if MinorVersion >= 3 then + GL_VERSION_3_3 := True; + end; + + if MajorVersion >= 4 then + begin + GL_VERSION_3_1 := True; + GL_VERSION_3_2 := True; + GL_VERSION_3_3 := True; + GL_VERSION_4_0 := True; + + if MinorVersion >= 1 then + GL_VERSION_4_1 := True; + if MinorVersion >= 2 then + GL_VERSION_4_2 := True; + if MinorVersion >= 3 then + GL_VERSION_4_3 := True; + if MinorVersion >= 4 then + GL_VERSION_4_4 := True; + end; + + // GLU + GLU_VERSION_1_1 := False; + GLU_VERSION_1_2 := False; + GLU_VERSION_1_3 := False; + + if Assigned(gluGetString) then begin + AnsiBuffer := gluGetString(GLU_VERSION); + Buffer := String(AnsiBuffer); + + TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion); + + GLU_VERSION_1_1 := True; + + if MinorVersion >= 2 then + GLU_VERSION_1_2 := True; + + if MinorVersion >= 3 then + GLU_VERSION_1_3 := True; + end; +end; + + +// ============================================================================= +// ReadImplementationProperties +// ============================================================================= + +procedure ReadImplementationProperties; +var + Buffer: Ansistring; +begin + ReadCoreVersion; + + // Check all extensions + Buffer := Int_GetExtensionString; + + // === 3DFX ==================================================================== + GL_3DFX_multisample := Int_CheckExtension(Buffer, 'GL_3DFX_multisample'); + GL_3DFX_tbuffer := Int_CheckExtension(Buffer, 'GL_3DFX_tbuffer'); + GL_3DFX_texture_compression_FXT1 := Int_CheckExtension(Buffer, 'GL_3DFX_texture_compression_FXT1'); + + // === APPLE =================================================================== + GL_APPLE_client_storage := Int_CheckExtension(Buffer, 'GL_APPLE_client_storage'); + GL_APPLE_element_array := Int_CheckExtension(Buffer, 'GL_APPLE_element_array'); + GL_APPLE_fence := Int_CheckExtension(Buffer, 'GL_APPLE_fence'); + GL_APPLE_specular_vector := Int_CheckExtension(Buffer, 'GL_APPLE_specular_vector'); + GL_APPLE_transform_hint := Int_CheckExtension(Buffer, 'GL_APPLE_transform_hint'); + GL_APPLE_vertex_array_object := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_object'); + GL_APPLE_vertex_array_range := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_range'); + GL_APPLE_ycbcr_422 := Int_CheckExtension(Buffer, 'GL_APPLE_ycbcr_422'); + GL_APPLE_texture_range := Int_CheckExtension(Buffer, 'GL_APPLE_texture_range'); + GL_APPLE_float_pixels := Int_CheckExtension(Buffer, 'GL_APPLE_float_pixels'); + GL_APPLE_vertex_program_evaluators := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_program_evaluators'); + GL_APPLE_aux_depth_stencil := Int_CheckExtension(Buffer, 'GL_APPLE_aux_depth_stencil'); + GL_APPLE_object_purgeable := Int_CheckExtension(Buffer, 'GL_APPLE_object_purgeable'); + GL_APPLE_row_bytes := Int_CheckExtension(Buffer, 'GL_APPLE_row_bytes'); + GL_APPLE_rgb_422 := Int_CheckExtension(Buffer, 'GL_APPLE_rgb_422'); + + // === ARB ===================================================================== + GL_ARB_depth_texture := Int_CheckExtension(Buffer, 'GL_ARB_depth_texture'); + GL_ARB_fragment_program := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program'); + GL_ARB_imaging := Int_CheckExtension(Buffer, 'GL_ARB_imaging'); + GL_ARB_matrix_palette := Int_CheckExtension(Buffer, 'GL_ARB_matrix_palette'); + GL_ARB_multisample := Int_CheckExtension(Buffer, 'GL_ARB_multisample'); + GL_ARB_multitexture := Int_CheckExtension(Buffer, 'GL_ARB_multitexture'); + GL_ARB_point_parameters := Int_CheckExtension(Buffer, 'GL_ARB_point_parameters'); + GL_ARB_shadow := Int_CheckExtension(Buffer, 'GL_ARB_shadow'); + GL_ARB_shadow_ambient := Int_CheckExtension(Buffer, 'GL_ARB_shadow_ambient'); + GL_ARB_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp'); + GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression'); + GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map'); + GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add'); + GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine'); + GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar'); + GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3'); + GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat'); + GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix'); + GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend'); + GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object'); + GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program'); + GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos'); + GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects'); + GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader'); + GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader'); + GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query'); + GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100'); + GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite'); + GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two'); + GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow'); + GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers'); + GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle'); + GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float'); + GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel'); + GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float'); + GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object'); + GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float'); + GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced'); + GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object'); + GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB'); + GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4'); + GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex'); + GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays'); + GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range'); + GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object'); + GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc'); + GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg'); + GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object'); + GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object'); + GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility'); + GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer'); + GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod'); + GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp'); + GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex'); + GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions'); + GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex'); + GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map'); + GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync'); + GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample'); + GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra'); + GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend'); + GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading'); + GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array'); + GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather'); + GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod'); + GL_ARB_shading_language_include := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_include'); + GL_ARB_texture_compression_bptc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_bptc'); + GL_ARB_blend_func_extended := Int_CheckExtension(Buffer, 'GL_ARB_blend_func_extended'); + GL_ARB_explicit_attrib_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_attrib_location'); + GL_ARB_occlusion_query2 := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query2'); + GL_ARB_sampler_objects := Int_CheckExtension(Buffer, 'GL_ARB_sampler_objects'); + GL_ARB_shader_bit_encoding := Int_CheckExtension(Buffer, 'GL_ARB_shader_bit_encoding'); + GL_ARB_texture_rgb10_a2ui := Int_CheckExtension(Buffer, 'GL_ARB_texture_rgb10_a2ui'); + GL_ARB_texture_swizzle := Int_CheckExtension(Buffer, 'GL_ARB_texture_swizzle'); + GL_ARB_timer_query := Int_CheckExtension(Buffer, 'GL_ARB_timer_query'); + GL_ARB_vertex_type_2_10_10_10_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_2_10_10_10_rev'); + GL_ARB_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_draw_indirect'); + GL_ARB_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader5'); + GL_ARB_gpu_shader_fp64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_fp64'); + GL_ARB_shader_subroutine := Int_CheckExtension(Buffer, 'GL_ARB_shader_subroutine'); + GL_ARB_tessellation_shader := Int_CheckExtension(Buffer, 'GL_ARB_tessellation_shader'); + GL_ARB_texture_buffer_object_rgb32 := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object_rgb32'); + GL_ARB_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback2'); + GL_ARB_transform_feedback3 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback3'); + GL_ARB_ES2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES2_compatibility'); + GL_ARB_get_program_binary := Int_CheckExtension(Buffer, 'GL_ARB_get_program_binary'); + GL_ARB_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_separate_shader_objects'); + GL_ARB_shader_precision := Int_CheckExtension(Buffer, 'GL_ARB_shader_precision'); + GL_ARB_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_64bit'); + GL_ARB_viewport_array := Int_CheckExtension(Buffer, 'GL_ARB_viewport_array'); + + // GL 4.2 + GL_ARB_base_instance := Int_CheckExtension(Buffer, 'GL_ARB_base_instance'); + GL_ARB_shading_language_420pack := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_420pack'); + GL_ARB_transform_feedback_instanced := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback_instanced'); + GL_ARB_compressed_texture_pixel_storage := Int_CheckExtension(Buffer, 'GL_ARB_compressed_texture_pixel_storage'); + GL_ARB_conservative_depth := Int_CheckExtension(Buffer, 'GL_ARB_conservative_depth'); + GL_ARB_internalformat_query := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query'); + GL_ARB_map_buffer_alignment := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_alignment'); + GL_ARB_shader_atomic_counters := Int_CheckExtension(Buffer, 'GL_ARB_shader_atomic_counters'); + GL_ARB_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_load_store'); + GL_ARB_shading_language_packing := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_packing'); + GL_ARB_texture_storage := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage'); + // END GL 4.2 + + // GL 4.3 + GL_ARB_arrays_of_arrays := Int_CheckExtension(Buffer, 'GL_ARB_arrays_of_arrays'); + GL_ARB_fragment_layer_viewport := Int_CheckExtension(Buffer, 'GL_ARB_fragment_layer_viewport'); + GL_ARB_shader_image_size := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_size'); + GL_ARB_ES3_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_compatibility'); + GL_ARB_clear_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_clear_buffer_object'); + GL_ARB_compute_shader := Int_CheckExtension(Buffer, 'GL_ARB_compute_shader'); + GL_ARB_copy_image := Int_CheckExtension(Buffer, 'GL_ARB_copy_image'); + GL_KHR_debug := Int_CheckExtension(Buffer, 'GL_KHR_debug'); + GL_ARB_explicit_uniform_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_uniform_location'); + GL_ARB_framebuffer_no_attachments := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_no_attachments'); + GL_ARB_internalformat_query2 := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query2'); + GL_ARB_invalidate_subdata := Int_CheckExtension(Buffer, 'GL_ARB_invalidate_subdata'); + GL_ARB_multi_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_multi_draw_indirect'); + GL_ARB_program_interface_query := Int_CheckExtension(Buffer, 'GL_ARB_program_interface_query'); + GL_ARB_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_ARB_robust_buffer_access_behavior'); + GL_ARB_shader_storage_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_shader_storage_buffer_object'); + GL_ARB_stencil_texturing := Int_CheckExtension(Buffer, 'GL_ARB_stencil_texturing'); + GL_ARB_texture_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_range'); + GL_ARB_texture_query_levels := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_levels'); + GL_ARB_texture_storage_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage_multisample'); + GL_ARB_texture_view := Int_CheckExtension(Buffer, 'GL_ARB_texture_view'); + GL_ARB_vertex_attrib_binding := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_binding'); + GL_ARB_cl_event := Int_CheckExtension(Buffer, 'GL_ARB_cl_event'); + GL_ARB_debug_output := Int_CheckExtension(Buffer, 'GL_ARB_debug_output'); + GL_ARB_robustness := Int_CheckExtension(Buffer, 'GL_ARB_robustness'); + GL_ARB_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_ARB_shader_stencil_export'); + // END GL 4.3 + + // GL 4.4 + GL_ARB_buffer_storage := Int_CheckExtension(Buffer, 'GL_ARB_buffer_storage'); + GL_ARB_clear_texture := Int_CheckExtension(Buffer, 'GL_ARB_clear_texture'); + GL_ARB_enhanced_layouts := Int_CheckExtension(Buffer, 'GL_ARB_enhanced_layouts'); + GL_ARB_multi_bind := Int_CheckExtension(Buffer, 'GL_ARB_multi_bind'); + GL_ARB_query_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_query_buffer_object'); + GL_ARB_texture_mirror_clamp_to_edge := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirror_clamp_to_edge'); + GL_ARB_texture_stencil8 := Int_CheckExtension(Buffer, 'GL_ARB_texture_stencil8'); + GL_ARB_vertex_type_10f_11f_11f_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_10f_11f_11f_rev'); + // END GL 4.4 + + // === ATI/AMD ================================================================ + GL_ATI_draw_buffers := Int_CheckExtension(Buffer, 'GL_ATI_draw_buffers'); + GL_ATI_element_array := Int_CheckExtension(Buffer, 'GL_ATI_element_array'); + GL_ATI_envmap_bumpmap := Int_CheckExtension(Buffer, 'GL_ATI_envmap_bumpmap'); + GL_ATI_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_fragment_shader'); + GL_ATI_map_object_buffer := Int_CheckExtension(Buffer, 'GL_ATI_map_object_buffer'); + GL_ATI_pn_triangles := Int_CheckExtension(Buffer, 'GL_ATI_pn_triangles'); + GL_ATI_separate_stencil := Int_CheckExtension(Buffer, 'GL_ATI_separate_stencil'); + GL_ATI_text_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_text_fragment_shader'); + GL_ATI_texture_env_combine3 := Int_CheckExtension(Buffer, 'GL_ATI_texture_env_combine3'); + GL_ATI_texture_float := Int_CheckExtension(Buffer, 'GL_ATI_texture_float'); + GL_ATI_texture_mirror_once := Int_CheckExtension(Buffer, 'GL_ATI_texture_mirror_once'); + GL_ATI_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_array_object'); + GL_ATI_vertex_attrib_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_attrib_array_object'); + GL_ATI_vertex_streams := Int_CheckExtension(Buffer, 'GL_ATI_vertex_streams'); + GL_ATI_meminfo := Int_CheckExtension(Buffer, 'GL_ATI_meminfo'); + GL_AMD_performance_monitor := Int_CheckExtension(Buffer, 'GL_AMD_performance_monitor'); + GL_AMD_texture_texture4 := Int_CheckExtension(Buffer, 'GL_AMD_texture_texture4'); + GL_AMD_vertex_shader_tesselator := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_tesselator'); + GL_AMD_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_AMD_draw_buffers_blend'); + GL_AMD_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_AMD_shader_stencil_export'); + GL_AMD_seamless_cubemap_per_texture := Int_CheckExtension(Buffer, 'GL_AMD_seamless_cubemap_per_texture'); + GL_AMD_conservative_depth := Int_CheckExtension(Buffer, 'GL_AMD_conservative_depth'); + GL_AMD_name_gen_delete := Int_CheckExtension(Buffer, 'GL_AMD_name_gen_delete'); + GL_AMD_debug_output := Int_CheckExtension(Buffer, 'GL_AMD_debug_output'); + GL_AMD_transform_feedback3_lines_triangles := Int_CheckExtension(Buffer, 'GL_AMD_transform_feedback3_lines_triangles'); + GL_AMD_depth_clamp_separate := Int_CheckExtension(Buffer, 'GL_AMD_depth_clamp_separate'); + // 4.3 + GL_AMD_pinned_memory := Int_CheckExtension(Buffer, 'GL_AMD_pinned_memory'); + GL_AMD_stencil_operation_extended := Int_CheckExtension(Buffer, 'GL_AMD_stencil_operation_extended'); + GL_AMD_vertex_shader_viewport_index := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_viewport_index'); + GL_AMD_vertex_shader_layer := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_layer'); + GL_AMD_query_buffer_object := Int_CheckExtension(Buffer, 'GL_AMD_query_buffer_object'); + + // === EXT ===================================================================== + GL_EXT_422_pixels := Int_CheckExtension(Buffer, 'GL_EXT_422_pixels'); + GL_EXT_abgr := Int_CheckExtension(Buffer, 'GL_EXT_abgr'); + GL_EXT_bgra := Int_CheckExtension(Buffer, 'GL_EXT_bgra'); + GL_EXT_blend_color := Int_CheckExtension(Buffer, 'GL_EXT_blend_color'); + GL_EXT_blend_func_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_func_separate'); + GL_EXT_blend_logic_op := Int_CheckExtension(Buffer, 'GL_EXT_blend_logic_op'); + GL_EXT_blend_minmax := Int_CheckExtension(Buffer, 'GL_EXT_blend_minmax'); + GL_EXT_blend_subtract := Int_CheckExtension(Buffer, 'GL_EXT_blend_subtract'); + GL_EXT_clip_volume_hint := Int_CheckExtension(Buffer, 'GL_EXT_clip_volume_hint'); + GL_EXT_cmyka := Int_CheckExtension(Buffer, 'GL_EXT_cmyka'); + GL_EXT_color_matrix := Int_CheckExtension(Buffer, 'GL_EXT_color_matrix'); + GL_EXT_color_subtable := Int_CheckExtension(Buffer, 'GL_EXT_color_subtable'); + GL_EXT_compiled_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_compiled_vertex_array'); + GL_EXT_convolution := Int_CheckExtension(Buffer, 'GL_EXT_convolution'); + GL_EXT_coordinate_frame := Int_CheckExtension(Buffer, 'GL_EXT_coordinate_frame'); + GL_EXT_copy_texture := Int_CheckExtension(Buffer, 'GL_EXT_copy_texture'); + GL_EXT_cull_vertex := Int_CheckExtension(Buffer, 'GL_EXT_cull_vertex'); + GL_EXT_draw_range_elements := Int_CheckExtension(Buffer, 'GL_EXT_draw_range_elements'); + GL_EXT_fog_coord := Int_CheckExtension(Buffer, 'GL_EXT_fog_coord'); + GL_EXT_framebuffer_object := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_object'); + GL_EXT_histogram := Int_CheckExtension(Buffer, 'GL_EXT_histogram'); + GL_EXT_index_array_formats := Int_CheckExtension(Buffer, 'GL_EXT_index_array_formats'); + GL_EXT_index_func := Int_CheckExtension(Buffer, 'GL_EXT_index_func'); + GL_EXT_index_material := Int_CheckExtension(Buffer, 'GL_EXT_index_material'); + GL_EXT_index_texture := Int_CheckExtension(Buffer, 'GL_EXT_index_texture'); + GL_EXT_light_texture := Int_CheckExtension(Buffer, 'GL_EXT_light_texture'); + GL_EXT_misc_attribute := Int_CheckExtension(Buffer, 'GL_EXT_misc_attribute'); + GL_EXT_multi_draw_arrays := Int_CheckExtension(Buffer, 'GL_EXT_multi_draw_arrays'); + GL_EXT_multisample := Int_CheckExtension(Buffer, 'GL_EXT_multisample'); + GL_EXT_packed_pixels := Int_CheckExtension(Buffer, 'GL_EXT_packed_pixels'); + GL_EXT_paletted_texture := Int_CheckExtension(Buffer, 'GL_EXT_paletted_texture'); + GL_EXT_pixel_transform := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform'); + GL_EXT_pixel_transform_color_table := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform_color_table'); + GL_EXT_point_parameters := Int_CheckExtension(Buffer, 'GL_EXT_point_parameters'); + GL_EXT_polygon_offset := Int_CheckExtension(Buffer, 'GL_EXT_polygon_offset'); + GL_EXT_rescale_normal := Int_CheckExtension(Buffer, 'GL_EXT_rescale_normal'); + GL_EXT_secondary_color := Int_CheckExtension(Buffer, 'GL_EXT_secondary_color'); + GL_EXT_separate_specular_color := Int_CheckExtension(Buffer, 'GL_EXT_separate_specular_color'); + GL_EXT_shadow_funcs := Int_CheckExtension(Buffer, 'GL_EXT_shadow_funcs'); + GL_EXT_shared_texture_palette := Int_CheckExtension(Buffer, 'GL_EXT_shared_texture_palette'); + GL_EXT_stencil_two_side := Int_CheckExtension(Buffer, 'GL_EXT_stencil_two_side'); + GL_EXT_stencil_wrap := Int_CheckExtension(Buffer, 'GL_EXT_stencil_wrap'); + GL_EXT_subtexture := Int_CheckExtension(Buffer, 'GL_EXT_subtexture'); + GL_EXT_texture := Int_CheckExtension(Buffer, 'GL_EXT_texture'); + GL_EXT_texture3D := Int_CheckExtension(Buffer, 'GL_EXT_texture3D'); + GL_EXT_texture_compression_s3tc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_s3tc'); + GL_EXT_texture_cube_map := Int_CheckExtension(Buffer, 'GL_EXT_texture_cube_map'); + GL_EXT_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_edge_clamp'); + GL_EXT_texture_env_add := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_add'); + GL_EXT_texture_env_combine := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_combine'); + GL_EXT_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_dot3'); + GL_EXT_texture_filter_anisotropic := Int_CheckExtension(Buffer, 'GL_EXT_texture_filter_anisotropic'); + GL_EXT_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_EXT_texture_lod_bias'); + GL_EXT_texture_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_object'); + GL_EXT_texture_perturb_normal := Int_CheckExtension(Buffer, 'GL_EXT_texture_perturb_normal'); + GL_EXT_texture_rectangle := Int_CheckExtension(Buffer, 'GL_EXT_texture_rectangle'); + GL_EXT_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array'); + GL_EXT_vertex_shader := Int_CheckExtension(Buffer, 'GL_EXT_vertex_shader'); + GL_EXT_vertex_weighting := Int_CheckExtension(Buffer, 'GL_EXT_vertex_weighting'); + GL_EXT_depth_bounds_test := Int_CheckExtension(Buffer, 'GL_EXT_depth_bounds_test'); + GL_EXT_texture_mirror_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_mirror_clamp'); + GL_EXT_blend_equation_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_equation_separate'); + GL_EXT_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_pixel_buffer_object'); + GL_EXT_texture_compression_dxt1 := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_dxt1'); + GL_EXT_stencil_clear_tag := Int_CheckExtension(Buffer, 'GL_EXT_stencil_clear_tag'); + GL_EXT_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_EXT_packed_depth_stencil'); + GL_EXT_texture_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB'); + GL_EXT_framebuffer_blit := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_blit'); + GL_EXT_framebuffer_multisample := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_multisample'); + GL_EXT_timer_query := Int_CheckExtension(Buffer, 'GL_EXT_timer_query'); + GL_EXT_gpu_program_parameters := Int_CheckExtension(Buffer, 'GL_EXT_gpu_program_parameters'); + GL_EXT_bindable_uniform := Int_CheckExtension(Buffer, 'GL_EXT_bindable_uniform'); + GL_EXT_draw_buffers2 := Int_CheckExtension(Buffer, 'GL_EXT_draw_buffers2'); + GL_EXT_draw_instanced := Int_CheckExtension(Buffer, 'GL_EXT_draw_instanced'); + GL_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_sRGB'); + GL_EXT_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_geometry_shader4'); + GL_EXT_gpu_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_gpu_shader4'); + GL_EXT_packed_float := Int_CheckExtension(Buffer, 'GL_EXT_packed_float'); + GL_EXT_texture_array := Int_CheckExtension(Buffer, 'GL_EXT_texture_array'); + GL_EXT_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_buffer_object'); + GL_EXT_texture_compression_latc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_latc'); + GL_EXT_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_rgtc'); + GL_EXT_texture_integer := Int_CheckExtension(Buffer, 'GL_EXT_texture_integer'); + GL_EXT_texture_shared_exponent := Int_CheckExtension(Buffer, 'GL_EXT_texture_shared_exponent'); + GL_EXT_transform_feedback := Int_CheckExtension(Buffer, 'GL_EXT_transform_feedback'); + GL_EXT_direct_state_access := Int_CheckExtension(Buffer, 'GL_EXT_direct_state_access'); + GL_EXT_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array_bgra'); + GL_EXT_texture_swizzle := Int_CheckExtension(Buffer, 'GL_EXT_texture_swizzle'); + GL_EXT_provoking_vertex := Int_CheckExtension(Buffer, 'GL_EXT_provoking_vertex'); + GL_EXT_texture_snorm := Int_CheckExtension(Buffer, 'GL_EXT_texture_snorm'); + GL_EXT_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_EXT_separate_shader_objects'); + GL_EXT_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_EXT_shader_image_load_store'); + GL_EXT_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_EXT_vertex_attrib_64bit'); + GL_EXT_texture_sRGB_decode := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB_decode'); + + // === HP ====================================================================== + GL_HP_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_HP_convolution_border_modes'); + GL_HP_image_transform := Int_CheckExtension(Buffer, 'GL_HP_image_transform'); + GL_HP_occlusion_test := Int_CheckExtension(Buffer, 'GL_HP_occlusion_test'); + GL_HP_texture_lighting := Int_CheckExtension(Buffer, 'GL_HP_texture_lighting'); + + // === IBM ===================================================================== + GL_IBM_cull_vertex := Int_CheckExtension(Buffer, 'GL_IBM_cull_vertex'); + GL_IBM_multimode_draw_arrays := Int_CheckExtension(Buffer, 'GL_IBM_multimode_draw_arrays'); + GL_IBM_rasterpos_clip := Int_CheckExtension(Buffer, 'GL_IBM_rasterpos_clip'); + GL_IBM_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_IBM_texture_mirrored_repeat'); + GL_IBM_vertex_array_lists := Int_CheckExtension(Buffer, 'GL_IBM_vertex_array_lists'); + + // === INGR ==================================================================== + GL_INGR_blend_func_separate := Int_CheckExtension(Buffer, 'GL_INGR_blend_func_separate'); + GL_INGR_color_clamp := Int_CheckExtension(Buffer, 'GL_INGR_color_clamp'); + GL_INGR_interlace_read := Int_CheckExtension(Buffer, 'GL_INGR_interlace_read'); + GL_INGR_palette_buffer := Int_CheckExtension(Buffer, 'GL_INGR_palette_buffer'); + + // === INTEL =================================================================== + GL_INTEL_parallel_arrays := Int_CheckExtension(Buffer, 'GL_INTEL_parallel_arrays'); + GL_INTEL_texture_scissor := Int_CheckExtension(Buffer, 'GL_INTEL_texture_scissor'); + + // === MESA ==================================================================== + GL_MESA_resize_buffers := Int_CheckExtension(Buffer, 'GL_MESA_resize_buffers'); + GL_MESA_window_pos := Int_CheckExtension(Buffer, 'GL_MESA_window_pos'); + + // === NVIDIA ================================================================== + GL_NV_blend_square := Int_CheckExtension(Buffer, 'GL_NV_blend_square'); + GL_NV_copy_depth_to_color := Int_CheckExtension(Buffer, 'GL_NV_copy_depth_to_color'); + GL_NV_depth_clamp := Int_CheckExtension(Buffer, 'GL_NV_depth_clamp'); + GL_NV_evaluators := Int_CheckExtension(Buffer, 'GL_NV_evaluators'); + GL_NV_fence := Int_CheckExtension(Buffer, 'GL_NV_fence'); + GL_NV_float_buffer := Int_CheckExtension(Buffer, 'GL_NV_float_buffer'); + GL_NV_fog_distance := Int_CheckExtension(Buffer, 'GL_NV_fog_distance'); + GL_NV_fragment_program := Int_CheckExtension(Buffer, 'GL_NV_fragment_program'); + GL_NV_half_float := Int_CheckExtension(Buffer, 'GL_NV_half_float'); + GL_NV_light_max_exponent := Int_CheckExtension(Buffer, 'GL_NV_light_max_exponent'); + GL_NV_multisample_filter_hint := Int_CheckExtension(Buffer, 'GL_NV_multisample_filter_hint'); + GL_NV_occlusion_query := Int_CheckExtension(Buffer, 'GL_NV_occlusion_query'); + GL_NV_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_NV_packed_depth_stencil'); + GL_NV_pixel_data_range := Int_CheckExtension(Buffer, 'GL_NV_pixel_data_range'); + GL_NV_point_sprite := Int_CheckExtension(Buffer, 'GL_NV_point_sprite'); + GL_NV_primitive_restart := Int_CheckExtension(Buffer, 'GL_NV_primitive_restart'); + GL_NV_register_combiners := Int_CheckExtension(Buffer, 'GL_NV_register_combiners'); + GL_NV_register_combiners2 := Int_CheckExtension(Buffer, 'GL_NV_register_combiners2'); + GL_NV_texgen_emboss := Int_CheckExtension(Buffer, 'GL_NV_texgen_emboss'); + GL_NV_texgen_reflection := Int_CheckExtension(Buffer, 'GL_NV_texgen_reflection'); + GL_NV_texture_compression_vtc := Int_CheckExtension(Buffer, 'GL_NV_texture_compression_vtc'); + GL_NV_texture_env_combine4 := Int_CheckExtension(Buffer, 'GL_NV_texture_env_combine4'); + GL_NV_texture_expand_normal := Int_CheckExtension(Buffer, 'GL_NV_texture_expand_normal'); + GL_NV_texture_rectangle := Int_CheckExtension(Buffer, 'GL_NV_texture_rectangle'); + GL_NV_texture_shader := Int_CheckExtension(Buffer, 'GL_NV_texture_shader'); + GL_NV_texture_shader2 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader2'); + GL_NV_texture_shader3 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader3'); + GL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range'); + GL_NV_vertex_array_range2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range2'); + GL_NV_vertex_program := Int_CheckExtension(Buffer, 'GL_NV_vertex_program'); + GL_NV_vertex_program1_1 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program1_1'); + GL_NV_vertex_program2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2'); + GL_NV_fragment_program_option := Int_CheckExtension(Buffer, 'GL_NV_fragment_program_option'); + GL_NV_fragment_program2 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program2'); + GL_NV_vertex_program2_option := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2_option'); + GL_NV_vertex_program3 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program3'); + GL_NV_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_NV_depth_buffer_float'); + GL_NV_fragment_program4 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program4'); + GL_NV_framebuffer_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_framebuffer_multisample_coverage'); + GL_NV_geometry_program4 := Int_CheckExtension(Buffer, 'GL_NV_geometry_program4'); + GL_NV_gpu_program4 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program4'); + GL_NV_parameter_buffer_object := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object'); + GL_NV_transform_feedback := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback'); + GL_NV_vertex_program4 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program4'); + GL_NV_conditional_render := Int_CheckExtension(Buffer, 'GL_NV_conditional_render'); + GL_NV_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video'); + GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample'); + GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2'); + GL_NV_video_capture := Int_CheckExtension(Buffer, 'GL_NV_video_capture'); + GL_NV_copy_image := Int_CheckExtension(Buffer, 'GL_NV_copy_image'); + GL_NV_parameter_buffer_object2 := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object2'); + GL_NV_shader_buffer_load := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_load'); + GL_NV_vertex_buffer_unified_memory := Int_CheckExtension(Buffer, 'GL_NV_vertex_buffer_unified_memory'); + GL_NV_gpu_program5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program5'); + GL_NV_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_shader5'); + GL_NV_shader_buffer_store := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_store'); + GL_NV_tessellation_program5 := Int_CheckExtension(Buffer, 'GL_NV_tessellation_program5'); + GL_NV_vertex_attrib_integer_64bit := Int_CheckExtension(Buffer, 'GL_NV_vertex_attrib_integer_64bit'); + GL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_multisample_coverage'); + GL_NV_vdpau_interop := Int_CheckExtension(Buffer, 'GL_NV_vdpau_interop'); + GL_NV_texture_barrier := Int_CheckExtension(Buffer, 'GL_NV_texture_barrier'); + // 4.3 + GL_NV_path_rendering := Int_CheckExtension(Buffer, 'GL_NV_path_rendering'); + GL_NV_bindless_texture := Int_CheckExtension(Buffer, 'GL_NV_bindless_texture'); + GL_NV_shader_atomic_float := Int_CheckExtension(Buffer, 'GL_NV_shader_atomic_float'); + + // === OML ===================================================================== + GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace'); + GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample'); + GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample'); + + // === PGI ===================================================================== + GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints'); + GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints'); + + // === REND ==================================================================== + GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates'); + + // === S3 ====================================================================== + GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc'); + + // === SGIS ==================================================================== + GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture'); + GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function'); + GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap'); + GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample'); + GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture'); + GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen'); + GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters'); + GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture'); + GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D'); + GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp'); + GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask'); + GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp'); + GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4'); + GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod'); + GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select'); + + // === SGIX ==================================================================== + GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX'); + GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async'); + GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram'); + GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel'); + GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax'); + GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment'); + GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap'); + GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy'); + GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument'); + GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture'); + GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster'); + GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset'); + GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale'); + GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting'); + GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom'); + GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface'); + GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture'); + GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments'); + GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace'); + GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1'); + GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority'); + GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture'); + GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles'); + GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd'); + GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane'); + GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample'); + GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint'); + GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow'); + GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient'); + GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite'); + GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample'); + GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer'); + GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env'); + GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp'); + GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias'); + GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer'); + GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias'); + GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select'); + GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip'); + GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb'); + GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample'); + GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba'); + + // === SGI ===================================================================== + GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix'); + GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table'); + GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument'); + GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table'); + + // === SUN ===================================================================== + GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data'); + GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes'); + GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha'); + GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array'); + GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum'); + GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list'); + GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex'); + + // === WIN ===================================================================== + GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading'); + GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog'); + + {$IFDEF DGL_WIN} + // === WGL ===================================================================== + WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample'); + WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region'); + WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string'); + WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read'); + WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample'); + WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer'); + WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format'); + WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float'); + WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture'); + WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context'); + WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile'); + WGL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'WGL_ARB_framebuffer_sRGB'); + WGL_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_robustness'); + WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float'); + WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association'); + WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float'); + WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table'); + WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string'); + WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read'); + WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample'); + WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer'); + WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format'); + WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control'); + WGL_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'WGL_EXT_create_context_es2_profile'); + WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control'); + WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma'); + WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock'); + WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer'); + WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock'); + WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage'); + WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer'); + WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture'); + WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle'); + WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range'); + WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video'); + WGL_NV_video_output := Int_CheckExtension(Buffer, 'WGL_NV_video_output'); + WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group'); + WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity'); + WGL_NV_video_capture := Int_CheckExtension(Buffer, 'WGL_NV_video_capture'); + WGL_NV_copy_image := Int_CheckExtension(Buffer, 'WGL_NV_copy_image'); + WGL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage'); + WGL_NV_DX_interop := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage'); + WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control'); + WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control'); + + WIN_draw_range_elements := Int_CheckExtension(Buffer, 'WIN_draw_range_elements'); + WIN_swap_hint := Int_CheckExtension(Buffer, 'WIN_swap_hint'); + {$ENDIF} + + {$IFDEF DGL_LINUX} + // === GLX ===================================================================== + GLX_ARB_multisample := Int_CheckExtension(Buffer, 'GLX_ARB_multisample'); + GLX_ARB_fbconfig_float := Int_CheckExtension(Buffer, 'GLX_ARB_fbconfig_float'); + GLX_ARB_get_proc_address := Int_CheckExtension(Buffer, 'GLX_ARB_get_proc_address'); + GLX_ARB_create_context := Int_CheckExtension(Buffer, 'GLX_ARB_create_context'); + GLX_ARB_create_context_profile := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_profile'); + GLX_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GLX_ARB_vertex_buffer_object'); + GLX_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_ARB_framebuffer_sRGB'); + GLX_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_robustness'); + GLX_EXT_visual_info := Int_CheckExtension(Buffer, 'GLX_EXT_visual_info'); + GLX_EXT_visual_rating := Int_CheckExtension(Buffer, 'GLX_EXT_visual_rating'); + GLX_EXT_import_context := Int_CheckExtension(Buffer, 'GLX_EXT_import_context'); + GLX_EXT_fbconfig_packed_float := Int_CheckExtension(Buffer, 'GLX_EXT_fbconfig_packed_float'); + GLX_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_EXT_framebuffer_sRGB'); + GLX_EXT_texture_from_pixmap := Int_CheckExtension(Buffer, 'GLX_EXT_texture_from_pixmap'); + GLX_EXT_swap_control := Int_CheckExtension(Buffer, 'GLX_EXT_swap_control'); + GLX_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'GLX_EXT_create_context_es2_profile'); + {$ENDIF} + ImplementationRead := True; +end; + +{$IFDEF DGL_WIN} +// ============================================================================= +// RaiseLastOSError +// ============================================================================= +// Needed for compatibility with older Delphiversions +// ============================================================================= + +procedure RaiseLastOSError; +begin +{$IFDEF FPC} + raise Exception.Create('RaiseLastOSError!'); // To-Do: find a better solution +{$ELSE} + {$IFDEF DELPHI6_AND_DOWN} // If Delphi 6 or later + SysUtils.RaiseLastWin32Error; + {$ELSE} + SysUtils.RaiseLastOSError; + {$ENDIF} +{$ENDIF} +end; + +// ============================================================================= +// CreateRenderingContext +// ============================================================================= + +function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; +const + OBJ_MEMDC = 10; + OBJ_ENHMETADC = 12; + OBJ_METADC = 4; + PFD_DOUBLEBUFFER = $00000001; + PFD_STEREO = $00000002; + PFD_DRAW_TO_WINDOW = $00000004; + PFD_DRAW_TO_BITMAP = $00000008; + PFD_SUPPORT_GDI = $00000010; + PFD_SUPPORT_OPENGL = $00000020; + PFD_TYPE_RGBA = 0; + PFD_MAIN_PLANE = 0; + PFD_OVERLAY_PLANE = 1; + PFD_UNDERLAY_PLANE = LongWord(-1); + MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC]; +var + PFDescriptor: TPixelFormatDescriptor; + PixelFormat: Integer; + AType: DWORD; +begin + if GL_LibHandle = nil then + InitOpenGL; + + FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0); + + with PFDescriptor do + begin + nSize := SizeOf(PFDescriptor); + nVersion := 1; + dwFlags := PFD_SUPPORT_OPENGL; + + AType := GetObjectType(DC); + + if AType = 0 then + RaiseLastOSError; + + if AType in MemoryDCs then + dwFlags := dwFlags or PFD_DRAW_TO_BITMAP + else + dwFlags := dwFlags or PFD_DRAW_TO_WINDOW; + + if opDoubleBuffered in Options then + dwFlags := dwFlags or PFD_DOUBLEBUFFER; + + if opGDI in Options then + dwFlags := dwFlags or PFD_SUPPORT_GDI; + + if opStereo in Options then + dwFlags := dwFlags or PFD_STEREO; + + iPixelType := PFD_TYPE_RGBA; + cColorBits := ColorBits; + cDepthBits := zBits; + cStencilBits := StencilBits; + cAccumBits := AccumBits; + cAuxBuffers := AuxBuffers; + + if Layer = 0 then + iLayerType := PFD_MAIN_PLANE + else + if Layer > 0 then + iLayerType := PFD_OVERLAY_PLANE + else + iLayerType := Byte(PFD_UNDERLAY_PLANE); + end; + + PixelFormat := ChoosePixelFormat(DC, @PFDescriptor); + + if PixelFormat = 0 then + RaiseLastOSError; + + if GetPixelFormat(DC) <> PixelFormat then + if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then + RaiseLastOSError; + + DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor); + + Result := wglCreateContext(DC); + + if Result = 0 then + RaiseLastOSError + else + LastPixelFormat := 0; +end; + +// ============================================================================= +// CreateRenderingContextVersion +// ============================================================================= +// Creates a context for the more recent OpenGL versions (3.0) and up +// For that we first need to get a normal GL context for getting the +// function pointer to wglCreateContextAttribsARB first +// ============================================================================= +function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; +const + OBJ_MEMDC = 10; + OBJ_ENHMETADC = 12; + OBJ_METADC = 4; + PFD_DOUBLEBUFFER = $00000001; + PFD_STEREO = $00000002; + PFD_DRAW_TO_WINDOW = $00000004; + PFD_DRAW_TO_BITMAP = $00000008; + PFD_SUPPORT_GDI = $00000010; + PFD_SUPPORT_OPENGL = $00000020; + PFD_TYPE_RGBA = 0; + PFD_MAIN_PLANE = 0; + PFD_OVERLAY_PLANE = 1; + PFD_UNDERLAY_PLANE = LongWord(-1); + MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC]; +var + PFDescriptor : TPixelFormatDescriptor; + PixelFormat : Integer; + AType : DWORD; + LegacyRC : HGLRC; + Attribs : array of Integer; +begin + if GL_LibHandle = nil then + InitOpenGL; + + if not Assigned(GL_LibHandle) then + raise Exception.Create('GL_LibHandle is NIL. Could not load OpenGL library!'); + + FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0); + + with PFDescriptor do + begin + nSize := SizeOf(PFDescriptor); + nVersion := 1; + dwFlags := PFD_SUPPORT_OPENGL; + AType := GetObjectType(DC); + + if AType = 0 then + RaiseLastOSError; + + if AType in MemoryDCs then + dwFlags := dwFlags or PFD_DRAW_TO_BITMAP + else + dwFlags := dwFlags or PFD_DRAW_TO_WINDOW; + + if opDoubleBuffered in Options then + dwFlags := dwFlags or PFD_DOUBLEBUFFER; + + if opGDI in Options then + dwFlags := dwFlags or PFD_SUPPORT_GDI; + + if opStereo in Options then + dwFlags := dwFlags or PFD_STEREO; + + iPixelType := PFD_TYPE_RGBA; + cColorBits := ColorBits; + cDepthBits := zBits; + cStencilBits := StencilBits; + cAccumBits := AccumBits; + cAuxBuffers := AuxBuffers; + + if Layer = 0 then + iLayerType := PFD_MAIN_PLANE + else + if Layer > 0 then + iLayerType := PFD_OVERLAY_PLANE + else + iLayerType := Byte(PFD_UNDERLAY_PLANE); + end; + + PixelFormat := ChoosePixelFormat(DC, @PFDescriptor); + + if PixelFormat = 0 then + RaiseLastOSError; + + if GetPixelFormat(DC) <> PixelFormat then + if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then + RaiseLastOSError; + + DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor); + + // Create legacy render context first for we need function pointers to + // create new OpenGL render contexts + LegacyRC := wglCreateContext(DC); + wglMakeCurrent(DC, LegacyRC); + + // Set attributes to describe our requested context + SetLength(Attribs, 5); + Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB; + Attribs[1] := MajorVersion; + Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB; + Attribs[3] := MinorVersion; + + // Add context flag for forward compatible context + // Forward compatible means no more support for legacy functions like + // immediate mode (glvertex, glrotate, gltranslate, etc.) + if ForwardCompatible then + begin + SetLength(Attribs, Length(Attribs)+2); + Attribs[4] := WGL_CONTEXT_FLAGS_ARB; + Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; + end; + + // Attribute flags must be finalized with a zero + Attribs[High(Attribs)] := 0; + + // Get function pointer for new context creation function + wglCreateContextAttribsARB := wglGetProcAddress('wglCreateContextAttribsARB'); + + if not Assigned(wglCreateContextAttribsARB) then + begin + raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!'); + wglDeleteContext(LegacyRC); + exit; + end; + + // Create context + Result := wglCreateContextAttribsARB(DC, 0, @Attribs[0]); + + if Result = 0 then + begin + raise Exception.Create('Could not create the desired OpenGL rendering context!'); + wglDeleteContext(LegacyRC); + exit; + end; + + wglDeleteContext(LegacyRC); + + if Result = 0 then + RaiseLastOSError + else + LastPixelFormat := 0; +end; + +// ============================================================================= +// DestroyRenderingContext +// ============================================================================= + +procedure DestroyRenderingContext(RC: HGLRC); +begin + wglDeleteContext(RC); +end; + + +// ============================================================================= +// ActivateRenderingContext +// ============================================================================= + +procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true); +begin + Assert((DC <> 0), 'DC must not be 0'); + Assert((RC <> 0), 'RC must not be 0'); + + wglMakeCurrent(DC, RC); + + {$ifdef DGL_TINY_HEADER} + ReadCoreVersion; + {$else} + ReadImplementationProperties; + + if (loadext) then + ReadExtensions; + {$endif} +end; + +// ============================================================================= +// DeactivateRenderingContext +// ============================================================================= + +procedure DeactivateRenderingContext; +begin + wglMakeCurrent(0, 0); +end; +{$ENDIF} + + +initialization + +{$IFDEF CPU386} + Set8087CW($133F); +{$ENDIF} + +finalization + +end. diff --git a/examples/textures/BMP_24_RGB8.bmp b/examples/textures/BMP_24_RGB8.bmp new file mode 100644 index 0000000..e1318e8 Binary files /dev/null and b/examples/textures/BMP_24_RGB8.bmp differ diff --git a/glBitmap.pas b/glBitmap.pas index 4986ed4..5f18496 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -1,237 +1,49 @@ -{ -glBitmap by Steffen Xonna aka Lossy eX (2003-2008) -http://www.opengl24.de/index.php?cat=header&file=glbitmap - -modified by Delphi OpenGL Community (http://delphigl.com/) (2013) - ------------------------------------------------------------- -The contents of this file are used with permission, subject to -the Mozilla Public License Version 1.1 (the "License"); you may -not use this file except in compliance with the License. You may -obtain a copy of the License at -http://www.mozilla.org/MPL/MPL-1.1.html ------------------------------------------------------------- -Version 3.0.1 ------------------------------------------------------------- -History -20-11-2013 -- refactoring of the complete library -21-03-2010 -- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi - then it's your problem if that isn't true. This prevents the unit for incompatibility - with newer versions of Delphi. -- Problems with D2009+ resolved (Thanks noeska and all i forgot) -- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson) -10-08-2008 -- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson) -- Additional Datapointer for functioninterface now has the name CustomData -24-07-2008 -- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson) -- If you load an texture from an file the property Filename will be set to the name of the file -- Three new properties to attach custom data to the Texture objects - - CustomName (free for use string) - - CustomNameW (free for use widestring) - - CustomDataPointer (free for use pointer to attach other objects or complex structures) -27-05-2008 -- RLE TGAs loaded much faster -26-05-2008 -- fixed some problem with reading RLE TGAs. -21-05-2008 -- function clone now only copys data if it's assigned and now it also copies the ID -- it seems that lazarus dont like comments in comments. -01-05-2008 -- It's possible to set the id of the texture -- define GLB_NO_NATIVE_GL deactivated by default -27-04-2008 -- Now supports the following libraries - - SDL and SDL_image - - libPNG - - libJPEG -- Linux compatibillity via free pascal compatibility (delphi sources optional) -- BMPs now loaded manuel -- Large restructuring -- Property DataPtr now has the name Data -- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR -- Unused Depth removed -- Function FreeData to freeing image data added -24-10-2007 -- ImageID flag of TGAs was ignored. (Thanks Zwoetzen) -15-11-2006 -- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER) -- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel -- Function ReadOpenGLExtension is now only intern -29-06-2006 -- pngimage now disabled by default like all other versions. -26-06-2006 -- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi) -22-06-2006 -- Fixed some Problem with Delphi 5 -- Now uses the newest version of pngimage. Makes saving pngs much easier. -22-03-2006 -- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi) -09-03-2006 -- Internal Format ifDepth8 added -- function GrabScreen now supports all uncompressed formats -31-01-2006 -- AddAlphaFromglBitmap implemented -29-12-2005 -- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID) -28-12-2005 -- Width, Height and Depth internal changed to TglBitmapPixelPosition. - property Width, Height, Depth are still existing and new property Dimension are avail -11-12-2005 -- Added native OpenGL Support. Breaking the dglOpenGL "barrier". -19-10-2005 -- Added function GrabScreen to class TglBitmap2D -18-10-2005 -- Added support to Save images -- Added function Clone to Clone Instance -11-10-2005 -- Functions now works with Cardinals for each channel. Up to 32 Bits per channel. - Usefull for Future -- Several speed optimizations -09-10-2005 -- Internal structure change. Loading of TGA, PNG and DDS improved. - Data, format and size will now set directly with SetDataPtr. -- AddFunc now works with all Types of Images and Formats -- Some Funtions moved to Baseclass TglBitmap -06-10-2005 -- Added Support to decompress DXT3 and DXT5 compressed Images. -- Added Mapping to convert data from one format into an other. -05-10-2005 -- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every - supported Input format (supported by GetPixel) into any uncompresed Format -- Added Support to decompress DXT1 compressed Images. -- SwapColors replaced by ConvertTo -04-10-2005 -- Added Support for compressed DDSs -- Added new internal formats (DXT1, DXT3, DXT5) -29-09-2005 -- Parameter Components renamed to InternalFormat -23-09-2005 -- Some AllocMem replaced with GetMem (little speed change) -- better exception handling. Better protection from memory leaks. -22-09-2005 -- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only) -- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5) -07-09-2005 -- Added support for Grayscale textures -- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8) -10-07-2005 -- Added support for GL_VERSION_2_0 -- Added support for GL_EXT_texture_filter_anisotropic -04-07-2005 -- Function FillWithColor fills the Image with one Color -- Function LoadNormalMap added -30-06-2005 -- ToNormalMap allows to Create an NormalMap from the Alphachannel -- ToNormalMap now supports Sobel (nmSobel) function. -29-06-2005 -- support for RLE Compressed RGB TGAs added -28-06-2005 -- Class TglBitmapNormalMap added to support Normalmap generation -- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures. - 3 Filters are supported. (4 Samples, 3x3 and 5x5) -16-06-2005 -- Method LoadCubeMapClass removed -- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures -- virtual abstract method GenTexture in class TglBitmap now is protected -12-06-2005 -- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal -10-06-2005 -- little enhancement for IsPowerOfTwo -- TglBitmap1D.GenTexture now tests NPOT Textures -06-06-2005 -- some little name changes. All properties or function with Texture in name are - now without texture in name. We have allways texture so we dosn't name it. -03-06-2005 -- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or - TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception. -02-06-2005 -- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle -25-04-2005 -- Function Unbind added -- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture. -21-04-2005 -- class TglBitmapCubeMap added (allows to Create Cubemaps) -29-03-2005 -- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/) - To Enable png's use the define pngimage -22-03-2005 -- New Functioninterface added -- Function GetPixel added -27-11-2004 -- Property BuildMipMaps renamed to MipMap -21-11-2004 -- property Name removed. -- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap -22-05-2004 -- property name added. Only used in glForms! -26-11-2003 -- property FreeDataAfterGenTexture is now available as default (default = true) -- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it) -- function MoveMemory replaced with function Move (little speed change) -- several calculations stored in variables (little speed change) -29-09-2003 -- property BuildMipsMaps added (default = true) - if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps -- property FreeDataAfterGenTexture added (default = true) - if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated. -- parameter DisableOtherTextureUnits of Bind removed -- parameter FreeDataAfterGeneration of GenTextures removed -12-09-2003 -- TglBitmap dosn't delete data if class was destroyed (fixed) -09-09-2003 -- Bind now enables TextureUnits (by params) -- GenTextures can leave data (by param) -- LoadTextures now optimal -03-09-2003 -- Performance optimization in AddFunc -- procedure Bind moved to subclasses -- Added new Class TglBitmap1D to support real OpenGL 1D Textures -19-08-2003 -- Texturefilter and texturewrap now also as defaults - Minfilter = GL_LINEAR_MIPMAP_LINEAR - Magfilter = GL_LINEAR - Wrap(str) = GL_CLAMP_TO_EDGE -- Added new format tfCompressed to create a compressed texture. -- propertys IsCompressed, TextureSize and IsResident added - IsCompressed and TextureSize only contains data from level 0 -18-08-2003 -- Added function AddFunc to add PerPixelEffects to Image -- LoadFromFunc now based on AddFunc -- Invert now based on AddFunc -- SwapColors now based on AddFunc -16-08-2003 -- Added function FlipHorz -15-08-2003 -- Added function LaodFromFunc to create images with function -- Added function FlipVert -- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported -29-07-2003 -- Added Alphafunctions to calculate alpha per function -- Added Alpha from ColorKey using alphafunctions -28-07-2003 -- First full functionally Version of glBitmap -- Support for 24Bit and 32Bit TGA Pictures added -25-07-2003 -- begin of programming -} +{ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) + http://www.opengl24.de/index.php?cat=header&file=glbitmap + + modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + + The contents of this file are used with permission, subject to + the Mozilla Public License Version 1.1 (the "License"); you may + not use this file except in compliance with the License. You may + obtain a copy of the License at + http://www.mozilla.org/MPL/MPL-1.1.html + + The glBitmap is a Delphi/FPC unit that contains several wrapper classes + to manage OpenGL texture objects. Below you can find a list of the main + functionality of this classes: + - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) + - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) + - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) + - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) + - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) + - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) + - upload texture data to video card + - download texture data from video card + - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...) } + unit glBitmap; // Please uncomment the defines below to configure the glBitmap to your preferences. // If you have configured the unit you can uncomment the warning above. -{.$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} +{$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// enable OpenGL ES support +// enable support for OpenGL ES 1.1 {.$DEFINE OPENGL_ES_1_1} + +// enable support for OpenGL ES 2.0 {.$DEFINE OPENGL_ES_2_0} + +// enable support for OpenGL ES 3.0 {.$DEFINE OPENGL_ES_3_0} + +// enable support for all OpenGL ES extensions {.$DEFINE OPENGL_ES_EXT} + // activate to enable build-in OpenGL support with statically linked methods // use dglOpenGL.pas if not enabled {.$DEFINE GLB_NATIVE_OGL_STATIC} @@ -791,14 +603,6 @@ var {$ENDIF} type -//////////////////////////////////////////////////////////////////////////////////////////////////// -// the name of formats is composed of the following constituents: -// - multiple chanals: -// - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved) -// - width of the chanel in bit (4, 8, 16, ...) -// - data type (e.g. ub, us, ui) -// - number of data types - {$IFNDEF fpc} QWord = System.UInt64; PQWord = ^QWord; @@ -807,93 +611,104 @@ type PtrUInt = DWord; {$ENDIF} + + { type that describes the format of the data stored in a texture. + the name of formats is composed of the following constituents: + - multiple channels: + - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) + - width of the chanel in bit (4, 8, 16, ...) + - data type (e.g. ub, us, ui) + - number of elements of data types } TglBitmapFormat = ( - tfEmpty = 0, //must be smallest value! - - tfAlpha4ub1, // 1 x unsigned byte - tfAlpha8ub1, // 1 x unsigned byte - tfAlpha16us1, // 1 x unsigned short - - tfLuminance4ub1, // 1 x unsigned byte - tfLuminance8ub1, // 1 x unsigned byte - tfLuminance16us1, // 1 x unsigned short - - tfLuminance4Alpha4ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) - tfLuminance6Alpha2ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) - tfLuminance8Alpha8ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) - tfLuminance12Alpha4us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) - tfLuminance16Alpha16us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) - - tfR3G3B2ub1, // 1 x unsigned byte (3bit red, 3bit green, 2bit blue) - tfRGBX4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd) - tfXRGB4us1, // 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue) - tfR5G6B5us1, // 1 x unsigned short (5bit red, 6bit green, 5bit blue) - tfRGB5X1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved) - tfX1RGB5us1, // 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue) - tfRGB8ub3, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue) - tfRGBX8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved) - tfXRGB8ui1, // 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue) - tfRGB10X2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved) - tfX2RGB10ui1, // 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue) - tfRGB16us3, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue) - - tfRGBA4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha) - tfARGB4us1, // 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue) - tfRGB5A1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha) - tfA1RGB5us1, // 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue) - tfRGBA8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha) - tfARGB8ui1, // 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue) - tfRGBA8ub4, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha) - tfRGB10A2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha) - tfA2RGB10ui1, // 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue) - tfRGBA16us4, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha) - - tfBGRX4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved) - tfXBGR4us1, // 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red) - tfB5G6R5us1, // 1 x unsigned short (5bit blue, 6bit green, 5bit red) - tfBGR5X1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved) - tfX1BGR5us1, // 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red) - tfBGR8ub3, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red) - tfBGRX8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved) - tfXBGR8ui1, // 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red) - tfBGR10X2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved) - tfX2BGR10ui1, // 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red) - tfBGR16us3, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red) - - tfBGRA4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha) - tfABGR4us1, // 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red) - tfBGR5A1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha) - tfA1BGR5us1, // 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red) - tfBGRA8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha) - tfABGR8ui1, // 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red) - tfBGRA8ub4, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha) - tfBGR10A2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha) - tfA2BGR10ui1, // 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red) - tfBGRA16us4, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha) - - tfDepth16us1, // 1 x unsigned short (depth) - tfDepth24ui1, // 1 x unsigned int (depth) - tfDepth32ui1, // 1 x unsigned int (depth) + tfEmpty = 0, + + tfAlpha4ub1, //< 1 x unsigned byte + tfAlpha8ub1, //< 1 x unsigned byte + tfAlpha16us1, //< 1 x unsigned short + + tfLuminance4ub1, //< 1 x unsigned byte + tfLuminance8ub1, //< 1 x unsigned byte + tfLuminance16us1, //< 1 x unsigned short + + tfLuminance4Alpha4ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance6Alpha2ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance8Alpha8ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance12Alpha4us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha) + tfLuminance16Alpha16us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha) + + tfR3G3B2ub1, //< 1 x unsigned byte (3bit red, 3bit green, 2bit blue) + tfRGBX4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd) + tfXRGB4us1, //< 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue) + tfR5G6B5us1, //< 1 x unsigned short (5bit red, 6bit green, 5bit blue) + tfRGB5X1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved) + tfX1RGB5us1, //< 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue) + tfRGB8ub3, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue) + tfRGBX8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved) + tfXRGB8ui1, //< 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue) + tfRGB10X2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved) + tfX2RGB10ui1, //< 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue) + tfRGB16us3, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue) + + tfRGBA4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha) + tfARGB4us1, //< 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue) + tfRGB5A1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha) + tfA1RGB5us1, //< 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue) + tfRGBA8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha) + tfARGB8ui1, //< 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue) + tfRGBA8ub4, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha) + tfRGB10A2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha) + tfA2RGB10ui1, //< 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue) + tfRGBA16us4, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha) + + tfBGRX4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved) + tfXBGR4us1, //< 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red) + tfB5G6R5us1, //< 1 x unsigned short (5bit blue, 6bit green, 5bit red) + tfBGR5X1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved) + tfX1BGR5us1, //< 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red) + tfBGR8ub3, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red) + tfBGRX8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved) + tfXBGR8ui1, //< 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red) + tfBGR10X2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved) + tfX2BGR10ui1, //< 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red) + tfBGR16us3, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red) + + tfBGRA4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha) + tfABGR4us1, //< 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red) + tfBGR5A1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha) + tfA1BGR5us1, //< 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red) + tfBGRA8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha) + tfABGR8ui1, //< 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red) + tfBGRA8ub4, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha) + tfBGR10A2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha) + tfA2BGR10ui1, //< 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red) + tfBGRA16us4, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha) + + tfDepth16us1, //< 1 x unsigned short (depth) + tfDepth24ui1, //< 1 x unsigned int (depth) + tfDepth32ui1, //< 1 x unsigned int (depth) tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA ); + { type to define suitable file formats } TglBitmapFileType = ( - {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} - ftDDS, - ftTGA, - ftBMP, - ftRAW); + {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} //< Portable Network Graphic file (PNG) + {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} //< JPEG file + ftDDS, //< Direct Draw Surface file (DDS) + ftTGA, //< Targa Image File (TGA) + ftBMP, //< Windows Bitmap File (BMP) + ftRAW); //< glBitmap RAW file format TglBitmapFileTypes = set of TglBitmapFileType; - TglBitmapMipMap = ( - mmNone, - mmMipmap, - mmMipmapGlu); + { possible mipmap types } + TglBitmapMipMap = ( + mmNone, //< no mipmaps + mmMipmap, //< normal mipmaps + mmMipmapGlu); //< mipmaps generated with glu functions + { possible normal map functions } TglBitmapNormalMapFunc = ( nm4Samples, nmSobel, @@ -901,426 +716,874 @@ type nm5x5); //////////////////////////////////////////////////////////////////////////////////////////////////// - EglBitmap = class(Exception); - EglBitmapNotSupported = class(Exception); - EglBitmapSizeToLarge = class(EglBitmap); - EglBitmapNonPowerOfTwo = class(EglBitmap); - EglBitmapUnsupportedFormat = class(EglBitmap) + EglBitmap = class(Exception); //< glBitmap exception + EglBitmapNotSupported = class(Exception); //< exception for not supported functions + EglBitmapSizeToLarge = class(EglBitmap); //< exception for to large textures + EglBitmapNonPowerOfTwo = class(EglBitmap); //< exception for non power of two textures + EglBitmapUnsupportedFormat = class(EglBitmap) //< exception for unsupporetd formats public constructor Create(const aFormat: TglBitmapFormat); overload; constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload; end; //////////////////////////////////////////////////////////////////////////////////////////////////// + { record that stores 4 unsigned integer values } TglBitmapRec4ui = packed record case Integer of 0: (r, g, b, a: Cardinal); 1: (arr: array[0..3] of Cardinal); end; + { record that stores 4 unsigned byte values } TglBitmapRec4ub = packed record case Integer of 0: (r, g, b, a: Byte); 1: (arr: array[0..3] of Byte); end; + { record that stores 4 unsigned long integer values } TglBitmapRec4ul = packed record case Integer of 0: (r, g, b, a: QWord); 1: (arr: array[0..3] of QWord); end; + { describes the properties of a given texture data format } TglBitmapFormatDescriptor = class(TObject) private // cached properties - fBytesPerPixel: Single; - fChannelCount: Integer; - fMask: TglBitmapRec4ul; - fRange: TglBitmapRec4ui; + fBytesPerPixel: Single; //< number of bytes for each pixel + fChannelCount: Integer; //< number of color channels + fMask: TglBitmapRec4ul; //< bitmask for each color channel + fRange: TglBitmapRec4ui; //< maximal value of each color channel + { @return @true if the format has a red color channel, @false otherwise } function GetHasRed: Boolean; + + { @return @true if the format has a green color channel, @false otherwise } function GetHasGreen: Boolean; + + { @return @true if the format has a blue color channel, @false otherwise } function GetHasBlue: Boolean; + + { @return @true if the format has a alpha color channel, @false otherwise } function GetHasAlpha: Boolean; + + { @return @true if the format has any color color channel, @false otherwise } function GetHasColor: Boolean; + + { @return @true if the format is a grayscale format, @false otherwise } function GetIsGrayscale: Boolean; protected - fFormat: TglBitmapFormat; - fWithAlpha: TglBitmapFormat; - fWithoutAlpha: TglBitmapFormat; - fOpenGLFormat: TglBitmapFormat; - fRGBInverted: TglBitmapFormat; - fUncompressed: TglBitmapFormat; + fFormat: TglBitmapFormat; //< format this descriptor belongs to + fWithAlpha: TglBitmapFormat; //< suitable format with alpha channel + fWithoutAlpha: TglBitmapFormat; //< suitable format without alpha channel + fOpenGLFormat: TglBitmapFormat; //< suitable format that is supported by OpenGL + fRGBInverted: TglBitmapFormat; //< suitable format with inverted RGB channels + fUncompressed: TglBitmapFormat; //< suitable format with uncompressed data - fBitsPerPixel: Integer; - fIsCompressed: Boolean; + fBitsPerPixel: Integer; //< number of bits per pixel + fIsCompressed: Boolean; //< @true if the format is compressed, @false otherwise - fPrecision: TglBitmapRec4ub; - fShift: TglBitmapRec4ub; + fPrecision: TglBitmapRec4ub; //< number of bits for each color channel + fShift: TglBitmapRec4ub; //< bit offset for each color channel - fglFormat: GLenum; - fglInternalFormat: GLenum; - fglDataFormat: GLenum; + fglFormat: GLenum; //< OpenGL format enum (e.g. GL_RGB) + fglInternalFormat: GLenum; //< OpenGL internal format enum (e.g. GL_RGB8) + fglDataFormat: GLenum; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE) + { set values for this format descriptor } procedure SetValues; virtual; + + { calculate cached values } procedure CalcValues; public - property Format: TglBitmapFormat read fFormat; - property ChannelCount: Integer read fChannelCount; - property IsCompressed: Boolean read fIsCompressed; - property BitsPerPixel: Integer read fBitsPerPixel; - property BytesPerPixel: Single read fBytesPerPixel; - - property Precision: TglBitmapRec4ub read fPrecision; - property Shift: TglBitmapRec4ub read fShift; - property Range: TglBitmapRec4ui read fRange; - property Mask: TglBitmapRec4ul read fMask; - - property RGBInverted: TglBitmapFormat read fRGBInverted; - property WithAlpha: TglBitmapFormat read fWithAlpha; - property WithoutAlpha: TglBitmapFormat read fWithAlpha; - property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; - property Uncompressed: TglBitmapFormat read fUncompressed; - - property glFormat: GLenum read fglFormat; - property glInternalFormat: GLenum read fglInternalFormat; - property glDataFormat: GLenum read fglDataFormat; - - property HasRed: Boolean read GetHasRed; - property HasGreen: Boolean read GetHasGreen; - property HasBlue: Boolean read GetHasBlue; - property HasAlpha: Boolean read GetHasAlpha; - property HasColor: Boolean read GetHasColor; - property IsGrayscale: Boolean read GetIsGrayscale; - + property Format: TglBitmapFormat read fFormat; //< format this descriptor belongs to + property ChannelCount: Integer read fChannelCount; //< number of color channels + property IsCompressed: Boolean read fIsCompressed; //< @true if the format is compressed, @false otherwise + property BitsPerPixel: Integer read fBitsPerPixel; //< number of bytes per pixel + property BytesPerPixel: Single read fBytesPerPixel; //< number of bits per pixel + + property Precision: TglBitmapRec4ub read fPrecision; //< number of bits for each color channel + property Shift: TglBitmapRec4ub read fShift; //< bit offset for each color channel + property Range: TglBitmapRec4ui read fRange; //< maximal value of each color channel + property Mask: TglBitmapRec4ul read fMask; //< bitmask for each color channel + + property RGBInverted: TglBitmapFormat read fRGBInverted; //< suitable format with inverted RGB channels + property WithAlpha: TglBitmapFormat read fWithAlpha; //< suitable format with alpha channel + property WithoutAlpha: TglBitmapFormat read fWithAlpha; //< suitable format without alpha channel + property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; //< suitable format that is supported by OpenGL + property Uncompressed: TglBitmapFormat read fUncompressed; //< suitable format with uncompressed data + + property glFormat: GLenum read fglFormat; //< OpenGL format enum (e.g. GL_RGB) + property glInternalFormat: GLenum read fglInternalFormat; //< OpenGL internal format enum (e.g. GL_RGB8) + property glDataFormat: GLenum read fglDataFormat; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE) + + property HasRed: Boolean read GetHasRed; //< @true if the format has a red color channel, @false otherwise + property HasGreen: Boolean read GetHasGreen; //< @true if the format has a green color channel, @false otherwise + property HasBlue: Boolean read GetHasBlue; //< @true if the format has a blue color channel, @false otherwise + property HasAlpha: Boolean read GetHasAlpha; //< @true if the format has a alpha color channel, @false otherwise + property HasColor: Boolean read GetHasColor; //< @true if the format has any color color channel, @false otherwise + property IsGrayscale: Boolean read GetIsGrayscale; //< @true if the format is a grayscale format, @false otherwise + + { constructor } constructor Create; public + { get the format descriptor by a given OpenGL internal format + @param aInternalFormat OpenGL internal format to get format descriptor for + @returns suitable format descriptor or tfEmpty-Descriptor } class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; end; //////////////////////////////////////////////////////////////////////////////////////////////////// + { structure to store pixel data in } TglBitmapPixelData = packed record - Data: TglBitmapRec4ui; - Range: TglBitmapRec4ui; - Format: TglBitmapFormat; + Data: TglBitmapRec4ui; //< color data for each color channel + Range: TglBitmapRec4ui; //< maximal color value for each channel + Format: TglBitmapFormat; //< format of the pixel end; PglBitmapPixelData = ^TglBitmapPixelData; - TglBitmapPixelPositionFields = set of (ffX, ffY); - TglBitmapPixelPosition = record - Fields : TglBitmapPixelPositionFields; - X : Word; - Y : Word; + TglBitmapSizeFields = set of (ffX, ffY); + TglBitmapSize = packed record + Fields: TglBitmapSizeFields; + X: Word; + Y: Word; end; + TglBitmapPixelPosition = TglBitmapSize; //////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class; + + { structure to store data for converting in } TglBitmapFunctionRec = record - Sender: TglBitmap; - Size: TglBitmapPixelPosition; - Position: TglBitmapPixelPosition; - Source: TglBitmapPixelData; - Dest: TglBitmapPixelData; - Args: Pointer; + Sender: TglBitmap; //< texture object that stores the data to convert + Size: TglBitmapSize; //< size of the texture + Position: TglBitmapPixelPosition; //< position of the currently pixel + Source: TglBitmapPixelData; //< pixel data of the current pixel + Dest: TglBitmapPixelData; //< new data of the pixel (must be filled in) + Args: Pointer; //< user defined args that was passed to the convert function end; + + { callback to use for converting texture data } TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { base class for all glBitmap classes. used to manage OpenGL texture objects + and to load, save and manipulate texture data } TglBitmap = class private + { @returns format descriptor that describes the format of the stored data } function GetFormatDesc: TglBitmapFormatDescriptor; protected - fID: GLuint; - fTarget: GLuint; - fAnisotropic: Integer; - fDeleteTextureOnFree: Boolean; - fFreeDataOnDestroy: Boolean; - fFreeDataAfterGenTexture: Boolean; - fData: PByte; + fID: GLuint; //< name of the OpenGL texture object + fTarget: GLuint; //< texture target (e.g. GL_TEXTURE_2D) + fAnisotropic: Integer; //< anisotropic level + fDeleteTextureOnFree: Boolean; //< delete OpenGL texture object when this object is destroyed + fFreeDataOnDestroy: Boolean; //< free stored data when this object is destroyed + fFreeDataAfterGenTexture: Boolean; //< free stored data after data was uploaded to video card + fData: PByte; //< data of this texture {$IFNDEF OPENGL_ES} - fIsResident: GLboolean; + fIsResident: GLboolean; //< @true if OpenGL texture object has data, @false otherwise {$ENDIF} - fBorderColor: array[0..3] of Single; + fBorderColor: array[0..3] of Single; //< color of the texture border - fDimension: TglBitmapPixelPosition; - fMipMap: TglBitmapMipMap; - fFormat: TglBitmapFormat; + fDimension: TglBitmapSize; //< size of this texture + fMipMap: TglBitmapMipMap; //< mipmap type + fFormat: TglBitmapFormat; //< format the texture data is stored in // Mapping - fPixelSize: Integer; - fRowSize: Integer; + fPixelSize: Integer; //< size of one pixel (in byte) + fRowSize: Integer; //< size of one pixel row (in byte) // Filtering - fFilterMin: GLenum; - fFilterMag: GLenum; + fFilterMin: GLenum; //< min filter to apply to the texture + fFilterMag: GLenum; //< mag filter to apply to the texture // TexturWarp - fWrapS: GLenum; - fWrapT: GLenum; - fWrapR: GLenum; + fWrapS: GLenum; //< texture wrapping for x axis + fWrapT: GLenum; //< texture wrapping for y axis + fWrapR: GLenum; //< texture wrapping for z axis {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} //Swizzle - fSwizzle: array[0..3] of GLenum; + fSwizzle: array[0..3] of GLenum; //< color channel swizzle {$IFEND} // CustomData - fFilename: String; - fCustomName: String; - fCustomNameW: WideString; - fCustomData: Pointer; + fFilename: String; //< filename the texture was load from + fCustomName: String; //< user defined name + fCustomNameW: WideString; //< user defined name + fCustomData: Pointer; //< user defined data - //Getter + protected + { @returns the actual width of the texture } function GetWidth: Integer; virtual; + + { @returns the actual height of the texture } function GetHeight: Integer; virtual; + { @returns the width of the texture or 1 if the width is zero } function GetFileWidth: Integer; virtual; + + { @returns the height of the texture or 1 if the height is zero } function GetFileHeight: Integer; virtual; - //Setter + protected + { set a new value for fCustomData } procedure SetCustomData(const aValue: Pointer); + + { set a new value for fCustomName } procedure SetCustomName(const aValue: String); + + { set a new value for fCustomNameW } procedure SetCustomNameW(const aValue: WideString); + + { set new value for fFreeDataOnDestroy } procedure SetFreeDataOnDestroy(const aValue: Boolean); + + { set new value for fDeleteTextureOnFree } procedure SetDeleteTextureOnFree(const aValue: Boolean); + + { set new value for the data format. only possible if new format has the same pixel size. + if you want to convert the texture data, see ConvertTo function } procedure SetFormat(const aValue: TglBitmapFormat); + + { set new value for fFreeDataAfterGenTexture } procedure SetFreeDataAfterGenTexture(const aValue: Boolean); + + { set name of OpenGL texture object } procedure SetID(const aValue: Cardinal); + + { set new value for fMipMap } procedure SetMipMap(const aValue: TglBitmapMipMap); + + { set new value for target } procedure SetTarget(const aValue: Cardinal); + + { set new value for fAnisotrophic } procedure SetAnisotropic(const aValue: Integer); + protected + { create OpenGL texture object (delete exisiting object if exists) } procedure CreateID; + + { setup texture parameters } procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); + + { set data pointer of texture data + @param aData pointer to new texture data (be carefull, aData could be freed by this function) + @param aFormat format of the data stored at aData + @param aWidth width of the texture data + @param aHeight height of the texture data } procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; //be careful, aData could be freed by this method + const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; + + { generate texture (upload texture data to video card) + @param aTestTextureSize test texture size before uploading and raise exception if something is wrong } procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract; + { flip texture horizontal + @returns @true in success, @false otherwise } function FlipHorz: Boolean; virtual; + + { flip texture vertical + @returns @true in success, @false otherwise } function FlipVert: Boolean; virtual; - property Width: Integer read GetWidth; - property Height: Integer read GetHeight; + protected + property Width: Integer read GetWidth; //< the actual width of the texture + property Height: Integer read GetHeight; //< the actual height of the texture - property FileWidth: Integer read GetFileWidth; - property FileHeight: Integer read GetFileHeight; + property FileWidth: Integer read GetFileWidth; //< the width of the texture or 1 if the width is zero + property FileHeight: Integer read GetFileHeight; //< the height of the texture or 1 if the height is zero public - //Properties - property ID: Cardinal read fID write SetID; - property Target: Cardinal read fTarget write SetTarget; - property Format: TglBitmapFormat read fFormat write SetFormat; - property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; - property Anisotropic: Integer read fAnisotropic write SetAnisotropic; - - property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; - - property Filename: String read fFilename; - property CustomName: String read fCustomName write SetCustomName; - property CustomNameW: WideString read fCustomNameW write SetCustomNameW; - property CustomData: Pointer read fCustomData write SetCustomData; - - property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; - property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; - property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; - - property Dimension: TglBitmapPixelPosition read fDimension; - property Data: PByte read fData; + property ID: Cardinal read fID write SetID; //< name of the OpenGL texture object + property Target: Cardinal read fTarget write SetTarget; //< texture target (e.g. GL_TEXTURE_2D) + property Format: TglBitmapFormat read fFormat write SetFormat; //< format the texture data is stored in + property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; //< mipmap type + property Anisotropic: Integer read fAnisotropic write SetAnisotropic; //< anisotropic level + + property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; //< format descriptor that describes the format of the stored data + + property Filename: String read fFilename; //< filename the texture was load from + property CustomName: String read fCustomName write SetCustomName; //< user defined name (use at will) + property CustomNameW: WideString read fCustomNameW write SetCustomNameW; //< user defined name (as WideString; use at will) + property CustomData: Pointer read fCustomData write SetCustomData; //< user defined data (use at will) + + property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; //< delete texture object when this object is destroyed + property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; //< free stored data when this object is destroyed + property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; //< free stored data after it is uplaoded to video card + + property Dimension: TglBitmapSize read fDimension; //< size of the texture + property Data: PByte read fData; //< texture data (or @nil if unset) {$IFNDEF OPENGL_ES} - property IsResident: GLboolean read fIsResident; + property IsResident: GLboolean read fIsResident; //< @true if OpenGL texture object has data, @false otherwise {$ENDIF} + { this method is called after the constructor and sets the default values of this object } procedure AfterConstruction; override; + + { this method is called before the destructor and does some cleanup } procedure BeforeDestruction; override; + { splits a resource identifier into the resource and it's type + @param aResource resource identifier to split and store name in + @param aResType type of the resource } procedure PrepareResType(var aResource: String; var aResType: PChar); - //Load + public + { load a texture from a file + @param aFilename file to load texuture from } procedure LoadFromFile(const aFilename: String); + + { load a texture from a stream + @param aStream stream to load texture from } procedure LoadFromStream(const aStream: TStream); virtual; - procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; + + { use a function to generate texture data + @param aSize size of the texture + @param aFunc callback to use for generation + @param aFormat format of the texture data + @param aArgs user defined paramaters (use at will) } + procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil); + + { load a texture from a resource + @param aInstance resource handle + @param aResource resource indentifier + @param aResType resource type (if known) } procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil); + + { load a texture from a resource id + @param aInstance resource handle + @param aResource resource ID + @param aResType resource type } procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); - //Save - procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); + public + { save texture data to a file + @param aFilename filename to store texture in + @param aFileType file type to store data into } + procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType); + + { save texture data to a stream + @param aFilename filename to store texture in + @param aFileType file type to store data into } procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual; - //Convert - function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload; - function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; + public + { convert texture data using a user defined callback + @param aFunc callback to use for converting + @param aCreateTemp create a temporary buffer to use for converting + @param aArgs user defined paramters (use at will) + @returns @true if converting was successful, @false otherwise } + function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload; + + { convert texture data using a user defined callback + @param aSource glBitmap to read data from + @param aFunc callback to use for converting + @param aCreateTemp create a temporary buffer to use for converting + @param aFormat format of the new data + @param aArgs user defined paramters (use at will) + @returns @true if converting was successful, @false otherwise } + function Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload; + + { convert texture data using a specific format + @param aFormat new format of texture data + @returns @true if converting was successful, @false otherwise } + function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; + +{$IFDEF GLB_SDL} public - //Alpha & Co - {$IFDEF GLB_SDL} + { assign texture data to SDL surface + @param aSurface SDL surface to write data to + @returns @true on success, @false otherwise } function AssignToSurface(out aSurface: PSDL_Surface): Boolean; + + { assign texture data from SDL surface + @param aSurface SDL surface to read data from + @returns @true on success, @false otherwise } function AssignFromSurface(const aSurface: PSDL_Surface): Boolean; + + { assign alpha channel data to SDL surface + @param aSurface SDL surface to write alpha channel data to + @returns @true on success, @false otherwise } function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; - function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - {$IFDEF GLB_DELPHI} + { assign alpha channel data from SDL surface + @param aSurface SDL surface to read data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } + function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; +{$ENDIF} + +{$IFDEF GLB_DELPHI} + public + { assign texture data to TBitmap object + @param aBitmap TBitmap to write data to + @returns @true on success, @false otherwise } function AssignToBitmap(const aBitmap: TBitmap): Boolean; + + { assign texture data from TBitmap object + @param aBitmap TBitmap to read data from + @returns @true on success, @false otherwise } function AssignFromBitmap(const aBitmap: TBitmap): Boolean; + + { assign alpha channel data to TBitmap object + @param aBitmap TBitmap to write data to + @returns @true on success, @false otherwise } function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; - function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - {$IFDEF GLB_LAZARUS} + { assign alpha channel data from TBitmap object + @param aBitmap TBitmap to read data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } + function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; +{$ENDIF} + +{$IFDEF GLB_LAZARUS} + public + { assign texture data to TLazIntfImage object + @param aImage TLazIntfImage to write data to + @returns @true on success, @false otherwise } function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; + + { assign texture data from TLazIntfImage object + @param aImage TLazIntfImage to read data from + @returns @true on success, @false otherwise } function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; + + { assign alpha channel data to TLazIntfImage object + @param aImage TLazIntfImage to write data to + @returns @true on success, @false otherwise } function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; - function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; - const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + { assign alpha channel data from TLazIntfImage object + @param aImage TLazIntfImage to read data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } + function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; +{$ENDIF} + public + { load alpha channel data from resource + @param aInstance resource handle + @param aResource resource ID + @param aResType resource type + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } + function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + { load alpha channel data from resource ID + @param aInstance resource handle + @param aResourceID resource ID + @param aResType resource type + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } + function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + { add alpha channel data from function + @param aFunc callback to get data from + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual; + + { add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap) + @param aFilename file to load alpha channel data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + { add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap) + @param aStream stream to load alpha channel data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + { add alpha channel data from existing glBitmap object + @param aBitmap TglBitmap to copy alpha channel data from + @param aFunc callback to use for converting + @param aArgs user defined parameters (use at will) + @returns @true on success, @false otherwise } function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + { add alpha to pixel if the pixels color is greter than the given color value + @param aRed red threshold (0-255) + @param aGreen green threshold (0-255) + @param aBlue blue threshold (0-255) + @param aDeviatation accepted deviatation (0-255) + @returns @true on success, @false otherwise } function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean; + + { add alpha to pixel if the pixels color is greter than the given color value + @param aRed red threshold (0-Range.r) + @param aGreen green threshold (0-Range.g) + @param aBlue blue threshold (0-Range.b) + @param aDeviatation accepted deviatation (0-max(Range.rgb)) + @returns @true on success, @false otherwise } function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean; + + { add alpha to pixel if the pixels color is greter than the given color value + @param aRed red threshold (0.0-1.0) + @param aGreen green threshold (0.0-1.0) + @param aBlue blue threshold (0.0-1.0) + @param aDeviatation accepted deviatation (0.0-1.0) + @returns @true on success, @false otherwise } function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean; + { add a constand alpha value to all pixels + @param aAlpha alpha value to add (0-255) + @returns @true on success, @false otherwise } function AddAlphaFromValue(const aAlpha: Byte): Boolean; + + { add a constand alpha value to all pixels + @param aAlpha alpha value to add (0-max(Range.rgb)) + @returns @true on success, @false otherwise } function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; + + { add a constand alpha value to all pixels + @param aAlpha alpha value to add (0.0-1.0) + @returns @true on success, @false otherwise } function AddAlphaFromValueFloat(const aAlpha: Single): Boolean; + { remove alpha channel + @returns @true on success, @false otherwise } function RemoveAlpha: Boolean; virtual; + public - //Common + { create a clone of the current object + @returns clone of this object} function Clone: TglBitmap; - function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; + + { invert color data (xor) + @param aUseRGB xor each color channel + @param aUseAlpha xor alpha channel } procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false); + + { free texture stored data } + procedure FreeData; + {$IFNDEF OPENGL_ES} + { set the new value for texture border color + @param aRed red color for border (0.0-1.0) + @param aGreen green color for border (0.0-1.0) + @param aBlue blue color for border (0.0-1.0) + @param aAlpha alpha color for border (0.0-1.0) } procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); {$ENDIF} - procedure FreeData; - //ColorFill + public + { fill complete texture with one color + @param aRed red color for border (0-255) + @param aGreen green color for border (0-255) + @param aBlue blue color for border (0-255) + @param aAlpha alpha color for border (0-255) } procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255); + + { fill complete texture with one color + @param aRed red color for border (0-Range.r) + @param aGreen green color for border (0-Range.g) + @param aBlue blue color for border (0-Range.b) + @param aAlpha alpha color for border (0-Range.a) } procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF); - procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1); - //TexParameters + { fill complete texture with one color + @param aRed red color for border (0.0-1.0) + @param aGreen green color for border (0.0-1.0) + @param aBlue blue color for border (0.0-1.0) + @param aAlpha alpha color for border (0.0-1.0) } + procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0); + + public + { set new texture filer + @param aMin min filter + @param aMag mag filter } procedure SetFilter(const aMin, aMag: GLenum); + + { set new texture wrapping + @param S texture wrapping for x axis + @param T texture wrapping for y axis + @param R texture wrapping for z axis } procedure SetWrap( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE); + {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + { set new swizzle + @param r swizzle for red channel + @param g swizzle for green channel + @param b swizzle for blue channel + @param a swizzle for alpha channel } procedure SetSwizzle(const r, g, b, a: GLenum); {$IFEND} + public + { bind texture + @param aEnableTextureUnit enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; + + { bind texture + @param aDisableTextureUnit disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; - //Constructors + public + { constructor - created an empty texture } constructor Create; overload; + + { constructor - creates a texture and load it from a file + @param aFilename file to load texture from } constructor Create(const aFileName: String); overload; + + { constructor - creates a texture and load it from a stream + @param aStream stream to load texture from } constructor Create(const aStream: TStream); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; + + { constructor - creates a texture with the given size, format and data + @param aSize size of the texture + @param aFormat format of the given data + @param aData texture data - be carefull: the data will now be managed by the glBitmap object, + you can control this by setting DeleteTextureOnFree, FreeDataOnDestroy and FreeDataAfterGenTexture } + constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; + + { constructor - creates a texture with the given size and format and uses the given callback to create the data + @param aSize size of the texture + @param aFormat format of the given data + @param aFunc callback to use for generating the data + @param aArgs user defined parameters (use at will) } + constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; + + { constructor - creates a texture and loads it from a resource + @param aInstance resource handle + @param aResource resource indentifier + @param aResType resource type (if known) } constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload; + + { constructor - creates a texture and loads it from a resource + @param aInstance resource handle + @param aResourceID resource ID + @param aResType resource type (if known) } constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload; + private - {$IFDEF GLB_SUPPORT_PNG_READ} function LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF} - {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF} +{$IFDEF GLB_SUPPORT_PNG_READ} + { try to load a PNG from a stream + @param aStream stream to load PNG from + @returns @true on success, @false otherwise } + function LoadPNG(const aStream: TStream): Boolean; virtual; +{$ENDIF} + +{$ifdef GLB_SUPPORT_PNG_WRITE} + { save texture data as PNG to stream + @param aStream stream to save data to} + procedure SavePNG(const aStream: TStream); virtual; +{$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_READ} function LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF} +{$IFDEF GLB_SUPPORT_JPEG_READ} + { try to load a JPEG from a stream + @param aStream stream to load JPEG from + @returns @true on success, @false otherwise } + function LoadJPEG(const aStream: TStream): Boolean; virtual; +{$ENDIF} + +{$IFDEF GLB_SUPPORT_JPEG_WRITE} + { save texture data as JPEG to stream + @param aStream stream to save data to} + procedure SaveJPEG(const aStream: TStream); virtual; +{$ENDIF} + { try to load a RAW image from a stream + @param aStream stream to load RAW image from + @returns @true on success, @false otherwise } function LoadRAW(const aStream: TStream): Boolean; + + { save texture data as RAW image to stream + @param aStream stream to save data to} procedure SaveRAW(const aStream: TStream); + { try to load a BMP from a stream + @param aStream stream to load BMP from + @returns @true on success, @false otherwise } function LoadBMP(const aStream: TStream): Boolean; + + { save texture data as BMP to stream + @param aStream stream to save data to} procedure SaveBMP(const aStream: TStream); + { try to load a TGA from a stream + @param aStream stream to load TGA from + @returns @true on success, @false otherwise } function LoadTGA(const aStream: TStream): Boolean; + + { save texture data as TGA to stream + @param aStream stream to save data to} procedure SaveTGA(const aStream: TStream); + { try to load a DDS from a stream + @param aStream stream to load DDS from + @returns @true on success, @false otherwise } function LoadDDS(const aStream: TStream): Boolean; + + { save texture data as DDS to stream + @param aStream stream to save data to} procedure SaveDDS(const aStream: TStream); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{$IFNDEF OPENGL_ES} +{$IF NOT DEFINED(OPENGL_ES)} + { wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D } TglBitmap1D = class(TglBitmap) protected - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + { set data pointer of texture data + @param aData pointer to new texture data (be carefull, aData could be freed by this function) + @param aFormat format of the data stored at aData + @param aWidth width of the texture data + @param aHeight height of the texture data } + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + + { upload the texture data to video card + @param aBuildWithGlu use glu functions to build mipmaps } procedure UploadData(const aBuildWithGlu: Boolean); public - property Width; + property Width; //< actual with of the texture + + { this method is called after constructor and initializes the object } procedure AfterConstruction; override; + + { flip texture horizontally + @returns @true on success, @fals otherwise } function FlipHorz: Boolean; override; + + { generate texture (create texture object if not exist, set texture parameters and upload data + @param aTestTextureSize check the size of the texture and throw exception if something is wrong } procedure GenTexture(const aTestTextureSize: Boolean = true); override; end; -{$ENDIF} +{$IFEND} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) } TglBitmap2D = class(TglBitmap) protected - fLines: array of PByte; + fLines: array of PByte; //< array to store scanline entry points in + + { get a specific scanline + @param aIndex index of the scanline to return + @returns scanline at position aIndex or @nil } function GetScanline(const aIndex: Integer): Pointer; + + { set data pointer of texture data + @param aData pointer to new texture data (be carefull, aData could be freed by this function) + @param aFormat format of the data stored at aData + @param aWidth width of the texture data + @param aHeight height of the texture data } procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + + { upload the texture data to video card + @param aTarget target o upload data to (e.g. GL_TEXTURE_2D) + @param aBuildWithGlu use glu functions to build mipmaps } procedure UploadData(const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); public - property Width; - property Height; - property Scanline[const aIndex: Integer]: Pointer read GetScanline; + property Width; //< actual width of the texture + property Height; //< actual height of the texture + property Scanline[const aIndex: Integer]: Pointer read GetScanline; //< scanline to access texture data directly + { this method is called after constructor and initializes the object } procedure AfterConstruction; override; + { copy a part of the frame buffer top the texture + @param aTop topmost pixel to copy + @param aLeft leftmost pixel to copy + @param aRight rightmost pixel to copy + @param aBottom bottommost pixel to copy + @param aFormat format to store data in } procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); + {$IFNDEF OPENGL_ES} + { downlaod texture data from OpenGL texture object } procedure GetDataFromTexture; {$ENDIF} + + { generate texture (create texture object if not exist, set texture parameters and upload data) + @param aTestTextureSize check the size of the texture and throw exception if something is wrong } procedure GenTexture(const aTestTextureSize: Boolean = true); override; + { flip texture horizontally + @returns @true on success, @false otherwise } function FlipHorz: Boolean; override; + + { flip texture vertically + @returns @true on success, @false otherwise } function FlipVert: Boolean; override; - procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; + { create normal map from texture data + @param aFunc normal map function to generate normalmap with + @param aScale scale of the normale stored in the normal map + @param aUseAlpha generate normalmap from alpha channel data (if present) } + procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} + { wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) } TglBitmapCubeMap = class(TglBitmap2D) protected {$IFNDEF OPENGL_ES} - fGenMode: Integer; + fGenMode: Integer; //< generation mode for the cube map (e.g. GL_REFLECTION_MAP) {$ENDIF} + + { generate texture (create texture object if not exist, set texture parameters and upload data + do not call directly for cubemaps, use GenerateCubeMap instead + @param aTestTextureSize check the size of the texture and throw exception if something is wrong } procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; public + { this method is called after constructor and initializes the object } procedure AfterConstruction; override; + + { generate texture (create texture object if not exist, set texture parameters and upload data + @param aCubeTarget cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X) + @param aTestTextureSize check the size of the texture and throw exception if something is wrong } procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); + + { bind texture + @param aEnableTexCoordsGen enable cube map generator + @param aEnableTextureUnit enable texture unit } procedure Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean = true;{$ENDIF} const aEnableTextureUnit: Boolean = true); reintroduce; virtual; + + { unbind texture + @param aDisableTexCoordsGen disable cube map generator + @param aDisableTextureUnit disable texture unit } procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean = true;{$ENDIF} const aDisableTextureUnit: Boolean = true); reintroduce; virtual; end; {$IFEND} {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { wrapper class for cube normal maps } TglBitmapNormalMap = class(TglBitmapCubeMap) public + { this method is called after constructor and initializes the object } procedure AfterConstruction; override; + + { create cube normal map from texture data and upload it to video card + @param aSize size of each cube map texture + @param aTestTextureSize check texture size when uploading and throw exception if something is wrong } procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); end; {$IFEND} const - NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0); + NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0); procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean); procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean); @@ -1332,13 +1595,21 @@ procedure glBitmapSetDefaultWrap( const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} +procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA); +{$IFEND} + function glBitmapGetDefaultDeleteTextureOnFree: Boolean; function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean; function glBitmapGetDefaultMipmap: TglBitmapMipMap; function glBitmapGetDefaultFormat: TglBitmapFormat; procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal); procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} +procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); +{$IFEND} +function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize; function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition; function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui; @@ -1348,6 +1619,17 @@ function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +{$IFDEF GLB_DELPHI} +function CreateGrayPalette: HPALETTE; +{$ENDIF} + +implementation + +uses + Math, syncobjs, typinfo + {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; + + var glBitmapDefaultDeleteTextureOnFree: Boolean; glBitmapDefaultFreeDataAfterGenTextures: Boolean; @@ -1360,16 +1642,6 @@ var glBitmapDefaultWrapR: Cardinal; glDefaultSwizzle: array[0..3] of GLenum; -{$IFDEF GLB_DELPHI} -function CreateGrayPalette: HPALETTE; -{$ENDIF} - -implementation - -uses - Math, syncobjs, typinfo - {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; - //////////////////////////////////////////////////////////////////////////////////////////////////// type TFormatDescriptor = class(TglBitmapFormatDescriptor) @@ -1377,7 +1649,7 @@ type procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; - function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual; + function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual; function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; function CreateMappingData: Pointer; virtual; @@ -1895,20 +2167,24 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition; +function glBitmapSize(X: Integer; Y: Integer): TglBitmapSize; begin result.Fields := []; - - if X >= 0 then + if (X >= 0) then result.Fields := result.Fields + [ffX]; - if Y >= 0 then + if (Y >= 0) then result.Fields := result.Fields + [ffY]; - result.X := Max(0, X); result.Y := Max(0, Y); end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition; +begin + result := glBitmapSize(X, Y); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; begin result.r := r; @@ -2477,7 +2753,7 @@ begin R := glBitmapDefaultWrapR; end; -{$IFNDEF OPENGL_ES} +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); begin @@ -2491,7 +2767,7 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; +function TFormatDescriptor.GetSize(const aSize: TglBitmapSize): Integer; var w, h: Integer; begin @@ -4989,7 +5265,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; +procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer); var tmpData: PByte; @@ -5005,7 +5281,7 @@ begin FreeMem(tmpData); raise; end; - AddFunc(Self, aFunc, false, aFormat, aArgs); + Convert(Self, aFunc, false, aFormat, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5036,7 +5312,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); +procedure TglBitmap.SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType); var fs: TFileStream; begin @@ -5067,13 +5343,13 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; +function TglBitmap.Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; begin - result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs); + result := Convert(Self, aFunc, aCreateTemp, Format, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; +function TglBitmap.Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean; var DestData, TmpData, SourceData: pByte; @@ -5158,6 +5434,73 @@ begin end; end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean; +var + SourceFD, DestFD: TFormatDescriptor; + SourcePD, DestPD: TglBitmapPixelData; + ShiftData: TShiftData; + + function DataIsIdentical: Boolean; + begin + result := SourceFD.MaskMatch(DestFD.Mask); + end; + + function CanCopyDirect: Boolean; + begin + result := + ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + end; + + function CanShift: Boolean; + begin + result := + ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + end; + + function GetShift(aSource, aDest: Cardinal) : ShortInt; + begin + result := 0; + while (aSource > aDest) and (aSource > 0) do begin + inc(result); + aSource := aSource shr 1; + end; + end; + +begin + if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin + SourceFD := TFormatDescriptor.Get(Format); + DestFD := TFormatDescriptor.Get(aFormat); + + if DataIsIdentical then begin + result := true; + Format := aFormat; + exit; + end; + + SourceFD.PreparePixel(SourcePD); + DestFD.PreparePixel (DestPD); + + if CanCopyDirect then + result := Convert(Self, glBitmapConvertCopyFunc, false, aFormat) + else if CanShift then begin + ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); + ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); + ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); + ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); + result := Convert(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); + end else + result := Convert(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); + end else + result := true; +end; + {$IFDEF GLB_SDL} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AssignToSurface(out aSurface: PSDL_Surface): Boolean; @@ -5755,7 +6098,7 @@ function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: begin if TFormatDescriptor.Get(Format).IsCompressed then raise EglBitmapUnsupportedFormat.Create(Format); - result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); + result := Convert(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5990,81 +6333,23 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean; -var - SourceFD, DestFD: TFormatDescriptor; - SourcePD, DestPD: TglBitmapPixelData; - ShiftData: TShiftData; - - function DataIsIdentical: Boolean; - begin - result := SourceFD.MaskMatch(DestFD.Mask); - end; - - function CanCopyDirect: Boolean; - begin - result := - ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); - end; - - function CanShift: Boolean; - begin - result := - ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); - end; - - function GetShift(aSource, aDest: Cardinal) : ShortInt; - begin - result := 0; - while (aSource > aDest) and (aSource > 0) do begin - inc(result); - aSource := aSource shr 1; - end; - end; - -begin - if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin - SourceFD := TFormatDescriptor.Get(Format); - DestFD := TFormatDescriptor.Get(aFormat); - - if DataIsIdentical then begin - result := true; - Format := aFormat; - exit; - end; - - SourceFD.PreparePixel(SourcePD); - DestFD.PreparePixel (DestPD); - - if CanCopyDirect then - result := AddFunc(Self, glBitmapConvertCopyFunc, false, aFormat) - else if CanShift then begin - ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); - ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); - ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); - ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); - result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); - end else - result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); - end else - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); begin if aUseRGB or aUseAlpha then - AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( + Convert(glBitmapInvertFunc, false, {%H-}Pointer( ((Byte(aUseAlpha) and 1) shl 1) or (Byte(aUseRGB) and 1) )); end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.FreeData; +var + TempPtr: PByte; +begin + TempPtr := nil; + SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method +end; + {$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); @@ -6081,15 +6366,6 @@ end; {$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FreeData; -var - TempPtr: PByte; -begin - TempPtr := nil; - SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte); begin @@ -6121,7 +6397,7 @@ begin Data.b := Max(0, Min(Range.b, Trunc(Range.b aBlue))); Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha))); end; - AddFunc(glBitmapFillWithColorFunc, false, @PixelData); + Convert(glBitmapFillWithColorFunc, false, @PixelData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -6324,7 +6600,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte); +constructor TglBitmap.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte); var ImageSize: Integer; begin @@ -6342,12 +6618,11 @@ begin end; end else begin SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - fFreeDataOnDestroy := false; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); +constructor TglBitmap.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); begin Create; LoadFromFunc(aSize, aFunc, aFormat, aArgs); @@ -8870,7 +9145,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.ToNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean); +procedure TglBitmap2D.GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean); var Rec: TglBitmapToNormalMapRec; @@ -8992,10 +9267,10 @@ begin // Daten Sammeln if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then - AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) + Convert(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) else - AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec); - AddFunc(glBitmapToNormalMapFunc, false, @Rec); + Convert(glBitmapToNormalMapPrepareFunc, false, @Rec); + Convert(glBitmapToNormalMapFunc, false, @Rec); finally SetLength(Rec.Heights, 0); end; @@ -9198,7 +9473,7 @@ end; procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); var Rec: TglBitmapNormalMapRec; - SizeRec: TglBitmapPixelPosition; + SizeRec: TglBitmapSize; begin Rec.HalfSize := aSize div 2; FreeDataAfterGenTexture := false; diff --git a/readme.txt b/readme.txt new file mode 100644 index 0000000..0d5f495 --- /dev/null +++ b/readme.txt @@ -0,0 +1,229 @@ +glBitmap by Steffen Xonna aka Lossy eX (2003-2008) +http://www.opengl24.de/index.php?cat=header&file=glbitmap + +modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + +------------------------------------------------------------ +The contents of this file are used with permission, subject to +the Mozilla Public License Version 1.1 (the "License"); you may +not use this file except in compliance with the License. You may +obtain a copy of the License at +http://www.mozilla.org/MPL/MPL-1.1.html +------------------------------------------------------------ +The glBitmap is a Delphi/FPC unit that contains several wrapper classes +to manage OpenGL texture objects. Below you can find a list of the main +functionality of this classes: +- load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) +- load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) +- save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) +- save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) +- support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) +- manage texture properties (e.g. Filter, Clamp, Mipmap, ...) +- upload texture data to video card +- download texture data from video card +- manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...) +------------------------------------------------------------ +History +20-11-2013 +- refactoring of the complete library +- glBitmap is managed by git, so this history is not maintenanced any longer +21-03-2010 +- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi + then it's your problem if that isn't true. This prevents the unit for incompatibility + with newer versions of Delphi. +- Problems with D2009+ resolved (Thanks noeska and all i forgot) +- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson) +10-08-2008 +- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson) +- Additional Datapointer for functioninterface now has the name CustomData +24-07-2008 +- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson) +- If you load an texture from an file the property Filename will be set to the name of the file +- Three new properties to attach custom data to the Texture objects + - CustomName (free for use string) + - CustomNameW (free for use widestring) + - CustomDataPointer (free for use pointer to attach other objects or complex structures) +27-05-2008 +- RLE TGAs loaded much faster +26-05-2008 +- fixed some problem with reading RLE TGAs. +21-05-2008 +- function clone now only copys data if it's assigned and now it also copies the ID +- it seems that lazarus dont like comments in comments. +01-05-2008 +- It's possible to set the id of the texture +- define GLB_NO_NATIVE_GL deactivated by default +27-04-2008 +- Now supports the following libraries + - SDL and SDL_image + - libPNG + - libJPEG +- Linux compatibillity via free pascal compatibility (delphi sources optional) +- BMPs now loaded manuel +- Large restructuring +- Property DataPtr now has the name Data +- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR +- Unused Depth removed +- Function FreeData to freeing image data added +24-10-2007 +- ImageID flag of TGAs was ignored. (Thanks Zwoetzen) +15-11-2006 +- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER) +- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel +- Function ReadOpenGLExtension is now only intern +29-06-2006 +- pngimage now disabled by default like all other versions. +26-06-2006 +- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi) +22-06-2006 +- Fixed some Problem with Delphi 5 +- Now uses the newest version of pngimage. Makes saving pngs much easier. +22-03-2006 +- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi) +09-03-2006 +- Internal Format ifDepth8 added +- function GrabScreen now supports all uncompressed formats +31-01-2006 +- AddAlphaFromglBitmap implemented +29-12-2005 +- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID) +28-12-2005 +- Width, Height and Depth internal changed to TglBitmapPixelPosition. + property Width, Height, Depth are still existing and new property Dimension are avail +11-12-2005 +- Added native OpenGL Support. Breaking the dglOpenGL "barrier". +19-10-2005 +- Added function GrabScreen to class TglBitmap2D +18-10-2005 +- Added support to Save images +- Added function Clone to Clone Instance +11-10-2005 +- Functions now works with Cardinals for each channel. Up to 32 Bits per channel. + Usefull for Future +- Several speed optimizations +09-10-2005 +- Internal structure change. Loading of TGA, PNG and DDS improved. + Data, format and size will now set directly with SetDataPtr. +- AddFunc now works with all Types of Images and Formats +- Some Funtions moved to Baseclass TglBitmap +06-10-2005 +- Added Support to decompress DXT3 and DXT5 compressed Images. +- Added Mapping to convert data from one format into an other. +05-10-2005 +- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every + supported Input format (supported by GetPixel) into any uncompresed Format +- Added Support to decompress DXT1 compressed Images. +- SwapColors replaced by ConvertTo +04-10-2005 +- Added Support for compressed DDSs +- Added new internal formats (DXT1, DXT3, DXT5) +29-09-2005 +- Parameter Components renamed to InternalFormat +23-09-2005 +- Some AllocMem replaced with GetMem (little speed change) +- better exception handling. Better protection from memory leaks. +22-09-2005 +- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only) +- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5) +07-09-2005 +- Added support for Grayscale textures +- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8) +10-07-2005 +- Added support for GL_VERSION_2_0 +- Added support for GL_EXT_texture_filter_anisotropic +04-07-2005 +- Function FillWithColor fills the Image with one Color +- Function LoadNormalMap added +30-06-2005 +- ToNormalMap allows to Create an NormalMap from the Alphachannel +- ToNormalMap now supports Sobel (nmSobel) function. +29-06-2005 +- support for RLE Compressed RGB TGAs added +28-06-2005 +- Class TglBitmapNormalMap added to support Normalmap generation +- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures. + 3 Filters are supported. (4 Samples, 3x3 and 5x5) +16-06-2005 +- Method LoadCubeMapClass removed +- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures +- virtual abstract method GenTexture in class TglBitmap now is protected +12-06-2005 +- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal +10-06-2005 +- little enhancement for IsPowerOfTwo +- TglBitmap1D.GenTexture now tests NPOT Textures +06-06-2005 +- some little name changes. All properties or function with Texture in name are + now without texture in name. We have allways texture so we dosn't name it. +03-06-2005 +- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or + TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception. +02-06-2005 +- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle +25-04-2005 +- Function Unbind added +- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture. +21-04-2005 +- class TglBitmapCubeMap added (allows to Create Cubemaps) +29-03-2005 +- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/) + To Enable png's use the define pngimage +22-03-2005 +- New Functioninterface added +- Function GetPixel added +27-11-2004 +- Property BuildMipMaps renamed to MipMap +21-11-2004 +- property Name removed. +- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap +22-05-2004 +- property name added. Only used in glForms! +26-11-2003 +- property FreeDataAfterGenTexture is now available as default (default = true) +- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it) +- function MoveMemory replaced with function Move (little speed change) +- several calculations stored in variables (little speed change) +29-09-2003 +- property BuildMipsMaps added (default = true) + if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps +- property FreeDataAfterGenTexture added (default = true) + if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated. +- parameter DisableOtherTextureUnits of Bind removed +- parameter FreeDataAfterGeneration of GenTextures removed +12-09-2003 +- TglBitmap dosn't delete data if class was destroyed (fixed) +09-09-2003 +- Bind now enables TextureUnits (by params) +- GenTextures can leave data (by param) +- LoadTextures now optimal +03-09-2003 +- Performance optimization in AddFunc +- procedure Bind moved to subclasses +- Added new Class TglBitmap1D to support real OpenGL 1D Textures +19-08-2003 +- Texturefilter and texturewrap now also as defaults + Minfilter = GL_LINEAR_MIPMAP_LINEAR + Magfilter = GL_LINEAR + Wrap(str) = GL_CLAMP_TO_EDGE +- Added new format tfCompressed to create a compressed texture. +- propertys IsCompressed, TextureSize and IsResident added + IsCompressed and TextureSize only contains data from level 0 +18-08-2003 +- Added function AddFunc to add PerPixelEffects to Image +- LoadFromFunc now based on AddFunc +- Invert now based on AddFunc +- SwapColors now based on AddFunc +16-08-2003 +- Added function FlipHorz +15-08-2003 +- Added function LaodFromFunc to create images with function +- Added function FlipVert +- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported +29-07-2003 +- Added Alphafunctions to calculate alpha per function +- Added Alpha from ColorKey using alphafunctions +28-07-2003 +- First full functionally Version of glBitmap +- Support for 24Bit and 32Bit TGA Pictures added +25-07-2003 +- begin of programming