mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-15 15:55:53 +01:00
20647 lines
1.0 MiB
20647 lines
1.0 MiB
{ ============================================================================
|
|
|
|
OpenGL 4.5 - Headertranslation
|
|
|
|
Supported environments and targets :
|
|
- (Win32) Delphi 6 and up
|
|
- (Win32, Win64) Delphi XE2
|
|
- (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up)
|
|
|
|
==============================================================================
|
|
|
|
Copyright (C) DGL-OpenGL-Portteam
|
|
All Rights Reserved
|
|
|
|
Obtained through:
|
|
Bitbucket source repository - https://bitbucket.org/saschawillems/dglopengl
|
|
Delphi OpenGL Community(DGL) - www.delphigl.com
|
|
|
|
Converted and maintained by DGL's OpenGL-Portteam :
|
|
- 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/
|
|
|
|
This Source Code Form is subject to the terms of the Mozilla Public License,
|
|
v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
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 : see readme.md
|
|
|
|
|
|
============================================================================== }
|
|
|
|
{$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}
|
|
|
|
// 64 BIT architecture
|
|
// Free pascal
|
|
{$IFDEF CPU64}
|
|
{$DEFINE DGL_64BIT}
|
|
{$ENDIF}
|
|
// Delphi
|
|
{$IFDEF WIN64}
|
|
{$DEFINE DGL_64BIT}
|
|
{$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}
|
|
|
|
uses
|
|
{$IFDEF FPC}{$IFDEF DARWIN}dynlibs,{$ENDIF}{$ENDIF} // LoadLibrary functions
|
|
SysUtils
|
|
{$IFDEF DGL_WIN}, Windows{$ENDIF}
|
|
{$IFDEF DGL_64BIT} ,math {$ENDIF}
|
|
{$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF}
|
|
;
|
|
|
|
type
|
|
{$IFDEF DELPHI6_AND_DOWN}
|
|
// Delphi 6 compatibility
|
|
PPointer = ^Pointer;
|
|
PCardinal = ^Cardinal;
|
|
{$ENDIF}
|
|
|
|
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;
|
|
PGLintptr = ^GLintptr;
|
|
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_compute_variable_group_size
|
|
TglDispatchComputeGroupSizeARB = procedure (num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint; group_size_x : GLuint; group_size_y : GLuint; group_size_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// 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}
|
|
|
|
// GL_KHR_debug (4.3)
|
|
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
|
|
TVector3f = TGLVectorf3;
|
|
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,
|
|
GL_VERSION_4_5,
|
|
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_filter_minmax,
|
|
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_fragment_shader_interlock,
|
|
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_shader_viewport_layer_array,
|
|
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_sample_locations,
|
|
GL_ARB_sparse_texture2,
|
|
GL_ARB_sparse_texture_clamp,
|
|
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_parallel_shader_compile,
|
|
GL_ARB_post_depth_coverage,
|
|
GL_ARB_sampler_objects,
|
|
GL_ARB_shader_bit_encoding,
|
|
GL_ARB_shader_clock,
|
|
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_gpu_shader_int64,
|
|
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_ES3_2_compatibility,
|
|
GL_ARB_get_program_binary,
|
|
GL_ARB_separate_shader_objects,
|
|
GL_ARB_shader_atomic_counter_ops,
|
|
GL_ARB_shader_precision,
|
|
GL_ARB_shader_ballot,
|
|
GL_ARB_vertex_attrib_64bit,
|
|
GL_ARB_viewport_array,
|
|
GL_KHR_no_error,
|
|
|
|
// 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,
|
|
|
|
|
|
// 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,
|
|
|
|
|
|
// 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,
|
|
GL_ARB_bindless_texture,
|
|
GL_ARB_sparse_texture,
|
|
|
|
// GL 4.5
|
|
GL_ARB_clip_control,
|
|
GL_ARB_cull_distance,
|
|
GL_ARB_ES3_1_compatibility,
|
|
GL_ARB_conditional_render_inverted,
|
|
GL_KHR_context_flush_control,
|
|
GL_ARB_derivative_control,
|
|
GL_ARB_direct_state_access,
|
|
GL_ARB_get_texture_sub_image,
|
|
GL_KHR_robustness,
|
|
GL_KHR_blend_equation_advanced,
|
|
GL_KHR_blend_equation_advanced_coherent,
|
|
GL_KHR_robust_buffer_access_behavior,
|
|
GL_ARB_shader_texture_image_samples,
|
|
GL_ARB_texture_barrier,
|
|
|
|
GL_ARB_cl_event,
|
|
GL_ARB_compute_variable_group_size,
|
|
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_framebuffer_CMAA,
|
|
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_conservative_raster,
|
|
GL_NV_conservative_raster_dilate,
|
|
|
|
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_OVR_multiview,
|
|
GL_OVR_multiview2,
|
|
|
|
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,
|
|
|
|
// WGL
|
|
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,
|
|
WGL_ARB_context_flush_control,
|
|
WIN_draw_range_elements,
|
|
WIN_swap_hint,
|
|
|
|
// GLX
|
|
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_ARB_context_flush_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: ByteBool = True;
|
|
GL_FALSE: ByteBool = False;
|
|
{ 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_RGB_RAW_422_APPLE = $8A51;
|
|
|
|
// 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_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_sparse_buffer
|
|
GL_SPARSE_STORAGE_BIT_ARB = $0400;
|
|
GL_SPARSE_BUFFER_PAGE_SIZE_ARB = $82F8;
|
|
|
|
// 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_filter_minmax
|
|
GL_TEXTURE_REDUCTION_MODE_ARB = $9366;
|
|
GL_WEIGHTED_AVERAGE_ARB = $9367;
|
|
|
|
// 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_compute_variable_group_size
|
|
GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = $9344;
|
|
GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = $90EB;
|
|
GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = $9345;
|
|
GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = $91BF;
|
|
|
|
// 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_sample_locations
|
|
GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB = $933D;
|
|
GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB = $933E;
|
|
GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB = $933F;
|
|
GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB = $9340;
|
|
GL_SAMPLE_LOCATION_ARB = $8E50;
|
|
GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB = $9341;
|
|
GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB = $9342;
|
|
GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB = $9343;
|
|
|
|
// 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_parallel_shader_compile
|
|
GL_MAX_SHADER_COMPILER_THREADS_ARB = $91B0;
|
|
GL_COMPLETION_STATUS_ARB = $91B1;
|
|
|
|
// 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_SPARSE_TEXTURE
|
|
GL_TEXTURE_SPARSE_ARB = $91A6;
|
|
GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = $91A7;
|
|
GL_NUM_VIRTUAL_PAGE_SIZES_ARB = $91A8;
|
|
GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = $91A9;
|
|
GL_NUM_SPARSE_LEVELS_ARB = $91AA;
|
|
GL_VIRTUAL_PAGE_SIZE_X_ARB = $9195;
|
|
GL_VIRTUAL_PAGE_SIZE_Y_ARB = $9196;
|
|
GL_VIRTUAL_PAGE_SIZE_Z_ARB = $9197;
|
|
GL_MAX_SPARSE_TEXTURE_SIZE_ARB = $9198;
|
|
GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = $9199;
|
|
GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = $919A;
|
|
GL_MIN_SPARSE_LEVEL_ARB = $919B;
|
|
|
|
// 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_gpu_shader_int64
|
|
GL_INT64_ARB = $140E;
|
|
GL_INT64_VEC2_ARB = $8FE9;
|
|
GL_INT64_VEC3_ARB = $8FEA;
|
|
GL_INT64_VEC4_ARB = $8FEB;
|
|
GL_UNSIGNED_INT64_VEC2_ARB = $8FF5;
|
|
GL_UNSIGNED_INT64_VEC3_ARB = $8FF6;
|
|
GL_UNSIGNED_INT64_VEC4_ARB = $8FF7;
|
|
|
|
// 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_feedback_overflow_query
|
|
GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = $82EC;
|
|
GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = $82ED;
|
|
|
|
// 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_ES3_2_compatibility
|
|
GL_PRIMITIVE_BOUNDING_BOX_ARB = $092BE;
|
|
GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB = $09381;
|
|
GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB = $09382;
|
|
|
|
// 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_KHR_texture_compression_astc_hdr
|
|
GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0;
|
|
GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1;
|
|
GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2;
|
|
GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3;
|
|
GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4;
|
|
GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5;
|
|
GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6;
|
|
GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7;
|
|
GL_COMPRESSED_RGBA_ASTC_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;
|
|
|
|
// GL 4.4
|
|
GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5;
|
|
GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = $8221;
|
|
GL_TEXTURE_BUFFER_BINDING = $8C2A;
|
|
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;
|
|
|
|
// GL 4.5
|
|
GL_CONTEXT_LOST = $0507;
|
|
GL_NEGATIVE_ONE_TO_ONE = $935E;
|
|
GL_ZERO_TO_ONE = $935F;
|
|
GL_CLIP_ORIGIN = $935C;
|
|
GL_CLIP_DEPTH_MODE = $935D;
|
|
GL_QUERY_WAIT_INVERTED = $8E17;
|
|
GL_QUERY_NO_WAIT_INVERTED = $8E18;
|
|
GL_QUERY_BY_REGION_WAIT_INVERTED = $8E19;
|
|
GL_QUERY_BY_REGION_NO_WAIT_INVERTED = $8E1A;
|
|
GL_MAX_CULL_DISTANCES = $82F9;
|
|
GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = $82FA;
|
|
GL_TEXTURE_TARGET = $1006;
|
|
GL_QUERY_TARGET = $82EA;
|
|
GL_TEXTURE_BINDING = $82EB;
|
|
GL_GUILTY_CONTEXT_RESET = $8253;
|
|
GL_INNOCENT_CONTEXT_RESET = $8254;
|
|
GL_UNKNOWN_CONTEXT_RESET = $8255;
|
|
GL_RESET_NOTIFICATION_STRATEGY = $8256;
|
|
GL_LOSE_CONTEXT_ON_RESET = $8252;
|
|
GL_NO_RESET_NOTIFICATION = $8261;
|
|
GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = $00000004;
|
|
GL_CONTEXT_RELEASE_BEHAVIOR = $82FB;
|
|
GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = $82FC;
|
|
|
|
// 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_conservative_raster
|
|
GL_CONSERVATIVE_RASTERIZATION_NV = $9346;
|
|
GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV = $9347;
|
|
GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = $9348;
|
|
GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = $9349;
|
|
|
|
// GL_NV_conservative_raster_dilate
|
|
GL_CONSERVATIVE_RASTER_DILATE_NV = $9379;
|
|
GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV = $937A;
|
|
GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV = $937B;
|
|
|
|
// 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_OVR_multiview
|
|
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = $9630;
|
|
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = $9632;
|
|
|
|
// 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_KHR_blend_equation_advanced
|
|
GL_MULTIPLY_KHR = $9294;
|
|
GL_SCREEN_KHR = $9295;
|
|
GL_OVERLAY_KHR = $9296;
|
|
GL_DARKEN_KHR = $9297;
|
|
GL_LIGHTEN_KHR = $9298;
|
|
GL_COLORDODGE_KHR = $9299;
|
|
GL_COLORBURN_KHR = $929A;
|
|
GL_HARDLIGHT_KHR = $929B;
|
|
GL_SOFTLIGHT_KHR = $929C;
|
|
GL_DIFFERENCE_KHR = $929E;
|
|
GL_EXCLUSION_KHR = $92A0;
|
|
GL_HSL_HUE_KHR = $92AD;
|
|
GL_HSL_SATURATION_KHR = $92AE;
|
|
GL_HSL_COLOR_KHR = $92AF;
|
|
GL_HSL_LUMINOSITY_KHR = $92B0;
|
|
|
|
// GL_KHR_blend_equation_advanced_coherent
|
|
GL_BLEND_ADVANCED_COHERENT_KHR = $9285;
|
|
|
|
// GL_KHR_robustness
|
|
GL_CONTEXT_ROBUST_ACCESS = $90F3;
|
|
|
|
// GL_KHR_no_error
|
|
GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR = $00000008;
|
|
|
|
// 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_pipeline_statistics_query
|
|
GL_VERTICES_SUBMITTED_ARB = $82EE;
|
|
GL_PRIMITIVES_SUBMITTED_ARB = $82EF;
|
|
GL_VERTEX_SHADER_INVOCATIONS_ARB = $82F0;
|
|
GL_TESS_CONTROL_SHADER_PATCHES_ARB = $82F1;
|
|
GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = $82F2;
|
|
GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = $82F3;
|
|
GL_FRAGMENT_SHADER_INVOCATIONS_ARB = $82F4;
|
|
GL_COMPUTE_SHADER_INVOCATIONS_ARB = $82F5;
|
|
GL_CLIPPING_INPUT_PRIMITIVES_ARB = $82F6;
|
|
GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = $82F7;
|
|
|
|
// 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_context_flush_control
|
|
WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097;
|
|
WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0;
|
|
WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098;
|
|
|
|
// 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_robustness_application_isolation
|
|
WGL_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008;
|
|
|
|
// 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_robustness_application_isolation
|
|
GLX_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008;
|
|
|
|
// GLX_ARB_fbconfig_float
|
|
GLX_RGBA_FLOAT_TYPE_ARB = $20B9;
|
|
GLX_RGBA_FLOAT_BIT_ARB = $00000004;
|
|
|
|
// GLX_ARB_context_flush_control
|
|
GLX_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097;
|
|
GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0;
|
|
GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098;
|
|
|
|
// 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: ByteBool = True;
|
|
GLU_FALSE: ByteBool = 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; length: PGLSizei; 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; length: PGLSizei; 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_parallel_shader_compile
|
|
TglMaxShaderCompilerThreadsARB = procedure(count : GLuint); {$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_sample_locations
|
|
TglFramebufferSampleLocationsfvARB = procedure(target : GLenum; start : GLuint; count : GLsizei; const v : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferSampleLocationsfvARB = procedure(framebuffer : GLuint; start : GLuint; count : GLsizei; const v : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglEvaluateDepthValuesARB = procedure(); {$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_gpu_shader_int64
|
|
TglUniform1i64ARB = procedure(location : GLint; x : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform2i64ARB = procedure(location : GLint; x : GLint64; y : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform3i64ARB = procedure(location : GLint; x : GLint64; y : GLint64; z : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform4i64ARB = procedure(location : GLint; x : GLint64; y : GLint64; z : GLint64; w : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform1i64vARB = procedure(location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform2i64vARB = procedure(location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform3i64vARB = procedure(location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform4i64vARB = procedure(location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform1ui64ARB = procedure(location : GLint; x : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform2ui64ARB = procedure(location : GLint; x : GLuint64; y : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform3ui64ARB = procedure(location : GLint; x : GLuint64; y : GLuint64; z : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform4ui64ARB = procedure(location : GLint; x : GLuint64; y : GLuint64; z : GLuint64; w : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform1ui64vARB = procedure(location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform2ui64vARB = procedure(location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform3ui64vARB = procedure(location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniform4ui64vARB = procedure(location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetUniformi64vARB = procedure(program_ : GLuint; location : GLint; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetUniformui64vARB = procedure(program_ : GLuint; location : GLint; params : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformi64vARB = procedure(program_ : GLuint; location : GLint; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformui64vARB = procedure(program_ : GLuint; location : GLint; bufSize : GLsizei; params : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform1i64ARB = procedure(program_ : GLuint; location : GLint; x : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform2i64ARB = procedure(program_ : GLuint; location : GLint; x : GLint64; y : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform3i64ARB = procedure(program_ : GLuint; location : GLint; x : GLint64; y : GLint64; z : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform4i64ARB = procedure(program_ : GLuint; location : GLint; x : GLint64; y : GLint64; z : GLint64; w : GLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform1i64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform2i64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform3i64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform4i64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform1ui64ARB = procedure(program_ : GLuint; location : GLint; x : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform2ui64ARB = procedure(program_ : GLuint; location : GLint; x : GLuint64; y : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform3ui64ARB = procedure(program_ : GLuint; location : GLint; x : GLuint64; y : GLuint64; z : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform4ui64ARB = procedure(program_ : GLuint; location : GLint; x : GLuint64; y : GLuint64; z : GLuint64; w : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform1ui64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform2ui64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform3ui64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLuint64 ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniform4ui64vARB = procedure(program_ : GLuint; location : GLint; count : GLsizei; const value : PGLuint64 ); {$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
|
|
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_2_compatibility
|
|
TglPrimitiveBoundingBoxARB = procedure(minX : GLfloat; minY : GLfloat; minZ : GLfloat; minW : GLfloat; maxX : GLfloat; maxY : GLfloat; maxZ : GLfloat; maxW : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// 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}
|
|
TglTexPageCommitmentARB = procedure(target : glenum; level : glint; xoffset : glint; yoffset : glint; zoffset : glint; width : glsizei; height : glsizei; depth : glsizei; resident : glboolean); {$IFDEF DGL_WIN} stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// GL 4.5
|
|
TglClipControl = procedure(origin : GLenum; depth : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateTransformFeedbacks = procedure(n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTransformFeedbackBufferBase = procedure (xfb : GLuint; index : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTransformFeedbackBufferRange = procedure (xfb : GLuint; index : GLuint; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTransformFeedbackiv = procedure (xfb : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTransformFeedbacki_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTransformFeedbacki64_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateBuffers = procedure (n : GLsizei; buffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedBufferStorage = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedBufferData = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; usage : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCopyNamedBufferSubData = procedure (readBuffer : GLuint; writeBuffer : GLuint; readOffset : GLintptr; writeOffset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedBufferData = procedure (buffer : GLuint; internalformat : GLenum; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedBufferSubData = procedure (buffer : GLuint; internalformat : GLenum; offset : GLintptr; size : GLsizei; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMapNamedBuffer = function(buffer : GLuint; access : GLenum) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMapNamedBufferRange = function(buffer : GLuint; offset : GLintptr; length : GLsizei; access : GLbitfield) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUnmapNamedBuffer = function(buffer : GLuint) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglFlushMappedNamedBufferRange = procedure (buffer : GLuint; offset : GLintptr; length : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedBufferParameteriv = procedure (buffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedBufferParameteri64v = procedure (buffer : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedBufferPointerv = procedure (buffer : GLuint; pname : GLenum; params : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateFramebuffers = procedure (n : GLsizei; framebuffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferRenderbuffer = procedure (framebuffer : GLuint; attachment : GLenum ; renderbuffertarget : GLEnum; renderbuffer : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferParameteri = procedure (framebuffer : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferTexture = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferTextureLayer = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint; layer : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferDrawBuffer = procedure (framebuffer : GLuint; buf : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferDrawBuffers = procedure (framebuffer : GLuint; n : GLsizei; bufs : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedFramebufferReadBuffer = procedure (framebuffer : GLuint; src : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglInvalidateNamedFramebufferData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglInvalidateNamedFramebufferSubData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedFramebufferiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedFramebufferuiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedFramebufferfv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglClearNamedFramebufferfi = procedure (framebuffer : GLuint; buffer : GLenum; const depth : GLfloat; stencil : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglBlitNamedFramebuffer = procedure (readFramebuffer : GLuint; drawFramebuffer : GLuint; 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}
|
|
TglCheckNamedFramebufferStatus = function(framebuffer : GLuint; target : GLenum) : GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedFramebufferParameteriv = procedure (framebuffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedFramebufferAttachmentParameteriv = procedure (framebuffer : GLuint; attachment : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateRenderbuffers = procedure (n : GLsizei; renderbuffers : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedRenderbufferStorage = procedure (renderbuffer : GLUInt; internalformat : GLenum ; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedRenderbufferStorageMultisample = procedure (renderbuffer : GLUInt; samples : GLSizei; internalformat : GLenum ; width : GLSizei; height : GLSizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetNamedRenderbufferParameteriv = procedure (renderbuffer : GLUInt; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateTextures = procedure (target : GLenum ; n : GLsizei; textures : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureBuffer = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureBufferRange = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureStorage1D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureStorage2D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureStorage3D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureStorage2DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureStorage3DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCompressedTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCompressedTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; mageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCompressedTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCopyTextureSubImage1D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; x : GLint; y : GLint; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCopyTextureSubImage2D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCopyTextureSubImage3D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameterf = procedure (texture : GLuint; pname : GLenum; param : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameterfv = procedure (texture : GLuint; pname : GLenum; const param : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameteri = procedure (texture : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; const params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; const params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureParameteriv = procedure (texture : GLuint; pname : GLenum; const param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGenerateTextureMipmap = procedure(texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglBindTextureUnit = procedure (_unit : GLuint; texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureImage = procedure (texture : GLuint; level : GLint ; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetCompressedTextureImage = procedure (texture : GLuint; level : GLint; bufSize : GLSizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureLevelParameterfv = procedure (texture : GLuint; level : GLint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureLevelParameteriv = procedure (texture : GLuint; level : GLint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureParameterfv = procedure (texture : GLuint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; params : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureParameteriv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateVertexArrays = procedure (n : GLsizei; arrays : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglDisableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglEnableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayElementBuffer = procedure (vaobj : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayVertexBuffer = procedure (vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayVertexBuffers = procedure (vaobj : GLuint; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : PGLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayAttribBinding = procedure (vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayAttribFormat = procedure(vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; normalized : GLboolean; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayAttribIFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayAttribLFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexArrayBindingDivisor = procedure (vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetVertexArrayiv = procedure (vaobj : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetVertexArrayIndexediv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetVertexArrayIndexed64iv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateSamplers = procedure (n : GLsizei; samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateProgramPipelines = procedure (n : GLsizei; pipelines : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglCreateQueries = procedure (target : GLenum; n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMemoryBarrierByRegion = procedure (barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetCompressedTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetGraphicsResetStatus = function : GLEnum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnCompressedTexImage = procedure (target : GLenum; lod : GLint; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnTexImage = procedure (target : GLenum; level : GLint; format : GLenum; _type : GLenum; bufSize : GLSizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformdv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformfv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnUniformuiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglReadnPixels = procedure (x : GLint; y : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnMapdv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnMapfv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnMapiv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnPixelMapfv = procedure (map : GLenum; bufSize : GLsizei; values : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnPixelMapuiv = procedure (map : GLenum; bufSize : GLsizei; values : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnPixelMapusv = procedure (map : GLenum; bufSize : GLsizei; values : PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnPolygonStipple = procedure (bufSize : GLsizei; pattern : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnColorTable = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; table : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnConvolutionFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; image : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnSeparableFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; rowBufSize : GLsizei; row : PGLvoid; columnBufSize : GLsizei; column : PGLvoid; span : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnHistogram = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetnMinmax = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglTextureBarrier = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// GL_ARB_sparse_buffer
|
|
TglBufferPageCommitmentARB = procedure (target : GLenum; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedBufferPageCommitmentEXT = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglNamedBufferPageCommitmentARB = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// GL_KHR_blend_equation_advanced
|
|
TglBlendBarrierKHR = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// 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}
|
|
|
|
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_framebuffer_CMAA
|
|
TglApplyFramebufferAttachmentCMAAINTEL = procedure(); {$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_conservative_raster
|
|
TglSubpixelPrecisionBiasNV = procedure(xbits : GLuint; ybits : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// GL_NV_conservative_raster_dilate
|
|
TglConservativeRasterParameterfNV = procedure(pname : GLenum; value : GLfloat); {$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_ARB_bindless_texture
|
|
|
|
TglGetTextureHandleARB = function (texture : GLuint) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetTextureSamplerHandleARB = function (texture : GLuint; sampler : GLuint) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMakeTextureHandleResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMakeTextureHandleNonResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetImageHandleARB = function (texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMakeImageHandleResidentARB = procedure (handle : GLuint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglMakeImageHandleNonResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniformHandleui64ARB = procedure (location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglUniformHandleui64vARB = procedure (location : GLint; count : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniformHandleui64ARB = procedure (program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglProgramUniformHandleui64vARB = procedure (program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglIsTextureHandleResidentARB = function (handle : GLuint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglIsImageHandleResidentARB = function (handle : GLuint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexAttribL1ui64ARB = procedure (index : GLuint; x : GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglVertexAttribL1ui64vARB = procedure (index : GLuint; const v : PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
TglGetVertexAttribLui64vARB = procedure (index : GLuint; pname : GLenum; params : PGLuint64EXT ); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// GL_NV_shader_atomic_float
|
|
|
|
// GL_AMD_query_buffer_object
|
|
|
|
// GL_OVR_multiview
|
|
TglFramebufferTextureMultiviewOVR = procedure(target : GLenum; attachment : GLenum; texture : GLuint; level : GLint; baseViewIndex : GLint; numViews : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
|
|
|
|
// 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;
|
|
|
|
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_sample_locations
|
|
glFramebufferSampleLocationsfvARB : TglFramebufferSampleLocationsfvARB;
|
|
glNamedFramebufferSampleLocationsfvARB : TglNamedFramebufferSampleLocationsfvARB;
|
|
glEvaluateDepthValuesARB : TglEvaluateDepthValuesARB;
|
|
|
|
// 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_gpu_shader_int64
|
|
glUniform1i64ARB : TglUniform1i64ARB;
|
|
glUniform2i64ARB : TglUniform2i64ARB;
|
|
glUniform3i64ARB : TglUniform3i64ARB;
|
|
glUniform4i64ARB : TglUniform4i64ARB;
|
|
glUniform1i64vARB : TglUniform1i64vARB;
|
|
glUniform2i64vARB : TglUniform2i64vARB;
|
|
glUniform3i64vARB : TglUniform3i64vARB;
|
|
glUniform4i64vARB : TglUniform4i64vARB;
|
|
glUniform1ui64ARB : TglUniform1ui64ARB;
|
|
glUniform2ui64ARB : TglUniform2ui64ARB;
|
|
glUniform3ui64ARB : TglUniform3ui64ARB;
|
|
glUniform4ui64ARB : TglUniform4ui64ARB;
|
|
glUniform1ui64vARB : TglUniform1ui64vARB;
|
|
glUniform2ui64vARB : TglUniform2ui64vARB;
|
|
glUniform3ui64vARB : TglUniform3ui64vARB;
|
|
glUniform4ui64vARB : TglUniform4ui64vARB;
|
|
glGetUniformi64vARB : TglGetUniformi64vARB;
|
|
glGetUniformui64vARB : TglGetUniformui64vARB;
|
|
glGetnUniformi64vARB : TglGetnUniformi64vARB;
|
|
glGetnUniformui64vARB : TglGetnUniformui64vARB;
|
|
glProgramUniform1i64ARB : TglProgramUniform1i64ARB;
|
|
glProgramUniform2i64ARB : TglProgramUniform2i64ARB;
|
|
glProgramUniform3i64ARB : TglProgramUniform3i64ARB;
|
|
glProgramUniform4i64ARB : TglProgramUniform4i64ARB;
|
|
glProgramUniform1i64vARB : TglProgramUniform1i64vARB;
|
|
glProgramUniform2i64vARB : TglProgramUniform2i64vARB;
|
|
glProgramUniform3i64vARB : TglProgramUniform3i64vARB;
|
|
glProgramUniform4i64vARB : TglProgramUniform4i64vARB;
|
|
glProgramUniform1ui64ARB : TglProgramUniform1ui64ARB;
|
|
glProgramUniform2ui64ARB : TglProgramUniform2ui64ARB;
|
|
glProgramUniform3ui64ARB : TglProgramUniform3ui64ARB;
|
|
glProgramUniform4ui64ARB : TglProgramUniform4ui64ARB ;
|
|
glProgramUniform1ui64vARB : TglProgramUniform1ui64vARB;
|
|
glProgramUniform2ui64vARB : TglProgramUniform2ui64vARB;
|
|
glProgramUniform3ui64vARB : TglProgramUniform3ui64vARB;
|
|
glProgramUniform4ui64vARB : TglProgramUniform4ui64vARB;
|
|
|
|
// 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_ES3_2_compatibility
|
|
glPrimitiveBoundingBoxARB : TglPrimitiveBoundingBoxARB;
|
|
|
|
// GL_ARB_parallel_shader_compile
|
|
glMaxShaderCompilerThreadsARB : TglMaxShaderCompilerThreadsARB;
|
|
|
|
// 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;
|
|
glTexPageCommitmentARB : TglTexPageCommitmentARB;
|
|
|
|
// GL 4.5
|
|
glClipControl : TglClipControl;
|
|
glCreateTransformFeedbacks : TglCreateTransformFeedbacks;
|
|
glTransformFeedbackBufferBase : TglTransformFeedbackBufferBase;
|
|
glTransformFeedbackBufferRange : TglTransformFeedbackBufferRange;
|
|
glGetTransformFeedbackiv : TglGetTransformFeedbackiv;
|
|
glGetTransformFeedbacki_v : TglGetTransformFeedbacki_v;
|
|
glGetTransformFeedbacki64_v : TglGetTransformFeedbacki64_v;
|
|
glCreateBuffers : TglCreateBuffers;
|
|
glNamedBufferStorage : TglNamedBufferStorage;
|
|
glNamedBufferData : TglNamedBufferData;
|
|
glNamedBufferSubData : TglNamedBufferSubData;
|
|
glCopyNamedBufferSubData : TglCopyNamedBufferSubData;
|
|
glClearNamedBufferData : TglClearNamedBufferData;
|
|
glClearNamedBufferSubData : TglClearNamedBufferSubData;
|
|
glMapNamedBuffer : TglMapNamedBuffer;
|
|
glMapNamedBufferRange : TglMapNamedBufferRange;
|
|
glUnmapNamedBuffer : TglUnmapNamedBuffer;
|
|
glFlushMappedNamedBufferRange : TglFlushMappedNamedBufferRange;
|
|
glGetNamedBufferParameteriv : TglGetNamedBufferParameteriv;
|
|
glGetNamedBufferParameteri64v : TglGetNamedBufferParameteri64v;
|
|
glGetNamedBufferPointerv : TglGetNamedBufferPointerv;
|
|
glGetNamedBufferSubData : TglGetNamedBufferSubData;
|
|
glCreateFramebuffers : TglCreateFramebuffers;
|
|
glNamedFramebufferRenderbuffer : TglNamedFramebufferRenderbuffer;
|
|
glNamedFramebufferParameteri : TglNamedFramebufferParameteri;
|
|
glNamedFramebufferTexture : TglNamedFramebufferTexture;
|
|
glNamedFramebufferTextureLayer : TglNamedFramebufferTextureLayer;
|
|
glNamedFramebufferDrawBuffer : TglNamedFramebufferDrawBuffer;
|
|
glNamedFramebufferDrawBuffers : TglNamedFramebufferDrawBuffers;
|
|
glNamedFramebufferReadBuffer : TglNamedFramebufferReadBuffer;
|
|
glInvalidateNamedFramebufferData : TglInvalidateNamedFramebufferData;
|
|
glInvalidateNamedFramebufferSubData : TglInvalidateNamedFramebufferSubData;
|
|
glClearNamedFramebufferiv : TglClearNamedFramebufferiv;
|
|
glClearNamedFramebufferuiv : TglClearNamedFramebufferuiv;
|
|
glClearNamedFramebufferfv : TglClearNamedFramebufferfv;
|
|
glClearNamedFramebufferfi : TglClearNamedFramebufferfi;
|
|
glBlitNamedFramebuffer : TglBlitNamedFramebuffer;
|
|
glCheckNamedFramebufferStatus : TglCheckNamedFramebufferStatus;
|
|
glGetNamedFramebufferParameteriv : TglGetNamedFramebufferParameteriv;
|
|
glGetNamedFramebufferAttachmentParameteriv : TglGetNamedFramebufferAttachmentParameteriv;
|
|
glCreateRenderbuffers : TglCreateRenderbuffers;
|
|
glNamedRenderbufferStorage : TglNamedRenderbufferStorage;
|
|
glNamedRenderbufferStorageMultisample : TglNamedRenderbufferStorageMultisample;
|
|
glGetNamedRenderbufferParameteriv : TglGetNamedRenderbufferParameteriv;
|
|
glCreateTextures : TglCreateTextures;
|
|
glTextureBuffer : TglTextureBuffer;
|
|
glTextureBufferRange : TglTextureBufferRange;
|
|
glTextureStorage1D : TglTextureStorage1D;
|
|
glTextureStorage2D : TglTextureStorage2D;
|
|
glTextureStorage3D : TglTextureStorage3D;
|
|
glTextureStorage2DMultisample : TglTextureStorage2DMultisample;
|
|
glTextureStorage3DMultisample : TglTextureStorage3DMultisample;
|
|
glTextureSubImage1D : TglTextureSubImage1D;
|
|
glTextureSubImage2D : TglTextureSubImage2D;
|
|
glTextureSubImage3D : TglTextureSubImage3D;
|
|
glCompressedTextureSubImage1D : TglCompressedTextureSubImage1D;
|
|
glCompressedTextureSubImage2D : TglCompressedTextureSubImage2D;
|
|
glCompressedTextureSubImage3D : TglCompressedTextureSubImage3D;
|
|
glCopyTextureSubImage1D : TglCopyTextureSubImage1D;
|
|
glCopyTextureSubImage2D : TglCopyTextureSubImage2D;
|
|
glCopyTextureSubImage3D : TglCopyTextureSubImage3D;
|
|
glTextureParameterf : TglTextureParameterf;
|
|
glTextureParameterfv : TglTextureParameterfv;
|
|
glTextureParameteri : TglTextureParameteri;
|
|
glTextureParameterIiv : TglTextureParameterIiv;
|
|
glTextureParameterIuiv : TglTextureParameterIuiv;
|
|
glTextureParameteriv : TglTextureParameteriv;
|
|
glGenerateTextureMipmap : TglGenerateTextureMipmap;
|
|
glBindTextureUnit : TglBindTextureUnit;
|
|
glGetTextureImage : TglGetTextureImage;
|
|
glGetCompressedTextureImage : TglGetCompressedTextureImage;
|
|
glGetTextureLevelParameterfv : TglGetTextureLevelParameterfv;
|
|
glGetTextureLevelParameteriv : TglGetTextureLevelParameteriv;
|
|
glGetTextureParameterfv : TglGetTextureParameterfv;
|
|
glGetTextureParameterIiv : TglGetTextureParameterIiv;
|
|
glGetTextureParameterIuiv : TglGetTextureParameterIuiv;
|
|
glGetTextureParameteriv : TglGetTextureParameteriv;
|
|
glCreateVertexArrays : TglCreateVertexArrays;
|
|
glDisableVertexArrayAttrib : TglDisableVertexArrayAttrib;
|
|
glEnableVertexArrayAttrib : TglEnableVertexArrayAttrib;
|
|
glVertexArrayElementBuffer : TglVertexArrayElementBuffer;
|
|
glVertexArrayVertexBuffer : TglVertexArrayVertexBuffer;
|
|
glVertexArrayVertexBuffers : TglVertexArrayVertexBuffers;
|
|
glVertexArrayAttribBinding : TglVertexArrayAttribBinding;
|
|
glVertexArrayAttribFormat : TglVertexArrayAttribFormat;
|
|
glVertexArrayAttribIFormat : TglVertexArrayAttribIFormat;
|
|
glVertexArrayAttribLFormat : TglVertexArrayAttribLFormat;
|
|
glVertexArrayBindingDivisor : TglVertexArrayBindingDivisor;
|
|
glGetVertexArrayiv : TglGetVertexArrayiv;
|
|
glGetVertexArrayIndexediv : TglGetVertexArrayIndexediv;
|
|
glGetVertexArrayIndexed64iv : TglGetVertexArrayIndexed64iv;
|
|
glCreateSamplers : TglCreateSamplers;
|
|
glCreateProgramPipelines : TglCreateProgramPipelines;
|
|
glCreateQueries : TglCreateQueries;
|
|
glMemoryBarrierByRegion : TglMemoryBarrierByRegion;
|
|
glGetTextureSubImage : TglGetTextureSubImage;
|
|
glGetCompressedTextureSubImage : TglGetCompressedTextureSubImage;
|
|
glGetGraphicsResetStatus : TglGetGraphicsResetStatus;
|
|
glGetnCompressedTexImage : TglGetnCompressedTexImage;
|
|
glGetnTexImage : TglGetnTexImage;
|
|
glGetnUniformdv : TglGetnUniformdv;
|
|
glGetnUniformfv : TglGetnUniformfv;
|
|
glGetnUniformiv : TglGetnUniformiv;
|
|
glGetnUniformuiv : TglGetnUniformuiv;
|
|
glReadnPixels : TglReadnPixels;
|
|
glGetnMapdv : TglGetnMapdv;
|
|
glGetnMapfv : TglGetnMapfv;
|
|
glGetnMapiv : TglGetnMapiv;
|
|
glGetnPixelMapfv : TglGetnPixelMapfv;
|
|
glGetnPixelMapuiv : TglGetnPixelMapuiv;
|
|
glGetnPixelMapusv : TglGetnPixelMapusv;
|
|
glGetnPolygonStipple : TglGetnPolygonStipple;
|
|
glGetnColorTable : TglGetnColorTable;
|
|
glGetnConvolutionFilter : TglGetnConvolutionFilter;
|
|
glGetnSeparableFilter : TglGetnSeparableFilter;
|
|
glGetnHistogram : TglGetnHistogram;
|
|
glGetnMinmax : TglGetnMinmax;
|
|
glTextureBarrier : TglTextureBarrier;
|
|
|
|
// GL_ARB_sparse_buffer
|
|
glBufferPageCommitmentARB : TglBufferPageCommitmentARB;
|
|
glNamedBufferPageCommitmentEXT : TglNamedBufferPageCommitmentEXT;
|
|
glNamedBufferPageCommitmentARB : TglNamedBufferPageCommitmentARB;
|
|
|
|
// GL_KHR_blend_equation_advanced
|
|
glBlendBarrierKHR : TglBlendBarrierKHR;
|
|
|
|
// GL_ARB_cl_event
|
|
glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB;
|
|
|
|
// GL_ARB_debug_output
|
|
glDebugMessageControlARB: TglDebugMessageControlARB;
|
|
glDebugMessageInsertARB: TglDebugMessageInsertARB;
|
|
glDebugMessageCallbackARB: TglDebugMessageCallbackARB;
|
|
glGetDebugMessageLogARB: TglGetDebugMessageLogARB;
|
|
|
|
// GL_ARB_compute_variable_group_size
|
|
glDispatchComputeGroupSizeARB : TglDispatchComputeGroupSizeARB;
|
|
|
|
// 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_framebuffer_CMAA
|
|
glApplyFramebufferAttachmentCMAAINTEL : TglApplyFramebufferAttachmentCMAAINTEL;
|
|
|
|
// 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_conservative_raster
|
|
glSubpixelPrecisionBiasNV : TglSubpixelPrecisionBiasNV;
|
|
|
|
// GL_NV_conservative_raster_dilate
|
|
glConservativeRasterParameterfNV : TglConservativeRasterParameterfNV;
|
|
|
|
// 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_ARB_bindless_texture
|
|
glGetTextureHandleARB : TglGetTextureHandleARB;
|
|
glGetTextureSamplerHandleARB : TglGetTextureSamplerHandleARB;
|
|
glMakeTextureHandleResidentARB : TglMakeTextureHandleResidentARB;
|
|
glMakeTextureHandleNonResidentARB : TglMakeTextureHandleNonResidentARB;
|
|
glGetImageHandleARB : TglGetImageHandleARB;
|
|
glMakeImageHandleResidentARB : TglMakeImageHandleResidentARB;
|
|
glMakeImageHandleNonResidentARB : TglMakeImageHandleNonResidentARB;
|
|
glUniformHandleui64ARB : TglUniformHandleui64ARB;
|
|
glUniformHandleui64vARB : TglUniformHandleui64vARB;
|
|
glProgramUniformHandleui64ARB : TglProgramUniformHandleui64ARB;
|
|
glProgramUniformHandleui64vARB : TglProgramUniformHandleui64vARB;
|
|
glIsTextureHandleResidentARB : TglIsTextureHandleResidentARB;
|
|
glIsImageHandleResidentARB : TglIsImageHandleResidentARB;
|
|
glVertexAttribL1ui64ARB : TglVertexAttribL1ui64ARB;
|
|
glVertexAttribL1ui64vARB : TglVertexAttribL1ui64vARB;
|
|
glGetVertexAttribLui64vARB : TglGetVertexAttribLui64vARB;
|
|
|
|
// GL_PGI_misc_hints
|
|
glHintPGI: TglHintPGI;
|
|
|
|
// GL_OVR_multiview
|
|
glFramebufferTextureMultiviewOVR : TglFramebufferTextureMultiviewOVR;
|
|
|
|
// 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;
|
|
|
|
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_sample_locations;
|
|
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_gpu_shader_int64;
|
|
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;
|
|
|
|
procedure Read_GL_ARB_ES3_2_compatibility;
|
|
procedure Read_GL_ARB_parallel_shader_compile;
|
|
|
|
// 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;
|
|
|
|
|
|
procedure Read_GL_4_4;
|
|
procedure Read_GL_4_5;
|
|
|
|
//
|
|
procedure Read_GL_ARB_cl_event;
|
|
procedure Read_GL_ARB_compute_variable_group_size;
|
|
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_INTEL_framebuffer_CMAA;
|
|
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_conservative_raster;
|
|
procedure Read_GL_NV_conservative_raster_dilate;
|
|
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_OVR_multiview;
|
|
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 := 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(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;
|
|
|
|
|
|
{$IFDEF DGL_WIN}
|
|
Result := GetProcAddress(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 : GLuint;
|
|
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');
|
|
|
|
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;
|
|
|
|
Read_GL_4_4;
|
|
Read_GL_4_5;
|
|
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_sample_locations;
|
|
begin
|
|
glFramebufferSampleLocationsfvARB := dglGetProcAddress('glFramebufferSampleLocationsfvARB');
|
|
glNamedFramebufferSampleLocationsfvARB := dglGetProcAddress('glNamedFramebufferSampleLocationsfvARB');
|
|
glEvaluateDepthValuesARB := dglGetProcAddress('glEvaluateDepthValuesARB');;
|
|
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_sparse_texture;
|
|
begin
|
|
glTexPageCommitmentARB := dglGetProcAddress('glTexPageCommitmentARB');
|
|
end;
|
|
|
|
procedure Read_GL_ARB_sparse_buffer;
|
|
begin
|
|
glBufferPageCommitmentARB := dglGetProcAddress('glBufferPageCommitmentARB');
|
|
glNamedBufferPageCommitmentEXT := dglGetProcAddress('glNamedBufferPageCommitmentEXT');
|
|
glNamedBufferPageCommitmentARB := dglGetProcAddress('glNamedBufferPageCommitmentARB');
|
|
end;
|
|
|
|
procedure Read_GL_KHR_blend_equation_advanced;
|
|
begin
|
|
glBlendBarrierKHR := dglGetProcAddress('glBlendBarrierKHR');
|
|
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_gpu_shader_int64;
|
|
begin
|
|
glUniform1i64ARB := dglGetProcAddress('glUniform1i64ARB');
|
|
glUniform2i64ARB := dglGetProcAddress('glUniform2i64ARB');
|
|
glUniform3i64ARB := dglGetProcAddress('glUniform3i64ARB');
|
|
glUniform4i64ARB := dglGetProcAddress('glUniform4i64ARB');
|
|
glUniform1i64vARB := dglGetProcAddress('glUniform1i64vARB');
|
|
glUniform2i64vARB := dglGetProcAddress('glUniform2i64vARB');
|
|
glUniform3i64vARB := dglGetProcAddress('glUniform3i64vARB');
|
|
glUniform4i64vARB := dglGetProcAddress('glUniform4i64vARB');
|
|
glUniform1ui64ARB := dglGetProcAddress('glUniform1ui64ARB');
|
|
glUniform2ui64ARB := dglGetProcAddress('glUniform2ui64ARB');
|
|
glUniform3ui64ARB := dglGetProcAddress('glUniform3ui64ARB');
|
|
glUniform4ui64ARB := dglGetProcAddress('glUniform4ui64ARB');
|
|
glUniform1ui64vARB := dglGetProcAddress('glUniform1ui64vARB');
|
|
glUniform2ui64vARB := dglGetProcAddress('glUniform2ui64vARB');
|
|
glUniform3ui64vARB := dglGetProcAddress('glUniform3ui64vARB');
|
|
glUniform4ui64vARB := dglGetProcAddress('glUniform4ui64vARB');
|
|
glGetUniformi64vARB := dglGetProcAddress('glGetUniformi64vARB');
|
|
glGetUniformui64vARB := dglGetProcAddress('glGetUniformui64vARB');
|
|
glGetnUniformi64vARB := dglGetProcAddress('glGetnUniformi64vARB');
|
|
glGetnUniformui64vARB := dglGetProcAddress('glGetnUniformui64vARB');
|
|
glProgramUniform1i64ARB := dglGetProcAddress('glProgramUniform1i64ARB');
|
|
glProgramUniform2i64ARB := dglGetProcAddress('glProgramUniform2i64ARB');
|
|
glProgramUniform3i64ARB := dglGetProcAddress('glProgramUniform3i64ARB');
|
|
glProgramUniform4i64ARB := dglGetProcAddress('glProgramUniform4i64ARB');
|
|
glProgramUniform1i64vARB := dglGetProcAddress('glProgramUniform1i64vARB');
|
|
glProgramUniform2i64vARB := dglGetProcAddress('glProgramUniform2i64vARB');
|
|
glProgramUniform3i64vARB := dglGetProcAddress('glProgramUniform3i64vARB');
|
|
glProgramUniform4i64vARB := dglGetProcAddress('glProgramUniform4i64vARB');
|
|
glProgramUniform1ui64ARB := dglGetProcAddress('glProgramUniform1ui64ARB');
|
|
glProgramUniform2ui64ARB := dglGetProcAddress('glProgramUniform2ui64ARB');
|
|
glProgramUniform3ui64ARB := dglGetProcAddress('glProgramUniform3ui64ARB');
|
|
glProgramUniform4ui64ARB := dglGetProcAddress('glProgramUniform4ui64ARB ');
|
|
glProgramUniform1ui64vARB := dglGetProcAddress('glProgramUniform1ui64vARB');
|
|
glProgramUniform2ui64vARB := dglGetProcAddress('glProgramUniform2ui64vARB');
|
|
glProgramUniform3ui64vARB := dglGetProcAddress('glProgramUniform3ui64vARB');
|
|
glProgramUniform4ui64vARB := dglGetProcAddress('glProgramUniform4ui64vARB');
|
|
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_ES3_2_compatibility;
|
|
begin
|
|
glPrimitiveBoundingBoxARB := dglGetProcAddress('glPrimitiveBoundingBoxARB');
|
|
end;
|
|
|
|
procedure Read_GL_ARB_parallel_shader_compile;
|
|
begin
|
|
glMaxShaderCompilerThreadsARB := dglGetProcAddress('glMaxShaderCompilerThreadsARB');
|
|
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_4_5;
|
|
begin
|
|
glClipControl:= dglGetProcAddress('glClipControl');
|
|
glCreateTransformFeedbacks:= dglGetProcAddress('glCreateTransformFeedbacks');
|
|
glTransformFeedbackBufferBase:= dglGetProcAddress('glTransformFeedbackBufferBase');
|
|
glTransformFeedbackBufferRange:= dglGetProcAddress('glTransformFeedbackBufferRange');
|
|
glGetTransformFeedbackiv:= dglGetProcAddress('glGetTransformFeedbackiv');
|
|
glGetTransformFeedbacki_v:= dglGetProcAddress('glGetTransformFeedbacki_v');
|
|
glGetTransformFeedbacki64_v:= dglGetProcAddress('glGetTransformFeedbacki64_v');
|
|
glCreateBuffers:= dglGetProcAddress('glCreateBuffers');
|
|
glNamedBufferStorage:= dglGetProcAddress('glNamedBufferStorage');
|
|
glNamedBufferData:= dglGetProcAddress('glNamedBufferData');
|
|
glNamedBufferSubData:= dglGetProcAddress('glNamedBufferSubData');
|
|
glCopyNamedBufferSubData:= dglGetProcAddress('glCopyNamedBufferSubData');
|
|
glClearNamedBufferData:= dglGetProcAddress('glClearNamedBufferData');
|
|
glClearNamedBufferSubData:= dglGetProcAddress('glClearNamedBufferSubData');
|
|
glMapNamedBuffer:= dglGetProcAddress('glMapNamedBuffer');
|
|
glMapNamedBufferRange:= dglGetProcAddress('glMapNamedBufferRange');
|
|
glUnmapNamedBuffer:= dglGetProcAddress('glUnmapNamedBuffer');
|
|
glFlushMappedNamedBufferRange:= dglGetProcAddress('glFlushMappedNamedBufferRange');
|
|
glGetNamedBufferParameteriv:= dglGetProcAddress('glGetNamedBufferParameteriv');
|
|
glGetNamedBufferParameteri64v:= dglGetProcAddress('glGetNamedBufferParameteri64v');
|
|
glGetNamedBufferPointerv:= dglGetProcAddress('glGetNamedBufferPointerv');
|
|
glGetNamedBufferSubData:= dglGetProcAddress('glGetNamedBufferSubData');
|
|
glCreateFramebuffers:= dglGetProcAddress('glCreateFramebuffers');
|
|
glNamedFramebufferRenderbuffer:= dglGetProcAddress('glNamedFramebufferRenderbuffer');
|
|
glNamedFramebufferParameteri:= dglGetProcAddress('glNamedFramebufferParameteri');
|
|
glNamedFramebufferTexture:= dglGetProcAddress('glNamedFramebufferTexture');
|
|
glNamedFramebufferTextureLayer:= dglGetProcAddress('glNamedFramebufferTextureLayer');
|
|
glNamedFramebufferDrawBuffer:= dglGetProcAddress('glNamedFramebufferDrawBuffer');
|
|
glNamedFramebufferDrawBuffers:= dglGetProcAddress('glNamedFramebufferDrawBuffers');
|
|
glNamedFramebufferReadBuffer:= dglGetProcAddress('glNamedFramebufferReadBuffer');
|
|
glInvalidateNamedFramebufferData:= dglGetProcAddress('glInvalidateNamedFramebufferData');
|
|
glInvalidateNamedFramebufferSubData:= dglGetProcAddress('glInvalidateNamedFramebufferSubData');
|
|
glClearNamedFramebufferiv:= dglGetProcAddress('glClearNamedFramebufferiv');
|
|
glClearNamedFramebufferuiv:= dglGetProcAddress('glClearNamedFramebufferuiv');
|
|
glClearNamedFramebufferfv:= dglGetProcAddress('glClearNamedFramebufferfv');
|
|
glClearNamedFramebufferfi:= dglGetProcAddress('glClearNamedFramebufferfi');
|
|
glBlitNamedFramebuffer:= dglGetProcAddress('glBlitNamedFramebuffer');
|
|
glCheckNamedFramebufferStatus:= dglGetProcAddress('glCheckNamedFramebufferStatus');
|
|
glGetNamedFramebufferParameteriv:= dglGetProcAddress('glGetNamedFramebufferParameteriv');
|
|
glGetNamedFramebufferAttachmentParameteriv:= dglGetProcAddress('glGetNamedFramebufferAttachmentParameteriv');
|
|
glCreateRenderbuffers:= dglGetProcAddress('glCreateRenderbuffers');
|
|
glNamedRenderbufferStorage:= dglGetProcAddress('glNamedRenderbufferStorage');
|
|
glNamedRenderbufferStorageMultisample:= dglGetProcAddress('glNamedRenderbufferStorageMultisample');
|
|
glGetNamedRenderbufferParameteriv:= dglGetProcAddress('glGetNamedRenderbufferParameteriv');
|
|
glCreateTextures:= dglGetProcAddress('glCreateTextures');
|
|
glTextureBuffer:= dglGetProcAddress('glTextureBuffer');
|
|
glTextureBufferRange:= dglGetProcAddress('glTextureBufferRange');
|
|
glTextureStorage1D:= dglGetProcAddress('glTextureStorage1D');
|
|
glTextureStorage2D:= dglGetProcAddress('glTextureStorage2D');
|
|
glTextureStorage3D:= dglGetProcAddress('glTextureStorage3D');
|
|
glTextureStorage2DMultisample:= dglGetProcAddress('glTextureStorage2DMultisample');
|
|
glTextureStorage3DMultisample:= dglGetProcAddress('glTextureStorage3DMultisample');
|
|
glTextureSubImage1D:= dglGetProcAddress('glTextureSubImage1D');
|
|
glTextureSubImage2D:= dglGetProcAddress('glTextureSubImage2D');
|
|
glTextureSubImage3D:= dglGetProcAddress('glTextureSubImage3D');
|
|
glCompressedTextureSubImage1D:= dglGetProcAddress('glCompressedTextureSubImage1D');
|
|
glCompressedTextureSubImage2D:= dglGetProcAddress('glCompressedTextureSubImage2D');
|
|
glCompressedTextureSubImage3D:= dglGetProcAddress('glCompressedTextureSubImage3D');
|
|
glCopyTextureSubImage1D:= dglGetProcAddress('glCopyTextureSubImage1D');
|
|
glCopyTextureSubImage2D:= dglGetProcAddress('glCopyTextureSubImage2D');
|
|
glCopyTextureSubImage3D:= dglGetProcAddress('glCopyTextureSubImage3D');
|
|
glTextureParameterf:= dglGetProcAddress('glTextureParameterf');
|
|
glTextureParameterfv:= dglGetProcAddress('glTextureParameterfv');
|
|
glTextureParameteri:= dglGetProcAddress('glTextureParameteri');
|
|
glTextureParameterIiv:= dglGetProcAddress('glTextureParameterIiv');
|
|
glTextureParameterIuiv:= dglGetProcAddress('glTextureParameterIuiv');
|
|
glTextureParameteriv:= dglGetProcAddress('glTextureParameteriv');
|
|
glGenerateTextureMipmap:= dglGetProcAddress('glGenerateTextureMipmap');
|
|
glBindTextureUnit:= dglGetProcAddress('glBindTextureUnit');
|
|
glGetTextureImage:= dglGetProcAddress('glGetTextureImage');
|
|
glGetCompressedTextureImage:= dglGetProcAddress('glGetCompressedTextureImage');
|
|
glGetTextureLevelParameterfv:= dglGetProcAddress('glGetTextureLevelParameterfv');
|
|
glGetTextureLevelParameteriv:= dglGetProcAddress('glGetTextureLevelParameteriv');
|
|
glGetTextureParameterfv:= dglGetProcAddress('glGetTextureParameterfv');
|
|
glGetTextureParameterIiv:= dglGetProcAddress('glGetTextureParameterIiv');
|
|
glGetTextureParameterIuiv:= dglGetProcAddress('glGetTextureParameterIuiv');
|
|
glGetTextureParameteriv:= dglGetProcAddress('glGetTextureParameteriv');
|
|
glCreateVertexArrays:= dglGetProcAddress('glCreateVertexArrays');
|
|
glDisableVertexArrayAttrib:= dglGetProcAddress('glDisableVertexArrayAttrib');
|
|
glEnableVertexArrayAttrib:= dglGetProcAddress('glEnableVertexArrayAttrib');
|
|
glVertexArrayElementBuffer:= dglGetProcAddress('glVertexArrayElementBuffer');
|
|
glVertexArrayVertexBuffer:= dglGetProcAddress('glVertexArrayVertexBuffer');
|
|
glVertexArrayVertexBuffers:= dglGetProcAddress('glVertexArrayVertexBuffers');
|
|
glVertexArrayAttribBinding:= dglGetProcAddress('glVertexArrayAttribBinding');
|
|
glVertexArrayAttribFormat:= dglGetProcAddress('glVertexArrayAttribFormat');
|
|
glVertexArrayAttribIFormat:= dglGetProcAddress('glVertexArrayAttribIFormat');
|
|
glVertexArrayAttribLFormat:= dglGetProcAddress('glVertexArrayAttribLFormat');
|
|
glVertexArrayBindingDivisor:= dglGetProcAddress('glVertexArrayBindingDivisor');
|
|
glGetVertexArrayiv:= dglGetProcAddress('glGetVertexArrayiv');
|
|
glGetVertexArrayIndexediv:= dglGetProcAddress('glGetVertexArrayIndexediv');
|
|
glGetVertexArrayIndexed64iv:= dglGetProcAddress('glGetVertexArrayIndexed64iv');
|
|
glCreateSamplers:= dglGetProcAddress('glCreateSamplers');
|
|
glCreateProgramPipelines:= dglGetProcAddress('glCreateProgramPipelines');
|
|
glCreateQueries:= dglGetProcAddress('glCreateQueries');
|
|
glMemoryBarrierByRegion:= dglGetProcAddress('glMemoryBarrierByRegion');
|
|
glGetTextureSubImage:= dglGetProcAddress('glGetTextureSubImage');
|
|
glGetCompressedTextureSubImage:= dglGetProcAddress('glGetCompressedTextureSubImage');
|
|
glGetGraphicsResetStatus:= dglGetProcAddress('glGetGraphicsResetStatus');
|
|
glGetnCompressedTexImage:= dglGetProcAddress('glGetnCompressedTexImage');
|
|
glGetnTexImage:= dglGetProcAddress('glGetnTexImage');
|
|
glGetnUniformdv:= dglGetProcAddress('glGetnUniformdv');
|
|
glGetnUniformfv:= dglGetProcAddress('glGetnUniformfv');
|
|
glGetnUniformiv:= dglGetProcAddress('glGetnUniformiv');
|
|
glGetnUniformuiv:= dglGetProcAddress('glGetnUniformuiv');
|
|
glReadnPixels:= dglGetProcAddress('glReadnPixels');
|
|
glGetnMapdv:= dglGetProcAddress('glGetnMapdv');
|
|
glGetnMapfv:= dglGetProcAddress('glGetnMapfv');
|
|
glGetnMapiv:= dglGetProcAddress('glGetnMapiv');
|
|
glGetnPixelMapfv:= dglGetProcAddress('glGetnPixelMapfv');
|
|
glGetnPixelMapuiv:= dglGetProcAddress('glGetnPixelMapuiv');
|
|
glGetnPixelMapusv:= dglGetProcAddress('glGetnPixelMapusv');
|
|
glGetnPolygonStipple:= dglGetProcAddress('glGetnPolygonStipple');
|
|
glGetnColorTable:= dglGetProcAddress('glGetnColorTable');
|
|
glGetnConvolutionFilter:= dglGetProcAddress('glGetnConvolutionFilter');
|
|
glGetnSeparableFilter:= dglGetProcAddress('glGetnSeparableFilter');
|
|
glGetnHistogram:= dglGetProcAddress('glGetnHistogram');
|
|
glGetnMinmax:= dglGetProcAddress('glGetnMinmax');
|
|
glTextureBarrier:= dglGetProcAddress('glTextureBarrier');
|
|
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_bindless_texture;
|
|
begin
|
|
glGetTextureHandleARB := dglGetProcAddress('TglGetTextureHandleARB');
|
|
glGetTextureSamplerHandleARB := dglGetProcAddress('TglGetTextureSamplerHandleARB');
|
|
glMakeTextureHandleResidentARB := dglGetProcAddress('TglMakeTextureHandleResidentARB');
|
|
glMakeTextureHandleNonResidentARB := dglGetProcAddress('TglMakeTextureHandleNonResidentARB');
|
|
glGetImageHandleARB := dglGetProcAddress('TglGetImageHandleARB');
|
|
glMakeImageHandleResidentARB := dglGetProcAddress('TglMakeImageHandleResidentARB');
|
|
glMakeImageHandleNonResidentARB := dglGetProcAddress('TglMakeImageHandleNonResidentARB');
|
|
glUniformHandleui64ARB := dglGetProcAddress('TglUniformHandleui64ARB');
|
|
glUniformHandleui64vARB := dglGetProcAddress('TglUniformHandleui64vARB');
|
|
glProgramUniformHandleui64ARB := dglGetProcAddress('TglProgramUniformHandleui64ARB');
|
|
glProgramUniformHandleui64vARB := dglGetProcAddress('TglProgramUniformHandleui64vARB');
|
|
glIsTextureHandleResidentARB := dglGetProcAddress('TglIsTextureHandleResidentARB');
|
|
glIsImageHandleResidentARB := dglGetProcAddress('TglIsImageHandleResidentARB');
|
|
glVertexAttribL1ui64ARB := dglGetProcAddress('TglVertexAttribL1ui64ARB');
|
|
glVertexAttribL1ui64vARB := dglGetProcAddress('TglVertexAttribL1ui64vARB');
|
|
glGetVertexAttribLui64vARB := dglGetProcAddress('TglGetVertexAttribLui64vARB');
|
|
end;
|
|
|
|
procedure Read_GL_ARB_cl_event;
|
|
begin
|
|
glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB');
|
|
end;
|
|
|
|
procedure Read_GL_ARB_compute_variable_group_size;
|
|
begin
|
|
glDispatchComputeGroupSizeARB := dglGetProcAddress('glDispatchComputeGroupSizeARB');
|
|
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_INTEL_framebuffer_CMAA;
|
|
begin
|
|
glApplyFramebufferAttachmentCMAAINTEL := dglGetProcAddress('glApplyFramebufferAttachmentCMAAINTEL');
|
|
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_conservative_raster;
|
|
begin
|
|
glSubpixelPrecisionBiasNV := dglGetProcAddress('glSubpixelPrecisionBiasNV');
|
|
end;
|
|
|
|
procedure Read_GL_NV_conservative_raster_dilate;
|
|
begin
|
|
glConservativeRasterParameterfNV := dglGetProcAddress('glConservativeRasterParameterfNV');
|
|
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_OVR_multiview;
|
|
begin
|
|
glFramebufferTextureMultiviewOVR := dglGetProcAddress('glFramebufferTextureMultiviewOVR');
|
|
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_gpu_shader_int64;
|
|
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_sample_locations;
|
|
Read_GL_ARB_shading_language_include;
|
|
Read_GL_ARB_sparse_texture;
|
|
Read_GL_ARB_sparse_buffer;
|
|
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_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_compute_variable_group_size;
|
|
Read_GL_ARB_debug_output;
|
|
Read_GL_ARB_robustness;
|
|
Read_GL_ARB_ES2_compatibility;
|
|
//
|
|
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_INTEL_framebuffer_CMAA;
|
|
Read_GL_KHR_blend_equation_advanced;
|
|
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_conservative_raster;
|
|
Read_GL_NV_conservative_raster_dilate;
|
|
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_OVR_multiview;
|
|
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;
|
|
|
|
Read_GL_ARB_ES3_2_compatibility;
|
|
Read_GL_ARB_parallel_shader_compile;
|
|
|
|
{$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; var 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;
|
|
GL_VERSION_4_5 := 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;
|
|
if MinorVersion >= 5 then
|
|
GL_VERSION_4_5:= 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_sparse_texture := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture');
|
|
GL_ARB_sparse_texture2 := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture2');
|
|
GL_ARB_sparse_texture_clamp := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture_clamp');
|
|
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_filter_minmax := Int_CheckExtension(Buffer, 'GL_ARB_texture_filter_minmax');
|
|
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_fragment_shader_interlock := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader_interlock');
|
|
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_shader_viewport_layer_array := Int_CheckExtension(Buffer, 'GL_ARB_shader_viewport_layer_array');
|
|
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_parallel_shader_compile := Int_CheckExtension(Buffer, 'GL_ARB_parallel_shader_compile');
|
|
GL_ARB_post_depth_coverage := Int_CheckExtension(Buffer, 'GL_ARB_post_depth_coverage');
|
|
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_shader_clock := Int_CheckExtension(Buffer, 'GL_ARB_shader_clock');
|
|
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_gpu_shader_int64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_int64');
|
|
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_ES3_2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_2_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_atomic_counter_ops := Int_CheckExtension(Buffer, 'GL_ARB_shader_atomic_counter_ops');
|
|
GL_ARB_shader_ballot := Int_CheckExtension(Buffer, 'GL_ARB_shader_ballot');
|
|
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_ARB_compute_variable_group_size := Int_CheckExtension(Buffer, 'GL_ARB_compute_variable_group_size');
|
|
|
|
// 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');
|
|
|
|
// 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');
|
|
|
|
// 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');
|
|
GL_ARB_bindless_texture := Int_CheckExtension(Buffer, 'GL_ARB_bindless_texture');
|
|
GL_ARB_sparse_texture := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture');
|
|
|
|
// GL 4.5
|
|
GL_ARB_clip_control := Int_CheckExtension(Buffer, 'GL_ARB_clip_control');
|
|
GL_ARB_cull_distance := Int_CheckExtension(Buffer, 'GL_ARB_cull_distance');
|
|
GL_ARB_ES3_1_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_1_compatibility');
|
|
GL_ARB_conditional_render_inverted := Int_CheckExtension(Buffer, 'GL_ARB_conditional_render_inverted');
|
|
GL_KHR_context_flush_control := Int_CheckExtension(Buffer, 'GL_KHR_context_flush_control');
|
|
GL_ARB_derivative_control := Int_CheckExtension(Buffer, 'GL_ARB_derivative_control');
|
|
GL_ARB_direct_state_access := Int_CheckExtension(Buffer, 'GL_ARB_direct_state_access');
|
|
GL_ARB_get_texture_sub_image := Int_CheckExtension(Buffer, 'GL_ARB_get_texture_sub_image');
|
|
GL_KHR_robustness := Int_CheckExtension(Buffer, 'GL_KHR_robustness');
|
|
GL_ARB_shader_texture_image_samples := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_image_samples');
|
|
GL_ARB_texture_barrier := Int_CheckExtension(Buffer, 'GL_ARB_texture_barrier');
|
|
|
|
// 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_framebuffer_CMAA := Int_CheckExtension(Buffer, 'GL_INTEL_framebuffer_CMAA');
|
|
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');
|
|
|
|
// Khronos
|
|
// 4.5
|
|
GL_KHR_blend_equation_advanced := Int_CheckExtension(Buffer, 'GL_KHR_blend_equation_advanced');
|
|
GL_KHR_blend_equation_advanced_coherent := Int_CheckExtension(Buffer, 'GL_KHR_blend_equation_advanced_coherent');
|
|
GL_KHR_no_error := Int_CheckExtension(Buffer, 'GL_KHR_no_error');
|
|
GL_KHR_robustness := Int_CheckExtension(Buffer, 'GL_KHR_robustness');
|
|
GL_KHR_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_KHR_robust_buffer_access_behavior');
|
|
|
|
// 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_conservative_raster := Int_CheckExtension(Buffer, 'GL_NV_conservative_raster');
|
|
GL_NV_conservative_raster_dilate := Int_CheckExtension(Buffer, 'GL_NV_conservative_raster_dilate');
|
|
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');
|
|
|
|
// OVR
|
|
GL_OVR_multiview := Int_CheckExtension(Buffer, 'GL_OVR_multiview');
|
|
GL_OVR_multiview2 := Int_CheckExtension(Buffer, 'GL_OVR_multiview2');
|
|
|
|
// 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');
|
|
WGL_ARB_context_flush_control := Int_CheckExtension(Buffer, 'WGL_ARB_context_flush_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');
|
|
GLX_ARB_context_flush_control := Int_CheckExtension(Buffer, 'GLX_ARB_context_flush_control');
|
|
{$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, 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, 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}
|
|
{$IFDEF DGL_64BIT}
|
|
SetExceptionMask([exInvalidOp, exDenormalized, exZeroDivide,exOverflow, exUnderflow, exPrecision]);
|
|
{$ENDIF}
|
|
|
|
|
|
finalization
|
|
|
|
end.
|
|
|