--- /dev/null
+lib/
\ No newline at end of file
--- /dev/null
+{ ============================================================================
+
+ OpenGL 4.5 - Headertranslation
+ Version 4.5a
+
+ 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/
+
+ The contents of this file are used with permission, subject to
+ the Mozilla Public License Version 1.1 (the "License"); you may
+ not use this file except in compliance with the License. You may
+ obtain a copy of the License at
+ http://www.mozilla.org/MPL/MPL-1.1.html
+
+ Software distributed under the License is distributed on an
+ "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ rights and limitations under the License.
+
+==============================================================================
+
+
+ History : 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_mirrored_repeat,
+ GL_ARB_transpose_matrix,
+ GL_ARB_vertex_blend,
+ GL_ARB_vertex_buffer_object,
+ GL_ARB_vertex_program,
+ GL_ARB_window_pos,
+ GL_ARB_shader_objects,
+ GL_ARB_vertex_shader,
+ GL_ARB_fragment_shader,
+ GL_ARB_shading_language_100,
+ GL_ARB_occlusion_query,
+ GL_ARB_texture_non_power_of_two,
+ GL_ARB_point_sprite,
+ GL_ARB_fragment_program_shadow,
+ GL_ARB_draw_buffers,
+ GL_ARB_texture_rectangle,
+ GL_ARB_color_buffer_float,
+ GL_ARB_half_float_pixel,
+ GL_ARB_texture_float,
+ GL_ARB_pixel_buffer_object,
+ GL_ARB_depth_buffer_float,
+ GL_ARB_draw_instanced,
+ GL_ARB_framebuffer_object,
+ GL_ARB_framebuffer_sRGB,
+ GL_ARB_geometry_shader4,
+ GL_ARB_half_float_vertex,
+ GL_ARB_instanced_arrays,
+ GL_ARB_map_buffer_range,
+ GL_ARB_texture_buffer_object,
+ GL_ARB_texture_compression_rgtc,
+ GL_ARB_texture_rg,
+ GL_ARB_vertex_array_object,
+ GL_ARB_uniform_buffer_object,
+ GL_ARB_compatibility,
+ GL_ARB_copy_buffer,
+ GL_ARB_shader_texture_lod,
+ GL_ARB_depth_clamp,
+ GL_ARB_draw_elements_base_vertex,
+ GL_ARB_fragment_coord_conventions,
+ GL_ARB_provoking_vertex,
+ GL_ARB_seamless_cube_map,
+ GL_ARB_sync,
+ GL_ARB_texture_multisample,
+ GL_ARB_vertex_array_bgra,
+ GL_ARB_draw_buffers_blend,
+ GL_ARB_sample_shading,
+ GL_ARB_texture_cube_map_array,
+ GL_ARB_texture_gather,
+ GL_ARB_texture_query_lod,
+ GL_ARB_shading_language_include,
+ GL_ARB_texture_compression_bptc,
+ GL_ARB_blend_func_extended,
+ GL_ARB_explicit_attrib_location,
+ GL_ARB_occlusion_query2,
+ GL_ARB_sampler_objects,
+ GL_ARB_shader_bit_encoding,
+ GL_ARB_texture_rgb10_a2ui,
+ GL_ARB_texture_swizzle,
+ GL_ARB_timer_query,
+ GL_ARB_vertex_type_2_10_10_10_rev,
+ GL_ARB_draw_indirect,
+ GL_ARB_gpu_shader5,
+ GL_ARB_gpu_shader_fp64,
+ GL_ARB_shader_subroutine,
+ GL_ARB_tessellation_shader,
+ GL_ARB_texture_buffer_object_rgb32,
+ GL_ARB_transform_feedback2,
+ GL_ARB_transform_feedback3,
+ GL_ARB_ES2_compatibility,
+ GL_ARB_get_program_binary,
+ GL_ARB_separate_shader_objects,
+ GL_ARB_shader_precision,
+ GL_ARB_vertex_attrib_64bit,
+ GL_ARB_viewport_array,
+
+ // GL 4.2
+ GL_ARB_base_instance,
+ GL_ARB_shading_language_420pack,
+ GL_ARB_transform_feedback_instanced,
+ GL_ARB_compressed_texture_pixel_storage,
+ GL_ARB_conservative_depth,
+ GL_ARB_internalformat_query,
+ GL_ARB_map_buffer_alignment,
+ GL_ARB_shader_atomic_counters,
+ GL_ARB_shader_image_load_store,
+ GL_ARB_shading_language_packing,
+ GL_ARB_texture_storage,
+
+
+ // 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_parallel_arrays,
+ GL_INTEL_texture_scissor,
+ GL_MESA_resize_buffers,
+ GL_MESA_window_pos,
+ GL_NV_blend_square,
+ GL_NV_copy_depth_to_color,
+ GL_NV_depth_clamp,
+ GL_NV_evaluators,
+ GL_NV_fence,
+ GL_NV_float_buffer,
+ GL_NV_fog_distance,
+ GL_NV_fragment_program,
+ GL_NV_half_float,
+ GL_NV_light_max_exponent,
+ GL_NV_multisample_filter_hint,
+ GL_NV_occlusion_query,
+ GL_NV_packed_depth_stencil,
+ GL_NV_pixel_data_range,
+ GL_NV_point_sprite,
+ GL_NV_primitive_restart,
+ GL_NV_register_combiners,
+ GL_NV_register_combiners2,
+ GL_NV_texgen_emboss,
+ GL_NV_texgen_reflection,
+ GL_NV_texture_compression_vtc,
+ GL_NV_texture_env_combine4,
+ GL_NV_texture_expand_normal,
+ GL_NV_texture_rectangle,
+ GL_NV_texture_shader,
+ GL_NV_texture_shader2,
+ GL_NV_texture_shader3,
+ GL_NV_vertex_array_range,
+ GL_NV_vertex_array_range2,
+ GL_NV_vertex_program,
+ GL_NV_vertex_program1_1,
+ GL_NV_vertex_program2,
+ GL_NV_fragment_program_option,
+ GL_NV_fragment_program2,
+ GL_NV_vertex_program2_option,
+ GL_NV_vertex_program3,
+ GL_NV_depth_buffer_float,
+ GL_NV_fragment_program4,
+ GL_NV_framebuffer_multisample_coverage,
+ GL_NV_geometry_program4,
+ GL_NV_gpu_program4,
+ GL_NV_parameter_buffer_object,
+ GL_NV_transform_feedback,
+ GL_NV_vertex_program4,
+ GL_NV_conditional_render,
+ GL_NV_present_video,
+ GL_NV_explicit_multisample,
+ GL_NV_transform_feedback2,
+ GL_NV_video_capture,
+ GL_NV_copy_image,
+ GL_NV_parameter_buffer_object2,
+ GL_NV_shader_buffer_load,
+ GL_NV_vertex_buffer_unified_memory,
+ GL_NV_gpu_program5,
+ GL_NV_gpu_shader5,
+ GL_NV_shader_buffer_store,
+ GL_NV_tessellation_program5,
+ GL_NV_vertex_attrib_integer_64bit,
+ GL_NV_multisample_coverage,
+ GL_NV_vdpau_interop,
+ GL_NV_texture_barrier,
+ GL_OML_interlace,
+ GL_OML_resample,
+ GL_OML_subsample,
+ GL_PGI_misc_hints,
+ GL_PGI_vertex_hints,
+ GL_REND_screen_coordinates,
+ GL_S3_s3tc,
+ GL_SGIS_detail_texture,
+ GL_SGIS_fog_function,
+ GL_SGIS_generate_mipmap,
+ GL_SGIS_multisample,
+ GL_SGIS_pixel_texture,
+ GL_SGIS_point_line_texgen,
+ GL_SGIS_point_parameters,
+ GL_SGIS_sharpen_texture,
+ GL_SGIS_texture4D,
+ GL_SGIS_texture_border_clamp,
+ GL_SGIS_texture_color_mask,
+ GL_SGIS_texture_edge_clamp,
+ GL_SGIS_texture_filter4,
+ GL_SGIS_texture_lod,
+ GL_SGIS_texture_select,
+ GL_SGIX_async,
+ GL_SGIX_async_histogram,
+ GL_SGIX_async_pixel,
+ GL_SGIX_blend_alpha_minmax,
+ GL_SGIX_calligraphic_fragment,
+ GL_SGIX_clipmap,
+ GL_SGIX_convolution_accuracy,
+ GL_SGIX_depth_pass_instrument,
+ GL_SGIX_depth_texture,
+ GL_SGIX_flush_raster,
+ GL_SGIX_fog_offset,
+ GL_SGIX_fog_scale,
+ GL_SGIX_fragment_lighting,
+ GL_SGIX_framezoom,
+ GL_SGIX_igloo_interface,
+ GL_SGIX_impact_pixel_texture,
+ GL_SGIX_instruments,
+ GL_SGIX_interlace,
+ GL_SGIX_ir_instrument1,
+ GL_SGIX_list_priority,
+ GL_SGIX_pixel_texture,
+ GL_SGIX_pixel_tiles,
+ GL_SGIX_polynomial_ffd,
+ GL_SGIX_reference_plane,
+ GL_SGIX_resample,
+ GL_SGIX_scalebias_hint,
+ GL_SGIX_shadow,
+ GL_SGIX_shadow_ambient,
+ GL_SGIX_sprite,
+ GL_SGIX_subsample,
+ GL_SGIX_tag_sample_buffer,
+ GL_SGIX_texture_add_env,
+ GL_SGIX_texture_coordinate_clamp,
+ GL_SGIX_texture_lod_bias,
+ GL_SGIX_texture_multi_buffer,
+ GL_SGIX_texture_scale_bias,
+ GL_SGIX_texture_select,
+ GL_SGIX_vertex_preclip,
+ GL_SGIX_ycrcb,
+ GL_SGIX_ycrcb_subsample,
+ GL_SGIX_ycrcba,
+ GL_SGI_color_matrix,
+ GL_SGI_color_table,
+ GL_SGI_depth_pass_instrument,
+ GL_SGI_texture_color_table,
+ GL_SUNX_constant_data,
+ GL_SUN_convolution_border_modes,
+ GL_SUN_global_alpha,
+ GL_SUN_mesh_array,
+ GL_SUN_slice_accum,
+ GL_SUN_triangle_list,
+ GL_SUN_vertex,
+
+ // 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_CONSTANT_COLOR = $8001;
+ GL_ONE_MINUS_CONSTANT_COLOR = $8002;
+ GL_CONSTANT_ALPHA = $8003;
+ GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
+ GL_BLEND_COLOR = $8005;
+ GL_FUNC_ADD = $8006;
+ GL_MIN = $8007;
+ GL_MAX = $8008;
+ GL_BLEND_EQUATION = $8009;
+ GL_FUNC_SUBTRACT = $800A;
+ GL_FUNC_REVERSE_SUBTRACT = $800B;
+{$ifdef DGL_DEPRECATED}
+ GL_CONVOLUTION_1D = $8010;
+ GL_CONVOLUTION_2D = $8011;
+ GL_SEPARABLE_2D = $8012;
+ GL_CONVOLUTION_BORDER_MODE = $8013;
+ GL_CONVOLUTION_FILTER_SCALE = $8014;
+ GL_CONVOLUTION_FILTER_BIAS = $8015;
+ GL_REDUCE = $8016;
+ GL_CONVOLUTION_FORMAT = $8017;
+ GL_CONVOLUTION_WIDTH = $8018;
+ GL_CONVOLUTION_HEIGHT = $8019;
+ GL_MAX_CONVOLUTION_WIDTH = $801A;
+ GL_MAX_CONVOLUTION_HEIGHT = $801B;
+ GL_POST_CONVOLUTION_RED_SCALE = $801C;
+ GL_POST_CONVOLUTION_GREEN_SCALE = $801D;
+ GL_POST_CONVOLUTION_BLUE_SCALE = $801E;
+ GL_POST_CONVOLUTION_ALPHA_SCALE = $801F;
+ GL_POST_CONVOLUTION_RED_BIAS = $8020;
+ GL_POST_CONVOLUTION_GREEN_BIAS = $8021;
+ GL_POST_CONVOLUTION_BLUE_BIAS = $8022;
+ GL_POST_CONVOLUTION_ALPHA_BIAS = $8023;
+ GL_HISTOGRAM = $8024;
+ GL_PROXY_HISTOGRAM = $8025;
+ GL_HISTOGRAM_WIDTH = $8026;
+ GL_HISTOGRAM_FORMAT = $8027;
+ GL_HISTOGRAM_RED_SIZE = $8028;
+ GL_HISTOGRAM_GREEN_SIZE = $8029;
+ GL_HISTOGRAM_BLUE_SIZE = $802A;
+ GL_HISTOGRAM_ALPHA_SIZE = $802B;
+ GL_HISTOGRAM_LUMINANCE_SIZE = $802C;
+ GL_HISTOGRAM_SINK = $802D;
+ GL_MINMAX = $802E;
+ GL_MINMAX_FORMAT = $802F;
+ GL_MINMAX_SINK = $8030;
+ GL_TABLE_TOO_LARGE = $8031;
+ GL_COLOR_MATRIX = $80B1;
+ GL_COLOR_MATRIX_STACK_DEPTH = $80B2;
+ GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3;
+ GL_POST_COLOR_MATRIX_RED_SCALE = $80B4;
+ GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5;
+ GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6;
+ GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7;
+ GL_POST_COLOR_MATRIX_RED_BIAS = $80B8;
+ GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9;
+ GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA;
+ GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB;
+ GL_COLOR_TABLE = $80D0;
+ GL_POST_CONVOLUTION_COLOR_TABLE = $80D1;
+ GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2;
+ GL_PROXY_COLOR_TABLE = $80D3;
+ GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4;
+ GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5;
+ GL_COLOR_TABLE_SCALE = $80D6;
+ GL_COLOR_TABLE_BIAS = $80D7;
+ GL_COLOR_TABLE_FORMAT = $80D8;
+ GL_COLOR_TABLE_WIDTH = $80D9;
+ GL_COLOR_TABLE_RED_SIZE = $80DA;
+ GL_COLOR_TABLE_GREEN_SIZE = $80DB;
+ GL_COLOR_TABLE_BLUE_SIZE = $80DC;
+ GL_COLOR_TABLE_ALPHA_SIZE = $80DD;
+ GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE;
+ GL_COLOR_TABLE_INTENSITY_SIZE = $80DF;
+ GL_CONSTANT_BORDER = $8151;
+ GL_REPLICATE_BORDER = $8153;
+ GL_CONVOLUTION_BORDER_COLOR = $8154;
+{$endif}
+
+ // GL_ARB_matrix_palette
+ GL_MATRIX_PALETTE_ARB = $8840;
+ GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841;
+ GL_MAX_PALETTE_MATRICES_ARB = $8842;
+ GL_CURRENT_PALETTE_MATRIX_ARB = $8843;
+ GL_MATRIX_INDEX_ARRAY_ARB = $8844;
+ GL_CURRENT_MATRIX_INDEX_ARB = $8845;
+ GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846;
+ GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847;
+ GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848;
+ GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849;
+
+ // GL_ARB_multisample
+ GL_MULTISAMPLE_ARB = $809D;
+ GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E;
+ GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F;
+ GL_SAMPLE_COVERAGE_ARB = $80A0;
+ GL_SAMPLE_BUFFERS_ARB = $80A8;
+ GL_SAMPLES_ARB = $80A9;
+ GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA;
+ GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB;
+ GL_MULTISAMPLE_BIT_ARB = $20000000;
+
+ // GL_ARB_multitexture
+ GL_TEXTURE0_ARB = $84C0;
+ GL_TEXTURE1_ARB = $84C1;
+ GL_TEXTURE2_ARB = $84C2;
+ GL_TEXTURE3_ARB = $84C3;
+ GL_TEXTURE4_ARB = $84C4;
+ GL_TEXTURE5_ARB = $84C5;
+ GL_TEXTURE6_ARB = $84C6;
+ GL_TEXTURE7_ARB = $84C7;
+ GL_TEXTURE8_ARB = $84C8;
+ GL_TEXTURE9_ARB = $84C9;
+ GL_TEXTURE10_ARB = $84CA;
+ GL_TEXTURE11_ARB = $84CB;
+ GL_TEXTURE12_ARB = $84CC;
+ GL_TEXTURE13_ARB = $84CD;
+ GL_TEXTURE14_ARB = $84CE;
+ GL_TEXTURE15_ARB = $84CF;
+ GL_TEXTURE16_ARB = $84D0;
+ GL_TEXTURE17_ARB = $84D1;
+ GL_TEXTURE18_ARB = $84D2;
+ GL_TEXTURE19_ARB = $84D3;
+ GL_TEXTURE20_ARB = $84D4;
+ GL_TEXTURE21_ARB = $84D5;
+ GL_TEXTURE22_ARB = $84D6;
+ GL_TEXTURE23_ARB = $84D7;
+ GL_TEXTURE24_ARB = $84D8;
+ GL_TEXTURE25_ARB = $84D9;
+ GL_TEXTURE26_ARB = $84DA;
+ GL_TEXTURE27_ARB = $84DB;
+ GL_TEXTURE28_ARB = $84DC;
+ GL_TEXTURE29_ARB = $84DD;
+ GL_TEXTURE30_ARB = $84DE;
+ GL_TEXTURE31_ARB = $84DF;
+ GL_ACTIVE_TEXTURE_ARB = $84E0;
+ GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1;
+ GL_MAX_TEXTURE_UNITS_ARB = $84E2;
+
+ // GL_ARB_point_parameters
+ GL_POINT_SIZE_MIN_ARB = $8126;
+ GL_POINT_SIZE_MAX_ARB = $8127;
+ GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128;
+ GL_POINT_DISTANCE_ATTENUATION_ARB = $8129;
+
+ // GL_ARB_shadow
+ GL_TEXTURE_COMPARE_MODE_ARB = $884C;
+ GL_TEXTURE_COMPARE_FUNC_ARB = $884D;
+ GL_COMPARE_R_TO_TEXTURE_ARB = $884E;
+
+ // GL_ARB_shadow_ambient
+ GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF;
+
+ // GL_ARB_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_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_texture_cube_map_array
+ GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009;
+ GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A;
+ GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B;
+ GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C;
+ GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D;
+ GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E;
+ GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F;
+
+ // GL_ARB_texture_gather
+ GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E;
+ GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F;
+
+ // GL_ARB_shading_language_include
+ GL_SHADER_INCLUDE_ARB = $8DAE;
+ GL_NAMED_STRING_LENGTH_ARB = $8DE9;
+ GL_NAMED_STRING_TYPE_ARB = $8DEA;
+
+ // GL_ARB_texture_compression_bptc
+ GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C;
+ GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D;
+ GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E;
+ GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F;
+
+ // GL_ARB_blend_func_extended
+ GL_SRC1_COLOR = $88F9;
+ { reuse GL_SRC1_ALPHA }
+ GL_ONE_MINUS_SRC1_COLOR = $88FA;
+ GL_ONE_MINUS_SRC1_ALPHA = $88FB;
+ GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC;
+
+ // GL_ARB_occlusion_query2
+ GL_ANY_SAMPLES_PASSED = $8C2F;
+
+ // GL_ARB_sampler_objects
+ GL_SAMPLER_BINDING = $8919;
+
+ // GL_ARB_texture_rgb10_a2ui
+ GL_RGB10_A2UI = $906F;
+
+ // GL_ARB_texture_swizzle
+ GL_TEXTURE_SWIZZLE_R = $8E42;
+ GL_TEXTURE_SWIZZLE_G = $8E43;
+ GL_TEXTURE_SWIZZLE_B = $8E44;
+ GL_TEXTURE_SWIZZLE_A = $8E45;
+ GL_TEXTURE_SWIZZLE_RGBA = $8E46;
+
+ // GL_ARB_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_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_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_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_present_video
+ GL_FRAME_NV = $8E26;
+ GL_FIELDS_NV = $8E27;
+ GL_CURRENT_TIME_NV = $8E28;
+ GL_NUM_FILL_STREAMS_NV = $8E29;
+ GL_PRESENT_TIME_NV = $8E2A;
+ GL_PRESENT_DURATION_NV = $8E2B;
+
+ // GL_NV_explicit_multisample
+ GL_SAMPLE_POSITION_NV = $8E50;
+ GL_SAMPLE_MASK_NV = $8E51;
+ GL_SAMPLE_MASK_VALUE_NV = $8E52;
+ GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53;
+ GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54;
+ GL_TEXTURE_RENDERBUFFER_NV = $8E55;
+ GL_SAMPLER_RENDERBUFFER_NV = $8E56;
+ GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57;
+ GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58;
+ GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59;
+
+ // GL_NV_transform_feedback2
+ GL_TRANSFORM_FEEDBACK_NV = $8E22;
+ GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23;
+ GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24;
+ GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25;
+
+ // GL_NV_video_capture
+ GL_VIDEO_BUFFER_NV = $9020;
+ GL_VIDEO_BUFFER_BINDING_NV = $9021;
+ GL_FIELD_UPPER_NV = $9022;
+ GL_FIELD_LOWER_NV = $9023;
+ GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024;
+ GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025;
+ GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026;
+ GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027;
+ GL_VIDEO_BUFFER_PITCH_NV = $9028;
+ GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029;
+ GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A;
+ GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B;
+ GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C;
+ GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D;
+ GL_PARTIAL_SUCCESS_NV = $902E;
+ GL_SUCCESS_NV = $902F;
+ GL_FAILURE_NV = $9030;
+ GL_YCBYCR8_422_NV = $9031;
+ GL_YCBAYCR8A_4224_NV = $9032;
+ GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033;
+ GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034;
+ GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035;
+ GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036;
+ GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037;
+ GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038;
+ GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039;
+ GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A;
+ GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B;
+ GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C;
+
+ // GL_NV_shader_buffer_load
+ GL_BUFFER_GPU_ADDRESS_NV = $8F1D;
+ GL_GPU_ADDRESS_NV = $8F34;
+ GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35;
+
+ // GL_NV_vertex_buffer_unified_memory
+ GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E;
+ GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F;
+ GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20;
+ GL_VERTEX_ARRAY_ADDRESS_NV = $8F21;
+ GL_NORMAL_ARRAY_ADDRESS_NV = $8F22;
+ GL_COLOR_ARRAY_ADDRESS_NV = $8F23;
+ GL_INDEX_ARRAY_ADDRESS_NV = $8F24;
+ GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25;
+ GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26;
+ GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27;
+ GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28;
+ GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29;
+ GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A;
+ GL_VERTEX_ARRAY_LENGTH_NV = $8F2B;
+ GL_NORMAL_ARRAY_LENGTH_NV = $8F2C;
+ GL_COLOR_ARRAY_LENGTH_NV = $8F2D;
+ GL_INDEX_ARRAY_LENGTH_NV = $8F2E;
+ GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F;
+ GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30;
+ GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31;
+ GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32;
+ GL_ELEMENT_ARRAY_LENGTH_NV = $8F33;
+ GL_DRAW_INDIRECT_UNIFIED_NV = $8F40;
+ GL_DRAW_INDIRECT_ADDRESS_NV = $8F41;
+ GL_DRAW_INDIRECT_LENGTH_NV = $8F42;
+
+ // GL_NV_gpu_program5
+ GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A;
+ GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B;
+ GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C;
+ GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D;
+ GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E;
+ GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F;
+ GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44;
+ GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45;
+
+ // GL_NV_gpu_shader5
+ GL_INT64_NV = $140E;
+ GL_UNSIGNED_INT64_NV = $140F;
+ GL_INT8_NV = $8FE0;
+ GL_INT8_VEC2_NV = $8FE1;
+ GL_INT8_VEC3_NV = $8FE2;
+ GL_INT8_VEC4_NV = $8FE3;
+ GL_INT16_NV = $8FE4;
+ GL_INT16_VEC2_NV = $8FE5;
+ GL_INT16_VEC3_NV = $8FE6;
+ GL_INT16_VEC4_NV = $8FE7;
+ GL_INT64_VEC2_NV = $8FE9;
+ GL_INT64_VEC3_NV = $8FEA;
+ GL_INT64_VEC4_NV = $8FEB;
+ GL_UNSIGNED_INT8_NV = $8FEC;
+ GL_UNSIGNED_INT8_VEC2_NV = $8FED;
+ GL_UNSIGNED_INT8_VEC3_NV = $8FEE;
+ GL_UNSIGNED_INT8_VEC4_NV = $8FEF;
+ GL_UNSIGNED_INT16_NV = $8FF0;
+ GL_UNSIGNED_INT16_VEC2_NV = $8FF1;
+ GL_UNSIGNED_INT16_VEC3_NV = $8FF2;
+ GL_UNSIGNED_INT16_VEC4_NV = $8FF3;
+ GL_UNSIGNED_INT64_VEC2_NV = $8FF5;
+ GL_UNSIGNED_INT64_VEC3_NV = $8FF6;
+ GL_UNSIGNED_INT64_VEC4_NV = $8FF7;
+ GL_FLOAT16_NV = $8FF8;
+ GL_FLOAT16_VEC2_NV = $8FF9;
+ GL_FLOAT16_VEC3_NV = $8FFA;
+ GL_FLOAT16_VEC4_NV = $8FFB;
+ { reuse GL_PATCHES }
+
+ // GL_NV_shader_buffer_store
+ GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010;
+ { reuse GL_READ_WRITE }
+ { reuse GL_WRITE_ONLY }
+
+ // GL_NV_tessellation_program5
+ GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8;
+ GL_TESS_CONTROL_PROGRAM_NV = $891E;
+ GL_TESS_EVALUATION_PROGRAM_NV = $891F;
+ GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74;
+ GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75;
+
+ // GL_NV_vertex_attrib_integer_64bit
+ { reuse GL_INT64_NV }
+ { reuse GL_UNSIGNED_INT64_NV }
+
+ // GL_NV_multisample_coverage
+ GL_COVERAGE_SAMPLES_NV = $80A9;
+ GL_COLOR_SAMPLES_NV = $8E20;
+
+ // GL_NV_vdpau_interop
+ GL_SURFACE_STATE_NV = $86EB;
+ GL_SURFACE_REGISTERED_NV = $86FD;
+ GL_SURFACE_MAPPED_NV = $8700;
+ GL_WRITE_DISCARD_NV = $88BE;
+
+ // GL_OML_interlace
+ GL_INTERLACE_OML = $8980;
+ GL_INTERLACE_READ_OML = $8981;
+
+ // GL_OML_resample
+ GL_PACK_RESAMPLE_OML = $8984;
+ GL_UNPACK_RESAMPLE_OML = $8985;
+ GL_RESAMPLE_REPLICATE_OML = $8986;
+ GL_RESAMPLE_ZERO_FILL_OML = $8987;
+ GL_RESAMPLE_AVERAGE_OML = $8988;
+ GL_RESAMPLE_DECIMATE_OML = $8989;
+
+ // GL_OML_subsample
+ GL_FORMAT_SUBSAMPLE_24_24_OML = $8982;
+ GL_FORMAT_SUBSAMPLE_244_244_OML = $8983;
+
+ // GL_PGI_misc_hints
+ GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8;
+ GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD;
+ GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE;
+ GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202;
+ GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203;
+ GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204;
+ GL_ALWAYS_FAST_HINT_PGI = $1A20C;
+ GL_ALWAYS_SOFT_HINT_PGI = $1A20D;
+ GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E;
+ GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F;
+ GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210;
+ GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211;
+ GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216;
+ GL_STRICT_LIGHTING_HINT_PGI = $1A217;
+ GL_STRICT_SCISSOR_HINT_PGI = $1A218;
+ GL_FULL_STIPPLE_HINT_PGI = $1A219;
+ GL_CLIP_NEAR_HINT_PGI = $1A220;
+ GL_CLIP_FAR_HINT_PGI = $1A221;
+ GL_WIDE_LINE_HINT_PGI = $1A222;
+ GL_BACK_NORMALS_HINT_PGI = $1A223;
+
+ // GL_PGI_vertex_hints
+ GL_VERTEX_DATA_HINT_PGI = $1A22A;
+ GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B;
+ GL_MATERIAL_SIDE_HINT_PGI = $1A22C;
+ GL_MAX_VERTEX_HINT_PGI = $1A22D;
+ GL_COLOR3_BIT_PGI = $00010000;
+ GL_COLOR4_BIT_PGI = $00020000;
+ GL_EDGEFLAG_BIT_PGI = $00040000;
+ GL_INDEX_BIT_PGI = $00080000;
+ GL_MAT_AMBIENT_BIT_PGI = $00100000;
+ GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000;
+ GL_MAT_DIFFUSE_BIT_PGI = $00400000;
+ GL_MAT_EMISSION_BIT_PGI = $00800000;
+ GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000;
+ GL_MAT_SHININESS_BIT_PGI = $02000000;
+ GL_MAT_SPECULAR_BIT_PGI = $04000000;
+ GL_NORMAL_BIT_PGI = $08000000;
+ GL_TEXCOORD1_BIT_PGI = $10000000;
+ GL_TEXCOORD2_BIT_PGI = $20000000;
+ GL_TEXCOORD3_BIT_PGI = $40000000;
+ GL_TEXCOORD4_BIT_PGI = $80000000;
+ GL_VERTEX23_BIT_PGI = $00000004;
+ GL_VERTEX4_BIT_PGI = $00000008;
+
+ // GL_REND_screen_coordinates
+ GL_SCREEN_COORDINATES_REND = $8490;
+ GL_INVERTED_SCREEN_W_REND = $8491;
+
+ // GL_S3_s3tc
+ GL_RGB_S3TC = $83A0;
+ GL_RGB4_S3TC = $83A1;
+ GL_RGBA_S3TC = $83A2;
+ GL_RGBA4_S3TC = $83A3;
+
+ // GL_SGIS_detail_texture
+ GL_DETAIL_TEXTURE_2D_SGIS = $8095;
+ GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096;
+ GL_LINEAR_DETAIL_SGIS = $8097;
+ GL_LINEAR_DETAIL_ALPHA_SGIS = $8098;
+ GL_LINEAR_DETAIL_COLOR_SGIS = $8099;
+ GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A;
+ GL_DETAIL_TEXTURE_MODE_SGIS = $809B;
+ GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C;
+
+ // GL_SGIS_fog_function
+ GL_FOG_FUNC_SGIS = $812A;
+ GL_FOG_FUNC_POINTS_SGIS = $812B;
+ GL_MAX_FOG_FUNC_POINTS_SGIS = $812C;
+
+ // GL_SGIS_generate_mipmap
+ GL_GENERATE_MIPMAP_SGIS = $8191;
+ GL_GENERATE_MIPMAP_HINT_SGIS = $8192;
+
+ // GL_SGIS_multisample
+ GL_MULTISAMPLE_SGIS = $809D;
+ GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E;
+ GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F;
+ GL_SAMPLE_MASK_SGIS = $80A0;
+ GL_1PASS_SGIS = $80A1;
+ GL_2PASS_0_SGIS = $80A2;
+ GL_2PASS_1_SGIS = $80A3;
+ GL_4PASS_0_SGIS = $80A4;
+ GL_4PASS_1_SGIS = $80A5;
+ GL_4PASS_2_SGIS = $80A6;
+ GL_4PASS_3_SGIS = $80A7;
+ GL_SAMPLE_BUFFERS_SGIS = $80A8;
+ GL_SAMPLES_SGIS = $80A9;
+ GL_SAMPLE_MASK_VALUE_SGIS = $80AA;
+ GL_SAMPLE_MASK_INVERT_SGIS = $80AB;
+ GL_SAMPLE_PATTERN_SGIS = $80AC;
+
+ // GL_SGIS_pixel_texture
+ GL_PIXEL_TEXTURE_SGIS = $8353;
+ GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354;
+ GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355;
+ GL_PIXEL_GROUP_COLOR_SGIS = $8356;
+
+ // GL_SGIS_point_line_texgen
+ GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0;
+ GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1;
+ GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2;
+ GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3;
+ GL_EYE_POINT_SGIS = $81F4;
+ GL_OBJECT_POINT_SGIS = $81F5;
+ GL_EYE_LINE_SGIS = $81F6;
+ GL_OBJECT_LINE_SGIS = $81F7;
+
+ // GL_SGIS_point_parameters
+ GL_POINT_SIZE_MIN_SGIS = $8126;
+ GL_POINT_SIZE_MAX_SGIS = $8127;
+ GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128;
+ GL_DISTANCE_ATTENUATION_SGIS = $8129;
+
+ // GL_SGIS_sharpen_texture
+ GL_LINEAR_SHARPEN_SGIS = $80AD;
+ GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE;
+ GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF;
+ GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0;
+
+ // GL_SGIS_texture4D
+ GL_PACK_SKIP_VOLUMES_SGIS = $8130;
+ GL_PACK_IMAGE_DEPTH_SGIS = $8131;
+ GL_UNPACK_SKIP_VOLUMES_SGIS = $8132;
+ GL_UNPACK_IMAGE_DEPTH_SGIS = $8133;
+ GL_TEXTURE_4D_SGIS = $8134;
+ GL_PROXY_TEXTURE_4D_SGIS = $8135;
+ GL_TEXTURE_4DSIZE_SGIS = $8136;
+ GL_TEXTURE_WRAP_Q_SGIS = $8137;
+ GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138;
+ GL_TEXTURE_4D_BINDING_SGIS = $814F;
+
+ // GL_SGIS_texture_color_mask
+ GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;
+
+ // GL_SGIS_texture_edge_clamp
+ GL_CLAMP_TO_EDGE_SGIS = $812F;
+
+ // GL_SGIS_texture_filter4
+ GL_FILTER4_SGIS = $8146;
+ GL_TEXTURE_FILTER4_SIZE_SGIS = $8147;
+
+ // GL_SGIS_texture_lod
+ GL_TEXTURE_MIN_LOD_SGIS = $813A;
+ GL_TEXTURE_MAX_LOD_SGIS = $813B;
+ GL_TEXTURE_BASE_LEVEL_SGIS = $813C;
+ GL_TEXTURE_MAX_LEVEL_SGIS = $813D;
+
+ // GL_SGIS_texture_select
+ GL_DUAL_ALPHA4_SGIS = $8110;
+ GL_DUAL_ALPHA8_SGIS = $8111;
+ GL_DUAL_ALPHA12_SGIS = $8112;
+ GL_DUAL_ALPHA16_SGIS = $8113;
+ GL_DUAL_LUMINANCE4_SGIS = $8114;
+ GL_DUAL_LUMINANCE8_SGIS = $8115;
+ GL_DUAL_LUMINANCE12_SGIS = $8116;
+ GL_DUAL_LUMINANCE16_SGIS = $8117;
+ GL_DUAL_INTENSITY4_SGIS = $8118;
+ GL_DUAL_INTENSITY8_SGIS = $8119;
+ GL_DUAL_INTENSITY12_SGIS = $811A;
+ GL_DUAL_INTENSITY16_SGIS = $811B;
+ GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C;
+ GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D;
+ GL_QUAD_ALPHA4_SGIS = $811E;
+ GL_QUAD_ALPHA8_SGIS = $811F;
+ GL_QUAD_LUMINANCE4_SGIS = $8120;
+ GL_QUAD_LUMINANCE8_SGIS = $8121;
+ GL_QUAD_INTENSITY4_SGIS = $8122;
+ GL_QUAD_INTENSITY8_SGIS = $8123;
+ GL_DUAL_TEXTURE_SELECT_SGIS = $8124;
+ GL_QUAD_TEXTURE_SELECT_SGIS = $8125;
+
+ // GL_SGIX_async
+ GL_ASYNC_MARKER_SGIX = $8329;
+
+ // GL_SGIX_async_histogram
+ GL_ASYNC_HISTOGRAM_SGIX = $832C;
+ GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D;
+
+ // GL_SGIX_async_pixel
+ GL_ASYNC_TEX_IMAGE_SGIX = $835C;
+ GL_ASYNC_DRAW_PIXELS_SGIX = $835D;
+ GL_ASYNC_READ_PIXELS_SGIX = $835E;
+ GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F;
+ GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360;
+ GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361;
+
+ // GL_SGIX_blend_alpha_minmax
+ GL_ALPHA_MIN_SGIX = $8320;
+ GL_ALPHA_MAX_SGIX = $8321;
+
+ // GL_SGIX_calligraphic_fragment
+ GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183;
+
+ // GL_SGIX_clipmap
+ GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170;
+ GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171;
+ GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172;
+ GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173;
+ GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174;
+ GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175;
+ GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176;
+ GL_MAX_CLIPMAP_DEPTH_SGIX = $8177;
+ GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178;
+ GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D;
+ GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E;
+ GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F;
+
+ // GL_SGIX_convolution_accuracy
+ GL_CONVOLUTION_HINT_SGIX = $8316;
+
+ // GL_SGIX_depth_texture
+ GL_DEPTH_COMPONENT16_SGIX = $81A5;
+ GL_DEPTH_COMPONENT24_SGIX = $81A6;
+ GL_DEPTH_COMPONENT32_SGIX = $81A7;
+
+ // GL_SGIX_fog_offset
+ GL_FOG_OFFSET_SGIX = $8198;
+ GL_FOG_OFFSET_VALUE_SGIX = $8199;
+
+ // GL_SGIX_fog_scale
+ GL_FOG_SCALE_SGIX = $81FC;
+ GL_FOG_SCALE_VALUE_SGIX = $81FD;
+
+ // GL_SGIX_fragment_lighting
+ GL_FRAGMENT_LIGHTING_SGIX = $8400;
+ GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401;
+ GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402;
+ GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403;
+ GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404;
+ GL_MAX_ACTIVE_LIGHTS_SGIX = $8405;
+ GL_CURRENT_RASTER_NORMAL_SGIX = $8406;
+ GL_LIGHT_ENV_MODE_SGIX = $8407;
+ GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408;
+ GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409;
+ GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A;
+ GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B;
+ GL_FRAGMENT_LIGHT0_SGIX = $840C;
+ GL_FRAGMENT_LIGHT1_SGIX = $840D;
+ GL_FRAGMENT_LIGHT2_SGIX = $840E;
+ GL_FRAGMENT_LIGHT3_SGIX = $840F;
+ GL_FRAGMENT_LIGHT4_SGIX = $8410;
+ GL_FRAGMENT_LIGHT5_SGIX = $8411;
+ GL_FRAGMENT_LIGHT6_SGIX = $8412;
+ GL_FRAGMENT_LIGHT7_SGIX = $8413;
+
+ // GL_SGIX_framezoom
+ GL_FRAMEZOOM_SGIX = $818B;
+ GL_FRAMEZOOM_FACTOR_SGIX = $818C;
+ GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D;
+
+ // GL_SGIX_impact_pixel_texture
+ GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184;
+ GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185;
+ GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186;
+ GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187;
+ GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188;
+ GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189;
+ GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A;
+
+ // GL_SGIX_instruments
+ GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180;
+ GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181;
+
+ // GL_SGIX_interlace
+ GL_INTERLACE_SGIX = $8094;
+
+ // GL_SGIX_ir_instrument1
+ GL_IR_INSTRUMENT1_SGIX = $817F;
+
+ // GL_SGIX_list_priority
+ GL_LIST_PRIORITY_SGIX = $8182;
+
+ // GL_SGIX_pixel_texture
+ GL_PIXEL_TEX_GEN_SGIX = $8139;
+ GL_PIXEL_TEX_GEN_MODE_SGIX = $832B;
+
+ // GL_SGIX_pixel_tiles
+ GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E;
+ GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F;
+ GL_PIXEL_TILE_WIDTH_SGIX = $8140;
+ GL_PIXEL_TILE_HEIGHT_SGIX = $8141;
+ GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142;
+ GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143;
+ GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144;
+ GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145;
+
+ // GL_SGIX_polynomial_ffd
+ GL_GEOMETRY_DEFORMATION_SGIX = $8194;
+ GL_TEXTURE_DEFORMATION_SGIX = $8195;
+ GL_DEFORMATIONS_MASK_SGIX = $8196;
+ GL_MAX_DEFORMATION_ORDER_SGIX = $8197;
+
+ // GL_SGIX_reference_plane
+ GL_REFERENCE_PLANE_SGIX = $817D;
+ GL_REFERENCE_PLANE_EQUATION_SGIX = $817E;
+
+ // GL_SGIX_resample
+ GL_PACK_RESAMPLE_SGIX = $842C;
+ GL_UNPACK_RESAMPLE_SGIX = $842D;
+ GL_RESAMPLE_REPLICATE_SGIX = $842E;
+ GL_RESAMPLE_ZERO_FILL_SGIX = $842F;
+ GL_RESAMPLE_DECIMATE_SGIX = $8430;
+
+ // GL_SGIX_scalebias_hint
+ GL_SCALEBIAS_HINT_SGIX = $8322;
+
+ // GL_SGIX_shadow
+ GL_TEXTURE_COMPARE_SGIX = $819A;
+ GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B;
+ GL_TEXTURE_LEQUAL_R_SGIX = $819C;
+ GL_TEXTURE_GEQUAL_R_SGIX = $819D;
+
+ // GL_SGIX_shadow_ambient
+ GL_SHADOW_AMBIENT_SGIX = $80BF;
+
+ // GL_SGIX_sprite
+ GL_SPRITE_SGIX = $8148;
+ GL_SPRITE_MODE_SGIX = $8149;
+ GL_SPRITE_AXIS_SGIX = $814A;
+ GL_SPRITE_TRANSLATION_SGIX = $814B;
+ GL_SPRITE_AXIAL_SGIX = $814C;
+ GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D;
+ GL_SPRITE_EYE_ALIGNED_SGIX = $814E;
+
+ // GL_SGIX_subsample
+ GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0;
+ GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1;
+ GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2;
+ GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3;
+ GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4;
+
+ // GL_SGIX_texture_add_env
+ GL_TEXTURE_ENV_BIAS_SGIX = $80BE;
+
+ // GL_SGIX_texture_coordinate_clamp
+ GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369;
+ GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A;
+ GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B;
+
+ // GL_SGIX_texture_lod_bias
+ GL_TEXTURE_LOD_BIAS_S_SGIX = $818E;
+ GL_TEXTURE_LOD_BIAS_T_SGIX = $818F;
+ GL_TEXTURE_LOD_BIAS_R_SGIX = $8190;
+
+ // GL_SGIX_texture_multi_buffer
+ GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E;
+
+ // GL_SGIX_texture_scale_bias
+ GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179;
+ GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A;
+ GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B;
+ GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C;
+
+ // GL_SGIX_vertex_preclip
+ GL_VERTEX_PRECLIP_SGIX = $83EE;
+ GL_VERTEX_PRECLIP_HINT_SGIX = $83EF;
+
+ // GL_SGIX_ycrcb
+ GL_YCRCB_422_SGIX = $81BB;
+ GL_YCRCB_444_SGIX = $81BC;
+
+ // GL_SGIX_ycrcba
+ GL_YCRCB_SGIX = $8318;
+ GL_YCRCBA_SGIX = $8319;
+
+ // GL_SGI_color_matrix
+ GL_COLOR_MATRIX_SGI = $80B1;
+ GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2;
+ GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3;
+ GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4;
+ GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5;
+ GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6;
+ GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7;
+ GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8;
+ GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9;
+ GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA;
+ GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB;
+
+ // GL_SGI_color_table
+ GL_COLOR_TABLE_SGI = $80D0;
+ GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1;
+ GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2;
+ GL_PROXY_COLOR_TABLE_SGI = $80D3;
+ GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4;
+ GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5;
+ GL_COLOR_TABLE_SCALE_SGI = $80D6;
+ GL_COLOR_TABLE_BIAS_SGI = $80D7;
+ GL_COLOR_TABLE_FORMAT_SGI = $80D8;
+ GL_COLOR_TABLE_WIDTH_SGI = $80D9;
+ GL_COLOR_TABLE_RED_SIZE_SGI = $80DA;
+ GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB;
+ GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC;
+ GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD;
+ GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE;
+ GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF;
+
+ // GL_SGI_depth_pass_instrument
+ GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310;
+ GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311;
+ GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312;
+
+ // GL_SGI_texture_color_table
+ GL_TEXTURE_COLOR_TABLE_SGI = $80BC;
+ GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD;
+
+ // GL_SUNX_constant_data
+ GL_UNPACK_CONSTANT_DATA_SUNX = $81D5;
+ GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6;
+
+ // GL_SUN_convolution_border_modes
+ GL_WRAP_BORDER_SUN = $81D4;
+
+ // GL_SUN_global_alpha
+ GL_GLOBAL_ALPHA_SUN = $81D9;
+ GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA;
+
+ // GL_SUN_mesh_array
+ GL_QUAD_MESH_SUN = $8614;
+ GL_TRIANGLE_MESH_SUN = $8615;
+
+ // GL_SUN_slice_accum
+ GL_SLICE_ACCUM_SUN = $85CC;
+
+ // GL_SUN_triangle_list
+ GL_RESTART_SUN = $0001;
+ GL_REPLACE_MIDDLE_SUN = $0002;
+ GL_REPLACE_OLDEST_SUN = $0003;
+ GL_TRIANGLE_LIST_SUN = $81D7;
+ GL_REPLACEMENT_CODE_SUN = $81D8;
+ GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0;
+ GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1;
+ GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2;
+ GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3;
+ GL_R1UI_V3F_SUN = $85C4;
+ GL_R1UI_C4UB_V3F_SUN = $85C5;
+ GL_R1UI_C3F_V3F_SUN = $85C6;
+ GL_R1UI_N3F_V3F_SUN = $85C7;
+ GL_R1UI_C4F_N3F_V3F_SUN = $85C8;
+ GL_R1UI_T2F_V3F_SUN = $85C9;
+ GL_R1UI_T2F_N3F_V3F_SUN = $85CA;
+ GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB;
+
+ // GL_WIN_phong_shading
+ GL_PHONG_WIN = $80EA;
+ GL_PHONG_HINT_WIN = $80EB;
+
+ // GL_WIN_specular_fog
+ GL_FOG_SPECULAR_TEXTURE_WIN = $80EC;
+
+ // GL_ARB_vertex_shader
+ GL_VERTEX_SHADER_ARB = $8B31;
+ GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A;
+ GL_MAX_VARYING_FLOATS_ARB = $8B4B;
+ GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
+ GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D;
+ GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89;
+ GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A;
+
+ // GL_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_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_texture_buffer_object
+ TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_vertex_array_object
+ TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_uniform_buffer_object
+ TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_copy_buffer
+ TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_draw_elements_base_vertex
+ TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_provoking_vertex
+ TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_sync
+ TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_texture_multisample
+ TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_draw_buffers_blend
+ TglBlendEquationiARB = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBlendEquationSeparateiARB = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBlendFunciARB = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBlendFuncSeparateiARB = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_sample_shading
+ TglMinSampleShadingARB = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_shading_language_include
+ TglNamedStringARB = procedure(type_: GLenum; namelen: GLint; const name: PGLchar; stringlen: GLint; const string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteNamedStringARB = procedure(namelen: GLint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCompileShaderIncludeARB = procedure (shader: GLuint; count: GLsizei; const path: PPGLchar; const length: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsNamedStringARB = function(namelen: GLint; const name: PGLchar): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetNamedStringARB = procedure(namelen: GLint; const name: PGLchar; bufSize: GLsizei; stringlen: GLint; string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetNamedStringivARB = procedure(namelen: GLint; const name: PGLchar; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_blend_func_extended
+ TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_sampler_objects
+ TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_timer_query
+ TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_vertex_type_2_10_10_10_rev
+ TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_draw_indirect
+ TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_gpu_shader_fp64
+ TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_shader_subroutine
+ TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_tessellation_shader
+ TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_transform_feedback2
+ TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_transform_feedback3
+ TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_ES2_compatibility
+ TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_get_program_binary
+ TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_separate_shader_objects
+ TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_vertex_attrib_64bit
+ TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_viewport_array
+ TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL 4.2
+
+ // GL_ARB_base_instance
+ TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_transform_feedback_instanced
+ TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_internalformat_query
+ TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_shader_atomic_counters
+ TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ /// GL_ARB_shader_image_load_store
+ TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_texture_storage
+ TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureStorage1DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureStorage2DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureStorage3DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+
+ // GL 4.3
+
+ // GL_KHR_debug
+ TglDebugMessageControl = procedure(source : GLenum; type_ : GLenum; severity : TGLenum; count : GLsizei; const ids : PGLUInt; enabled : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDebugMessageInsert = procedure(source : GLenum; type_ : GLenum; id : GLuint; sverity : GLenum; length : GLsizei; const buf : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDebugMessageCallback = procedure(callback : TGLDEBUGPROC; const userParam : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetDebugMessageLog = function(count : GLuint; bufsize : GLsizei; sources : PGLenum; types : PGLenum; ids : PGLuint; sverities : PGLenum; lengths : PGLSizei; messagelog : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPushDebugGroup = procedure(source : GLenum; id : GLuint; length : GLsizei; const message_ : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPopDebugGroup = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglObjectLabel = procedure(identifier : GLenum; name : GLuint; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetObjectLabel = procedure(identifier : GLenum; name : GLuint; bufsize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglObjectPtrLabel = procedure(const ptr : Pointer; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetObjectPtrLabel = procedure(const ptr : Pointer; bufSize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_clear_buffer_object
+ TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearNamedBufferDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearNamedBufferSubDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLenum; type_ : GLenum; offset : GLsizeiptr; size : GLsizeiptr; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_compute_shader
+ TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_copy_image
+ TglCopyImageSubData = procedure(srcName : GLUInt; srcTarget : GLenum; srcLevel : GLint; srcX : GLint; srcY : GLint; srcZ : GLint; dstName : GLUInt; dstTarget : GLEnum; dstLevel : GLInt; dstX : GLInt; dstY : GLint; dstZ : GLint; srcWidth : GLsizei; srcHeight : GLsizei; srcDepth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_debug_group
+ // ARB_debug_group reuses entry points from KHR_debug
+
+ // GL_ARB_debug_label
+ // ARB_debug_label reuses entry points from KHR_debug
+
+ // GL_ARB_debug_output2
+
+ // GL_ARB_ES3_compatibility
+
+ // GL_ARB_explicit_uniform_location
+
+ // GL_ARB_fragment_layer_viewport
+
+ // GL_ARB_framebuffer_no_attachments
+ TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNamedFramebufferParameteriEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetNamedFramebufferParameterivEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_internalformat_query2
+ TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_invalidate_subdata
+ TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_multi_draw_indirect
+ TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_program_interface_query
+ TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_robust_buffer_access_behavior
+
+ // GL_ARB_shader_image_size
+
+ // GL_ARB_shader_storage_buffer_object
+ TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_stencil_texturing
+
+ // GL_ARB_texture_buffer_range
+ TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureBufferRangeEXT = procedure(texture : GLuint; target : GLenum; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_ARB_texture_query_levels
+
+ // GL_ARB_texture_storage_multisample
+ TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureStorage2DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTextureStorage3DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL 4.4
+
+ TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ 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_parallel_arrays
+ TglVertexPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormalPointervINTEL = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_MESA_resize_buffers
+ TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_MESA_window_pos
+ TglWindowPos2dMESA = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2fMESA = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2iMESA = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2sMESA = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3iMESA = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3sMESA = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4iMESA = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4sMESA = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_evaluators
+ TglMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMapParameterivNV = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMapParameterfvNV = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMapParameterivNV = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMapParameterfvNV = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMapAttribParameterivNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetMapAttribParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEvalMapsNV = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_fence
+ TglDeleteFencesNV = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenFencesNV = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTestFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFenceivNV = procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFinishFenceNV = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSetFenceNV = procedure(fence: GLuint; condition: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_fragment_program
+ TglProgramNamedParameter4fNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramNamedParameter4dNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramNamedParameter4fvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramNamedParameter4dvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramNamedParameterfvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramNamedParameterdvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_half_float
+ TglVertex2hNV = procedure(x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertex3hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertex4hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormal3hNV = procedure(nx: GLhalfNV; ny: GLhalfNV; nz: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColor4hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV; alpha: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord1hNV = procedure(s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord2hNV = procedure(s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord3hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord4hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord1hNV = procedure(target: GLenum; s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord1hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord2hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord2hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord3hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord3hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord4hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMultiTexCoord4hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFogCoordhNV = procedure(fog: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSecondaryColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexWeighthNV = procedure(weight: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1hNV = procedure(index: GLuint; x: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs1hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs2hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs3hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs4hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_occlusion_query
+ TglGenOcclusionQueriesNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteOcclusionQueriesNV = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsOcclusionQueryNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBeginOcclusionQueryNV = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetOcclusionQueryivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetOcclusionQueryuivNV = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_pixel_data_range
+ TglPixelDataRangeNV = procedure(target: GLenum; length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFlushPixelDataRangeNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_point_sprite
+ TglPointParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPointParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_primitive_restart
+ TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPrimitiveRestartIndexNV = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_register_combiners
+ TglCombinerParameterfvNV = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCombinerParameterfNV = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCombinerParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCombinerParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCombinerInputNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCombinerOutputNV = procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFinalCombinerInputNV = procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetCombinerInputParameterfvNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetCombinerInputParameterivNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetCombinerOutputParameterfvNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetCombinerOutputParameterivNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFinalCombinerInputParameterfvNV = procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetFinalCombinerInputParameterivNV = procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_register_combiners2
+ TglCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_vertex_array_range
+ TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexArrayRangeNV = procedure(length: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_vertex_program
+ TglAreProgramsResidentNV = function(n: GLsizei; const programs: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindProgramNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglExecuteProgramNV = procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenProgramsNV = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramParameterdvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramStringNV = procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetTrackMatrixivNV = procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribdvNV = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribfvNV = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribivNV = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribPointervNV = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsProgramNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglLoadProgramNV = procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameter4dNV = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameter4dvNV = procedure(target: GLenum; index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameter4fNV = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameter4fvNV = procedure(target: GLenum; index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameters4dvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramParameters4fvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglRequestResidentProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTrackMatrixNV = procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribPointerNV = procedure(index: GLuint; fsize: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1dNV = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1fNV = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1sNV = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib1svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2sNV = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib2svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib3svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4ubNV = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttrib4ubvNV = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs1dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs1fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs1svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs2dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs2fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs2svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs3dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs3fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs3svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs4dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs4fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs4svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribs4ubvNV = procedure(index: GLuint; count: GLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_depth_buffer_float
+ TglDepthRangedNV = procedure(n: GLdouble; f: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglClearDepthdNV = procedure(d: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDepthBoundsdNV = procedure(zmin: GLdouble; zmax: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_framebuffer_multisample_coverage
+ TglRenderbufferStorageMultsampleCoverageNV = procedure(target: GLenum; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_geometry_program4
+ TglProgramVertexLimitNV = procedure(target: GLenum; limit: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_gpu_program4
+ TglProgramLocalParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramLocalParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramLocalParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramLocalParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramLocalParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramLocalParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramEnvParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramLocalParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramLocalParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramEnvParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramEnvParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_parameter_buffer_object
+ TglProgramBufferParametersfvNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramBufferParametersIivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramBufferParametersIuivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_transform_feedback
+ TglBeginTransformFeedbackNV = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTransformFeedbackAttribsNV = procedure(count: GLsizei; const attribs: GLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTransformFeedbackVaryingsNV = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglActiveVaryingNV = procedure(program_: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVaryingLocationNV = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetActiveVaryingNV = procedure(program_: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetTransformFeedbackVaryingNV = procedure(program_: GLuint; index: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTransformFeedbackStreamAttribsNV = procedure(count: GLsizei; const attribs: PGLint; nbuffers: GLsizei; const bufstreams: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_conditional_render
+ TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_present_video
+ TglPresentFrameKeyedNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDuratioId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; key0: GLuint; target1: GLenum; fill1: GLuint; key1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPresentFrameDualFillNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDurationId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; target1: GLenum; fill1: GLuint; target2: GLenum; fill2: GLuint; target3: GLenum; fill3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+// TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_explicit_multisample
+ TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_transform_feedback2
+ TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_video_capture
+ TglBeginVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindVideoCaptureStreamBufferNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; offset: GLintptrARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglBindVideoCaptureStreamTextureNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEndVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoCaptureivNV = procedure(video_capture_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoCaptureStreamivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoCaptureStreamfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVideoCaptureStreamdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVideoCaptureNV = function(video_capture_slot: GLuint; sequence_num: PGLuint; capture_time: PGLuint64EXT): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVideoCaptureStreamParameterivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVideoCaptureStreamParameterfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVideoCaptureStreamParameterdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_copy_image
+ TglCopyImageSubDataNV = procedure(srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_shader_buffer_load
+ TglMakeBufferResidentNV = procedure(target: GLenum; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeBufferNonResidentNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsBufferResidentNV = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeNamedBufferResidentNV = procedure(buffer: GLuint; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeNamedBufferNonResidentNV = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsNamedBufferResidentNV = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetBufferParameterui64vNV = procedure(target: GLenum; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetNamedBufferParameterui64vNV = procedure(buffer: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetIntegerui64vNV = procedure(value: GLenum; result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformui64NV = procedure(location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetUniformui64vNV = procedure(_program: GLuint; location: GLint; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformui64NV = procedure(_program: GLuint; location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformui64vNV = procedure(_program: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_vertex_buffer_unified_memory
+ TglBufferAddressRangeNV = procedure(pname: GLenum; index: GLuint; adress: GLuint64EXT; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglNormalFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIndexFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTexCoordFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglEdgeFlagFormatNV = procedure(stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglSecondaryColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglFogCoordFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribIFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetIntegerui64i_vNV = procedure(value: GLenum; index: GLuint; Result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_gpu_program5
+ TglProgramSubroutineParametersuivNV = procedure(target: GLenum; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetProgramSubroutineParameteruivNV = procedure(target: GLenum; index: GLuint; param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_gpu_shader5
+ TglUniform1i64NV = procedure(location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform1i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform1ui64NV = procedure(location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform1ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform2ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform3ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniform4ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetUniformi64vNV = procedure(program_: GLuint; location: GLint; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform1ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform2ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform3ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniform4ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_vertex_attrib_integer_64bit
+ TglVertexAttribL1i64NV = procedure(index: GLuint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL1i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL1ui64NV = procedure(index: GLuint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL1ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL2ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL3ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribL4ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribLi64vNV = procedure(index: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetVertexAttribLui64vNV = procedure(index: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVertexAttribLFormatNV = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_vdpau_interop
+ TglVDPAUInitNV = procedure(const vdpDevice: PGLvoid; const getProcAddress: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUFiniNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAURegisterVideoSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAURegisterOutputSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUIsSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUUnregisterSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUGetSurfaceivNV = procedure(surface: GLvdpauSurfaceNV; pname: GLenum; bufSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUSurfaceAccessNV = procedure(surface: GLvdpauSurfaceNV; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUMapSurfacesNV = procedure(numSurfaces: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglVDPAUUnmapSurfacesNV = procedure(numSurface: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_NV_texture_barrier
+ TglTextureBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // (4.3)
+ // GL_NV_path_rendering
+ TglGenPathsNV = function(range : GLsizei) : GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglDeletePathsNV = procedure(path : GLUInt; range : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsPathNV = function(path : GLUInt) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathCommandsNV = procedure(path : GLUInt; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLsizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathCoordsNV = procedure(path : GLUInt; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathSubCommandsNV = procedure(path : GLUInt; commandStart : GLsizei; commandsToDelete : GLsizei; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathSubCoordsNV = procedure(path : GLUInt; coordStart : GLsizei; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathStringNV = procedure(path : GLUInt; format : GLenum; length : GLsizei; const pathString : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathGlyphsNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; numGlyphs : GLsizei; type_ : GLenum; const charcodes : PGLvoid; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathGlyphRangeNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; firstGlyph : GLuint; numGlyphs : GLsizei; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglWeightPathsNV = procedure(resultPath : GLUInt; numPaths : GLSizei; const paths : PGLuint; const weights : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCopyPathNV = procedure(resultPath : GLUInt; srcPath : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglInterpolatePathsNV = procedure(resultPath : GLUInt; pathA : GLUInt; pathB : GLUInt; weight : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglTransformPathNV = procedure(resultPath : GLUInt; srcPath : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathParameteriNV = procedure(path : GLUInt; pname : GLEnum; value : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathParameterfNV = procedure(path : GLUInt; pname : GLEnum; value : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathDashArrayNV = procedure(path : GLUInt; dashCount : GLsizei; const dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathStencilFuncNV = procedure(func : GLenum; ref : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathStencilDepthOffsetNV = procedure(factor : GLfloat; units : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglStencilFillPathNV = procedure(path : GLUInt; fillMode : GLenum; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglStencilStrokePathNV = procedure(path : GLUInt; reference : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglStencilFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; fillMode : GLenum; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglStencilStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; reference : GLint; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathCoverDepthFuncNV = procedure(func : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathColorGenNV = procedure(color : GLenum; genMode : GLenum; colorFormat : GLenum; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathTexGenNV = procedure(texCoordSet : GLenum; genMode : GLenum; components : GLint; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPathFogGenNV = procedure(genMode : GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCoverFillPathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCoverStrokePathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCoverFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglCoverStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathCommandsNV = procedure(path : GLUInt; commands : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathCoordsNV = procedure(path : GLUInt; coords : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathDashArrayNV = procedure(path : GLUInt; dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathMetricsNV = procedure(metricQueryMask : GLbitfield; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathMetricRangeNV = procedure(metricQueryMask : GLbitfield; firstPathName : GLuint; numPaths : GLSizei; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathSpacingNV = procedure(pathListMode : GLenum; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; advanceScale : GLfloat; kerningScale : GLfloat; transformType : GLenum; returnedSpacing : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathColorGenivNV = procedure(color : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathColorGenfvNV = procedure(color : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathTexGenivNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathTexGenfvNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsPointInFillPathNV = function(path : GLUInt; mask : GLuint; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsPointInStrokePathNV = function (path : GLUInt; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetPathLengthNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei) : GLfloat; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglPointAlongPathNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei; distance : GLfloat; x : PGLfloat; y : PGLfloat; tangentX : PGLfloat; tangentY : PGLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_AMD_pinned_memory
+
+ // GL_AMD_stencil_operation_extended
+ TglStencilOpValueAMD = procedure(face : GLEnum; value : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_AMD_vertex_shader_viewport_index
+
+ // GL_AMD_vertex_shader_layer
+
+ // GL_NV_bindless_texture
+ TglGetTextureHandleNV = function(texture : GLuint ) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetTextureSamplerHandleNV = function(texture : GLuint; sampler : GLuint) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeTextureHandleResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeTextureHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglGetImageHandleNV = function(texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeImageHandleResidentNV = procedure(handle : GLUint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglMakeImageHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformHandleui64NV = procedure(location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglUniformHandleui64vNV = procedure(location : GLint; cowunt : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformHandleui64NV = procedure(program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglProgramUniformHandleui64vNV = procedure(program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsTextureHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+ TglIsImageHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+ // GL_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_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_shading_language_include
+ glNamedStringARB: TglNamedStringARB;
+ glDeleteNamedStringARB: TglDeleteNamedStringARB;
+ glCompileShaderIncludeARB: TglCompileShaderIncludeARB;
+ glIsNamedStringARB: TglIsNamedStringARB;
+ glGetNamedStringARB: TglGetNamedStringARB;
+ glGetNamedStringivARB: TglGetNamedStringivARB;
+
+ // GL_ARB_blend_func_extended
+ glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed;
+ glGetFragDataIndex: TglGetFragDataIndex;
+
+ // GL_ARB_sampler_objects
+ glGenSamplers: TglGenSamplers;
+ glDeleteSamplers: TglDeleteSamplers;
+ glIsSampler: TglIsSampler;
+ glBindSampler: TglBindSampler;
+ glSamplerParameteri: TglSamplerParameteri;
+ glSamplerParameteriv: TglSamplerParameteriv;
+ glSamplerParameterf: TglSamplerParameterf;
+ glSamplerParameterfv: TglSamplerParameterfv;
+ glSamplerParameterIiv: TglSamplerParameterIiv;
+ glSamplerParameterIuiv: TglSamplerParameterIuiv;
+ glGetSamplerParameteriv: TglGetSamplerParameteriv;
+ glGetSamplerParameterIiv: TglGetSamplerParameterIiv;
+ glGetSamplerParameterfv: TglGetSamplerParameterfv;
+ glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv;
+
+ // GL_ARB_timer_query
+ glQueryCounter: TglQueryCounter;
+ glGetQueryObjecti64v: TglGetQueryObjecti64v;
+ glGetQueryObjectui64v: TglGetQueryObjectui64v;
+
+ // GL_ARB_vertex_type_2_10_10_10_rev
+ glVertexP2ui: TglVertexP2ui;
+ glVertexP2uiv: TglVertexP2uiv;
+ glVertexP3ui: TglVertexP3ui;
+ glVertexP3uiv: TglVertexP3uiv;
+ glVertexP4ui: TglVertexP4ui;
+ glVertexP4uiv: TglVertexP4uiv;
+ glTexCoordP1ui: TglTexCoordP1ui;
+ glTexCoordP1uiv: TglTexCoordP1uiv;
+ glTexCoordP2ui: TglTexCoordP2ui;
+ glTexCoordP2uiv: TglTexCoordP2uiv;
+ glTexCoordP3ui: TglTexCoordP3ui;
+ glTexCoordP3uiv: TglTexCoordP3uiv;
+ glTexCoordP4ui: TglTexCoordP4ui;
+ glTexCoordP4uiv: TglTexCoordP4uiv;
+ glMultiTexCoordP1ui: TglMultiTexCoordP1ui;
+ glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv;
+ glMultiTexCoordP2ui: TglMultiTexCoordP2ui;
+ glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv;
+ glMultiTexCoordP3ui: TglMultiTexCoordP3ui;
+ glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv;
+ glMultiTexCoordP4ui: TglMultiTexCoordP4ui;
+ glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv;
+ glNormalP3ui: TglNormalP3ui;
+ glNormalP3uiv: TglNormalP3uiv;
+ glColorP3ui: TglColorP3ui;
+ glColorP3uiv: TglColorP3uiv;
+ glColorP4ui: TglColorP4ui;
+ glColorP4uiv: TglColorP4uiv;
+ glSecondaryColorP3ui: TglSecondaryColorP3ui;
+ glSecondaryColorP3uiv: TglSecondaryColorP3uiv;
+ glVertexAttribP1ui: TglVertexAttribP1ui;
+ glVertexAttribP1uiv: TglVertexAttribP1uiv;
+ glVertexAttribP2ui: TglVertexAttribP2ui;
+ glVertexAttribP2uiv: TglVertexAttribP2uiv;
+ glVertexAttribP3ui: TglVertexAttribP3ui;
+ glVertexAttribP3uiv: TglVertexAttribP3uiv;
+ glVertexAttribP4ui: TglVertexAttribP4ui;
+ glVertexAttribP4uiv: TglVertexAttribP4uiv;
+
+ // GL_ARB_draw_indirect
+ glDrawArraysIndirect: TglDrawArraysIndirect;
+ glDrawElementsIndirect: TglDrawElementsIndirect;
+
+ // GL_ARB_gpu_shader_fp64
+ glUniform1d: TglUniform1d;
+ glUniform2d: TglUniform2d;
+ glUniform3d: TglUniform3d;
+ glUniform4d: TglUniform4d;
+ glUniform1dv: TglUniform1dv;
+ glUniform2dv: TglUniform2dv;
+ glUniform3dv: TglUniform3dv;
+ glUniform4dv: TglUniform4dv;
+ glUniformMatrix2dv: TglUniformMatrix2dv;
+ glUniformMatrix3dv: TglUniformMatrix3dv;
+ glUniformMatrix4dv: TglUniformMatrix4dv;
+ glUniformMatrix2x3dv: TglUniformMatrix2x3dv;
+ glUniformMatrix2x4dv: TglUniformMatrix2x4dv;
+ glUniformMatrix3x2dv: TglUniformMatrix3x2dv;
+ glUniformMatrix3x4dv: TglUniformMatrix3x4dv;
+ glUniformMatrix4x2dv: TglUniformMatrix4x2dv;
+ glUniformMatrix4x3dv: TglUniformMatrix4x3dv;
+ glGetUniformdv: TglGetUniformdv;
+
+ // GL_ARB_shader_subroutine
+ glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation;
+ glGetSubroutineIndex: TglGetSubroutineIndex;
+ glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv;
+ glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName;
+ glGetActiveSubroutineName: TglGetActiveSubroutineName;
+ glUniformSubroutinesuiv: TglUniformSubroutinesuiv;
+ glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv;
+ glGetProgramStageiv: TglGetProgramStageiv;
+
+ // GL_ARB_tessellation_shader
+ glPatchParameteri: TglPatchParameteri;
+ glPatchParameterfv: TglPatchParameterfv;
+
+ // GL_ARB_transform_feedback2
+ glBindTransformFeedback: TglBindTransformFeedback;
+ glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks;
+ glGenTransformFeedbacks: TglGenTransformFeedbacks;
+ glIsTransformFeedback: TglIsTransformFeedback;
+ glPauseTransformFeedback: TglPauseTransformFeedback;
+ glResumeTransformFeedback: TglResumeTransformFeedback;
+ glDrawTransformFeedback: TglDrawTransformFeedback;
+
+ // GL_ARB_transform_feedback3
+ glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream;
+ glBeginQueryIndexed: TglBeginQueryIndexed;
+ glEndQueryIndexed: TglEndQueryIndexed;
+ glGetQueryIndexediv: TglGetQueryIndexediv;
+
+ // GL_ARB_ES2_compatibility
+ glReleaseShaderCompiler: TglReleaseShaderCompiler;
+ glShaderBinary: TglShaderBinary;
+ glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat;
+ glDepthRangef: TglDepthRangef;
+ glClearDepthf: TglClearDepthf;
+
+ // GL_ARB_get_program_binary
+ glGetProgramBinary: TglGetProgramBinary;
+ glProgramBinary: TglProgramBinary;
+ glProgramParameteri: TglProgramParameteri;
+
+ // GL_ARB_separate_shader_objects
+ glUseProgramStages: TglUseProgramStages;
+ glActiveShaderProgram: TglActiveShaderProgram;
+ glCreateShaderProgramv: TglCreateShaderProgramv;
+ glBindProgramPipeline: TglBindProgramPipeline;
+ glDeleteProgramPipelines: TglDeleteProgramPipelines;
+ glGenProgramPipelines: TglGenProgramPipelines;
+ glIsProgramPipeline: TglIsProgramPipeline;
+ glGetProgramPipelineiv: TglGetProgramPipelineiv;
+ glProgramUniform1i: TglProgramUniform1i;
+ glProgramUniform1iv: TglProgramUniform1iv;
+ glProgramUniform1f: TglProgramUniform1f;
+ glProgramUniform1fv: TglProgramUniform1fv;
+ glProgramUniform1d: TglProgramUniform1d;
+ glProgramUniform1dv: TglProgramUniform1dv;
+ glProgramUniform1ui: TglProgramUniform1ui;
+ glProgramUniform1uiv: TglProgramUniform1uiv;
+ glProgramUniform2i: TglProgramUniform2i;
+ glProgramUniform2iv: TglProgramUniform2iv;
+ glProgramUniform2f: TglProgramUniform2f;
+ glProgramUniform2fv: TglProgramUniform2fv;
+ glProgramUniform2d: TglProgramUniform2d;
+ glProgramUniform2dv: TglProgramUniform2dv;
+ glProgramUniform2ui: TglProgramUniform2ui;
+ glProgramUniform2uiv: TglProgramUniform2uiv;
+ glProgramUniform3i: TglProgramUniform3i;
+ glProgramUniform3iv: TglProgramUniform3iv;
+ glProgramUniform3f: TglProgramUniform3f;
+ glProgramUniform3fv: TglProgramUniform3fv;
+ glProgramUniform3d: TglProgramUniform3d;
+ glProgramUniform3dv: TglProgramUniform3dv;
+ glProgramUniform3ui: TglProgramUniform3ui;
+ glProgramUniform3uiv: TglProgramUniform3uiv;
+ glProgramUniform4i: TglProgramUniform4i;
+ glProgramUniform4iv: TglProgramUniform4iv;
+ glProgramUniform4f: TglProgramUniform4f;
+ glProgramUniform4fv: TglProgramUniform4fv;
+ glProgramUniform4d: TglProgramUniform4d;
+ glProgramUniform4dv: TglProgramUniform4dv;
+ glProgramUniform4ui: TglProgramUniform4ui;
+ glProgramUniform4uiv: TglProgramUniform4uiv;
+ glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv;
+ glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv;
+ glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv;
+ glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv;
+ glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv;
+ glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv;
+ glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv;
+ glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv;
+ glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv;
+ glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv;
+ glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv;
+ glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv;
+ glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv;
+ glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv;
+ glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv;
+ glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv;
+ glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv;
+ glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv;
+ glValidateProgramPipeline: TglValidateProgramPipeline;
+ glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog;
+
+ // GL_ARB_vertex_attrib_64bit
+ glVertexAttribL1d: TglVertexAttribL1d;
+ glVertexAttribL2d: TglVertexAttribL2d;
+ glVertexAttribL3d: TglVertexAttribL3d;
+ glVertexAttribL4d: TglVertexAttribL4d;
+ glVertexAttribL1dv: TglVertexAttribL1dv;
+ glVertexAttribL2dv: TglVertexAttribL2dv;
+ glVertexAttribL3dv: TglVertexAttribL3dv;
+ glVertexAttribL4dv: TglVertexAttribL4dv;
+ glVertexAttribLPointer: TglVertexAttribLPointer;
+ glGetVertexAttribLdv: TglGetVertexAttribLdv;
+
+ // GL_ARB_viewport_array
+ glViewportArrayv: TglViewportArrayv;
+ glViewportIndexedf: TglViewportIndexedf;
+ glViewportIndexedfv: TglViewportIndexedfv;
+ glScissorArrayv: TglScissorArrayv;
+ glScissorIndexed: TglScissorIndexed;
+ glScissorIndexedv: TglScissorIndexedv;
+ glDepthRangeArrayv: TglDepthRangeArrayv;
+ glDepthRangeIndexed: TglDepthRangeIndexed;
+ glGetFloati_v: TglGetFloati_v;
+ glGetDoublei_v: TglGetDoublei_v;
+
+ // GL 4.2
+
+ // GL_ARB_base_instance
+ glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance;
+ glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance;
+ glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance;
+
+ // GL_ARB_transform_feedback_instanced
+ glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced;
+ glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced;
+
+ // GL_ARB_internalformat_query
+ glGetInternalformativ : TglGetInternalformativ;
+
+ // GL_ARB_shader_atomic_counters
+ glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv;
+
+ /// GL_ARB_shader_image_load_store
+ glBindImageTexture : TglBindImageTexture;
+ glMemoryBarrier : TglMemoryBarrier;
+
+ // GL_ARB_texture_storage
+ glTexStorage1D : TglTexStorage1D;
+ glTexStorage2D : TglTexStorage2D;
+ glTexStorage3D : TglTexStorage3D;
+ glTextureStorage1DEXT : TglTextureStorage1DEXT;
+ glTextureStorage2DEXT : TglTextureStorage2DEXT;
+ glTextureStorage3DEXT : TglTextureStorage3DEXT;
+
+
+ // GL 4.3
+ // GL_KHR_debug
+ glDebugMessageControl : TglDebugMessageControl;
+ glDebugMessageInsert : TglDebugMessageInsert;
+ glDebugMessageCallback : TglDebugMessageCallback;
+ glGetDebugMessageLog : TglGetDebugMessageLog;
+ glPushDebugGroup : TglPushDebugGroup;
+ glPopDebugGroup : TglPopDebugGroup;
+ glObjectLabel : TglObjectLabel;
+ glGetObjectLabel : TglGetObjectLabel;
+ glObjectPtrLabel : TglObjectPtrLabel;
+ glGetObjectPtrLabel : TglGetObjectPtrLabel;
+ // GL_ARB_clear_buffer_object
+ glClearBufferData : TglClearBufferData;
+ glClearBufferSubData : TglClearBufferSubData;
+ glClearNamedBufferDataEXT : TglClearNamedBufferDataEXT;
+ glClearNamedBufferSubDataEXT : TglClearNamedBufferSubDataEXT;
+ // GL_ARB_compute_shader
+ glDispatchCompute : TglDispatchCompute;
+ glDispatchComputeIndirect : TglDispatchComputeIndirect;
+ // GL_ARB_copy_image
+ glCopyImageSubData : TglCopyImageSubData;
+ // GL_ARB_framebuffer_no_attachments
+ glFramebufferParameteri : TglFramebufferParameteri;
+ glGetFramebufferParameteriv : TglGetFramebufferParameteriv;
+ glNamedFramebufferParameteriEXT : TglNamedFramebufferParameteriEXT;
+ glGetNamedFramebufferParameterivEXT : TglGetNamedFramebufferParameterivEXT;
+ // GL_ARB_internalformat_query2
+ glGetInternalformati64v : TglGetInternalformati64v;
+ // GL_ARB_invalidate_subdata
+ glInvalidateTexSubImage : TglInvalidateTexSubImage;
+ glInvalidateTexImage : TglInvalidateTexImage;
+ glInvalidateBufferSubData : TglInvalidateBufferSubData;
+ glInvalidateBufferData : TglInvalidateBufferData;
+ glInvalidateFramebuffer : TglInvalidateFramebuffer;
+ glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer;
+ // GL_ARB_multi_draw_indirect
+ glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect;
+ glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect;
+ // GL_ARB_program_interface_query
+ glGetProgramInterfaceiv : TglGetProgramInterfaceiv;
+ glGetProgramResourceIndex : TglGetProgramResourceIndex;
+ glGetProgramResourceName : TglGetProgramResourceName;
+ glGetProgramResourceiv : TglGetProgramResourceiv;
+ glGetProgramResourceLocation : TglGetProgramResourceLocation;
+ glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex;
+ // GL_ARB_shader_storage_buffer_object
+ glShaderStorageBlockBinding : TglShaderStorageBlockBinding;
+ // GL_ARB_texture_buffer_range
+ glTexBufferRange : TglTexBufferRange;
+ glTextureBufferRangeEXT : TglTextureBufferRangeEXT;
+ // GL_ARB_texture_storage_multisample
+ glTexStorage2DMultisample : TglTexStorage2DMultisample;
+ glTexStorage3DMultisample : TglTexStorage3DMultisample;
+ glTextureStorage2DMultisampleEXT : TglTextureStorage2DMultisampleEXT;
+ glTextureStorage3DMultisampleEXT : TglTextureStorage3DMultisampleEXT;
+ // GL_ARB_texture_view
+ glTextureView : TglTextureView;
+ // GL_ARB_vertex_attrib_binding
+ glBindVertexBuffer : TglBindVertexBuffer;
+ glVertexAttribFormat : TglVertexAttribFormat;
+ glVertexAttribIFormat : TglVertexAttribIFormat;
+ glVertexAttribLFormat : TglVertexAttribLFormat;
+ glVertexAttribBinding : TglVertexAttribBinding;
+ glVertexBindingDivisor : TglVertexBindingDivisor;
+ glVertexArrayBindVertexBufferEXT : TglVertexArrayBindVertexBufferEXT;
+ glVertexArrayVertexAttribFormatEXT : TglVertexArrayVertexAttribFormatEXT;
+ glVertexArrayVertexAttribIFormatEXT : TglVertexArrayVertexAttribIFormatEXT;
+ glVertexArrayVertexAttribLFormatEXT : TglVertexArrayVertexAttribLFormatEXT;
+ glVertexArrayVertexAttribBindingEXT : TglVertexArrayVertexAttribBindingEXT;
+ glVertexArrayVertexBindingDivisorEXT : TglVertexArrayVertexBindingDivisorEXT;
+ // END GL 4.3
+
+
+ // GL 4.4
+ glBufferStorage : TglBufferStorage;
+ glClearTexImage : TglClearTexImage;
+ glClearTexSubImage : TglClearTexSubImage;
+ glBindBuffersBase : TglBindBuffersBase;
+ glBindBuffersRange : TglBindBuffersRange;
+ glBindTextures : TglBindTextures;
+ glBindSamplers : TglBindSamplers;
+ glBindImageTextures : TglBindImageTextures;
+ glBindVertexBuffers : TglBindVertexBuffers;
+ 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_parallel_arrays
+ glVertexPointervINTEL: TglVertexPointervINTEL;
+ glNormalPointervINTEL: TglNormalPointervINTEL;
+ glColorPointervINTEL: TglColorPointervINTEL;
+ glTexCoordPointervINTEL: TglTexCoordPointervINTEL;
+
+ // GL_MESA_resize_buffers
+ glResizeBuffersMESA: TglResizeBuffersMESA;
+
+ // GL_MESA_window_pos
+ glWindowPos2dMESA: TglWindowPos2dMESA;
+ glWindowPos2dvMESA: TglWindowPos2dvMESA;
+ glWindowPos2fMESA: TglWindowPos2fMESA;
+ glWindowPos2fvMESA: TglWindowPos2fvMESA;
+ glWindowPos2iMESA: TglWindowPos2iMESA;
+ glWindowPos2ivMESA: TglWindowPos2ivMESA;
+ glWindowPos2sMESA: TglWindowPos2sMESA;
+ glWindowPos2svMESA: TglWindowPos2svMESA;
+ glWindowPos3dMESA: TglWindowPos3dMESA;
+ glWindowPos3dvMESA: TglWindowPos3dvMESA;
+ glWindowPos3fMESA: TglWindowPos3fMESA;
+ glWindowPos3fvMESA: TglWindowPos3fvMESA;
+ glWindowPos3iMESA: TglWindowPos3iMESA;
+ glWindowPos3ivMESA: TglWindowPos3ivMESA;
+ glWindowPos3sMESA: TglWindowPos3sMESA;
+ glWindowPos3svMESA: TglWindowPos3svMESA;
+ glWindowPos4dMESA: TglWindowPos4dMESA;
+ glWindowPos4dvMESA: TglWindowPos4dvMESA;
+ glWindowPos4fMESA: TglWindowPos4fMESA;
+ glWindowPos4fvMESA: TglWindowPos4fvMESA;
+ glWindowPos4iMESA: TglWindowPos4iMESA;
+ glWindowPos4ivMESA: TglWindowPos4ivMESA;
+ glWindowPos4sMESA: TglWindowPos4sMESA;
+ glWindowPos4svMESA: TglWindowPos4svMESA;
+
+ // GL_NV_evaluators
+ glMapControlPointsNV: TglMapControlPointsNV;
+ glMapParameterivNV: TglMapParameterivNV;
+ glMapParameterfvNV: TglMapParameterfvNV;
+ glGetMapControlPointsNV: TglGetMapControlPointsNV;
+ glGetMapParameterivNV: TglGetMapParameterivNV;
+ glGetMapParameterfvNV: TglGetMapParameterfvNV;
+ glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV;
+ glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV;
+ glEvalMapsNV: TglEvalMapsNV;
+
+ // GL_NV_fence
+ glDeleteFencesNV: TglDeleteFencesNV;
+ glGenFencesNV: TglGenFencesNV;
+ glIsFenceNV: TglIsFenceNV;
+ glTestFenceNV: TglTestFenceNV;
+ glGetFenceivNV: TglGetFenceivNV;
+ glFinishFenceNV: TglFinishFenceNV;
+ glSetFenceNV: TglSetFenceNV;
+
+ // GL_NV_fragment_program
+ glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV;
+ glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV;
+ glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV;
+ glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV;
+ glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV;
+ glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV;
+
+ // GL_NV_half_float
+ glVertex2hNV: TglVertex2hNV;
+ glVertex2hvNV: TglVertex2hvNV;
+ glVertex3hNV: TglVertex3hNV;
+ glVertex3hvNV: TglVertex3hvNV;
+ glVertex4hNV: TglVertex4hNV;
+ glVertex4hvNV: TglVertex4hvNV;
+ glNormal3hNV: TglNormal3hNV;
+ glNormal3hvNV: TglNormal3hvNV;
+ glColor3hNV: TglColor3hNV;
+ glColor3hvNV: TglColor3hvNV;
+ glColor4hNV: TglColor4hNV;
+ glColor4hvNV: TglColor4hvNV;
+ glTexCoord1hNV: TglTexCoord1hNV;
+ glTexCoord1hvNV: TglTexCoord1hvNV;
+ glTexCoord2hNV: TglTexCoord2hNV;
+ glTexCoord2hvNV: TglTexCoord2hvNV;
+ glTexCoord3hNV: TglTexCoord3hNV;
+ glTexCoord3hvNV: TglTexCoord3hvNV;
+ glTexCoord4hNV: TglTexCoord4hNV;
+ glTexCoord4hvNV: TglTexCoord4hvNV;
+ glMultiTexCoord1hNV: TglMultiTexCoord1hNV;
+ glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV;
+ glMultiTexCoord2hNV: TglMultiTexCoord2hNV;
+ glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV;
+ glMultiTexCoord3hNV: TglMultiTexCoord3hNV;
+ glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV;
+ glMultiTexCoord4hNV: TglMultiTexCoord4hNV;
+ glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV;
+ glFogCoordhNV: TglFogCoordhNV;
+ glFogCoordhvNV: TglFogCoordhvNV;
+ glSecondaryColor3hNV: TglSecondaryColor3hNV;
+ glSecondaryColor3hvNV: TglSecondaryColor3hvNV;
+ glVertexWeighthNV: TglVertexWeighthNV;
+ glVertexWeighthvNV: TglVertexWeighthvNV;
+ glVertexAttrib1hNV: TglVertexAttrib1hNV;
+ glVertexAttrib1hvNV: TglVertexAttrib1hvNV;
+ glVertexAttrib2hNV: TglVertexAttrib2hNV;
+ glVertexAttrib2hvNV: TglVertexAttrib2hvNV;
+ glVertexAttrib3hNV: TglVertexAttrib3hNV;
+ glVertexAttrib3hvNV: TglVertexAttrib3hvNV;
+ glVertexAttrib4hNV: TglVertexAttrib4hNV;
+ glVertexAttrib4hvNV: TglVertexAttrib4hvNV;
+ glVertexAttribs1hvNV: TglVertexAttribs1hvNV;
+ glVertexAttribs2hvNV: TglVertexAttribs2hvNV;
+ glVertexAttribs3hvNV: TglVertexAttribs3hvNV;
+ glVertexAttribs4hvNV: TglVertexAttribs4hvNV;
+
+ // GL_NV_occlusion_query
+ glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV;
+ glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV;
+ glIsOcclusionQueryNV: TglIsOcclusionQueryNV;
+ glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV;
+ glEndOcclusionQueryNV: TglEndOcclusionQueryNV;
+ glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV;
+ glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV;
+
+ // GL_NV_pixel_data_range
+ glPixelDataRangeNV: TglPixelDataRangeNV;
+ glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV;
+
+ // GL_NV_point_sprite
+ glPointParameteriNV: TglPointParameteriNV;
+ glPointParameterivNV: TglPointParameterivNV;
+
+ // GL_NV_primitive_restart
+ glPrimitiveRestartNV: TglPrimitiveRestartNV;
+ glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV;
+
+ // GL_NV_register_combiners
+ glCombinerParameterfvNV: TglCombinerParameterfvNV;
+ glCombinerParameterfNV: TglCombinerParameterfNV;
+ glCombinerParameterivNV: TglCombinerParameterivNV;
+ glCombinerParameteriNV: TglCombinerParameteriNV;
+ glCombinerInputNV: TglCombinerInputNV;
+ glCombinerOutputNV: TglCombinerOutputNV;
+ glFinalCombinerInputNV: TglFinalCombinerInputNV;
+ glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV;
+ glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV;
+ glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV;
+ glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV;
+ glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV;
+ glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV;
+
+ // GL_NV_register_combiners2
+ glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV;
+ glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV;
+
+ // GL_NV_vertex_array_range
+ glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV;
+ glVertexArrayRangeNV: TglVertexArrayRangeNV;
+
+ // GL_NV_vertex_program
+ glAreProgramsResidentNV: TglAreProgramsResidentNV;
+ glBindProgramNV: TglBindProgramNV;
+ glDeleteProgramsNV: TglDeleteProgramsNV;
+ glExecuteProgramNV: TglExecuteProgramNV;
+ glGenProgramsNV: TglGenProgramsNV;
+ glGetProgramParameterdvNV: TglGetProgramParameterdvNV;
+ glGetProgramParameterfvNV: TglGetProgramParameterfvNV;
+ glGetProgramivNV: TglGetProgramivNV;
+ glGetProgramStringNV: TglGetProgramStringNV;
+ glGetTrackMatrixivNV: TglGetTrackMatrixivNV;
+ glGetVertexAttribdvNV: TglGetVertexAttribdvNV;
+ glGetVertexAttribfvNV: TglGetVertexAttribfvNV;
+ glGetVertexAttribivNV: TglGetVertexAttribivNV;
+ glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV;
+ glIsProgramNV: TglIsProgramNV;
+ glLoadProgramNV: TglLoadProgramNV;
+ glProgramParameter4dNV: TglProgramParameter4dNV;
+ glProgramParameter4dvNV: TglProgramParameter4dvNV;
+ glProgramParameter4fNV: TglProgramParameter4fNV;
+ glProgramParameter4fvNV: TglProgramParameter4fvNV;
+ glProgramParameters4dvNV: TglProgramParameters4dvNV;
+ glProgramParameters4fvNV: TglProgramParameters4fvNV;
+ glRequestResidentProgramsNV: TglRequestResidentProgramsNV;
+ glTrackMatrixNV: TglTrackMatrixNV;
+ glVertexAttribPointerNV: TglVertexAttribPointerNV;
+ glVertexAttrib1dNV: TglVertexAttrib1dNV;
+ glVertexAttrib1dvNV: TglVertexAttrib1dvNV;
+ glVertexAttrib1fNV: TglVertexAttrib1fNV;
+ glVertexAttrib1fvNV: TglVertexAttrib1fvNV;
+ glVertexAttrib1sNV: TglVertexAttrib1sNV;
+ glVertexAttrib1svNV: TglVertexAttrib1svNV;
+ glVertexAttrib2dNV: TglVertexAttrib2dNV;
+ glVertexAttrib2dvNV: TglVertexAttrib2dvNV;
+ glVertexAttrib2fNV: TglVertexAttrib2fNV;
+ glVertexAttrib2fvNV: TglVertexAttrib2fvNV;
+ glVertexAttrib2sNV: TglVertexAttrib2sNV;
+ glVertexAttrib2svNV: TglVertexAttrib2svNV;
+ glVertexAttrib3dNV: TglVertexAttrib3dNV;
+ glVertexAttrib3dvNV: TglVertexAttrib3dvNV;
+ glVertexAttrib3fNV: TglVertexAttrib3fNV;
+ glVertexAttrib3fvNV: TglVertexAttrib3fvNV;
+ glVertexAttrib3sNV: TglVertexAttrib3sNV;
+ glVertexAttrib3svNV: TglVertexAttrib3svNV;
+ glVertexAttrib4dNV: TglVertexAttrib4dNV;
+ glVertexAttrib4dvNV: TglVertexAttrib4dvNV;
+ glVertexAttrib4fNV: TglVertexAttrib4fNV;
+ glVertexAttrib4fvNV: TglVertexAttrib4fvNV;
+ glVertexAttrib4sNV: TglVertexAttrib4sNV;
+ glVertexAttrib4svNV: TglVertexAttrib4svNV;
+ glVertexAttrib4ubNV: TglVertexAttrib4ubNV;
+ glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV;
+ glVertexAttribs1dvNV: TglVertexAttribs1dvNV;
+ glVertexAttribs1fvNV: TglVertexAttribs1fvNV;
+ glVertexAttribs1svNV: TglVertexAttribs1svNV;
+ glVertexAttribs2dvNV: TglVertexAttribs2dvNV;
+ glVertexAttribs2fvNV: TglVertexAttribs2fvNV;
+ glVertexAttribs2svNV: TglVertexAttribs2svNV;
+ glVertexAttribs3dvNV: TglVertexAttribs3dvNV;
+ glVertexAttribs3fvNV: TglVertexAttribs3fvNV;
+ glVertexAttribs3svNV: TglVertexAttribs3svNV;
+ glVertexAttribs4dvNV: TglVertexAttribs4dvNV;
+ glVertexAttribs4fvNV: TglVertexAttribs4fvNV;
+ glVertexAttribs4svNV: TglVertexAttribs4svNV;
+ glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV;
+
+ // GL_NV_depth_buffer_float
+ glDepthRangedNV: TglDepthRangedNV;
+ glClearDepthdNV: TglClearDepthdNV;
+ glDepthBoundsdNV: TglDepthBoundsdNV;
+
+ // GL_NV_framebuffer_multisample_coverage
+ glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV;
+
+ // GL_NV_geometry_program4
+ glProgramVertexLimitNV: TglProgramVertexLimitNV;
+
+ // GL_NV_gpu_program4
+ glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV;
+ glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV;
+ glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV;
+ glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV;
+ glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV;
+ glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV;
+ glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV;
+ glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV;
+ glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV;
+ glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV;
+ glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV;
+ glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV;
+ glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV;
+ glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV;
+ glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV;
+ glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV;
+
+ // GL_NV_parameter_buffer_object
+ glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV;
+ glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV;
+ glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV;
+
+ // GL_NV_transform_feedback
+ glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV;
+ glEndTransformFeedbackNV: TglEndTransformFeedbackNV;
+ glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV;
+ glBindBufferRangeNV: TglBindBufferRangeNV;
+ glBindBufferOffsetNV: TglBindBufferOffsetNV;
+ glBindBufferBaseNV: TglBindBufferBaseNV;
+ glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV;
+ glActiveVaryingNV: TglActiveVaryingNV;
+ glGetVaryingLocationNV: TglGetVaryingLocationNV;
+ glGetActiveVaryingNV: TglGetActiveVaryingNV;
+ glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV;
+ glTransformFeedbackStreamAttribsNV: TglTransformFeedbackStreamAttribsNV;
+
+ // GL_NV_conditional_render
+ glBeginConditionalRenderNV: TglBeginConditionalRenderNV;
+ glEndConditionalRenderNV: TglEndConditionalRenderNV;
+
+ // GL_NV_present_video
+ glPresentFrameKeyedNV: TglPresentFrameKeyedNV;
+ glPresentFrameDualFillNV: TglPresentFrameDualFillNV;
+ glGetVideoivNV: TglGetVideoivNV;
+ glGetVideouivNV: TglGetVideouivNV;
+ glGetVideoi64vNV: TglGetVideoi64vNV;
+ glGetVideoui64vNV: TglGetVideoui64vNV;
+// glVideoParameterivNV: TglVideoParameterivNV;
+
+ // GL_NV_explicit_multisample
+ glGetMultisamplefvNV: TglGetMultisamplefvNV;
+ glSampleMaskIndexedNV: TglSampleMaskIndexedNV;
+ glTexRenderbufferNV: TglTexRenderbufferNV;
+
+ // GL_NV_transform_feedback2
+ glBindTransformFeedbackNV: TglBindTransformFeedbackNV;
+ glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV;
+ glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV;
+ glIsTransformFeedbackNV: TglIsTransformFeedbackNV;
+ glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV;
+ glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV;
+ glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV;
+
+ // GL_NV_video_capture
+ glBeginVideoCaptureNV: TglBeginVideoCaptureNV;
+ glBindVideoCaptureStreamBufferNV: TglBindVideoCaptureStreamBufferNV;
+ glBindVideoCaptureStreamTextureNV: TglBindVideoCaptureStreamTextureNV;
+ glEndVideoCaptureNV: TglEndVideoCaptureNV;
+ glGetVideoCaptureivNV: TglGetVideoCaptureivNV;
+ glGetVideoCaptureStreamivNV: TglGetVideoCaptureStreamivNV;
+ glGetVideoCaptureStreamfvNV: TglGetVideoCaptureStreamfvNV;
+ glGetVideoCaptureStreamdvNV: TglGetVideoCaptureStreamdvNV;
+ glVideoCaptureNV: TglVideoCaptureNV;
+ glVideoCaptureStreamParameterivNV: TglVideoCaptureStreamParameterivNV;
+ glVideoCaptureStreamParameterfvNV: TglVideoCaptureStreamParameterfvNV;
+ glVideoCaptureStreamParameterdvNV: TglVideoCaptureStreamParameterdvNV;
+
+ // GL_NV_copy_image
+ glCopyImageSubDataNV: TglCopyImageSubDataNV;
+
+ // GL_NV_shader_buffer_load
+ glMakeBufferResidentNV: TglMakeBufferResidentNV;
+ glMakeBufferNonResidentNV: TglMakeBufferNonResidentNV;
+ glIsBufferResidentNV: TglIsBufferResidentNV;
+ glMakeNamedBufferResidentNV: TglMakeNamedBufferResidentNV;
+ glMakeNamedBufferNonResidentNV: TglMakeNamedBufferNonResidentNV;
+ glIsNamedBufferResidentNV: TglIsNamedBufferResidentNV;
+ glGetBufferParameterui64vNV: TglGetBufferParameterui64vNV;
+ glGetNamedBufferParameterui64vNV: TglGetNamedBufferParameterui64vNV;
+ glGetIntegerui64vNV: TglGetIntegerui64vNV;
+ glUniformui64NV: TglUniformui64NV;
+ glUniformui64vNV: TglUniformui64vNV;
+ glGetUniformui64vNV: TglGetUniformui64vNV;
+ glProgramUniformui64NV: TglProgramUniformui64NV;
+ glProgramUniformui64vNV: TglProgramUniformui64vNV;
+
+ // GL_NV_vertex_buffer_unified_memory
+ glBufferAddressRangeNV: TglBufferAddressRangeNV;
+ glVertexFormatNV: TglVertexFormatNV;
+ glNormalFormatNV: TglNormalFormatNV;
+ glColorFormatNV: TglColorFormatNV;
+ glIndexFormatNV: TglIndexFormatNV;
+ glTexCoordFormatNV: TglTexCoordFormatNV;
+ glEdgeFlagFormatNV: TglEdgeFlagFormatNV;
+ glSecondaryColorFormatNV: TglSecondaryColorFormatNV;
+ glFogCoordFormatNV: TglFogCoordFormatNV;
+ glVertexAttribFormatNV: TglVertexAttribFormatNV;
+ glVertexAttribIFormatNV: TglVertexAttribIFormatNV;
+ glGetIntegerui64i_vNV: TglGetIntegerui64i_vNV;
+
+ // GL_NV_gpu_program5
+ glProgramSubroutineParametersuivNV: TglProgramSubroutineParametersuivNV;
+ glGetProgramSubroutineParameteruivNV: TglGetProgramSubroutineParameteruivNV;
+
+ // GL_NV_gpu_shader5
+ glUniform1i64NV: TglUniform1i64NV;
+ glUniform2i64NV: TglUniform2i64NV;
+ glUniform3i64NV: TglUniform3i64NV;
+ glUniform4i64NV: TglUniform4i64NV;
+ glUniform1i64vNV: TglUniform1i64vNV;
+ glUniform2i64vNV: TglUniform2i64vNV;
+ glUniform3i64vNV: TglUniform3i64vNV;
+ glUniform4i64vNV: TglUniform4i64vNV;
+ glUniform1ui64NV: TglUniform1ui64NV;
+ glUniform2ui64NV: TglUniform2ui64NV;
+ glUniform3ui64NV: TglUniform3ui64NV;
+ glUniform4ui64NV: TglUniform4ui64NV;
+ glUniform1ui64vNV: TglUniform1ui64vNV;
+ glUniform2ui64vNV: TglUniform2ui64vNV;
+ glUniform3ui64vNV: TglUniform3ui64vNV;
+ glUniform4ui64vNV: TglUniform4ui64vNV;
+ glGetUniformi64vNV: TglGetUniformi64vNV;
+ glProgramUniform1i64NV: TglProgramUniform1i64NV;
+ glProgramUniform2i64NV: TglProgramUniform2i64NV;
+ glProgramUniform3i64NV: TglProgramUniform3i64NV;
+ glProgramUniform4i64NV: TglProgramUniform4i64NV;
+ glProgramUniform1i64vNV: TglProgramUniform1i64vNV;
+ glProgramUniform2i64vNV: TglProgramUniform2i64vNV;
+ glProgramUniform3i64vNV: TglProgramUniform3i64vNV;
+ glProgramUniform4i64vNV: TglProgramUniform4i64vNV;
+ glProgramUniform1ui64NV: TglProgramUniform1ui64NV;
+ glProgramUniform2ui64NV: TglProgramUniform2ui64NV;
+ glProgramUniform3ui64NV: TglProgramUniform3ui64NV;
+ glProgramUniform4ui64NV: TglProgramUniform4ui64NV;
+ glProgramUniform1ui64vNV: TglProgramUniform1ui64vNV;
+ glProgramUniform2ui64vNV: TglProgramUniform2ui64vNV;
+ glProgramUniform3ui64vNV: TglProgramUniform3ui64vNV;
+ glProgramUniform4ui64vNV: TglProgramUniform4ui64vNV;
+
+ // GL_NV_vertex_attrib_integer_64bit
+ glVertexAttribL1i64NV: TglVertexAttribL1i64NV;
+ glVertexAttribL2i64NV: TglVertexAttribL2i64NV;
+ glVertexAttribL3i64NV: TglVertexAttribL3i64NV;
+ glVertexAttribL4i64NV: TglVertexAttribL4i64NV;
+ glVertexAttribL1i64vNV: TglVertexAttribL1i64vNV;
+ glVertexAttribL2i64vNV: TglVertexAttribL2i64vNV;
+ glVertexAttribL3i64vNV: TglVertexAttribL3i64vNV;
+ glVertexAttribL4i64vNV: TglVertexAttribL4i64vNV;
+ glVertexAttribL1ui64NV: TglVertexAttribL1ui64NV;
+ glVertexAttribL2ui64NV: TglVertexAttribL2ui64NV;
+ glVertexAttribL3ui64NV: TglVertexAttribL3ui64NV;
+ glVertexAttribL4ui64NV: TglVertexAttribL4ui64NV;
+ glVertexAttribL1ui64vNV: TglVertexAttribL1ui64vNV;
+ glVertexAttribL2ui64vNV: TglVertexAttribL2ui64vNV;
+ glVertexAttribL3ui64vNV: TglVertexAttribL3ui64vNV;
+ glVertexAttribL4ui64vNV: TglVertexAttribL4ui64vNV;
+ glGetVertexAttribLi64vNV: TglGetVertexAttribLi64vNV;
+ glGetVertexAttribLui64vNV: TglGetVertexAttribLui64vNV;
+ glVertexAttribLFormatNV: TglVertexAttribLFormatNV;
+
+ // GL_NV_vdpau_interop
+ glVDPAUInitNV: TglVDPAUInitNV;
+ glVDPAUFiniNV: TglVDPAUFiniNV;
+ glVDPAURegisterVideoSurfaceNV: TglVDPAURegisterVideoSurfaceNV;
+ glVDPAURegisterOutputSurfaceNV: TglVDPAURegisterOutputSurfaceNV;
+ glVDPAUIsSurfaceNV: TglVDPAUIsSurfaceNV;
+ glVDPAUUnregisterSurfaceNV: TglVDPAUUnregisterSurfaceNV;
+ glVDPAUGetSurfaceivNV: TglVDPAUGetSurfaceivNV;
+ glVDPAUSurfaceAccessNV: TglVDPAUSurfaceAccessNV;
+ glVDPAUMapSurfacesNV: TglVDPAUMapSurfacesNV;
+ glVDPAUUnmapSurfacesNV: TglVDPAUUnmapSurfacesNV;
+
+ // GL_NV_texture_barrier
+ glTextureBarrierNV: TglTextureBarrierNV;
+
+ // (4.3) GL_NV_path_rendering
+ glGenPathsNV : TglGenPathsNV;
+ glDeletePathsNV : TglDeletePathsNV;
+ glIsPathNV : TglIsPathNV;
+ glPathCommandsNV : TglPathCommandsNV;
+ glPathCoordsNV : TglPathCoordsNV;
+ glPathSubCommandsNV : TglPathSubCommandsNV;
+ glPathSubCoordsNV : TglPathSubCoordsNV;
+ glPathStringNV : TglPathStringNV;
+ glPathGlyphsNV : TglPathGlyphsNV;
+ glPathGlyphRangeNV : TglPathGlyphRangeNV;
+ glWeightPathsNV : TglWeightPathsNV;
+ glCopyPathNV : TglCopyPathNV;
+ glInterpolatePathsNV : TglInterpolatePathsNV;
+ glTransformPathNV : TglTransformPathNV;
+ glPathParameterivNV : TglPathParameterivNV;
+ glPathParameteriNV : TglPathParameteriNV;
+ glPathParameterfvNV : TglPathParameterfvNV;
+ glPathParameterfNV : TglPathParameterfNV;
+ glPathDashArrayNV : TglPathDashArrayNV;
+ glPathStencilFuncNV : TglPathStencilFuncNV;
+ glPathStencilDepthOffsetNV : TglPathStencilDepthOffsetNV;
+ glStencilFillPathNV : TglStencilFillPathNV;
+ glStencilStrokePathNV : TglStencilStrokePathNV;
+ glStencilFillPathInstancedNV : TglStencilFillPathInstancedNV;
+ glStencilStrokePathInstancedNV : TglStencilStrokePathInstancedNV;
+ glPathCoverDepthFuncNV : TglPathCoverDepthFuncNV;
+ glPathColorGenNV : TglPathColorGenNV;
+ glPathTexGenNV : TglPathTexGenNV;
+ glPathFogGenNV : TglPathFogGenNV;
+ glCoverFillPathNV : TglCoverFillPathNV;
+ glCoverStrokePathNV : TglCoverStrokePathNV;
+ glCoverFillPathInstancedNV : TglCoverFillPathInstancedNV;
+ glCoverStrokePathInstancedNV : TglCoverStrokePathInstancedNV;
+ glGetPathParameterivNV : TglGetPathParameterivNV;
+ glGetPathParameterfvNV : TglGetPathParameterfvNV;
+ glGetPathCommandsNV : TglGetPathCommandsNV;
+ glGetPathCoordsNV : TglGetPathCoordsNV;
+ glGetPathDashArrayNV : TglGetPathDashArrayNV;
+ glGetPathMetricsNV : TglGetPathMetricsNV;
+ glGetPathMetricRangeNV : TglGetPathMetricRangeNV;
+ glGetPathSpacingNV : TglGetPathSpacingNV;
+ glGetPathColorGenivNV : TglGetPathColorGenivNV;
+ glGetPathColorGenfvNV : TglGetPathColorGenfvNV;
+ glGetPathTexGenivNV : TglGetPathTexGenivNV;
+ glGetPathTexGenfvNV : TglGetPathTexGenfvNV;
+ glIsPointInFillPathNV : TglIsPointInFillPathNV;
+ glIsPointInStrokePathNV : TglIsPointInStrokePathNV;
+ glGetPathLengthNV : TglGetPathLengthNV;
+ glPointAlongPathNV : TglPointAlongPathNV;
+
+ // GL_AMD_pinned_memory
+
+ // GL_AMD_stencil_operation_extended
+ glStencilOpValueAMD : TglStencilOpValueAMD;
+
+ // GL_AMD_vertex_shader_viewport_index
+
+ // GL_AMD_vertex_shader_layer
+
+ // GL_NV_bindless_texture
+ glGetTextureHandleNV : TglGetTextureHandleNV;
+ glGetTextureSamplerHandleNV : TglGetTextureSamplerHandleNV;
+ glMakeTextureHandleResidentNV : TglMakeTextureHandleResidentNV;
+ glMakeTextureHandleNonResidentNV : TglMakeTextureHandleNonResidentNV;
+ glGetImageHandleNV : TglGetImageHandleNV;
+ glMakeImageHandleResidentNV : TglMakeImageHandleResidentNV;
+ glMakeImageHandleNonResidentNV : TglMakeImageHandleNonResidentNV;
+ glUniformHandleui64NV : TglUniformHandleui64NV;
+ glUniformHandleui64vNV : TglUniformHandleui64vNV;
+ glProgramUniformHandleui64NV : TglProgramUniformHandleui64NV;
+ glProgramUniformHandleui64vNV : TglProgramUniformHandleui64vNV;
+ glIsTextureHandleResidentNV : TglIsTextureHandleResidentNV;
+ glIsImageHandleResidentNV : TglIsImageHandleResidentNV;
+
+ // GL_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_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_shading_language_include;
+procedure Read_GL_ARB_blend_func_extended;
+procedure Read_GL_ARB_sampler_objects;
+procedure Read_GL_ARB_timer_query;
+procedure Read_GL_ARB_vertex_type_2_10_10_10_rev;
+procedure Read_GL_ARB_draw_indirect;
+procedure Read_GL_ARB_gpu_shader_fp64;
+procedure Read_GL_ARB_shader_subroutine;
+procedure Read_GL_ARB_tessellation_shader;
+procedure Read_GL_ARB_transform_feedback2;
+procedure Read_GL_ARB_transform_feedback3;
+procedure Read_GL_ARB_ES2_compatibility;
+procedure Read_GL_ARB_get_program_binary;
+procedure Read_GL_ARB_separate_shader_objects;
+procedure Read_GL_ARB_vertex_attrib_64bit;
+procedure Read_GL_ARB_viewport_array;
+// GL 4.2
+procedure Read_GL_ARB_base_instance;
+procedure Read_GL_ARB_transform_feedback_instanced;
+procedure Read_GL_ARB_internalformat_query;
+procedure Read_GL_ARB_shader_atomic_counters;
+procedure Read_GL_ARB_shader_image_load_store;
+procedure Read_GL_ARB_texture_storage;
+// GL 4.3
+procedure Read_GL_KHR_debug;
+procedure Read_GL_ARB_clear_buffer_object;
+procedure Read_GL_ARB_compute_shader;
+procedure Read_GL_ARB_copy_image;
+procedure Read_GL_ARB_framebuffer_no_attachments;
+procedure Read_GL_ARB_internalformat_query2;
+procedure Read_GL_ARB_invalidate_subdata;
+procedure Read_GL_ARB_multi_draw_indirect;
+procedure Read_GL_ARB_program_interface_query;
+procedure Read_GL_ARB_shader_storage_buffer_object;
+procedure Read_GL_ARB_texture_buffer_range;
+procedure Read_GL_ARB_texture_storage_multisample;
+procedure Read_GL_ARB_texture_view;
+procedure Read_GL_ARB_vertex_attrib_binding;
+
+
+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_MESA_resize_buffers;
+procedure Read_GL_MESA_window_pos;
+procedure Read_GL_NV_evaluators;
+procedure Read_GL_NV_fence;
+procedure Read_GL_NV_fragment_program;
+procedure Read_GL_NV_half_float;
+procedure Read_GL_NV_occlusion_query;
+procedure Read_GL_NV_pixel_data_range;
+procedure Read_GL_NV_point_sprite;
+procedure Read_GL_NV_primitive_restart;
+procedure Read_GL_NV_register_combiners;
+procedure Read_GL_NV_register_combiners2;
+procedure Read_GL_NV_vertex_array_range;
+procedure Read_GL_NV_vertex_program;
+procedure Read_GL_NV_depth_buffer_float;
+procedure Read_GL_NV_framebuffer_multisample_coverage;
+procedure Read_GL_NV_geometry_program4;
+procedure Read_GL_NV_gpu_program4;
+procedure Read_GL_NV_parameter_buffer_object;
+procedure Read_GL_NV_transform_feedback;
+procedure Read_GL_NV_conditional_render;
+procedure Read_GL_NV_present_video;
+procedure Read_GL_NV_explicit_multisample;
+procedure Read_GL_NV_transform_feedback2;
+procedure Read_GL_NV_video_capture;
+procedure Read_GL_NV_copy_image;
+procedure Read_GL_NV_shader_buffer_load;
+procedure Read_GL_NV_vertex_buffer_unified_memory;
+procedure Read_GL_NV_gpu_program5;
+procedure Read_GL_NV_gpu_shader5;
+procedure Read_GL_NV_vertex_attrib_integer_64bit;
+procedure Read_GL_NV_vdpau_interop;
+procedure Read_GL_NV_texture_barrier;
+procedure Read_GL_PGI_misc_hints;
+procedure Read_GL_SGIS_detail_texture;
+procedure Read_GL_SGIS_fog_function;
+procedure Read_GL_SGIS_multisample;
+procedure Read_GL_SGIS_pixel_texture;
+procedure Read_GL_SGIS_point_parameters;
+procedure Read_GL_SGIS_sharpen_texture;
+procedure Read_GL_SGIS_texture4D;
+procedure Read_GL_SGIS_texture_color_mask;
+procedure Read_GL_SGIS_texture_filter4;
+procedure Read_GL_SGIX_async;
+procedure Read_GL_SGIX_flush_raster;
+procedure Read_GL_SGIX_fragment_lighting;
+procedure Read_GL_SGIX_framezoom;
+procedure Read_GL_SGIX_igloo_interface;
+procedure Read_GL_SGIX_instruments;
+procedure Read_GL_SGIX_list_priority;
+procedure Read_GL_SGIX_pixel_texture;
+procedure Read_GL_SGIX_polynomial_ffd;
+procedure Read_GL_SGIX_reference_plane;
+procedure Read_GL_SGIX_sprite;
+procedure Read_GL_SGIX_tag_sample_buffer;
+procedure Read_GL_SGI_color_table;
+procedure Read_GL_SUNX_constant_data;
+procedure Read_GL_SUN_global_alpha;
+procedure Read_GL_SUN_mesh_array;
+procedure Read_GL_SUN_triangle_list;
+procedure Read_GL_SUN_vertex;
+
+{$IFDEF DGL_WIN}
+procedure Read_WGL_ARB_buffer_region;
+procedure Read_WGL_ARB_extensions_string;
+procedure Read_WGL_ARB_make_current_read;
+procedure Read_WGL_ARB_pbuffer;
+procedure Read_WGL_ARB_pixel_format;
+procedure Read_WGL_ARB_pixel_format_float;
+procedure Read_WGL_ARB_render_texture;
+procedure Read_WGL_ARB_create_context;
+procedure Read_WGL_AMD_gpu_association;
+procedure Read_WGL_EXT_display_color_table;
+procedure Read_WGL_EXT_extensions_string;
+procedure Read_WGL_EXT_make_current_read;
+procedure Read_WGL_EXT_pbuffer;
+procedure Read_WGL_EXT_pixel_format;
+procedure Read_WGL_EXT_swap_control;
+procedure Read_WGL_I3D_digital_video_control;
+procedure Read_WGL_I3D_gamma;
+procedure Read_WGL_I3D_genlock;
+procedure Read_WGL_I3D_image_buffer;
+procedure Read_WGL_I3D_swap_frame_lock;
+procedure Read_WGL_I3D_swap_frame_usage;
+procedure Read_WGL_NV_vertex_array_range;
+procedure Read_WGL_NV_present_video;
+procedure Read_WGL_NV_video_output;
+procedure Read_WGL_NV_swap_group;
+procedure Read_WGL_NV_gpu_affinity;
+procedure Read_WGL_NV_video_capture;
+procedure Read_WGL_NV_copy_image;
+procedure Read_WGL_OML_sync_control;
+procedure Read_WGL_3DL_stereo_control;
+
+procedure Read_WIN_draw_range_elements;
+procedure Read_WIN_swap_hint;
+{$ENDIF}
+
+
+implementation
+
+
+{$IFDEF DGL_LINUX}
+const
+ RTLD_LAZY = $001;
+ RTLD_NOW = $002;
+ RTLD_BINDING_MASK = $003;
+
+ // Seems to work on Debian / Fedora
+ LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF};
+
+function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen';
+function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose';
+
+function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym';
+{$ENDIF}
+
+{$IFDEF DGL_MAC}{$IFDEF OPENGL_FRAMEWORK} // OpenGL framework used
+const
+ RTLD_DEFAULT = Pointer(-2);
+{$ENDIF}{$ENDIF}
+
+function dglLoadLibrary(Name: PChar): Pointer;
+begin
+ {$IFDEF DGL_WIN}
+ Result := {%H-}Pointer(LoadLibrary(Name));
+ {$ENDIF}
+
+ {$IFDEF DGL_LINUX}
+ Result := dlopen(Name, RTLD_LAZY);
+ {$ENDIF}
+
+ {$IFDEF DGL_MAC}
+ {$IFDEF OPENGL_FRAMEWORK}
+ Result := RTLD_DEFAULT;
+ {$ELSE}
+ Result := Pointer(LoadLibrary(Name));
+ {$ENDIF}
+ {$ENDIF}
+end;
+
+
+function dglFreeLibrary(LibHandle: Pointer): Boolean;
+begin
+ if LibHandle = nil then
+ Result := False
+ else
+ {$IFDEF DGL_WIN}
+ Result := FreeLibrary({%H-}HMODULE(LibHandle));
+ {$ENDIF}
+
+ {$IFDEF DGL_LINUX}
+ Result := dlclose(LibHandle) = 0;
+ {$ENDIF}
+
+ {$IFDEF DGL_MAC}
+ {$IFDEF OPENGL_FRAMEWORK}
+ Result := true;
+ {$ELSE}
+ Result := FreeLibrary(HMODULE(LibHandle));
+ {$ENDIF}
+ {$ENDIF}
+end;
+
+
+function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer;
+begin
+ if LibHandle = nil then
+ LibHandle := GL_LibHandle;
+
+
+ {$IFDEF DGL_WIN}
+ Result := GetProcAddress({%H-}HMODULE(LibHandle), ProcName);
+
+ if result <> nil then
+ exit;
+
+ if Addr(wglGetProcAddress) <> nil then
+ Result := wglGetProcAddress(ProcName);
+ {$ENDIF}
+
+ {$IFDEF DGL_LINUX}
+ if not ForceDLSym then begin
+ if Addr(glXGetProcAddress) <> nil then
+ Result := glXGetProcAddress(ProcName);
+
+ if result <> nil then
+ exit;
+
+ if Addr(glXGetProcAddressARB) <> nil then
+ Result := glXGetProcAddressARB(ProcName);
+
+ if result <> nil then
+ exit;
+ end;
+
+ Result := dlsym(LibHandle, ProcName);
+ {$ENDIF}
+
+ {$IFDEF DGL_MAC}
+ Result := GetProcAddress(HMODULE(LibHandle), ProcName);
+ {$ENDIF}
+end;
+
+
+function Int_GetExtensionString: AnsiString;
+var
+ ExtensionCount : GLint;
+ i : Integer;
+begin
+ if GL_VERSION_3_0
+ then
+ begin
+ if not Assigned(@glGetIntegerv) then glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+ if not Assigned(@glGetStringi) then glGetStringi := dglGetProcAddress('glGetStringi');
+
+ result := '';
+
+ if Assigned(@glGetIntegerv) and Assigned(@glGetStringi)
+ then
+ begin
+ glGetIntegerv(GL_NUM_EXTENSIONS, @extensionCount);
+
+ For I := 0 to extensionCount - 1 do
+ result := result + #32 + PAnsiChar(glGetStringi(GL_EXTENSIONS, I));
+ end;
+ end
+ else
+ begin
+ if not Assigned(@glGetString) then glGetString := dglGetProcAddress('glGetString');
+
+ if Assigned(@glGetString)
+ then result := glGetString(GL_EXTENSIONS)
+ else result := '';
+ end;
+
+ if (GL_LibHandle <> nil) then begin
+ {$IFDEF DGL_WIN}
+ // wglGetExtensionsStringEXT
+ if not Assigned(@wglGetExtensionsStringEXT) then
+ wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
+
+ if Assigned(@wglGetExtensionsStringEXT) then
+ Result := Result + #32 + wglGetExtensionsStringEXT;
+
+ // wglGetExtensionsStringARB
+ if not Assigned(@wglGetExtensionsStringARB) then
+ wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
+
+ if Assigned(@wglGetExtensionsStringARB) then
+ Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC);
+ {$ENDIF}
+ end;
+
+ Result := #32 + Result + #32;
+end;
+
+
+function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean;
+begin
+ Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0;
+end;
+
+
+function dglCheckExtension(Extension: AnsiString): Boolean;
+var
+ Extensions: AnsiString;
+begin
+ Extensions := Int_GetExtensionString;
+ Result := Int_CheckExtension(Extensions, Extension);
+end;
+
+
+
+function InitOpenGL(LibName: String; GLULibName: String): Boolean;
+begin
+ Result := False;
+
+ // free opened libraries
+ if GL_LibHandle <> nil then
+ dglFreeLibrary(GL_LibHandle);
+
+ if GLU_LibHandle <> nil then
+ dglFreeLibrary(GLU_LibHandle);
+
+ // load library
+ GL_LibHandle := dglLoadLibrary(PChar(LibName));
+ GLU_LibHandle := dglLoadLibrary(PChar(GLULibName));
+
+ // load GL functions
+ if (GL_LibHandle <> nil) then begin
+ {$IFDEF DGL_WIN}
+ wglCopyContext := dglGetProcAddress('wglCopyContext');
+ wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext');
+ wglCreateContext := dglGetProcAddress('wglCreateContext');
+ wglDeleteContext := dglGetProcAddress('wglDeleteContext');
+ wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane');
+ wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext');
+ wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC');
+ wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries');
+ wglGetProcAddress := dglGetProcAddress('wglGetProcAddress');
+ wglMakeCurrent := dglGetProcAddress('wglMakeCurrent');
+ wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette');
+ wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries');
+ wglShareLists := dglGetProcAddress('wglShareLists');
+ wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers');
+ wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers');
+ wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA');
+ wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA');
+ wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW');
+ wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW');
+ wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA');
+ wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA');
+ {$ENDIF}
+
+ {$IFDEF DGL_LINUX}
+ // GLX_VERSION_1_4 (needs to be first)
+ glXGetProcAddress := dglGetProcAddress('glXGetProcAddress', nil, True);
+
+ // GLX_ARB_get_proc_address (also needs to be first)
+ glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB', nil, True);
+
+ glXChooseVisual := dglGetProcAddress('glXChooseVisual');
+ glXCopyContext := dglGetProcAddress('glXCopyContext');
+ glXCreateContext := dglGetProcAddress('glXCreateContext');
+ glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap');
+ glXDestroyContext := dglGetProcAddress('glXDestroyContext');
+ glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap');
+ glXGetConfig := dglGetProcAddress('glXGetConfig');
+ glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext');
+ glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable');
+ glXIsDirect := dglGetProcAddress('glXIsDirect');
+ glXMakeCurrent := dglGetProcAddress('glXMakeCurrent');
+ glXQueryExtension := dglGetProcAddress('glXQueryExtension');
+ glXQueryVersion := dglGetProcAddress('glXQueryVersion');
+ glXSwapBuffers := dglGetProcAddress('glXSwapBuffers');
+ glXUseXFont := dglGetProcAddress('glXUseXFont');
+ glXWaitGL := dglGetProcAddress('glXWaitGL');
+ glXWaitX := dglGetProcAddress('glXWaitX');
+
+ glXGetClientString := dglGetProcAddress('glXGetClientString');
+ glXQueryServerString := dglGetProcAddress('glXQueryServerString');
+ glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString');
+
+ // GLX_VERSION_1_3
+ glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs');
+ glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig');
+ glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib');
+ glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig');
+ glXCreateWindow := dglGetProcAddress('glXCreateWindow');
+ glXDestroyWindow := dglGetProcAddress('glXDestroyWindow');
+ glXCreatePixmap := dglGetProcAddress('glXCreatePixmap');
+
+ glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap');
+ glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer');
+ glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer');
+ glXQueryDrawable := dglGetProcAddress('glXQueryDrawable');
+ glXCreateNewContext := dglGetProcAddress('glXCreateNewContext');
+ glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent');
+ glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable');
+ glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay');
+
+ glXQueryContext := dglGetProcAddress('glXQueryContext');
+ glXSelectEvent := dglGetProcAddress('glXSelectEvent');
+ glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent');
+
+ // GLX_ARB_create_context
+ glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB');
+
+ // GLX_EXT_import_context
+ glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT');
+ glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT');
+ glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT');
+ glXImportContextEXT := dglGetProcAddress('glXImportContextEXT');
+ glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT');
+
+ // GLX_EXT_texture_from_pixmap
+ glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT');
+ glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT');
+
+ 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;
+
+ // Note (Due to Khronos' change in header convetions, no more single read_ functions) starting with GL 4.4
+ 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_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_shader_subroutine;
+begin
+ glGetSubroutineUniformLocation := dglGetProcAddress('glGetSubroutineUniformLocation');
+ glGetSubroutineIndex := dglGetProcAddress('glGetSubroutineIndex');
+ glGetActiveSubroutineUniformiv := dglGetProcAddress('glGetActiveSubroutineUniformiv');
+ glGetActiveSubroutineUniformName := dglGetProcAddress('glGetActiveSubroutineUniformName');
+ glGetActiveSubroutineName := dglGetProcAddress('glGetActiveSubroutineName');
+ glUniformSubroutinesuiv := dglGetProcAddress('glUniformSubroutinesuiv');
+ glGetUniformSubroutineuiv := dglGetProcAddress('glGetUniformSubroutineuiv');
+ glGetProgramStageiv := dglGetProcAddress('glGetProgramStageiv');
+end;
+
+procedure Read_GL_ARB_tessellation_shader;
+begin
+ glPatchParameteri := dglGetProcAddress('glPatchParameteri');
+ glPatchParameterfv := dglGetProcAddress('glPatchParameterfv');
+end;
+
+procedure Read_GL_ARB_transform_feedback2;
+begin
+ glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback');
+ glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks');
+ glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks');
+ glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback');
+ glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback');
+ glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback');
+ glDrawTransformFeedback := dglGetProcAddress('glDrawTransformFeedback');
+end;
+
+procedure Read_GL_ARB_transform_feedback3;
+begin
+ glDrawTransformFeedbackStream := dglGetProcAddress('glDrawTransformFeedbackStream');
+ glBeginQueryIndexed := dglGetProcAddress('glBeginQueryIndexed');
+ glEndQueryIndexed := dglGetProcAddress('glEndQueryIndexed');
+ glGetQueryIndexediv := dglGetProcAddress('glGetQueryIndexediv');
+end;
+
+procedure Read_GL_ARB_ES2_compatibility;
+begin
+ glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler');
+ glShaderBinary := dglGetProcAddress('glShaderBinary');
+ glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat');
+ glDepthRangef := dglGetProcAddress('glDepthRangef');
+ glClearDepthf := dglGetProcAddress('glClearDepthf');
+end;
+
+procedure Read_GL_ARB_get_program_binary;
+begin
+ glGetProgramBinary := dglGetProcAddress('glGetProgramBinary');
+ glProgramBinary := dglGetProcAddress('glProgramBinary');
+ glProgramParameteri := dglGetProcAddress('glProgramParameteri');
+end;
+
+procedure Read_GL_ARB_separate_shader_objects;
+begin
+ glUseProgramStages := dglGetProcAddress('glUseProgramStages');
+ glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram');
+ glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv');
+ glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline');
+ glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines');
+ glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines');
+ glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline');
+ glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv');
+ glProgramUniform1i := dglGetProcAddress('glProgramUniform1i');
+ glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv');
+ glProgramUniform1f := dglGetProcAddress('glProgramUniform1f');
+ glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv');
+ glProgramUniform1d := dglGetProcAddress('glProgramUniform1d');
+ glProgramUniform1dv := dglGetProcAddress('glProgramUniform1dv');
+ glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui');
+ glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv');
+ glProgramUniform2i := dglGetProcAddress('glProgramUniform2i');
+ glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv');
+ glProgramUniform2f := dglGetProcAddress('glProgramUniform2f');
+ glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv');
+ glProgramUniform2d := dglGetProcAddress('glProgramUniform2d');
+ glProgramUniform2dv := dglGetProcAddress('glProgramUniform2dv');
+ glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui');
+ glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv');
+ glProgramUniform3i := dglGetProcAddress('glProgramUniform3i');
+ glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv');
+ glProgramUniform3f := dglGetProcAddress('glProgramUniform3f');
+ glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv');
+ glProgramUniform3d := dglGetProcAddress('glProgramUniform3d');
+ glProgramUniform3dv := dglGetProcAddress('glProgramUniform3dv');
+ glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui');
+ glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv');
+ glProgramUniform4i := dglGetProcAddress('glProgramUniform4i');
+ glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv');
+ glProgramUniform4f := dglGetProcAddress('glProgramUniform4f');
+ glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv');
+ glProgramUniform4d := dglGetProcAddress('glProgramUniform4d');
+ glProgramUniform4dv := dglGetProcAddress('glProgramUniform4dv');
+ glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui');
+ glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv');
+ glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv');
+ glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv');
+ glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv');
+ glProgramUniformMatrix2dv := dglGetProcAddress('glProgramUniformMatrix2dv');
+ glProgramUniformMatrix3dv := dglGetProcAddress('glProgramUniformMatrix3dv');
+ glProgramUniformMatrix4dv := dglGetProcAddress('glProgramUniformMatrix4dv');
+ glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv');
+ glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv');
+ glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv');
+ glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv');
+ glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv');
+ glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv');
+ glProgramUniformMatrix2x3dv := dglGetProcAddress('glProgramUniformMatrix2x3dv');
+ glProgramUniformMatrix3x2dv := dglGetProcAddress('glProgramUniformMatrix3x2dv');
+ glProgramUniformMatrix2x4dv := dglGetProcAddress('glProgramUniformMatrix2x4dv');
+ glProgramUniformMatrix4x2dv := dglGetProcAddress('glProgramUniformMatrix4x2dv');
+ glProgramUniformMatrix3x4dv := dglGetProcAddress('glProgramUniformMatrix3x4dv');
+ glProgramUniformMatrix4x3dv := dglGetProcAddress('glProgramUniformMatrix4x3dv');
+ glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline');
+ glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog');
+end;
+
+procedure Read_GL_ARB_vertex_attrib_64bit;
+begin
+ glVertexAttribL1d := dglGetProcAddress('glVertexAttribL1d');
+ glVertexAttribL2d := dglGetProcAddress('glVertexAttribL2d');
+ glVertexAttribL3d := dglGetProcAddress('glVertexAttribL3d');
+ glVertexAttribL4d := dglGetProcAddress('glVertexAttribL4d');
+ glVertexAttribL1dv := dglGetProcAddress('glVertexAttribL1dv');
+ glVertexAttribL2dv := dglGetProcAddress('glVertexAttribL2dv');
+ glVertexAttribL3dv := dglGetProcAddress('glVertexAttribL3dv');
+ glVertexAttribL4dv := dglGetProcAddress('glVertexAttribL4dv');
+ glVertexAttribLPointer := dglGetProcAddress('glVertexAttribLPointer');
+ glGetVertexAttribLdv := dglGetProcAddress('glGetVertexAttribLdv');
+end;
+
+procedure Read_GL_ARB_viewport_array;
+begin
+ glViewportArrayv := dglGetProcAddress('glViewportArrayv');
+ glViewportIndexedf := dglGetProcAddress('glViewportIndexedf');
+ glViewportIndexedfv := dglGetProcAddress('glViewportIndexedfv');
+ glScissorArrayv := dglGetProcAddress('glScissorArrayv');
+ glScissorIndexed := dglGetProcAddress('glScissorIndexed');
+ glScissorIndexedv := dglGetProcAddress('glScissorIndexedv');
+ glDepthRangeArrayv := dglGetProcAddress('glDepthRangeArrayv');
+ glDepthRangeIndexed := dglGetProcAddress('glDepthRangeIndexed');
+ glGetFloati_v := dglGetProcAddress('glGetFloati_v');
+ glGetDoublei_v := dglGetProcAddress('glGetDoublei_v');
+end;
+
+// GL 4.2
+
+procedure Read_GL_ARB_base_instance;
+begin
+glDrawArraysInstancedBaseInstance := dglGetProcAddress('glDrawArraysInstancedBaseInstance');
+glDrawElementsInstancedBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseInstance');
+glDrawElementsInstancedBaseVertexBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstance');
+end;
+
+procedure Read_GL_ARB_transform_feedback_instanced;
+begin
+glDrawTransformFeedbackInstanced := dglGetProcAddress('glDrawTransformFeedbackInstanced');
+glDrawTransformFeedbackStreamInstanced := dglGetProcAddress('glDrawTransformFeedbackStreamInstanced');
+end;
+
+procedure Read_GL_ARB_internalformat_query;
+begin
+glGetInternalformativ := dglGetProcAddress('glGetInternalformativ');
+end;
+
+procedure Read_GL_ARB_shader_atomic_counters;
+begin
+glGetActiveAtomicCounterBufferiv := dglGetProcAddress('glGetActiveAtomicCounterBufferiv');
+end;
+
+procedure Read_GL_ARB_shader_image_load_store;
+begin
+glBindImageTexture := dglGetProcAddress('glBindImageTexture');
+glMemoryBarrier := dglGetProcAddress('glMemoryBarrier');
+end;
+
+procedure Read_GL_ARB_texture_storage;
+begin
+glTexStorage1D := dglGetProcAddress('glTexStorage1D');
+glTexStorage2D := dglGetProcAddress('glTexStorage2D');
+glTexStorage3D := dglGetProcAddress('glTexStorage3D');
+glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT');
+glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT');
+glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT');
+end;
+
+
+// GL 4.3
+procedure Read_GL_KHR_debug;
+begin
+ glDebugMessageControl := dglGetProcAddress('glDebugMessageControl');
+ glDebugMessageInsert := dglGetProcAddress('glDebugMessageInsert');
+ glDebugMessageCallback := dglGetProcAddress('glDebugMessageCallback');
+ glGetDebugMessageLog := dglGetProcAddress('glGetDebugMessageLog');
+ glPushDebugGroup := dglGetProcAddress('glPushDebugGroup');
+ glPopDebugGroup := dglGetProcAddress('glPopDebugGroup');
+ glObjectLabel := dglGetProcAddress('glObjectLabel');
+ glGetObjectLabel := dglGetProcAddress('glGetObjectLabel');
+ glObjectPtrLabel := dglGetProcAddress('glObjectPtrLabel');
+ glGetObjectPtrLabel := dglGetProcAddress('glGetObjectPtrLabel');
+end;
+
+procedure Read_GL_ARB_clear_buffer_object;
+begin
+ glClearBufferData := dglGetProcAddress('glClearBufferData');
+ glClearBufferSubData := dglGetProcAddress('glClearBufferSubData');
+ glClearNamedBufferDataEXT := dglGetProcAddress('glClearNamedBufferDataEXT');
+ glClearNamedBufferSubDataEXT := dglGetProcAddress('glClearNamedBufferSubDataEXT');
+end;
+
+procedure Read_GL_ARB_compute_shader;
+begin
+ glDispatchCompute := dglGetProcAddress('glDispatchCompute');
+ glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect');
+end;
+
+procedure Read_GL_ARB_copy_image;
+begin
+ glCopyImageSubData := dglGetProcAddress('glCopyImageSubData');
+end;
+
+procedure Read_GL_ARB_framebuffer_no_attachments;
+begin
+ glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri');
+ glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv');
+ glNamedFramebufferParameteriEXT := dglGetProcAddress('glNamedFramebufferParameteriEXT');
+ glGetNamedFramebufferParameterivEXT := dglGetProcAddress('glGetNamedFramebufferParameterivEXT');
+end;
+
+procedure Read_GL_ARB_internalformat_query2;
+begin
+ glGetInternalformati64v := dglGetProcAddress('glGetInternalformati64v');;
+end;
+
+procedure Read_GL_ARB_invalidate_subdata;
+begin
+ glInvalidateTexSubImage := dglGetProcAddress('glInvalidateTexSubImage');
+ glInvalidateTexImage := dglGetProcAddress('glInvalidateTexImage');
+ glInvalidateBufferSubData := dglGetProcAddress('glInvalidateBufferSubData');
+ glInvalidateBufferData := dglGetProcAddress('glInvalidateBufferData');
+ glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer');
+ glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer');
+end;
+
+procedure Read_GL_ARB_multi_draw_indirect;
+begin
+ glMultiDrawArraysIndirect := dglGetProcAddress('glMultiDrawArraysIndirect');
+ glMultiDrawElementsIndirect := dglGetProcAddress('glMultiDrawElementsIndirect');
+end;
+
+procedure Read_GL_ARB_program_interface_query;
+begin
+ glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv');
+ glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex');
+ glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName');
+ glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv');
+ glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation');
+ glGetProgramResourceLocationIndex := dglGetProcAddress('glGetProgramResourceLocationIndex');
+end;
+
+procedure Read_GL_ARB_shader_storage_buffer_object;
+begin
+ glShaderStorageBlockBinding := dglGetProcAddress('glShaderStorageBlockBinding');
+end;
+
+procedure Read_GL_ARB_texture_buffer_range;
+begin
+ glTexBufferRange := dglGetProcAddress('glTexBufferRange');
+ glTextureBufferRangeEXT := dglGetProcAddress('glTextureBufferRangeEXT');
+end;
+
+procedure Read_GL_ARB_texture_storage_multisample;
+begin
+ glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample');
+ glTexStorage3DMultisample := dglGetProcAddress('glTexStorage3DMultisample');
+ glTextureStorage2DMultisampleEXT := dglGetProcAddress('glTextureStorage2DMultisampleEXT');
+ glTextureStorage3DMultisampleEXT := dglGetProcAddress('glTextureStorage3DMultisampleEXT');
+end;
+
+procedure Read_GL_ARB_texture_view;
+begin
+ glTextureView := dglGetProcAddress('glTextureView');
+end;
+
+procedure Read_GL_ARB_vertex_attrib_binding;
+begin
+ glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer');
+ glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat');
+ glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat');
+ glVertexAttribLFormat := dglGetProcAddress('glVertexAttribLFormat');
+ glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding');
+ glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor');
+ glVertexArrayBindVertexBufferEXT := dglGetProcAddress('glVertexArrayBindVertexBufferEXT');
+ glVertexArrayVertexAttribFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribFormatEXT');
+ glVertexArrayVertexAttribIFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribIFormatEXT');
+ glVertexArrayVertexAttribLFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribLFormatEXT');
+ glVertexArrayVertexAttribBindingEXT := dglGetProcAddress('glVertexArrayVertexAttribBindingEXT');
+ glVertexArrayVertexBindingDivisorEXT := dglGetProcAddress('glVertexArrayVertexBindingDivisorEXT');
+end;
+
+procedure Read_GL_4_4;
+begin
+ glBufferStorage := dglGetProcAddress('glBufferStorage');
+ glClearTexImage := dglGetProcAddress('glClearTexImage');
+ glClearTexSubImage := dglGetProcAddress('glClearTexSubImage');
+ glBindBuffersBase := dglGetProcAddress('glBindBuffersBase');
+ glBindBuffersRange := dglGetProcAddress('glBindBuffersRange');
+ glBindTextures := dglGetProcAddress('glBindTextures');
+ glBindSamplers := dglGetProcAddress('glBindSamplers');
+ glBindImageTextures := dglGetProcAddress('glBindImageTextures');
+ glBindVertexBuffers := dglGetProcAddress('glBindVertexBuffers');
+end;
+
+procedure Read_GL_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_MESA_resize_buffers;
+begin
+ glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA');
+end;
+
+procedure Read_GL_MESA_window_pos;
+begin
+ glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA');
+ glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA');
+ glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA');
+ glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA');
+ glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA');
+ glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA');
+ glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA');
+ glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA');
+ glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA');
+ glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA');
+ glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA');
+ glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA');
+ glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA');
+ glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA');
+ glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA');
+ glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA');
+ glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA');
+ glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA');
+ glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA');
+ glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA');
+ glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA');
+ glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA');
+ glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA');
+ glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA');
+end;
+
+procedure Read_GL_NV_evaluators;
+begin
+ glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV');
+ glMapParameterivNV := dglGetProcAddress('glMapParameterivNV');
+ glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV');
+ glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV');
+ glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV');
+ glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV');
+ glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV');
+ glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV');
+ glEvalMapsNV := dglGetProcAddress('glEvalMapsNV');
+end;
+
+procedure Read_GL_NV_fence;
+begin
+ glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV');
+ glGenFencesNV := dglGetProcAddress('glGenFencesNV');
+ glIsFenceNV := dglGetProcAddress('glIsFenceNV');
+ glTestFenceNV := dglGetProcAddress('glTestFenceNV');
+ glGetFenceivNV := dglGetProcAddress('glGetFenceivNV');
+ glFinishFenceNV := dglGetProcAddress('glFinishFenceNV');
+ glSetFenceNV := dglGetProcAddress('glSetFenceNV');
+end;
+
+procedure Read_GL_NV_fragment_program;
+begin
+ glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV');
+ glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV');
+ glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV');
+ glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV');
+ glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV');
+ glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV');
+end;
+
+procedure Read_GL_NV_half_float;
+begin
+ glVertex2hNV := dglGetProcAddress('glVertex2hNV');
+ glVertex2hvNV := dglGetProcAddress('glVertex2hvNV');
+ glVertex3hNV := dglGetProcAddress('glVertex3hNV');
+ glVertex3hvNV := dglGetProcAddress('glVertex3hvNV');
+ glVertex4hNV := dglGetProcAddress('glVertex4hNV');
+ glVertex4hvNV := dglGetProcAddress('glVertex4hvNV');
+ glNormal3hNV := dglGetProcAddress('glNormal3hNV');
+ glNormal3hvNV := dglGetProcAddress('glNormal3hvNV');
+ glColor3hNV := dglGetProcAddress('glColor3hNV');
+ glColor3hvNV := dglGetProcAddress('glColor3hvNV');
+ glColor4hNV := dglGetProcAddress('glColor4hNV');
+ glColor4hvNV := dglGetProcAddress('glColor4hvNV');
+ glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV');
+ glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV');
+ glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV');
+ glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV');
+ glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV');
+ glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV');
+ glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV');
+ glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV');
+ glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV');
+ glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV');
+ glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV');
+ glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV');
+ glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV');
+ glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV');
+ glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV');
+ glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV');
+ glFogCoordhNV := dglGetProcAddress('glFogCoordhNV');
+ glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV');
+ glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV');
+ glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV');
+ glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV');
+ glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV');
+ glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV');
+ glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV');
+ glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV');
+ glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV');
+ glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV');
+ glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV');
+ glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV');
+ glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV');
+ glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV');
+ glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV');
+ glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV');
+ glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV');
+end;
+
+procedure Read_GL_NV_occlusion_query;
+begin
+ glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV');
+ glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV');
+ glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV');
+ glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV');
+ glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV');
+ glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV');
+ glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV');
+end;
+
+procedure Read_GL_NV_pixel_data_range;
+begin
+ glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV');
+ glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV');
+end;
+
+procedure Read_GL_NV_point_sprite;
+begin
+ glPointParameteriNV := dglGetProcAddress('glPointParameteriNV');
+ glPointParameterivNV := dglGetProcAddress('glPointParameterivNV');
+end;
+
+procedure Read_GL_NV_primitive_restart;
+begin
+ glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV');
+ glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV');
+end;
+
+procedure Read_GL_NV_register_combiners;
+begin
+ glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV');
+ glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV');
+ glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV');
+ glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV');
+ glCombinerInputNV := dglGetProcAddress('glCombinerInputNV');
+ glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV');
+ glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV');
+ glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV');
+ glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV');
+ glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV');
+ glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV');
+ glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV');
+ glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV');
+end;
+
+procedure Read_GL_NV_register_combiners2;
+begin
+ glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV');
+ glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV');
+end;
+
+procedure Read_GL_NV_vertex_array_range;
+begin
+ glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV');
+ glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV');
+end;
+
+procedure Read_GL_NV_vertex_program;
+begin
+ glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV');
+ glBindProgramNV := dglGetProcAddress('glBindProgramNV');
+ glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV');
+ glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV');
+ glGenProgramsNV := dglGetProcAddress('glGenProgramsNV');
+ glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV');
+ glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV');
+ glGetProgramivNV := dglGetProcAddress('glGetProgramivNV');
+ glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV');
+ glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV');
+ glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV');
+ glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV');
+ glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV');
+ glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV');
+ glIsProgramNV := dglGetProcAddress('glIsProgramNV');
+ glLoadProgramNV := dglGetProcAddress('glLoadProgramNV');
+ glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV');
+ glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV');
+ glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV');
+ glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV');
+ glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV');
+ glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV');
+ glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV');
+ glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV');
+ glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV');
+ glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV');
+ glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV');
+ glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV');
+ glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV');
+ glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV');
+ glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV');
+ glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV');
+ glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV');
+ glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV');
+ glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV');
+ glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV');
+ glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV');
+ glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV');
+ glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV');
+ glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV');
+ glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV');
+ glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV');
+ glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV');
+ glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV');
+ glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV');
+ glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV');
+ glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV');
+ glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV');
+ glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV');
+ glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV');
+ glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV');
+ glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV');
+ glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV');
+ glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV');
+ glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV');
+ glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV');
+ glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV');
+ glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV');
+ glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV');
+ glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV');
+ glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV');
+ glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV');
+ glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV');
+ glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV');
+end;
+
+procedure Read_GL_NV_depth_buffer_float;
+begin
+ glDepthRangedNV := dglGetProcAddress('glDepthRangedNV');
+ glClearDepthdNV := dglGetProcAddress('glClearDepthdNV');
+ glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV');
+end;
+
+procedure Read_GL_NV_framebuffer_multisample_coverage;
+begin
+ glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV');
+end;
+
+procedure Read_GL_NV_geometry_program4;
+begin
+ glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV');
+end;
+
+procedure Read_GL_NV_gpu_program4;
+begin
+ glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV');
+ glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV');
+ glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV');
+ glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV');
+ glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV');
+ glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV');
+ glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV');
+ glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV');
+ glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV');
+ glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV');
+ glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV');
+ glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV');
+ glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV');
+ glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV');
+ glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV');
+ glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV');
+end;
+
+procedure Read_GL_NV_parameter_buffer_object;
+begin
+ glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV');
+ glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV');
+ glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV');
+end;
+
+procedure Read_GL_NV_transform_feedback;
+begin
+ glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV');
+ glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV');
+ glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV');
+ glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV');
+ glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV');
+ glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV');
+ glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV');
+ glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV');
+ glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV');
+ glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV');
+ glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV');
+ glTransformFeedbackStreamAttribsNV := dglGetProcAddress('glTransformFeedbackStreamAttribsNV');
+end;
+
+procedure Read_GL_NV_conditional_render;
+begin
+ glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV');
+ glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV');
+end;
+
+procedure Read_GL_NV_present_video;
+begin
+ glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV');
+ glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV');
+ glGetVideoivNV := dglGetProcAddress('glGetVideoivNV');
+ glGetVideouivNV := dglGetProcAddress('glGetVideouivNV');
+ glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV');
+ glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV');
+// glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV');
+end;
+
+procedure Read_GL_NV_explicit_multisample;
+begin
+ glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV');
+ glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV');
+ glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV');
+end;
+
+procedure Read_GL_NV_transform_feedback2;
+begin
+ glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV');
+ glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV');
+ glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV');
+ glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV');
+ glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV');
+ glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV');
+ glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV');
+end;
+
+procedure Read_GL_NV_video_capture;
+begin
+ glBeginVideoCaptureNV := dglGetProcAddress('glBeginVideoCaptureNV');
+ glBindVideoCaptureStreamBufferNV := dglGetProcAddress('glBindVideoCaptureStreamBufferNV');
+ glBindVideoCaptureStreamTextureNV := dglGetProcAddress('glBindVideoCaptureStreamTextureNV');
+ glEndVideoCaptureNV := dglGetProcAddress('glEndVideoCaptureNV');
+ glGetVideoCaptureivNV := dglGetProcAddress('glGetVideoCaptureivNV');
+ glGetVideoCaptureStreamivNV := dglGetProcAddress('glGetVideoCaptureStreamivNV');
+ glGetVideoCaptureStreamfvNV := dglGetProcAddress('glGetVideoCaptureStreamfvNV');
+ glGetVideoCaptureStreamdvNV := dglGetProcAddress('glGetVideoCaptureStreamdvNV');
+ glVideoCaptureNV := dglGetProcAddress('glVideoCaptureNV');
+ glVideoCaptureStreamParameterivNV := dglGetProcAddress('glVideoCaptureStreamParameterivNV');
+ glVideoCaptureStreamParameterfvNV := dglGetProcAddress('glVideoCaptureStreamParameterfvNV');
+ glVideoCaptureStreamParameterdvNV := dglGetProcAddress('glVideoCaptureStreamParameterdvNV');
+end;
+
+procedure Read_GL_NV_copy_image;
+begin
+ glCopyImageSubDataNV := dglGetProcAddress('glCopyImageSubDataNV');
+end;
+
+procedure Read_GL_NV_shader_buffer_load;
+begin
+ glMakeBufferResidentNV := dglGetProcAddress('glMakeBufferResidentNV');
+ glMakeBufferNonResidentNV := dglGetProcAddress('glMakeBufferNonResidentNV');
+ glIsBufferResidentNV := dglGetProcAddress('glIsBufferResidentNV');
+ glMakeNamedBufferResidentNV := dglGetProcAddress('glMakeNamedBufferResidentNV');
+ glMakeNamedBufferNonResidentNV := dglGetProcAddress('glMakeNamedBufferNonResidentNV');
+ glIsNamedBufferResidentNV := dglGetProcAddress('glIsNamedBufferResidentNV');
+ glGetBufferParameterui64vNV := dglGetProcAddress('glGetBufferParameterui64vNV');
+ glGetNamedBufferParameterui64vNV := dglGetProcAddress('glGetNamedBufferParameterui64vNV');
+ glGetIntegerui64vNV := dglGetProcAddress('glGetIntegerui64vNV');
+ glUniformui64NV := dglGetProcAddress('glUniformui64NV');
+ glUniformui64vNV := dglGetProcAddress('glUniformui64vNV');
+ glGetUniformui64vNV := dglGetProcAddress('glGetUniformui64vNV');
+ glProgramUniformui64NV := dglGetProcAddress('glProgramUniformui64NV');
+ glProgramUniformui64vNV := dglGetProcAddress('glProgramUniformui64vNV');
+end;
+
+procedure Read_GL_NV_vertex_buffer_unified_memory;
+begin
+ glBufferAddressRangeNV := dglGetProcAddress('glBufferAddressRangeNV');
+ glVertexFormatNV := dglGetProcAddress('glVertexFormatNV');
+ glNormalFormatNV := dglGetProcAddress('glNormalFormatNV');
+ glColorFormatNV := dglGetProcAddress('glColorFormatNV');
+ glIndexFormatNV := dglGetProcAddress('glIndexFormatNV');
+ glTexCoordFormatNV := dglGetProcAddress('glTexCoordFormatNV');
+ glEdgeFlagFormatNV := dglGetProcAddress('glEdgeFlagFormatNV');
+ glSecondaryColorFormatNV := dglGetProcAddress('glSecondaryColorFormatNV');
+ glFogCoordFormatNV := dglGetProcAddress('glFogCoordFormatNV');
+ glVertexAttribFormatNV := dglGetProcAddress('glVertexAttribFormatNV');
+ glVertexAttribIFormatNV := dglGetProcAddress('glVertexAttribIFormatNV');
+ glGetIntegerui64i_vNV := dglGetProcAddress('glGetIntegerui64i_vNV');
+end;
+
+procedure Read_GL_NV_gpu_program5;
+begin
+ glProgramSubroutineParametersuivNV := dglGetProcAddress('glProgramSubroutineParametersuivNV');
+ glGetProgramSubroutineParameteruivNV := dglGetProcAddress('glGetProgramSubroutineParameteruivNV');
+end;
+
+procedure Read_GL_NV_gpu_shader5;
+begin
+ glUniform1i64NV := dglGetProcAddress('glUniform1i64NV');
+ glUniform2i64NV := dglGetProcAddress('glUniform2i64NV');
+ glUniform3i64NV := dglGetProcAddress('glUniform3i64NV');
+ glUniform4i64NV := dglGetProcAddress('glUniform4i64NV');
+ glUniform1i64vNV := dglGetProcAddress('glUniform1i64vNV');
+ glUniform2i64vNV := dglGetProcAddress('glUniform2i64vNV');
+ glUniform3i64vNV := dglGetProcAddress('glUniform3i64vNV');
+ glUniform4i64vNV := dglGetProcAddress('glUniform4i64vNV');
+ glUniform1ui64NV := dglGetProcAddress('glUniform1ui64NV');
+ glUniform2ui64NV := dglGetProcAddress('glUniform2ui64NV');
+ glUniform3ui64NV := dglGetProcAddress('glUniform3ui64NV');
+ glUniform4ui64NV := dglGetProcAddress('glUniform4ui64NV');
+ glUniform1ui64vNV := dglGetProcAddress('glUniform1ui64vNV');
+ glUniform2ui64vNV := dglGetProcAddress('glUniform2ui64vNV');
+ glUniform3ui64vNV := dglGetProcAddress('glUniform3ui64vNV');
+ glUniform4ui64vNV := dglGetProcAddress('glUniform4ui64vNV');
+ glGetUniformi64vNV := dglGetProcAddress('glGetUniformi64vNV');
+ glProgramUniform1i64NV := dglGetProcAddress('glProgramUniform1i64NV');
+ glProgramUniform2i64NV := dglGetProcAddress('glProgramUniform2i64NV');
+ glProgramUniform3i64NV := dglGetProcAddress('glProgramUniform3i64NV');
+ glProgramUniform4i64NV := dglGetProcAddress('glProgramUniform4i64NV');
+ glProgramUniform1i64vNV := dglGetProcAddress('glProgramUniform1i64vNV');
+ glProgramUniform2i64vNV := dglGetProcAddress('glProgramUniform2i64vNV');
+ glProgramUniform3i64vNV := dglGetProcAddress('glProgramUniform3i64vNV');
+ glProgramUniform4i64vNV := dglGetProcAddress('glProgramUniform4i64vNV');
+ glProgramUniform1ui64NV := dglGetProcAddress('glProgramUniform1ui64NV');
+ glProgramUniform2ui64NV := dglGetProcAddress('glProgramUniform2ui64NV');
+ glProgramUniform3ui64NV := dglGetProcAddress('glProgramUniform3ui64NV');
+ glProgramUniform4ui64NV := dglGetProcAddress('glProgramUniform4ui64NV');
+ glProgramUniform1ui64vNV := dglGetProcAddress('glProgramUniform1ui64vNV');
+ glProgramUniform2ui64vNV := dglGetProcAddress('glProgramUniform2ui64vNV');
+ glProgramUniform3ui64vNV := dglGetProcAddress('glProgramUniform3ui64vNV');
+ glProgramUniform4ui64vNV := dglGetProcAddress('glProgramUniform4ui64vNV');
+end;
+
+procedure Read_GL_NV_vertex_attrib_integer_64bit;
+begin
+ glVertexAttribL1i64NV := dglGetProcAddress('glVertexAttribL1i64NV');
+ glVertexAttribL2i64NV := dglGetProcAddress('glVertexAttribL2i64NV');
+ glVertexAttribL3i64NV := dglGetProcAddress('glVertexAttribL3i64NV');
+ glVertexAttribL4i64NV := dglGetProcAddress('glVertexAttribL4i64NV');
+ glVertexAttribL1i64vNV := dglGetProcAddress('glVertexAttribL1i64vNV');
+ glVertexAttribL2i64vNV := dglGetProcAddress('glVertexAttribL2i64vNV');
+ glVertexAttribL3i64vNV := dglGetProcAddress('glVertexAttribL3i64vNV');
+ glVertexAttribL4i64vNV := dglGetProcAddress('glVertexAttribL4i64vNV');
+ glVertexAttribL1ui64NV := dglGetProcAddress('glVertexAttribL1ui64NV');
+ glVertexAttribL2ui64NV := dglGetProcAddress('glVertexAttribL2ui64NV');
+ glVertexAttribL3ui64NV := dglGetProcAddress('glVertexAttribL3ui64NV');
+ glVertexAttribL4ui64NV := dglGetProcAddress('glVertexAttribL4ui64NV');
+ glVertexAttribL1ui64vNV := dglGetProcAddress('glVertexAttribL1ui64vNV');
+ glVertexAttribL2ui64vNV := dglGetProcAddress('glVertexAttribL2ui64vNV');
+ glVertexAttribL3ui64vNV := dglGetProcAddress('glVertexAttribL3ui64vNV');
+ glVertexAttribL4ui64vNV := dglGetProcAddress('glVertexAttribL4ui64vNV');
+ glGetVertexAttribLi64vNV := dglGetProcAddress('glGetVertexAttribLi64vNV');
+ glGetVertexAttribLui64vNV := dglGetProcAddress('glGetVertexAttribLui64vNV');
+ glVertexAttribLFormatNV := dglGetProcAddress('glVertexAttribLFormatNV');
+end;
+
+procedure Read_GL_NV_vdpau_interop;
+begin
+ glVDPAUInitNV := dglGetProcAddress('glVDPAUInitNV');
+ glVDPAUFiniNV := dglGetProcAddress('glVDPAUFiniNV');
+ glVDPAURegisterVideoSurfaceNV := dglGetProcAddress('glVDPAURegisterVideoSurfaceNV');
+ glVDPAURegisterOutputSurfaceNV := dglGetProcAddress('glVDPAURegisterOutputSurfaceNV');
+ glVDPAUIsSurfaceNV := dglGetProcAddress('glVDPAUIsSurfaceNV');
+ glVDPAUUnregisterSurfaceNV := dglGetProcAddress('glVDPAUUnregisterSurfaceNV');
+ glVDPAUGetSurfaceivNV := dglGetProcAddress('glVDPAUGetSurfaceivNV');
+ glVDPAUSurfaceAccessNV := dglGetProcAddress('glVDPAUSurfaceAccessNV');
+ glVDPAUMapSurfacesNV := dglGetProcAddress('glVDPAUMapSurfacesNV');
+ glVDPAUUnmapSurfacesNV := dglGetProcAddress('glVDPAUUnmapSurfacesNV');
+end;
+
+procedure Read_GL_NV_texture_barrier;
+begin
+ glTextureBarrierNV := dglGetProcAddress('glTextureBarrierNV');
+end;
+
+procedure Read_GL_PGI_misc_hints;
+begin
+ glHintPGI := dglGetProcAddress('glHintPGI');
+end;
+
+procedure Read_GL_SGIS_detail_texture;
+begin
+ glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS');
+ glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_fog_function;
+begin
+ glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS');
+ glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_multisample;
+begin
+ glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS');
+ glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS');
+end;
+
+procedure Read_GL_SGIS_pixel_texture;
+begin
+ glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS');
+ glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS');
+ glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS');
+ glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS');
+ glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS');
+ glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS');
+end;
+
+procedure Read_GL_SGIS_point_parameters;
+begin
+ glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS');
+ glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS');
+end;
+
+procedure Read_GL_SGIS_sharpen_texture;
+begin
+ glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS');
+ glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_texture4D;
+begin
+ glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS');
+ glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS');
+end;
+
+procedure Read_GL_SGIS_texture_color_mask;
+begin
+ glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS');
+end;
+
+procedure Read_GL_SGIS_texture_filter4;
+begin
+ glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS');
+ glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS');
+end;
+
+procedure Read_GL_SGIX_async;
+begin
+ glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX');
+ glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX');
+ glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX');
+ glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX');
+ glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX');
+ glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX');
+end;
+
+procedure Read_GL_SGIX_flush_raster;
+begin
+ glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX');
+end;
+
+procedure Read_GL_SGIX_fragment_lighting;
+begin
+ glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX');
+ glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX');
+ glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX');
+ glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX');
+ glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX');
+ glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX');
+ glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX');
+ glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX');
+ glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX');
+ glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX');
+ glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX');
+ glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX');
+ glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX');
+ glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX');
+ glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX');
+ glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX');
+ glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX');
+ glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX');
+end;
+
+procedure Read_GL_SGIX_framezoom;
+begin
+ glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX');
+end;
+
+procedure Read_GL_SGIX_igloo_interface;
+begin
+ glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX');
+end;
+
+procedure Read_GL_SGIX_instruments;
+begin
+ glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX');
+ glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX');
+ glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX');
+ glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX');
+ glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX');
+ glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX');
+end;
+
+procedure Read_GL_SGIX_list_priority;
+begin
+ glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX');
+ glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX');
+ glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX');
+ glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX');
+ glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX');
+ glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX');
+end;
+
+procedure Read_GL_SGIX_pixel_texture;
+begin
+ glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX');
+end;
+
+procedure Read_GL_SGIX_polynomial_ffd;
+begin
+ glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX');
+ glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX');
+ glDeformSGIX := dglGetProcAddress('glDeformSGIX');
+ glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX');
+end;
+
+procedure Read_GL_SGIX_reference_plane;
+begin
+ glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX');
+end;
+
+procedure Read_GL_SGIX_sprite;
+begin
+ glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX');
+ glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX');
+ glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX');
+ glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX');
+end;
+
+procedure Read_GL_SGIX_tag_sample_buffer;
+begin
+ glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX');
+end;
+
+procedure Read_GL_SGI_color_table;
+begin
+ glColorTableSGI := dglGetProcAddress('glColorTableSGI');
+ glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI');
+ glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI');
+ glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI');
+ glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI');
+ glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI');
+ glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI');
+end;
+
+procedure Read_GL_SUNX_constant_data;
+begin
+ glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX');
+end;
+
+procedure Read_GL_SUN_global_alpha;
+begin
+ glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN');
+ glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN');
+ glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN');
+ glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN');
+ glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN');
+ glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN');
+ glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN');
+ glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN');
+end;
+
+procedure Read_GL_SUN_mesh_array;
+begin
+ glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN');
+end;
+
+procedure Read_GL_SUN_triangle_list;
+begin
+ glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN');
+ glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN');
+ glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN');
+ glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN');
+ glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN');
+ glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN');
+ glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN');
+end;
+
+procedure Read_GL_SUN_vertex;
+begin
+ glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN');
+ glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN');
+ glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN');
+ glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN');
+ glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN');
+ glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN');
+ glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN');
+ glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN');
+ glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN');
+ glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN');
+ glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN');
+ glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN');
+ glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN');
+ glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN');
+ glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN');
+ glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN');
+ glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN');
+ glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN');
+ glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN');
+ glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN');
+ glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN');
+ glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN');
+ glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN');
+ glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN');
+ glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN');
+ glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN');
+ glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN');
+ glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN');
+ glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN');
+ glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN');
+ glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN');
+ glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN');
+ glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
+ glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
+ glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN');
+ glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN');
+ glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
+ glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
+ glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
+ glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
+end;
+
+{$IFDEF DGL_WIN}
+procedure Read_WGL_ARB_buffer_region;
+begin
+ wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB');
+ wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB');
+ wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB');
+ wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB');
+end;
+
+procedure Read_WGL_ARB_extensions_string;
+begin
+ wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
+end;
+
+procedure Read_WGL_ARB_make_current_read;
+begin
+ wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB');
+ wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB');
+end;
+
+procedure Read_WGL_ARB_pbuffer;
+begin
+ wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB');
+ wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB');
+ wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB');
+ wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB');
+ wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB');
+end;
+
+procedure Read_WGL_ARB_pixel_format;
+begin
+ wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB');
+ wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB');
+ wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB');
+end;
+
+procedure Read_WGL_ARB_pixel_format_float;
+begin
+ wglClampColorARB := dglGetProcAddress('wglClampColorARB');
+end;
+
+procedure Read_WGL_ARB_render_texture;
+begin
+ wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB');
+ wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB');
+ wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB');
+end;
+
+procedure Read_WGL_ARB_create_context;
+begin
+ wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB');
+end;
+
+procedure Read_WGL_AMD_gpu_association;
+begin
+ wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD');
+ wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD');
+ wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD');
+ wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD');
+ wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD');
+ wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD');
+ wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD');
+ wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD');
+ wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD');
+end;
+
+procedure Read_WGL_EXT_display_color_table;
+begin
+ wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT');
+ wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT');
+ wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT');
+ wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT');
+end;
+
+procedure Read_WGL_EXT_extensions_string;
+begin
+ wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
+end;
+
+procedure Read_WGL_EXT_make_current_read;
+begin
+ wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT');
+ wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT');
+end;
+
+procedure Read_WGL_EXT_pbuffer;
+begin
+ wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT');
+ wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT');
+ wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT');
+ wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT');
+ wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT');
+end;
+
+procedure Read_WGL_EXT_pixel_format;
+begin
+ wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT');
+ wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT');
+ wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT');
+end;
+
+procedure Read_WGL_EXT_swap_control;
+begin
+ wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT');
+ wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT');
+end;
+
+procedure Read_WGL_I3D_digital_video_control;
+begin
+ wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D');
+ wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D');
+end;
+
+procedure Read_WGL_I3D_gamma;
+begin
+ wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D');
+ wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D');
+ wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D');
+ wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D');
+end;
+
+procedure Read_WGL_I3D_genlock;
+begin
+ wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D');
+ wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D');
+ wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D');
+ wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D');
+ wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D');
+ wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D');
+ wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D');
+ wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D');
+ wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D');
+ wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D');
+ wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D');
+ wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
+end;
+
+procedure Read_WGL_I3D_image_buffer;
+begin
+ wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D');
+ wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D');
+ wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D');
+ wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D');
+end;
+
+procedure Read_WGL_I3D_swap_frame_lock;
+begin
+ wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D');
+ wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D');
+ wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D');
+ wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D');
+end;
+
+procedure Read_WGL_I3D_swap_frame_usage;
+begin
+ wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D');
+ wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D');
+ wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D');
+ wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D');
+end;
+
+procedure Read_WGL_NV_vertex_array_range;
+begin
+ wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV');
+ wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV');
+end;
+
+procedure Read_WGL_NV_present_video;
+begin
+ wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV');
+ wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV');
+ wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV');
+end;
+
+procedure Read_WGL_NV_video_output;
+begin
+ wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV');
+ wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV');
+ wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV');
+ wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV');
+ wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV');
+ wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV');
+end;
+
+procedure Read_WGL_NV_swap_group;
+begin
+ wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV');
+ wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV');
+ wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV');
+ wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV');
+ wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV');
+ wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV');
+end;
+
+procedure Read_WGL_NV_gpu_affinity;
+begin
+ wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV');
+ wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV');
+ wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV');
+ wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV');
+ wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV');
+end;
+
+procedure Read_WGL_NV_video_capture;
+begin
+ wglBindVideoCaptureDeviceNV := dglGetProcAddress('wglBindVideoCaptureDeviceNV');
+ wglEnumerateVideoCaptureDevicesNV := dglGetProcAddress('wglEnumerateVideoCaptureDevicesNV');
+ wglLockVideoCaptureDeviceNV := dglGetProcAddress('wglLockVideoCaptureDeviceNV');
+ wglQueryVideoCaptureDeviceNV := dglGetProcAddress('wglQueryVideoCaptureDeviceNV');
+ wglReleaseVideoCaptureDeviceNV := dglGetProcAddress('wglReleaseVideoCaptureDeviceNV');
+end;
+
+procedure Read_WGL_NV_copy_image;
+begin
+ wglCopyImageSubDataNV := dglGetProcAddress('wglCopyImageSubDataNV');
+end;
+
+procedure Read_WGL_NV_DX_interop;
+begin
+ wglDXSetResourceShareHandleNV := dglGetProcAddress('wglDXSetResourceShareHandleNV');
+ wglDXOpenDeviceNV := dglGetProcAddress('wglDXOpenDeviceNV');
+ wglDXCloseDeviceNV := dglGetProcAddress('wglDXCloseDeviceNV');
+ wglDXRegisterObjectNV := dglGetProcAddress('wglDXRegisterObjectNV');
+ wglDXUnregisterObjectNV := dglGetProcAddress('wglDXUnregisterObjectNV');
+ wglDXObjectAccessNV := dglGetProcAddress('wglDXObjectAccessNV');
+ wglDXLockObjectsNV := dglGetProcAddress('wglDXLockObjectsNV');
+ wglDXUnlockObjectsNV := dglGetProcAddress('wglDXUnlockObjectsNV');
+end;
+
+
+procedure Read_WGL_OML_sync_control;
+begin
+ wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML');
+ wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML');
+ wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML');
+ wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML');
+ wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML');
+ wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML');
+end;
+
+procedure Read_WGL_3DL_stereo_control;
+begin
+ wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL');
+end;
+
+procedure Read_WIN_draw_range_elements;
+begin
+ glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN');
+end;
+
+procedure Read_WIN_swap_hint;
+begin
+ glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN');
+end;
+{$ENDIF}
+
+
+procedure ReadExtensions;
+begin
+ ReadOpenGLCore;
+
+ Read_GL_3DFX_tbuffer;
+ Read_GL_APPLE_element_array;
+ Read_GL_APPLE_fence;
+ Read_GL_APPLE_vertex_array_object;
+ Read_GL_APPLE_vertex_array_range;
+ Read_GL_APPLE_texture_range;
+ Read_GL_APPLE_vertex_program_evaluators;
+ Read_GL_APPLE_object_purgeable;
+ Read_GL_ARB_matrix_palette;
+ Read_GL_ARB_multitexture;
+ Read_GL_ARB_point_parameters;
+ Read_GL_ARB_texture_compression;
+ Read_GL_ARB_transpose_matrix;
+ Read_GL_ARB_vertex_blend;
+ Read_GL_ARB_vertex_buffer_object;
+ Read_GL_ARB_vertex_program;
+ Read_GL_ARB_window_pos;
+ Read_GL_ARB_color_buffer_float;
+ Read_GL_ARB_Shader_Objects;
+ Read_GL_ARB_occlusion_query;
+ Read_GL_ARB_draw_instanced;
+ Read_GL_ARB_framebuffer_object;
+ Read_GL_ARB_geometry_shader4;
+ Read_GL_ARB_instanced_arrays;
+ Read_GL_ARB_map_buffer_range;
+ Read_GL_ARB_texture_buffer_object;
+ Read_GL_ARB_vertex_array_object;
+ Read_GL_ARB_uniform_buffer_object;
+ Read_GL_ARB_copy_buffer;
+ Read_GL_ARB_draw_elements_base_vertex;
+ Read_GL_ARB_provoking_vertex;
+ Read_GL_ARB_sync;
+ Read_GL_ARB_texture_multisample;
+ Read_GL_ARB_draw_buffers_blend;
+ Read_GL_ARB_sample_shading;
+ Read_GL_ARB_shading_language_include;
+ Read_GL_ARB_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_ES2_compatibility;
+ Read_GL_ARB_get_program_binary;
+ Read_GL_ARB_separate_shader_objects;
+ Read_GL_ARB_vertex_attrib_64bit;
+ Read_GL_ARB_viewport_array;
+ Read_GL_ARB_cl_event;
+ Read_GL_ARB_compute_variable_group_size;
+ Read_GL_ARB_debug_output;
+ Read_GL_ARB_robustness;
+ //
+ Read_GL_ATI_draw_buffers;
+ Read_GL_ATI_element_array;
+ Read_GL_ATI_envmap_bumpmap;
+ Read_GL_ATI_fragment_shader;
+ Read_GL_ATI_map_object_buffer;
+ Read_GL_ATI_pn_triangles;
+ Read_GL_ATI_separate_stencil;
+ Read_GL_ATI_vertex_array_object;
+ Read_GL_ATI_vertex_attrib_array_object;
+ Read_GL_ATI_vertex_streams;
+ Read_GL_AMD_performance_monitor;
+ Read_GL_AMD_vertex_shader_tesselator;
+ Read_GL_AMD_draw_buffers_blend;
+ Read_GL_AMD_name_gen_delete;
+ Read_GL_AMD_debug_output;
+ Read_GL_AMD_stencil_operation_extended;
+ Read_GL_EXT_blend_color;
+ Read_GL_EXT_blend_func_separate;
+ Read_GL_EXT_blend_minmax;
+ Read_GL_EXT_color_subtable;
+ Read_GL_EXT_compiled_vertex_array;
+ Read_GL_EXT_convolution;
+ Read_GL_EXT_coordinate_frame;
+ Read_GL_EXT_copy_texture;
+ Read_GL_EXT_cull_vertex;
+ Read_GL_EXT_draw_range_elements;
+ Read_GL_EXT_fog_coord;
+ Read_GL_EXT_framebuffer_object;
+ Read_GL_EXT_histogram;
+ Read_GL_EXT_index_func;
+ Read_GL_EXT_index_material;
+ Read_GL_EXT_multi_draw_arrays;
+ Read_GL_EXT_multisample;
+ Read_GL_EXT_paletted_texture;
+ Read_GL_EXT_pixel_transform;
+ Read_GL_EXT_point_parameters;
+ Read_GL_EXT_polygon_offset;
+ Read_GL_EXT_secondary_color;
+ Read_GL_EXT_stencil_two_side;
+ Read_GL_EXT_subtexture;
+ Read_GL_EXT_texture3D;
+ Read_GL_EXT_texture_object;
+ Read_GL_EXT_texture_perturb_normal;
+ Read_GL_EXT_vertex_array;
+ Read_GL_EXT_vertex_shader;
+ Read_GL_EXT_vertex_weighting;
+ Read_GL_EXT_depth_bounds_test;
+ Read_GL_EXT_blend_equation_separate;
+ Read_GL_EXT_stencil_clear_tag;
+ Read_GL_EXT_framebuffer_blit;
+ Read_GL_EXT_framebuffer_multisample;
+ Read_GL_EXT_timer_query;
+ Read_GL_EXT_gpu_program_parameters;
+ Read_GL_EXT_bindable_uniform;
+ Read_GL_EXT_draw_buffers2;
+ Read_GL_EXT_draw_instanced;
+ Read_GL_EXT_geometry_shader4;
+ Read_GL_EXT_gpu_shader4;
+ Read_GL_EXT_texture_array;
+ Read_GL_EXT_texture_buffer_object;
+ Read_GL_EXT_texture_integer;
+ Read_GL_EXT_transform_feedback;
+ Read_GL_EXT_direct_state_access;
+ Read_GL_EXT_separate_shader_objects;
+ Read_GL_EXT_shader_image_load_store;
+ Read_GL_EXT_vertex_attrib_64bit;
+ Read_GL_HP_image_transform;
+ Read_GL_IBM_multimode_draw_arrays;
+ Read_GL_IBM_vertex_array_lists;
+ Read_GL_INGR_blend_func_separate;
+ Read_GL_INTEL_parallel_arrays;
+ Read_GL_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_present_video;
+ Read_GL_NV_explicit_multisample;
+ Read_GL_NV_transform_feedback2;
+ Read_GL_NV_video_capture;
+ Read_GL_NV_copy_image;
+ Read_GL_NV_shader_buffer_load;
+ Read_GL_NV_vertex_buffer_unified_memory;
+ Read_GL_NV_gpu_program5;
+ Read_GL_NV_gpu_shader5;
+ Read_GL_NV_vertex_attrib_integer_64bit;
+ Read_GL_NV_vdpau_interop;
+ Read_GL_NV_texture_barrier;
+ Read_GL_NV_path_rendering;
+ Read_GL_NV_bindless_texture;
+ Read_GL_PGI_misc_hints;
+ Read_GL_SGIS_detail_texture;
+ Read_GL_SGIS_fog_function;
+ Read_GL_SGIS_multisample;
+ Read_GL_SGIS_pixel_texture;
+ Read_GL_SGIS_point_parameters;
+ Read_GL_SGIS_sharpen_texture;
+ Read_GL_SGIS_texture4D;
+ Read_GL_SGIS_texture_color_mask;
+ Read_GL_SGIS_texture_filter4;
+ Read_GL_SGIX_async;
+ Read_GL_SGIX_flush_raster;
+ Read_GL_SGIX_fragment_lighting;
+ Read_GL_SGIX_framezoom;
+ Read_GL_SGIX_igloo_interface;
+ Read_GL_SGIX_instruments;
+ Read_GL_SGIX_list_priority;
+ Read_GL_SGIX_pixel_texture;
+ Read_GL_SGIX_polynomial_ffd;
+ Read_GL_SGIX_reference_plane;
+ Read_GL_SGIX_sprite;
+ Read_GL_SGIX_tag_sample_buffer;
+ Read_GL_SGI_color_table;
+ Read_GL_SUNX_constant_data;
+ Read_GL_SUN_global_alpha;
+ Read_GL_SUN_mesh_array;
+ Read_GL_SUN_triangle_list;
+ Read_GL_SUN_vertex;
+
+{$IFDEF DGL_WIN}
+ Read_WGL_ARB_buffer_region;
+ Read_WGL_ARB_extensions_string;
+ Read_WGL_ARB_make_current_read;
+ Read_WGL_ARB_pbuffer;
+ Read_WGL_ARB_pixel_format;
+ Read_WGL_ARB_pixel_format_float;
+ Read_WGL_ARB_render_texture;
+ Read_WGL_ARB_create_context;
+ Read_WGL_AMD_gpu_association;
+ Read_WGL_EXT_display_color_table;
+ Read_WGL_EXT_extensions_string;
+ Read_WGL_EXT_make_current_read;
+ Read_WGL_EXT_pbuffer;
+ Read_WGL_EXT_pixel_format;
+ Read_WGL_EXT_swap_control;
+ Read_WGL_I3D_digital_video_control;
+ Read_WGL_I3D_gamma;
+ Read_WGL_I3D_genlock;
+ Read_WGL_I3D_image_buffer;
+ Read_WGL_I3D_swap_frame_lock;
+ Read_WGL_I3D_swap_frame_usage;
+ Read_WGL_NV_vertex_array_range;
+ Read_WGL_NV_present_video;
+ Read_WGL_NV_video_output;
+ Read_WGL_NV_swap_group;
+ Read_WGL_NV_gpu_affinity;
+ Read_WGL_NV_video_capture;
+ Read_WGL_NV_copy_image;
+ Read_WGL_NV_DX_interop;
+ Read_WGL_OML_sync_control;
+ Read_WGL_3DL_stereo_control;
+
+ Read_WIN_draw_range_elements;
+ Read_WIN_swap_hint;
+{$ENDIF}
+
+ ExtensionsRead := True;
+end;
+
+// =============================================================================
+// ReadCoreVersion
+// =============================================================================
+
+procedure ReadCoreVersion;
+var
+ AnsiBuffer: AnsiString;
+ Buffer: String;
+ MajorVersion, MinorVersion: Integer;
+
+ procedure TrimAndSplitVersionString(Buffer: String; out Max, Min: Integer);
+ // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
+ // at least however "Major.Minor".
+ var
+ Separator: Integer;
+ begin
+ try
+ // There must be at least one dot to separate major and minor version number.
+ Separator := Pos('.', Buffer);
+ // At least one number must be before and one after the dot.
+ if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and
+ (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then
+ begin
+ // OK, it's a valid version string. Now remove unnecessary parts.
+ Dec(Separator);
+ // Find last non-numeric character before version number.
+ while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
+ Dec(Separator);
+ // Delete leading characters which do not belong to the version string.
+ Delete(Buffer, 1, Separator);
+ Separator := Pos('.', Buffer) + 1;
+ // Find first non-numeric character after version number
+ while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
+ Inc(Separator);
+ // delete trailing characters not belonging to the version string
+ Delete(Buffer, Separator, 255);
+ // Now translate the numbers.
+ Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.
+ Max := StrToInt(Copy(Buffer, 1, Separator - 1));
+ Min := StrToInt(Copy(Buffer, Separator + 1, 1));
+ end
+ else
+ Abort;
+ except
+ Min := 0;
+ Max := 0;
+ end;
+ end;
+
+
+begin
+ // determine version of implementation
+ // GL
+ if not Assigned(@glGetString) then
+ glGetString := dglGetProcAddress('glGetString');
+
+ AnsiBuffer := glGetString(GL_VERSION);
+ Buffer := String(AnsiBuffer);
+
+ TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion);
+
+ GL_VERSION_1_0 := True;
+ GL_VERSION_1_1 := False;
+ GL_VERSION_1_2 := False;
+ GL_VERSION_1_3 := False;
+ GL_VERSION_1_4 := False;
+ GL_VERSION_1_5 := False;
+ GL_VERSION_2_0 := False;
+ GL_VERSION_2_1 := False;
+ GL_VERSION_3_0 := False;
+ GL_VERSION_3_1 := False;
+ GL_VERSION_3_2 := False;
+ GL_VERSION_3_3 := False;
+ GL_VERSION_4_0 := False;
+ GL_VERSION_4_1 := False;
+ GL_VERSION_4_2 := False;
+ GL_VERSION_4_3 := False;
+ GL_VERSION_4_4 := False;
+ 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_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp');
+ GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression');
+ GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map');
+ GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add');
+ GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine');
+ GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar');
+ GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3');
+ GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat');
+ GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix');
+ GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend');
+ GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object');
+ GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program');
+ GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos');
+ GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects');
+ GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader');
+ GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader');
+ GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query');
+ GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100');
+ GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite');
+ GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two');
+ GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow');
+ GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers');
+ GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle');
+ GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float');
+ GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel');
+ GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float');
+ GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object');
+ GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float');
+ GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced');
+ GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object');
+ GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB');
+ GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4');
+ GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex');
+ GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays');
+ GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range');
+ GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object');
+ GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc');
+ GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg');
+ GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object');
+ GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object');
+ GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility');
+ GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer');
+ GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod');
+ GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp');
+ GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex');
+ GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions');
+ GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex');
+ GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map');
+ GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync');
+ GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample');
+ GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra');
+ GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend');
+ GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading');
+ GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array');
+ GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather');
+ GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod');
+ GL_ARB_shading_language_include := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_include');
+ GL_ARB_texture_compression_bptc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_bptc');
+ GL_ARB_blend_func_extended := Int_CheckExtension(Buffer, 'GL_ARB_blend_func_extended');
+ GL_ARB_explicit_attrib_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_attrib_location');
+ GL_ARB_occlusion_query2 := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query2');
+ GL_ARB_sampler_objects := Int_CheckExtension(Buffer, 'GL_ARB_sampler_objects');
+ GL_ARB_shader_bit_encoding := Int_CheckExtension(Buffer, 'GL_ARB_shader_bit_encoding');
+ GL_ARB_texture_rgb10_a2ui := Int_CheckExtension(Buffer, 'GL_ARB_texture_rgb10_a2ui');
+ GL_ARB_texture_swizzle := Int_CheckExtension(Buffer, 'GL_ARB_texture_swizzle');
+ GL_ARB_timer_query := Int_CheckExtension(Buffer, 'GL_ARB_timer_query');
+ GL_ARB_vertex_type_2_10_10_10_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_2_10_10_10_rev');
+ GL_ARB_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_draw_indirect');
+ GL_ARB_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader5');
+ GL_ARB_gpu_shader_fp64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_fp64');
+ GL_ARB_shader_subroutine := Int_CheckExtension(Buffer, 'GL_ARB_shader_subroutine');
+ GL_ARB_tessellation_shader := Int_CheckExtension(Buffer, 'GL_ARB_tessellation_shader');
+ GL_ARB_texture_buffer_object_rgb32 := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object_rgb32');
+ GL_ARB_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback2');
+ GL_ARB_transform_feedback3 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback3');
+ GL_ARB_ES2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES2_compatibility');
+ GL_ARB_get_program_binary := Int_CheckExtension(Buffer, 'GL_ARB_get_program_binary');
+ GL_ARB_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_separate_shader_objects');
+ GL_ARB_shader_precision := Int_CheckExtension(Buffer, 'GL_ARB_shader_precision');
+ GL_ARB_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_64bit');
+ GL_ARB_viewport_array := Int_CheckExtension(Buffer, 'GL_ARB_viewport_array');
+ GL_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_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_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_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video');
+ GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample');
+ GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2');
+ GL_NV_video_capture := Int_CheckExtension(Buffer, 'GL_NV_video_capture');
+ GL_NV_copy_image := Int_CheckExtension(Buffer, 'GL_NV_copy_image');
+ GL_NV_parameter_buffer_object2 := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object2');
+ GL_NV_shader_buffer_load := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_load');
+ GL_NV_vertex_buffer_unified_memory := Int_CheckExtension(Buffer, 'GL_NV_vertex_buffer_unified_memory');
+ GL_NV_gpu_program5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program5');
+ GL_NV_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_shader5');
+ GL_NV_shader_buffer_store := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_store');
+ GL_NV_tessellation_program5 := Int_CheckExtension(Buffer, 'GL_NV_tessellation_program5');
+ GL_NV_vertex_attrib_integer_64bit := Int_CheckExtension(Buffer, 'GL_NV_vertex_attrib_integer_64bit');
+ GL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_multisample_coverage');
+ GL_NV_vdpau_interop := Int_CheckExtension(Buffer, 'GL_NV_vdpau_interop');
+ GL_NV_texture_barrier := Int_CheckExtension(Buffer, 'GL_NV_texture_barrier');
+ // 4.3
+ GL_NV_path_rendering := Int_CheckExtension(Buffer, 'GL_NV_path_rendering');
+ GL_NV_bindless_texture := Int_CheckExtension(Buffer, 'GL_NV_bindless_texture');
+ GL_NV_shader_atomic_float := Int_CheckExtension(Buffer, 'GL_NV_shader_atomic_float');
+
+ // OML
+ GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace');
+ GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample');
+ GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample');
+
+ // PGI
+ GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints');
+ GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints');
+
+ // REND
+ GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates');
+
+ // S3
+ GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc');
+
+ // SGIS
+ GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture');
+ GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function');
+ GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap');
+ GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample');
+ GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture');
+ GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen');
+ GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters');
+ GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture');
+ GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D');
+ GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp');
+ GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask');
+ GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp');
+ GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4');
+ GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod');
+ GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select');
+
+ // SGIX
+ GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX');
+ GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async');
+ GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram');
+ GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel');
+ GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax');
+ GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment');
+ GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap');
+ GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy');
+ GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument');
+ GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture');
+ GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster');
+ GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset');
+ GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale');
+ GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting');
+ GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom');
+ GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface');
+ GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture');
+ GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments');
+ GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace');
+ GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1');
+ GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority');
+ GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture');
+ GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles');
+ GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd');
+ GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane');
+ GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample');
+ GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint');
+ GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow');
+ GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient');
+ GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite');
+ GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample');
+ GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer');
+ GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env');
+ GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp');
+ GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias');
+ GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer');
+ GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias');
+ GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select');
+ GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip');
+ GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb');
+ GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample');
+ GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba');
+
+ // SGI
+ GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix');
+ GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table');
+ GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument');
+ GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table');
+
+ // SUN
+ GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data');
+ GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes');
+ GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha');
+ GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array');
+ GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum');
+ GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list');
+ GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex');
+
+ // WIN
+ GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading');
+ GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog');
+
+ {$IFDEF DGL_WIN}
+ // WGL
+ WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample');
+ WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region');
+ WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string');
+ WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read');
+ WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample');
+ WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer');
+ WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format');
+ WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float');
+ WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture');
+ WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context');
+ WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile');
+ WGL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'WGL_ARB_framebuffer_sRGB');
+ WGL_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_robustness');
+ WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float');
+ WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association');
+ WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float');
+ WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table');
+ WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string');
+ WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read');
+ WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample');
+ WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer');
+ WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format');
+ WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control');
+ WGL_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'WGL_EXT_create_context_es2_profile');
+ WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control');
+ WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma');
+ WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock');
+ WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer');
+ WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock');
+ WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage');
+ WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer');
+ WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture');
+ WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle');
+ WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range');
+ WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video');
+ WGL_NV_video_output := Int_CheckExtension(Buffer, 'WGL_NV_video_output');
+ WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group');
+ WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity');
+ WGL_NV_video_capture := Int_CheckExtension(Buffer, 'WGL_NV_video_capture');
+ WGL_NV_copy_image := Int_CheckExtension(Buffer, 'WGL_NV_copy_image');
+ WGL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
+ WGL_NV_DX_interop := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
+ WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control');
+ WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control');
+ 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{%H-}, SizeOf(PFDescriptor), 0);
+
+ with PFDescriptor do
+ begin
+ nSize := SizeOf(PFDescriptor);
+ nVersion := 1;
+ dwFlags := PFD_SUPPORT_OPENGL;
+
+ AType := GetObjectType(DC);
+
+ if AType = 0 then
+ RaiseLastOSError;
+
+ if AType in MemoryDCs then
+ dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+ else
+ dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+ if opDoubleBuffered in Options then
+ dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+
+ if opGDI in Options then
+ dwFlags := dwFlags or PFD_SUPPORT_GDI;
+
+ if opStereo in Options then
+ dwFlags := dwFlags or PFD_STEREO;
+
+ iPixelType := PFD_TYPE_RGBA;
+ cColorBits := ColorBits;
+ cDepthBits := zBits;
+ cStencilBits := StencilBits;
+ cAccumBits := AccumBits;
+ cAuxBuffers := AuxBuffers;
+
+ if Layer = 0 then
+ iLayerType := PFD_MAIN_PLANE
+ else
+ if Layer > 0 then
+ iLayerType := PFD_OVERLAY_PLANE
+ else
+ iLayerType := Byte(PFD_UNDERLAY_PLANE);
+ end;
+
+ PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
+
+ if PixelFormat = 0 then
+ RaiseLastOSError;
+
+ if GetPixelFormat(DC) <> PixelFormat then
+ if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
+ RaiseLastOSError;
+
+ DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
+
+ Result := wglCreateContext(DC);
+
+ if Result = 0 then
+ RaiseLastOSError
+ else
+ LastPixelFormat := 0;
+end;
+
+// =============================================================================
+// CreateRenderingContextVersion
+// =============================================================================
+// Creates a context for the more recent OpenGL versions (3.0) and up
+// For that we first need to get a normal GL context for getting the
+// function pointer to wglCreateContextAttribsARB first
+// =============================================================================
+function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
+const
+ OBJ_MEMDC = 10;
+ OBJ_ENHMETADC = 12;
+ OBJ_METADC = 4;
+ PFD_DOUBLEBUFFER = $00000001;
+ PFD_STEREO = $00000002;
+ PFD_DRAW_TO_WINDOW = $00000004;
+ PFD_DRAW_TO_BITMAP = $00000008;
+ PFD_SUPPORT_GDI = $00000010;
+ PFD_SUPPORT_OPENGL = $00000020;
+ PFD_TYPE_RGBA = 0;
+ PFD_MAIN_PLANE = 0;
+ PFD_OVERLAY_PLANE = 1;
+ PFD_UNDERLAY_PLANE = LongWord(-1);
+ MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
+var
+ PFDescriptor : TPixelFormatDescriptor;
+ PixelFormat : Integer;
+ AType : DWORD;
+ LegacyRC : HGLRC;
+ Attribs : array of Integer;
+begin
+ if GL_LibHandle = nil then
+ InitOpenGL;
+
+ if not Assigned(GL_LibHandle) then
+ raise Exception.Create('GL_LibHandle is NIL. Could not load OpenGL library!');
+
+ FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0);
+
+ with PFDescriptor do
+ begin
+ nSize := SizeOf(PFDescriptor);
+ nVersion := 1;
+ dwFlags := PFD_SUPPORT_OPENGL;
+ AType := GetObjectType(DC);
+
+ if AType = 0 then
+ RaiseLastOSError;
+
+ if AType in MemoryDCs then
+ dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+ else
+ dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+ if opDoubleBuffered in Options then
+ dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+
+ if opGDI in Options then
+ dwFlags := dwFlags or PFD_SUPPORT_GDI;
+
+ if opStereo in Options then
+ dwFlags := dwFlags or PFD_STEREO;
+
+ iPixelType := PFD_TYPE_RGBA;
+ cColorBits := ColorBits;
+ cDepthBits := zBits;
+ cStencilBits := StencilBits;
+ cAccumBits := AccumBits;
+ cAuxBuffers := AuxBuffers;
+
+ if Layer = 0 then
+ iLayerType := PFD_MAIN_PLANE
+ else
+ if Layer > 0 then
+ iLayerType := PFD_OVERLAY_PLANE
+ else
+ iLayerType := Byte(PFD_UNDERLAY_PLANE);
+ end;
+
+ PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
+
+ if PixelFormat = 0 then
+ RaiseLastOSError;
+
+ if GetPixelFormat(DC) <> PixelFormat then
+ if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
+ RaiseLastOSError;
+
+ DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
+
+ // Create legacy render context first for we need function pointers to
+ // create new OpenGL render contexts
+ LegacyRC := wglCreateContext(DC);
+ wglMakeCurrent(DC, LegacyRC);
+
+ // Set attributes to describe our requested context
+ SetLength(Attribs, 5);
+ Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;
+ Attribs[1] := MajorVersion;
+ Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;
+ Attribs[3] := MinorVersion;
+
+ // Add context flag for forward compatible context
+ // Forward compatible means no more support for legacy functions like
+ // immediate mode (glvertex, glrotate, gltranslate, etc.)
+ if ForwardCompatible then
+ begin
+ SetLength(Attribs, Length(Attribs)+2);
+ Attribs[4] := WGL_CONTEXT_FLAGS_ARB;
+ Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+ end;
+
+ // Attribute flags must be finalized with a zero
+ Attribs[High(Attribs)] := 0;
+
+ // Get function pointer for new context creation function
+ wglCreateContextAttribsARB := wglGetProcAddress('wglCreateContextAttribsARB');
+
+ if not Assigned(wglCreateContextAttribsARB) then
+ begin
+ raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!');
+ wglDeleteContext(LegacyRC);
+ exit;
+ end;
+
+ // Create context
+ Result := wglCreateContextAttribsARB(DC, 0, @Attribs[0]);
+
+ if Result = 0 then
+ begin
+ raise Exception.Create('Could not create the desired OpenGL rendering context!');
+ wglDeleteContext(LegacyRC);
+ exit;
+ end;
+
+ wglDeleteContext(LegacyRC);
+
+ if Result = 0 then
+ RaiseLastOSError
+ else
+ LastPixelFormat := 0;
+end;
+
+// =============================================================================
+// DestroyRenderingContext
+// =============================================================================
+
+procedure DestroyRenderingContext(RC: HGLRC);
+begin
+ wglDeleteContext(RC);
+end;
+
+
+// =============================================================================
+// ActivateRenderingContext
+// =============================================================================
+
+procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
+begin
+ Assert((DC <> 0), 'DC must not be 0');
+ Assert((RC <> 0), 'RC must not be 0');
+
+ wglMakeCurrent(DC, RC);
+
+ {$ifdef DGL_TINY_HEADER}
+ ReadCoreVersion;
+ {$else}
+ ReadImplementationProperties;
+
+ if (loadext) then
+ ReadExtensions;
+ {$endif}
+end;
+
+// =============================================================================
+// DeactivateRenderingContext
+// =============================================================================
+
+procedure DeactivateRenderingContext;
+begin
+ wglMakeCurrent(0, 0);
+end;
+{$ENDIF}
+
+
+initialization
+
+{$IFDEF CPU386}
+ Set8087CW($133F);
+{$ENDIF}
+{$IFDEF DGL_64BIT}
+ SetExceptionMask([exInvalidOp, exDenormalized, exZeroDivide,exOverflow, exUnderflow, exPrecision]);
+{$ENDIF}
+
+
+finalization
+
+end.
+
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Classes, Interfaces, Objects and Records</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Classes, Interfaces, Objects and Records</h1>
-<table class="itemstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemunit">Unit</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmap.html">EglBitmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>glBitmap exception</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapNonPowerOfTwo.html">EglBitmapNonPowerOfTwo</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for non power of two textures</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapNotSupported.html">EglBitmapNotSupported</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for not supported functions</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapSizeToLarge.html">EglBitmapSizeToLarge</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for to large textures</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapUnsupportedFormat.html">EglBitmapUnsupportedFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for unsupporetd formats</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap.html">TglBitmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>base class for all glBitmap classes. used to manage OpenGL texture objects all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap1D.html">TglBitmap1D</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapCubeMap.html">TglBitmapCubeMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapData.html">TglBitmapData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>class to store texture data in. used to load, save and manipulate data before assigned to texture object all operations on a data object can be done from a background thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>describes the properties of a given texture data format</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapFunctionRec.html">TglBitmapFunctionRec</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>structure to store data for converting in</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapNormalMap.html">TglBitmapNormalMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>structure to store pixel data in</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned byte values</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned integer values</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned long integer values</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapSize.html">TglBitmapSize</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Constants</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Constants</h1>
-<table class="itemstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemunit">Unit</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#NULL_SIZE">NULL_SIZE</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Functions and Procedures</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Functions and Procedures</h1>
-<table class="itemstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemunit">Unit</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapCreateTestData">glBitmapCreateTestData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultDeleteTextureOnFree">glBitmapGetDefaultDeleteTextureOnFree</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFilter">glBitmapGetDefaultFilter</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFormat">glBitmapGetDefaultFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFreeDataAfterGenTexture">glBitmapGetDefaultFreeDataAfterGenTexture</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultMipmap">glBitmapGetDefaultMipmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultSwizzle">glBitmapGetDefaultSwizzle</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultTextureWrap">glBitmapGetDefaultTextureWrap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapPosition">glBitmapPosition</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ub">glBitmapRec4ub</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ubCompare">glBitmapRec4ubCompare</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ui">glBitmapRec4ui</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4uiCompare">glBitmapRec4uiCompare</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ul">glBitmapRec4ul</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultDeleteTextureOnFree">glBitmapSetDefaultDeleteTextureOnFree</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFilter">glBitmapSetDefaultFilter</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFormat">glBitmapSetDefaultFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFreeDataAfterGenTexture">glBitmapSetDefaultFreeDataAfterGenTexture</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultMipmap">glBitmapSetDefaultMipmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultSwizzle">glBitmapSetDefaultSwizzle</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultWrap">glBitmapSetDefaultWrap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSize">glBitmapSize</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Identifiers</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Identifiers</h1>
-<table class="itemstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemunit">Unit</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmap.html">EglBitmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>glBitmap exception</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapNonPowerOfTwo.html">EglBitmapNonPowerOfTwo</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for non power of two textures</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapNotSupported.html">EglBitmapNotSupported</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for not supported functions</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapSizeToLarge.html">EglBitmapSizeToLarge</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for to large textures</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.EglBitmapUnsupportedFormat.html">EglBitmapUnsupportedFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>exception for unsupporetd formats</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapCreateTestData">glBitmapCreateTestData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultDeleteTextureOnFree">glBitmapGetDefaultDeleteTextureOnFree</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFilter">glBitmapGetDefaultFilter</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFormat">glBitmapGetDefaultFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultFreeDataAfterGenTexture">glBitmapGetDefaultFreeDataAfterGenTexture</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultMipmap">glBitmapGetDefaultMipmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultSwizzle">glBitmapGetDefaultSwizzle</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapGetDefaultTextureWrap">glBitmapGetDefaultTextureWrap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapPosition">glBitmapPosition</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ub">glBitmapRec4ub</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ubCompare">glBitmapRec4ubCompare</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ui">glBitmapRec4ui</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4uiCompare">glBitmapRec4uiCompare</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapRec4ul">glBitmapRec4ul</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultDeleteTextureOnFree">glBitmapSetDefaultDeleteTextureOnFree</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFilter">glBitmapSetDefaultFilter</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFormat">glBitmapSetDefaultFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultFreeDataAfterGenTexture">glBitmapSetDefaultFreeDataAfterGenTexture</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultMipmap">glBitmapSetDefaultMipmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultSwizzle">glBitmapSetDefaultSwizzle</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSetDefaultWrap">glBitmapSetDefaultWrap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#glBitmapSize">glBitmapSize</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#NULL_SIZE">NULL_SIZE</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#PglBitmapPixelData">PglBitmapPixelData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap.html">TglBitmap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>base class for all glBitmap classes. used to manage OpenGL texture objects all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap1D.html">TglBitmap1D</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapCubeMap.html">TglBitmapCubeMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapData.html">TglBitmapData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>class to store texture data in. used to load, save and manipulate data before assigned to texture object all operations on a data object can be done from a background thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>type to define suitable file formats</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFileTypes">TglBitmapFileTypes</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>describes the properties of a given texture data format</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>callback to use for converting texture data</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapFunctionRec.html">TglBitmapFunctionRec</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>structure to store data for converting in</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>possible mipmap types</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapNormalMap.html">TglBitmapNormalMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapNormalMapFunc">TglBitmapNormalMapFunc</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>possible normal map functions</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>structure to store pixel data in</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned byte values</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned integer values</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>record that stores 4 unsigned long integer values</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.TglBitmapSize.html">TglBitmapSize</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapSizeFields">TglBitmapSizeFields</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Types</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Types</h1>
-<table class="itemstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemunit">Unit</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#PglBitmapPixelData">PglBitmapPixelData</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>type to define suitable file formats</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFileTypes">TglBitmapFileTypes</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>callback to use for converting texture data</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>possible mipmap types</p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapNormalMapFunc">TglBitmapNormalMapFunc</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>possible normal map functions</p></td>
-</tr>
-<tr class="list2">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html#TglBitmapSizeFields">TglBitmapSizeFields</a></td>
-<td class="itemunit"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p> </p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Units</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Units</h1>
-<table class="unitstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>glBitmap by Steffen Xonna aka Lossy eX (2003-2008) <a href="http://www.opengl24.de/index.php?cat=header&file=glbitmap">http://www.opengl24.de/index.php?cat=header&file=glbitmap</a>
-
-<p>modified by Delphi OpenGL Community (<a href="http://delphigl.com/">http://delphigl.com/</a>) (2013)
-
-<p>The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>
-
-<p>The glBitmap is a Delphi/FPC unit that contains several wrapper classes to manage OpenGL texture objects. Below you can find a list of the main functionality of this classes: - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) - upload texture data to video card - download texture data from video card - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)</p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Variables</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Variables</h1>
-<p>
-The units do not contain any variables.</p>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>Class Hierarchy</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">Class Hierarchy</h1>
-<ul class="hierarchylevel">
-<li>TObject<ul class="hierarchylevel">
-<li>Exception<ul class="hierarchylevel">
-<li><a class="bold" href="glBitmap.EglBitmap.html">EglBitmap</a><ul class="hierarchylevel">
-<li><a class="bold" href="glBitmap.EglBitmapNonPowerOfTwo.html">EglBitmapNonPowerOfTwo</a><li><a class="bold" href="glBitmap.EglBitmapSizeToLarge.html">EglBitmapSizeToLarge</a><li><a class="bold" href="glBitmap.EglBitmapUnsupportedFormat.html">EglBitmapUnsupportedFormat</a></ul>
-</li>
-<li><a class="bold" href="glBitmap.EglBitmapNotSupported.html">EglBitmapNotSupported</a></ul>
-</li>
-<li><a class="bold" href="glBitmap.TglBitmap.html">TglBitmap</a><ul class="hierarchylevel">
-<li><a class="bold" href="glBitmap.TglBitmap1D.html">TglBitmap1D</a><li><a class="bold" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a><ul class="hierarchylevel">
-<li><a class="bold" href="glBitmap.TglBitmapCubeMap.html">TglBitmapCubeMap</a><ul class="hierarchylevel">
-<li><a class="bold" href="glBitmap.TglBitmapNormalMap.html">TglBitmapNormalMap</a></ul>
-</li>
-</ul>
-</li>
-</ul>
-</li>
-<li><a class="bold" href="glBitmap.TglBitmapData.html">TglBitmapData</a><li><a class="bold" href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a></ul>
-</li>
-</ul>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-[Main]
-StoreRelativePaths=1
-Language=en
-OutputDir=..\doc
-GenerateFormat=0
-ProjectName=
-Verbosity=2
-ClassMembers_0=1
-ClassMembers_1=1
-ClassMembers_2=1
-ClassMembers_3=1
-ClassMembers_4=1
-ClassMembers_5=1
-ClassMembers_6=1
-ClassMembers_7=1
-ImplicitVisibility=0
-Sorting_0=0
-Sorting_1=0
-Sorting_2=0
-Sorting_3=0
-Sorting_4=0
-Sorting_5=0
-Sorting_6=0
-Sorting_7=0
-Sorting_8=0
-Sorting_9=0
-CssFileName=
-IntroductionFileName=
-ConclusionFileName=
-WriteUsesList=0
-AutoAbstract=0
-AutoLink=0
-HandleMacros=1
-UseTipueSearch=0
-LineBreakQuality=0
-SpecialMarkerTreatment=1
-Title=
-VizGraphClasses=0
-VizGraphUses=0
-CheckSpelling=0
-LatexGraphicsPackage=0
-
-[Defines]
-Count=4
-Item_0=FPC
-Item_1=MSWINDOWS
-Item_2=WIN32
-Item_3=CPU386
-
-[Header]
-Count=0
-
-[Footer]
-Count=0
-
-[IncludeDirectories]
-Count=2
-Item_0=..\..\glBitmap
-Item_1=..\..\TestProjekt
-
-[Files]
-Count=1
-Item_0=..\glBitmap.pas
-
-[HyphenatedWords]
-Count=0
-
-[SpecialMarkers]
-Count=0
-
-[IgnoreWords]
-Count=0
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class EglBitmap</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="EglBitmap"></a><h1 class="cio">Class EglBitmap</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type EglBitmap = class(Exception)</code></p>
-<h2 class="description">Description</h2>
-<p>
-glBitmap exception</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">Exception</li>
-<li class="thisitem">EglBitmap</li></ul><hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class EglBitmapNonPowerOfTwo</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="EglBitmapNonPowerOfTwo"></a><h1 class="cio">Class EglBitmapNonPowerOfTwo</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type EglBitmapNonPowerOfTwo = class(<a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-exception for non power of two textures</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">Exception</li>
-<li class="ancestor"><a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a></li>
-<li class="thisitem">EglBitmapNonPowerOfTwo</li></ul><hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class EglBitmapNotSupported</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="EglBitmapNotSupported"></a><h1 class="cio">Class EglBitmapNotSupported</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type EglBitmapNotSupported = class(Exception)</code></p>
-<h2 class="description">Description</h2>
-<p>
-exception for not supported functions</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">Exception</li>
-<li class="thisitem">EglBitmapNotSupported</li></ul><hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class EglBitmapSizeToLarge</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="EglBitmapSizeToLarge"></a><h1 class="cio">Class EglBitmapSizeToLarge</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type EglBitmapSizeToLarge = class(<a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-exception for to large textures</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">Exception</li>
-<li class="ancestor"><a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a></li>
-<li class="thisitem">EglBitmapSizeToLarge</li></ul><hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class EglBitmapUnsupportedFormat</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="EglBitmapUnsupportedFormat"></a><h1 class="cio">Class EglBitmapUnsupportedFormat</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type EglBitmapUnsupportedFormat = class(<a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-exception for unsupporetd formats</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">Exception</li>
-<li class="ancestor"><a class="normal" href="glBitmap.EglBitmap.html">EglBitmap</a></li>
-<li class="thisitem">EglBitmapUnsupportedFormat</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.EglBitmapUnsupportedFormat.html#Create">Create</a></b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>); overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.EglBitmapUnsupportedFormat.html#Create">Create</a></b>(const aMsg: String; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>); overload;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>); overload;</code></td>
-</tr>
-<tr><td colspan="2">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aMsg: String; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>); overload;</code></td>
-</tr>
-<tr><td colspan="2">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmap</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmap"></a><h1 class="cio">Class TglBitmap</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td><a class="section" href="#PasDoc-Properties">Properties</a></td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmap = class(TObject)</code></p>
-<h2 class="description">Description</h2>
-<p>
-base class for all glBitmap classes. used to manage OpenGL texture objects all operations on a bitmap object must be done from the render thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="thisitem">TglBitmap</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fID">fID</a></b>: GLuint;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fTarget">fTarget</a></b>: GLuint;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fDeleteTextureOnFree">fDeleteTextureOnFree</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fFilterMin">fFilterMin</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fFilterMag">fFilterMag</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fWrapS">fWrapS</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fWrapT">fWrapT</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fWrapR">fWrapR</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fAnisotropic">fAnisotropic</a></b>: Integer;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fBorderColor">fBorderColor</a></b>: array[0..3] of Single;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fSwizzle">fSwizzle</a></b>: array[0..3] of GLenum;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fDimension">fDimension</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fMipMap">fMipMap</a></b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fCustomData">fCustomData</a></b>: Pointer;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fCustomName">fCustomName</a></b>: String;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmap.html#fCustomNameW">fCustomNameW</a></b>: WideString;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmap.html#GetWidth">GetWidth</a></b>: Integer; virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmap.html#GetHeight">GetHeight</a></b>: Integer; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetCustomData">SetCustomData</a></b>(const aValue: Pointer);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetCustomName">SetCustomName</a></b>(const aValue: String);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetCustomNameW">SetCustomNameW</a></b>(const aValue: WideString);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetDeleteTextureOnFree">SetDeleteTextureOnFree</a></b>(const aValue: Boolean);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetID">SetID</a></b>(const aValue: Cardinal);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetMipMap">SetMipMap</a></b>(const aValue: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetTarget">SetTarget</a></b>(const aValue: Cardinal);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetAnisotropic">SetAnisotropic</a></b>(const aValue: Integer);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#CreateID">CreateID</a></b>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetupParameters">SetupParameters</a></b>();</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#AfterConstruction">AfterConstruction</a></b>; override;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#BeforeDestruction">BeforeDestruction</a></b>; override;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetFilter">SetFilter</a></b>(const aMin, aMag: GLenum);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetWrap">SetWrap</a></b>( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#SetSwizzle">SetSwizzle</a></b>(const r, g, b, a: GLenum);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#Bind">Bind</a></b>(const aEnableTextureUnit: Boolean = true); virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#Unbind">Unbind</a></b>(const aDisableTextureUnit: Boolean = true); virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap.html#UploadData">UploadData</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmap.html#Create">Create</a></b>; overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmap.html#Create">Create</a></b>(const aData: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>); overload;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Properties"></a><h3 class="summary">Properties</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#Width">Width</a></b>: Integer read <a href="glBitmap.TglBitmap.html#GetWidth">GetWidth</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#Height">Height</a></b>: Integer read <a href="glBitmap.TglBitmap.html#GetHeight">GetHeight</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#ID">ID</a></b>: Cardinal read <a href="glBitmap.TglBitmap.html#fID">fID</a> write <a href="glBitmap.TglBitmap.html#SetID">SetID</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#Target">Target</a></b>: Cardinal read <a href="glBitmap.TglBitmap.html#fTarget">fTarget</a> write <a href="glBitmap.TglBitmap.html#SetTarget">SetTarget</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#DeleteTextureOnFree">DeleteTextureOnFree</a></b>: Boolean read <a href="glBitmap.TglBitmap.html#fDeleteTextureOnFree">fDeleteTextureOnFree</a> write <a href="glBitmap.TglBitmap.html#SetDeleteTextureOnFree">SetDeleteTextureOnFree</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#MipMap">MipMap</a></b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a> read <a href="glBitmap.TglBitmap.html#fMipMap">fMipMap</a> write <a href="glBitmap.TglBitmap.html#SetMipMap">SetMipMap</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#Anisotropic">Anisotropic</a></b>: Integer read <a href="glBitmap.TglBitmap.html#fAnisotropic">fAnisotropic</a> write <a href="glBitmap.TglBitmap.html#SetAnisotropic">SetAnisotropic</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#CustomData">CustomData</a></b>: Pointer read <a href="glBitmap.TglBitmap.html#fCustomData">fCustomData</a> write <a href="glBitmap.TglBitmap.html#SetCustomData">SetCustomData</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#CustomName">CustomName</a></b>: String read <a href="glBitmap.TglBitmap.html#fCustomName">fCustomName</a> write <a href="glBitmap.TglBitmap.html#SetCustomName">SetCustomName</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#CustomNameW">CustomNameW</a></b>: WideString read <a href="glBitmap.TglBitmap.html#fCustomNameW">fCustomNameW</a> write <a href="glBitmap.TglBitmap.html#SetCustomNameW">SetCustomNameW</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap.html#Dimension">Dimension</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> read <a href="glBitmap.TglBitmap.html#fDimension">fDimension</a>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fID"></a><code><b>fID</b>: GLuint;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-name of the OpenGL texture object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fTarget"></a><code><b>fTarget</b>: GLuint;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture target (e.g. GL_TEXTURE_2D)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fDeleteTextureOnFree"></a><code><b>fDeleteTextureOnFree</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-delete OpenGL texture object when this object is destroyed</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fFilterMin"></a><code><b>fFilterMin</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-min filter to apply to the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fFilterMag"></a><code><b>fFilterMag</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-mag filter to apply to the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fWrapS"></a><code><b>fWrapS</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture wrapping for x axis</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fWrapT"></a><code><b>fWrapT</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture wrapping for y axis</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fWrapR"></a><code><b>fWrapR</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture wrapping for z axis</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fAnisotropic"></a><code><b>fAnisotropic</b>: Integer;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-anisotropic level</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fBorderColor"></a><code><b>fBorderColor</b>: array[0..3] of Single;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-color of the texture border</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fSwizzle"></a><code><b>fSwizzle</b>: array[0..3] of GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-color channel swizzle</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fDimension"></a><code><b>fDimension</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-size of this texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fMipMap"></a><code><b>fMipMap</b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-mipmap type</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fCustomData"></a><code><b>fCustomData</b>: Pointer;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined data</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fCustomName"></a><code><b>fCustomName</b>: String;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined name</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fCustomNameW"></a><code><b>fCustomNameW</b>: WideString;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined name</p>
-</td></tr>
-</table>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="GetWidth"></a><code>function <b>GetWidth</b>: Integer; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return">the actual width of the texture</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="GetHeight"></a><code>function <b>GetHeight</b>: Integer; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return">the actual height of the texture</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetCustomData"></a><code>procedure <b>SetCustomData</b>(const aValue: Pointer);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set a new value for fCustomData</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetCustomName"></a><code>procedure <b>SetCustomName</b>(const aValue: String);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set a new value for fCustomName</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetCustomNameW"></a><code>procedure <b>SetCustomNameW</b>(const aValue: WideString);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set a new value for fCustomNameW</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetDeleteTextureOnFree"></a><code>procedure <b>SetDeleteTextureOnFree</b>(const aValue: Boolean);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new value for fDeleteTextureOnFree</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetID"></a><code>procedure <b>SetID</b>(const aValue: Cardinal);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set name of OpenGL texture object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetMipMap"></a><code>procedure <b>SetMipMap</b>(const aValue: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new value for fMipMap</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetTarget"></a><code>procedure <b>SetTarget</b>(const aValue: Cardinal);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new value for target</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetAnisotropic"></a><code>procedure <b>SetAnisotropic</b>(const aValue: Integer);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new value for fAnisotrophic</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="CreateID"></a><code>procedure <b>CreateID</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-create OpenGL texture object (delete exisiting object if exists)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetupParameters"></a><code>procedure <b>SetupParameters</b>();</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-setup texture parameters</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AfterConstruction"></a><code>procedure <b>AfterConstruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called after the constructor and sets the default values of this object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="BeforeDestruction"></a><code>procedure <b>BeforeDestruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called before the destructor and does some cleanup</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SetFilter"></a><code>procedure <b>SetFilter</b>(const aMin, aMag: GLenum);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new texture filer </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aMin</dt>
-<dd>min filter</dd>
-<dt>aMag</dt>
-<dd>mag filter</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SetWrap"></a><code>procedure <b>SetWrap</b>( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new texture wrapping </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>S</dt>
-<dd>texture wrapping for x axis</dd>
-<dt>T</dt>
-<dd>texture wrapping for y axis</dd>
-<dt>R</dt>
-<dd>texture wrapping for z axis</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SetSwizzle"></a><code>procedure <b>SetSwizzle</b>(const r, g, b, a: GLenum);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new swizzle </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>r</dt>
-<dd>swizzle for red channel</dd>
-<dt>g</dt>
-<dd>swizzle for green channel</dd>
-<dt>b</dt>
-<dd>swizzle for blue channel</dd>
-<dt>a</dt>
-<dd>swizzle for alpha channel</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Bind"></a><code>procedure <b>Bind</b>(const aEnableTextureUnit: Boolean = true); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bind texture </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aEnableTextureUnit</dt>
-<dd>enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Unbind"></a><code>procedure <b>Unbind</b>(const aDisableTextureUnit: Boolean = true); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bind texture </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aDisableTextureUnit</dt>
-<dd>disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="UploadData"></a><code>procedure <b>UploadData</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload texture data from given data object to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>; overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates an empty texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aData: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates an texture object and uploads the given data</p>
-</td></tr>
-</table>
-<h3 class="detail">Properties</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="Width"></a><code>property <b>Width</b>: Integer read <a href="glBitmap.TglBitmap.html#GetWidth">GetWidth</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-the actual width of the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="Height"></a><code>property <b>Height</b>: Integer read <a href="glBitmap.TglBitmap.html#GetHeight">GetHeight</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-the actual height of the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="ID"></a><code>property <b>ID</b>: Cardinal read <a href="glBitmap.TglBitmap.html#fID">fID</a> write <a href="glBitmap.TglBitmap.html#SetID">SetID</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-name of the OpenGL texture object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Target"></a><code>property <b>Target</b>: Cardinal read <a href="glBitmap.TglBitmap.html#fTarget">fTarget</a> write <a href="glBitmap.TglBitmap.html#SetTarget">SetTarget</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture target (e.g. GL_TEXTURE_2D)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="DeleteTextureOnFree"></a><code>property <b>DeleteTextureOnFree</b>: Boolean read <a href="glBitmap.TglBitmap.html#fDeleteTextureOnFree">fDeleteTextureOnFree</a> write <a href="glBitmap.TglBitmap.html#SetDeleteTextureOnFree">SetDeleteTextureOnFree</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-delete texture object when this object is destroyed</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="MipMap"></a><code>property <b>MipMap</b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a> read <a href="glBitmap.TglBitmap.html#fMipMap">fMipMap</a> write <a href="glBitmap.TglBitmap.html#SetMipMap">SetMipMap</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-mipmap type</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Anisotropic"></a><code>property <b>Anisotropic</b>: Integer read <a href="glBitmap.TglBitmap.html#fAnisotropic">fAnisotropic</a> write <a href="glBitmap.TglBitmap.html#SetAnisotropic">SetAnisotropic</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-anisotropic level</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="CustomData"></a><code>property <b>CustomData</b>: Pointer read <a href="glBitmap.TglBitmap.html#fCustomData">fCustomData</a> write <a href="glBitmap.TglBitmap.html#SetCustomData">SetCustomData</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined data (use at will)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="CustomName"></a><code>property <b>CustomName</b>: String read <a href="glBitmap.TglBitmap.html#fCustomName">fCustomName</a> write <a href="glBitmap.TglBitmap.html#SetCustomName">SetCustomName</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined name (use at will)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="CustomNameW"></a><code>property <b>CustomNameW</b>: WideString read <a href="glBitmap.TglBitmap.html#fCustomNameW">fCustomNameW</a> write <a href="glBitmap.TglBitmap.html#SetCustomNameW">SetCustomNameW</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-user defined name (as WideString; use at will)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Dimension"></a><code>property <b>Dimension</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> read <a href="glBitmap.TglBitmap.html#fDimension">fDimension</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-size of the texture</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmap1D</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmap1D"></a><h1 class="cio">Class TglBitmap1D</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td><a class="section" href="#PasDoc-Properties">Properties</a></td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmap1D = class(<a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a></li>
-<li class="thisitem">TglBitmap1D</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap1D.html#UploadDataIntern">UploadDataIntern</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aBuildWithGlu: Boolean);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap1D.html#AfterConstruction">AfterConstruction</a></b>; override;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap1D.html#UploadData">UploadData</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Properties"></a><h3 class="summary">Properties</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap1D.html#Width">Width</a></b>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="UploadDataIntern"></a><code>procedure <b>UploadDataIntern</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aBuildWithGlu: Boolean);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload the texture data to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aDataObj</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aBuildWithGlu</dt>
-<dd>use glu functions to build mipmaps</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AfterConstruction"></a><code>procedure <b>AfterConstruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called after constructor and initializes the object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="UploadData"></a><code>procedure <b>UploadData</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload texture data from given data object to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<h3 class="detail">Properties</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Width"></a><code>property <b>Width</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-actual with of the texture</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmap2D</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmap2D"></a><h1 class="cio">Class TglBitmap2D</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td><a class="section" href="#PasDoc-Properties">Properties</a></td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmap2D = class(<a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a></li>
-<li class="thisitem">TglBitmap2D</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap2D.html#UploadDataIntern">UploadDataIntern</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aTarget: GLenum );</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap2D.html#AfterConstruction">AfterConstruction</a></b>; override;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap2D.html#GrabScreen">GrabScreen</a></b>(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmap2D.html#UploadData">UploadData</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Properties"></a><h3 class="summary">Properties</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap2D.html#Width">Width</a></b>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmap2D.html#Height">Height</a></b>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="UploadDataIntern"></a><code>procedure <b>UploadDataIntern</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aTarget: GLenum );</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload the texture data to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aDataObj</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aTarget</dt>
-<dd>target o upload data to (e.g. GL_TEXTURE_2D)</dd>
-<dt>aBuildWithGlu</dt>
-<dd>use glu functions to build mipmaps</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AfterConstruction"></a><code>procedure <b>AfterConstruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called after constructor and initializes the object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GrabScreen"></a><code>procedure <b>GrabScreen</b>(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-copy a part of the frame buffer to the texture </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aTop</dt>
-<dd>topmost pixel to copy</dd>
-<dt>aLeft</dt>
-<dd>leftmost pixel to copy</dd>
-<dt>aRight</dt>
-<dd>rightmost pixel to copy</dd>
-<dt>aBottom</dt>
-<dd>bottommost pixel to copy</dd>
-<dt>aFormat</dt>
-<dd>format to store data in</dd>
-<dt>aDataObj</dt>
-<dd>texture data object to store the data in</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="UploadData"></a><code>procedure <b>UploadData</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload texture data from given data object to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<h3 class="detail">Properties</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Width"></a><code>property <b>Width</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-actual width of the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Height"></a><code>property <b>Height</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-actual height of the texture</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmapCubeMap</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapCubeMap"></a><h1 class="cio">Class TglBitmapCubeMap</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapCubeMap = class(<a class="normal" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a></li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a></li>
-<li class="thisitem">TglBitmapCubeMap</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapCubeMap.html#AfterConstruction">AfterConstruction</a></b>; override;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapCubeMap.html#UploadData">UploadData</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapCubeMap.html#UploadCubeMap">UploadCubeMap</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCubeTarget: Cardinal; const aCheckSize: Boolean);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapCubeMap.html#Bind">Bind</a></b>( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapCubeMap.html#Unbind">Unbind</a></b>( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AfterConstruction"></a><code>procedure <b>AfterConstruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called after constructor and initializes the object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="UploadData"></a><code>procedure <b>UploadData</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCheckSize: Boolean = true); override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload texture data from given data object to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="UploadCubeMap"></a><code>procedure <b>UploadCubeMap</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aCubeTarget: Cardinal; const aCheckSize: Boolean);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-upload texture data from given data object to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>texture data object that contains the actual data</dd>
-<dt>aCubeTarget</dt>
-<dd>cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X)</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Bind"></a><code>procedure <b>Bind</b>( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bind texture </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aEnableTexCoordsGen</dt>
-<dd>enable cube map generator</dd>
-<dt>aEnableTextureUnit</dt>
-<dd>enable texture unit</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Unbind"></a><code>procedure <b>Unbind</b>( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-unbind texture </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aDisableTexCoordsGen</dt>
-<dd>disable cube map generator</dd>
-<dt>aDisableTextureUnit</dt>
-<dd>disable texture unit</dd>
-</dl>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmapData</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapData"></a><h1 class="cio">Class TglBitmapData</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td><a class="section" href="#PasDoc-Properties">Properties</a></td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapData = class(TObject)</code></p>
-<h2 class="description">Description</h2>
-<p>
-class to store texture data in. used to load, save and manipulate data before assigned to texture object all operations on a data object can be done from a background thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="thisitem">TglBitmapData</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fData">fData</a></b>: PByte;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fDimension">fDimension</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fFormat">fFormat</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fFilename">fFilename</a></b>: String;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fScanlines">fScanlines</a></b>: array of PByte;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapData.html#fHasScanlines">fHasScanlines</a></b>: Boolean;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#GetFormatDescriptor">GetFormatDescriptor</a></b>: <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#GetWidth">GetWidth</a></b>: Integer;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#GetHeight">GetHeight</a></b>: Integer;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#GetScanlines">GetScanlines</a></b>(const aIndex: Integer): PByte;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SetFormat">SetFormat</a></b>(const aValue: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#PrepareResType">PrepareResType</a></b>(var aResource: String; var aResType: PChar);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#UpdateScanlines">UpdateScanlines</a></b>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadPNG">LoadPNG</a></b>(const aStream: TStream): Boolean; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SavePNG">SavePNG</a></b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadJPEG">LoadJPEG</a></b>(const aStream: TStream): Boolean; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveJPEG">SaveJPEG</a></b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadRAW">LoadRAW</a></b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveRAW">SaveRAW</a></b>(const aStream: TStream);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadBMP">LoadBMP</a></b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveBMP">SaveBMP</a></b>(const aStream: TStream);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadTGA">LoadTGA</a></b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveTGA">SaveTGA</a></b>(const aStream: TStream);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#LoadDDS">LoadDDS</a></b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveDDS">SaveDDS</a></b>(const aStream: TStream);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#FlipHorz">FlipHorz</a></b>: Boolean; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#FlipVert">FlipVert</a></b>: Boolean; virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#LoadFromFile">LoadFromFile</a></b>(const aFilename: String);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#LoadFromStream">LoadFromStream</a></b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#LoadFromFunc">LoadFromFunc</a></b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aArgs: Pointer = nil);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#LoadFromResource">LoadFromResource</a></b>(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#LoadFromResourceID">LoadFromResourceID</a></b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveToFile">SaveToFile</a></b>(const aFilename: String; const aFileType: <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SaveToStream">SaveToStream</a></b>(const aStream: TStream; const aFileType: <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>); virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#Convert">Convert</a></b>(const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#Convert">Convert</a></b>(const aSource: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; aCreateTemp: Boolean; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aArgs: Pointer = nil): Boolean; overload;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#ConvertTo">ConvertTo</a></b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>): Boolean; virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AssignToLazIntfImage">AssignToLazIntfImage</a></b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AssignFromLazIntfImage">AssignFromLazIntfImage</a></b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AssignAlphaToLazIntfImage">AssignAlphaToLazIntfImage</a></b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromLazIntfImage">AddAlphaFromLazIntfImage</a></b>(const aImage: TLazIntfImage; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromResource">AddAlphaFromResource</a></b>(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromResourceID">AddAlphaFromResourceID</a></b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromFunc">AddAlphaFromFunc</a></b>(const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer = nil): Boolean; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromFile">AddAlphaFromFile</a></b>(const aFileName: String; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromStream">AddAlphaFromStream</a></b>(const aStream: TStream; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromDataObj">AddAlphaFromDataObj</a></b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromColorKey">AddAlphaFromColorKey</a></b>(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromColorKeyRange">AddAlphaFromColorKeyRange</a></b>(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromColorKeyFloat">AddAlphaFromColorKeyFloat</a></b>(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromValue">AddAlphaFromValue</a></b>(const aAlpha: Byte): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromValueRange">AddAlphaFromValueRange</a></b>(const aAlpha: Cardinal): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#AddAlphaFromValueFloat">AddAlphaFromValueFloat</a></b>(const aAlpha: Single): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#RemoveAlpha">RemoveAlpha</a></b>: Boolean; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#FillWithColor">FillWithColor</a></b>(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#FillWithColorRange">FillWithColorRange</a></b>(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#FillWithColorFloat">FillWithColorFloat</a></b>(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#SetData">SetData</a></b>(const aData: PByte; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapData.html#Clone">Clone</a></b>: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#Invert">Invert</a></b>(const aRed, aGreen, aBlue, aAlpha: Boolean);</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapData.html#GenerateNormalMap">GenerateNormalMap</a></b>(const aFunc: <a href="glBitmap.html#TglBitmapNormalMapFunc">TglBitmapNormalMapFunc</a> = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>; overload;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aFileName: String); overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aStream: TStream); overload;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; aData: PByte = nil); overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer = nil); overload;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapData.html#Create">Create</a></b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>destructor <b><a href="glBitmap.TglBitmapData.html#Destroy">Destroy</a></b>; override;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Properties"></a><h3 class="summary">Properties</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Data">Data</a></b>: PByte read <a href="glBitmap.TglBitmapData.html#fData">fData</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Dimension">Dimension</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> read <a href="glBitmap.TglBitmapData.html#fDimension">fDimension</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Filename">Filename</a></b>: String read <a href="glBitmap.TglBitmapData.html#fFilename">fFilename</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Width">Width</a></b>: Integer read <a href="glBitmap.TglBitmapData.html#GetWidth">GetWidth</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Height">Height</a></b>: Integer read <a href="glBitmap.TglBitmapData.html#GetHeight">GetHeight</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Format">Format</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapData.html#fFormat">fFormat</a> write <a href="glBitmap.TglBitmapData.html#SetFormat">SetFormat</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#Scanlines">Scanlines</a></b>[constaIndex:Integer]: PByte read <a href="glBitmap.TglBitmapData.html#GetScanlines">GetScanlines</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapData.html#FormatDescriptor">FormatDescriptor</a></b>: <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a> read <a href="glBitmap.TglBitmapData.html#GetFormatDescriptor">GetFormatDescriptor</a>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fData"></a><code><b>fData</b>: PByte;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture data</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fDimension"></a><code><b>fDimension</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-pixel size of the data</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fFormat"></a><code><b>fFormat</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-format the texture data is stored in</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fFilename"></a><code><b>fFilename</b>: String;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-file the data was load from</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fScanlines"></a><code><b>fScanlines</b>: array of PByte;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-pointer to begin of each line</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fHasScanlines"></a><code><b>fHasScanlines</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if scanlines are initialized, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetFormatDescriptor"></a><code>function <b>GetFormatDescriptor</b>: <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a>;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return">the format descriptor suitable to the texture data format</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetWidth"></a><code>function <b>GetWidth</b>: Integer;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return">the width of the texture data (in pixel) or -1 if no data is set</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHeight"></a><code>function <b>GetHeight</b>: Integer;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return">the height of the texture data (in pixel) or -1 if no data is set</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetScanlines"></a><code>function <b>GetScanlines</b>(const aIndex: Integer): PByte;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-get scanline at index aIndex </p>
-<h6 class="description_section">Returns</h6>
-<p class="return">Pointer to start of line or <code>Nil</code></p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SetFormat"></a><code>procedure <b>SetFormat</b>(const aValue: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set new value for the data format. only possible if new format has the same pixel size. if you want to convert the texture data, see ConvertTo function</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="PrepareResType"></a><code>procedure <b>PrepareResType</b>(var aResource: String; var aResType: PChar);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-splits a resource identifier into the resource and it's type </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aResource</dt>
-<dd>resource identifier to split and store name in</dd>
-<dt>aResType</dt>
-<dd>type of the resource</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="UpdateScanlines"></a><code>procedure <b>UpdateScanlines</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-updates scanlines array</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadPNG"></a><code>function <b>LoadPNG</b>(const aStream: TStream): Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a PNG from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load PNG from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SavePNG"></a><code>procedure <b>SavePNG</b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as PNG to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadJPEG"></a><code>function <b>LoadJPEG</b>(const aStream: TStream): Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a JPEG from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load JPEG from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SaveJPEG"></a><code>procedure <b>SaveJPEG</b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as JPEG to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadRAW"></a><code>function <b>LoadRAW</b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a RAW image from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load RAW image from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SaveRAW"></a><code>procedure <b>SaveRAW</b>(const aStream: TStream);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as RAW image to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadBMP"></a><code>function <b>LoadBMP</b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a BMP from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load BMP from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SaveBMP"></a><code>procedure <b>SaveBMP</b>(const aStream: TStream);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as BMP to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadTGA"></a><code>function <b>LoadTGA</b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a TGA from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load TGA from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SaveTGA"></a><code>procedure <b>SaveTGA</b>(const aStream: TStream);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as TGA to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="LoadDDS"></a><code>function <b>LoadDDS</b>(const aStream: TStream): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-try to load a DDS from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load DDS from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="SaveDDS"></a><code>procedure <b>SaveDDS</b>(const aStream: TStream);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data as DDS to stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to save data to</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FlipHorz"></a><code>function <b>FlipHorz</b>: Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-flip texture horizontal </p>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> in success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FlipVert"></a><code>function <b>FlipVert</b>: Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-flip texture vertical </p>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> in success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="LoadFromFile"></a><code>procedure <b>LoadFromFile</b>(const aFilename: String);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load a texture from a file </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFilename</dt>
-<dd>file to load texuture from</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="LoadFromStream"></a><code>procedure <b>LoadFromStream</b>(const aStream: TStream); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load a texture from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load texture from</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="LoadFromFunc"></a><code>procedure <b>LoadFromFunc</b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aArgs: Pointer = nil);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-use a function to generate texture data </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aSize</dt>
-<dd>size of the texture</dd>
-<dt>aFunc</dt>
-<dd>callback to use for generation</dd>
-<dt>aFormat</dt>
-<dd>format of the texture data</dd>
-<dt>aArgs</dt>
-<dd>user defined paramaters (use at will)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="LoadFromResource"></a><code>procedure <b>LoadFromResource</b>(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load a texture from a resource </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResource</dt>
-<dd>resource indentifier</dd>
-<dt>aResType</dt>
-<dd>resource type (if known)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="LoadFromResourceID"></a><code>procedure <b>LoadFromResourceID</b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load a texture from a resource id </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResource</dt>
-<dd>resource ID</dd>
-<dt>aResType</dt>
-<dd>resource type</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SaveToFile"></a><code>procedure <b>SaveToFile</b>(const aFilename: String; const aFileType: <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data to a file </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFilename</dt>
-<dd>filename to store texture in</dd>
-<dt>aFileType</dt>
-<dd>file type to store data into</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SaveToStream"></a><code>procedure <b>SaveToStream</b>(const aStream: TStream; const aFileType: <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-save texture data to a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFilename</dt>
-<dd>filename to store texture in</dd>
-<dt>aFileType</dt>
-<dd>file type to store data into</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Convert"></a><code>function <b>Convert</b>(const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-convert texture data using a user defined callback </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aCreateTemp</dt>
-<dd>create a temporary buffer to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined paramters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if converting was successful, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Convert"></a><code>function <b>Convert</b>(const aSource: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; aCreateTemp: Boolean; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aArgs: Pointer = nil): Boolean; overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-convert texture data using a user defined callback </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aSource</dt>
-<dd>glBitmap to read data from</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aCreateTemp</dt>
-<dd>create a temporary buffer to use for converting</dd>
-<dt>aFormat</dt>
-<dd>format of the new data</dd>
-<dt>aArgs</dt>
-<dd>user defined paramters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if converting was successful, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="ConvertTo"></a><code>function <b>ConvertTo</b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>): Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-convert texture data using a specific format </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFormat</dt>
-<dd>new format of texture data</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if converting was successful, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AssignToLazIntfImage"></a><code>function <b>AssignToLazIntfImage</b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-assign texture data to TLazIntfImage object </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aImage</dt>
-<dd>TLazIntfImage to write data to</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AssignFromLazIntfImage"></a><code>function <b>AssignFromLazIntfImage</b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-assign texture data from TLazIntfImage object </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aImage</dt>
-<dd>TLazIntfImage to read data from</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AssignAlphaToLazIntfImage"></a><code>function <b>AssignAlphaToLazIntfImage</b>(const aImage: TLazIntfImage): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-assign alpha channel data to TLazIntfImage object </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aImage</dt>
-<dd>TLazIntfImage to write data to</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromLazIntfImage"></a><code>function <b>AddAlphaFromLazIntfImage</b>(const aImage: TLazIntfImage; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-assign alpha channel data from TLazIntfImage object </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aImage</dt>
-<dd>TLazIntfImage to read data from</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromResource"></a><code>function <b>AddAlphaFromResource</b>(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load alpha channel data from resource </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResource</dt>
-<dd>resource ID</dd>
-<dt>aResType</dt>
-<dd>resource type</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromResourceID"></a><code>function <b>AddAlphaFromResourceID</b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-load alpha channel data from resource ID </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResourceID</dt>
-<dd>resource ID</dd>
-<dt>aResType</dt>
-<dd>resource type</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromFunc"></a><code>function <b>AddAlphaFromFunc</b>(const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer = nil): Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha channel data from function </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFunc</dt>
-<dd>callback to get data from</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromFile"></a><code>function <b>AddAlphaFromFile</b>(const aFileName: String; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap) </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFilename</dt>
-<dd>file to load alpha channel data from</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>SetFormat user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromStream"></a><code>function <b>AddAlphaFromStream</b>(const aStream: TStream; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a> = nil; const aArgs: Pointer = nil): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap) </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load alpha channel data from</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromDataObj"></a><code>function <b>AddAlphaFromDataObj</b>(const aDataObj: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>; aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha channel data from existing glBitmap object </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aBitmap</dt>
-<dd>TglBitmap to copy alpha channel data from</dd>
-<dt>aFunc</dt>
-<dd>callback to use for converting</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromColorKey"></a><code>function <b>AddAlphaFromColorKey</b>(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha to pixel if the pixels color is greter than the given color value </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red threshold (0-255)</dd>
-<dt>aGreen</dt>
-<dd>green threshold (0-255)</dd>
-<dt>aBlue</dt>
-<dd>blue threshold (0-255)</dd>
-<dt>aDeviatation</dt>
-<dd>accepted deviatation (0-255)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromColorKeyRange"></a><code>function <b>AddAlphaFromColorKeyRange</b>(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha to pixel if the pixels color is greter than the given color value </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red threshold (0-Range.r)</dd>
-<dt>aGreen</dt>
-<dd>green threshold (0-Range.g)</dd>
-<dt>aBlue</dt>
-<dd>blue threshold (0-Range.b)</dd>
-<dt>aDeviatation</dt>
-<dd>accepted deviatation (0-max(Range.rgb))</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromColorKeyFloat"></a><code>function <b>AddAlphaFromColorKeyFloat</b>(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add alpha to pixel if the pixels color is greter than the given color value </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red threshold (0.0-1.0)</dd>
-<dt>aGreen</dt>
-<dd>green threshold (0.0-1.0)</dd>
-<dt>aBlue</dt>
-<dd>blue threshold (0.0-1.0)</dd>
-<dt>aDeviatation</dt>
-<dd>accepted deviatation (0.0-1.0)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromValue"></a><code>function <b>AddAlphaFromValue</b>(const aAlpha: Byte): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add a constand alpha value to all pixels </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aAlpha</dt>
-<dd>alpha value to add (0-255)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromValueRange"></a><code>function <b>AddAlphaFromValueRange</b>(const aAlpha: Cardinal): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add a constand alpha value to all pixels </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aAlpha</dt>
-<dd>alpha value to add (0-max(Range.rgb))</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AddAlphaFromValueFloat"></a><code>function <b>AddAlphaFromValueFloat</b>(const aAlpha: Single): Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-add a constand alpha value to all pixels </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aAlpha</dt>
-<dd>alpha value to add (0.0-1.0)</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="RemoveAlpha"></a><code>function <b>RemoveAlpha</b>: Boolean; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-remove alpha channel </p>
-<h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> on success, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FillWithColor"></a><code>procedure <b>FillWithColor</b>(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-fill complete texture with one color </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red color for border (0-255)</dd>
-<dt>aGreen</dt>
-<dd>green color for border (0-255)</dd>
-<dt>aBlue</dt>
-<dd>blue color for border (0-255)</dd>
-<dt>aAlpha</dt>
-<dd>alpha color for border (0-255)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FillWithColorRange"></a><code>procedure <b>FillWithColorRange</b>(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-fill complete texture with one color </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red color for border (0-Range.r)</dd>
-<dt>aGreen</dt>
-<dd>green color for border (0-Range.g)</dd>
-<dt>aBlue</dt>
-<dd>blue color for border (0-Range.b)</dd>
-<dt>aAlpha</dt>
-<dd>alpha color for border (0-Range.a)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FillWithColorFloat"></a><code>procedure <b>FillWithColorFloat</b>(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-fill complete texture with one color </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>red color for border (0.0-1.0)</dd>
-<dt>aGreen</dt>
-<dd>green color for border (0.0-1.0)</dd>
-<dt>aBlue</dt>
-<dd>blue color for border (0.0-1.0)</dd>
-<dt>aAlpha</dt>
-<dd>alpha color for border (0.0-1.0)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="SetData"></a><code>procedure <b>SetData</b>(const aData: PByte; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set data pointer of texture data </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aData</dt>
-<dd>pointer to new texture data</dd>
-<dt>aFormat</dt>
-<dd>format of the data stored at aData</dd>
-<dt>aWidth</dt>
-<dd>width of the texture data</dd>
-<dt>aHeight</dt>
-<dd>height of the texture data</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Clone"></a><code>function <b>Clone</b>: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-create a clone of the current object </p>
-<h6 class="description_section">Returns</h6>
-<p class="return">clone of this object</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Invert"></a><code>procedure <b>Invert</b>(const aRed, aGreen, aBlue, aAlpha: Boolean);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-invert color data (bitwise not) </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aRed</dt>
-<dd>invert red channel</dd>
-<dt>aGreen</dt>
-<dd>invert green channel</dd>
-<dt>aBlue</dt>
-<dd>invert blue channel</dd>
-<dt>aAlpha</dt>
-<dd>invert alpha channel</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GenerateNormalMap"></a><code>procedure <b>GenerateNormalMap</b>(const aFunc: <a href="glBitmap.html#TglBitmapNormalMapFunc">TglBitmapNormalMapFunc</a> = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-create normal map from texture data </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFunc</dt>
-<dd>normal map function to generate normalmap with</dd>
-<dt>aScale</dt>
-<dd>scale of the normale stored in the normal map</dd>
-<dt>aUseAlpha</dt>
-<dd>generate normalmap from alpha channel data (if present)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>; overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texutre data object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aFileName: String); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object and loads it from a file </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aFilename</dt>
-<dd>file to load texture from</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aStream: TStream); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object and loads it from a stream </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aStream</dt>
-<dd>stream to load texture from</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; aData: PByte = nil); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object with the given size, format and data </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aSize</dt>
-<dd>size of the texture</dd>
-<dt>aFormat</dt>
-<dd>format of the given data</dd>
-<dt>aData</dt>
-<dd>texture data - be carefull: the data will now be managed by the texture data object</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>; const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>; const aFunc: <a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a>; const aArgs: Pointer = nil); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object with the given size and format and uses the given callback to create the data </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aSize</dt>
-<dd>size of the texture</dd>
-<dt>aFormat</dt>
-<dd>format of the given data</dd>
-<dt>aFunc</dt>
-<dd>callback to use for generating the data</dd>
-<dt>aArgs</dt>
-<dd>user defined parameters (use at will)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object and loads it from a resource </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResource</dt>
-<dd>resource indentifier</dd>
-<dt>aResType</dt>
-<dd>resource type (if known)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor - creates a texture data object and loads it from a resource </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInstance</dt>
-<dd>resource handle</dd>
-<dt>aResourceID</dt>
-<dd>resource ID</dd>
-<dt>aResType</dt>
-<dd>resource type (if known)</dd>
-</dl>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Destroy"></a><code>destructor <b>Destroy</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-destructor</p>
-</td></tr>
-</table>
-<h3 class="detail">Properties</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Data"></a><code>property <b>Data</b>: PByte read <a href="glBitmap.TglBitmapData.html#fData">fData</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-texture data (be carefull with this!)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Dimension"></a><code>property <b>Dimension</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> read <a href="glBitmap.TglBitmapData.html#fDimension">fDimension</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-size of the texture data (in pixel)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Filename"></a><code>property <b>Filename</b>: String read <a href="glBitmap.TglBitmapData.html#fFilename">fFilename</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-file the data was loaded from</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Width"></a><code>property <b>Width</b>: Integer read <a href="glBitmap.TglBitmapData.html#GetWidth">GetWidth</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-width of the texture data (in pixel)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Height"></a><code>property <b>Height</b>: Integer read <a href="glBitmap.TglBitmapData.html#GetHeight">GetHeight</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-height of the texture data (in pixel)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Format"></a><code>property <b>Format</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapData.html#fFormat">fFormat</a> write <a href="glBitmap.TglBitmapData.html#SetFormat">SetFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-format the texture data is stored in</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Scanlines"></a><code>property <b>Scanlines</b>[constaIndex:Integer]: PByte read <a href="glBitmap.TglBitmapData.html#GetScanlines">GetScanlines</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-pointer to begin of line at given index or <code>Nil</code></p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="FormatDescriptor"></a><code>property <b>FormatDescriptor</b>: <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a> read <a href="glBitmap.TglBitmapData.html#GetFormatDescriptor">GetFormatDescriptor</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-descriptor object that describes the format of the stored data</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmapFormatDescriptor</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapFormatDescriptor"></a><h1 class="cio">Class TglBitmapFormatDescriptor</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td><a class="section" href="#PasDoc-Properties">Properties</a></td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapFormatDescriptor = class(TObject)</code></p>
-<h2 class="description">Description</h2>
-<p>
-describes the properties of a given texture data format</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="thisitem">TglBitmapFormatDescriptor</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fBytesPerPixel">fBytesPerPixel</a></b>: Single;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fChannelCount">fChannelCount</a></b>: Integer;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fMask">fMask</a></b>: <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fRange">fRange</a></b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fFormat">fFormat</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fWithAlpha">fWithAlpha</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fWithoutAlpha">fWithoutAlpha</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fOpenGLFormat">fOpenGLFormat</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fRGBInverted">fRGBInverted</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fUncompressed">fUncompressed</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fBitsPerPixel">fBitsPerPixel</a></b>: Integer;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fIsCompressed">fIsCompressed</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fPrecision">fPrecision</a></b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fShift">fShift</a></b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fglFormat">fglFormat</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fglInternalFormat">fglInternalFormat</a></b>: GLenum;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFormatDescriptor.html#fglDataFormat">fglDataFormat</a></b>: GLenum;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasRed">GetHasRed</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasGreen">GetHasGreen</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasBlue">GetHasBlue</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasAlpha">GetHasAlpha</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasColor">GetHasColor</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetIsGrayscale">GetIsGrayscale</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapFormatDescriptor.html#SetValues">SetValues</a></b>; virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapFormatDescriptor.html#CalcValues">CalcValues</a></b>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetSize">GetSize</a></b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>): Integer; overload; virtual;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetSize">GetSize</a></b>(const aWidth, aHeight: Integer): Integer; overload; virtual;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>constructor <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Create">Create</a></b>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>class function <b><a href="glBitmap.TglBitmapFormatDescriptor.html#GetByFormat">GetByFormat</a></b>(const aInternalFormat: GLenum): <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a>;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Properties"></a><h3 class="summary">Properties</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Format">Format</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fFormat">fFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#ChannelCount">ChannelCount</a></b>: Integer read <a href="glBitmap.TglBitmapFormatDescriptor.html#fChannelCount">fChannelCount</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#IsCompressed">IsCompressed</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#fIsCompressed">fIsCompressed</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#BitsPerPixel">BitsPerPixel</a></b>: Integer read <a href="glBitmap.TglBitmapFormatDescriptor.html#fBitsPerPixel">fBitsPerPixel</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#BytesPerPixel">BytesPerPixel</a></b>: Single read <a href="glBitmap.TglBitmapFormatDescriptor.html#fBytesPerPixel">fBytesPerPixel</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Precision">Precision</a></b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fPrecision">fPrecision</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Shift">Shift</a></b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fShift">fShift</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Range">Range</a></b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fRange">fRange</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Mask">Mask</a></b>: <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fMask">fMask</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#RGBInverted">RGBInverted</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fRGBInverted">fRGBInverted</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#WithAlpha">WithAlpha</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fWithAlpha">fWithAlpha</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#WithoutAlpha">WithoutAlpha</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fWithAlpha">fWithAlpha</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#OpenGLFormat">OpenGLFormat</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fOpenGLFormat">fOpenGLFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#Uncompressed">Uncompressed</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fUncompressed">fUncompressed</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#glFormat">glFormat</a></b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglFormat">fglFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#glInternalFormat">glInternalFormat</a></b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglInternalFormat">fglInternalFormat</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#glDataFormat">glDataFormat</a></b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglDataFormat">fglDataFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#HasRed">HasRed</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasRed">GetHasRed</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#HasGreen">HasGreen</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasGreen">GetHasGreen</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#HasBlue">HasBlue</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasBlue">GetHasBlue</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#HasAlpha">HasAlpha</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasAlpha">GetHasAlpha</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#HasColor">HasColor</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasColor">GetHasColor</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>property <b><a href="glBitmap.TglBitmapFormatDescriptor.html#IsGrayscale">IsGrayscale</a></b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetIsGrayscale">GetIsGrayscale</a>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fBytesPerPixel"></a><code><b>fBytesPerPixel</b>: Single;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bytes for each pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fChannelCount"></a><code><b>fChannelCount</b>: Integer;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of color channels</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fMask"></a><code><b>fMask</b>: <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bitmask for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="fRange"></a><code><b>fRange</b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-maximal value of each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fFormat"></a><code><b>fFormat</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-format this descriptor belongs to</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fWithAlpha"></a><code><b>fWithAlpha</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with alpha channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fWithoutAlpha"></a><code><b>fWithoutAlpha</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format without alpha channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fOpenGLFormat"></a><code><b>fOpenGLFormat</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format that is supported by OpenGL</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fRGBInverted"></a><code><b>fRGBInverted</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with inverted RGB channels</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fUncompressed"></a><code><b>fUncompressed</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with uncompressed data</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fBitsPerPixel"></a><code><b>fBitsPerPixel</b>: Integer;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bits per pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fIsCompressed"></a><code><b>fIsCompressed</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format is compressed, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fPrecision"></a><code><b>fPrecision</b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bits for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fShift"></a><code><b>fShift</b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bit offset for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fglFormat"></a><code><b>fglFormat</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL format enum (e.g. GL_RGB)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fglInternalFormat"></a><code><b>fglInternalFormat</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL internal format enum (e.g. GL_RGB8)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="fglDataFormat"></a><code><b>fglDataFormat</b>: GLenum;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)</p>
-</td></tr>
-</table>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHasRed"></a><code>function <b>GetHasRed</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format has a red color channel, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHasGreen"></a><code>function <b>GetHasGreen</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format has a green color channel, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHasBlue"></a><code>function <b>GetHasBlue</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format has a blue color channel, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHasAlpha"></a><code>function <b>GetHasAlpha</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format has a alpha color channel, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetHasColor"></a><code>function <b>GetHasColor</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format has any color color channel, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="private.gif" alt="Private" title="Private"></a></td>
-<td class="itemcode"><a name="GetIsGrayscale"></a><code>function <b>GetIsGrayscale</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="2">
- <h6 class="description_section">Returns</h6>
-<p class="return"><code>True</code> if the format is a grayscale format, <code>False</code> otherwise</p></td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="SetValues"></a><code>procedure <b>SetValues</b>; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-set values for this format descriptor</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="protected.gif" alt="Protected" title="Protected"></a></td>
-<td class="itemcode"><a name="CalcValues"></a><code>procedure <b>CalcValues</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-calculate cached values</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GetSize"></a><code>function <b>GetSize</b>(const aSize: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>): Integer; overload; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GetSize"></a><code>function <b>GetSize</b>(const aWidth, aHeight: Integer): Integer; overload; virtual;</code></td>
-</tr>
-<tr><td colspan="2">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Create"></a><code>constructor <b>Create</b>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-constructor</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GetByFormat"></a><code>class function <b>GetByFormat</b>(const aInternalFormat: GLenum): <a href="glBitmap.TglBitmapFormatDescriptor.html">TglBitmapFormatDescriptor</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-get the format descriptor by a given OpenGL internal format </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aInternalFormat</dt>
-<dd>OpenGL internal format to get format descriptor for</dd>
-</dl>
-<h6 class="description_section">Returns</h6>
-<p class="return">suitable format descriptor or tfEmpty-Descriptor</p></td></tr>
-</table>
-<h3 class="detail">Properties</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Format"></a><code>property <b>Format</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fFormat">fFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-format this descriptor belongs to</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="ChannelCount"></a><code>property <b>ChannelCount</b>: Integer read <a href="glBitmap.TglBitmapFormatDescriptor.html#fChannelCount">fChannelCount</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of color channels</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="IsCompressed"></a><code>property <b>IsCompressed</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#fIsCompressed">fIsCompressed</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format is compressed, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="BitsPerPixel"></a><code>property <b>BitsPerPixel</b>: Integer read <a href="glBitmap.TglBitmapFormatDescriptor.html#fBitsPerPixel">fBitsPerPixel</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bytes per pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="BytesPerPixel"></a><code>property <b>BytesPerPixel</b>: Single read <a href="glBitmap.TglBitmapFormatDescriptor.html#fBytesPerPixel">fBytesPerPixel</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bits per pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Precision"></a><code>property <b>Precision</b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fPrecision">fPrecision</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-number of bits for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Shift"></a><code>property <b>Shift</b>: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fShift">fShift</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bit offset for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Range"></a><code>property <b>Range</b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fRange">fRange</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-maximal value of each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Mask"></a><code>property <b>Mask</b>: <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fMask">fMask</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-bitmask for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="RGBInverted"></a><code>property <b>RGBInverted</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fRGBInverted">fRGBInverted</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with inverted RGB channels</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="WithAlpha"></a><code>property <b>WithAlpha</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fWithAlpha">fWithAlpha</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with alpha channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="WithoutAlpha"></a><code>property <b>WithoutAlpha</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fWithAlpha">fWithAlpha</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format without alpha channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="OpenGLFormat"></a><code>property <b>OpenGLFormat</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fOpenGLFormat">fOpenGLFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format that is supported by OpenGL</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="Uncompressed"></a><code>property <b>Uncompressed</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a> read <a href="glBitmap.TglBitmapFormatDescriptor.html#fUncompressed">fUncompressed</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-suitable format with uncompressed data</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="glFormat"></a><code>property <b>glFormat</b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglFormat">fglFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL format enum (e.g. GL_RGB)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="glInternalFormat"></a><code>property <b>glInternalFormat</b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglInternalFormat">fglInternalFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL internal format enum (e.g. GL_RGB8)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="glDataFormat"></a><code>property <b>glDataFormat</b>: GLenum read <a href="glBitmap.TglBitmapFormatDescriptor.html#fglDataFormat">fglDataFormat</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="HasRed"></a><code>property <b>HasRed</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasRed">GetHasRed</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format has a red color channel, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="HasGreen"></a><code>property <b>HasGreen</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasGreen">GetHasGreen</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format has a green color channel, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="HasBlue"></a><code>property <b>HasBlue</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasBlue">GetHasBlue</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format has a blue color channel, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="HasAlpha"></a><code>property <b>HasAlpha</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasAlpha">GetHasAlpha</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format has a alpha color channel, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="HasColor"></a><code>property <b>HasColor</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetHasColor">GetHasColor</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format has any color color channel, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="IsGrayscale"></a><code>property <b>IsGrayscale</b>: Boolean read <a href="glBitmap.TglBitmapFormatDescriptor.html#GetIsGrayscale">GetIsGrayscale</a>;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-<code>True</code> if the format is a grayscale format, <code>False</code> otherwise</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: record TglBitmapFunctionRec</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapFunctionRec"></a><h1 class="cio">record TglBitmapFunctionRec</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapFunctionRec = record</code></p>
-<h2 class="description">Description</h2>
-<p>
-structure to store data for converting in</p>
-<h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Sender">Sender</a></b>: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Size">Size</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Position">Position</a></b>: <a href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Source">Source</a></b>: <a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Dest">Dest</a></b>: <a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapFunctionRec.html#Args">Args</a></b>: Pointer;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Sender"></a><code><b>Sender</b>: <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-texture object that stores the data to convert</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Size"></a><code><b>Size</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-size of the texture</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Position"></a><code><b>Position</b>: <a href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-position of the currently pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Source"></a><code><b>Source</b>: <a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-pixel data of the current pixel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Dest"></a><code><b>Dest</b>: <a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-new data of the pixel (must be filled in)</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Args"></a><code><b>Args</b>: Pointer;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-user defined args that was passed to the convert function</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: Class TglBitmapNormalMap</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapNormalMap"></a><h1 class="cio">Class TglBitmapNormalMap</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td><a class="section" href="#PasDoc-Hierarchy">Hierarchy</a></td><td>Fields</td><td><a class="section" href="#PasDoc-Methods">Methods</a></td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapNormalMap = class(<a class="normal" href="glBitmap.TglBitmapCubeMap.html">TglBitmapCubeMap</a>)</code></p>
-<h2 class="description">Description</h2>
-<p>
-wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread</p>
-<a name="PasDoc-Hierarchy"></a><h2 class="hierarchy">Hierarchy</h2>
-<ul class="hierarchy"><li class="ancestor">TObject</li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap.html">TglBitmap</a></li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmap2D.html">TglBitmap2D</a></li>
-<li class="ancestor"><a class="normal" href="glBitmap.TglBitmapCubeMap.html">TglBitmapCubeMap</a></li>
-<li class="thisitem">TglBitmapNormalMap</li></ul><h2 class="overview">Overview</h2>
-<a name="PasDoc-Methods"></a><h3 class="summary">Methods</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapNormalMap.html#AfterConstruction">AfterConstruction</a></b>; override;</code></td>
-</tr>
-<tr class="list2">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><code>procedure <b><a href="glBitmap.TglBitmapNormalMap.html#GenerateNormalMap">GenerateNormalMap</a></b>(const aSize: Integer = 32; const aCheckSize: Boolean = true);</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Methods</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="AfterConstruction"></a><code>procedure <b>AfterConstruction</b>; override;</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-this method is called after constructor and initializes the object</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="visibility"><a href="legend.html"><img src="public.gif" alt="Public" title="Public"></a></td>
-<td class="itemcode"><a name="GenerateNormalMap"></a><code>procedure <b>GenerateNormalMap</b>(const aSize: Integer = 32; const aCheckSize: Boolean = true);</code></td>
-</tr>
-<tr><td colspan="2">
-<p>
-create cube normal map from texture data and upload it to video card </p>
-<h6 class="description_section">Parameters</h6>
-<dl class="parameters">
-<dt>aSize</dt>
-<dd>size of each cube map texture</dd>
-<dt>aCheckSize</dt>
-<dd>check size before upload and throw exception if something is wrong</dd>
-</dl>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: packed record TglBitmapPixelData</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapPixelData"></a><h1 class="cio">packed record TglBitmapPixelData</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapPixelData = packed record</code></p>
-<h2 class="description">Description</h2>
-<p>
-structure to store pixel data in</p>
-<h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapPixelData.html#Data">Data</a></b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapPixelData.html#Range">Range</a></b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapPixelData.html#Format">Format</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Data"></a><code><b>Data</b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-color data for each color channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Range"></a><code><b>Range</b>: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-maximal color value for each channel</p>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Format"></a><code><b>Format</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-format of the pixel</p>
-</td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: packed record TglBitmapRec4ub</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapRec4ub"></a><h1 class="cio">packed record TglBitmapRec4ub</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapRec4ub = packed record</code></p>
-<h2 class="description">Description</h2>
-<p>
-record that stores 4 unsigned byte values</p>
-<h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ub.html#r">r</a></b>: Byte</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ub.html#g">g</a></b>: Byte</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ub.html#b">b</a></b>: Byte</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ub.html#a">a</a></b>: Byte</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ub.html#arr">arr</a></b>: array[0..3] of Byte</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="r"></a><code><b>r</b>: Byte</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="g"></a><code><b>g</b>: Byte</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="b"></a><code><b>b</b>: Byte</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="a"></a><code><b>a</b>: Byte</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="arr"></a><code><b>arr</b>: array[0..3] of Byte</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: packed record TglBitmapRec4ui</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapRec4ui"></a><h1 class="cio">packed record TglBitmapRec4ui</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapRec4ui = packed record</code></p>
-<h2 class="description">Description</h2>
-<p>
-record that stores 4 unsigned integer values</p>
-<h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ui.html#r">r</a></b>: Cardinal</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ui.html#g">g</a></b>: Cardinal</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ui.html#b">b</a></b>: Cardinal</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ui.html#a">a</a></b>: Cardinal</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ui.html#arr">arr</a></b>: array[0..3] of Cardinal</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="r"></a><code><b>r</b>: Cardinal</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="g"></a><code><b>g</b>: Cardinal</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="b"></a><code><b>b</b>: Cardinal</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="a"></a><code><b>a</b>: Cardinal</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="arr"></a><code><b>arr</b>: array[0..3] of Cardinal</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: packed record TglBitmapRec4ul</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapRec4ul"></a><h1 class="cio">packed record TglBitmapRec4ul</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapRec4ul = packed record</code></p>
-<h2 class="description">Description</h2>
-<p>
-record that stores 4 unsigned long integer values</p>
-<h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ul.html#r">r</a></b>: QWord</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ul.html#g">g</a></b>: QWord</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ul.html#b">b</a></b>: QWord</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ul.html#a">a</a></b>: QWord</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapRec4ul.html#arr">arr</a></b>: array[0..3] of QWord</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="r"></a><code><b>r</b>: QWord</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="g"></a><code><b>g</b>: QWord</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="b"></a><code><b>b</b>: QWord</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="a"></a><code><b>a</b>: QWord</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="arr"></a><code><b>arr</b>: array[0..3] of QWord</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap: packed record TglBitmapSize</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<a name="TglBitmapSize"></a><h1 class="cio">packed record TglBitmapSize</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Hierarchy</td><td><a class="section" href="#PasDoc-Fields">Fields</a></td><td>Methods</td><td>Properties</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="unit">Unit</h2>
-<p class="unitlink">
-<a href="glBitmap.html">glBitmap</a></p>
-<h2 class="declaration">Declaration</h2>
-<p class="declaration">
-<code>type TglBitmapSize = packed record</code></p>
-<h2 class="description">Description</h2>
- <h2 class="overview">Overview</h2>
-<a name="PasDoc-Fields"></a><h3 class="summary">Fields</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapSize.html#Fields">Fields</a></b>: <a href="glBitmap.html#TglBitmapSizeFields">TglBitmapSizeFields</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapSize.html#X">X</a></b>: Word;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.TglBitmapSize.html#Y">Y</a></b>: Word;</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Fields</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Fields"></a><code><b>Fields</b>: <a href="glBitmap.html#TglBitmapSizeFields">TglBitmapSizeFields</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="X"></a><code><b>X</b>: Word;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="Y"></a><code><b>Y</b>: Word;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>glBitmap</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="unit">Unit glBitmap</h1>
-<table class="sections wide_list">
-<tr>
-<td><a class="section" href="#PasDoc-Description">Description</a></td><td>Uses</td><td><a class="section" href="#PasDoc-Classes">Classes, Interfaces, Objects and Records</a></td><td><a class="section" href="#PasDoc-FuncsProcs">Functions and Procedures</a></td><td><a class="section" href="#PasDoc-Types">Types</a></td><td><a class="section" href="#PasDoc-Constants">Constants</a></td><td>Variables</td></tr></table>
-<a name="PasDoc-Description"></a><h2 class="description">Description</h2>
-<p>
-glBitmap by Steffen Xonna aka Lossy eX (2003-2008) <a href="http://www.opengl24.de/index.php?cat=header&file=glbitmap">http://www.opengl24.de/index.php?cat=header&file=glbitmap</a>
-
-<p>modified by Delphi OpenGL Community (<a href="http://delphigl.com/">http://delphigl.com/</a>) (2013)
-
-<p>The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>
-
-<p>The glBitmap is a Delphi/FPC unit that contains several wrapper classes to manage OpenGL texture objects. Below you can find a list of the main functionality of this classes: - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) - upload texture data to video card - download texture data from video card - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)</p>
-<a name="PasDoc-Uses"></a><h2 class="overview">Overview</h2>
-<a name="PasDoc-Classes"></a><h3 class="cio">Classes, Interfaces, Objects and Records</h3>
-<table class="classestable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.EglBitmap.html"><code>EglBitmap</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">Class <a class="bold" href="glBitmap.EglBitmapNotSupported.html"><code>EglBitmapNotSupported</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.EglBitmapSizeToLarge.html"><code>EglBitmapSizeToLarge</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">Class <a class="bold" href="glBitmap.EglBitmapNonPowerOfTwo.html"><code>EglBitmapNonPowerOfTwo</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.EglBitmapUnsupportedFormat.html"><code>EglBitmapUnsupportedFormat</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">packed record <a class="bold" href="glBitmap.TglBitmapRec4ui.html"><code>TglBitmapRec4ui</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">packed record <a class="bold" href="glBitmap.TglBitmapRec4ub.html"><code>TglBitmapRec4ub</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">packed record <a class="bold" href="glBitmap.TglBitmapRec4ul.html"><code>TglBitmapRec4ul</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">packed record <a class="bold" href="glBitmap.TglBitmapPixelData.html"><code>TglBitmapPixelData</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">packed record <a class="bold" href="glBitmap.TglBitmapSize.html"><code>TglBitmapSize</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmapFormatDescriptor.html"><code>TglBitmapFormatDescriptor</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">record <a class="bold" href="glBitmap.TglBitmapFunctionRec.html"><code>TglBitmapFunctionRec</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmapData.html"><code>TglBitmapData</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmap.html"><code>TglBitmap</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmap1D.html"><code>TglBitmap1D</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmap2D.html"><code>TglBitmap2D</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmapCubeMap.html"><code>TglBitmapCubeMap</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-<tr class="list2">
-<td class="itemname">Class <a class="bold" href="glBitmap.TglBitmapNormalMap.html"><code>TglBitmapNormalMap</code></a></td>
-<td class="itemdesc"> </td>
-</tr>
-</table>
-<a name="PasDoc-FuncsProcs"></a><h3 class="summary">Functions and Procedures</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultDeleteTextureOnFree">glBitmapSetDefaultDeleteTextureOnFree</a></b>(const aDeleteTextureOnFree: Boolean);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultFreeDataAfterGenTexture">glBitmapSetDefaultFreeDataAfterGenTexture</a></b>(const aFreeData: Boolean);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultMipmap">glBitmapSetDefaultMipmap</a></b>(const aValue: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultFormat">glBitmapSetDefaultFormat</a></b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultFilter">glBitmapSetDefaultFilter</a></b>(const aMin, aMag: Integer);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultWrap">glBitmapSetDefaultWrap</a></b>( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapSetDefaultSwizzle">glBitmapSetDefaultSwizzle</a></b>(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapGetDefaultDeleteTextureOnFree">glBitmapGetDefaultDeleteTextureOnFree</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapGetDefaultFreeDataAfterGenTexture">glBitmapGetDefaultFreeDataAfterGenTexture</a></b>: Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapGetDefaultMipmap">glBitmapGetDefaultMipmap</a></b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapGetDefaultFormat">glBitmapGetDefaultFormat</a></b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapGetDefaultFilter">glBitmapGetDefaultFilter</a></b>(var aMin, aMag: Cardinal);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapGetDefaultTextureWrap">glBitmapGetDefaultTextureWrap</a></b>(var S, T, R: Cardinal);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>procedure <b><a href="glBitmap.html#glBitmapGetDefaultSwizzle">glBitmapGetDefaultSwizzle</a></b>(var r, g, b, a: GLenum);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapSize">glBitmapSize</a></b>(X: Integer = -1; Y: Integer = -1): <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapPosition">glBitmapPosition</a></b>(X: Integer = -1; Y: Integer = -1): <a href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapRec4ub">glBitmapRec4ub</a></b>(const r, g, b, a: Byte): <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapRec4ui">glBitmapRec4ui</a></b>(const r, g, b, a: Cardinal): <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapRec4ul">glBitmapRec4ul</a></b>(const r, g, b, a: QWord): <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapRec4ubCompare">glBitmapRec4ubCompare</a></b>(const r1, r2: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>): Boolean;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapRec4uiCompare">glBitmapRec4uiCompare</a></b>(const r1, r2: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>): Boolean;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code>function <b><a href="glBitmap.html#glBitmapCreateTestData">glBitmapCreateTestData</a></b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>): <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-</table>
-<a name="PasDoc-Types"></a><h3 class="summary">Types</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a></b> = (...);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a></b> = (...);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapFileTypes">TglBitmapFileTypes</a></b> = set of <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>;</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a></b> = (...);</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapNormalMapFunc">TglBitmapNormalMapFunc</a></b> = (...);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.html#PglBitmapPixelData">PglBitmapPixelData</a></b> = ˆ<a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapSizeFields">TglBitmapSizeFields</a></b> = set of (ffX, ffY);</code></td>
-</tr>
-<tr class="list2">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a></b> = <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#TglBitmapFunction">TglBitmapFunction</a></b> = procedure(var FuncRec: <a href="glBitmap.TglBitmapFunctionRec.html">TglBitmapFunctionRec</a>);</code></td>
-</tr>
-</table>
-<a name="PasDoc-Constants"></a><h3 class="summary">Constants</h3>
-<table class="summary wide_list">
-<tr class="list">
-<td class="itemcode"><code><b><a href="glBitmap.html#NULL_SIZE">NULL_SIZE</a></b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> = (Fields: []; X: 0; Y: 0);</code></td>
-</tr>
-</table>
-<h2 class="description">Description</h2>
-<h3 class="detail">Functions and Procedures</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultDeleteTextureOnFree"></a><code>procedure <b>glBitmapSetDefaultDeleteTextureOnFree</b>(const aDeleteTextureOnFree: Boolean);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultFreeDataAfterGenTexture"></a><code>procedure <b>glBitmapSetDefaultFreeDataAfterGenTexture</b>(const aFreeData: Boolean);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultMipmap"></a><code>procedure <b>glBitmapSetDefaultMipmap</b>(const aValue: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultFormat"></a><code>procedure <b>glBitmapSetDefaultFormat</b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultFilter"></a><code>procedure <b>glBitmapSetDefaultFilter</b>(const aMin, aMag: Integer);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultWrap"></a><code>procedure <b>glBitmapSetDefaultWrap</b>( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSetDefaultSwizzle"></a><code>procedure <b>glBitmapSetDefaultSwizzle</b>(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultDeleteTextureOnFree"></a><code>function <b>glBitmapGetDefaultDeleteTextureOnFree</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultFreeDataAfterGenTexture"></a><code>function <b>glBitmapGetDefaultFreeDataAfterGenTexture</b>: Boolean;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultMipmap"></a><code>function <b>glBitmapGetDefaultMipmap</b>: <a href="glBitmap.html#TglBitmapMipMap">TglBitmapMipMap</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultFormat"></a><code>function <b>glBitmapGetDefaultFormat</b>: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultFilter"></a><code>procedure <b>glBitmapGetDefaultFilter</b>(var aMin, aMag: Cardinal);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultTextureWrap"></a><code>procedure <b>glBitmapGetDefaultTextureWrap</b>(var S, T, R: Cardinal);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapGetDefaultSwizzle"></a><code>procedure <b>glBitmapGetDefaultSwizzle</b>(var r, g, b, a: GLenum);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapSize"></a><code>function <b>glBitmapSize</b>(X: Integer = -1; Y: Integer = -1): <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapPosition"></a><code>function <b>glBitmapPosition</b>(X: Integer = -1; Y: Integer = -1): <a href="glBitmap.html#TglBitmapPixelPosition">TglBitmapPixelPosition</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapRec4ub"></a><code>function <b>glBitmapRec4ub</b>(const r, g, b, a: Byte): <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapRec4ui"></a><code>function <b>glBitmapRec4ui</b>(const r, g, b, a: Cardinal): <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapRec4ul"></a><code>function <b>glBitmapRec4ul</b>(const r, g, b, a: QWord): <a href="glBitmap.TglBitmapRec4ul.html">TglBitmapRec4ul</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapRec4ubCompare"></a><code>function <b>glBitmapRec4ubCompare</b>(const r1, r2: <a href="glBitmap.TglBitmapRec4ub.html">TglBitmapRec4ub</a>): Boolean;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapRec4uiCompare"></a><code>function <b>glBitmapRec4uiCompare</b>(const r1, r2: <a href="glBitmap.TglBitmapRec4ui.html">TglBitmapRec4ui</a>): Boolean;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="glBitmapCreateTestData"></a><code>function <b>glBitmapCreateTestData</b>(const aFormat: <a href="glBitmap.html#TglBitmapFormat">TglBitmapFormat</a>): <a href="glBitmap.TglBitmapData.html">TglBitmapData</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<h3 class="detail">Types</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapFormat"></a><code><b>TglBitmapFormat</b> = (...);</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-type that describes the format of the data stored in a texture. the name of formats is composed of the following constituents: - multiple channels: - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved)) - width of the chanel in bit (4, 8, 16, ...) - data type (e.g. ub, us, ui) - number of elements of data types</p>
-<h6 class="description_section">Values</h6>
-<ul>
-<li>
-tfEmpty = 0: </li>
-<li>
-tfAlpha4ub1: 1 x unsigned byte</li>
-<li>
-tfAlpha8ub1: 1 x unsigned byte</li>
-<li>
-tfAlpha16us1: 1 x unsigned short</li>
-<li>
-tfLuminance4ub1: 1 x unsigned byte</li>
-<li>
-tfLuminance8ub1: 1 x unsigned byte</li>
-<li>
-tfLuminance16us1: 1 x unsigned short</li>
-<li>
-tfLuminance4Alpha4ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)</li>
-<li>
-tfLuminance6Alpha2ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)</li>
-<li>
-tfLuminance8Alpha8ub2: 1 x unsigned byte (lum), 1 x unsigned byte (alpha)</li>
-<li>
-tfLuminance12Alpha4us2: 1 x unsigned short (lum), 1 x unsigned short (alpha)</li>
-<li>
-tfLuminance16Alpha16us2: 1 x unsigned short (lum), 1 x unsigned short (alpha)</li>
-<li>
-tfR3G3B2ub1: 1 x unsigned byte (3bit red, 3bit green, 2bit blue)</li>
-<li>
-tfRGBX4us1: 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd)</li>
-<li>
-tfXRGB4us1: 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue)</li>
-<li>
-tfR5G6B5us1: 1 x unsigned short (5bit red, 6bit green, 5bit blue)</li>
-<li>
-tfRGB5X1us1: 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved)</li>
-<li>
-tfX1RGB5us1: 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue)</li>
-<li>
-tfRGB8ub3: 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue)</li>
-<li>
-tfRGBX8ui1: 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved)</li>
-<li>
-tfXRGB8ui1: 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue)</li>
-<li>
-tfRGB10X2ui1: 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved)</li>
-<li>
-tfX2RGB10ui1: 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue)</li>
-<li>
-tfRGB16us3: 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue)</li>
-<li>
-tfRGBA4us1: 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha)</li>
-<li>
-tfARGB4us1: 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue)</li>
-<li>
-tfRGB5A1us1: 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha)</li>
-<li>
-tfA1RGB5us1: 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue)</li>
-<li>
-tfRGBA8ui1: 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha)</li>
-<li>
-tfARGB8ui1: 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue)</li>
-<li>
-tfRGBA8ub4: 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha)</li>
-<li>
-tfRGB10A2ui1: 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha)</li>
-<li>
-tfA2RGB10ui1: 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue)</li>
-<li>
-tfRGBA16us4: 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha)</li>
-<li>
-tfBGRX4us1: 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved)</li>
-<li>
-tfXBGR4us1: 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red)</li>
-<li>
-tfB5G6R5us1: 1 x unsigned short (5bit blue, 6bit green, 5bit red)</li>
-<li>
-tfBGR5X1us1: 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved)</li>
-<li>
-tfX1BGR5us1: 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red)</li>
-<li>
-tfBGR8ub3: 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red)</li>
-<li>
-tfBGRX8ui1: 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved)</li>
-<li>
-tfXBGR8ui1: 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red)</li>
-<li>
-tfBGR10X2ui1: 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved)</li>
-<li>
-tfX2BGR10ui1: 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red)</li>
-<li>
-tfBGR16us3: 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red)</li>
-<li>
-tfBGRA4us1: 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha)</li>
-<li>
-tfABGR4us1: 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red)</li>
-<li>
-tfBGR5A1us1: 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha)</li>
-<li>
-tfA1BGR5us1: 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red)</li>
-<li>
-tfBGRA8ui1: 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha)</li>
-<li>
-tfABGR8ui1: 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red)</li>
-<li>
-tfBGRA8ub4: 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha)</li>
-<li>
-tfBGR10A2ui1: 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha)</li>
-<li>
-tfA2BGR10ui1: 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red)</li>
-<li>
-tfBGRA16us4: 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha)</li>
-<li>
-tfDepth16us1: 1 x unsigned short (depth)</li>
-<li>
-tfDepth24ui1: 1 x unsigned int (depth)</li>
-<li>
-tfDepth32ui1: 1 x unsigned int (depth)</li>
-<li>
-tfS3tcDtx1RGBA: </li>
-<li>
-tfS3tcDtx3RGBA: </li>
-<li>
-tfS3tcDtx5RGBA: </li>
-</ul>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapFileType"></a><code><b>TglBitmapFileType</b> = (...);</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-type to define suitable file formats</p>
-<h6 class="description_section">Values</h6>
-<ul>
-<li>
-ftPNG: Portable Network Graphic file (PNG)</li>
-<li>
-ftJPEG: JPEG file</li>
-<li>
-ftDDS: Direct Draw Surface file (DDS)</li>
-<li>
-ftTGA: Targa Image File (TGA)</li>
-<li>
-ftBMP: Windows Bitmap File (BMP)</li>
-<li>
-ftRAW: glBitmap RAW file format</li>
-</ul>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapFileTypes"></a><code><b>TglBitmapFileTypes</b> = set of <a href="glBitmap.html#TglBitmapFileType">TglBitmapFileType</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapMipMap"></a><code><b>TglBitmapMipMap</b> = (...);</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-possible mipmap types</p>
-<h6 class="description_section">Values</h6>
-<ul>
-<li>
-mmNone: no mipmaps</li>
-<li>
-mmMipmap: normal mipmaps</li>
-<li>
-mmMipmapGlu: mipmaps generated with glu functions</li>
-</ul>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapNormalMapFunc"></a><code><b>TglBitmapNormalMapFunc</b> = (...);</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-possible normal map functions</p>
-<h6 class="description_section">Values</h6>
-<ul>
-<li>
-nm4Samples: </li>
-<li>
-nmSobel: </li>
-<li>
-nm3x3: </li>
-<li>
-nm5x5: </li>
-</ul>
-</td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="PglBitmapPixelData"></a><code><b>PglBitmapPixelData</b> = ˆ<a href="glBitmap.TglBitmapPixelData.html">TglBitmapPixelData</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapSizeFields"></a><code><b>TglBitmapSizeFields</b> = set of (ffX, ffY);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapPixelPosition"></a><code><b>TglBitmapPixelPosition</b> = <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a>;</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="TglBitmapFunction"></a><code><b>TglBitmapFunction</b> = procedure(var FuncRec: <a href="glBitmap.TglBitmapFunctionRec.html">TglBitmapFunctionRec</a>);</code></td>
-</tr>
-<tr><td colspan="1">
-<p>
-callback to use for converting texture data</p>
-</td></tr>
-</table>
-<h3 class="detail">Constants</h3>
-<table class="detail wide_list">
-<tr class="list">
-<td class="itemcode"><a name="NULL_SIZE"></a><code><b>NULL_SIZE</b>: <a href="glBitmap.TglBitmapSize.html">TglBitmapSize</a> = (Fields: []; X: 0; Y: 0);</code></td>
-</tr>
-<tr><td colspan="1">
- </td></tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>All Units</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="allitems">All Units</h1>
-<table class="unitstable wide_list">
-<tr class="listheader">
-<th class="itemname">Name</th>
-<th class="itemdesc">Description</th>
-</tr>
-<tr class="list">
-<td class="itemname"><a class="bold" href="glBitmap.html">glBitmap</a></td>
-<td class="itemdesc"><p>glBitmap by Steffen Xonna aka Lossy eX (2003-2008) <a href="http://www.opengl24.de/index.php?cat=header&file=glbitmap">http://www.opengl24.de/index.php?cat=header&file=glbitmap</a>
-
-<p>modified by Delphi OpenGL Community (<a href="http://delphigl.com/">http://delphigl.com/</a>) (2013)
-
-<p>The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>
-
-<p>The glBitmap is a Delphi/FPC unit that contains several wrapper classes to manage OpenGL texture objects. Below you can find a list of the main functionality of this classes: - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) - upload texture data to video card - download texture data from video card - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)</p></td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>Legend</title>
-<meta name="generator" content="PasDoc 0.13.0">
-<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
-<link rel="StyleSheet" type="text/css" href="pasdoc.css">
-</head>
-<body>
-<table class="container"><tr><td class="navigation">
-<p><a href="AllUnits.html" class="navigation">Units</a></p><p><a href="ClassHierarchy.html" class="navigation">Class Hierarchy</a></p><p><a href="AllClasses.html" class="navigation">Classes, Interfaces, Objects and Records</a></p><p><a href="AllTypes.html" class="navigation">Types</a></p><p><a href="AllVariables.html" class="navigation">Variables</a></p><p><a href="AllConstants.html" class="navigation">Constants</a></p><p><a href="AllFunctions.html" class="navigation">Functions and Procedures</a></p><p><a href="AllIdentifiers.html" class="navigation">Identifiers</a></p></td><td class="content">
-<h1 class="markerlegend">Legend</h1>
-<table class="markerlegend wide_list">
-<tr class="listheader">
-<th class="itemname">Marker</th>
-<th class="itemdesc">Visibility</th>
-</tr>
-<tr class="list">
-<td class="legendmarker"><img src="private.gif" alt="Strict Private" title="Strict Private"></td>
-<td class="legenddesc">Strict Private</td>
-</tr>
-<tr class="list2">
-<td class="legendmarker"><img src="private.gif" alt="Private" title="Private"></td>
-<td class="legenddesc">Private</td>
-</tr>
-<tr class="list">
-<td class="legendmarker"><img src="protected.gif" alt="Strict Protected" title="Strict Protected"></td>
-<td class="legenddesc">Strict Protected</td>
-</tr>
-<tr class="list2">
-<td class="legendmarker"><img src="protected.gif" alt="Protected" title="Protected"></td>
-<td class="legenddesc">Protected</td>
-</tr>
-<tr class="list">
-<td class="legendmarker"><img src="public.gif" alt="Public" title="Public"></td>
-<td class="legenddesc">Public</td>
-</tr>
-<tr class="list2">
-<td class="legendmarker"><img src="published.gif" alt="Published" title="Published"></td>
-<td class="legenddesc">Published</td>
-</tr>
-<tr class="list">
-<td class="legendmarker"><img src="automated.gif" alt="Automated" title="Automated"></td>
-<td class="legenddesc">Automated</td>
-</tr>
-<tr class="list2">
-<td class="legendmarker"><img src="published.gif" alt="Implicit" title="Implicit"></td>
-<td class="legenddesc">Implicit</td>
-</tr>
-</table>
-<hr noshade size="1"><span class="appinfo"><em>Generated by <a href="http://pasdoc.sourceforge.net/">PasDoc 0.13.0</a> on 2014-12-24 04:27:09</em>
-</span>
-</td></tr></table></body></html>
+++ /dev/null
-body, html, table.container {
- margin: 0;
- padding: 0;
-}
-
-body {
- font-family: Verdana,Arial;
- color: black;
- background-color: white;
- font-size: 12px;
-}
-
-table.container {
- width: 100%;
- border-spacing: 0;
-}
-table.container td {
- vertical-align: top;
-}
-
-td.navigation {
- width: 200px;
- color: white;
- background-color: #787878;
- margin: 0;
- /* padding-bottom is a little larger, to make navigation column have some
- nice height even when td.content column is very small. */
- padding: 1em 1em 100px 1em;
-}
-td.navigation p { padding: 0; }
-td.navigation h2 { margin-top: 0; }
-
-td.content { padding: 1em; }
-td.content h1 { margin-top: 0; }
-
-img { border:0px; }
-
-a:link {color:#C91E0C; text-decoration: none; }
-a:visited {color:#7E5C31; text-decoration: none; }
-a:hover {text-decoration: underline; }
-a:active {text-decoration: underline; }
-
-a.navigation:link { color: white; text-decoration: none; }
-a.navigation:visited { color: white; text-decoration: none; }
-a.navigation:hover { color: white; font-weight: bold; text-decoration: none; }
-a.navigation:active { color: white; text-decoration: none; }
-
-a.bold:link {color:#C91E0C; text-decoration: none; font-weight:bold; }
-a.bold:visited {color:#7E5C31; text-decoration: none; font-weight:bold; }
-a.bold:hover {text-decoration: underline; font-weight:bold; }
-a.bold:active {text-decoration: underline; font-weight:bold; }
-
-a.section {color: green; text-decoration: none; font-weight: bold; }
-a.section:hover {color: green; text-decoration: underline; font-weight: bold; }
-
-ul.useslist a:link {color:#C91E0C; text-decoration: none; font-weight:bold; }
-ul.useslist a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; }
-ul.useslist a:hover {text-decoration: underline; font-weight:bold; }
-ul.useslist a:active {text-decoration: underline; font-weight:bold; }
-
-ul.hierarchy { list-style-type:none; }
-ul.hierarchylevel { list-style-type:none; }
-
-p.unitlink a:link {color:#C91E0C; text-decoration: none; font-weight:bold; }
-p.unitlink a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; }
-p.unitlink a:hover {text-decoration: underline; font-weight:bold; }
-p.unitlink a:active {text-decoration: underline; font-weight:bold; }
-
-tr.list { background: #FFBF44; }
-tr.list2 { background: #FFC982; }
-tr.listheader { background: #C91E0C; color: white; }
-
-table.wide_list { border-spacing:2px; width:100%; }
-table.wide_list td { vertical-align:top; padding:4px; }
-
-table.markerlegend { width:auto; }
-table.markerlegend td.legendmarker { text-align:center; }
-
-table.sections { background:white; }
-table.sections td {background:lightgray; }
-
-table.summary td.itemcode { width:100%; }
-table.detail td.itemcode { width:100%; }
-
-td.itemname {white-space:nowrap; }
-td.itemunit {white-space:nowrap; }
-td.itemdesc { width:100%; }
-
-div.nodescription { color:red; }
-dl.parameters dt { color:blue; }
-
-/* Various browsers have various default styles for <h6>,
- sometimes ugly for our purposes, so it's best to set things
- like font-size and font-weight in out pasdoc.css explicitly. */
-h6.description_section {
- /* font-size 100% means that it has the same font size as the
- parent element, i.e. normal description text */
- font-size: 100%;
- font-weight: bold;
- /* By default browsers usually have some large margin-bottom and
- margin-top for <h1-6> tags. In our case, margin-bottom is
- unnecessary, we want to visually show that description_section
- is closely related to content below. In this situation
- (where the font size is just as a normal text), smaller bottom
- margin seems to look good. */
- margin-bottom: 0em;
-}
-
-/* Style applied to Pascal code in documentation
- (e.g. produced by @longcode tag) } */
-span.pascal_string { color: #000080; }
-span.pascal_keyword { font-weight: bolder; }
-span.pascal_comment { color: #000080; font-style: italic; }
-span.pascal_compiler_comment { color: #008000; }
-span.pascal_numeric { }
-span.pascal_hex { }
-
-p.hint_directive { color: red; }
-
-input#search_text { }
-input#search_submit_button { }
-
-acronym.mispelling { background-color: #ffa; }
-
-/* Actually this reduces vertical space between *every* paragraph
- inside list with @itemSpacing(compact).
- While we would like to reduce this space only for the
- top of 1st and bottom of last paragraph within each list item.
- But, well, user probably will not do any paragraph breaks
- within a list with @itemSpacing(compact) anyway, so it's
- acceptable solution. */
-ul.compact_spacing p { margin-top: 0em; margin-bottom: 0em; }
-ol.compact_spacing p { margin-top: 0em; margin-bottom: 0em; }
-dl.compact_spacing p { margin-top: 0em; margin-bottom: 0em; }
-
-/* Style for table created by @table tags:
- just some thin border.
-
- This way we have some borders around the cells
- (so cells are visibly separated), but the border
- "blends with the background" so it doesn't look too ugly.
- Hopefully it looks satisfactory in most cases and for most
- people.
-
- We add padding for cells, otherwise they look too close.
- This is normal thing to do when border-collapse is set to
- collapse (because this eliminates spacing between cells).
-*/
-table.table_tag { border-collapse: collapse; }
-table.table_tag td { border: 1pt solid gray; padding: 0.3em; }
-table.table_tag th { border: 1pt solid gray; padding: 0.3em; }
-
-table.detail {
- border: 1pt solid gray;
- margin-top: 0.3em;
- margin-bottom: 0.3em;
-}
-
-.search-form { white-space: nowrap; }
-.search-input, .search-button { display: inline-block; vertical-align: middle; }
-
-/* Do not make extra vertical space at the beginning/end of table cells.
- We need ">" selector, to not change paragraphs inside lists inside
- table cells. */
-table.table_tag td > p:first-child,
-table.table_tag th > p:first-child,
- td.itemdesc > p:first-child { margin-top: 0em; }
-
-table.table_tag td > p:last-child,
-table.table_tag th > p:last-child,
- td.itemdesc > p:last-child { margin-bottom: 0em; }
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectOptions>
- <Version Value="9"/>
- <PathDelim Value="\"/>
- <General>
- <Flags>
- <MainUnitHasCreateFormStatements Value="False"/>
- <MainUnitHasTitleStatement Value="False"/>
- </Flags>
- <SessionStorage Value="InProjectDir"/>
- <MainUnit Value="0"/>
- <Title Value="GrabScreen"/>
- <UseAppBundle Value="False"/>
- <ResourceType Value="res"/>
- </General>
- <i18n>
- <EnableI18N LFM="False"/>
- </i18n>
- <VersionInfo>
- <StringTable ProductVersion=""/>
- </VersionInfo>
- <BuildModes Count="1">
- <Item1 Name="Default" Default="True"/>
- </BuildModes>
- <PublishOptions>
- <Version Value="2"/>
- </PublishOptions>
- <RunParams>
- <local>
- <FormatVersion Value="1"/>
- </local>
- </RunParams>
- <Units Count="4">
- <Unit0>
- <Filename Value="GrabScreen.lpr"/>
- <IsPartOfProject Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="Helper"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- </Unit3>
- </Units>
- </ProjectOptions>
- <CompilerOptions>
- <Version Value="11"/>
- <PathDelim Value="\"/>
- <Target>
- <Filename Value="GrabScreen"/>
- </Target>
- <SearchPaths>
- <IncludeFiles Value="$(ProjOutDir);.."/>
- <OtherUnitFiles Value="..;..\.."/>
- <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
- </SearchPaths>
- </CompilerOptions>
- <Debugging>
- <Exceptions Count="3">
- <Item1>
- <Name Value="EAbort"/>
- </Item1>
- <Item2>
- <Name Value="ECodetoolError"/>
- </Item2>
- <Item3>
- <Name Value="EFOpenError"/>
- </Item3>
- </Exceptions>
- </Debugging>
-</CONFIG>
+++ /dev/null
-program SimpleLoadFromFile;
-
-{$mode objfpc}{$H+}
-
-uses
- {$IFDEF UNIX}{$IFDEF UseCThreads}
- cthreads,
- {$ENDIF}{$ENDIF}
- Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper;
-
-var
- oglWindow: TOpenGLWindow;
- running: Boolean = true;
-
-function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
-var
- data: TglBitmapData;
-begin
- case Msg of
- WM_DESTROY: begin
- running := false;
- end;
-
- WM_KEYDOWN: begin
- if wParam = VK_RETURN then begin
- data := TglBitmapData.Create; // create texture data object
- try
- TglBitmap2D.GrabScreen(0, 0, 800, 600, tfRGBA8ui1, data); // read pixels from frame buffer
- data.SaveToFile( // save data to file
- ExtractFilePath(ApplicationName) +
- 'screen.bmp', ftBMP);
- WriteLn('screen saved to screen.bmp');
- finally
- FreeAndNil(data); // free texture data object when done
- end;
- end;
- end;
- end;
- result := DefWindowProc(hWnd, Msg, wParam, lParam);
-end;
-
-procedure RenderLoop;
-begin
- glBegin(GL_TRIANGLES);
- glColor4f(1, 0, 0, 1); glVertex2f(400, 100);
- glColor4f(0, 1, 0, 1); glVertex2f(100, 500);
- glColor4f(0, 0, 1, 1); glVertex2f(700, 500);
- glEnd;
-end;
-
-begin
- oglWindow := CreateOpenGLWindow('GrapScreen (hit enter to grab screen)', 800, 600, @WindowProc);
- while running and ProgressMesages do begin
- RenderLoop;
- SwapBuffers(oglWindow.DC);
- end;
- DestroyOpenGLWindow(oglWindow);
-end.
-
-
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectSession>
- <PathDelim Value="\"/>
- <Version Value="9"/>
- <BuildModes Active="Default"/>
- <Units Count="4">
- <Unit0>
- <Filename Value="GrabScreen.lpr"/>
- <IsPartOfProject Value="True"/>
- <IsVisibleTab Value="True"/>
- <TopLine Value="25"/>
- <CursorPos Y="49"/>
- <UsageCount Value="21"/>
- <Loaded Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- <EditorIndex Value="-1"/>
- <UsageCount Value="21"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="Helper"/>
- <EditorIndex Value="1"/>
- <TopLine Value="37"/>
- <CursorPos X="40" Y="36"/>
- <UsageCount Value="21"/>
- <Loaded Value="True"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- <EditorIndex Value="2"/>
- <TopLine Value="5821"/>
- <CursorPos Y="5837"/>
- <UsageCount Value="21"/>
- <Loaded Value="True"/>
- </Unit3>
- </Units>
- <JumpHistory Count="30" HistoryIndex="29">
- <Position1>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4131" TopLine="4112"/>
- </Position1>
- <Position2>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4127" TopLine="4112"/>
- </Position2>
- <Position3>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4128" TopLine="4112"/>
- </Position3>
- <Position4>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4129" TopLine="4112"/>
- </Position4>
- <Position5>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4130" TopLine="4112"/>
- </Position5>
- <Position6>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4131" TopLine="4112"/>
- </Position6>
- <Position7>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4127" TopLine="4112"/>
- </Position7>
- <Position8>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4128" TopLine="4112"/>
- </Position8>
- <Position9>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4129" TopLine="4112"/>
- </Position9>
- <Position10>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4130" TopLine="4112"/>
- </Position10>
- <Position11>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4131" TopLine="4112"/>
- </Position11>
- <Position12>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4127" TopLine="4112"/>
- </Position12>
- <Position13>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4128" TopLine="4112"/>
- </Position13>
- <Position14>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4129" TopLine="4112"/>
- </Position14>
- <Position15>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4130" TopLine="4112"/>
- </Position15>
- <Position16>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4131" TopLine="4112"/>
- </Position16>
- <Position17>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4156" Column="29" TopLine="4136"/>
- </Position17>
- <Position18>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4151" Column="23" TopLine="4136"/>
- </Position18>
- <Position19>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4161" Column="12" TopLine="4136"/>
- </Position19>
- <Position20>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4425" Column="21" TopLine="4406"/>
- </Position20>
- <Position21>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="5436" Column="20" TopLine="5417"/>
- </Position21>
- <Position22>
- <Filename Value="..\..\glBitmap.pas"/>
- </Position22>
- <Position23>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="299" Column="11" TopLine="279"/>
- </Position23>
- <Position24>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4145" Column="3" TopLine="4142"/>
- </Position24>
- <Position25>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4157" TopLine="4141"/>
- </Position25>
- <Position26>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="5840" Column="44" TopLine="5825"/>
- </Position26>
- <Position27>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="5839" TopLine="5825"/>
- </Position27>
- <Position28>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="2229" TopLine="2212"/>
- </Position28>
- <Position29>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="2230" TopLine="2212"/>
- </Position29>
- <Position30>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="4155" Column="26" TopLine="4140"/>
- </Position30>
- </JumpHistory>
- </ProjectSession>
-</CONFIG>
+++ /dev/null
-unit Helper;
-
-{$mode objfpc}{$H+}
-
-interface
-
-uses
- Classes, SysUtils, Windows, dglOpenGL;
-
-type
- TOpenGLWindow = packed record
- LWndClass: TWndClass;
- hMainHandle: HWND;
- DC: HDC;
- RC: HGLRC;
- end;
-
-function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow;
-function ProgressMesages: Boolean;
-procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow);
-
-implementation
-
-function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow;
-begin
- //create the window
- result.LWndClass.hInstance := hInstance;
- with result.LWndClass do begin
- lpszClassName := 'MyWinApiWnd';
- Style := CS_PARENTDC or CS_BYTEALIGNCLIENT;
- hIcon := LoadIcon(hInstance,'MAINICON');
- lpfnWndProc := aWndProc;
- hbrBackground := COLOR_BTNFACE+1;
- hCursor := LoadCursor(0,IDC_ARROW);
- end;
- RegisterClass(result.LWndClass);
- result.hMainHandle := CreateWindow(
- result.LWndClass.lpszClassName,
- PAnsiChar(aCaption),
- WS_CAPTION or WS_MINIMIZEBOX or WS_SYSMENU or WS_VISIBLE,
- (GetSystemMetrics(SM_CXSCREEN) - aWidth) div 2,
- (GetSystemMetrics(SM_CYSCREEN) - aHeight) div 2,
- aWidth, aHeight, 0, 0, hInstance, nil);
-
- // create and activate rendering context
- result.DC := GetDC(result.hMainHandle);
- if (result.DC = 0) then begin
- WriteLn('unable to get DeviceContext');
- halt;
- end;
- result.RC := CreateRenderingContext(result.DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
- if (result.RC = 0) then begin
- WriteLn('unable to create RenderingContext');
- halt;
- end;
- ActivateRenderingContext(result.DC, result.RC);
-
- // init OpenGL
- glViewport(0, 0, aWidth, aHeight);
- glClearColor(0, 0, 0, 0);
- glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
-
- glDisable(GL_DEPTH_TEST);
- glDisable(GL_CULL_FACE);
-
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity;
- glOrtho(0, aWidth, aHeight, 0, -10, 10);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity;
-end;
-
-function ProgressMesages: Boolean;
-var
- Msg: TMSG;
-begin
- result := GetMessage(Msg, 0, 0, 0);
- if result then begin
- TranslateMessage(Msg);
- DispatchMessage(Msg);
- end;
-end;
-
-procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow);
-begin
- DestroyRenderingContext(aWindow.RC);
- ReleaseDC(aWindow.hMainHandle, aWindow.DC);
-end;
-
-end.
-
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectOptions>
- <Version Value="9"/>
- <PathDelim Value="\"/>
- <General>
- <Flags>
- <MainUnitHasCreateFormStatements Value="False"/>
- <MainUnitHasTitleStatement Value="False"/>
- </Flags>
- <SessionStorage Value="InProjectDir"/>
- <MainUnit Value="0"/>
- <Title Value="SimpleLoadFromFile"/>
- <UseAppBundle Value="False"/>
- <ResourceType Value="res"/>
- </General>
- <i18n>
- <EnableI18N LFM="False"/>
- </i18n>
- <VersionInfo>
- <StringTable ProductVersion=""/>
- </VersionInfo>
- <BuildModes Count="1">
- <Item1 Name="Default" Default="True"/>
- </BuildModes>
- <PublishOptions>
- <Version Value="2"/>
- </PublishOptions>
- <RunParams>
- <local>
- <FormatVersion Value="1"/>
- </local>
- </RunParams>
- <Units Count="4">
- <Unit0>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <IsPartOfProject Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- </Unit3>
- </Units>
- </ProjectOptions>
- <CompilerOptions>
- <Version Value="11"/>
- <PathDelim Value="\"/>
- <Target>
- <Filename Value="SimpleLoadFromFile"/>
- </Target>
- <SearchPaths>
- <IncludeFiles Value="$(ProjOutDir);.."/>
- <OtherUnitFiles Value="..;..\.."/>
- <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
- </SearchPaths>
- </CompilerOptions>
- <Debugging>
- <Exceptions Count="3">
- <Item1>
- <Name Value="EAbort"/>
- </Item1>
- <Item2>
- <Name Value="ECodetoolError"/>
- </Item2>
- <Item3>
- <Name Value="EFOpenError"/>
- </Item3>
- </Exceptions>
- </Debugging>
-</CONFIG>
+++ /dev/null
-program SimpleLoadFromFile;
-
-{$mode objfpc}{$H+}
-
-uses
- {$IFDEF UNIX}{$IFDEF UseCThreads}
- cthreads,
- {$ENDIF}{$ENDIF}
- Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper;
-
-var
- oglWindow: TOpenGLWindow;
- running: Boolean = true;
- tex: TglBitmap2D;
- data: TglBitmapData;
-
-function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
-begin
- case Msg of
- WM_DESTROY: begin
- running := false;
- end;
- end;
- result := DefWindowProc(hWnd, Msg, wParam, lParam);
-end;
-
-procedure RenderLoop;
-begin
- tex.Bind();
- glColor4f(1, 1, 1, 1);
- glBegin(GL_QUADS);
- glTexCoord2f(0, 0); glVertex2f(100, 100);
- glTexCoord2f(1, 0); glVertex2f(700, 100);
- glTexCoord2f(1, 1); glVertex2f(700, 500);
- glTexCoord2f(0, 1); glVertex2f(100, 500);
- glEnd;
- tex.Unbind();
-end;
-
-begin
- oglWindow := CreateOpenGLWindow('SimpleLoadFromFile', 800, 600, @WindowProc);
- try
- tex := TglBitmap2D.Create; // create texture object
- data := TglBitmapData.Create; // create texture data object
- try
- data.LoadFromFile( // load texture data from file
- ExtractFilePath(ApplicationName) +
- '../textures/BMP_24_RGB8.bmp');
- if not data.FormatDescriptor.HasOpenGLSupport then // check if format is supported by OpenGL
- data.ConvertTo(data.FormatDescriptor.OpenGLFormat); // if not then convert
- tex.UploadData(data); // upload data to video card
- finally
- FreeAndNil(data); // after upload is done, the data object could be freed to save memory
- end;
-
- while running and ProgressMesages do begin
- RenderLoop;
- SwapBuffers(oglWindow.DC);
- end;
- finally
- FreeAndNil(tex);
- DestroyOpenGLWindow(oglWindow);
- end;
-end.
-
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectSession>
- <PathDelim Value="\"/>
- <Version Value="9"/>
- <BuildModes Active="Default"/>
- <Units Count="5">
- <Unit0>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <IsPartOfProject Value="True"/>
- <TopLine Value="30"/>
- <CursorPos X="56" Y="46"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- <UsageCount Value="20"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- <IsVisibleTab Value="True"/>
- <EditorIndex Value="1"/>
- <TopLine Value="3822"/>
- <CursorPos X="65" Y="3838"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- <UsageCount Value="20"/>
- </Unit3>
- <Unit4>
- <Filename Value="..\TextureFromFunction\TextureFromFunction.lpr"/>
- <EditorIndex Value="2"/>
- <TopLine Value="68"/>
- <CursorPos Y="78"/>
- <UsageCount Value="10"/>
- <Loaded Value="True"/>
- </Unit4>
- </Units>
- <JumpHistory Count="24" HistoryIndex="23">
- <Position1>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="47" Column="75" TopLine="22"/>
- </Position1>
- <Position2>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="45" Column="22" TopLine="26"/>
- </Position2>
- <Position3>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="47" Column="43" TopLine="27"/>
- </Position3>
- <Position4>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="50" Column="18" TopLine="30"/>
- </Position4>
- <Position5>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="45" TopLine="30"/>
- </Position5>
- <Position6>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="48" TopLine="30"/>
- </Position6>
- <Position7>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="47" TopLine="30"/>
- </Position7>
- <Position8>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="48" TopLine="30"/>
- </Position8>
- <Position9>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="46" Column="10" TopLine="30"/>
- </Position9>
- <Position10>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="45" TopLine="30"/>
- </Position10>
- <Position11>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="48" TopLine="30"/>
- </Position11>
- <Position12>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="47" TopLine="30"/>
- </Position12>
- <Position13>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="48" TopLine="30"/>
- </Position13>
- <Position14>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="46" TopLine="30"/>
- </Position14>
- <Position15>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="6549" TopLine="6532"/>
- </Position15>
- <Position16>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="6550" TopLine="6532"/>
- </Position16>
- <Position17>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="6552" TopLine="6532"/>
- </Position17>
- <Position18>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="51" TopLine="30"/>
- </Position18>
- <Position19>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="50" TopLine="30"/>
- </Position19>
- <Position20>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="62" TopLine="30"/>
- </Position20>
- <Position21>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="45" Column="8" TopLine="30"/>
- </Position21>
- <Position22>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="446" Column="50" TopLine="420"/>
- </Position22>
- <Position23>
- <Filename Value="SimpleLoadFromFile.lpr"/>
- <Caret Line="46" Column="56" TopLine="30"/>
- </Position23>
- <Position24>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="446" Column="14" TopLine="431"/>
- </Position24>
- </JumpHistory>
- </ProjectSession>
-</CONFIG>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectOptions>
- <Version Value="9"/>
- <PathDelim Value="\"/>
- <General>
- <Flags>
- <MainUnitHasCreateFormStatements Value="False"/>
- <MainUnitHasTitleStatement Value="False"/>
- </Flags>
- <SessionStorage Value="InProjectDir"/>
- <MainUnit Value="0"/>
- <Title Value="TextureFromFunction"/>
- <UseAppBundle Value="False"/>
- <ResourceType Value="res"/>
- </General>
- <i18n>
- <EnableI18N LFM="False"/>
- </i18n>
- <VersionInfo>
- <StringTable ProductVersion=""/>
- </VersionInfo>
- <BuildModes Count="1">
- <Item1 Name="Default" Default="True"/>
- </BuildModes>
- <PublishOptions>
- <Version Value="2"/>
- </PublishOptions>
- <RunParams>
- <local>
- <FormatVersion Value="1"/>
- </local>
- </RunParams>
- <Units Count="4">
- <Unit0>
- <Filename Value="TextureFromFunction.lpr"/>
- <IsPartOfProject Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="dglOpenGL"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="Helper"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- </Unit3>
- </Units>
- </ProjectOptions>
- <CompilerOptions>
- <Version Value="11"/>
- <PathDelim Value="\"/>
- <Target>
- <Filename Value="TextureFromFunction"/>
- </Target>
- <SearchPaths>
- <IncludeFiles Value="$(ProjOutDir);.."/>
- <OtherUnitFiles Value="..;..\.."/>
- <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
- </SearchPaths>
- </CompilerOptions>
- <Debugging>
- <Exceptions Count="3">
- <Item1>
- <Name Value="EAbort"/>
- </Item1>
- <Item2>
- <Name Value="ECodetoolError"/>
- </Item2>
- <Item3>
- <Name Value="EFOpenError"/>
- </Item3>
- </Exceptions>
- </Debugging>
-</CONFIG>
+++ /dev/null
-program SimpleLoadFromFile;
-
-{$mode objfpc}{$H+}
-
-uses
- {$IFDEF UNIX}{$IFDEF UseCThreads}
- cthreads,
- {$ENDIF}{$ENDIF}
- Classes, Windows, SysUtils, dglOpenGL, glBitmap, Helper;
-
-var
- oglWindow: TOpenGLWindow;
- running: Boolean = true;
- data: TglBitmapData;
- tex: TglBitmap2D;
-
-function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
-begin
- case Msg of
- WM_DESTROY: begin
- running := false;
- end;
- end;
- result := DefWindowProc(hWnd, Msg, wParam, lParam);
-end;
-
-procedure RenderLoop;
-begin
- tex.Bind();
- glColor4f(1, 1, 1, 1);
- glBegin(GL_QUADS);
- glTexCoord2f(0, 0); glVertex2f(100, 100);
- glTexCoord2f(1, 0); glVertex2f(700, 100);
- glTexCoord2f(1, 1); glVertex2f(700, 500);
- glTexCoord2f(0, 1); glVertex2f(100, 500);
- glEnd;
- tex.Unbind();
-end;
-
-{ function to generate texture data }
-procedure GenerateTextureFunc1(var FuncRec: TglBitmapFunctionRec);
-var
- g1, g2, g3, g4: Single;
-begin
- g1 := (sin(FuncRec.Position.X / 25) + 1) / 2; // generator function 1: large sinus on x position (0.0 to 1.0)
- g2 := (sin(FuncRec.Position.Y / 25) + 1) / 2; // generator function 2: large sinus on y position (0.0 to 1.0)
- g3 := FuncRec.Position.X / FuncRec.Size.X; // generator function 3: linear fade on x position (0.0 to 1.0)
- g4 := FuncRec.Position.Y / FuncRec.Size.Y; // generator function 4: linear fade on y position (0.0 to 1.0)
-
- FuncRec.Dest.Data.r := Trunc(g1 * FuncRec.Dest.Range.r);
- FuncRec.Dest.Data.g := Trunc(g2 * FuncRec.Dest.Range.g);
- FuncRec.Dest.Data.b := Trunc(g3 * FuncRec.Dest.Range.b);
- FuncRec.Dest.Data.a := Trunc(g4 * FuncRec.Dest.Range.a);
-end;
-
-{ function to generate texture data }
-procedure GenerateTextureFunc2(var FuncRec: TglBitmapFunctionRec);
-var
- x, y: Single;
-begin
- x := FuncRec.Position.X / FuncRec.Size.X;
- y := FuncRec.Position.Y / FuncRec.Size.Y;
- if (x < 0.05) or (x > 0.95) or (y < 0.05) or (y > 0.95) then
- begin
- FuncRec.Dest.Data := FuncRec.Dest.Range;
- end else if (y < 0.333) then begin
- FuncRec.Dest.Data := glBitmapRec4ui(0, 0, 0, 0);
- end else if (y < 0.666) then begin
- FuncRec.Dest.Data := glBitmapRec4ui(FuncRec.Dest.Range.r, 0, 0, 0);
- end else begin
- FuncRec.Dest.Data := glBitmapRec4ui(FuncRec.Dest.Range.r, FuncRec.Dest.Range.g, 0, 0);
- end;
-end;
-
-begin
- oglWindow := CreateOpenGLWindow('TextureFromFunction', 800, 600, @WindowProc);
- try
- tex := TglBitmap2D.Create; // create texture object
- data := TglBitmapData.Create; // create texture data object
- try
- data.LoadFromFunc( // generate texture data using either GenerateTextureFunc1 or GenerateTextureFunc2
- glBitmapSize(512, 512),
- tfRGBA8ub4,
- @GenerateTextureFunc1
- //@GenerateTextureFunc2
- );
- tex.UploadData(data); // upload data to video card
- finally
- FreeAndNil(data); // after upload is done, the data object could be freed to save memory
- end;
-
- while running and ProgressMesages do begin
- RenderLoop;
- SwapBuffers(oglWindow.DC);
- end;
- finally
- FreeAndNil(tex);
- DestroyOpenGLWindow(oglWindow);
- end;
-end.
-
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<CONFIG>
- <ProjectSession>
- <PathDelim Value="\"/>
- <Version Value="9"/>
- <BuildModes Active="Default"/>
- <Units Count="5">
- <Unit0>
- <Filename Value="TextureFromFunction.lpr"/>
- <IsPartOfProject Value="True"/>
- <IsVisibleTab Value="True"/>
- <TopLine Value="63"/>
- <CursorPos X="22" Y="83"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit0>
- <Unit1>
- <Filename Value="..\dglOpenGL.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="dglOpenGL"/>
- <EditorIndex Value="2"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit1>
- <Unit2>
- <Filename Value="..\Helper.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="Helper"/>
- <EditorIndex Value="3"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit2>
- <Unit3>
- <Filename Value="..\..\glBitmap.pas"/>
- <IsPartOfProject Value="True"/>
- <UnitName Value="glBitmap"/>
- <EditorIndex Value="1"/>
- <TopLine Value="8809"/>
- <CursorPos X="17" Y="8814"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
- </Unit3>
- <Unit4>
- <Filename Value="..\SimpleLoadFromFile\SimpleLoadFromFile.lpr"/>
- <EditorIndex Value="-1"/>
- <TopLine Value="23"/>
- <CursorPos Y="56"/>
- <UsageCount Value="10"/>
- </Unit4>
- </Units>
- <JumpHistory Count="16" HistoryIndex="15">
- <Position1>
- <Filename Value="TextureFromFunction.lpr"/>
- </Position1>
- <Position2>
- <Filename Value="..\..\glBitmap.pas"/>
- </Position2>
- <Position3>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="44" Column="62" TopLine="23"/>
- </Position3>
- <Position4>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="1474" Column="3" TopLine="1445"/>
- </Position4>
- <Position5>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="59" TopLine="29"/>
- </Position5>
- <Position6>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="62" Column="32" TopLine="46"/>
- </Position6>
- <Position7>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="869" Column="67" TopLine="852"/>
- </Position7>
- <Position8>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="32" Column="76" TopLine="11"/>
- </Position8>
- <Position9>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="74" Column="40" TopLine="59"/>
- </Position9>
- <Position10>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="91" TopLine="67"/>
- </Position10>
- <Position11>
- <Filename Value="TextureFromFunction.lpr"/>
- <Caret Line="83" Column="22" TopLine="60"/>
- </Position11>
- <Position12>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="614" Column="15" TopLine="885"/>
- </Position12>
- <Position13>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="7976" Column="39" TopLine="7963"/>
- </Position13>
- <Position14>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="612" Column="55" TopLine="598"/>
- </Position14>
- <Position15>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="6579" Column="25" TopLine="6563"/>
- </Position15>
- <Position16>
- <Filename Value="..\..\glBitmap.pas"/>
- <Caret Line="614" Column="64" TopLine="611"/>
- </Position16>
- </JumpHistory>
- </ProjectSession>
-</CONFIG>
+++ /dev/null
-{ ============================================================================
-
- OpenGL 4.4 - Headertranslation
- Version 4.4
- Date : 2013/07/22
-
- Supported environments and targets :
- - (Win32) Delphi 4 and up
- - (Win32, Win64) Delphi XE2
- - (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up)
-
-==============================================================================
-
- Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h.
- It also contains some helperfunctions that were inspired by those
- found in Mike Lischke's OpenGL12.pas.
-
- Copyright (C) DGL-OpenGL2-Portteam
- All Rights Reserved
-
- Obtained through:
- Delphi OpenGL Community(DGL) - www.delphigl.com
-
- Converted and maintained by DGL's GL2.0-Team :
- - Sascha Willems - http://www.saschawillems.de
- - Steffen Xonna (Lossy eX) - http://www.dev-center.de
- Additional input :
- - Andrey Gruzdev (Mac OS X patch for XE2 / FPC)
- - Lars Middendorf
- - Martin Waldegger (Mars)
- - Benjamin Rosseaux (BeRo) - http://www.0ok.de
- Additional thanks:
- sigsegv (libdl.so)
-
-==============================================================================
- You may retrieve the latest version of this file at the Delphi OpenGL
- Community home page, located at http://www.delphigl.com/
-
- The contents of this file are used with permission, subject to
- the Mozilla Public License Version 1.1 (the "License"); you may
- not use this file except in compliance with the License. You may
- obtain a copy of the License at
- http://www.mozilla.org/MPL/MPL-1.1.html
-
- Software distributed under the License is distributed on an
- "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- implied. See the License for the specific language governing
- rights and limitations under the License.
-
-==============================================================================
- History :
- Version 1.0 Initial Release
- Version 1.1 Added PPointer in Tpyessection for compatiblity with Delphi
- versions lower than 7 (SW)
- Added a function named RaiseLastOSError including a comment
- on how to make it run under Delphi versions lower than 7 (SW)
- Added some data types according to the GL-Syntax (SW)
- Version 1.2 Fixed some problems with getting the addresses of some
- Extensions (e.g. glTexImage3D) where the EXT/ARB did work
- but not the core-functions (SW)
- Version 1.3 A second call to ReadimplementationProperties won't
- revert to the default libs anymore (MW)
- Libraries now will be released if necessary (MW)
- Version 1.3a Small fixes for glSlang-functions (SW)
- Version 1.3b Fixed a small bug with GL_ARB_shader_objects, that lead
- lead to that extension not loaded correctly (SW)
- Version 1.3c more GL 1.5 compliance by FOG_COORD_xx and
- ARB less VBO and occlusion query routines (MW)
- Version 1.3d Fixed linebreaks (should now be corrected under D5) (SW)
- Version 1.4 Changed header to correspond to the OpenGL-Shading
- Language specification 1.10 :
- - Added new GL_SAMPLER_*-Constants
- - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB
- - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
- - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW)
- Version 1.4a Fixed a missing stdcall for glBindAttribLocationARB (SW)
- Version 1.4b Fixed declaration for glUniform*(f/i)vARB (added count) (MW)
- glCompileShaderARB changed from function to procedure (MW)
- Version 1.5 Added support for FreePascal (BR)
- Added type TGLVectorf3/TGLVector3f (SW)
- Version 1.6 Added Extension GL_EXT_framebuffer_object (SX)
- Version 1.7 Added Extension GL_ARB_fragment_program_shadow (SX)
- Added Extension GL_ARB_draw_buffers (SX)
- Added Extension GL_ARB_texture_rectangle (SX)
- Added Extension GL_ARB_color_buffer_float (SX)
- Added Extension GL_ARB_half_float_pixel (SX)
- Added Extension GL_ARB_texture_float (SX)
- Added Extension GL_ARB_pixel_buffer_object (SX)
- Added Extension GL_EXT_depth_bounds_test (SX)
- Added Extension GL_EXT_texture_mirror_clamp (SX)
- Added Extension GL_EXT_blend_equation_separate (SX)
- Added Extension GL_EXT_pixel_buffer_object (SX)
- Added Extension GL_EXT_texture_compression_dxt1 (SX)
- Added Extension GL_NV_fragment_program_option (SX)
- Added Extension GL_NV_fragment_program2 (SX)
- Added Extension GL_NV_vertex_program2_option (SX)
- Added Extension GL_NV_vertex_program3 (SX)
- Version 1.8 Added explicit delegate type definitions (LM)
- Added .Net 1.1 Support (LM)
- Added .Net overloaded functions (LM)
- Added delayed extension loading and stubs (LM)
- Added automatic InitOpenGL call in CreateRenderingContext(LM)
- Added extra Read_* function (LM)
- Version 2.0 fixed some Problem with version string and damn drivers.
- String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX)
- Removed unexisting extension GL_ARB_texture_mirror_repeat(SX)
- Added Extension WGL_ARB_pixel_format_float (SX)
- Added Extension GL_EXT_stencil_clear_tag (SX)
- Added Extension GL_EXT_texture_rectangle (SX)
- Added Extension GL_EXT_texture_edge_clamp (SX)
- Some 1.5 Core Consts added (now completed) (SX)
- gluProject need pointer for not .net (SX)
- gluUnProject need pointer for not .net (SX)
- wglUseFontOutlines* need pointer for not .net (SX)
- wglSwapMultipleBuffers need pointer for not .net (SX)
- Bug with wglGetExtensionsStringEXT removed
- different type for .net (SX)
- Added OpenGL 2.0 Core (SX)
- Version 2.0.1 fixed some problems with glGetActiveAttrib in 2.0 Core (SX)
- fixes some problems with gluProject (SX)
- fixes some problems with gluUnProject (SX)
- fixes some problems with gluTessVertex (SX)
- fixes some problems with gluLoadSamplingMatrices (SX)
- Version 2.1 Removed .NET Support (SX)
- Better support for Linux (SX)
- Better Codeformation (SX)
- Added some more Vector/Matrix types (SX)
- Added OpenGL 2.1 Core (SX)
- Added Extension GL_EXT_packed_depth_stencil (SX)
- Added Extension GL_EXT_texture_sRGB (SX)
- Added Extension GL_EXT_framebuffer_blit (SX)
- Added Extension GL_EXT_framebuffer_multisample (SX)
- Added Extension GL_EXT_timer_query (SX)
- Added Extension GL_EXT_gpu_program_parameters (SX)
- Added Extension GL_EXT_bindable_uniform (SX)
- Added Extension GL_EXT_draw_buffers2 (SX)
- Added Extension GL_EXT_draw_instanced (SX)
- Added Extension GL_EXT_framebuffer_sRGB (SX)
- Added Extension GL_EXT_geometry_shader4 (SX)
- Added Extension GL_EXT_gpu_shader4 (SX)
- Added Extension GL_EXT_packed_float (SX)
- Added Extension GL_EXT_texture_array (SX)
- Added Extension GL_EXT_texture_buffer_object (SX)
- Added Extension GL_EXT_texture_compression_latc (SX)
- Added Extension GL_EXT_texture_compression_rgtc (SX)
- Added Extension GL_EXT_texture_integer (SX)
- Added Extension GL_EXT_texture_shared_exponent (SX)
- Added Extension GL_NV_depth_buffer_float (SX)
- Added Extension GL_NV_fragment_program4 (SX)
- Added Extension GL_NV_framebuffer_multisample_coverage (SX)
- Added Extension GL_NV_geometry_program4 (SX)
- Added Extension GL_NV_gpu_program4 (SX)
- Added Extension GL_NV_parameter_buffer_object (SX)
- Added Extension GL_NV_transform_feedback (SX)
- Added Extension GL_NV_vertex_program4 (SX)
- Version 3.0 fixed some const of GL_EXT_texture_shared_exponent (SX)
- possible better support for mac (SX)
- Added OpenGL 3.0 Core (SX)
- Added Extension GL_ARB_depth_buffer_float (SX)
- Added Extension GL_ARB_draw_instanced (SX)
- Added Extension GL_ARB_framebuffer_object (SX)
- Added Extension GL_ARB_framebuffer_sRGB (SX)
- Added Extension GL_ARB_geometry_shader4 (SX)
- Added Extension GL_ARB_half_float_vertex (SX)
- Added Extension GL_ARB_instanced_arrays (SX)
- Added Extension GL_ARB_map_buffer_range (SX)
- Added Extension GL_ARB_texture_buffer_object (SX)
- Added Extension GL_ARB_texture_compression_rgtc (SX)
- Added Extension GL_ARB_texture_rg (SX)
- Added Extension GL_ARB_vertex_array_object (SX)
- Added Extension GL_NV_conditional_render (SX)
- Added Extension GL_NV_present_video (SX)
- Added Extension GL_EXT_transform_feedback (SX)
- Added Extension GL_EXT_direct_state_access (SX)
- Added Extension GL_EXT_vertex_array_bgra (SX)
- Added Extension GL_EXT_texture_swizzle (SX)
- Added Extension GL_NV_explicit_multisample (SX)
- Added Extension GL_NV_transform_feedback2 (SX)
- Added Extension WGL_ARB_create_context (SX)
- Added Extension WGL_NV_present_video (SX)
- Added Extension WGL_NV_video_out (SX)
- Added Extension WGL_NV_swap_group (SX)
- Added Extension WGL_NV_gpu_affinity (SX)
- Added define DGL_TINY_HEADER to suppress automatic
- function loading (SX)
- glProcedure renamed to dglGetProcAddress and now it's
- visible from outside the unit to custom load functions (SX)
- dglCheckExtension added to check if an extension exists (SX)
- Read_GL_ARB_buffer_object renamed to
- Read_GL_ARB_vertex_buffer_object (SX)
- Version 3.0.1 fixed an problem with fpc (SX)
- Version 3.0.2 fixed an problem with WGL_ARB_create_context (SX)
- Version 3.2 Functions from GL_VERSION_3_0 where updated (SX)
- Functions from GL_ARB_map_buffer_range where updated (SX)
- Functions from GL_NV_present_video where added (SX)
- Added consts of GL_ARB_instanced_arrays (SX)
- Defines to identify Delphi was changed (prevent for
- feature maintenance) (SX)
- Added Extension GL_ATI_meminfo (SX)
- Added Extension GL_AMD_performance_monitor (SX)
- Added Extension GL_AMD_texture_texture4 (SX)
- Added Extension GL_AMD_vertex_shader_tesselator (SX)
- Added Extension GL_EXT_provoking_vertex (SX)
- Added Extension WGL_AMD_gpu_association (SX)
- Added OpenGL 3.1 Core (SX)
- All deprecated stuff can be disabled if you undef the
- define DGL_DEPRECATED (SX)
- Added Extension GL_ARB_uniform_buffer_object (SX)
- Added Extension GL_ARB_compatibility (SX)
- Added Extension GL_ARB_copy_buffer (SX)
- Added Extension GL_ARB_shader_texture_lod (SX)
- Remove function from GL_NV_present_video (SX)
- Added Extension WGL_3DL_stereo_control (SX)
- Added Extension GL_EXT_texture_snorm (SX)
- Added Extension GL_AMD_draw_buffers_blend (SX)
- Added Extension GL_APPLE_texture_range (SX)
- Added Extension GL_APPLE_float_pixels (SX)
- Added Extension GL_APPLE_vertex_program_evaluators (SX)
- Added Extension GL_APPLE_aux_depth_stencil (SX)
- Added Extension GL_APPLE_object_purgeable (SX)
- Added Extension GL_APPLE_row_bytes (SX)
- Added OpenGL 3.2 Core (SX)
- Added Extension GL_ARB_depth_clamp (SX)
- Added Extension GL_ARB_draw_elements_base_vertex (SX)
- Added Extension GL_ARB_fragment_coord_conventions (SX)
- Added Extension GL_ARB_provoking_vertex (SX)
- Added Extension GL_ARB_seamless_cube_map (SX)
- Added Extension GL_ARB_sync (SX)
- Added Extension GL_ARB_texture_multisample (SX)
- Added Extension GL_ARB_vertex_array_bgra (SX)
- Added Extension GL_ARB_draw_buffers_blend (SX)
- Added Extension GL_ARB_sample_shading (SX)
- Added Extension GL_ARB_texture_cube_map_array (SX)
- Added Extension GL_ARB_texture_gather (SX)
- Added Extension GL_ARB_texture_query_lod (SX)
- Added Extension WGL_ARB_create_context_profile (SX)
- Added GLX Core up to Version 1.4 (SX)
- Added Extension GLX_ARB_multisample (SX)
- Added Extension GLX_ARB_fbconfig_float (SX)
- Added Extension GLX_ARB_get_proc_address (SX)
- Added Extension GLX_ARB_create_context (SX)
- Added Extension GLX_ARB_create_context_profile (SX)
- Added Extension GLX_EXT_visual_info (SX)
- Added Extension GLX_EXT_visual_rating (SX)
- Added Extension GLX_EXT_import_context (SX)
- Added Extension GLX_EXT_fbconfig_packed_float (SX)
- Added Extension GLX_EXT_framebuffer_sRGB (SX)
- Added Extension GLX_EXT_texture_from_pixmap (SX)
- Version 3.2.1 Fixed some problems with Delphi < 6 (SX)
- Version 3.2.2 Added Extension GL_APPLE_rgb_422 (SX)
- Added Extension GL_EXT_separate_shader_objects (SX)
- Added Extension GL_NV_video_capture (SX)
- Added Extension GL_NV_copy_image (SX)
- Added Extension GL_NV_parameter_buffer_object2 (SX)
- Added Extension GL_NV_shader_buffer_load (SX)
- Added Extension GL_NV_vertex_buffer_unified_memory (SX)
- Added Extension GL_NV_texture_barrier (SX)
- Variable GL_EXT_texture_snorm will be filled (SX)
- Variable GL_APPLE_row_bytes will be filled (SX)
- Added Extension WGL_NV_video_capture (SX)
- Added Extension WGL_NV_copy_image (SX)
- WGL_NV_video_out now named WGL_NV_video_output (SX)
- Added Extension GLX_EXT_swap_control (SX)
- Version 3.2.3 Fixed an Problem with glGetAttribLocation (SX)
- Added const GL_UNIFORM_BUFFER_EXT (SX)
- Functions of GL_NV_texture_barrier now will be loaded (SX)
- Version 4.0 Changes on Extension GL_ARB_texture_gather (SX)
- Changes on Extension GL_NV_shader_buffer_load (SX)
- Added OpenGL 3.3 Core (SX)
- Added OpenGL 4.0 Core (SX)
- Added Extension GL_AMD_shader_stencil_export (SX)
- Added Extension GL_AMD_seamless_cubemap_per_texture (SX)
- Added Extension GL_ARB_shading_language_include (SX)
- Added Extension GL_ARB_texture_compression_bptc (SX)
- Added Extension GL_ARB_blend_func_extended (SX)
- Added Extension GL_ARB_explicit_attrib_location (SX)
- Added Extension GL_ARB_occlusion_query2 (SX)
- Added Extension GL_ARB_sampler_objects (SX)
- Added Extension GL_ARB_shader_bit_encoding (SX)
- Added Extension GL_ARB_texture_rgb10_a2ui (SX)
- Added Extension GL_ARB_texture_swizzle (SX)
- Added Extension GL_ARB_timer_query (SX)
- Added Extension GL_ARB_vertex_type_2_10_10_10_rev (SX)
- Added Extension GL_ARB_draw_indirect (SX)
- Added Extension GL_ARB_gpu_shader5 (SX)
- Added Extension GL_ARB_gpu_shader_fp64 (SX)
- Added Extension GL_ARB_shader_subroutine (SX)
- Added Extension GL_ARB_tessellation_shader (SX)
- Added Extension GL_ARB_texture_buffer_object_rgb32 (SX)
- Added Extension GL_ARB_transform_feedback2 (SX)
- Added Extension GL_ARB_transform_feedback3 (SX)
- Version 4.1 Possible fix some strange linux behavior (SX)
- All function uses GL instead of TGL types (SX)
- GL_AMD_vertex_shader_tesselator will be read now (SX)
- GL_AMD_draw_buffers_blend will be read now (SX)
- Changes on glStencilFuncSeparate (GL_2_0) (SX)
- Changes on GL_VERSION_3_2 (SX)
- Changes on GL_VERSION_3_3 (SX)
- Changes on GL_VERSION_4_0 (SX)
- Changes on GL_ARB_sample_shading (SX)
- Changes on GL_ARB_texture_cube_map_array (SX)
- Changes on GL_ARB_gpu_shader5 (SX)
- Changes on GL_ARB_transform_feedback3 (SX)
- Changes on GL_ARB_sampler_objects (SX)
- Changes on GL_ARB_gpu_shader_fp64 (SX)
- Changes on GL_APPLE_element_array (SX)
- Changes on GL_APPLE_vertex_array_range (SX)
- Changes on GL_NV_transform_feedback (SX)
- Changes on GL_NV_vertex_buffer_unified_memory (SX)
- Changes on GL_EXT_multi_draw_arrays (SX)
- Changes on GL_EXT_direct_state_access (SX)
- Changes on GL_AMD_performance_monitor (SX)
- Changes on GL_AMD_seamless_cubemap_per_texture (SX)
- Changes on GL_EXT_geometry_shader4 (SX)
- Added OpenGL 4.1 Core (SX)
- Added Extension GL_ARB_ES2_compatibility (SX)
- Added Extension GL_ARB_get_program_binary (SX)
- Added Extension GL_ARB_separate_shader_objects (SX)
- Added Extension GL_ARB_shader_precision (SX)
- Added Extension GL_ARB_vertex_attrib_64bit (SX)
- Added Extension GL_ARB_viewport_array (SX)
- Added Extension GL_ARB_cl_event (SX)
- Added Extension GL_ARB_debug_output (SX)
- Added Extension GL_ARB_robustness (SX)
- Added Extension GL_ARB_shader_stencil_export (SX)
- Added Extension GL_AMD_conservative_depth (SX)
- Added Extension GL_EXT_shader_image_load_store (SX)
- Added Extension GL_EXT_vertex_attrib_64bit (SX)
- Added Extension GL_NV_gpu_program5 (SX)
- Added Extension GL_NV_gpu_shader5 (SX)
- Added Extension GL_NV_shader_buffer_store (SX)
- Added Extension GL_NV_tessellation_program5 (SX)
- Added Extension GL_NV_vertex_attrib_integer_64bit (SX)
- Added Extension GL_NV_multisample_coverage (SX)
- Added Extension GL_AMD_name_gen_delete (SX)
- Added Extension GL_AMD_debug_output (SX)
- Added Extension GL_NV_vdpau_interop (SX)
- Added Extension GL_AMD_transform_feedback3_lines_triangles (SX)
- Added Extension GL_AMD_depth_clamp_separate (SX)
- Added Extension GL_EXT_texture_sRGB_decode (SX)
- Added Extension WGL_ARB_framebuffer_sRGB (SX)
- Added Extension WGL_ARB_create_context_robustness (SX)
- Added Extension WGL_EXT_create_context_es2_profile (SX)
- Added Extension WGL_NV_multisample_coverage (SX)
- Added Extension GLX_ARB_vertex_buffer_object (SX)
- Added Extension GLX_ARB_framebuffer_sRGB (SX)
- Added Extension GLX_ARB_create_context_robustness (SX)
- Added Extension GLX_EXT_create_context_es2_profile (SX)
- Version 4.1a Fix for dglGetProcAddress with FPC and linux (def param) (SW)
- Version 4.2 Added OpenGL 4.2 Core (SW)
- Added Extension GL_ARB_base_instance (SW)
- Added Extension GL_ARB_shading_language_420pack (SW)
- Added Extension GL_ARB_transform_feedback_instanced (SW)
- Added Extension GL_ARB_compressed_texture_pixel_storage (SW)
- Added Extension GL_ARB_conservative_depth (SW)
- Added Extension GL_ARB_internalformat_query (SW)
- Added Extension GL_ARB_map_buffer_alignment (SW)
- Added Extension GL_ARB_shader_atomic_counters (SW)
- Added Extension GL_ARB_shader_image_load_store (SW)
- Added Extension GL_ARB_shading_language_packing (SW)
- Added Extension GL_ARB_texture_storage (SW)
- Added Extension WGL_NV_DX_interop (SW)
- Added Define for WGL_EXT_create_context_es2_profile (SW)
- Version 4.2a Added Mac OS X patch by Andrey Gruzdev (SW)
- Version 4.3 Added OpenGL 4.3 Core (SW)
- Added GL_ARB_arrays_of_arrays (SW)
- Added GL_ARB_fragment_layer_viewport (SW)
- Added GL_ARB_shader_image_size (SW)
- Added GL_ARB_ES3_compatibility (SW)
- Added GL_ARB_clear_buffer_object (SW)
- Added GL_ARB_compute_shader (SW)
- Added GL_ARB_copy_image (SW)
- Added GL_KHR_debug (SW)
- Added GL_ARB_explicit_uniform_location, (SW)
- Added GL_ARB_framebuffer_no_attachments (SW)
- Added GL_ARB_internalformat_query2 (SW)
- Added GL_ARB_invalidate_subdata (SW)
- Added GL_ARB_multi_draw_indirect (SW)
- Added GL_ARB_program_interface_query (SW)
- Added GL_ARB_robust_buffer_access_behavior (SW)
- Added GL_ARB_shader_storage_buffer_object (SW)
- Added GL_ARB_stencil_texturing (SW)
- Added GL_ARB_texture_buffer_range (SW)
- Added GL_ARB_texture_query_levels (SW)
- Added GL_ARB_texture_storage_multisample (SW)
- Added GL_ARB_texture_view (SW)
- Added GL_ARB_vertex_attrib_binding (SW)
- Added new vendor-specific extensions (SW)
- Added GL_NV_path_rendering (SW)
- Added GL_AMD_pinned_memory (SW)
- Added GL_AMD_stencil_operation_extended (SW)
- Added GL_AMD_vertex_shader_viewport_index (SW)
- Added GL_AMD_vertex_shader_layer (SW)
- Added GL_NV_bindless_texture (SW)
- Added GL_NV_shader_atomic_float (SW)
- Added GL_AMD_query_buffer_object (SW)
- Added CreateRenderingContextVersion (SW)
- Version 4.4 Added ARB_buffer_storage (SW)
- Added ARB_clear_texture extension (SW)
- Added ARB_enhanced_layouts extension (SW)
- Added ARB_multi_bind extension (SW)
- Added ARB_query_buffer_object extension (SW)
- Added ARB_texture_mirror_clamp_to_edge extension (SW)
- Added ARB_texture_stencil8 extension (SW)
- Added ARB_vertex_type_10f_11f_11f_rev extension (SW)
- Added MAX_VERTEX_ATTRIB_STRIDE stat (SW)
- Added missing functions for GL_EXT_direct_state_access (SW)
- GL3.0+ uses non-deprecated way of getting extensions
- (thanks to frenK) (SW)
- Added missing cdecl for TglXGetVisualFromFBConfig (SW)
-
-
-==============================================================================
- Header based on glext.h rev 87 (2012-08-06)
- Header based on wglext.h rev 24 (2012/01/04)
- Header based on glxext.h rev 33 (2012/02/29) (only Core/ARB/EXT)
-
- This is an important notice for maintaining. Dont remove it. And make sure
- to keep it up to date
-============================================================================== }
-
-{$define DGL_DEPRECATED}
-{
- This define defines if the header should use deprecated ARB stuff or not.
- per Default the Header use deprecated Stuff.
-}
-
-
-{.$define DGL_TINY_HEADER}
-{
- If you enable the define DGL_TINY_HEADER no function automatically will be loaded if you
- call ActivateRenderingContext. This may some bit faster and the smart linker can delete
- all non used functions. This will reduce the filesize of your binary file. But in this
- case you have to load the functions by yourself. There are two ways to do this.
-
- 1. You can load whole extension by calling the func Read_Extensionname. But if you do
- this it's possible to load functions you dont use. So you have the same "problem"
- like before. But it's only an bit smaler.
- > Read_GL_ARB_multitexture;
-
- 2. You are able to load only the functions you exactly need. In this case you are able
- to use the variables of the dglOpenGL.pas. So you only need to load the functions
- and you can use the header like before.
- To do this you have to created and activated an opengl context and than you can load
- the needed functions.
- > ActivateRenderingContext(fDC, fRC);
- > glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
- > glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
-
- So only the function "glActiveTextureARB" and "glMultiTexCoord2fARB" will be loaded.
-
-
- Please notice that the extension variables won't be loaded if this define is active. But
- you can call dglCheckExtension to check if any extension exists. You can assign them to
- the variables of the dglOpenGL.pas so all code they use this will find them.
-
- > GL_ARB_shading_language_100 := dglCheckExtension('GL_ARB_shading_language_100');
-}
-
-
-unit dglOpenGL;
-
-interface
-
-// defines to configure freepascal
-{$IFDEF FPC}
- {$MODE Delphi}
-
- {$IFNDEF WINDOWS}
- {$LINKLIB c}
- {$ENDIF}
-{$ENDIF}
-
-// known delphi versions
-{$IFNDEF FPC} // if freepascal isnt defined
- {$IFDEF VER140} // Delphi 6
- {$DEFINE DELPHI6_AND_DOWN}
- {$ENDIF}
-
- {$IFDEF VER130} // Delphi 5
- {$DEFINE DELPHI6_AND_DOWN}
- {$ENDIF}
-
- {$IFDEF VER120} // Delphi 4
- {$DEFINE DELPHI6_AND_DOWN}
- {$ENDIF}
-
- {$IFDEF VER110} // C++ Builder 3
- {$DEFINE DELPHI6_AND_DOWN}
- {$ENDIF}
-
- {$IFDEF VER100} // Delphi 3
- {$DEFINE DELPHI6_AND_DOWN}
- {$ENDIF}
-{$ENDIF}
-
-// Options for Delphi < 5
-{$IFDEF DELPHI6_AND_DOWN}
- {$A+}
-{$ELSE}
- {$A4}
-{$ENDIF}
-
-// generell options
-{$H+,O+,X+}
-
-// detecting Windows
-{$IFDEF Win32} // Delphi and fpc of 32 Bit Windows
- {$DEFINE DGL_WIN}
-{$ENDIF}
-
-{$IFDEF Win64} // Delphi and fpc of 32 Bit Windows
- {$DEFINE DGL_WIN}
-{$ENDIF}
-
-// detecting Linux
-{$IFDEF linux} // Linux
- {$DEFINE DGL_LINUX}
-{$ENDIF}
-
-{$IFDEF DARWIN} // Mac OS X and FPC
- {$DEFINE DGL_MAC}
-{$ENDIF}
-
-{$IFDEF DELPHI} // Mac OS X add Delphi
-{$IFDEF MACOS}
- {$DEFINE DGL_MAC}
-{$ENDIF}
-{$ENDIF}
-
-
-// detecting 64 Bit CPU
-{$IFDEF CPU64} // fpc on 64 bit cpus
- {$DEFINE DGL_64BIT} // dgl define for 64 bit
-{$ENDIF}
-
-
-
-uses
- {$IFDEF FPC}{$IFDEF DARWIN}dynlibs,{$ENDIF}{$ENDIF} // LoadLibrary functions
- SysUtils
- {$IFDEF DGL_WIN}, Windows{$ENDIF}
- {$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF}
- ;
-
-type
- // Needed for Delphi 6 and less (defined in system.pas for Delphi 7)
- PPointer = ^Pointer;
- PCardinal = ^Cardinal;
-
- GLenum = Cardinal;
- GLboolean = BYTEBOOL;
- GLbitfield = Cardinal;
- GLbyte = Shortint;
- GLshort = SmallInt;
- GLint = Integer;
- GLsizei = Integer;
- GLubyte = Byte;
- GLushort = Word;
- GLuint = Cardinal;
- GLfloat = Single;
- GLclampf = Single;
- GLdouble = Double;
- GLclampd = Double;
- GLvoid = Pointer;
- GLint64 = Int64;
- GLuint64 = {$IFDEF DELPHI6_AND_DOWN} Int64 {$ELSE} UInt64 {$ENDIF};
-
- TGLenum = GLenum;
- TGLboolean = GLboolean;
- TGLbitfield = GLbitfield;
- TGLbyte = GLbyte;
- TGLshort = GLshort;
- TGLint = GLint;
- TGLsizei = GLsizei;
- TGLubyte = GLubyte;
- TGLushort = GLushort;
- TGLuint = GLuint;
- TGLfloat = GLfloat;
- TGLclampf = GLclampf;
- TGLdouble = GLdouble;
- TGLclampd = GLclampd;
- TGLvoid = GLvoid;
- TGLint64 = GLint64;
- TGLuint64 = GLuint64;
-
- PGLboolean = ^GLboolean;
- PGLbyte = ^GLbyte;
- PGLshort = ^GLshort;
- PGLint = ^GLint;
- PGLsizei = ^GLsizei;
- PGLubyte = ^GLubyte;
- PGLushort = ^GLushort;
- PGLuint = ^GLuint;
- PGLclampf = ^GLclampf;
- PGLfloat = ^GLfloat;
- PGLdouble = ^GLdouble;
- PGLclampd = ^GLclampd;
- PGLenum = ^GLenum;
- PGLvoid = Pointer;
- PPGLvoid = ^PGLvoid;
- PGLint64 = ^GLint64;
- PGLuint64 = ^GLuint64;
-
- // GL_NV_half_float
- GLhalfNV = WORD;
- TGLhalfNV = GLhalfNV;
- PGLhalfNV = ^GLhalfNV;
-
- // GL_ARB_shader_objects
- PGLHandleARB = ^GLHandleARB;
- GLHandleARB = Integer;
- GLcharARB = AnsiChar;
- PGLcharARB = PAnsiChar;
- PPGLcharARB = ^PGLcharARB;
-
- // GL_VERSION_1_5
- GLintptr = GLint;
- GLsizeiptr = GLsizei;
-
- // GL_ARB_vertex_buffer_object
- GLintptrARB = GLint;
- GLsizeiptrARB = GLsizei;
-
- // GL_VERSION_2_0
- GLHandle = Integer;
- PGLchar = PAnsiChar;
- PPGLchar = ^PGLChar;
-
- // GL_EXT_timer_query
- GLint64EXT = Int64;
- TGLint64EXT = GLint64EXT;
- PGLint64EXT = ^GLint64EXT;
-
- GLuint64EXT = GLuint64;
- TGLuint64EXT = GLuint64EXT;
- PGLuint64EXT = ^GLuint64EXT;
-
- // WGL_ARB_pbuffer
- HPBUFFERARB = THandle;
-
- // WGL_EXT_pbuffer
- HPBUFFEREXT = THandle;
-
- // WGL_NV_present_video
- PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV;
- HVIDEOOUTPUTDEVICENV = THandle;
-
- // WGL_NV_video_output
- PHPVIDEODEV = ^HPVIDEODEV;
- HPVIDEODEV = THandle;
-
- // WGL_NV_gpu_affinity
- PHPGPUNV = ^HPGPUNV;
- PHGPUNV = ^HGPUNV;
-
- // WGL_NV_video_capture
- HVIDEOINPUTDEVICENV = THandle;
- PHVIDEOINPUTDEVICENV = ^HVIDEOINPUTDEVICENV;
-
- HPGPUNV = THandle;
- HGPUNV = THandle;
-
- // GL_ARB_sync
- GLsync = Pointer;
-
- // GL_ARB_cl_event
- { These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event }
- _cl_context = record end;
- _cl_event = record end;
- p_cl_context = ^_cl_context;
- p_cl_event = ^_cl_event;
-
- // GL_ARB_debug_output
- TglDebugProcARB = procedure (source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_debug_output
- TglDebugProcAMD = procedure (id: GLuint; category: GLenum; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // (4.3) GL_KHR_debug
- TglDebugProc = procedure(source : GLEnum; type_ : GLEnum; id : GLUInt; severity : GLUInt; length : GLsizei; const message_ : PGLCHar; userParam : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vdpau_interop
- GLvdpauSurfaceNV = GLintptr;
- PGLvdpauSurfaceNV = ^GLvdpauSurfaceNV;
-
-
- // GLX
- {$IFDEF DGL_LINUX}
- GLXContext = Pointer;
- GLXContextID = TXID;
- GLXDrawable = TXID;
- GLXFBConfig = Pointer;
- GLXPbuffer = TXID;
- GLXPixmap = TXID;
- GLXWindow = TXID;
-
- Window = TXID;
- Colormap = TXID;
- Pixmap = TXID;
- Font = TXID;
- {$ENDIF}
-
- // Datatypes corresponding to GL's types TGL(name)(type)(count)
- TGLVectorub2 = array[0..1] of GLubyte;
- TGLVectori2 = array[0..1] of GLint;
- TGLVectorf2 = array[0..1] of GLfloat;
- TGLVectord2 = array[0..1] of GLdouble;
- TGLVectorp2 = array[0..1] of Pointer;
-
- TGLVectorub3 = array[0..2] of GLubyte;
- TGLVectori3 = array[0..2] of GLint;
- TGLVectorf3 = array[0..2] of GLfloat;
- TGLVectord3 = array[0..2] of GLdouble;
- TGLVectorp3 = array[0..2] of Pointer;
-
- TGLVectorub4 = array[0..3] of GLubyte;
- TGLVectori4 = array[0..3] of GLint;
- TGLVectorf4 = array[0..3] of GLfloat;
- TGLVectord4 = array[0..3] of GLdouble;
- TGLVectorp4 = array[0..3] of Pointer;
-
- TGLArrayf4 = TGLVectorf4;
- TGLArrayf3 = TGLVectorf3;
- TGLArrayd3 = TGLVectord3;
- TGLArrayi4 = TGLVectori4;
- TGLArrayp4 = TGLVectorp4;
-
- TGlMatrixub3 = array[0..2, 0..2] of GLubyte;
- TGlMatrixi3 = array[0..2, 0..2] of GLint;
- TGLMatrixf3 = array[0..2, 0..2] of GLfloat;
- TGLMatrixd3 = array[0..2, 0..2] of GLdouble;
-
- TGlMatrixub4 = array[0..3, 0..3] of GLubyte;
- TGlMatrixi4 = array[0..3, 0..3] of GLint;
- TGLMatrixf4 = array[0..3, 0..3] of GLfloat;
- TGLMatrixd4 = array[0..3, 0..3] of GLdouble;
-
- TGLVector3f = TGLVectorf3;
-
- // Datatypes corresponding to OpenGL12.pas for easy porting
- TVector3d = TGLVectord3;
-
- TVector4i = TGLVectori4;
- TVector4f = TGLVectorf4;
- TVector4p = TGLVectorp4;
-
- TMatrix4f = TGLMatrixf4;
- TMatrix4d = TGLMatrixd4;
-
- PGLMatrixd4 = ^TGLMatrixd4;
- PVector4i = ^TVector4i;
-
-
-
-{$IFDEF FPC}
- TRect = packed record
- Left, Top, Right, Bottom: Longint;
- end;
-{$ENDIF}
-
-
- PGPU_DEVICE = ^GPU_DEVICE;
- GPU_DEVICE = record
- cb: DWORD;
- DeviceName: array [0..31] of AnsiChar;
- DeviceString: array [0..127] of AnsiChar;
- Flags: DWORD;
- rcVirtualScreen: TRect;
- end;
-
-
-type
-{$IFDEF FPC}
- {$IFDEF DGL_WIN}
- PWGLSwap = ^TWGLSwap;
- {$EXTERNALSYM _WGLSWAP}
- _WGLSWAP = packed record
- hdc: HDC;
- uiFlags: UINT;
- end;
-
- TWGLSwap = _WGLSWAP;
- {$EXTERNALSYM WGLSWAP}
- WGLSWAP = _WGLSWAP;
-
- {$ENDIF}
-{$ENDIF}
-
- // GLU types
- TGLUNurbs = record
- end;
- TGLUQuadric = record
- end;
- TGLUTesselator = record
- end;
- PGLUNurbs = ^TGLUNurbs;
- PGLUQuadric = ^TGLUQuadric;
- PGLUTesselator = ^TGLUTesselator;
- // backwards compatibility
- TGLUNurbsObj = TGLUNurbs;
- TGLUQuadricObj = TGLUQuadric;
- TGLUTesselatorObj = TGLUTesselator;
- TGLUTriangulatorObj = TGLUTesselator;
- PGLUNurbsObj = PGLUNurbs;
- PGLUQuadricObj = PGLUQuadric;
- PGLUTesselatorObj = PGLUTesselator;
- PGLUTriangulatorObj = PGLUTesselator;
-
- // GLUQuadricCallback
- TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- // GLUTessCallback
- TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- // GLUNurbsCallback
- TGLUNurbsErrorProc = procedure(ErrorCode: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-var
- GL_VERSION_1_0,
- GL_VERSION_1_1,
- GL_VERSION_1_2,
- GL_VERSION_1_3,
- GL_VERSION_1_4,
- GL_VERSION_1_5,
- GL_VERSION_2_0,
- GL_VERSION_2_1,
- GL_VERSION_3_0,
- GL_VERSION_3_1,
- GL_VERSION_3_2,
- GL_VERSION_3_3,
- GL_VERSION_4_0,
- GL_VERSION_4_1,
- GL_VERSION_4_2,
- GL_VERSION_4_3,
- GL_VERSION_4_4,
- GLU_VERSION_1_1,
- GLU_VERSION_1_2,
- GLU_VERSION_1_3,
- GL_3DFX_multisample,
- GL_3DFX_tbuffer,
- GL_3DFX_texture_compression_FXT1,
- GL_APPLE_client_storage,
- GL_APPLE_element_array,
- GL_APPLE_fence,
- GL_APPLE_specular_vector,
- GL_APPLE_transform_hint,
- GL_APPLE_vertex_array_object,
- GL_APPLE_vertex_array_range,
- GL_APPLE_ycbcr_422,
- GL_APPLE_texture_range,
- GL_APPLE_float_pixels,
- GL_APPLE_vertex_program_evaluators,
- GL_APPLE_aux_depth_stencil,
- GL_APPLE_object_purgeable,
- GL_APPLE_row_bytes,
- GL_APPLE_rgb_422,
- GL_ARB_depth_texture,
- GL_ARB_fragment_program,
- GL_ARB_imaging,
- GL_ARB_matrix_palette,
- GL_ARB_multisample,
- GL_ARB_multitexture,
- GL_ARB_point_parameters,
- GL_ARB_shadow,
- GL_ARB_shadow_ambient,
- GL_ARB_texture_border_clamp,
- GL_ARB_texture_compression,
- GL_ARB_texture_cube_map,
- GL_ARB_texture_env_add,
- GL_ARB_texture_env_combine,
- GL_ARB_texture_env_crossbar,
- GL_ARB_texture_env_dot3,
- GL_ARB_texture_mirrored_repeat,
- GL_ARB_transpose_matrix,
- GL_ARB_vertex_blend,
- GL_ARB_vertex_buffer_object,
- GL_ARB_vertex_program,
- GL_ARB_window_pos,
- GL_ARB_shader_objects,
- GL_ARB_vertex_shader,
- GL_ARB_fragment_shader,
- GL_ARB_shading_language_100,
- GL_ARB_occlusion_query,
- GL_ARB_texture_non_power_of_two,
- GL_ARB_point_sprite,
- GL_ARB_fragment_program_shadow,
- GL_ARB_draw_buffers,
- GL_ARB_texture_rectangle,
- GL_ARB_color_buffer_float,
- GL_ARB_half_float_pixel,
- GL_ARB_texture_float,
- GL_ARB_pixel_buffer_object,
- GL_ARB_depth_buffer_float,
- GL_ARB_draw_instanced,
- GL_ARB_framebuffer_object,
- GL_ARB_framebuffer_sRGB,
- GL_ARB_geometry_shader4,
- GL_ARB_half_float_vertex,
- GL_ARB_instanced_arrays,
- GL_ARB_map_buffer_range,
- GL_ARB_texture_buffer_object,
- GL_ARB_texture_compression_rgtc,
- GL_ARB_texture_rg,
- GL_ARB_vertex_array_object,
- GL_ARB_uniform_buffer_object,
- GL_ARB_compatibility,
- GL_ARB_copy_buffer,
- GL_ARB_shader_texture_lod,
- GL_ARB_depth_clamp,
- GL_ARB_draw_elements_base_vertex,
- GL_ARB_fragment_coord_conventions,
- GL_ARB_provoking_vertex,
- GL_ARB_seamless_cube_map,
- GL_ARB_sync,
- GL_ARB_texture_multisample,
- GL_ARB_vertex_array_bgra,
- GL_ARB_draw_buffers_blend,
- GL_ARB_sample_shading,
- GL_ARB_texture_cube_map_array,
- GL_ARB_texture_gather,
- GL_ARB_texture_query_lod,
- GL_ARB_shading_language_include,
- GL_ARB_texture_compression_bptc,
- GL_ARB_blend_func_extended,
- GL_ARB_explicit_attrib_location,
- GL_ARB_occlusion_query2,
- GL_ARB_sampler_objects,
- GL_ARB_shader_bit_encoding,
- GL_ARB_texture_rgb10_a2ui,
- GL_ARB_texture_swizzle,
- GL_ARB_timer_query,
- GL_ARB_vertex_type_2_10_10_10_rev,
- GL_ARB_draw_indirect,
- GL_ARB_gpu_shader5,
- GL_ARB_gpu_shader_fp64,
- GL_ARB_shader_subroutine,
- GL_ARB_tessellation_shader,
- GL_ARB_texture_buffer_object_rgb32,
- GL_ARB_transform_feedback2,
- GL_ARB_transform_feedback3,
- GL_ARB_ES2_compatibility,
- GL_ARB_get_program_binary,
- GL_ARB_separate_shader_objects,
- GL_ARB_shader_precision,
- GL_ARB_vertex_attrib_64bit,
- GL_ARB_viewport_array,
-
- // GL 4.2
- GL_ARB_base_instance,
- GL_ARB_shading_language_420pack,
- GL_ARB_transform_feedback_instanced,
- GL_ARB_compressed_texture_pixel_storage,
- GL_ARB_conservative_depth,
- GL_ARB_internalformat_query,
- GL_ARB_map_buffer_alignment,
- GL_ARB_shader_atomic_counters,
- GL_ARB_shader_image_load_store,
- GL_ARB_shading_language_packing,
- GL_ARB_texture_storage,
- // END GL 4.2
-
- // GL 4.3
- GL_ARB_arrays_of_arrays,
- GL_ARB_fragment_layer_viewport,
- GL_ARB_shader_image_size,
- GL_ARB_ES3_compatibility,
- GL_ARB_clear_buffer_object,
- GL_ARB_compute_shader,
- GL_ARB_copy_image,
- GL_KHR_debug,
- GL_ARB_explicit_uniform_location,
- GL_ARB_framebuffer_no_attachments,
- GL_ARB_internalformat_query2,
- GL_ARB_invalidate_subdata,
- GL_ARB_multi_draw_indirect,
- GL_ARB_program_interface_query,
- GL_ARB_robust_buffer_access_behavior,
- GL_ARB_shader_storage_buffer_object,
- GL_ARB_stencil_texturing,
- GL_ARB_texture_buffer_range,
- GL_ARB_texture_query_levels,
- GL_ARB_texture_storage_multisample,
- GL_ARB_texture_view,
- GL_ARB_vertex_attrib_binding,
- GL_NV_path_rendering,
- GL_AMD_pinned_memory,
- GL_AMD_stencil_operation_extended,
- GL_AMD_vertex_shader_viewport_index,
- GL_AMD_vertex_shader_layer,
- GL_NV_bindless_texture,
- GL_NV_shader_atomic_float,
- GL_AMD_query_buffer_object,
- // END GL 4.3
-
- // GL 4.4
- GL_ARB_buffer_storage,
- GL_ARB_clear_texture,
- GL_ARB_enhanced_layouts,
- GL_ARB_multi_bind,
- GL_ARB_query_buffer_object,
- GL_ARB_texture_mirror_clamp_to_edge,
- GL_ARB_texture_stencil8,
- GL_ARB_vertex_type_10f_11f_11f_rev,
- // END 4.4
-
- GL_ARB_cl_event,
- GL_ARB_debug_output,
- GL_ARB_robustness,
- GL_ARB_shader_stencil_export,
- GL_ATI_draw_buffers,
- GL_ATI_element_array,
- GL_ATI_envmap_bumpmap,
- GL_ATI_fragment_shader,
- GL_ATI_map_object_buffer,
- GL_ATI_pn_triangles,
- GL_ATI_separate_stencil,
- GL_ATI_text_fragment_shader,
- GL_ATI_texture_env_combine3,
- GL_ATI_texture_float,
- GL_ATI_texture_mirror_once,
- GL_ATI_vertex_array_object,
- GL_ATI_vertex_attrib_array_object,
- GL_ATI_vertex_streams,
- GL_ATI_meminfo,
- GL_AMD_performance_monitor,
- GL_AMD_texture_texture4,
- GL_AMD_vertex_shader_tesselator,
- GL_AMD_draw_buffers_blend,
- GL_AMD_shader_stencil_export,
- GL_AMD_seamless_cubemap_per_texture,
- GL_AMD_conservative_depth,
- GL_AMD_name_gen_delete,
- GL_AMD_debug_output,
- GL_AMD_transform_feedback3_lines_triangles,
- GL_AMD_depth_clamp_separate,
- GL_EXT_422_pixels,
- GL_EXT_abgr,
- GL_EXT_bgra,
- GL_EXT_blend_color,
- GL_EXT_blend_func_separate,
- GL_EXT_blend_logic_op,
- GL_EXT_blend_minmax,
- GL_EXT_blend_subtract,
- GL_EXT_clip_volume_hint,
- GL_EXT_cmyka,
- GL_EXT_color_matrix,
- GL_EXT_color_subtable,
- GL_EXT_compiled_vertex_array,
- GL_EXT_convolution,
- GL_EXT_coordinate_frame,
- GL_EXT_copy_texture,
- GL_EXT_cull_vertex,
- GL_EXT_draw_range_elements,
- GL_EXT_fog_coord,
- GL_EXT_framebuffer_object,
- GL_EXT_histogram,
- GL_EXT_index_array_formats,
- GL_EXT_index_func,
- GL_EXT_index_material,
- GL_EXT_index_texture,
- GL_EXT_light_texture,
- GL_EXT_misc_attribute,
- GL_EXT_multi_draw_arrays,
- GL_EXT_multisample,
- GL_EXT_packed_pixels,
- GL_EXT_paletted_texture,
- GL_EXT_pixel_transform,
- GL_EXT_pixel_transform_color_table,
- GL_EXT_point_parameters,
- GL_EXT_polygon_offset,
- GL_EXT_rescale_normal,
- GL_EXT_secondary_color,
- GL_EXT_separate_specular_color,
- GL_EXT_shadow_funcs,
- GL_EXT_shared_texture_palette,
- GL_EXT_stencil_two_side,
- GL_EXT_stencil_wrap,
- GL_EXT_subtexture,
- GL_EXT_texture,
- GL_EXT_texture3D,
- GL_EXT_texture_compression_s3tc,
- GL_EXT_texture_cube_map,
- GL_EXT_texture_edge_clamp,
- GL_EXT_texture_env_add,
- GL_EXT_texture_env_combine,
- GL_EXT_texture_env_dot3,
- GL_EXT_texture_filter_anisotropic,
- GL_EXT_texture_lod_bias,
- GL_EXT_texture_object,
- GL_EXT_texture_perturb_normal,
- GL_EXT_texture_rectangle,
- GL_EXT_vertex_array,
- GL_EXT_vertex_shader,
- GL_EXT_vertex_weighting,
- GL_EXT_depth_bounds_test,
- GL_EXT_texture_mirror_clamp,
- GL_EXT_blend_equation_separate,
- GL_EXT_pixel_buffer_object,
- GL_EXT_texture_compression_dxt1,
- GL_EXT_stencil_clear_tag,
- GL_EXT_packed_depth_stencil,
- GL_EXT_texture_sRGB,
- GL_EXT_framebuffer_blit,
- GL_EXT_framebuffer_multisample,
- GL_EXT_timer_query,
- GL_EXT_gpu_program_parameters,
- GL_EXT_bindable_uniform,
- GL_EXT_draw_buffers2,
- GL_EXT_draw_instanced,
- GL_EXT_framebuffer_sRGB,
- GL_EXT_geometry_shader4,
- GL_EXT_gpu_shader4,
- GL_EXT_packed_float,
- GL_EXT_texture_array,
- GL_EXT_texture_buffer_object,
- GL_EXT_texture_compression_latc,
- GL_EXT_texture_compression_rgtc,
- GL_EXT_texture_integer,
- GL_EXT_texture_shared_exponent,
- GL_EXT_transform_feedback,
- GL_EXT_direct_state_access,
- GL_EXT_vertex_array_bgra,
- GL_EXT_texture_swizzle,
- GL_EXT_provoking_vertex,
- GL_EXT_texture_snorm,
- GL_EXT_separate_shader_objects,
- GL_EXT_shader_image_load_store,
- GL_EXT_vertex_attrib_64bit,
- GL_EXT_texture_sRGB_decode,
- GL_FfdMaskSGIX,
- GL_HP_convolution_border_modes,
- GL_HP_image_transform,
- GL_HP_occlusion_test,
- GL_HP_texture_lighting,
- GL_IBM_cull_vertex,
- GL_IBM_multimode_draw_arrays,
- GL_IBM_rasterpos_clip,
- GL_IBM_texture_mirrored_repeat,
- GL_IBM_vertex_array_lists,
- GL_INGR_blend_func_separate,
- GL_INGR_color_clamp,
- GL_INGR_interlace_read,
- GL_INGR_palette_buffer,
- GL_INTEL_parallel_arrays,
- GL_INTEL_texture_scissor,
- GL_MESA_resize_buffers,
- GL_MESA_window_pos,
- GL_NV_blend_square,
- GL_NV_copy_depth_to_color,
- GL_NV_depth_clamp,
- GL_NV_evaluators,
- GL_NV_fence,
- GL_NV_float_buffer,
- GL_NV_fog_distance,
- GL_NV_fragment_program,
- GL_NV_half_float,
- GL_NV_light_max_exponent,
- GL_NV_multisample_filter_hint,
- GL_NV_occlusion_query,
- GL_NV_packed_depth_stencil,
- GL_NV_pixel_data_range,
- GL_NV_point_sprite,
- GL_NV_primitive_restart,
- GL_NV_register_combiners,
- GL_NV_register_combiners2,
- GL_NV_texgen_emboss,
- GL_NV_texgen_reflection,
- GL_NV_texture_compression_vtc,
- GL_NV_texture_env_combine4,
- GL_NV_texture_expand_normal,
- GL_NV_texture_rectangle,
- GL_NV_texture_shader,
- GL_NV_texture_shader2,
- GL_NV_texture_shader3,
- GL_NV_vertex_array_range,
- GL_NV_vertex_array_range2,
- GL_NV_vertex_program,
- GL_NV_vertex_program1_1,
- GL_NV_vertex_program2,
- GL_NV_fragment_program_option,
- GL_NV_fragment_program2,
- GL_NV_vertex_program2_option,
- GL_NV_vertex_program3,
- GL_NV_depth_buffer_float,
- GL_NV_fragment_program4,
- GL_NV_framebuffer_multisample_coverage,
- GL_NV_geometry_program4,
- GL_NV_gpu_program4,
- GL_NV_parameter_buffer_object,
- GL_NV_transform_feedback,
- GL_NV_vertex_program4,
- GL_NV_conditional_render,
- GL_NV_present_video,
- GL_NV_explicit_multisample,
- GL_NV_transform_feedback2,
- GL_NV_video_capture,
- GL_NV_copy_image,
- GL_NV_parameter_buffer_object2,
- GL_NV_shader_buffer_load,
- GL_NV_vertex_buffer_unified_memory,
- GL_NV_gpu_program5,
- GL_NV_gpu_shader5,
- GL_NV_shader_buffer_store,
- GL_NV_tessellation_program5,
- GL_NV_vertex_attrib_integer_64bit,
- GL_NV_multisample_coverage,
- GL_NV_vdpau_interop,
- GL_NV_texture_barrier,
- GL_OML_interlace,
- GL_OML_resample,
- GL_OML_subsample,
- GL_PGI_misc_hints,
- GL_PGI_vertex_hints,
- GL_REND_screen_coordinates,
- GL_S3_s3tc,
- GL_SGIS_detail_texture,
- GL_SGIS_fog_function,
- GL_SGIS_generate_mipmap,
- GL_SGIS_multisample,
- GL_SGIS_pixel_texture,
- GL_SGIS_point_line_texgen,
- GL_SGIS_point_parameters,
- GL_SGIS_sharpen_texture,
- GL_SGIS_texture4D,
- GL_SGIS_texture_border_clamp,
- GL_SGIS_texture_color_mask,
- GL_SGIS_texture_edge_clamp,
- GL_SGIS_texture_filter4,
- GL_SGIS_texture_lod,
- GL_SGIS_texture_select,
- GL_SGIX_async,
- GL_SGIX_async_histogram,
- GL_SGIX_async_pixel,
- GL_SGIX_blend_alpha_minmax,
- GL_SGIX_calligraphic_fragment,
- GL_SGIX_clipmap,
- GL_SGIX_convolution_accuracy,
- GL_SGIX_depth_pass_instrument,
- GL_SGIX_depth_texture,
- GL_SGIX_flush_raster,
- GL_SGIX_fog_offset,
- GL_SGIX_fog_scale,
- GL_SGIX_fragment_lighting,
- GL_SGIX_framezoom,
- GL_SGIX_igloo_interface,
- GL_SGIX_impact_pixel_texture,
- GL_SGIX_instruments,
- GL_SGIX_interlace,
- GL_SGIX_ir_instrument1,
- GL_SGIX_list_priority,
- GL_SGIX_pixel_texture,
- GL_SGIX_pixel_tiles,
- GL_SGIX_polynomial_ffd,
- GL_SGIX_reference_plane,
- GL_SGIX_resample,
- GL_SGIX_scalebias_hint,
- GL_SGIX_shadow,
- GL_SGIX_shadow_ambient,
- GL_SGIX_sprite,
- GL_SGIX_subsample,
- GL_SGIX_tag_sample_buffer,
- GL_SGIX_texture_add_env,
- GL_SGIX_texture_coordinate_clamp,
- GL_SGIX_texture_lod_bias,
- GL_SGIX_texture_multi_buffer,
- GL_SGIX_texture_scale_bias,
- GL_SGIX_texture_select,
- GL_SGIX_vertex_preclip,
- GL_SGIX_ycrcb,
- GL_SGIX_ycrcb_subsample,
- GL_SGIX_ycrcba,
- GL_SGI_color_matrix,
- GL_SGI_color_table,
- GL_SGI_depth_pass_instrument,
- GL_SGI_texture_color_table,
- GL_SUNX_constant_data,
- GL_SUN_convolution_border_modes,
- GL_SUN_global_alpha,
- GL_SUN_mesh_array,
- GL_SUN_slice_accum,
- GL_SUN_triangle_list,
- GL_SUN_vertex,
-
- GL_WIN_phong_shading,
- GL_WIN_specular_fog,
- WGL_3DFX_multisample,
- WGL_ARB_buffer_region,
- WGL_ARB_extensions_string,
- WGL_ARB_make_current_read,
- WGL_ARB_multisample,
- WGL_ARB_pbuffer,
- WGL_ARB_pixel_format,
- WGL_ARB_pixel_format_float,
- WGL_ARB_render_texture,
- WGL_ARB_create_context,
- WGL_ARB_create_context_profile,
- WGL_ARB_framebuffer_sRGB,
- WGL_ARB_create_context_robustness,
- WGL_ATI_pixel_format_float,
- WGL_AMD_gpu_association,
- WGL_EXT_depth_float,
- WGL_EXT_display_color_table,
- WGL_EXT_extensions_string,
- WGL_EXT_make_current_read,
- WGL_EXT_multisample,
- WGL_EXT_pbuffer,
- WGL_EXT_pixel_format,
- WGL_EXT_swap_control,
- WGL_EXT_create_context_es2_profile,
- WGL_I3D_digital_video_control,
- WGL_I3D_gamma,
- WGL_I3D_genlock,
- WGL_I3D_image_buffer,
- WGL_I3D_swap_frame_lock,
- WGL_I3D_swap_frame_usage,
- WGL_NV_float_buffer,
- WGL_NV_render_depth_texture,
- WGL_NV_render_texture_rectangle,
- WGL_NV_vertex_array_range,
- WGL_NV_present_video,
- WGL_NV_video_output,
- WGL_NV_swap_group,
- WGL_NV_gpu_affinity,
- WGL_NV_video_capture,
- WGL_NV_copy_image,
- WGL_NV_multisample_coverage,
- WGL_NV_DX_interop,
- WGL_OML_sync_control,
- WGL_3DL_stereo_control,
- WIN_draw_range_elements,
- WIN_swap_hint,
-
-// GLX_VERSION_1_0,
- GLX_VERSION_1_3,
- GLX_VERSION_1_4,
- GLX_ARB_multisample,
- GLX_ARB_fbconfig_float,
- GLX_ARB_get_proc_address,
- GLX_ARB_create_context,
- GLX_ARB_create_context_profile,
- GLX_ARB_vertex_buffer_object,
- GLX_ARB_framebuffer_sRGB,
- GLX_ARB_create_context_robustness,
- GLX_EXT_visual_info,
- GLX_EXT_visual_rating,
- GLX_EXT_import_context,
- GLX_EXT_fbconfig_packed_float,
- GLX_EXT_framebuffer_sRGB,
- GLX_EXT_texture_from_pixmap,
- GLX_EXT_swap_control,
- GLX_EXT_create_context_es2_profile : Boolean;
-
-const
- // GL_VERSION_1_1
- { AttribMask }
- GL_DEPTH_BUFFER_BIT = $00000100;
- GL_STENCIL_BUFFER_BIT = $00000400;
- GL_COLOR_BUFFER_BIT = $00004000;
- { Boolean }
- GL_TRUE = 1;
- GL_FALSE = 0;
- { BeginMode }
- GL_POINTS = $0000;
- GL_LINES = $0001;
- GL_LINE_LOOP = $0002;
- GL_LINE_STRIP = $0003;
- GL_TRIANGLES = $0004;
- GL_TRIANGLE_STRIP = $0005;
- GL_TRIANGLE_FAN = $0006;
- { AlphaFunction }
- GL_NEVER = $0200;
- GL_LESS = $0201;
- GL_EQUAL = $0202;
- GL_LEQUAL = $0203;
- GL_GREATER = $0204;
- GL_NOTEQUAL = $0205;
- GL_GEQUAL = $0206;
- GL_ALWAYS = $0207;
- { BlendingFactorDest }
- GL_ZERO = 0;
- GL_ONE = 1;
- GL_SRC_COLOR = $0300;
- GL_ONE_MINUS_SRC_COLOR = $0301;
- GL_SRC_ALPHA = $0302;
- GL_ONE_MINUS_SRC_ALPHA = $0303;
- GL_DST_ALPHA = $0304;
- GL_ONE_MINUS_DST_ALPHA = $0305;
- { BlendingFactorSrc }
- GL_DST_COLOR = $0306;
- GL_ONE_MINUS_DST_COLOR = $0307;
- GL_SRC_ALPHA_SATURATE = $0308;
- { DrawBufferMode }
- GL_NONE = 0;
- GL_FRONT_LEFT = $0400;
- GL_FRONT_RIGHT = $0401;
- GL_BACK_LEFT = $0402;
- GL_BACK_RIGHT = $0403;
- GL_FRONT = $0404;
- GL_BACK = $0405;
- GL_LEFT = $0406;
- GL_RIGHT = $0407;
- GL_FRONT_AND_BACK = $0408;
- { ErrorCode }
- GL_NO_ERROR = 0;
- GL_INVALID_ENUM = $0500;
- GL_INVALID_VALUE = $0501;
- GL_INVALID_OPERATION = $0502;
- GL_OUT_OF_MEMORY = $0505;
- { FrontFaceDirection }
- GL_CW = $0900;
- GL_CCW = $0901;
- { GetPName }
- GL_POINT_SIZE = $0B11;
- GL_POINT_SIZE_RANGE = $0B12;
- GL_POINT_SIZE_GRANULARITY = $0B13;
- GL_LINE_SMOOTH = $0B20;
- GL_LINE_WIDTH = $0B21;
- GL_LINE_WIDTH_RANGE = $0B22;
- GL_LINE_WIDTH_GRANULARITY = $0B23;
- GL_POLYGON_SMOOTH = $0B41;
- GL_CULL_FACE = $0B44;
- GL_CULL_FACE_MODE = $0B45;
- GL_FRONT_FACE = $0B46;
- GL_DEPTH_RANGE = $0B70;
- GL_DEPTH_TEST = $0B71;
- GL_DEPTH_WRITEMASK = $0B72;
- GL_DEPTH_CLEAR_VALUE = $0B73;
- GL_DEPTH_FUNC = $0B74;
- GL_STENCIL_TEST = $0B90;
- GL_STENCIL_CLEAR_VALUE = $0B91;
- GL_STENCIL_FUNC = $0B92;
- GL_STENCIL_VALUE_MASK = $0B93;
- GL_STENCIL_FAIL = $0B94;
- GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
- GL_STENCIL_PASS_DEPTH_PASS = $0B96;
- GL_STENCIL_REF = $0B97;
- GL_STENCIL_WRITEMASK = $0B98;
- GL_VIEWPORT = $0BA2;
- GL_DITHER = $0BD0;
- GL_BLEND_DST = $0BE0;
- GL_BLEND_SRC = $0BE1;
- GL_BLEND = $0BE2;
- GL_LOGIC_OP_MODE = $0BF0;
- GL_COLOR_LOGIC_OP = $0BF2;
- GL_DRAW_BUFFER = $0C01;
- GL_READ_BUFFER = $0C02;
- GL_SCISSOR_BOX = $0C10;
- GL_SCISSOR_TEST = $0C11;
- GL_COLOR_CLEAR_VALUE = $0C22;
- GL_COLOR_WRITEMASK = $0C23;
- GL_DOUBLEBUFFER = $0C32;
- GL_STEREO = $0C33;
- GL_LINE_SMOOTH_HINT = $0C52;
- GL_POLYGON_SMOOTH_HINT = $0C53;
- GL_UNPACK_SWAP_BYTES = $0CF0;
- GL_UNPACK_LSB_FIRST = $0CF1;
- GL_UNPACK_ROW_LENGTH = $0CF2;
- GL_UNPACK_SKIP_ROWS = $0CF3;
- GL_UNPACK_SKIP_PIXELS = $0CF4;
- GL_UNPACK_ALIGNMENT = $0CF5;
- GL_PACK_SWAP_BYTES = $0D00;
- GL_PACK_LSB_FIRST = $0D01;
- GL_PACK_ROW_LENGTH = $0D02;
- GL_PACK_SKIP_ROWS = $0D03;
- GL_PACK_SKIP_PIXELS = $0D04;
- GL_PACK_ALIGNMENT = $0D05;
- GL_MAX_TEXTURE_SIZE = $0D33;
- GL_MAX_VIEWPORT_DIMS = $0D3A;
- GL_SUBPIXEL_BITS = $0D50;
- GL_TEXTURE_1D = $0DE0;
- GL_TEXTURE_2D = $0DE1;
- GL_POLYGON_OFFSET_UNITS = $2A00;
- GL_POLYGON_OFFSET_POINT = $2A01;
- GL_POLYGON_OFFSET_LINE = $2A02;
- GL_POLYGON_OFFSET_FILL = $8037;
- GL_POLYGON_OFFSET_FACTOR = $8038;
- GL_TEXTURE_BINDING_1D = $8068;
- GL_TEXTURE_BINDING_2D = $8069;
- { GetTextureParameter }
- GL_TEXTURE_WIDTH = $1000;
- GL_TEXTURE_HEIGHT = $1001;
- GL_TEXTURE_INTERNAL_FORMAT = $1003;
- GL_TEXTURE_BORDER_COLOR = $1004;
- GL_TEXTURE_BORDER = $1005;
- GL_TEXTURE_RED_SIZE = $805C;
- GL_TEXTURE_GREEN_SIZE = $805D;
- GL_TEXTURE_BLUE_SIZE = $805E;
- GL_TEXTURE_ALPHA_SIZE = $805F;
- { HintMode }
- GL_DONT_CARE = $1100;
- GL_FASTEST = $1101;
- GL_NICEST = $1102;
- { DataType }
- GL_BYTE = $1400;
- GL_UNSIGNED_BYTE = $1401;
- GL_SHORT = $1402;
- GL_UNSIGNED_SHORT = $1403;
- GL_INT = $1404;
- GL_UNSIGNED_INT = $1405;
- GL_FLOAT = $1406;
- GL_DOUBLE = $140A;
- { LogicOp }
- GL_CLEAR = $1500;
- GL_AND = $1501;
- GL_AND_REVERSE = $1502;
- GL_COPY = $1503;
- GL_AND_INVERTED = $1504;
- GL_NOOP = $1505;
- GL_XOR = $1506;
- GL_OR = $1507;
- GL_NOR = $1508;
- GL_EQUIV = $1509;
- GL_INVERT = $150A;
- GL_OR_REVERSE = $150B;
- GL_COPY_INVERTED = $150C;
- GL_OR_INVERTED = $150D;
- GL_NAND = $150E;
- GL_SET = $150F;
- { MatrixMode (for gl3.h, FBO attachment type) }
- GL_TEXTURE = $1702;
- { PixelCopyType }
- GL_COLOR = $1800;
- GL_DEPTH = $1801;
- GL_STENCIL = $1802;
- { PixelFormat }
- GL_STENCIL_INDEX = $1901;
- GL_DEPTH_COMPONENT = $1902;
- GL_RED = $1903;
- GL_GREEN = $1904;
- GL_BLUE = $1905;
- GL_ALPHA = $1906;
- GL_RGB = $1907;
- GL_RGBA = $1908;
- { PolygonMode }
- GL_POINT = $1B00;
- GL_LINE = $1B01;
- GL_FILL = $1B02;
- { StencilOp }
- GL_KEEP = $1E00;
- GL_REPLACE = $1E01;
- GL_INCR = $1E02;
- GL_DECR = $1E03;
- { StringName }
- GL_VENDOR = $1F00;
- GL_RENDERER = $1F01;
- GL_VERSION = $1F02;
- GL_EXTENSIONS = $1F03;
- { TextureMagFilter }
- GL_NEAREST = $2600;
- GL_LINEAR = $2601;
- { TextureMinFilter }
- GL_NEAREST_MIPMAP_NEAREST = $2700;
- GL_LINEAR_MIPMAP_NEAREST = $2701;
- GL_NEAREST_MIPMAP_LINEAR = $2702;
- GL_LINEAR_MIPMAP_LINEAR = $2703;
- { TextureParameterName }
- GL_TEXTURE_MAG_FILTER = $2800;
- GL_TEXTURE_MIN_FILTER = $2801;
- GL_TEXTURE_WRAP_S = $2802;
- GL_TEXTURE_WRAP_T = $2803;
- { TextureTarget }
- GL_PROXY_TEXTURE_1D = $8063;
- GL_PROXY_TEXTURE_2D = $8064;
- { TextureWrapMode }
- GL_REPEAT = $2901;
- { PixelInternalFormat }
- GL_R3_G3_B2 = $2A10;
- GL_RGB4 = $804F;
- GL_RGB5 = $8050;
- GL_RGB8 = $8051;
- GL_RGB10 = $8052;
- GL_RGB12 = $8053;
- GL_RGB16 = $8054;
- GL_RGBA2 = $8055;
- GL_RGBA4 = $8056;
- GL_RGB5_A1 = $8057;
- GL_RGBA8 = $8058;
- GL_RGB10_A2 = $8059;
- GL_RGBA12 = $805A;
- GL_RGBA16 = $805B;
-{$ifdef DGL_DEPRECATED}
- GL_ACCUM = $0100;
- GL_LOAD = $0101;
- GL_RETURN = $0102;
- GL_MULT = $0103;
- GL_ADD = $0104;
- GL_CURRENT_BIT = $00000001;
- GL_POINT_BIT = $00000002;
- GL_LINE_BIT = $00000004;
- GL_POLYGON_BIT = $00000008;
- GL_POLYGON_STIPPLE_BIT = $00000010;
- GL_PIXEL_MODE_BIT = $00000020;
- GL_LIGHTING_BIT = $00000040;
- GL_FOG_BIT = $00000080;
- GL_ACCUM_BUFFER_BIT = $00000200;
- GL_VIEWPORT_BIT = $00000800;
- GL_TRANSFORM_BIT = $00001000;
- GL_ENABLE_BIT = $00002000;
- GL_HINT_BIT = $00008000;
- GL_EVAL_BIT = $00010000;
- GL_LIST_BIT = $00020000;
- GL_TEXTURE_BIT = $00040000;
- GL_SCISSOR_BIT = $00080000;
- GL_ALL_ATTRIB_BITS = $000FFFFF;
- GL_QUADS = $0007;
- GL_QUAD_STRIP = $0008;
- GL_POLYGON = $0009;
- GL_CLIP_PLANE0 = $3000;
- GL_CLIP_PLANE1 = $3001;
- GL_CLIP_PLANE2 = $3002;
- GL_CLIP_PLANE3 = $3003;
- GL_CLIP_PLANE4 = $3004;
- GL_CLIP_PLANE5 = $3005;
- GL_2_BYTES = $1407;
- GL_3_BYTES = $1408;
- GL_4_BYTES = $1409;
- GL_AUX0 = $0409;
- GL_AUX1 = $040A;
- GL_AUX2 = $040B;
- GL_AUX3 = $040C;
- GL_STACK_OVERFLOW = $0503;
- GL_STACK_UNDERFLOW = $0504;
- GL_2D = $0600;
- GL_3D = $0601;
- GL_3D_COLOR = $0602;
- GL_3D_COLOR_TEXTURE = $0603;
- GL_4D_COLOR_TEXTURE = $0604;
- GL_PASS_THROUGH_TOKEN = $0700;
- GL_POINT_TOKEN = $0701;
- GL_LINE_TOKEN = $0702;
- GL_POLYGON_TOKEN = $0703;
- GL_BITMAP_TOKEN = $0704;
- GL_DRAW_PIXEL_TOKEN = $0705;
- GL_COPY_PIXEL_TOKEN = $0706;
- GL_LINE_RESET_TOKEN = $0707;
- GL_EXP = $0800;
- GL_EXP2 = $0801;
- GL_COEFF = $0A00;
- GL_ORDER = $0A01;
- GL_DOMAIN = $0A02;
- GL_CURRENT_COLOR = $0B00;
- GL_CURRENT_INDEX = $0B01;
- GL_CURRENT_NORMAL = $0B02;
- GL_CURRENT_TEXTURE_COORDS = $0B03;
- GL_CURRENT_RASTER_COLOR = $0B04;
- GL_CURRENT_RASTER_INDEX = $0B05;
- GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06;
- GL_CURRENT_RASTER_POSITION = $0B07;
- GL_CURRENT_RASTER_POSITION_VALID = $0B08;
- GL_CURRENT_RASTER_DISTANCE = $0B09;
- GL_POINT_SMOOTH = $0B10;
- GL_LINE_STIPPLE = $0B24;
- GL_LINE_STIPPLE_PATTERN = $0B25;
- GL_LINE_STIPPLE_REPEAT = $0B26;
- GL_LIST_MODE = $0B30;
- GL_MAX_LIST_NESTING = $0B31;
- GL_LIST_BASE = $0B32;
- GL_LIST_INDEX = $0B33;
- GL_POLYGON_MODE = $0B40;
- GL_POLYGON_STIPPLE = $0B42;
- GL_EDGE_FLAG = $0B43;
- GL_LIGHTING = $0B50;
- GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51;
- GL_LIGHT_MODEL_TWO_SIDE = $0B52;
- GL_LIGHT_MODEL_AMBIENT = $0B53;
- GL_SHADE_MODEL = $0B54;
- GL_COLOR_MATERIAL_FACE = $0B55;
- GL_COLOR_MATERIAL_PARAMETER = $0B56;
- GL_COLOR_MATERIAL = $0B57;
- GL_FOG = $0B60;
- GL_FOG_INDEX = $0B61;
- GL_FOG_DENSITY = $0B62;
- GL_FOG_START = $0B63;
- GL_FOG_END = $0B64;
- GL_FOG_MODE = $0B65;
- GL_FOG_COLOR = $0B66;
- GL_ACCUM_CLEAR_VALUE = $0B80;
- GL_MATRIX_MODE = $0BA0;
- GL_NORMALIZE = $0BA1;
- GL_MODELVIEW_STACK_DEPTH = $0BA3;
- GL_PROJECTION_STACK_DEPTH = $0BA4;
- GL_TEXTURE_STACK_DEPTH = $0BA5;
- GL_MODELVIEW_MATRIX = $0BA6;
- GL_PROJECTION_MATRIX = $0BA7;
- GL_TEXTURE_MATRIX = $0BA8;
- GL_ATTRIB_STACK_DEPTH = $0BB0;
- GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1;
- GL_ALPHA_TEST = $0BC0;
- GL_ALPHA_TEST_FUNC = $0BC1;
- GL_ALPHA_TEST_REF = $0BC2;
- GL_INDEX_LOGIC_OP = $0BF1;
- GL_AUX_BUFFERS = $0C00;
- GL_INDEX_CLEAR_VALUE = $0C20;
- GL_INDEX_WRITEMASK = $0C21;
- GL_INDEX_MODE = $0C30;
- GL_RGBA_MODE = $0C31;
- GL_RENDER_MODE = $0C40;
- GL_PERSPECTIVE_CORRECTION_HINT = $0C50;
- GL_POINT_SMOOTH_HINT = $0C51;
- GL_FOG_HINT = $0C54;
- GL_TEXTURE_GEN_S = $0C60;
- GL_TEXTURE_GEN_T = $0C61;
- GL_TEXTURE_GEN_R = $0C62;
- GL_TEXTURE_GEN_Q = $0C63;
- GL_PIXEL_MAP_I_TO_I = $0C70;
- GL_PIXEL_MAP_S_TO_S = $0C71;
- GL_PIXEL_MAP_I_TO_R = $0C72;
- GL_PIXEL_MAP_I_TO_G = $0C73;
- GL_PIXEL_MAP_I_TO_B = $0C74;
- GL_PIXEL_MAP_I_TO_A = $0C75;
- GL_PIXEL_MAP_R_TO_R = $0C76;
- GL_PIXEL_MAP_G_TO_G = $0C77;
- GL_PIXEL_MAP_B_TO_B = $0C78;
- GL_PIXEL_MAP_A_TO_A = $0C79;
- GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0;
- GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1;
- GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2;
- GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3;
- GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4;
- GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5;
- GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6;
- GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7;
- GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8;
- GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9;
- GL_MAP_COLOR = $0D10;
- GL_MAP_STENCIL = $0D11;
- GL_INDEX_SHIFT = $0D12;
- GL_INDEX_OFFSET = $0D13;
- GL_RED_SCALE = $0D14;
- GL_RED_BIAS = $0D15;
- GL_ZOOM_X = $0D16;
- GL_ZOOM_Y = $0D17;
- GL_GREEN_SCALE = $0D18;
- GL_GREEN_BIAS = $0D19;
- GL_BLUE_SCALE = $0D1A;
- GL_BLUE_BIAS = $0D1B;
- GL_ALPHA_SCALE = $0D1C;
- GL_ALPHA_BIAS = $0D1D;
- GL_DEPTH_SCALE = $0D1E;
- GL_DEPTH_BIAS = $0D1F;
- GL_MAX_EVAL_ORDER = $0D30;
- GL_MAX_LIGHTS = $0D31;
- GL_MAX_CLIP_PLANES = $0D32;
- GL_MAX_PIXEL_MAP_TABLE = $0D34;
- GL_MAX_ATTRIB_STACK_DEPTH = $0D35;
- GL_MAX_MODELVIEW_STACK_DEPTH = $0D36;
- GL_MAX_NAME_STACK_DEPTH = $0D37;
- GL_MAX_PROJECTION_STACK_DEPTH = $0D38;
- GL_MAX_TEXTURE_STACK_DEPTH = $0D39;
- GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B;
- GL_INDEX_BITS = $0D51;
- GL_RED_BITS = $0D52;
- GL_GREEN_BITS = $0D53;
- GL_BLUE_BITS = $0D54;
- GL_ALPHA_BITS = $0D55;
- GL_DEPTH_BITS = $0D56;
- GL_STENCIL_BITS = $0D57;
- GL_ACCUM_RED_BITS = $0D58;
- GL_ACCUM_GREEN_BITS = $0D59;
- GL_ACCUM_BLUE_BITS = $0D5A;
- GL_ACCUM_ALPHA_BITS = $0D5B;
- GL_NAME_STACK_DEPTH = $0D70;
- GL_AUTO_NORMAL = $0D80;
- GL_MAP1_COLOR_4 = $0D90;
- GL_MAP1_INDEX = $0D91;
- GL_MAP1_NORMAL = $0D92;
- GL_MAP1_TEXTURE_COORD_1 = $0D93;
- GL_MAP1_TEXTURE_COORD_2 = $0D94;
- GL_MAP1_TEXTURE_COORD_3 = $0D95;
- GL_MAP1_TEXTURE_COORD_4 = $0D96;
- GL_MAP1_VERTEX_3 = $0D97;
- GL_MAP1_VERTEX_4 = $0D98;
- GL_MAP2_COLOR_4 = $0DB0;
- GL_MAP2_INDEX = $0DB1;
- GL_MAP2_NORMAL = $0DB2;
- GL_MAP2_TEXTURE_COORD_1 = $0DB3;
- GL_MAP2_TEXTURE_COORD_2 = $0DB4;
- GL_MAP2_TEXTURE_COORD_3 = $0DB5;
- GL_MAP2_TEXTURE_COORD_4 = $0DB6;
- GL_MAP2_VERTEX_3 = $0DB7;
- GL_MAP2_VERTEX_4 = $0DB8;
- GL_MAP1_GRID_DOMAIN = $0DD0;
- GL_MAP1_GRID_SEGMENTS = $0DD1;
- GL_MAP2_GRID_DOMAIN = $0DD2;
- GL_MAP2_GRID_SEGMENTS = $0DD3;
- GL_FEEDBACK_BUFFER_POINTER = $0DF0;
- GL_FEEDBACK_BUFFER_SIZE = $0DF1;
- GL_FEEDBACK_BUFFER_TYPE = $0DF2;
- GL_SELECTION_BUFFER_POINTER = $0DF3;
- GL_SELECTION_BUFFER_SIZE = $0DF4;
- GL_LIGHT0 = $4000;
- GL_LIGHT1 = $4001;
- GL_LIGHT2 = $4002;
- GL_LIGHT3 = $4003;
- GL_LIGHT4 = $4004;
- GL_LIGHT5 = $4005;
- GL_LIGHT6 = $4006;
- GL_LIGHT7 = $4007;
- GL_AMBIENT = $1200;
- GL_DIFFUSE = $1201;
- GL_SPECULAR = $1202;
- GL_POSITION = $1203;
- GL_SPOT_DIRECTION = $1204;
- GL_SPOT_EXPONENT = $1205;
- GL_SPOT_CUTOFF = $1206;
- GL_CONSTANT_ATTENUATION = $1207;
- GL_LINEAR_ATTENUATION = $1208;
- GL_QUADRATIC_ATTENUATION = $1209;
- GL_COMPILE = $1300;
- GL_COMPILE_AND_EXECUTE = $1301;
- GL_EMISSION = $1600;
- GL_SHININESS = $1601;
- GL_AMBIENT_AND_DIFFUSE = $1602;
- GL_COLOR_INDEXES = $1603;
- GL_MODELVIEW = $1700;
- GL_PROJECTION = $1701;
- GL_COLOR_INDEX = $1900;
- GL_LUMINANCE = $1909;
- GL_LUMINANCE_ALPHA = $190A;
- GL_BITMAP = $1A00;
- GL_RENDER = $1C00;
- GL_FEEDBACK = $1C01;
- GL_SELECT = $1C02;
- GL_FLAT = $1D00;
- GL_SMOOTH = $1D01;
- GL_S = $2000;
- GL_T = $2001;
- GL_R = $2002;
- GL_Q = $2003;
- GL_MODULATE = $2100;
- GL_DECAL = $2101;
- GL_TEXTURE_ENV_MODE = $2200;
- GL_TEXTURE_ENV_COLOR = $2201;
- GL_TEXTURE_ENV = $2300;
- GL_EYE_LINEAR = $2400;
- GL_OBJECT_LINEAR = $2401;
- GL_SPHERE_MAP = $2402;
- GL_TEXTURE_GEN_MODE = $2500;
- GL_OBJECT_PLANE = $2501;
- GL_EYE_PLANE = $2502;
- GL_CLAMP = $2900;
- GL_CLIENT_PIXEL_STORE_BIT = $00000001;
- GL_CLIENT_VERTEX_ARRAY_BIT = $00000002;
- GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF;
- GL_ALPHA4 = $803B;
- GL_ALPHA8 = $803C;
- GL_ALPHA12 = $803D;
- GL_ALPHA16 = $803E;
- GL_LUMINANCE4 = $803F;
- GL_LUMINANCE8 = $8040;
- GL_LUMINANCE12 = $8041;
- GL_LUMINANCE16 = $8042;
- GL_LUMINANCE4_ALPHA4 = $8043;
- GL_LUMINANCE6_ALPHA2 = $8044;
- GL_LUMINANCE8_ALPHA8 = $8045;
- GL_LUMINANCE12_ALPHA4 = $8046;
- GL_LUMINANCE12_ALPHA12 = $8047;
- GL_LUMINANCE16_ALPHA16 = $8048;
- GL_INTENSITY = $8049;
- GL_INTENSITY4 = $804A;
- GL_INTENSITY8 = $804B;
- GL_INTENSITY12 = $804C;
- GL_INTENSITY16 = $804D;
- GL_TEXTURE_LUMINANCE_SIZE = $8060;
- GL_TEXTURE_INTENSITY_SIZE = $8061;
- GL_TEXTURE_PRIORITY = $8066;
- GL_TEXTURE_RESIDENT = $8067;
- GL_VERTEX_ARRAY = $8074;
- GL_NORMAL_ARRAY = $8075;
- GL_COLOR_ARRAY = $8076;
- GL_INDEX_ARRAY = $8077;
- GL_TEXTURE_COORD_ARRAY = $8078;
- GL_EDGE_FLAG_ARRAY = $8079;
- GL_VERTEX_ARRAY_SIZE = $807A;
- GL_VERTEX_ARRAY_TYPE = $807B;
- GL_VERTEX_ARRAY_STRIDE = $807C;
- GL_NORMAL_ARRAY_TYPE = $807E;
- GL_NORMAL_ARRAY_STRIDE = $807F;
- GL_COLOR_ARRAY_SIZE = $8081;
- GL_COLOR_ARRAY_TYPE = $8082;
- GL_COLOR_ARRAY_STRIDE = $8083;
- GL_INDEX_ARRAY_TYPE = $8085;
- GL_INDEX_ARRAY_STRIDE = $8086;
- GL_TEXTURE_COORD_ARRAY_SIZE = $8088;
- GL_TEXTURE_COORD_ARRAY_TYPE = $8089;
- GL_TEXTURE_COORD_ARRAY_STRIDE = $808A;
- GL_EDGE_FLAG_ARRAY_STRIDE = $808C;
- GL_VERTEX_ARRAY_POINTER = $808E;
- GL_NORMAL_ARRAY_POINTER = $808F;
- GL_COLOR_ARRAY_POINTER = $8090;
- GL_INDEX_ARRAY_POINTER = $8091;
- GL_TEXTURE_COORD_ARRAY_POINTER = $8092;
- GL_EDGE_FLAG_ARRAY_POINTER = $8093;
- GL_V2F = $2A20;
- GL_V3F = $2A21;
- GL_C4UB_V2F = $2A22;
- GL_C4UB_V3F = $2A23;
- GL_C3F_V3F = $2A24;
- GL_N3F_V3F = $2A25;
- GL_C4F_N3F_V3F = $2A26;
- GL_T2F_V3F = $2A27;
- GL_T4F_V4F = $2A28;
- GL_T2F_C4UB_V3F = $2A29;
- GL_T2F_C3F_V3F = $2A2A;
- GL_T2F_N3F_V3F = $2A2B;
- GL_T2F_C4F_N3F_V3F = $2A2C;
- GL_T4F_C4F_N3F_V4F = $2A2D;
- GL_COLOR_TABLE_FORMAT_EXT = $80D8;
- GL_COLOR_TABLE_WIDTH_EXT = $80D9;
- GL_COLOR_TABLE_RED_SIZE_EXT = $80DA;
- GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB;
- GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC;
- GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD;
- GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE;
- GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF;
- GL_LOGIC_OP = GL_INDEX_LOGIC_OP;
- GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT;
-{$endif}
-
- // GL_VERSION_1_2
- GL_UNSIGNED_BYTE_3_3_2 = $8032;
- GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
- GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
- GL_UNSIGNED_INT_8_8_8_8 = $8035;
- GL_UNSIGNED_INT_10_10_10_2 = $8036;
- GL_TEXTURE_BINDING_3D = $806A;
- GL_PACK_SKIP_IMAGES = $806B;
- GL_PACK_IMAGE_HEIGHT = $806C;
- GL_UNPACK_SKIP_IMAGES = $806D;
- GL_UNPACK_IMAGE_HEIGHT = $806E;
- GL_TEXTURE_3D = $806F;
- GL_PROXY_TEXTURE_3D = $8070;
- GL_TEXTURE_DEPTH = $8071;
- GL_TEXTURE_WRAP_R = $8072;
- GL_MAX_3D_TEXTURE_SIZE = $8073;
- GL_UNSIGNED_BYTE_2_3_3_REV = $8362;
- GL_UNSIGNED_SHORT_5_6_5 = $8363;
- GL_UNSIGNED_SHORT_5_6_5_REV = $8364;
- GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365;
- GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366;
- GL_UNSIGNED_INT_8_8_8_8_REV = $8367;
- GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
- GL_BGR = $80E0;
- GL_BGRA = $80E1;
- GL_MAX_ELEMENTS_VERTICES = $80E8;
- GL_MAX_ELEMENTS_INDICES = $80E9;
- GL_CLAMP_TO_EDGE = $812F;
- GL_TEXTURE_MIN_LOD = $813A;
- GL_TEXTURE_MAX_LOD = $813B;
- GL_TEXTURE_BASE_LEVEL = $813C;
- GL_TEXTURE_MAX_LEVEL = $813D;
- GL_SMOOTH_POINT_SIZE_RANGE = $0B12;
- GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13;
- GL_SMOOTH_LINE_WIDTH_RANGE = $0B22;
- GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23;
- GL_ALIASED_LINE_WIDTH_RANGE = $846E;
-{$ifdef DGL_DEPRECATED}
- GL_RESCALE_NORMAL = $803A;
- GL_LIGHT_MODEL_COLOR_CONTROL = $81F8;
- GL_SINGLE_COLOR = $81F9;
- GL_SEPARATE_SPECULAR_COLOR = $81FA;
- GL_ALIASED_POINT_SIZE_RANGE = $846D;
-{$endif}
-
- // GL_VERSION_1_3
- GL_TEXTURE0 = $84C0;
- GL_TEXTURE1 = $84C1;
- GL_TEXTURE2 = $84C2;
- GL_TEXTURE3 = $84C3;
- GL_TEXTURE4 = $84C4;
- GL_TEXTURE5 = $84C5;
- GL_TEXTURE6 = $84C6;
- GL_TEXTURE7 = $84C7;
- GL_TEXTURE8 = $84C8;
- GL_TEXTURE9 = $84C9;
- GL_TEXTURE10 = $84CA;
- GL_TEXTURE11 = $84CB;
- GL_TEXTURE12 = $84CC;
- GL_TEXTURE13 = $84CD;
- GL_TEXTURE14 = $84CE;
- GL_TEXTURE15 = $84CF;
- GL_TEXTURE16 = $84D0;
- GL_TEXTURE17 = $84D1;
- GL_TEXTURE18 = $84D2;
- GL_TEXTURE19 = $84D3;
- GL_TEXTURE20 = $84D4;
- GL_TEXTURE21 = $84D5;
- GL_TEXTURE22 = $84D6;
- GL_TEXTURE23 = $84D7;
- GL_TEXTURE24 = $84D8;
- GL_TEXTURE25 = $84D9;
- GL_TEXTURE26 = $84DA;
- GL_TEXTURE27 = $84DB;
- GL_TEXTURE28 = $84DC;
- GL_TEXTURE29 = $84DD;
- GL_TEXTURE30 = $84DE;
- GL_TEXTURE31 = $84DF;
- GL_ACTIVE_TEXTURE = $84E0;
- GL_MULTISAMPLE = $809D;
- GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
- GL_SAMPLE_ALPHA_TO_ONE = $809F;
- GL_SAMPLE_COVERAGE = $80A0;
- GL_SAMPLE_BUFFERS = $80A8;
- GL_SAMPLES = $80A9;
- GL_SAMPLE_COVERAGE_VALUE = $80AA;
- GL_SAMPLE_COVERAGE_INVERT = $80AB;
- GL_TEXTURE_CUBE_MAP = $8513;
- GL_TEXTURE_BINDING_CUBE_MAP = $8514;
- GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
- GL_PROXY_TEXTURE_CUBE_MAP = $851B;
- GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
- GL_COMPRESSED_RGB = $84ED;
- GL_COMPRESSED_RGBA = $84EE;
- GL_TEXTURE_COMPRESSION_HINT = $84EF;
- GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0;
- GL_TEXTURE_COMPRESSED = $86A1;
- GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
- GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
- GL_CLAMP_TO_BORDER = $812D;
-{$ifdef DGL_DEPRECATED}
- GL_CLIENT_ACTIVE_TEXTURE = $84E1;
- GL_MAX_TEXTURE_UNITS = $84E2;
- GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3;
- GL_TRANSPOSE_PROJECTION_MATRIX = $84E4;
- GL_TRANSPOSE_TEXTURE_MATRIX = $84E5;
- GL_TRANSPOSE_COLOR_MATRIX = $84E6;
- GL_MULTISAMPLE_BIT = $20000000;
- GL_NORMAL_MAP = $8511;
- GL_REFLECTION_MAP = $8512;
- GL_COMPRESSED_ALPHA = $84E9;
- GL_COMPRESSED_LUMINANCE = $84EA;
- GL_COMPRESSED_LUMINANCE_ALPHA = $84EB;
- GL_COMPRESSED_INTENSITY = $84EC;
- GL_COMBINE = $8570;
- GL_COMBINE_RGB = $8571;
- GL_COMBINE_ALPHA = $8572;
- GL_SOURCE0_RGB = $8580;
- GL_SOURCE1_RGB = $8581;
- GL_SOURCE2_RGB = $8582;
- GL_SOURCE0_ALPHA = $8588;
- GL_SOURCE1_ALPHA = $8589;
- GL_SOURCE2_ALPHA = $858A;
- GL_OPERAND0_RGB = $8590;
- GL_OPERAND1_RGB = $8591;
- GL_OPERAND2_RGB = $8592;
- GL_OPERAND0_ALPHA = $8598;
- GL_OPERAND1_ALPHA = $8599;
- GL_OPERAND2_ALPHA = $859A;
- GL_RGB_SCALE = $8573;
- GL_ADD_SIGNED = $8574;
- GL_INTERPOLATE = $8575;
- GL_SUBTRACT = $84E7;
- GL_CONSTANT = $8576;
- GL_PRIMARY_COLOR = $8577;
- GL_PREVIOUS = $8578;
- GL_DOT3_RGB = $86AE;
- GL_DOT3_RGBA = $86AF;
-{$endif}
-
- // GL_VERSION_1_4
- GL_BLEND_DST_RGB = $80C8;
- GL_BLEND_SRC_RGB = $80C9;
- GL_BLEND_DST_ALPHA = $80CA;
- GL_BLEND_SRC_ALPHA = $80CB;
- GL_POINT_FADE_THRESHOLD_SIZE = $8128;
- GL_DEPTH_COMPONENT16 = $81A5;
- GL_DEPTH_COMPONENT24 = $81A6;
- GL_DEPTH_COMPONENT32 = $81A7;
- GL_MIRRORED_REPEAT = $8370;
- GL_MAX_TEXTURE_LOD_BIAS = $84FD;
- GL_TEXTURE_LOD_BIAS = $8501;
- GL_INCR_WRAP = $8507;
- GL_DECR_WRAP = $8508;
- GL_TEXTURE_DEPTH_SIZE = $884A;
- GL_TEXTURE_COMPARE_MODE = $884C;
- GL_TEXTURE_COMPARE_FUNC = $884D;
-{$ifdef DGL_DEPRECATED}
- GL_POINT_SIZE_MIN = $8126;
- GL_POINT_SIZE_MAX = $8127;
- GL_POINT_DISTANCE_ATTENUATION = $8129;
- GL_GENERATE_MIPMAP = $8191;
- GL_GENERATE_MIPMAP_HINT = $8192;
- GL_FOG_COORDINATE_SOURCE = $8450;
- GL_FOG_COORDINATE = $8451;
- GL_FRAGMENT_DEPTH = $8452;
- GL_CURRENT_FOG_COORDINATE = $8453;
- GL_FOG_COORDINATE_ARRAY_TYPE = $8454;
- GL_FOG_COORDINATE_ARRAY_STRIDE = $8455;
- GL_FOG_COORDINATE_ARRAY_POINTER = $8456;
- GL_FOG_COORDINATE_ARRAY = $8457;
- GL_COLOR_SUM = $8458;
- GL_CURRENT_SECONDARY_COLOR = $8459;
- GL_SECONDARY_COLOR_ARRAY_SIZE = $845A;
- GL_SECONDARY_COLOR_ARRAY_TYPE = $845B;
- GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C;
- GL_SECONDARY_COLOR_ARRAY_POINTER = $845D;
- GL_SECONDARY_COLOR_ARRAY = $845E;
- GL_TEXTURE_FILTER_CONTROL = $8500;
- GL_DEPTH_TEXTURE_MODE = $884B;
- GL_COMPARE_R_TO_TEXTURE = $884E;
-{$endif}
-
- // GL_VERSION_1_5
- GL_BUFFER_SIZE = $8764;
- GL_BUFFER_USAGE = $8765;
- GL_QUERY_COUNTER_BITS = $8864;
- GL_CURRENT_QUERY = $8865;
- GL_QUERY_RESULT = $8866;
- GL_QUERY_RESULT_AVAILABLE = $8867;
- GL_ARRAY_BUFFER = $8892;
- GL_ELEMENT_ARRAY_BUFFER = $8893;
- GL_ARRAY_BUFFER_BINDING = $8894;
- GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
- GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;
- GL_READ_ONLY = $88B8;
- GL_WRITE_ONLY = $88B9;
- GL_READ_WRITE = $88BA;
- GL_BUFFER_ACCESS = $88BB;
- GL_BUFFER_MAPPED = $88BC;
- GL_BUFFER_MAP_POINTER = $88BD;
- GL_STREAM_DRAW = $88E0;
- GL_STREAM_READ = $88E1;
- GL_STREAM_COPY = $88E2;
- GL_STATIC_DRAW = $88E4;
- GL_STATIC_READ = $88E5;
- GL_STATIC_COPY = $88E6;
- GL_DYNAMIC_DRAW = $88E8;
- GL_DYNAMIC_READ = $88E9;
- GL_DYNAMIC_COPY = $88EA;
- GL_SAMPLES_PASSED = $8914;
-{$ifdef DGL_DEPRECATED}
- GL_VERTEX_ARRAY_BUFFER_BINDING = $8896;
- GL_NORMAL_ARRAY_BUFFER_BINDING = $8897;
- GL_COLOR_ARRAY_BUFFER_BINDING = $8898;
- GL_INDEX_ARRAY_BUFFER_BINDING = $8899;
- GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A;
- GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B;
- GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C;
- GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D;
- GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E;
- GL_FOG_COORD_SRC = $8450;
- GL_FOG_COORD = $8451;
- GL_CURRENT_FOG_COORD = $8453;
- GL_FOG_COORD_ARRAY_TYPE = $8454;
- GL_FOG_COORD_ARRAY_STRIDE = $8455;
- GL_FOG_COORD_ARRAY_POINTER = $8456;
- GL_FOG_COORD_ARRAY = $8457;
- GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D;
- GL_SRC0_RGB = $8580;
- GL_SRC1_RGB = $8581;
- GL_SRC2_RGB = $8582;
- GL_SRC0_ALPHA = $8588;
- GL_SRC1_ALPHA = $8589;
- GL_SRC2_ALPHA = $858A;
-{$endif}
-
- // GL_VERSION_2_0
- GL_BLEND_EQUATION_RGB = $8009;
- GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;
- GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;
- GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;
- GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;
- GL_CURRENT_VERTEX_ATTRIB = $8626;
- GL_VERTEX_PROGRAM_POINT_SIZE = $8642;
- GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;
- GL_STENCIL_BACK_FUNC = $8800;
- GL_STENCIL_BACK_FAIL = $8801;
- GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;
- GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;
- GL_MAX_DRAW_BUFFERS = $8824;
- GL_DRAW_BUFFER0 = $8825;
- GL_DRAW_BUFFER1 = $8826;
- GL_DRAW_BUFFER2 = $8827;
- GL_DRAW_BUFFER3 = $8828;
- GL_DRAW_BUFFER4 = $8829;
- GL_DRAW_BUFFER5 = $882A;
- GL_DRAW_BUFFER6 = $882B;
- GL_DRAW_BUFFER7 = $882C;
- GL_DRAW_BUFFER8 = $882D;
- GL_DRAW_BUFFER9 = $882E;
- GL_DRAW_BUFFER10 = $882F;
- GL_DRAW_BUFFER11 = $8830;
- GL_DRAW_BUFFER12 = $8831;
- GL_DRAW_BUFFER13 = $8832;
- GL_DRAW_BUFFER14 = $8833;
- GL_DRAW_BUFFER15 = $8834;
- GL_BLEND_EQUATION_ALPHA = $883D;
- GL_MAX_VERTEX_ATTRIBS = $8869;
- GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;
- GL_MAX_TEXTURE_IMAGE_UNITS = $8872;
- GL_FRAGMENT_SHADER = $8B30;
- GL_VERTEX_SHADER = $8B31;
- GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;
- GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;
- GL_MAX_VARYING_FLOATS = $8B4B;
- GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;
- GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;
- GL_SHADER_TYPE = $8B4F;
- GL_FLOAT_VEC2 = $8B50;
- GL_FLOAT_VEC3 = $8B51;
- GL_FLOAT_VEC4 = $8B52;
- GL_INT_VEC2 = $8B53;
- GL_INT_VEC3 = $8B54;
- GL_INT_VEC4 = $8B55;
- GL_BOOL = $8B56;
- GL_BOOL_VEC2 = $8B57;
- GL_BOOL_VEC3 = $8B58;
- GL_BOOL_VEC4 = $8B59;
- GL_FLOAT_MAT2 = $8B5A;
- GL_FLOAT_MAT3 = $8B5B;
- GL_FLOAT_MAT4 = $8B5C;
- GL_SAMPLER_1D = $8B5D;
- GL_SAMPLER_2D = $8B5E;
- GL_SAMPLER_3D = $8B5F;
- GL_SAMPLER_CUBE = $8B60;
- GL_SAMPLER_1D_SHADOW = $8B61;
- GL_SAMPLER_2D_SHADOW = $8B62;
- GL_DELETE_STATUS = $8B80;
- GL_COMPILE_STATUS = $8B81;
- GL_LINK_STATUS = $8B82;
- GL_VALIDATE_STATUS = $8B83;
- GL_INFO_LOG_LENGTH = $8B84;
- GL_ATTACHED_SHADERS = $8B85;
- GL_ACTIVE_UNIFORMS = $8B86;
- GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;
- GL_SHADER_SOURCE_LENGTH = $8B88;
- GL_ACTIVE_ATTRIBUTES = $8B89;
- GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;
- GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;
- GL_SHADING_LANGUAGE_VERSION = $8B8C;
- GL_CURRENT_PROGRAM = $8B8D;
- GL_POINT_SPRITE_COORD_ORIGIN = $8CA0;
- GL_LOWER_LEFT = $8CA1;
- GL_UPPER_LEFT = $8CA2;
- GL_STENCIL_BACK_REF = $8CA3;
- GL_STENCIL_BACK_VALUE_MASK = $8CA4;
- GL_STENCIL_BACK_WRITEMASK = $8CA5;
-{$ifdef DGL_DEPRECATED}
- GL_VERTEX_PROGRAM_TWO_SIDE = $8643;
- GL_POINT_SPRITE = $8861;
- GL_COORD_REPLACE = $8862;
- GL_MAX_TEXTURE_COORDS = $8871;
-{$endif}
-
- // GL_VERSION_2_1
- GL_PIXEL_PACK_BUFFER = $88EB;
- GL_PIXEL_UNPACK_BUFFER = $88EC;
- GL_PIXEL_PACK_BUFFER_BINDING = $88ED;
- GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF;
- GL_FLOAT_MAT2x3 = $8B65;
- GL_FLOAT_MAT2x4 = $8B66;
- GL_FLOAT_MAT3x2 = $8B67;
- GL_FLOAT_MAT3x4 = $8B68;
- GL_FLOAT_MAT4x2 = $8B69;
- GL_FLOAT_MAT4x3 = $8B6A;
- GL_SRGB = $8C40;
- GL_SRGB8 = $8C41;
- GL_SRGB_ALPHA = $8C42;
- GL_SRGB8_ALPHA8 = $8C43;
- GL_COMPRESSED_SRGB = $8C48;
- GL_COMPRESSED_SRGB_ALPHA = $8C49;
-{$ifdef DGL_DEPRECATED}
- GL_CURRENT_RASTER_SECONDARY_COLOR = $845F;
- GL_SLUMINANCE_ALPHA = $8C44;
- GL_SLUMINANCE8_ALPHA8 = $8C45;
- GL_SLUMINANCE = $8C46;
- GL_SLUMINANCE8 = $8C47;
- GL_COMPRESSED_SLUMINANCE = $8C4A;
- GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B;
-{$endif}
-
- // GL_VERSION_3_0
- GL_COMPARE_REF_TO_TEXTURE = $884E;
- GL_CLIP_DISTANCE0 = $3000;
- GL_CLIP_DISTANCE1 = $3001;
- GL_CLIP_DISTANCE2 = $3002;
- GL_CLIP_DISTANCE3 = $3003;
- GL_CLIP_DISTANCE4 = $3004;
- GL_CLIP_DISTANCE5 = $3005;
- GL_CLIP_DISTANCE6 = $3006;
- GL_CLIP_DISTANCE7 = $3007;
- GL_MAX_CLIP_DISTANCES = $0D32;
- GL_MAJOR_VERSION = $821B;
- GL_MINOR_VERSION = $821C;
- GL_NUM_EXTENSIONS = $821D;
- GL_CONTEXT_FLAGS = $821E;
- GL_DEPTH_BUFFER = $8223;
- GL_STENCIL_BUFFER = $8224;
- GL_COMPRESSED_RED = $8225;
- GL_COMPRESSED_RG = $8226;
- GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001;
- GL_RGBA32F = $8814;
- GL_RGB32F = $8815;
- GL_RGBA16F = $881A;
- GL_RGB16F = $881B;
- GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD;
- GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF;
- GL_MIN_PROGRAM_TEXEL_OFFSET = $8904;
- GL_MAX_PROGRAM_TEXEL_OFFSET = $8905;
- GL_CLAMP_READ_COLOR = $891C;
- GL_FIXED_ONLY = $891D;
- GL_MAX_VARYING_COMPONENTS = $8B4B;
- GL_TEXTURE_1D_ARRAY = $8C18;
- GL_PROXY_TEXTURE_1D_ARRAY = $8C19;
- GL_TEXTURE_2D_ARRAY = $8C1A;
- GL_PROXY_TEXTURE_2D_ARRAY = $8C1B;
- GL_TEXTURE_BINDING_1D_ARRAY = $8C1C;
- GL_TEXTURE_BINDING_2D_ARRAY = $8C1D;
- GL_R11F_G11F_B10F = $8C3A;
- GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B;
- GL_RGB9_E5 = $8C3D;
- GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E;
- GL_TEXTURE_SHARED_SIZE = $8C3F;
- GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76;
- GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80;
- GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83;
- GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84;
- GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85;
- GL_PRIMITIVES_GENERATED = $8C87;
- GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88;
- GL_RASTERIZER_DISCARD = $8C89;
- GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B;
- GL_INTERLEAVED_ATTRIBS = $8C8C;
- GL_SEPARATE_ATTRIBS = $8C8D;
- GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E;
- GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F;
- GL_RGBA32UI = $8D70;
- GL_RGB32UI = $8D71;
- GL_RGBA16UI = $8D76;
- GL_RGB16UI = $8D77;
- GL_RGBA8UI = $8D7C;
- GL_RGB8UI = $8D7D;
- GL_RGBA32I = $8D82;
- GL_RGB32I = $8D83;
- GL_RGBA16I = $8D88;
- GL_RGB16I = $8D89;
- GL_RGBA8I = $8D8E;
- GL_RGB8I = $8D8F;
- GL_RED_INTEGER = $8D94;
- GL_GREEN_INTEGER = $8D95;
- GL_BLUE_INTEGER = $8D96;
- GL_RGB_INTEGER = $8D98;
- GL_RGBA_INTEGER = $8D99;
- GL_BGR_INTEGER = $8D9A;
- GL_BGRA_INTEGER = $8D9B;
- GL_SAMPLER_1D_ARRAY = $8DC0;
- GL_SAMPLER_2D_ARRAY = $8DC1;
- GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3;
- GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4;
- GL_SAMPLER_CUBE_SHADOW = $8DC5;
- GL_UNSIGNED_INT_VEC2 = $8DC6;
- GL_UNSIGNED_INT_VEC3 = $8DC7;
- GL_UNSIGNED_INT_VEC4 = $8DC8;
- GL_INT_SAMPLER_1D = $8DC9;
- GL_INT_SAMPLER_2D = $8DCA;
- GL_INT_SAMPLER_3D = $8DCB;
- GL_INT_SAMPLER_CUBE = $8DCC;
- GL_INT_SAMPLER_1D_ARRAY = $8DCE;
- GL_INT_SAMPLER_2D_ARRAY = $8DCF;
- GL_UNSIGNED_INT_SAMPLER_1D = $8DD1;
- GL_UNSIGNED_INT_SAMPLER_2D = $8DD2;
- GL_UNSIGNED_INT_SAMPLER_3D = $8DD3;
- GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4;
- GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6;
- GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7;
- GL_QUERY_WAIT = $8E13;
- GL_QUERY_NO_WAIT = $8E14;
- GL_QUERY_BY_REGION_WAIT = $8E15;
- GL_QUERY_BY_REGION_NO_WAIT = $8E16;
- GL_BUFFER_ACCESS_FLAGS = $911F;
- GL_BUFFER_MAP_LENGTH = $9120;
- GL_BUFFER_MAP_OFFSET = $9121;
- { Reuse tokens from ARB_depth_buffer_float }
- { reuse GL_DEPTH_COMPONENT32F }
- { reuse GL_DEPTH32F_STENCIL8 }
- { reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV }
- { Reuse tokens from ARB_framebuffer_object }
- { reuse GL_INVALID_FRAMEBUFFER_OPERATION }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE }
- { reuse GL_FRAMEBUFFER_DEFAULT }
- { reuse GL_FRAMEBUFFER_UNDEFINED }
- { reuse GL_DEPTH_STENCIL_ATTACHMENT }
- { reuse GL_INDEX }
- { reuse GL_MAX_RENDERBUFFER_SIZE }
- { reuse GL_DEPTH_STENCIL }
- { reuse GL_UNSIGNED_INT_24_8 }
- { reuse GL_DEPTH24_STENCIL8 }
- { reuse GL_TEXTURE_STENCIL_SIZE }
- { reuse GL_TEXTURE_RED_TYPE }
- { reuse GL_TEXTURE_GREEN_TYPE }
- { reuse GL_TEXTURE_BLUE_TYPE }
- { reuse GL_TEXTURE_ALPHA_TYPE }
- { reuse GL_TEXTURE_DEPTH_TYPE }
- { reuse GL_UNSIGNED_NORMALIZED }
- { reuse GL_FRAMEBUFFER_BINDING }
- { reuse GL_DRAW_FRAMEBUFFER_BINDING }
- { reuse GL_RENDERBUFFER_BINDING }
- { reuse GL_READ_FRAMEBUFFER }
- { reuse GL_DRAW_FRAMEBUFFER }
- { reuse GL_READ_FRAMEBUFFER_BINDING }
- { reuse GL_RENDERBUFFER_SAMPLES }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
- { reuse GL_FRAMEBUFFER_COMPLETE }
- { reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT }
- { reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT }
- { reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER }
- { reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER }
- { reuse GL_FRAMEBUFFER_UNSUPPORTED }
- { reuse GL_MAX_COLOR_ATTACHMENTS }
- { reuse GL_COLOR_ATTACHMENT0 }
- { reuse GL_COLOR_ATTACHMENT1 }
- { reuse GL_COLOR_ATTACHMENT2 }
- { reuse GL_COLOR_ATTACHMENT3 }
- { reuse GL_COLOR_ATTACHMENT4 }
- { reuse GL_COLOR_ATTACHMENT5 }
- { reuse GL_COLOR_ATTACHMENT6 }
- { reuse GL_COLOR_ATTACHMENT7 }
- { reuse GL_COLOR_ATTACHMENT8 }
- { reuse GL_COLOR_ATTACHMENT9 }
- { reuse GL_COLOR_ATTACHMENT10 }
- { reuse GL_COLOR_ATTACHMENT11 }
- { reuse GL_COLOR_ATTACHMENT12 }
- { reuse GL_COLOR_ATTACHMENT13 }
- { reuse GL_COLOR_ATTACHMENT14 }
- { reuse GL_COLOR_ATTACHMENT15 }
- { reuse GL_DEPTH_ATTACHMENT }
- { reuse GL_STENCIL_ATTACHMENT }
- { reuse GL_FRAMEBUFFER }
- { reuse GL_RENDERBUFFER }
- { reuse GL_RENDERBUFFER_WIDTH }
- { reuse GL_RENDERBUFFER_HEIGHT }
- { reuse GL_RENDERBUFFER_INTERNAL_FORMAT }
- { reuse GL_STENCIL_INDEX1 }
- { reuse GL_STENCIL_INDEX4 }
- { reuse GL_STENCIL_INDEX8 }
- { reuse GL_STENCIL_INDEX16 }
- { reuse GL_RENDERBUFFER_RED_SIZE }
- { reuse GL_RENDERBUFFER_GREEN_SIZE }
- { reuse GL_RENDERBUFFER_BLUE_SIZE }
- { reuse GL_RENDERBUFFER_ALPHA_SIZE }
- { reuse GL_RENDERBUFFER_DEPTH_SIZE }
- { reuse GL_RENDERBUFFER_STENCIL_SIZE }
- { reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE }
- { reuse GL_MAX_SAMPLES }
- { Reuse tokens from ARB_framebuffer_sRGB }
- { reuse GL_FRAMEBUFFER_SRGB }
- { Reuse tokens from ARB_half_float_vertex }
- { reuse GL_HALF_FLOAT }
- { Reuse tokens from ARB_map_buffer_range }
- { reuse GL_MAP_READ_BIT }
- { reuse GL_MAP_WRITE_BIT }
- { reuse GL_MAP_INVALIDATE_RANGE_BIT }
- { reuse GL_MAP_INVALIDATE_BUFFER_BIT }
- { reuse GL_MAP_FLUSH_EXPLICIT_BIT }
- { reuse GL_MAP_UNSYNCHRONIZED_BIT }
- { Reuse tokens from ARB_texture_compression_rgtc }
- { reuse GL_COMPRESSED_RED_RGTC1 }
- { reuse GL_COMPRESSED_SIGNED_RED_RGTC1 }
- { reuse GL_COMPRESSED_RG_RGTC2 }
- { reuse GL_COMPRESSED_SIGNED_RG_RGTC2 }
- { Reuse tokens from ARB_texture_rg }
- { reuse GL_RG }
- { reuse GL_RG_INTEGER }
- { reuse GL_R8 }
- { reuse GL_R16 }
- { reuse GL_RG8 }
- { reuse GL_RG16 }
- { reuse GL_R16F }
- { reuse GL_R32F }
- { reuse GL_RG16F }
- { reuse GL_RG32F }
- { reuse GL_R8I }
- { reuse GL_R8UI }
- { reuse GL_R16I }
- { reuse GL_R16UI }
- { reuse GL_R32I }
- { reuse GL_R32UI }
- { reuse GL_RG8I }
- { reuse GL_RG8UI }
- { reuse GL_RG16I }
- { reuse GL_RG16UI }
- { reuse GL_RG32I }
- { reuse GL_RG32UI }
- { Reuse tokens from ARB_vertex_array_object }
- { reuse GL_VERTEX_ARRAY_BINDING }
-{$ifdef DGL_DEPRECATED}
- GL_CLAMP_VERTEX_COLOR = $891A;
- GL_CLAMP_FRAGMENT_COLOR = $891B;
- GL_ALPHA_INTEGER = $8D97;
- { Reuse tokens from ARB_framebuffer_object }
- { reuse GL_TEXTURE_LUMINANCE_TYPE }
- { reuse GL_TEXTURE_INTENSITY_TYPE }
-{$endif}
-
- // GL_VERSION_3_1
- GL_SAMPLER_2D_RECT = $8B63;
- GL_SAMPLER_2D_RECT_SHADOW = $8B64;
- GL_SAMPLER_BUFFER = $8DC2;
- GL_INT_SAMPLER_2D_RECT = $8DCD;
- GL_INT_SAMPLER_BUFFER = $8DD0;
- GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5;
- GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8;
- GL_TEXTURE_BUFFER = $8C2A;
- GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B;
- GL_TEXTURE_BINDING_BUFFER = $8C2C;
- GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D;
- GL_TEXTURE_BUFFER_FORMAT = $8C2E;
- GL_TEXTURE_RECTANGLE = $84F5;
- GL_TEXTURE_BINDING_RECTANGLE = $84F6;
- GL_PROXY_TEXTURE_RECTANGLE = $84F7;
- GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8;
- GL_RED_SNORM = $8F90;
- GL_RG_SNORM = $8F91;
- GL_RGB_SNORM = $8F92;
- GL_RGBA_SNORM = $8F93;
- GL_R8_SNORM = $8F94;
- GL_RG8_SNORM = $8F95;
- GL_RGB8_SNORM = $8F96;
- GL_RGBA8_SNORM = $8F97;
- GL_R16_SNORM = $8F98;
- GL_RG16_SNORM = $8F99;
- GL_RGB16_SNORM = $8F9A;
- GL_RGBA16_SNORM = $8F9B;
- GL_SIGNED_NORMALIZED = $8F9C;
- GL_PRIMITIVE_RESTART = $8F9D;
- GL_PRIMITIVE_RESTART_INDEX = $8F9E;
- { Reuse tokens from ARB_copy_buffer }
- { reuse GL_COPY_READ_BUFFER }
- { reuse GL_COPY_WRITE_BUFFER }
- { Reuse tokens from ARB_draw_instanced (none) }
- { Reuse tokens from ARB_uniform_buffer_object }
- { reuse GL_UNIFORM_BUFFER }
- { reuse GL_UNIFORM_BUFFER_BINDING }
- { reuse GL_UNIFORM_BUFFER_START }
- { reuse GL_UNIFORM_BUFFER_SIZE }
- { reuse GL_MAX_VERTEX_UNIFORM_BLOCKS }
- { reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS }
- { reuse GL_MAX_COMBINED_UNIFORM_BLOCKS }
- { reuse GL_MAX_UNIFORM_BUFFER_BINDINGS }
- { reuse GL_MAX_UNIFORM_BLOCK_SIZE }
- { reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS }
- { reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS }
- { reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT }
- { reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH }
- { reuse GL_ACTIVE_UNIFORM_BLOCKS }
- { reuse GL_UNIFORM_TYPE }
- { reuse GL_UNIFORM_SIZE }
- { reuse GL_UNIFORM_NAME_LENGTH }
- { reuse GL_UNIFORM_BLOCK_INDEX }
- { reuse GL_UNIFORM_OFFSET }
- { reuse GL_UNIFORM_ARRAY_STRIDE }
- { reuse GL_UNIFORM_MATRIX_STRIDE }
- { reuse GL_UNIFORM_IS_ROW_MAJOR }
- { reuse GL_UNIFORM_BLOCK_BINDING }
- { reuse GL_UNIFORM_BLOCK_DATA_SIZE }
- { reuse GL_UNIFORM_BLOCK_NAME_LENGTH }
- { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS }
- { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES }
- { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER }
- { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER }
- { reuse GL_INVALID_INDEX }
-
- // GL_VERSION_3_2
- GL_CONTEXT_CORE_PROFILE_BIT = $00000001;
- GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002;
- GL_LINES_ADJACENCY = $000A;
- GL_LINE_STRIP_ADJACENCY = $000B;
- GL_TRIANGLES_ADJACENCY = $000C;
- GL_TRIANGLE_STRIP_ADJACENCY = $000D;
- GL_PROGRAM_POINT_SIZE = $8642;
- GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29;
- GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7;
- GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8;
- GL_GEOMETRY_SHADER = $8DD9;
- GL_GEOMETRY_VERTICES_OUT = $8916;
- GL_GEOMETRY_INPUT_TYPE = $8917;
- GL_GEOMETRY_OUTPUT_TYPE = $8918;
- GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF;
- GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0;
- GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1;
- GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122;
- GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123;
- GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124;
- GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125;
- GL_CONTEXT_PROFILE_MASK = $9126;
- { reuse GL_MAX_VARYING_COMPONENTS }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
- { Reuse tokens from ARB_depth_clamp }
- { reuse GL_DEPTH_CLAMP }
- { Reuse tokens from ARB_draw_elements_base_vertex (none) }
- { Reuse tokens from ARB_fragment_coord_conventions (none) }
- { Reuse tokens from ARB_provoking_vertex }
- { reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION }
- { reuse GL_FIRST_VERTEX_CONVENTION }
- { reuse GL_LAST_VERTEX_CONVENTION }
- { reuse GL_PROVOKING_VERTEX }
- { Reuse tokens from ARB_seamless_cube_map }
- { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS }
- { Reuse tokens from ARB_sync }
- { reuse GL_MAX_SERVER_WAIT_TIMEOUT }
- { reuse GL_OBJECT_TYPE }
- { reuse GL_SYNC_CONDITION }
- { reuse GL_SYNC_STATUS }
- { reuse GL_SYNC_FLAGS }
- { reuse GL_SYNC_FENCE }
- { reuse GL_SYNC_GPU_COMMANDS_COMPLETE }
- { reuse GL_UNSIGNALED }
- { reuse GL_SIGNALED }
- { reuse GL_ALREADY_SIGNALED }
- { reuse GL_TIMEOUT_EXPIRED }
- { reuse GL_CONDITION_SATISFIED }
- { reuse GL_WAIT_FAILED }
- { reuse GL_TIMEOUT_IGNORED }
- { reuse GL_SYNC_FLUSH_COMMANDS_BIT }
- { reuse GL_TIMEOUT_IGNORED }
- { Reuse tokens from ARB_texture_multisample }
- { reuse GL_SAMPLE_POSITION }
- { reuse GL_SAMPLE_MASK }
- { reuse GL_SAMPLE_MASK_VALUE }
- { reuse GL_MAX_SAMPLE_MASK_WORDS }
- { reuse GL_TEXTURE_2D_MULTISAMPLE }
- { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE }
- { reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY }
- { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY }
- { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE }
- { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY }
- { reuse GL_TEXTURE_SAMPLES }
- { reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS }
- { reuse GL_SAMPLER_2D_MULTISAMPLE }
- { reuse GL_INT_SAMPLER_2D_MULTISAMPLE }
- { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE }
- { reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY }
- { reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
- { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
- { reuse GL_MAX_COLOR_TEXTURE_SAMPLES }
- { reuse GL_MAX_DEPTH_TEXTURE_SAMPLES }
- { reuse GL_MAX_INTEGER_SAMPLES }
- { Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core }
-
- // GL_VERSION_3_3
- GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE;
- { Reuse tokens from ARB_blend_func_extended }
- { reuse GL_SRC1_COLOR }
- { reuse GL_ONE_MINUS_SRC1_COLOR }
- { reuse GL_ONE_MINUS_SRC1_ALPHA }
- { reuse GL_MAX_DUAL_SOURCE_DRAW_BUFFERS }
- { Reuse tokens from ARB_explicit_attrib_location (none) }
- { Reuse tokens from ARB_occlusion_query2 }
- { reuse GL_ANY_SAMPLES_PASSED }
- { Reuse tokens from ARB_sampler_objects }
- { reuse GL_SAMPLER_BINDING }
- { Reuse tokens from ARB_shader_bit_encoding (none) }
- { Reuse tokens from ARB_texture_rgb10_a2ui }
- { reuse GL_RGB10_A2UI }
- { Reuse tokens from ARB_texture_swizzle }
- { reuse GL_TEXTURE_SWIZZLE_R }
- { reuse GL_TEXTURE_SWIZZLE_G }
- { reuse GL_TEXTURE_SWIZZLE_B }
- { reuse GL_TEXTURE_SWIZZLE_A }
- { reuse GL_TEXTURE_SWIZZLE_RGBA }
- { Reuse tokens from ARB_timer_query }
- { reuse GL_TIME_ELAPSED }
- { reuse GL_TIMESTAMP }
- { Reuse tokens from ARB_vertex_type_2_10_10_10_rev }
- { reuse GL_INT_2_10_10_10_REV }
-
- // GL_VERSION_4_0
- GL_SAMPLE_SHADING = $8C36;
- GL_MIN_SAMPLE_SHADING_VALUE = $8C37;
- GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E;
- GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F;
- GL_TEXTURE_CUBE_MAP_ARRAY = $9009;
- GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A;
- GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B;
- GL_SAMPLER_CUBE_MAP_ARRAY = $900C;
- GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D;
- GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E;
- GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F;
- { Reuse tokens from ARB_texture_query_lod (none) }
- { Reuse tokens from ARB_draw_buffers_blend (none) }
- { Reuse tokens from ARB_draw_indirect }
- { reuse GL_DRAW_INDIRECT_BUFFER }
- { reuse GL_DRAW_INDIRECT_BUFFER_BINDING }
- { Reuse tokens from ARB_gpu_shader5 }
- { reuse GL_GEOMETRY_SHADER_INVOCATIONS }
- { reuse GL_MAX_GEOMETRY_SHADER_INVOCATIONS }
- { reuse GL_MIN_FRAGMENT_INTERPOLATION_OFFSET }
- { reuse GL_MAX_FRAGMENT_INTERPOLATION_OFFSET }
- { reuse GL_FRAGMENT_INTERPOLATION_OFFSET_BITS }
- { reuse GL_MAX_VERTEX_STREAMS }
- { Reuse tokens from ARB_gpu_shader_fp64 }
- { reuse GL_DOUBLE_VEC2 }
- { reuse GL_DOUBLE_VEC3 }
- { reuse GL_DOUBLE_VEC4 }
- { reuse GL_DOUBLE_MAT2 }
- { reuse GL_DOUBLE_MAT3 }
- { reuse GL_DOUBLE_MAT4 }
- { reuse GL_DOUBLE_MAT2x3 }
- { reuse GL_DOUBLE_MAT2x4 }
- { reuse GL_DOUBLE_MAT3x2 }
- { reuse GL_DOUBLE_MAT3x4 }
- { reuse GL_DOUBLE_MAT4x2 }
- { reuse GL_DOUBLE_MAT4x3 }
- { Reuse tokens from ARB_shader_subroutine }
- { reuse GL_ACTIVE_SUBROUTINES }
- { reuse GL_ACTIVE_SUBROUTINE_UNIFORMS }
- { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS }
- { reuse GL_ACTIVE_SUBROUTINE_MAX_LENGTH }
- { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH }
- { reuse GL_MAX_SUBROUTINES }
- { reuse GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS }
- { reuse GL_NUM_COMPATIBLE_SUBROUTINES }
- { reuse GL_COMPATIBLE_SUBROUTINES }
- { Reuse tokens from ARB_tessellation_shader }
- { reuse GL_PATCHES }
- { reuse GL_PATCH_VERTICES }
- { reuse GL_PATCH_DEFAULT_INNER_LEVEL }
- { reuse GL_PATCH_DEFAULT_OUTER_LEVEL }
- { reuse GL_TESS_CONTROL_OUTPUT_VERTICES }
- { reuse GL_TESS_GEN_MODE }
- { reuse GL_TESS_GEN_SPACING }
- { reuse GL_TESS_GEN_VERTEX_ORDER }
- { reuse GL_TESS_GEN_POINT_MODE }
- { reuse GL_ISOLINES }
- { reuse GL_FRACTIONAL_ODD }
- { reuse GL_FRACTIONAL_EVEN }
- { reuse GL_MAX_PATCH_VERTICES }
- { reuse GL_MAX_TESS_GEN_LEVEL }
- { reuse GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS }
- { reuse GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS }
- { reuse GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS }
- { reuse GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS }
- { reuse GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS }
- { reuse GL_MAX_TESS_PATCH_COMPONENTS }
- { reuse GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS }
- { reuse GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS }
- { reuse GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS }
- { reuse GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS }
- { reuse GL_MAX_TESS_CONTROL_INPUT_COMPONENTS }
- { reuse GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS }
- { reuse GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS }
- { reuse GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS }
- { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER }
- { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER }
- { reuse GL_TESS_EVALUATION_SHADER }
- { reuse GL_TESS_CONTROL_SHADER }
- { Reuse tokens from ARB_texture_buffer_object_rgb32 (none) }
- { Reuse tokens from ARB_transform_feedback2 }
- { reuse GL_TRANSFORM_FEEDBACK }
- { reuse GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED }
- { reuse GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE }
- { reuse GL_TRANSFORM_FEEDBACK_BINDING }
- { Reuse tokens from ARB_transform_feedback3 }
- { reuse GL_MAX_TRANSFORM_FEEDBACK_BUFFERS }
- { reuse GL_MAX_VERTEX_STREAMS }
-
- // GL_VERSION_4_1
- { Reuse tokens from ARB_ES2_compatibility }
- { reuse GL_FIXED }
- { reuse GL_IMPLEMENTATION_COLOR_READ_TYPE }
- { reuse GL_IMPLEMENTATION_COLOR_READ_FORMAT }
- { reuse GL_LOW_FLOAT }
- { reuse GL_MEDIUM_FLOAT }
- { reuse GL_HIGH_FLOAT }
- { reuse GL_LOW_INT }
- { reuse GL_MEDIUM_INT }
- { reuse GL_HIGH_INT }
- { reuse GL_SHADER_COMPILER }
- { reuse GL_NUM_SHADER_BINARY_FORMATS }
- { reuse GL_MAX_VERTEX_UNIFORM_VECTORS }
- { reuse GL_MAX_VARYING_VECTORS }
- { reuse GL_MAX_FRAGMENT_UNIFORM_VECTORS }
- { reuse GL_RGB565 }
- { Reuse tokens from ARB_get_program_binary }
- { reuse GL_PROGRAM_BINARY_RETRIEVABLE_HINT }
- { reuse GL_PROGRAM_BINARY_LENGTH }
- { reuse GL_NUM_PROGRAM_BINARY_FORMATS }
- { reuse GL_PROGRAM_BINARY_FORMATS }
- { Reuse tokens from ARB_separate_shader_objects }
- { reuse GL_VERTEX_SHADER_BIT }
- { reuse GL_FRAGMENT_SHADER_BIT }
- { reuse GL_GEOMETRY_SHADER_BIT }
- { reuse GL_TESS_CONTROL_SHADER_BIT }
- { reuse GL_TESS_EVALUATION_SHADER_BIT }
- { reuse GL_ALL_SHADER_BITS }
- { reuse GL_PROGRAM_SEPARABLE }
- { reuse GL_ACTIVE_PROGRAM }
- { reuse GL_PROGRAM_PIPELINE_BINDING }
- { Reuse tokens from ARB_shader_precision (none) }
- { Reuse tokens from ARB_vertex_attrib_64bit - all are in GL 3.0 and 4.0 already }
- { Reuse tokens from ARB_viewport_array - some are in GL 1.1 and ARB_provoking_vertex already }
- { reuse GL_MAX_VIEWPORTS }
- { reuse GL_VIEWPORT_SUBPIXEL_BITS }
- { reuse GL_VIEWPORT_BOUNDS_RANGE }
- { reuse GL_LAYER_PROVOKING_VERTEX }
- { reuse GL_VIEWPORT_INDEX_PROVOKING_VERTEX }
- { reuse GL_UNDEFINED_VERTEX }
-
- // GL_VERSION_4_2
- { Reuse tokens from ARB_base_instance (none) }
- { Reuse tokens from ARB_shading_language_420pack (none) }
- { Reuse tokens from ARB_transform_feedback_instanced (none) }
- { Reuse tokens from ARB_compressed_texture_pixel_storage }
- { reuse GL_UNPACK_COMPRESSED_BLOCK_WIDTH }
- { reuse GL_UNPACK_COMPRESSED_BLOCK_HEIGHT }
- { reuse GL_UNPACK_COMPRESSED_BLOCK_DEPTH }
- { reuse GL_UNPACK_COMPRESSED_BLOCK_SIZE }
- { reuse GL_PACK_COMPRESSED_BLOCK_WIDTH }
- { reuse GL_PACK_COMPRESSED_BLOCK_HEIGHT }
- { reuse GL_PACK_COMPRESSED_BLOCK_DEPTH }
- { reuse GL_PACK_COMPRESSED_BLOCK_SIZE }
- { Reuse tokens from ARB_conservative_depth (none) }
- { Reuse tokens from ARB_internalformat_query }
- { reuse GL_NUM_SAMPLE_COUNTS }
- { Reuse tokens from ARB_map_buffer_alignment }
- { reuse GL_MIN_MAP_BUFFER_ALIGNMENT }
- { Reuse tokens from ARB_shader_atomic_counters }
- { reuse GL_ATOMIC_COUNTER_BUFFER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_BINDING }
- { reuse GL_ATOMIC_COUNTER_BUFFER_START }
- { reuse GL_ATOMIC_COUNTER_BUFFER_SIZE }
- { reuse GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE }
- { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS }
- { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER }
- { reuse GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_VERTEX_ATOMIC_COUNTERS }
- { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS }
- { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS }
- { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTERS }
- { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTERS }
- { reuse GL_MAX_COMBINED_ATOMIC_COUNTERS }
- { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE }
- { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS }
- { reuse GL_ACTIVE_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX }
- { reuse GL_UNSIGNED_INT_ATOMIC_COUNTER }
- { Reuse tokens from ARB_shader_image_load_store }
- { reuse GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT }
- { reuse GL_ELEMENT_ARRAY_BARRIER_BIT }
- { reuse GL_UNIFORM_BARRIER_BIT }
- { reuse GL_TEXTURE_FETCH_BARRIER_BIT }
- { reuse GL_SHADER_IMAGE_ACCESS_BARRIER_BIT }
- { reuse GL_COMMAND_BARRIER_BIT }
- { reuse GL_PIXEL_BUFFER_BARRIER_BIT }
- { reuse GL_TEXTURE_UPDATE_BARRIER_BIT }
- { reuse GL_BUFFER_UPDATE_BARRIER_BIT }
- { reuse GL_FRAMEBUFFER_BARRIER_BIT }
- { reuse GL_TRANSFORM_FEEDBACK_BARRIER_BIT }
- { reuse GL_ATOMIC_COUNTER_BARRIER_BIT }
- { reuse GL_ALL_BARRIER_BITS }
- { reuse GL_MAX_IMAGE_UNITS }
- { reuse GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS }
- { reuse GL_IMAGE_BINDING_NAME }
- { reuse GL_IMAGE_BINDING_LEVEL }
- { reuse GL_IMAGE_BINDING_LAYERED }
- { reuse GL_IMAGE_BINDING_LAYER }
- { reuse GL_IMAGE_BINDING_ACCESS }
- { reuse GL_IMAGE_1D }
- { reuse GL_IMAGE_2D }
- { reuse GL_IMAGE_3D }
- { reuse GL_IMAGE_2D_RECT }
- { reuse GL_IMAGE_CUBE }
- { reuse GL_IMAGE_BUFFER }
- { reuse GL_IMAGE_1D_ARRAY }
- { reuse GL_IMAGE_2D_ARRAY }
- { reuse GL_IMAGE_CUBE_MAP_ARRAY }
- { reuse GL_IMAGE_2D_MULTISAMPLE }
- { reuse GL_IMAGE_2D_MULTISAMPLE_ARRAY }
- { reuse GL_INT_IMAGE_1D }
- { reuse GL_INT_IMAGE_2D }
- { reuse GL_INT_IMAGE_3D }
- { reuse GL_INT_IMAGE_2D_RECT }
- { reuse GL_INT_IMAGE_CUBE }
- { reuse GL_INT_IMAGE_BUFFER }
- { reuse GL_INT_IMAGE_1D_ARRAY }
- { reuse GL_INT_IMAGE_2D_ARRAY }
- { reuse GL_INT_IMAGE_CUBE_MAP_ARRAY }
- { reuse GL_INT_IMAGE_2D_MULTISAMPLE }
- { reuse GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY }
- { reuse GL_UNSIGNED_INT_IMAGE_1D }
- { reuse GL_UNSIGNED_INT_IMAGE_2D }
- { reuse GL_UNSIGNED_INT_IMAGE_3D }
- { reuse GL_UNSIGNED_INT_IMAGE_2D_RECT }
- { reuse GL_UNSIGNED_INT_IMAGE_CUBE }
- { reuse GL_UNSIGNED_INT_IMAGE_BUFFER }
- { reuse GL_UNSIGNED_INT_IMAGE_1D_ARRAY }
- { reuse GL_UNSIGNED_INT_IMAGE_2D_ARRAY }
- { reuse GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY }
- { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE }
- { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY }
- { reuse GL_MAX_IMAGE_SAMPLES }
- { reuse GL_IMAGE_BINDING_FORMAT }
- { reuse GL_IMAGE_FORMAT_COMPATIBILITY_TYPE }
- { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE }
- { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS }
- { reuse GL_MAX_VERTEX_IMAGE_UNIFORMS }
- { reuse GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS }
- { reuse GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS }
- { reuse GL_MAX_GEOMETRY_IMAGE_UNIFORMS }
- { reuse GL_MAX_FRAGMENT_IMAGE_UNIFORMS }
- { reuse GL_MAX_COMBINED_IMAGE_UNIFORMS }
- { Reuse tokens from ARB_shading_language_packing (none) }
- { Reuse tokens from ARB_texture_storage }
- { reuse GL_TEXTURE_IMMUTABLE_FORMAT }
-
- // GL_VERSION_4_3
- GL_NUM_SHADING_LANGUAGE_VERSIONS = $82E9;
- GL_VERTEX_ATTRIB_ARRAY_LONG = $874E;
- { Reuse tokens from ARB_arrays_of_arrays (none, GLSL only) }
- { Reuse tokens from ARB_fragment_layer_viewport (none, GLSL only) }
- { Reuse tokens from ARB_shader_image_size (none, GLSL only) }
- { Reuse tokens from ARB_ES3_compatibility }
- { reuse GL_COMPRESSED_RGB8_ETC2 }
- { reuse GL_COMPRESSED_SRGB8_ETC2 }
- { reuse GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 }
- { reuse GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 }
- { reuse GL_COMPRESSED_RGBA8_ETC2_EAC }
- { reuse GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC }
- { reuse GL_COMPRESSED_R11_EAC }
- { reuse GL_COMPRESSED_SIGNED_R11_EAC }
- { reuse GL_COMPRESSED_RG11_EAC }
- { reuse GL_COMPRESSED_SIGNED_RG11_EAC }
- { reuse GL_PRIMITIVE_RESTART_FIXED_INDEX }
- { reuse GL_ANY_SAMPLES_PASSED_CONSERVATIVE }
- { reuse GL_MAX_ELEMENT_INDEX }
- { Reuse tokens from ARB_clear_buffer_object (none) }
- { Reuse tokens from ARB_compute_shader }
- { reuse GL_COMPUTE_SHADER }
- { reuse GL_MAX_COMPUTE_UNIFORM_BLOCKS }
- { reuse GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS }
- { reuse GL_MAX_COMPUTE_IMAGE_UNIFORMS }
- { reuse GL_MAX_COMPUTE_SHARED_MEMORY_SIZE }
- { reuse GL_MAX_COMPUTE_UNIFORM_COMPONENTS }
- { reuse GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS }
- { reuse GL_MAX_COMPUTE_ATOMIC_COUNTERS }
- { reuse GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS }
- { reuse GL_MAX_COMPUTE_LOCAL_INVOCATIONS }
- { reuse GL_MAX_COMPUTE_WORK_GROUP_COUNT }
- { reuse GL_MAX_COMPUTE_WORK_GROUP_SIZE }
- { reuse GL_COMPUTE_LOCAL_WORK_SIZE }
- { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER }
- { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER }
- { reuse GL_DISPATCH_INDIRECT_BUFFER }
- { reuse GL_DISPATCH_INDIRECT_BUFFER_BINDING }
- { Reuse tokens from ARB_copy_image (none) }
- { Reuse tokens from KHR_debug }
- { reuse GL_DEBUG_OUTPUT_SYNCHRONOUS }
- { reuse GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH }
- { reuse GL_DEBUG_CALLBACK_FUNCTION }
- { reuse GL_DEBUG_CALLBACK_USER_PARAM }
- { reuse GL_DEBUG_SOURCE_API }
- { reuse GL_DEBUG_SOURCE_WINDOW_SYSTEM }
- { reuse GL_DEBUG_SOURCE_SHADER_COMPILER }
- { reuse GL_DEBUG_SOURCE_THIRD_PARTY }
- { reuse GL_DEBUG_SOURCE_APPLICATION }
- { reuse GL_DEBUG_SOURCE_OTHER }
- { reuse GL_DEBUG_TYPE_ERROR }
- { reuse GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR }
- { reuse GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR }
- { reuse GL_DEBUG_TYPE_PORTABILITY }
- { reuse GL_DEBUG_TYPE_PERFORMANCE }
- { reuse GL_DEBUG_TYPE_OTHER }
- { reuse GL_MAX_DEBUG_MESSAGE_LENGTH }
- { reuse GL_MAX_DEBUG_LOGGED_MESSAGES }
- { reuse GL_DEBUG_LOGGED_MESSAGES }
- { reuse GL_DEBUG_SEVERITY_HIGH }
- { reuse GL_DEBUG_SEVERITY_MEDIUM }
- { reuse GL_DEBUG_SEVERITY_LOW }
- { reuse GL_DEBUG_TYPE_MARKER }
- { reuse GL_DEBUG_TYPE_PUSH_GROUP }
- { reuse GL_DEBUG_TYPE_POP_GROUP }
- { reuse GL_DEBUG_SEVERITY_NOTIFICATION }
- { reuse GL_MAX_DEBUG_GROUP_STACK_DEPTH }
- { reuse GL_DEBUG_GROUP_STACK_DEPTH }
- { reuse GL_BUFFER }
- { reuse GL_SHADER }
- { reuse GL_PROGRAM }
- { reuse GL_QUERY }
- { reuse GL_PROGRAM_PIPELINE }
- { reuse GL_SAMPLER }
- { reuse GL_DISPLAY_LIST }
- { reuse GL_MAX_LABEL_LENGTH }
- { reuse GL_DEBUG_OUTPUT }
- { reuse GL_CONTEXT_FLAG_DEBUG_BIT }
- { reuse GL_STACK_UNDERFLOW }
- { reuse GL_STACK_OVERFLOW }
- { Reuse tokens from ARB_explicit_uniform_location }
- { reuse GL_MAX_UNIFORM_LOCATIONS }
- { Reuse tokens from ARB_framebuffer_no_attachments }
- { reuse GL_FRAMEBUFFER_DEFAULT_WIDTH }
- { reuse GL_FRAMEBUFFER_DEFAULT_HEIGHT }
- { reuse GL_FRAMEBUFFER_DEFAULT_LAYERS }
- { reuse GL_FRAMEBUFFER_DEFAULT_SAMPLES }
- { reuse GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS }
- { reuse GL_MAX_FRAMEBUFFER_WIDTH }
- { reuse GL_MAX_FRAMEBUFFER_HEIGHT }
- { reuse GL_MAX_FRAMEBUFFER_LAYERS }
- { reuse GL_MAX_FRAMEBUFFER_SAMPLES }
- { Reuse tokens from ARB_internalformat_query2 }
- { reuse GL_INTERNALFORMAT_SUPPORTED }
- { reuse GL_INTERNALFORMAT_PREFERRED }
- { reuse GL_INTERNALFORMAT_RED_SIZE }
- { reuse GL_INTERNALFORMAT_GREEN_SIZE }
- { reuse GL_INTERNALFORMAT_BLUE_SIZE }
- { reuse GL_INTERNALFORMAT_ALPHA_SIZE }
- { reuse GL_INTERNALFORMAT_DEPTH_SIZE }
- { reuse GL_INTERNALFORMAT_STENCIL_SIZE }
- { reuse GL_INTERNALFORMAT_SHARED_SIZE }
- { reuse GL_INTERNALFORMAT_RED_TYPE }
- { reuse GL_INTERNALFORMAT_GREEN_TYPE }
- { reuse GL_INTERNALFORMAT_BLUE_TYPE }
- { reuse GL_INTERNALFORMAT_ALPHA_TYPE }
- { reuse GL_INTERNALFORMAT_DEPTH_TYPE }
- { reuse GL_INTERNALFORMAT_STENCIL_TYPE }
- { reuse GL_MAX_WIDTH }
- { reuse GL_MAX_HEIGHT }
- { reuse GL_MAX_DEPTH }
- { reuse GL_MAX_LAYERS }
- { reuse GL_MAX_COMBINED_DIMENSIONS }
- { reuse GL_COLOR_COMPONENTS }
- { reuse GL_DEPTH_COMPONENTS }
- { reuse GL_STENCIL_COMPONENTS }
- { reuse GL_COLOR_RENDERABLE }
- { reuse GL_DEPTH_RENDERABLE }
- { reuse GL_STENCIL_RENDERABLE }
- { reuse GL_FRAMEBUFFER_RENDERABLE }
- { reuse GL_FRAMEBUFFER_RENDERABLE_LAYERED }
- { reuse GL_FRAMEBUFFER_BLEND }
- { reuse GL_READ_PIXELS }
- { reuse GL_READ_PIXELS_FORMAT }
- { reuse GL_READ_PIXELS_TYPE }
- { reuse GL_TEXTURE_IMAGE_FORMAT }
- { reuse GL_TEXTURE_IMAGE_TYPE }
- { reuse GL_GET_TEXTURE_IMAGE_FORMAT }
- { reuse GL_GET_TEXTURE_IMAGE_TYPE }
- { reuse GL_MIPMAP }
- { reuse GL_MANUAL_GENERATE_MIPMAP }
- { reuse GL_AUTO_GENERATE_MIPMAP }
- { reuse GL_COLOR_ENCODING }
- { reuse GL_SRGB_READ }
- { reuse GL_SRGB_WRITE }
- { reuse GL_FILTER }
- { reuse GL_VERTEX_TEXTURE }
- { reuse GL_TESS_CONTROL_TEXTURE }
- { reuse GL_TESS_EVALUATION_TEXTURE }
- { reuse GL_GEOMETRY_TEXTURE }
- { reuse GL_FRAGMENT_TEXTURE }
- { reuse GL_COMPUTE_TEXTURE }
- { reuse GL_TEXTURE_SHADOW }
- { reuse GL_TEXTURE_GATHER }
- { reuse GL_TEXTURE_GATHER_SHADOW }
- { reuse GL_SHADER_IMAGE_LOAD }
- { reuse GL_SHADER_IMAGE_STORE }
- { reuse GL_SHADER_IMAGE_ATOMIC }
- { reuse GL_IMAGE_TEXEL_SIZE }
- { reuse GL_IMAGE_COMPATIBILITY_CLASS }
- { reuse GL_IMAGE_PIXEL_FORMAT }
- { reuse GL_IMAGE_PIXEL_TYPE }
- { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST }
- { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST }
- { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE }
- { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE }
- { reuse GL_TEXTURE_COMPRESSED_BLOCK_WIDTH }
- { reuse GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT }
- { reuse GL_TEXTURE_COMPRESSED_BLOCK_SIZE }
- { reuse GL_CLEAR_BUFFER }
- { reuse GL_TEXTURE_VIEW }
- { reuse GL_VIEW_COMPATIBILITY_CLASS }
- { reuse GL_FULL_SUPPORT }
- { reuse GL_CAVEAT_SUPPORT }
- { reuse GL_IMAGE_CLASS_4_X_32 }
- { reuse GL_IMAGE_CLASS_2_X_32 }
- { reuse GL_IMAGE_CLASS_1_X_32 }
- { reuse GL_IMAGE_CLASS_4_X_16 }
- { reuse GL_IMAGE_CLASS_2_X_16 }
- { reuse GL_IMAGE_CLASS_1_X_16 }
- { reuse GL_IMAGE_CLASS_4_X_8 }
- { reuse GL_IMAGE_CLASS_2_X_8 }
- { reuse GL_IMAGE_CLASS_1_X_8 }
- { reuse GL_IMAGE_CLASS_11_11_10 }
- { reuse GL_IMAGE_CLASS_10_10_10_2 }
- { reuse GL_VIEW_CLASS_128_BITS }
- { reuse GL_VIEW_CLASS_96_BITS }
- { reuse GL_VIEW_CLASS_64_BITS }
- { reuse GL_VIEW_CLASS_48_BITS }
- { reuse GL_VIEW_CLASS_32_BITS }
- { reuse GL_VIEW_CLASS_24_BITS }
- { reuse GL_VIEW_CLASS_16_BITS }
- { reuse GL_VIEW_CLASS_8_BITS }
- { reuse GL_VIEW_CLASS_S3TC_DXT1_RGB }
- { reuse GL_VIEW_CLASS_S3TC_DXT1_RGBA }
- { reuse GL_VIEW_CLASS_S3TC_DXT3_RGBA }
- { reuse GL_VIEW_CLASS_S3TC_DXT5_RGBA }
- { reuse GL_VIEW_CLASS_RGTC1_RED }
- { reuse GL_VIEW_CLASS_RGTC2_RG }
- { reuse GL_VIEW_CLASS_BPTC_UNORM }
- { reuse GL_VIEW_CLASS_BPTC_FLOAT }
- { Reuse tokens from ARB_invalidate_subdata (none) }
- { Reuse tokens from ARB_multi_draw_indirect (none) }
- { Reuse tokens from ARB_program_interface_query }
- { reuse GL_UNIFORM }
- { reuse GL_UNIFORM_BLOCK }
- { reuse GL_PROGRAM_INPUT }
- { reuse GL_PROGRAM_OUTPUT }
- { reuse GL_BUFFER_VARIABLE }
- { reuse GL_SHADER_STORAGE_BLOCK }
- { reuse GL_VERTEX_SUBROUTINE }
- { reuse GL_TESS_CONTROL_SUBROUTINE }
- { reuse GL_TESS_EVALUATION_SUBROUTINE }
- { reuse GL_GEOMETRY_SUBROUTINE }
- { reuse GL_FRAGMENT_SUBROUTINE }
- { reuse GL_COMPUTE_SUBROUTINE }
- { reuse GL_VERTEX_SUBROUTINE_UNIFORM }
- { reuse GL_TESS_CONTROL_SUBROUTINE_UNIFORM }
- { reuse GL_TESS_EVALUATION_SUBROUTINE_UNIFORM }
- { reuse GL_GEOMETRY_SUBROUTINE_UNIFORM }
- { reuse GL_FRAGMENT_SUBROUTINE_UNIFORM }
- { reuse GL_COMPUTE_SUBROUTINE_UNIFORM }
- { reuse GL_TRANSFORM_FEEDBACK_VARYING }
- { reuse GL_ACTIVE_RESOURCES }
- { reuse GL_MAX_NAME_LENGTH }
- { reuse GL_MAX_NUM_ACTIVE_VARIABLES }
- { reuse GL_MAX_NUM_COMPATIBLE_SUBROUTINES }
- { reuse GL_NAME_LENGTH }
- { reuse GL_TYPE }
- { reuse GL_ARRAY_SIZE }
- { reuse GL_OFFSET }
- { reuse GL_BLOCK_INDEX }
- { reuse GL_ARRAY_STRIDE }
- { reuse GL_MATRIX_STRIDE }
- { reuse GL_IS_ROW_MAJOR }
- { reuse GL_ATOMIC_COUNTER_BUFFER_INDEX }
- { reuse GL_BUFFER_BINDING }
- { reuse GL_BUFFER_DATA_SIZE }
- { reuse GL_NUM_ACTIVE_VARIABLES }
- { reuse GL_ACTIVE_VARIABLES }
- { reuse GL_REFERENCED_BY_VERTEX_SHADER }
- { reuse GL_REFERENCED_BY_TESS_CONTROL_SHADER }
- { reuse GL_REFERENCED_BY_TESS_EVALUATION_SHADER }
- { reuse GL_REFERENCED_BY_GEOMETRY_SHADER }
- { reuse GL_REFERENCED_BY_FRAGMENT_SHADER }
- { reuse GL_REFERENCED_BY_COMPUTE_SHADER }
- { reuse GL_TOP_LEVEL_ARRAY_SIZE }
- { reuse GL_TOP_LEVEL_ARRAY_STRIDE }
- { reuse GL_LOCATION }
- { reuse GL_LOCATION_INDEX }
- { reuse GL_IS_PER_PATCH }
- { Reuse tokens from ARB_robust_buffer_access_behavior (none) }
- { Reuse tokens from ARB_shader_storage_buffer_object }
- { reuse GL_SHADER_STORAGE_BUFFER }
- { reuse GL_SHADER_STORAGE_BUFFER_BINDING }
- { reuse GL_SHADER_STORAGE_BUFFER_START }
- { reuse GL_SHADER_STORAGE_BUFFER_SIZE }
- { reuse GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS }
- { reuse GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS }
- { reuse GL_MAX_SHADER_STORAGE_BLOCK_SIZE }
- { reuse GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT }
- { reuse GL_SHADER_STORAGE_BARRIER_BIT }
- { reuse GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES }
- { Reuse tokens from ARB_stencil_texturing }
- { reuse GL_DEPTH_STENCIL_TEXTURE_MODE }
- { Reuse tokens from ARB_texture_buffer_range }
- { reuse GL_TEXTURE_BUFFER_OFFSET }
- { reuse GL_TEXTURE_BUFFER_SIZE }
- { reuse GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT }
- { Reuse tokens from ARB_texture_query_levels (none) }
- { Reuse tokens from ARB_texture_storage_multisample (none) }
- { Reuse tokens from ARB_texture_view }
- { reuse GL_TEXTURE_VIEW_MIN_LEVEL }
- { reuse GL_TEXTURE_VIEW_NUM_LEVELS }
- { reuse GL_TEXTURE_VIEW_MIN_LAYER }
- { reuse GL_TEXTURE_VIEW_NUM_LAYERS }
- { reuse GL_TEXTURE_IMMUTABLE_LEVELS }
- { Reuse tokens from ARB_vertex_attrib_binding }
- { reuse GL_VERTEX_ATTRIB_BINDING }
- { reuse GL_VERTEX_ATTRIB_RELATIVE_OFFSET }
- { reuse GL_VERTEX_BINDING_DIVISOR }
- { reuse GL_VERTEX_BINDING_OFFSET }
- { reuse GL_VERTEX_BINDING_STRIDE }
- { reuse GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET }
- { reuse GL_MAX_VERTEX_ATTRIB_BINDINGS }
-
-
- // GL_3DFX_multisample
- GL_MULTISAMPLE_3DFX = $86B2;
- GL_SAMPLE_BUFFERS_3DFX = $86B3;
- GL_SAMPLES_3DFX = $86B4;
- GL_MULTISAMPLE_BIT_3DFX = $20000000;
-
- // GL_3DFX_texture_compression_FXT1
- GL_COMPRESSED_RGB_FXT1_3DFX = $86B0;
- GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1;
-
- // GL_APPLE_client_storage
- GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2;
-
- // GL_APPLE_element_array
- GL_ELEMENT_ARRAY_APPLE = $8A0C;
- GL_ELEMENT_ARRAY_TYPE_APPLE = $8A0D;
- GL_ELEMENT_ARRAY_POINTER_APPLE = $8A0E;
-
- // GL_APPLE_fence
- GL_DRAW_PIXELS_APPLE = $8A0A;
- GL_FENCE_APPLE = $8A0B;
-
- // GL_APPLE_specular_vector
- GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0;
-
- // GL_APPLE_transform_hint
- GL_TRANSFORM_HINT_APPLE = $85B1;
-
- // GL_APPLE_vertex_array_object
- GL_VERTEX_ARRAY_BINDING_APPLE = $85B5;
-
- // GL_APPLE_vertex_array_range
- GL_VERTEX_ARRAY_RANGE_APPLE = $851D;
- GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E;
- GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F;
- GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521;
- GL_STORAGE_CLIENT_APPLE = $85B4;
- GL_STORAGE_CACHED_APPLE = $85BE;
- GL_STORAGE_SHARED_APPLE = $85BF;
-
- // GL_APPLE_ycbcr_422
- GL_YCBCR_422_APPLE = $85B9;
- GL_UNSIGNED_SHORT_8_8_APPLE = $85BA;
- GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB;
-
- // GL_APPLE_texture_range
- GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7;
- GL_TEXTURE_RANGE_POINTER_APPLE = $85B8;
- GL_TEXTURE_STORAGE_HINT_APPLE = $85BC;
- GL_STORAGE_PRIVATE_APPLE = $85BD;
- { reuse GL_STORAGE_CACHED_APPLE }
- { reuse GL_STORAGE_SHARED_APPLE }
-
- // GL_APPLE_float_pixels
- GL_HALF_APPLE = $140B;
- GL_RGBA_FLOAT32_APPLE = $8814;
- GL_RGB_FLOAT32_APPLE = $8815;
- GL_ALPHA_FLOAT32_APPLE = $8816;
- GL_INTENSITY_FLOAT32_APPLE = $8817;
- GL_LUMINANCE_FLOAT32_APPLE = $8818;
- GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819;
- GL_RGBA_FLOAT16_APPLE = $881A;
- GL_RGB_FLOAT16_APPLE = $881B;
- GL_ALPHA_FLOAT16_APPLE = $881C;
- GL_INTENSITY_FLOAT16_APPLE = $881D;
- GL_LUMINANCE_FLOAT16_APPLE = $881E;
- GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F;
- GL_COLOR_FLOAT_APPLE = $8A0F;
-
- // GL_APPLE_vertex_program_evaluators
- GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00;
- GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01;
- GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02;
- GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03;
- GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04;
- GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05;
- GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06;
- GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07;
- GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08;
- GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09;
-
- // GL_APPLE_aux_depth_stencil
- GL_AUX_DEPTH_STENCIL_APPLE = $8A14;
-
- // GL_APPLE_object_purgeable
- GL_BUFFER_OBJECT_APPLE = $85B3;
- GL_RELEASED_APPLE = $8A19;
- GL_VOLATILE_APPLE = $8A1A;
- GL_RETAINED_APPLE = $8A1B;
- GL_UNDEFINED_APPLE = $8A1C;
- GL_PURGEABLE_APPLE = $8A1D;
-
- // GL_APPLE_row_bytes
- GL_PACK_ROW_BYTES_APPLE = $8A15;
- GL_UNPACK_ROW_BYTES_APPLE = $8A16;
-
- // GL_APPLE_rgb_422
- { reuse GL_UNSIGNED_SHORT_8_8_APPLE }
- { reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE }
-
- // GL_ARB_depth_texture
- GL_DEPTH_COMPONENT16_ARB = $81A5;
- GL_DEPTH_COMPONENT24_ARB = $81A6;
- GL_DEPTH_COMPONENT32_ARB = $81A7;
- GL_TEXTURE_DEPTH_SIZE_ARB = $884A;
- GL_DEPTH_TEXTURE_MODE_ARB = $884B;
-
- // GL_ARB_fragment_program
- GL_FRAGMENT_PROGRAM_ARB = $8804;
- GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805;
- GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806;
- GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807;
- GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808;
- GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809;
- GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A;
- GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B;
- GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C;
- GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D;
- GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E;
- GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F;
- GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810;
- GL_MAX_TEXTURE_COORDS_ARB = $8871;
- GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872;
-
- // GL_ARB_imaging
- GL_CONSTANT_COLOR_ARB = $8001;
- GL_CONSTANT_COLOR = $8001;
- GL_ONE_MINUS_CONSTANT_COLOR = $8002;
- GL_CONSTANT_ALPHA = $8003;
- GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
- GL_BLEND_COLOR = $8005;
- GL_FUNC_ADD = $8006;
- GL_MIN = $8007;
- GL_MAX = $8008;
- GL_BLEND_EQUATION = $8009;
- GL_FUNC_SUBTRACT = $800A;
- GL_FUNC_REVERSE_SUBTRACT = $800B;
-{$ifdef DGL_DEPRECATED}
- GL_CONVOLUTION_1D = $8010;
- GL_CONVOLUTION_2D = $8011;
- GL_SEPARABLE_2D = $8012;
- GL_CONVOLUTION_BORDER_MODE = $8013;
- GL_CONVOLUTION_FILTER_SCALE = $8014;
- GL_CONVOLUTION_FILTER_BIAS = $8015;
- GL_REDUCE = $8016;
- GL_CONVOLUTION_FORMAT = $8017;
- GL_CONVOLUTION_WIDTH = $8018;
- GL_CONVOLUTION_HEIGHT = $8019;
- GL_MAX_CONVOLUTION_WIDTH = $801A;
- GL_MAX_CONVOLUTION_HEIGHT = $801B;
- GL_POST_CONVOLUTION_RED_SCALE = $801C;
- GL_POST_CONVOLUTION_GREEN_SCALE = $801D;
- GL_POST_CONVOLUTION_BLUE_SCALE = $801E;
- GL_POST_CONVOLUTION_ALPHA_SCALE = $801F;
- GL_POST_CONVOLUTION_RED_BIAS = $8020;
- GL_POST_CONVOLUTION_GREEN_BIAS = $8021;
- GL_POST_CONVOLUTION_BLUE_BIAS = $8022;
- GL_POST_CONVOLUTION_ALPHA_BIAS = $8023;
- GL_HISTOGRAM = $8024;
- GL_PROXY_HISTOGRAM = $8025;
- GL_HISTOGRAM_WIDTH = $8026;
- GL_HISTOGRAM_FORMAT = $8027;
- GL_HISTOGRAM_RED_SIZE = $8028;
- GL_HISTOGRAM_GREEN_SIZE = $8029;
- GL_HISTOGRAM_BLUE_SIZE = $802A;
- GL_HISTOGRAM_ALPHA_SIZE = $802B;
- GL_HISTOGRAM_LUMINANCE_SIZE = $802C;
- GL_HISTOGRAM_SINK = $802D;
- GL_MINMAX = $802E;
- GL_MINMAX_FORMAT = $802F;
- GL_MINMAX_SINK = $8030;
- GL_TABLE_TOO_LARGE = $8031;
- GL_COLOR_MATRIX = $80B1;
- GL_COLOR_MATRIX_STACK_DEPTH = $80B2;
- GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3;
- GL_POST_COLOR_MATRIX_RED_SCALE = $80B4;
- GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5;
- GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6;
- GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7;
- GL_POST_COLOR_MATRIX_RED_BIAS = $80B8;
- GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9;
- GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA;
- GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB;
- GL_COLOR_TABLE = $80D0;
- GL_POST_CONVOLUTION_COLOR_TABLE = $80D1;
- GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2;
- GL_PROXY_COLOR_TABLE = $80D3;
- GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4;
- GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5;
- GL_COLOR_TABLE_SCALE = $80D6;
- GL_COLOR_TABLE_BIAS = $80D7;
- GL_COLOR_TABLE_FORMAT = $80D8;
- GL_COLOR_TABLE_WIDTH = $80D9;
- GL_COLOR_TABLE_RED_SIZE = $80DA;
- GL_COLOR_TABLE_GREEN_SIZE = $80DB;
- GL_COLOR_TABLE_BLUE_SIZE = $80DC;
- GL_COLOR_TABLE_ALPHA_SIZE = $80DD;
- GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE;
- GL_COLOR_TABLE_INTENSITY_SIZE = $80DF;
- GL_CONSTANT_BORDER = $8151;
- GL_REPLICATE_BORDER = $8153;
- GL_CONVOLUTION_BORDER_COLOR = $8154;
-{$endif}
-
- // GL_ARB_matrix_palette
- GL_MATRIX_PALETTE_ARB = $8840;
- GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841;
- GL_MAX_PALETTE_MATRICES_ARB = $8842;
- GL_CURRENT_PALETTE_MATRIX_ARB = $8843;
- GL_MATRIX_INDEX_ARRAY_ARB = $8844;
- GL_CURRENT_MATRIX_INDEX_ARB = $8845;
- GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846;
- GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847;
- GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848;
- GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849;
-
- // GL_ARB_multisample
- GL_MULTISAMPLE_ARB = $809D;
- GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E;
- GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F;
- GL_SAMPLE_COVERAGE_ARB = $80A0;
- GL_SAMPLE_BUFFERS_ARB = $80A8;
- GL_SAMPLES_ARB = $80A9;
- GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA;
- GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB;
- GL_MULTISAMPLE_BIT_ARB = $20000000;
-
- // GL_ARB_multitexture
- GL_TEXTURE0_ARB = $84C0;
- GL_TEXTURE1_ARB = $84C1;
- GL_TEXTURE2_ARB = $84C2;
- GL_TEXTURE3_ARB = $84C3;
- GL_TEXTURE4_ARB = $84C4;
- GL_TEXTURE5_ARB = $84C5;
- GL_TEXTURE6_ARB = $84C6;
- GL_TEXTURE7_ARB = $84C7;
- GL_TEXTURE8_ARB = $84C8;
- GL_TEXTURE9_ARB = $84C9;
- GL_TEXTURE10_ARB = $84CA;
- GL_TEXTURE11_ARB = $84CB;
- GL_TEXTURE12_ARB = $84CC;
- GL_TEXTURE13_ARB = $84CD;
- GL_TEXTURE14_ARB = $84CE;
- GL_TEXTURE15_ARB = $84CF;
- GL_TEXTURE16_ARB = $84D0;
- GL_TEXTURE17_ARB = $84D1;
- GL_TEXTURE18_ARB = $84D2;
- GL_TEXTURE19_ARB = $84D3;
- GL_TEXTURE20_ARB = $84D4;
- GL_TEXTURE21_ARB = $84D5;
- GL_TEXTURE22_ARB = $84D6;
- GL_TEXTURE23_ARB = $84D7;
- GL_TEXTURE24_ARB = $84D8;
- GL_TEXTURE25_ARB = $84D9;
- GL_TEXTURE26_ARB = $84DA;
- GL_TEXTURE27_ARB = $84DB;
- GL_TEXTURE28_ARB = $84DC;
- GL_TEXTURE29_ARB = $84DD;
- GL_TEXTURE30_ARB = $84DE;
- GL_TEXTURE31_ARB = $84DF;
- GL_ACTIVE_TEXTURE_ARB = $84E0;
- GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1;
- GL_MAX_TEXTURE_UNITS_ARB = $84E2;
-
- // GL_ARB_point_parameters
- GL_POINT_SIZE_MIN_ARB = $8126;
- GL_POINT_SIZE_MAX_ARB = $8127;
- GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128;
- GL_POINT_DISTANCE_ATTENUATION_ARB = $8129;
-
- // GL_ARB_shadow
- GL_TEXTURE_COMPARE_MODE_ARB = $884C;
- GL_TEXTURE_COMPARE_FUNC_ARB = $884D;
- GL_COMPARE_R_TO_TEXTURE_ARB = $884E;
-
- // GL_ARB_shadow_ambient
- GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF;
-
- // GL_ARB_texture_border_clamp
- GL_CLAMP_TO_BORDER_ARB = $812D;
-
- // GL_ARB_texture_compression
- GL_COMPRESSED_ALPHA_ARB = $84E9;
- GL_COMPRESSED_LUMINANCE_ARB = $84EA;
- GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB;
- GL_COMPRESSED_INTENSITY_ARB = $84EC;
- GL_COMPRESSED_RGB_ARB = $84ED;
- GL_COMPRESSED_RGBA_ARB = $84EE;
- GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF;
- GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0;
- GL_TEXTURE_COMPRESSED_ARB = $86A1;
- GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2;
- GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3;
-
- // GL_ARB_texture_cube_map
- GL_NORMAL_MAP_ARB = $8511;
- GL_REFLECTION_MAP_ARB = $8512;
- GL_TEXTURE_CUBE_MAP_ARB = $8513;
- GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514;
- GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A;
- GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B;
- GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C;
-
- // GL_ARB_texture_env_combine
- GL_COMBINE_ARB = $8570;
- GL_COMBINE_RGB_ARB = $8571;
- GL_COMBINE_ALPHA_ARB = $8572;
- GL_SOURCE0_RGB_ARB = $8580;
- GL_SOURCE1_RGB_ARB = $8581;
- GL_SOURCE2_RGB_ARB = $8582;
- GL_SOURCE0_ALPHA_ARB = $8588;
- GL_SOURCE1_ALPHA_ARB = $8589;
- GL_SOURCE2_ALPHA_ARB = $858A;
- GL_OPERAND0_RGB_ARB = $8590;
- GL_OPERAND1_RGB_ARB = $8591;
- GL_OPERAND2_RGB_ARB = $8592;
- GL_OPERAND0_ALPHA_ARB = $8598;
- GL_OPERAND1_ALPHA_ARB = $8599;
- GL_OPERAND2_ALPHA_ARB = $859A;
- GL_RGB_SCALE_ARB = $8573;
- GL_ADD_SIGNED_ARB = $8574;
- GL_INTERPOLATE_ARB = $8575;
- GL_SUBTRACT_ARB = $84E7;
- GL_CONSTANT_ARB = $8576;
- GL_PRIMARY_COLOR_ARB = $8577;
- GL_PREVIOUS_ARB = $8578;
-
- // GL_ARB_texture_env_dot3
- GL_DOT3_RGB_ARB = $86AE;
- GL_DOT3_RGBA_ARB = $86AF;
-
- // GL_ARB_texture_mirrored_repeat
- GL_MIRRORED_REPEAT_ARB = $8370;
-
- // GL_ARB_transpose_matrix
- GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3;
- GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4;
- GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5;
- GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6;
-
- // GL_ARB_vertex_blend
- GL_MAX_VERTEX_UNITS_ARB = $86A4;
- GL_ACTIVE_VERTEX_UNITS_ARB = $86A5;
- GL_WEIGHT_SUM_UNITY_ARB = $86A6;
- GL_VERTEX_BLEND_ARB = $86A7;
- GL_CURRENT_WEIGHT_ARB = $86A8;
- GL_WEIGHT_ARRAY_TYPE_ARB = $86A9;
- GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA;
- GL_WEIGHT_ARRAY_SIZE_ARB = $86AB;
- GL_WEIGHT_ARRAY_POINTER_ARB = $86AC;
- GL_WEIGHT_ARRAY_ARB = $86AD;
- GL_MODELVIEW0_ARB = $1700;
- GL_MODELVIEW1_ARB = $850A;
- GL_MODELVIEW2_ARB = $8722;
- GL_MODELVIEW3_ARB = $8723;
- GL_MODELVIEW4_ARB = $8724;
- GL_MODELVIEW5_ARB = $8725;
- GL_MODELVIEW6_ARB = $8726;
- GL_MODELVIEW7_ARB = $8727;
- GL_MODELVIEW8_ARB = $8728;
- GL_MODELVIEW9_ARB = $8729;
- GL_MODELVIEW10_ARB = $872A;
- GL_MODELVIEW11_ARB = $872B;
- GL_MODELVIEW12_ARB = $872C;
- GL_MODELVIEW13_ARB = $872D;
- GL_MODELVIEW14_ARB = $872E;
- GL_MODELVIEW15_ARB = $872F;
- GL_MODELVIEW16_ARB = $8730;
- GL_MODELVIEW17_ARB = $8731;
- GL_MODELVIEW18_ARB = $8732;
- GL_MODELVIEW19_ARB = $8733;
- GL_MODELVIEW20_ARB = $8734;
- GL_MODELVIEW21_ARB = $8735;
- GL_MODELVIEW22_ARB = $8736;
- GL_MODELVIEW23_ARB = $8737;
- GL_MODELVIEW24_ARB = $8738;
- GL_MODELVIEW25_ARB = $8739;
- GL_MODELVIEW26_ARB = $873A;
- GL_MODELVIEW27_ARB = $873B;
- GL_MODELVIEW28_ARB = $873C;
- GL_MODELVIEW29_ARB = $873D;
- GL_MODELVIEW30_ARB = $873E;
- GL_MODELVIEW31_ARB = $873F;
-
- // GL_ARB_vertex_buffer_object
- GL_BUFFER_SIZE_ARB = $8764;
- GL_BUFFER_USAGE_ARB = $8765;
- GL_ARRAY_BUFFER_ARB = $8892;
- GL_ELEMENT_ARRAY_BUFFER_ARB = $8893;
- GL_ARRAY_BUFFER_BINDING_ARB = $8894;
- GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895;
- GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896;
- GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897;
- GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898;
- GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899;
- GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A;
- GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B;
- GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C;
- GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D;
- GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E;
- GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F;
- GL_READ_ONLY_ARB = $88B8;
- GL_WRITE_ONLY_ARB = $88B9;
- GL_READ_WRITE_ARB = $88BA;
- GL_BUFFER_ACCESS_ARB = $88BB;
- GL_BUFFER_MAPPED_ARB = $88BC;
- GL_BUFFER_MAP_POINTER_ARB = $88BD;
- GL_STREAM_DRAW_ARB = $88E0;
- GL_STREAM_READ_ARB = $88E1;
- GL_STREAM_COPY_ARB = $88E2;
- GL_STATIC_DRAW_ARB = $88E4;
- GL_STATIC_READ_ARB = $88E5;
- GL_STATIC_COPY_ARB = $88E6;
- GL_DYNAMIC_DRAW_ARB = $88E8;
- GL_DYNAMIC_READ_ARB = $88E9;
- GL_DYNAMIC_COPY_ARB = $88EA;
-
- // GL_ARB_vertex_program
- GL_COLOR_SUM_ARB = $8458;
- GL_VERTEX_PROGRAM_ARB = $8620;
- GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622;
- GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623;
- GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624;
- GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625;
- GL_CURRENT_VERTEX_ATTRIB_ARB = $8626;
- GL_PROGRAM_LENGTH_ARB = $8627;
- GL_PROGRAM_STRING_ARB = $8628;
- GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E;
- GL_MAX_PROGRAM_MATRICES_ARB = $862F;
- GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640;
- GL_CURRENT_MATRIX_ARB = $8641;
- GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642;
- GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643;
- GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645;
- GL_PROGRAM_ERROR_POSITION_ARB = $864B;
- GL_PROGRAM_BINDING_ARB = $8677;
- GL_MAX_VERTEX_ATTRIBS_ARB = $8869;
- GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A;
- GL_PROGRAM_ERROR_STRING_ARB = $8874;
- GL_PROGRAM_FORMAT_ASCII_ARB = $8875;
- GL_PROGRAM_FORMAT_ARB = $8876;
- GL_PROGRAM_INSTRUCTIONS_ARB = $88A0;
- GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1;
- GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2;
- GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3;
- GL_PROGRAM_TEMPORARIES_ARB = $88A4;
- GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5;
- GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6;
- GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7;
- GL_PROGRAM_PARAMETERS_ARB = $88A8;
- GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9;
- GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA;
- GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB;
- GL_PROGRAM_ATTRIBS_ARB = $88AC;
- GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD;
- GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE;
- GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF;
- GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0;
- GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1;
- GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2;
- GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3;
- GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4;
- GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5;
- GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6;
- GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7;
- GL_MATRIX0_ARB = $88C0;
- GL_MATRIX1_ARB = $88C1;
- GL_MATRIX2_ARB = $88C2;
- GL_MATRIX3_ARB = $88C3;
- GL_MATRIX4_ARB = $88C4;
- GL_MATRIX5_ARB = $88C5;
- GL_MATRIX6_ARB = $88C6;
- GL_MATRIX7_ARB = $88C7;
- GL_MATRIX8_ARB = $88C8;
- GL_MATRIX9_ARB = $88C9;
- GL_MATRIX10_ARB = $88CA;
- GL_MATRIX11_ARB = $88CB;
- GL_MATRIX12_ARB = $88CC;
- GL_MATRIX13_ARB = $88CD;
- GL_MATRIX14_ARB = $88CE;
- GL_MATRIX15_ARB = $88CF;
- GL_MATRIX16_ARB = $88D0;
- GL_MATRIX17_ARB = $88D1;
- GL_MATRIX18_ARB = $88D2;
- GL_MATRIX19_ARB = $88D3;
- GL_MATRIX20_ARB = $88D4;
- GL_MATRIX21_ARB = $88D5;
- GL_MATRIX22_ARB = $88D6;
- GL_MATRIX23_ARB = $88D7;
- GL_MATRIX24_ARB = $88D8;
- GL_MATRIX25_ARB = $88D9;
- GL_MATRIX26_ARB = $88DA;
- GL_MATRIX27_ARB = $88DB;
- GL_MATRIX28_ARB = $88DC;
- GL_MATRIX29_ARB = $88DD;
- GL_MATRIX30_ARB = $88DE;
- GL_MATRIX31_ARB = $88DF;
-
- // GL_ARB_draw_buffers
- GL_MAX_DRAW_BUFFERS_ARB = $8824;
- GL_DRAW_BUFFER0_ARB = $8825;
- GL_DRAW_BUFFER1_ARB = $8826;
- GL_DRAW_BUFFER2_ARB = $8827;
- GL_DRAW_BUFFER3_ARB = $8828;
- GL_DRAW_BUFFER4_ARB = $8829;
- GL_DRAW_BUFFER5_ARB = $882A;
- GL_DRAW_BUFFER6_ARB = $882B;
- GL_DRAW_BUFFER7_ARB = $882C;
- GL_DRAW_BUFFER8_ARB = $882D;
- GL_DRAW_BUFFER9_ARB = $882E;
- GL_DRAW_BUFFER10_ARB = $882F;
- GL_DRAW_BUFFER11_ARB = $8830;
- GL_DRAW_BUFFER12_ARB = $8831;
- GL_DRAW_BUFFER13_ARB = $8832;
- GL_DRAW_BUFFER14_ARB = $8833;
- GL_DRAW_BUFFER15_ARB = $8834;
-
- // GL_ARB_texture_rectangle
- GL_TEXTURE_RECTANGLE_ARB = $84F5;
- GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6;
- GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7;
- GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8;
-
- // GL_ARB_color_buffer_float
- GL_RGBA_FLOAT_MODE_ARB = $8820;
- GL_CLAMP_VERTEX_COLOR_ARB = $891A;
- GL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
- GL_CLAMP_READ_COLOR_ARB = $891C;
- GL_FIXED_ONLY_ARB = $891D;
- WGL_TYPE_RGBA_FLOAT_ARB = $21A0;
- GLX_RGBA_FLOAT_TYPE = $20B9;
- GLX_RGBA_FLOAT_BIT = $00000004;
-
- // GL_ARB_half_float_pixel
- GL_HALF_FLOAT_ARB = $140B;
-
- // GL_ARB_texture_float
- GL_TEXTURE_RED_TYPE_ARB = $8C10;
- GL_TEXTURE_GREEN_TYPE_ARB = $8C11;
- GL_TEXTURE_BLUE_TYPE_ARB = $8C12;
- GL_TEXTURE_ALPHA_TYPE_ARB = $8C13;
- GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14;
- GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15;
- GL_TEXTURE_DEPTH_TYPE_ARB = $8C16;
- GL_UNSIGNED_NORMALIZED_ARB = $8C17;
- GL_RGBA32F_ARB = $8814;
- GL_RGB32F_ARB = $8815;
- GL_ALPHA32F_ARB = $8816;
- GL_INTENSITY32F_ARB = $8817;
- GL_LUMINANCE32F_ARB = $8818;
- GL_LUMINANCE_ALPHA32F_ARB = $8819;
- GL_RGBA16F_ARB = $881A;
- GL_RGB16F_ARB = $881B;
- GL_ALPHA16F_ARB = $881C;
- GL_INTENSITY16F_ARB = $881D;
- GL_LUMINANCE16F_ARB = $881E;
- GL_LUMINANCE_ALPHA16F_ARB = $881F;
-
- // GL_ARB_pixel_buffer_object
- GL_PIXEL_PACK_BUFFER_ARB = $88EB;
- GL_PIXEL_UNPACK_BUFFER_ARB = $88EC;
- GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED;
- GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF;
-
- // GL_ARB_depth_buffer_float
- GL_DEPTH_COMPONENT32F = $8CAC;
- GL_DEPTH32F_STENCIL8 = $8CAD;
- GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD;
-
- // GL_ARB_framebuffer_object
- GL_INVALID_FRAMEBUFFER_OPERATION = $0506;
- GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210;
- GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211;
- GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212;
- GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213;
- GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214;
- GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215;
- GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216;
- GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217;
- GL_FRAMEBUFFER_DEFAULT = $8218;
- GL_FRAMEBUFFER_UNDEFINED = $8219;
- GL_DEPTH_STENCIL_ATTACHMENT = $821A;
- GL_MAX_RENDERBUFFER_SIZE = $84E8;
- GL_DEPTH_STENCIL = $84F9;
- GL_UNSIGNED_INT_24_8 = $84FA;
- GL_DEPTH24_STENCIL8 = $88F0;
- GL_TEXTURE_STENCIL_SIZE = $88F1;
- GL_TEXTURE_RED_TYPE = $8C10;
- GL_TEXTURE_GREEN_TYPE = $8C11;
- GL_TEXTURE_BLUE_TYPE = $8C12;
- GL_TEXTURE_ALPHA_TYPE = $8C13;
- GL_TEXTURE_DEPTH_TYPE = $8C16;
- GL_UNSIGNED_NORMALIZED = $8C17;
- GL_FRAMEBUFFER_BINDING = $8CA6;
- GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING;
- GL_RENDERBUFFER_BINDING = $8CA7;
- GL_READ_FRAMEBUFFER = $8CA8;
- GL_DRAW_FRAMEBUFFER = $8CA9;
- GL_READ_FRAMEBUFFER_BINDING = $8CAA;
- GL_RENDERBUFFER_SAMPLES = $8CAB;
- GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0;
- GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4;
- GL_FRAMEBUFFER_COMPLETE = $8CD5;
- GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6;
- GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7;
- GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB;
- GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC;
- GL_FRAMEBUFFER_UNSUPPORTED = $8CDD;
- GL_MAX_COLOR_ATTACHMENTS = $8CDF;
- GL_COLOR_ATTACHMENT0 = $8CE0;
- GL_COLOR_ATTACHMENT1 = $8CE1;
- GL_COLOR_ATTACHMENT2 = $8CE2;
- GL_COLOR_ATTACHMENT3 = $8CE3;
- GL_COLOR_ATTACHMENT4 = $8CE4;
- GL_COLOR_ATTACHMENT5 = $8CE5;
- GL_COLOR_ATTACHMENT6 = $8CE6;
- GL_COLOR_ATTACHMENT7 = $8CE7;
- GL_COLOR_ATTACHMENT8 = $8CE8;
- GL_COLOR_ATTACHMENT9 = $8CE9;
- GL_COLOR_ATTACHMENT10 = $8CEA;
- GL_COLOR_ATTACHMENT11 = $8CEB;
- GL_COLOR_ATTACHMENT12 = $8CEC;
- GL_COLOR_ATTACHMENT13 = $8CED;
- GL_COLOR_ATTACHMENT14 = $8CEE;
- GL_COLOR_ATTACHMENT15 = $8CEF;
- GL_DEPTH_ATTACHMENT = $8D00;
- GL_STENCIL_ATTACHMENT = $8D20;
- GL_FRAMEBUFFER = $8D40;
- GL_RENDERBUFFER = $8D41;
- GL_RENDERBUFFER_WIDTH = $8D42;
- GL_RENDERBUFFER_HEIGHT = $8D43;
- GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44;
- GL_STENCIL_INDEX1 = $8D46;
- GL_STENCIL_INDEX4 = $8D47;
- GL_STENCIL_INDEX8 = $8D48;
- GL_STENCIL_INDEX16 = $8D49;
- GL_RENDERBUFFER_RED_SIZE = $8D50;
- GL_RENDERBUFFER_GREEN_SIZE = $8D51;
- GL_RENDERBUFFER_BLUE_SIZE = $8D52;
- GL_RENDERBUFFER_ALPHA_SIZE = $8D53;
- GL_RENDERBUFFER_DEPTH_SIZE = $8D54;
- GL_RENDERBUFFER_STENCIL_SIZE = $8D55;
- GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56;
- GL_MAX_SAMPLES = $8D57;
-{$ifdef DGL_DEPRECATED}
- GL_INDEX = $8222;
- GL_TEXTURE_LUMINANCE_TYPE = $8C14;
- GL_TEXTURE_INTENSITY_TYPE = $8C15;
-{$endif}
-
- // GL_ARB_framebuffer_sRGB
- GL_FRAMEBUFFER_SRGB = $8DB9;
-
- // GL_ARB_geometry_shader4
- GL_LINES_ADJACENCY_ARB = $000A;
- GL_LINE_STRIP_ADJACENCY_ARB = $000B;
- GL_TRIANGLES_ADJACENCY_ARB = $000C;
- GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D;
- GL_PROGRAM_POINT_SIZE_ARB = $8642;
- GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29;
- GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7;
- GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8;
- GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9;
- GL_GEOMETRY_SHADER_ARB = $8DD9;
- GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA;
- GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB;
- GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC;
- GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD;
- GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE;
- GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF;
- GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0;
- GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1;
- { reuse GL_MAX_VARYING_COMPONENTS }
- { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
-
- // GL_ARB_half_float_vertex
- GL_HALF_FLOAT = $140B;
-
- // GL_ARB_instanced_arrays
- GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE;
-
- // GL_ARB_map_buffer_range
- GL_MAP_READ_BIT = $0001;
- GL_MAP_WRITE_BIT = $0002;
- GL_MAP_INVALIDATE_RANGE_BIT = $0004;
- GL_MAP_INVALIDATE_BUFFER_BIT = $0008;
- GL_MAP_FLUSH_EXPLICIT_BIT = $0010;
- GL_MAP_UNSYNCHRONIZED_BIT = $0020;
-
- // GL_ARB_texture_buffer_object
- GL_TEXTURE_BUFFER_ARB = $8C2A;
- GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B;
- GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C;
- GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D;
- GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E;
-
- // GL_ARB_texture_compression_rgtc
- GL_COMPRESSED_RED_RGTC1 = $8DBB;
- GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC;
- GL_COMPRESSED_RG_RGTC2 = $8DBD;
- GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE;
-
- // GL_ARB_texture_rg
- GL_RG = $8227;
- GL_RG_INTEGER = $8228;
- GL_R8 = $8229;
- GL_R16 = $822A;
- GL_RG8 = $822B;
- GL_RG16 = $822C;
- GL_R16F = $822D;
- GL_R32F = $822E;
- GL_RG16F = $822F;
- GL_RG32F = $8230;
- GL_R8I = $8231;
- GL_R8UI = $8232;
- GL_R16I = $8233;
- GL_R16UI = $8234;
- GL_R32I = $8235;
- GL_R32UI = $8236;
- GL_RG8I = $8237;
- GL_RG8UI = $8238;
- GL_RG16I = $8239;
- GL_RG16UI = $823A;
- GL_RG32I = $823B;
- GL_RG32UI = $823C;
-
- // GL_ARB_vertex_array_object
- GL_VERTEX_ARRAY_BINDING = $85B5;
-
- // GL_ARB_uniform_buffer_object
- GL_UNIFORM_BUFFER = $8A11;
- GL_UNIFORM_BUFFER_BINDING = $8A28;
- GL_UNIFORM_BUFFER_START = $8A29;
- GL_UNIFORM_BUFFER_SIZE = $8A2A;
- GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B;
- GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C;
- GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D;
- GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E;
- GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F;
- GL_MAX_UNIFORM_BLOCK_SIZE = $8A30;
- GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31;
- GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32;
- GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33;
- GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34;
- GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35;
- GL_ACTIVE_UNIFORM_BLOCKS = $8A36;
- GL_UNIFORM_TYPE = $8A37;
- GL_UNIFORM_SIZE = $8A38;
- GL_UNIFORM_NAME_LENGTH = $8A39;
- GL_UNIFORM_BLOCK_INDEX = $8A3A;
- GL_UNIFORM_OFFSET = $8A3B;
- GL_UNIFORM_ARRAY_STRIDE = $8A3C;
- GL_UNIFORM_MATRIX_STRIDE = $8A3D;
- GL_UNIFORM_IS_ROW_MAJOR = $8A3E;
- GL_UNIFORM_BLOCK_BINDING = $8A3F;
- GL_UNIFORM_BLOCK_DATA_SIZE = $8A40;
- GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41;
- GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42;
- GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43;
- GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44;
- GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = $8A45;
- GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46;
- GL_INVALID_INDEX = $FFFFFFFF;
-
- // GL_ARB_compatibility
- { ARB_compatibility just defines tokens from core 3.0 }
-
- // GL_ARB_copy_buffer
- GL_COPY_READ_BUFFER_BINDING = $8F36;
- GL_COPY_READ_BUFFER = GL_COPY_READ_BUFFER_BINDING;
- GL_COPY_WRITE_BUFFER_BINDING = $8F37;
- GL_COPY_WRITE_BUFFER = GL_COPY_WRITE_BUFFER_BINDING;
-
- // GL_ARB_depth_clamp
- GL_DEPTH_CLAMP = $864F;
-
- // GL_ARB_provoking_vertex
- GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C;
- GL_FIRST_VERTEX_CONVENTION = $8E4D;
- GL_LAST_VERTEX_CONVENTION = $8E4E;
- GL_PROVOKING_VERTEX = $8E4F;
-
- // GL_ARB_seamless_cube_map
- GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F;
-
- // GL_ARB_sync
- GL_MAX_SERVER_WAIT_TIMEOUT = $9111;
- GL_OBJECT_TYPE = $9112;
- GL_SYNC_CONDITION = $9113;
- GL_SYNC_STATUS = $9114;
- GL_SYNC_FLAGS = $9115;
- GL_SYNC_FENCE = $9116;
- GL_SYNC_GPU_COMMANDS_COMPLETE = $9117;
- GL_UNSIGNALED = $9118;
- GL_SIGNALED = $9119;
- GL_ALREADY_SIGNALED = $911A;
- GL_TIMEOUT_EXPIRED = $911B;
- GL_CONDITION_SATISFIED = $911C;
- GL_WAIT_FAILED = $911D;
- GL_SYNC_FLUSH_COMMANDS_BIT = $00000001;
- GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF;
-
- // GL_ARB_texture_multisample
- GL_SAMPLE_POSITION = $8E50;
- GL_SAMPLE_MASK = $8E51;
- GL_SAMPLE_MASK_VALUE = $8E52;
- GL_MAX_SAMPLE_MASK_WORDS = $8E59;
- GL_TEXTURE_2D_MULTISAMPLE = $9100;
- GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101;
- GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102;
- GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103;
- GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104;
- GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105;
- GL_TEXTURE_SAMPLES = $9106;
- GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107;
- GL_SAMPLER_2D_MULTISAMPLE = $9108;
- GL_INT_SAMPLER_2D_MULTISAMPLE = $9109;
- GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A;
- GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B;
- GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C;
- GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D;
- GL_MAX_COLOR_TEXTURE_SAMPLES = $910E;
- GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F;
- GL_MAX_INTEGER_SAMPLES = $9110;
-
- // GL_ARB_vertex_array_bgra
- { reuse GL_BGRA }
-
- // GL_ARB_sample_shading
- GL_SAMPLE_SHADING_ARB = $8C36;
- GL_MIN_SAMPLE_SHADING_VALUE_ARB = $8C37;
-
- // GL_ARB_texture_cube_map_array
- GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009;
- GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A;
- GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B;
- GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C;
- GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D;
- GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E;
- GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F;
-
- // GL_ARB_texture_gather
- GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E;
- GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F;
-
- // GL_ARB_shading_language_include
- GL_SHADER_INCLUDE_ARB = $8DAE;
- GL_NAMED_STRING_LENGTH_ARB = $8DE9;
- GL_NAMED_STRING_TYPE_ARB = $8DEA;
-
- // GL_ARB_texture_compression_bptc
- GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C;
- GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D;
- GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E;
- GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F;
-
- // GL_ARB_blend_func_extended
- GL_SRC1_COLOR = $88F9;
- { reuse GL_SRC1_ALPHA }
- GL_ONE_MINUS_SRC1_COLOR = $88FA;
- GL_ONE_MINUS_SRC1_ALPHA = $88FB;
- GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC;
-
- // GL_ARB_occlusion_query2
- GL_ANY_SAMPLES_PASSED = $8C2F;
-
- // GL_ARB_sampler_objects
- GL_SAMPLER_BINDING = $8919;
-
- // GL_ARB_texture_rgb10_a2ui
- GL_RGB10_A2UI = $906F;
-
- // GL_ARB_texture_swizzle
- GL_TEXTURE_SWIZZLE_R = $8E42;
- GL_TEXTURE_SWIZZLE_G = $8E43;
- GL_TEXTURE_SWIZZLE_B = $8E44;
- GL_TEXTURE_SWIZZLE_A = $8E45;
- GL_TEXTURE_SWIZZLE_RGBA = $8E46;
-
- // GL_ARB_timer_query
- GL_TIME_ELAPSED = $88BF;
- GL_TIMESTAMP = $8E28;
-
- // GL_ARB_vertex_type_2_10_10_10_rev
- { reuse GL_UNSIGNED_INT_2_10_10_10_REV }
- GL_INT_2_10_10_10_REV = $8D9F;
-
- // GL_ARB_draw_indirect
- GL_DRAW_INDIRECT_BUFFER = $8F3F;
- GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43;
-
- // GL_ARB_gpu_shader5
- GL_GEOMETRY_SHADER_INVOCATIONS = $887F;
- GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A;
- GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B;
- GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C;
- GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D;
- { reuse GL_MAX_VERTEX_STREAMS }
-
- // GL_ARB_gpu_shader_fp64
- { reuse GL_DOUBLE }
- GL_DOUBLE_VEC2 = $8FFC;
- GL_DOUBLE_VEC3 = $8FFD;
- GL_DOUBLE_VEC4 = $8FFE;
- GL_DOUBLE_MAT2 = $8F46;
- GL_DOUBLE_MAT3 = $8F47;
- GL_DOUBLE_MAT4 = $8F48;
- GL_DOUBLE_MAT2x3 = $8F49;
- GL_DOUBLE_MAT2x4 = $8F4A;
- GL_DOUBLE_MAT3x2 = $8F4B;
- GL_DOUBLE_MAT3x4 = $8F4C;
- GL_DOUBLE_MAT4x2 = $8F4D;
- GL_DOUBLE_MAT4x3 = $8F4E;
-
- // GL_ARB_shader_subroutine
- GL_ACTIVE_SUBROUTINES = $8DE5;
- GL_ACTIVE_SUBROUTINE_UNIFORMS = $8DE6;
- GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = $8E47;
- GL_ACTIVE_SUBROUTINE_MAX_LENGTH = $8E48;
- GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = $8E49;
- GL_MAX_SUBROUTINES = $8DE7;
- GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = $8DE8;
- GL_NUM_COMPATIBLE_SUBROUTINES = $8E4A;
- GL_COMPATIBLE_SUBROUTINES = $8E4B;
- { reuse GL_UNIFORM_SIZE }
- { reuse GL_UNIFORM_NAME_LENGTH }
-
- // GL_ARB_tessellation_shader
- GL_PATCHES = $000E;
- GL_PATCH_VERTICES = $8E72;
- GL_PATCH_DEFAULT_INNER_LEVEL = $8E73;
- GL_PATCH_DEFAULT_OUTER_LEVEL = $8E74;
- GL_TESS_CONTROL_OUTPUT_VERTICES = $8E75;
- GL_TESS_GEN_MODE = $8E76;
- GL_TESS_GEN_SPACING = $8E77;
- GL_TESS_GEN_VERTEX_ORDER = $8E78;
- GL_TESS_GEN_POINT_MODE = $8E79;
- { reuse GL_TRIANGLES }
- { reuse GL_QUADS }
- GL_ISOLINES = $8E7A;
- { reuse GL_EQUAL }
- GL_FRACTIONAL_ODD = $8E7B;
- GL_FRACTIONAL_EVEN = $8E7C;
- { reuse GL_CCW }
- { reuse GL_CW }
- GL_MAX_PATCH_VERTICES = $8E7D;
- GL_MAX_TESS_GEN_LEVEL = $8E7E;
- GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = $8E7F;
- GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E80;
- GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = $8E81;
- GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = $8E82;
- GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = $8E83;
- GL_MAX_TESS_PATCH_COMPONENTS = $8E84;
- GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = $8E85;
- GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = $8E86;
- GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = $8E89;
- GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = $8E8A;
- GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = $886C;
- GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = $886D;
- GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = $8E1E;
- GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E1F;
- GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = $84F0;
- GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = $84F1;
- GL_TESS_EVALUATION_SHADER = $8E87;
- GL_TESS_CONTROL_SHADER = $8E88;
-
- // GL_ARB_texture_buffer_object_rgb32
- { reuse GL_RGB32F }
- { reuse GL_RGB32UI }
- { reuse GL_RGB32I }
-
- // GL_ARB_transform_feedback2
- GL_TRANSFORM_FEEDBACK = $8E22;
- GL_TRANSFORM_FEEDBACK_PAUSED = $8E23;
- GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = GL_TRANSFORM_FEEDBACK_PAUSED;
- GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24;
- GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = GL_TRANSFORM_FEEDBACK_ACTIVE;
- GL_TRANSFORM_FEEDBACK_BINDING = $8E25;
-
- // GL_ARB_transform_feedback3
- GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = $8E70;
- GL_MAX_VERTEX_STREAMS = $8E71;
-
- // GL_ARB_ES2_compatibility
- GL_FIXED = $140C;
- GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A;
- GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B;
- GL_LOW_FLOAT = $8DF0;
- GL_MEDIUM_FLOAT = $8DF1;
- GL_HIGH_FLOAT = $8DF2;
- GL_LOW_INT = $8DF3;
- GL_MEDIUM_INT = $8DF4;
- GL_HIGH_INT = $8DF5;
- GL_SHADER_COMPILER = $8DFA;
- GL_NUM_SHADER_BINARY_FORMATS = $8DF9;
- GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB;
- GL_MAX_VARYING_VECTORS = $8DFC;
- GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD;
- GL_RGB565 = $8D62;
-
- // GL_ARB_get_program_binary
- GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257;
- GL_PROGRAM_BINARY_LENGTH = $8741;
- GL_NUM_PROGRAM_BINARY_FORMATS = $87FE;
- GL_PROGRAM_BINARY_FORMATS = $87FF;
-
- // GL_ARB_separate_shader_objects
- GL_VERTEX_SHADER_BIT = $00000001;
- GL_FRAGMENT_SHADER_BIT = $00000002;
- GL_GEOMETRY_SHADER_BIT = $00000004;
- GL_TESS_CONTROL_SHADER_BIT = $00000008;
- GL_TESS_EVALUATION_SHADER_BIT = $00000010;
- GL_ALL_SHADER_BITS = $FFFFFFFF;
- GL_PROGRAM_SEPARABLE = $8258;
- GL_ACTIVE_PROGRAM = $8259;
- GL_PROGRAM_PIPELINE_BINDING = $825A;
-
- // GL_ARB_vertex_attrib_64bit
- { reuse GL_RGB32I }
- { reuse GL_DOUBLE_VEC2 }
- { reuse GL_DOUBLE_VEC3 }
- { reuse GL_DOUBLE_VEC4 }
- { reuse GL_DOUBLE_MAT2 }
- { reuse GL_DOUBLE_MAT3 }
- { reuse GL_DOUBLE_MAT4 }
- { reuse GL_DOUBLE_MAT2x3 }
- { reuse GL_DOUBLE_MAT2x4 }
- { reuse GL_DOUBLE_MAT3x2 }
- { reuse GL_DOUBLE_MAT3x4 }
- { reuse GL_DOUBLE_MAT4x2 }
- { reuse GL_DOUBLE_MAT4x3 }
-
- // GL_ARB_viewport_array
- { reuse GL_SCISSOR_BOX }
- { reuse GL_VIEWPORT }
- { reuse GL_DEPTH_RANGE }
- { reuse GL_SCISSOR_TEST }
- GL_MAX_VIEWPORTS = $825B;
- GL_VIEWPORT_SUBPIXEL_BITS = $825C;
- GL_VIEWPORT_BOUNDS_RANGE = $825D;
- GL_LAYER_PROVOKING_VERTEX = $825E;
- GL_VIEWPORT_INDEX_PROVOKING_VERTEX = $825F;
- GL_UNDEFINED_VERTEX = $8260;
- { reuse GL_FIRST_VERTEX_CONVENTION }
- { reuse GL_LAST_VERTEX_CONVENTION }
- { reuse GL_PROVOKING_VERTEX }
-
- // GL_ARB_cl_event
- GL_SYNC_CL_EVENT_ARB = $8240;
- GL_SYNC_CL_EVENT_COMPLETE_ARB = $8241;
-
- // GL_ARB_debug_output
- GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = $8242;
- GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = $8243;
- GL_DEBUG_CALLBACK_FUNCTION_ARB = $8244;
- GL_DEBUG_CALLBACK_USER_PARAM_ARB = $8245;
- GL_DEBUG_SOURCE_API_ARB = $8246;
- GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = $8247;
- GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = $8248;
- GL_DEBUG_SOURCE_THIRD_PARTY_ARB = $8249;
- GL_DEBUG_SOURCE_APPLICATION_ARB = $824A;
- GL_DEBUG_SOURCE_OTHER_ARB = $824B;
- GL_DEBUG_TYPE_ERROR_ARB = $824C;
- GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = $824D;
- GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = $824E;
- GL_DEBUG_TYPE_PORTABILITY_ARB = $824F;
- GL_DEBUG_TYPE_PERFORMANCE_ARB = $8250;
- GL_DEBUG_TYPE_OTHER_ARB = $8251;
- GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = $9143;
- GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = $9144;
- GL_DEBUG_LOGGED_MESSAGES_ARB = $9145;
- GL_DEBUG_SEVERITY_HIGH_ARB = $9146;
- GL_DEBUG_SEVERITY_MEDIUM_ARB = $9147;
- GL_DEBUG_SEVERITY_LOW_ARB = $9148;
-
- // GL_ARB_robustness
- { reuse GL_NO_ERROR }
- GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = $00000004;
- GL_LOSE_CONTEXT_ON_RESET_ARB = $8252;
- GL_GUILTY_CONTEXT_RESET_ARB = $8253;
- GL_INNOCENT_CONTEXT_RESET_ARB = $8254;
- GL_UNKNOWN_CONTEXT_RESET_ARB = $8255;
- GL_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
- GL_NO_RESET_NOTIFICATION_ARB = $8261;
-
- // GL_ARB_compressed_texture_pixel_storage
- GL_UNPACK_COMPRESSED_BLOCK_WIDTH = $09127;
- GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = $09128;
- GL_UNPACK_COMPRESSED_BLOCK_DEPTH = $09129;
- GL_UNPACK_COMPRESSED_BLOCK_SIZE = $0912A;
- GL_PACK_COMPRESSED_BLOCK_WIDTH = $0912B;
- GL_PACK_COMPRESSED_BLOCK_HEIGHT = $0912C;
- GL_PACK_COMPRESSED_BLOCK_DEPTH = $0912D;
- GL_PACK_COMPRESSED_BLOCK_SIZE = $0912E;
-
- // GL_ARB_internalformat_query
- GL_NUM_SAMPLE_COUNTS = $09380;
-
- // GL_ARB_map_buffer_alignment
- GL_MIN_MAP_BUFFER_ALIGNMENT = $090BC;
-
- // GL_ARB_shader_atomic_counters
- GL_ATOMIC_COUNTER_BUFFER = $92C0;
- GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1;
- GL_ATOMIC_COUNTER_BUFFER_START = $92C2;
- GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3;
- GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = $92C4;
- GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = $92C5;
- GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = $92C6;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = $92C7;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = $92C8;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = $92C9;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = $92CA;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = $92CB;
- GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC;
- GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD;
- GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE;
- GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF;
- GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0;
- GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1;
- GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2;
- GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3;
- GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4;
- GL_MAX_GEOMETRY_ATOMIC_COUNTERS = $92D5;
- GL_MAX_FRAGMENT_ATOMIC_COUNTERS = $92D6;
- GL_MAX_COMBINED_ATOMIC_COUNTERS = $92D7;
- GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8;
- GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC;
- GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = $92D9;
- GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = $92DA;
- GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB;
-
- // GL_ARB_shader_image_load_store
- GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001;
- GL_ELEMENT_ARRAY_BARRIER_BIT = $00000002;
- GL_UNIFORM_BARRIER_BIT = $00000004;
- GL_TEXTURE_FETCH_BARRIER_BIT = $00000008;
- GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020;
- GL_COMMAND_BARRIER_BIT = $00000040;
- GL_PIXEL_BUFFER_BARRIER_BIT = $00000080;
- GL_TEXTURE_UPDATE_BARRIER_BIT = $00000100;
- GL_BUFFER_UPDATE_BARRIER_BIT = $00000200;
- GL_FRAMEBUFFER_BARRIER_BIT = $00000400;
- GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800;
- GL_ATOMIC_COUNTER_BARRIER_BIT = $00001000;
- GL_ALL_BARRIER_BITS = $FFFFFFFF;
- GL_MAX_IMAGE_UNITS = $8F38;
- GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = $8F39;
- GL_IMAGE_BINDING_NAME = $8F3A;
- GL_IMAGE_BINDING_LEVEL = $8F3B;
- GL_IMAGE_BINDING_LAYERED = $8F3C;
- GL_IMAGE_BINDING_LAYER = $8F3D;
- GL_IMAGE_BINDING_ACCESS = $8F3E;
- GL_IMAGE_1D = $904C;
- GL_IMAGE_2D = $904D;
- GL_IMAGE_3D = $904E;
- GL_IMAGE_2D_RECT = $904F;
- GL_IMAGE_CUBE = $9050;
- GL_IMAGE_BUFFER = $9051;
- GL_IMAGE_1D_ARRAY = $9052;
- GL_IMAGE_2D_ARRAY = $9053;
- GL_IMAGE_CUBE_MAP_ARRAY = $9054;
- GL_IMAGE_2D_MULTISAMPLE = $9055;
- GL_IMAGE_2D_MULTISAMPLE_ARRAY = $9056;
- GL_INT_IMAGE_1D = $9057;
- GL_INT_IMAGE_2D = $9058;
- GL_INT_IMAGE_3D = $9059;
- GL_INT_IMAGE_2D_RECT = $905A;
- GL_INT_IMAGE_CUBE = $905B;
- GL_INT_IMAGE_BUFFER = $905C;
- GL_INT_IMAGE_1D_ARRAY = $905D;
- GL_INT_IMAGE_2D_ARRAY = $905E;
- GL_INT_IMAGE_CUBE_MAP_ARRAY = $905F;
- GL_INT_IMAGE_2D_MULTISAMPLE = $9060;
- GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $9061;
- GL_UNSIGNED_INT_IMAGE_1D = $9062;
- GL_UNSIGNED_INT_IMAGE_2D = $9063;
- GL_UNSIGNED_INT_IMAGE_3D = $9064;
- GL_UNSIGNED_INT_IMAGE_2D_RECT = $9065;
- GL_UNSIGNED_INT_IMAGE_CUBE = $9066;
- GL_UNSIGNED_INT_IMAGE_BUFFER = $9067;
- GL_UNSIGNED_INT_IMAGE_1D_ARRAY = $9068;
- GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069;
- GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A;
- GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = $906B;
- GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $906C;
- GL_MAX_IMAGE_SAMPLES = $906D;
- GL_IMAGE_BINDING_FORMAT = $906E;
- GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7;
- GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8;
- GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9;
- GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA;
- GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB;
- GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC;
- GL_MAX_GEOMETRY_IMAGE_UNIFORMS = $90CD;
- GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE;
- GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF;
-
- // GL_ARB_texture_storage
- GL_TEXTURE_IMMUTABLE_FORMAT = $912F;
-
- // 4.3
- GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0;
- GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1;
- GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2;
- GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3;
- GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4;
- GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5;
- GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6;
- GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7;
- GL_COMPRESSED_RGBA_ASTC_105_KHR = $93B8;
- GL_COMPRESSED_RGBA_ASTC_106_KHR = $93B9;
- GL_COMPRESSED_RGBA_ASTC_108_KHR = $93BA;
- GL_COMPRESSED_RGBA_ASTC_110_KHR = $93BB;
- GL_COMPRESSED_RGBA_ASTC_12x10_KHR = $93BC;
- GL_COMPRESSED_RGBA_ASTC_12x12_KHR = $93BD;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = $93D0;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = $93D1;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = $93D2;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = $93D3;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = $93D4;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = $93D5;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = $93D6;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = $93D7;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = $93D8;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = $93D9;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = $93DA;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = $93DB;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = $93DC;
- GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = $93DD;
- // (4.3) GL_KHR_debug
- GL_DEBUG_OUTPUT_SYNCHRONOUS = $8242;
- GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = $8243;
- GL_DEBUG_CALLBACK_FUNCTION = $8244;
- GL_DEBUG_CALLBACK_USER_PARAM = $8245;
- GL_DEBUG_SOURCE_API = $8246;
- GL_DEBUG_SOURCE_WINDOW_SYSTEM = $8247;
- GL_DEBUG_SOURCE_SHADER_COMPILER = $8248;
- GL_DEBUG_SOURCE_THIRD_PARTY = $8249;
- GL_DEBUG_SOURCE_APPLICATION = $824A;
- GL_DEBUG_SOURCE_OTHER = $824B;
- GL_DEBUG_TYPE_ERROR = $824C;
- GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = $824D;
- GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = $824E;
- GL_DEBUG_TYPE_PORTABILITY = $824F;
- GL_DEBUG_TYPE_PERFORMANCE = $8250;
- GL_DEBUG_TYPE_OTHER = $8251;
- GL_DEBUG_TYPE_MARKER = $8268;
- GL_DEBUG_TYPE_PUSH_GROUP = $8269;
- GL_DEBUG_TYPE_POP_GROUP = $826A;
- GL_DEBUG_SEVERITY_NOTIFICATION = $826B;
- GL_MAX_DEBUG_GROUP_STACK_DEPTH = $826C;
- GL_DEBUG_GROUP_STACK_DEPTH = $826D;
- GL_BUFFER = $82E0;
- GL_SHADER = $82E1;
- GL_PROGRAM = $82E2;
- GL_QUERY = $82E3;
- GL_PROGRAM_PIPELINE = $82E4;
- GL_SAMPLER = $82E6;
- GL_DISPLAY_LIST = $82E7;
- GL_MAX_LABEL_LENGTH = $82E8;
- GL_MAX_DEBUG_MESSAGE_LENGTH = $9143;
- GL_MAX_DEBUG_LOGGED_MESSAGES = $9144;
- GL_DEBUG_LOGGED_MESSAGES = $9145;
- GL_DEBUG_SEVERITY_HIGH = $9146;
- GL_DEBUG_SEVERITY_MEDIUM = $9147;
- GL_DEBUG_SEVERITY_LOW = $9148;
- GL_DEBUG_OUTPUT = $92E0;
- GL_CONTEXT_FLAG_DEBUG_BIT = $00000002;
- GL_COMPUTE_SHADER = $91B9;
- GL_MAX_COMPUTE_UNIFORM_BLOCKS = $91BB;
- GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC;
- GL_MAX_COMPUTE_IMAGE_UNIFORMS = $91BD;
- GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262;
- GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263;
- GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264;
- GL_MAX_COMPUTE_ATOMIC_COUNTERS = $8265;
- GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266;
- GL_MAX_COMPUTE_LOCAL_INVOCATIONS = $90EB;
- GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE;
- GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF;
- GL_COMPUTE_LOCAL_WORK_SIZE = $8267;
- GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = $90EC;
- GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = $90ED;
- GL_DISPATCH_INDIRECT_BUFFER = $90EE;
- GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF;
- GL_COMPUTE_SHADER_BIT = $00000020;
- GL_COMPRESSED_RGB8_ETC2 = $9274;
- GL_COMPRESSED_SRGB8_ETC2 = $9275;
- GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276;
- GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277;
- GL_COMPRESSED_RGBA8_ETC2_EAC = $9278;
- GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279;
- GL_COMPRESSED_R11_EAC = $9270;
- GL_COMPRESSED_SIGNED_R11_EAC = $9271;
- GL_COMPRESSED_RG11_EAC = $9272;
- GL_COMPRESSED_SIGNED_RG11_EAC = $9273;
- GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69;
- GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A;
- GL_MAX_ELEMENT_INDEX = $8D6B;
- GL_MAX_UNIFORM_LOCATIONS = $826E;
- GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310;
- GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311;
- GL_FRAMEBUFFER_DEFAULT_LAYERS = $9312;
- GL_FRAMEBUFFER_DEFAULT_SAMPLES = $9313;
- GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314;
- GL_MAX_FRAMEBUFFER_WIDTH = $9315;
- GL_MAX_FRAMEBUFFER_HEIGHT = $9316;
- GL_MAX_FRAMEBUFFER_LAYERS = $9317;
- GL_MAX_FRAMEBUFFER_SAMPLES = $9318;
- GL_INTERNALFORMAT_SUPPORTED = $826F;
- GL_INTERNALFORMAT_PREFERRED = $8270;
- GL_INTERNALFORMAT_RED_SIZE = $8271;
- GL_INTERNALFORMAT_GREEN_SIZE = $8272;
- GL_INTERNALFORMAT_BLUE_SIZE = $8273;
- GL_INTERNALFORMAT_ALPHA_SIZE = $8274;
- GL_INTERNALFORMAT_DEPTH_SIZE = $8275;
- GL_INTERNALFORMAT_STENCIL_SIZE = $8276;
- GL_INTERNALFORMAT_SHARED_SIZE = $8277;
- GL_INTERNALFORMAT_RED_TYPE = $8278;
- GL_INTERNALFORMAT_GREEN_TYPE = $8279;
- GL_INTERNALFORMAT_BLUE_TYPE = $827A;
- GL_INTERNALFORMAT_ALPHA_TYPE = $827B;
- GL_INTERNALFORMAT_DEPTH_TYPE = $827C;
- GL_INTERNALFORMAT_STENCIL_TYPE = $827D;
- GL_MAX_WIDTH = $827E;
- GL_MAX_HEIGHT = $827F;
- GL_MAX_DEPTH = $8280;
- GL_MAX_LAYERS = $8281;
- GL_MAX_COMBINED_DIMENSIONS = $8282;
- GL_COLOR_COMPONENTS = $8283;
- GL_DEPTH_COMPONENTS = $8284;
- GL_STENCIL_COMPONENTS = $8285;
- GL_COLOR_RENDERABLE = $8286;
- GL_DEPTH_RENDERABLE = $8287;
- GL_STENCIL_RENDERABLE = $8288;
- GL_FRAMEBUFFER_RENDERABLE = $8289;
- GL_FRAMEBUFFER_RENDERABLE_LAYERED = $828A;
- GL_FRAMEBUFFER_BLEND = $828B;
- GL_READ_PIXELS = $828C;
- GL_READ_PIXELS_FORMAT = $828D;
- GL_READ_PIXELS_TYPE = $828E;
- GL_TEXTURE_IMAGE_FORMAT = $828F;
- GL_TEXTURE_IMAGE_TYPE = $8290;
- GL_GET_TEXTURE_IMAGE_FORMAT = $8291;
- GL_GET_TEXTURE_IMAGE_TYPE = $8292;
- GL_MIPMAP = $8293;
- GL_MANUAL_GENERATE_MIPMAP = $8294;
- GL_AUTO_GENERATE_MIPMAP = $8295;
- GL_COLOR_ENCODING = $8296;
- GL_SRGB_READ = $8297;
- GL_SRGB_WRITE = $8298;
- GL_SRGB_DECODE_ARB = $8299;
- GL_FILTER = $829A;
- GL_VERTEX_TEXTURE = $829B;
- GL_TESS_CONTROL_TEXTURE = $829C;
- GL_TESS_EVALUATION_TEXTURE = $829D;
- GL_GEOMETRY_TEXTURE = $829E;
- GL_FRAGMENT_TEXTURE = $829F;
- GL_COMPUTE_TEXTURE = $82A0;
- GL_TEXTURE_SHADOW = $82A1;
- GL_TEXTURE_GATHER = $82A2;
- GL_TEXTURE_GATHER_SHADOW = $82A3;
- GL_SHADER_IMAGE_LOAD = $82A4;
- GL_SHADER_IMAGE_STORE = $82A5;
- GL_SHADER_IMAGE_ATOMIC = $82A6;
- GL_IMAGE_TEXEL_SIZE = $82A7;
- GL_IMAGE_COMPATIBILITY_CLASS = $82A8;
- GL_IMAGE_PIXEL_FORMAT = $82A9;
- GL_IMAGE_PIXEL_TYPE = $82AA;
- GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = $82AC;
- GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = $82AD;
- GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = $82AE;
- GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = $82AF;
- GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = $82B1;
- GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = $82B2;
- GL_TEXTURE_COMPRESSED_BLOCK_SIZE = $82B3;
- GL_CLEAR_BUFFER = $82B4;
- GL_TEXTURE_VIEW = $82B5;
- GL_VIEW_COMPATIBILITY_CLASS = $82B6;
- GL_FULL_SUPPORT = $82B7;
- GL_CAVEAT_SUPPORT = $82B8;
- GL_IMAGE_CLASS_4_X_32 = $82B9;
- GL_IMAGE_CLASS_2_X_32 = $82BA;
- GL_IMAGE_CLASS_1_X_32 = $82BB;
- GL_IMAGE_CLASS_4_X_16 = $82BC;
- GL_IMAGE_CLASS_2_X_16 = $82BD;
- GL_IMAGE_CLASS_1_X_16 = $82BE;
- GL_IMAGE_CLASS_4_X_8 = $82BF;
- GL_IMAGE_CLASS_2_X_8 = $82C0;
- GL_IMAGE_CLASS_1_X_8 = $82C1;
- GL_IMAGE_CLASS_11_11_10 = $82C2;
- GL_IMAGE_CLASS_10_10_10_2 = $82C3;
- GL_VIEW_CLASS_128_BITS = $82C4;
- GL_VIEW_CLASS_96_BITS = $82C5;
- GL_VIEW_CLASS_64_BITS = $82C6;
- GL_VIEW_CLASS_48_BITS = $82C7;
- GL_VIEW_CLASS_32_BITS = $82C8;
- GL_VIEW_CLASS_24_BITS = $82C9;
- GL_VIEW_CLASS_16_BITS = $82CA;
- GL_VIEW_CLASS_8_BITS = $82CB;
- GL_VIEW_CLASS_S3TC_DXT1_RGB = $82CC;
- GL_VIEW_CLASS_S3TC_DXT1_RGBA = $82CD;
- GL_VIEW_CLASS_S3TC_DXT3_RGBA = $82CE;
- GL_VIEW_CLASS_S3TC_DXT5_RGBA = $82CF;
- GL_VIEW_CLASS_RGTC1_RED = $82D0;
- GL_VIEW_CLASS_RGTC2_RG = $82D1;
- GL_VIEW_CLASS_BPTC_UNORM = $82D2;
- GL_VIEW_CLASS_BPTC_FLOAT = $82D3;
- GL_UNIFORM = $92E1;
- GL_UNIFORM_BLOCK = $92E2;
- GL_PROGRAM_INPUT = $92E3;
- GL_PROGRAM_OUTPUT = $92E4;
- GL_BUFFER_VARIABLE = $92E5;
- GL_SHADER_STORAGE_BLOCK = $92E6;
- GL_VERTEX_SUBROUTINE = $92E8;
- GL_TESS_CONTROL_SUBROUTINE = $92E9;
- GL_TESS_EVALUATION_SUBROUTINE = $92EA;
- GL_GEOMETRY_SUBROUTINE = $92EB;
- GL_FRAGMENT_SUBROUTINE = $92EC;
- GL_COMPUTE_SUBROUTINE = $92ED;
- GL_VERTEX_SUBROUTINE_UNIFORM = $92EE;
- GL_TESS_CONTROL_SUBROUTINE_UNIFORM = $92EF;
- GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = $92F0;
- GL_GEOMETRY_SUBROUTINE_UNIFORM = $92F1;
- GL_FRAGMENT_SUBROUTINE_UNIFORM = $92F2;
- GL_COMPUTE_SUBROUTINE_UNIFORM = $92F3;
- GL_TRANSFORM_FEEDBACK_VARYING = $92F4;
- GL_ACTIVE_RESOURCES = $92F5;
- GL_MAX_NAME_LENGTH = $92F6;
- GL_MAX_NUM_ACTIVE_VARIABLES = $92F7;
- GL_MAX_NUM_COMPATIBLE_SUBROUTINES = $92F8;
- GL_NAME_LENGTH = $92F9;
- GL_TYPE = $92FA;
- GL_ARRAY_SIZE = $92FB;
- GL_OFFSET = $92FC;
- GL_BLOCK_INDEX = $92FD;
- GL_ARRAY_STRIDE = $92FE;
- GL_MATRIX_STRIDE = $92FF;
- GL_IS_ROW_MAJOR = $9300;
- GL_ATOMIC_COUNTER_BUFFER_INDEX = $9301;
- GL_BUFFER_BINDING = $9302;
- GL_BUFFER_DATA_SIZE = $9303;
- GL_NUM_ACTIVE_VARIABLES = $9304;
- GL_ACTIVE_VARIABLES = $9305;
- GL_REFERENCED_BY_VERTEX_SHADER = $9306;
- GL_REFERENCED_BY_TESS_CONTROL_SHADER = $9307;
- GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308;
- GL_REFERENCED_BY_GEOMETRY_SHADER = $9309;
- GL_REFERENCED_BY_FRAGMENT_SHADER = $930A;
- GL_REFERENCED_BY_COMPUTE_SHADER = $930B;
- GL_TOP_LEVEL_ARRAY_SIZE = $930C;
- GL_TOP_LEVEL_ARRAY_STRIDE = $930D;
- GL_LOCATION = $930E;
- GL_LOCATION_INDEX = $930F;
- GL_IS_PER_PATCH = $92E7;
- GL_SHADER_STORAGE_BUFFER = $90D2;
- GL_SHADER_STORAGE_BUFFER_BINDING = $90D3;
- GL_SHADER_STORAGE_BUFFER_START = $90D4;
- GL_SHADER_STORAGE_BUFFER_SIZE = $90D5;
- GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6;
- GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7;
- GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8;
- GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9;
- GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA;
- GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB;
- GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC;
- GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD;
- GL_MAX_SHADER_STORAGE_BLOCK_SIZE = $90DE;
- GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF;
- GL_SHADER_STORAGE_BARRIER_BIT = $2000;
- GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS;
- GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA;
- GL_TEXTURE_BUFFER_OFFSET = $919D;
- GL_TEXTURE_BUFFER_SIZE = $919E;
- GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F;
- GL_TEXTURE_VIEW_MIN_LEVEL = $82DB;
- GL_TEXTURE_VIEW_NUM_LEVELS = $82DC;
- GL_TEXTURE_VIEW_MIN_LAYER = $82DD;
- GL_TEXTURE_VIEW_NUM_LAYERS = $82DE;
- GL_TEXTURE_IMMUTABLE_LEVELS = $82DF;
- GL_VERTEX_ATTRIB_BINDING = $82D4;
- GL_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D5;
- GL_VERTEX_BINDING_DIVISOR = $82D6;
- GL_VERTEX_BINDING_OFFSET = $82D7;
- GL_VERTEX_BINDING_STRIDE = $82D8;
- GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9;
- GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA;
- // END 4.3
-
- // GL 4.4
- GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5;
- GL_MAP_PERSISTENT_BIT = $0040;
- GL_MAP_COHERENT_BIT = $0080;
- GL_DYNAMIC_STORAGE_BIT = $0100;
- GL_CLIENT_STORAGE_BIT = $0200;
- GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = $00004000;
- GL_BUFFER_IMMUTABLE_STORAGE = $821F;
- GL_BUFFER_STORAGE_FLAGS = $8220;
- GL_CLEAR_TEXTURE = $9365;
- GL_LOCATION_COMPONENT = $934A;
- GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = $934B;
- GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = $934C;
- GL_QUERY_BUFFER = $9192;
- GL_QUERY_BUFFER_BARRIER_BIT = $00008000;
- GL_QUERY_BUFFER_BINDING = $9193;
- GL_QUERY_RESULT_NO_WAIT = $9194;
- GL_MIRROR_CLAMP_TO_EDGE = $8743;
- // END GL 4.4
-
- // GL_ATI_draw_buffers
- GL_MAX_DRAW_BUFFERS_ATI = $8824;
- GL_DRAW_BUFFER0_ATI = $8825;
- GL_DRAW_BUFFER1_ATI = $8826;
- GL_DRAW_BUFFER2_ATI = $8827;
- GL_DRAW_BUFFER3_ATI = $8828;
- GL_DRAW_BUFFER4_ATI = $8829;
- GL_DRAW_BUFFER5_ATI = $882A;
- GL_DRAW_BUFFER6_ATI = $882B;
- GL_DRAW_BUFFER7_ATI = $882C;
- GL_DRAW_BUFFER8_ATI = $882D;
- GL_DRAW_BUFFER9_ATI = $882E;
- GL_DRAW_BUFFER10_ATI = $882F;
- GL_DRAW_BUFFER11_ATI = $8830;
- GL_DRAW_BUFFER12_ATI = $8831;
- GL_DRAW_BUFFER13_ATI = $8832;
- GL_DRAW_BUFFER14_ATI = $8833;
- GL_DRAW_BUFFER15_ATI = $8834;
-
- // GL_ATI_element_array
- GL_ELEMENT_ARRAY_ATI = $8768;
- GL_ELEMENT_ARRAY_TYPE_ATI = $8769;
- GL_ELEMENT_ARRAY_POINTER_ATI = $876A;
-
- // GL_ATI_envmap_bumpmap
- GL_BUMP_ROT_MATRIX_ATI = $8775;
- GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776;
- GL_BUMP_NUM_TEX_UNITS_ATI = $8777;
- GL_BUMP_TEX_UNITS_ATI = $8778;
- GL_DUDV_ATI = $8779;
- GL_DU8DV8_ATI = $877A;
- GL_BUMP_ENVMAP_ATI = $877B;
- GL_BUMP_TARGET_ATI = $877C;
-
- // GL_ATI_fragment_shader
- GL_FRAGMENT_SHADER_ATI = $8920;
- GL_REG_0_ATI = $8921;
- GL_REG_1_ATI = $8922;
- GL_REG_2_ATI = $8923;
- GL_REG_3_ATI = $8924;
- GL_REG_4_ATI = $8925;
- GL_REG_5_ATI = $8926;
- GL_REG_6_ATI = $8927;
- GL_REG_7_ATI = $8928;
- GL_REG_8_ATI = $8929;
- GL_REG_9_ATI = $892A;
- GL_REG_10_ATI = $892B;
- GL_REG_11_ATI = $892C;
- GL_REG_12_ATI = $892D;
- GL_REG_13_ATI = $892E;
- GL_REG_14_ATI = $892F;
- GL_REG_15_ATI = $8930;
- GL_REG_16_ATI = $8931;
- GL_REG_17_ATI = $8932;
- GL_REG_18_ATI = $8933;
- GL_REG_19_ATI = $8934;
- GL_REG_20_ATI = $8935;
- GL_REG_21_ATI = $8936;
- GL_REG_22_ATI = $8937;
- GL_REG_23_ATI = $8938;
- GL_REG_24_ATI = $8939;
- GL_REG_25_ATI = $893A;
- GL_REG_26_ATI = $893B;
- GL_REG_27_ATI = $893C;
- GL_REG_28_ATI = $893D;
- GL_REG_29_ATI = $893E;
- GL_REG_30_ATI = $893F;
- GL_REG_31_ATI = $8940;
- GL_CON_0_ATI = $8941;
- GL_CON_1_ATI = $8942;
- GL_CON_2_ATI = $8943;
- GL_CON_3_ATI = $8944;
- GL_CON_4_ATI = $8945;
- GL_CON_5_ATI = $8946;
- GL_CON_6_ATI = $8947;
- GL_CON_7_ATI = $8948;
- GL_CON_8_ATI = $8949;
- GL_CON_9_ATI = $894A;
- GL_CON_10_ATI = $894B;
- GL_CON_11_ATI = $894C;
- GL_CON_12_ATI = $894D;
- GL_CON_13_ATI = $894E;
- GL_CON_14_ATI = $894F;
- GL_CON_15_ATI = $8950;
- GL_CON_16_ATI = $8951;
- GL_CON_17_ATI = $8952;
- GL_CON_18_ATI = $8953;
- GL_CON_19_ATI = $8954;
- GL_CON_20_ATI = $8955;
- GL_CON_21_ATI = $8956;
- GL_CON_22_ATI = $8957;
- GL_CON_23_ATI = $8958;
- GL_CON_24_ATI = $8959;
- GL_CON_25_ATI = $895A;
- GL_CON_26_ATI = $895B;
- GL_CON_27_ATI = $895C;
- GL_CON_28_ATI = $895D;
- GL_CON_29_ATI = $895E;
- GL_CON_30_ATI = $895F;
- GL_CON_31_ATI = $8960;
- GL_MOV_ATI = $8961;
- GL_ADD_ATI = $8963;
- GL_MUL_ATI = $8964;
- GL_SUB_ATI = $8965;
- GL_DOT3_ATI = $8966;
- GL_DOT4_ATI = $8967;
- GL_MAD_ATI = $8968;
- GL_LERP_ATI = $8969;
- GL_CND_ATI = $896A;
- GL_CND0_ATI = $896B;
- GL_DOT2_ADD_ATI = $896C;
- GL_SECONDARY_INTERPOLATOR_ATI = $896D;
- GL_NUM_FRAGMENT_REGISTERS_ATI = $896E;
- GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F;
- GL_NUM_PASSES_ATI = $8970;
- GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971;
- GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972;
- GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973;
- GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974;
- GL_COLOR_ALPHA_PAIRING_ATI = $8975;
- GL_SWIZZLE_STR_ATI = $8976;
- GL_SWIZZLE_STQ_ATI = $8977;
- GL_SWIZZLE_STR_DR_ATI = $8978;
- GL_SWIZZLE_STQ_DQ_ATI = $8979;
- GL_SWIZZLE_STRQ_ATI = $897A;
- GL_SWIZZLE_STRQ_DQ_ATI = $897B;
- GL_RED_BIT_ATI = $00000001;
- GL_GREEN_BIT_ATI = $00000002;
- GL_BLUE_BIT_ATI = $00000004;
- GL_2X_BIT_ATI = $00000001;
- GL_4X_BIT_ATI = $00000002;
- GL_8X_BIT_ATI = $00000004;
- GL_HALF_BIT_ATI = $00000008;
- GL_QUARTER_BIT_ATI = $00000010;
- GL_EIGHTH_BIT_ATI = $00000020;
- GL_SATURATE_BIT_ATI = $00000040;
- GL_COMP_BIT_ATI = $00000002;
- GL_NEGATE_BIT_ATI = $00000004;
- GL_BIAS_BIT_ATI = $00000008;
-
- // GL_ATI_pn_triangles
- GL_PN_TRIANGLES_ATI = $87F0;
- GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1;
- GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2;
- GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3;
- GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4;
- GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5;
- GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6;
- GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7;
- GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8;
-
- // GL_ATI_separate_stencil
- GL_STENCIL_BACK_FUNC_ATI = $8800;
- GL_STENCIL_BACK_FAIL_ATI = $8801;
- GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802;
- GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803;
-
- // GL_ATI_text_fragment_shader
- GL_TEXT_FRAGMENT_SHADER_ATI = $8200;
-
- // GL_ATI_texture_env_combine3
- GL_MODULATE_ADD_ATI = $8744;
- GL_MODULATE_SIGNED_ADD_ATI = $8745;
- GL_MODULATE_SUBTRACT_ATI = $8746;
-
- // GL_ATI_texture_float
- GL_RGBA_FLOAT32_ATI = $8814;
- GL_RGB_FLOAT32_ATI = $8815;
- GL_ALPHA_FLOAT32_ATI = $8816;
- GL_INTENSITY_FLOAT32_ATI = $8817;
- GL_LUMINANCE_FLOAT32_ATI = $8818;
- GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819;
- GL_RGBA_FLOAT16_ATI = $881A;
- GL_RGB_FLOAT16_ATI = $881B;
- GL_ALPHA_FLOAT16_ATI = $881C;
- GL_INTENSITY_FLOAT16_ATI = $881D;
- GL_LUMINANCE_FLOAT16_ATI = $881E;
- GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F;
-
- // GL_ATI_texture_mirror_once
- GL_MIRROR_CLAMP_ATI = $8742;
- GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743;
-
- // GL_ATI_vertex_array_object
- GL_STATIC_ATI = $8760;
- GL_DYNAMIC_ATI = $8761;
- GL_PRESERVE_ATI = $8762;
- GL_DISCARD_ATI = $8763;
- GL_OBJECT_BUFFER_SIZE_ATI = $8764;
- GL_OBJECT_BUFFER_USAGE_ATI = $8765;
- GL_ARRAY_OBJECT_BUFFER_ATI = $8766;
- GL_ARRAY_OBJECT_OFFSET_ATI = $8767;
-
- // GL_ATI_vertex_streams
- GL_MAX_VERTEX_STREAMS_ATI = $876B;
- GL_VERTEX_STREAM0_ATI = $876C;
- GL_VERTEX_STREAM1_ATI = $876D;
- GL_VERTEX_STREAM2_ATI = $876E;
- GL_VERTEX_STREAM3_ATI = $876F;
- GL_VERTEX_STREAM4_ATI = $8770;
- GL_VERTEX_STREAM5_ATI = $8771;
- GL_VERTEX_STREAM6_ATI = $8772;
- GL_VERTEX_STREAM7_ATI = $8773;
- GL_VERTEX_SOURCE_ATI = $8774;
-
- // GL_ATI_meminfo
- GL_VBO_FREE_MEMORY_ATI = $87FB;
- GL_TEXTURE_FREE_MEMORY_ATI = $87FC;
- GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD;
-
- // GL_AMD_performance_monitor
- GL_COUNTER_TYPE_AMD = $8BC0;
- GL_COUNTER_RANGE_AMD = $8BC1;
- GL_UNSIGNED_INT64_AMD = $8BC2;
- GL_PERCENTAGE_AMD = $8BC3;
- GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4;
- GL_PERFMON_RESULT_SIZE_AMD = $8BC5;
- GL_PERFMON_RESULT_AMD = $8BC6;
-
- // GL_AMD_vertex_shader_tesselator
- GL_SAMPLER_BUFFER_AMD = $9001;
- GL_INT_SAMPLER_BUFFER_AMD = $9002;
- GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003;
- GL_TESSELLATION_MODE_AMD = $9004;
- GL_TESSELLATION_FACTOR_AMD = $9005;
- GL_DISCRETE_AMD = $9006;
- GL_CONTINUOUS_AMD = $9007;
-
- // GL_AMD_seamless_cubemap_per_texture
- { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS }
-
- // GL_AMD_name_gen_delete
- GL_DATA_BUFFER_AMD = $9151;
- GL_PERFORMANCE_MONITOR_AMD = $9152;
- GL_QUERY_OBJECT_AMD = $9153;
- GL_VERTEX_ARRAY_OBJECT_AMD = $9154;
- GL_SAMPLER_OBJECT_AMD = $9155;
-
- // GL_AMD_debug_output
- GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = $9144;
- GL_DEBUG_LOGGED_MESSAGES_AMD = $9145;
- GL_DEBUG_SEVERITY_HIGH_AMD = $9146;
- GL_DEBUG_SEVERITY_MEDIUM_AMD = $9147;
- GL_DEBUG_SEVERITY_LOW_AMD = $9148;
- GL_DEBUG_CATEGORY_API_ERROR_AMD = $9149;
- GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = $914A;
- GL_DEBUG_CATEGORY_DEPRECATION_AMD = $914B;
- GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = $914C;
- GL_DEBUG_CATEGORY_PERFORMANCE_AMD = $914D;
- GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = $914E;
- GL_DEBUG_CATEGORY_APPLICATION_AMD = $914F;
- GL_DEBUG_CATEGORY_OTHER_AMD = $9150;
-
- // GL_AMD_depth_clamp_separate
- GL_DEPTH_CLAMP_NEAR_AMD = $901E;
- GL_DEPTH_CLAMP_FAR_AMD = $901F;
-
- // GL_EXT_422_pixels
- GL_422_EXT = $80CC;
- GL_422_REV_EXT = $80CD;
- GL_422_AVERAGE_EXT = $80CE;
- GL_422_REV_AVERAGE_EXT = $80CF;
-
- // GL_EXT_abgr
- GL_ABGR_EXT = $8000;
-
- // GL_EXT_bgra
- GL_BGR_EXT = $80E0;
- GL_BGRA_EXT = $80E1;
-
- // GL_EXT_blend_color
- GL_CONSTANT_COLOR_EXT = $8001;
- GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002;
- GL_CONSTANT_ALPHA_EXT = $8003;
- GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004;
- GL_BLEND_COLOR_EXT = $8005;
-
- // GL_EXT_blend_func_separate
- GL_BLEND_DST_RGB_EXT = $80C8;
- GL_BLEND_SRC_RGB_EXT = $80C9;
- GL_BLEND_DST_ALPHA_EXT = $80CA;
- GL_BLEND_SRC_ALPHA_EXT = $80CB;
-
- // GL_EXT_blend_minmax
- GL_FUNC_ADD_EXT = $8006;
- GL_MIN_EXT = $8007;
- GL_MAX_EXT = $8008;
- GL_BLEND_EQUATION_EXT = $8009;
-
- // GL_EXT_blend_subtract
- GL_FUNC_SUBTRACT_EXT = $800A;
- GL_FUNC_REVERSE_SUBTRACT_EXT = $800B;
-
- // GL_EXT_clip_volume_hint
- GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0;
-
- // GL_EXT_cmyka
- GL_CMYK_EXT = $800C;
- GL_CMYKA_EXT = $800D;
- GL_PACK_CMYK_HINT_EXT = $800E;
- GL_UNPACK_CMYK_HINT_EXT = $800F;
-
- // GL_EXT_compiled_vertex_array
- GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8;
- GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9;
-
- // GL_EXT_convolution
- GL_CONVOLUTION_1D_EXT = $8010;
- GL_CONVOLUTION_2D_EXT = $8011;
- GL_SEPARABLE_2D_EXT = $8012;
- GL_CONVOLUTION_BORDER_MODE_EXT = $8013;
- GL_CONVOLUTION_FILTER_SCALE_EXT = $8014;
- GL_CONVOLUTION_FILTER_BIAS_EXT = $8015;
- GL_REDUCE_EXT = $8016;
- GL_CONVOLUTION_FORMAT_EXT = $8017;
- GL_CONVOLUTION_WIDTH_EXT = $8018;
- GL_CONVOLUTION_HEIGHT_EXT = $8019;
- GL_MAX_CONVOLUTION_WIDTH_EXT = $801A;
- GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B;
- GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C;
- GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D;
- GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E;
- GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F;
- GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020;
- GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021;
- GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022;
- GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023;
-
- // GL_EXT_coordinate_frame
- GL_TANGENT_ARRAY_EXT = $8439;
- GL_BINORMAL_ARRAY_EXT = $843A;
- GL_CURRENT_TANGENT_EXT = $843B;
- GL_CURRENT_BINORMAL_EXT = $843C;
- GL_TANGENT_ARRAY_TYPE_EXT = $843E;
- GL_TANGENT_ARRAY_STRIDE_EXT = $843F;
- GL_BINORMAL_ARRAY_TYPE_EXT = $8440;
- GL_BINORMAL_ARRAY_STRIDE_EXT = $8441;
- GL_TANGENT_ARRAY_POINTER_EXT = $8442;
- GL_BINORMAL_ARRAY_POINTER_EXT = $8443;
- GL_MAP1_TANGENT_EXT = $8444;
- GL_MAP2_TANGENT_EXT = $8445;
- GL_MAP1_BINORMAL_EXT = $8446;
- GL_MAP2_BINORMAL_EXT = $8447;
-
- // GL_EXT_cull_vertex
- GL_CULL_VERTEX_EXT = $81AA;
- GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB;
- GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC;
-
- // GL_EXT_draw_range_elements
- GL_MAX_ELEMENTS_VERTICES_EXT = $80E8;
- GL_MAX_ELEMENTS_INDICES_EXT = $80E9;
-
- // GL_EXT_fog_coord
- GL_FOG_COORDINATE_SOURCE_EXT = $8450;
- GL_FOG_COORDINATE_EXT = $8451;
- GL_FRAGMENT_DEPTH_EXT = $8452;
- GL_CURRENT_FOG_COORDINATE_EXT = $8453;
- GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454;
- GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455;
- GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456;
- GL_FOG_COORDINATE_ARRAY_EXT = $8457;
-
- // GL_EXT_framebuffer_object
- GL_FRAMEBUFFER_EXT = $8D40;
- GL_RENDERBUFFER_EXT = $8D41;
- GL_STENCIL_INDEX_EXT = $8D45;
- GL_STENCIL_INDEX1_EXT = $8D46;
- GL_STENCIL_INDEX4_EXT = $8D47;
- GL_STENCIL_INDEX8_EXT = $8D48;
- GL_STENCIL_INDEX16_EXT = $8D49;
- GL_RENDERBUFFER_WIDTH_EXT = $8D42;
- GL_RENDERBUFFER_HEIGHT_EXT = $8D43;
- GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44;
- GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0;
- GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4;
- GL_COLOR_ATTACHMENT0_EXT = $8CE0;
- GL_COLOR_ATTACHMENT1_EXT = $8CE1;
- GL_COLOR_ATTACHMENT2_EXT = $8CE2;
- GL_COLOR_ATTACHMENT3_EXT = $8CE3;
- GL_COLOR_ATTACHMENT4_EXT = $8CE4;
- GL_COLOR_ATTACHMENT5_EXT = $8CE5;
- GL_COLOR_ATTACHMENT6_EXT = $8CE6;
- GL_COLOR_ATTACHMENT7_EXT = $8CE7;
- GL_COLOR_ATTACHMENT8_EXT = $8CE8;
- GL_COLOR_ATTACHMENT9_EXT = $8CE9;
- GL_COLOR_ATTACHMENT10_EXT = $8CEA;
- GL_COLOR_ATTACHMENT11_EXT = $8CEB;
- GL_COLOR_ATTACHMENT12_EXT = $8CEC;
- GL_COLOR_ATTACHMENT13_EXT = $8CED;
- GL_COLOR_ATTACHMENT14_EXT = $8CEE;
- GL_COLOR_ATTACHMENT15_EXT = $8CEF;
- GL_DEPTH_ATTACHMENT_EXT = $8D00;
- GL_STENCIL_ATTACHMENT_EXT = $8D20;
- GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5;
- GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6;
- GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7;
- GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8;
- GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9;
- GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA;
- GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB;
- GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC;
- GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD;
- GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE;
- GL_FRAMEBUFFER_BINDING_EXT = $8CA6;
- GL_RENDERBUFFER_BINDING_EXT = $8CA7;
- GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF;
- GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8;
- GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506;
-
- // GL_EXT_histogram
- GL_HISTOGRAM_EXT = $8024;
- GL_PROXY_HISTOGRAM_EXT = $8025;
- GL_HISTOGRAM_WIDTH_EXT = $8026;
- GL_HISTOGRAM_FORMAT_EXT = $8027;
- GL_HISTOGRAM_RED_SIZE_EXT = $8028;
- GL_HISTOGRAM_GREEN_SIZE_EXT = $8029;
- GL_HISTOGRAM_BLUE_SIZE_EXT = $802A;
- GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B;
- GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C;
- GL_HISTOGRAM_SINK_EXT = $802D;
- GL_MINMAX_EXT = $802E;
- GL_MINMAX_FORMAT_EXT = $802F;
- GL_MINMAX_SINK_EXT = $8030;
- GL_TABLE_TOO_LARGE_EXT = $8031;
-
- // GL_EXT_index_array_formats
- GL_IUI_V2F_EXT = $81AD;
- GL_IUI_V3F_EXT = $81AE;
- GL_IUI_N3F_V2F_EXT = $81AF;
- GL_IUI_N3F_V3F_EXT = $81B0;
- GL_T2F_IUI_V2F_EXT = $81B1;
- GL_T2F_IUI_V3F_EXT = $81B2;
- GL_T2F_IUI_N3F_V2F_EXT = $81B3;
- GL_T2F_IUI_N3F_V3F_EXT = $81B4;
-
- // GL_EXT_index_func
- GL_INDEX_TEST_EXT = $81B5;
- GL_INDEX_TEST_FUNC_EXT = $81B6;
- GL_INDEX_TEST_REF_EXT = $81B7;
-
- // GL_EXT_index_material
- GL_INDEX_MATERIAL_EXT = $81B8;
- GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9;
- GL_INDEX_MATERIAL_FACE_EXT = $81BA;
-
- // GL_EXT_light_texture
- GL_FRAGMENT_MATERIAL_EXT = $8349;
- GL_FRAGMENT_NORMAL_EXT = $834A;
- GL_FRAGMENT_COLOR_EXT = $834C;
- GL_ATTENUATION_EXT = $834D;
- GL_SHADOW_ATTENUATION_EXT = $834E;
- GL_TEXTURE_APPLICATION_MODE_EXT = $834F;
- GL_TEXTURE_LIGHT_EXT = $8350;
- GL_TEXTURE_MATERIAL_FACE_EXT = $8351;
- GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352;
-
- // GL_EXT_multisample
- GL_MULTISAMPLE_EXT = $809D;
- GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E;
- GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F;
- GL_SAMPLE_MASK_EXT = $80A0;
- GL_1PASS_EXT = $80A1;
- GL_2PASS_0_EXT = $80A2;
- GL_2PASS_1_EXT = $80A3;
- GL_4PASS_0_EXT = $80A4;
- GL_4PASS_1_EXT = $80A5;
- GL_4PASS_2_EXT = $80A6;
- GL_4PASS_3_EXT = $80A7;
- GL_SAMPLE_BUFFERS_EXT = $80A8;
- GL_SAMPLES_EXT = $80A9;
- GL_SAMPLE_MASK_VALUE_EXT = $80AA;
- GL_SAMPLE_MASK_INVERT_EXT = $80AB;
- GL_SAMPLE_PATTERN_EXT = $80AC;
- GL_MULTISAMPLE_BIT_EXT = $20000000;
-
- // GL_EXT_packed_pixels
- GL_UNSIGNED_BYTE_3_3_2_EXT = $8032;
- GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033;
- GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034;
- GL_UNSIGNED_INT_8_8_8_8_EXT = $8035;
- GL_UNSIGNED_INT_10_10_10_2_EXT = $8036;
-
- // GL_EXT_paletted_texture
- GL_COLOR_INDEX1_EXT = $80E2;
- GL_COLOR_INDEX2_EXT = $80E3;
- GL_COLOR_INDEX4_EXT = $80E4;
- GL_COLOR_INDEX8_EXT = $80E5;
- GL_COLOR_INDEX12_EXT = $80E6;
- GL_COLOR_INDEX16_EXT = $80E7;
- GL_TEXTURE_INDEX_SIZE_EXT = $80ED;
-
- // GL_EXT_pixel_transform
- GL_PIXEL_TRANSFORM_2D_EXT = $8330;
- GL_PIXEL_MAG_FILTER_EXT = $8331;
- GL_PIXEL_MIN_FILTER_EXT = $8332;
- GL_PIXEL_CUBIC_WEIGHT_EXT = $8333;
- GL_CUBIC_EXT = $8334;
- GL_AVERAGE_EXT = $8335;
- GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336;
- GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337;
- GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338;
-
- // GL_EXT_point_parameters
- GL_POINT_SIZE_MIN_EXT = $8126;
- GL_POINT_SIZE_MAX_EXT = $8127;
- GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128;
- GL_DISTANCE_ATTENUATION_EXT = $8129;
-
- // GL_EXT_polygon_offset
- GL_POLYGON_OFFSET_EXT = $8037;
- GL_POLYGON_OFFSET_FACTOR_EXT = $8038;
- GL_POLYGON_OFFSET_BIAS_EXT = $8039;
-
- // GL_EXT_rescale_normal
- GL_RESCALE_NORMAL_EXT = $803A;
-
- // GL_EXT_secondary_color
- GL_COLOR_SUM_EXT = $8458;
- GL_CURRENT_SECONDARY_COLOR_EXT = $8459;
- GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A;
- GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B;
- GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C;
- GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D;
- GL_SECONDARY_COLOR_ARRAY_EXT = $845E;
-
- // GL_EXT_separate_specular_color
- GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8;
- GL_SINGLE_COLOR_EXT = $81F9;
- GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA;
-
- // GL_EXT_shared_texture_palette
- GL_SHARED_TEXTURE_PALETTE_EXT = $81FB;
-
- // GL_EXT_stencil_two_side
- GL_STENCIL_TEST_TWO_SIDE_EXT = $8910;
- GL_ACTIVE_STENCIL_FACE_EXT = $8911;
-
- // GL_EXT_stencil_wrap
- GL_INCR_WRAP_EXT = $8507;
- GL_DECR_WRAP_EXT = $8508;
-
- // GL_EXT_texture
- GL_ALPHA4_EXT = $803B;
- GL_ALPHA8_EXT = $803C;
- GL_ALPHA12_EXT = $803D;
- GL_ALPHA16_EXT = $803E;
- GL_LUMINANCE4_EXT = $803F;
- GL_LUMINANCE8_EXT = $8040;
- GL_LUMINANCE12_EXT = $8041;
- GL_LUMINANCE16_EXT = $8042;
- GL_LUMINANCE4_ALPHA4_EXT = $8043;
- GL_LUMINANCE6_ALPHA2_EXT = $8044;
- GL_LUMINANCE8_ALPHA8_EXT = $8045;
- GL_LUMINANCE12_ALPHA4_EXT = $8046;
- GL_LUMINANCE12_ALPHA12_EXT = $8047;
- GL_LUMINANCE16_ALPHA16_EXT = $8048;
- GL_INTENSITY_EXT = $8049;
- GL_INTENSITY4_EXT = $804A;
- GL_INTENSITY8_EXT = $804B;
- GL_INTENSITY12_EXT = $804C;
- GL_INTENSITY16_EXT = $804D;
- GL_RGB2_EXT = $804E;
- GL_RGB4_EXT = $804F;
- GL_RGB5_EXT = $8050;
- GL_RGB8_EXT = $8051;
- GL_RGB10_EXT = $8052;
- GL_RGB12_EXT = $8053;
- GL_RGB16_EXT = $8054;
- GL_RGBA2_EXT = $8055;
- GL_RGBA4_EXT = $8056;
- GL_RGB5_A1_EXT = $8057;
- GL_RGBA8_EXT = $8058;
- GL_RGB10_A2_EXT = $8059;
- GL_RGBA12_EXT = $805A;
- GL_RGBA16_EXT = $805B;
- GL_TEXTURE_RED_SIZE_EXT = $805C;
- GL_TEXTURE_GREEN_SIZE_EXT = $805D;
- GL_TEXTURE_BLUE_SIZE_EXT = $805E;
- GL_TEXTURE_ALPHA_SIZE_EXT = $805F;
- GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060;
- GL_TEXTURE_INTENSITY_SIZE_EXT = $8061;
- GL_REPLACE_EXT = $8062;
- GL_PROXY_TEXTURE_1D_EXT = $8063;
- GL_PROXY_TEXTURE_2D_EXT = $8064;
- GL_TEXTURE_TOO_LARGE_EXT = $8065;
-
- // GL_EXT_texture3D
- GL_PACK_SKIP_IMAGES_EXT = $806B;
- GL_PACK_IMAGE_HEIGHT_EXT = $806C;
- GL_UNPACK_SKIP_IMAGES_EXT = $806D;
- GL_UNPACK_IMAGE_HEIGHT_EXT = $806E;
- GL_TEXTURE_3D_EXT = $806F;
- GL_PROXY_TEXTURE_3D_EXT = $8070;
- GL_TEXTURE_DEPTH_EXT = $8071;
- GL_TEXTURE_WRAP_R_EXT = $8072;
- GL_MAX_3D_TEXTURE_SIZE_EXT = $8073;
-
- // GL_EXT_texture_compression_s3tc
- GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
- GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
- GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
- GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
-
- // GL_EXT_texture_cube_map
- GL_NORMAL_MAP_EXT = $8511;
- GL_REFLECTION_MAP_EXT = $8512;
- GL_TEXTURE_CUBE_MAP_EXT = $8513;
- GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514;
- GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518;
- GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519;
- GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A;
- GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B;
- GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C;
-
- // GL_EXT_texture_edge_clamp
- GL_CLAMP_TO_EDGE_EXT = $812F;
-
- // GL_EXT_texture_env_combine
- GL_COMBINE_EXT = $8570;
- GL_COMBINE_RGB_EXT = $8571;
- GL_COMBINE_ALPHA_EXT = $8572;
- GL_RGB_SCALE_EXT = $8573;
- GL_ADD_SIGNED_EXT = $8574;
- GL_INTERPOLATE_EXT = $8575;
- GL_CONSTANT_EXT = $8576;
- GL_PRIMARY_COLOR_EXT = $8577;
- GL_PREVIOUS_EXT = $8578;
- GL_SOURCE0_RGB_EXT = $8580;
- GL_SOURCE1_RGB_EXT = $8581;
- GL_SOURCE2_RGB_EXT = $8582;
- GL_SOURCE0_ALPHA_EXT = $8588;
- GL_SOURCE1_ALPHA_EXT = $8589;
- GL_SOURCE2_ALPHA_EXT = $858A;
- GL_OPERAND0_RGB_EXT = $8590;
- GL_OPERAND1_RGB_EXT = $8591;
- GL_OPERAND2_RGB_EXT = $8592;
- GL_OPERAND0_ALPHA_EXT = $8598;
- GL_OPERAND1_ALPHA_EXT = $8599;
- GL_OPERAND2_ALPHA_EXT = $859A;
-
- // GL_EXT_texture_env_dot3
- GL_DOT3_RGB_EXT = $8740;
- GL_DOT3_RGBA_EXT = $8741;
-
- // GL_EXT_texture_filter_anisotropic
- GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
- GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
-
- // GL_EXT_texture_lod_bias
- GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD;
- GL_TEXTURE_FILTER_CONTROL_EXT = $8500;
- GL_TEXTURE_LOD_BIAS_EXT = $8501;
-
- // GL_EXT_texture_object
- GL_TEXTURE_PRIORITY_EXT = $8066;
- GL_TEXTURE_RESIDENT_EXT = $8067;
- GL_TEXTURE_1D_BINDING_EXT = $8068;
- GL_TEXTURE_2D_BINDING_EXT = $8069;
- GL_TEXTURE_3D_BINDING_EXT = $806A;
-
- // GL_EXT_texture_perturb_normal
- GL_PERTURB_EXT = $85AE;
- GL_TEXTURE_NORMAL_EXT = $85AF;
-
- // GL_EXT_texture_rectangle
- GL_TEXTURE_RECTANGLE_EXT = $84F5;
- GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6;
- GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7;
- GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8;
-
- // GL_EXT_vertex_array
- GL_VERTEX_ARRAY_EXT = $8074;
- GL_NORMAL_ARRAY_EXT = $8075;
- GL_COLOR_ARRAY_EXT = $8076;
- GL_INDEX_ARRAY_EXT = $8077;
- GL_TEXTURE_COORD_ARRAY_EXT = $8078;
- GL_EDGE_FLAG_ARRAY_EXT = $8079;
- GL_VERTEX_ARRAY_SIZE_EXT = $807A;
- GL_VERTEX_ARRAY_TYPE_EXT = $807B;
- GL_VERTEX_ARRAY_STRIDE_EXT = $807C;
- GL_VERTEX_ARRAY_COUNT_EXT = $807D;
- GL_NORMAL_ARRAY_TYPE_EXT = $807E;
- GL_NORMAL_ARRAY_STRIDE_EXT = $807F;
- GL_NORMAL_ARRAY_COUNT_EXT = $8080;
- GL_COLOR_ARRAY_SIZE_EXT = $8081;
- GL_COLOR_ARRAY_TYPE_EXT = $8082;
- GL_COLOR_ARRAY_STRIDE_EXT = $8083;
- GL_COLOR_ARRAY_COUNT_EXT = $8084;
- GL_INDEX_ARRAY_TYPE_EXT = $8085;
- GL_INDEX_ARRAY_STRIDE_EXT = $8086;
- GL_INDEX_ARRAY_COUNT_EXT = $8087;
- GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088;
- GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089;
- GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A;
- GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B;
- GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C;
- GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D;
- GL_VERTEX_ARRAY_POINTER_EXT = $808E;
- GL_NORMAL_ARRAY_POINTER_EXT = $808F;
- GL_COLOR_ARRAY_POINTER_EXT = $8090;
- GL_INDEX_ARRAY_POINTER_EXT = $8091;
- GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092;
- GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093;
-
- // GL_EXT_vertex_shader
- GL_VERTEX_SHADER_EXT = $8780;
- GL_VERTEX_SHADER_BINDING_EXT = $8781;
- GL_OP_INDEX_EXT = $8782;
- GL_OP_NEGATE_EXT = $8783;
- GL_OP_DOT3_EXT = $8784;
- GL_OP_DOT4_EXT = $8785;
- GL_OP_MUL_EXT = $8786;
- GL_OP_ADD_EXT = $8787;
- GL_OP_MADD_EXT = $8788;
- GL_OP_FRAC_EXT = $8789;
- GL_OP_MAX_EXT = $878A;
- GL_OP_MIN_EXT = $878B;
- GL_OP_SET_GE_EXT = $878C;
- GL_OP_SET_LT_EXT = $878D;
- GL_OP_CLAMP_EXT = $878E;
- GL_OP_FLOOR_EXT = $878F;
- GL_OP_ROUND_EXT = $8790;
- GL_OP_EXP_BASE_2_EXT = $8791;
- GL_OP_LOG_BASE_2_EXT = $8792;
- GL_OP_POWER_EXT = $8793;
- GL_OP_RECIP_EXT = $8794;
- GL_OP_RECIP_SQRT_EXT = $8795;
- GL_OP_SUB_EXT = $8796;
- GL_OP_CROSS_PRODUCT_EXT = $8797;
- GL_OP_MULTIPLY_MATRIX_EXT = $8798;
- GL_OP_MOV_EXT = $8799;
- GL_OUTPUT_VERTEX_EXT = $879A;
- GL_OUTPUT_COLOR0_EXT = $879B;
- GL_OUTPUT_COLOR1_EXT = $879C;
- GL_OUTPUT_TEXTURE_COORD0_EXT = $879D;
- GL_OUTPUT_TEXTURE_COORD1_EXT = $879E;
- GL_OUTPUT_TEXTURE_COORD2_EXT = $879F;
- GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0;
- GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1;
- GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2;
- GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3;
- GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4;
- GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5;
- GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6;
- GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7;
- GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8;
- GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9;
- GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA;
- GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB;
- GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC;
- GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD;
- GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE;
- GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF;
- GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0;
- GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1;
- GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2;
- GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3;
- GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4;
- GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5;
- GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6;
- GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7;
- GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8;
- GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9;
- GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA;
- GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB;
- GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC;
- GL_OUTPUT_FOG_EXT = $87BD;
- GL_SCALAR_EXT = $87BE;
- GL_VECTOR_EXT = $87BF;
- GL_MATRIX_EXT = $87C0;
- GL_VARIANT_EXT = $87C1;
- GL_INVARIANT_EXT = $87C2;
- GL_LOCAL_CONSTANT_EXT = $87C3;
- GL_LOCAL_EXT = $87C4;
- GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5;
- GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6;
- GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7;
- GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8;
- GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9;
- GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA;
- GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB;
- GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC;
- GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD;
- GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE;
- GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF;
- GL_VERTEX_SHADER_VARIANTS_EXT = $87D0;
- GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1;
- GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2;
- GL_VERTEX_SHADER_LOCALS_EXT = $87D3;
- GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4;
- GL_X_EXT = $87D5;
- GL_Y_EXT = $87D6;
- GL_Z_EXT = $87D7;
- GL_W_EXT = $87D8;
- GL_NEGATIVE_X_EXT = $87D9;
- GL_NEGATIVE_Y_EXT = $87DA;
- GL_NEGATIVE_Z_EXT = $87DB;
- GL_NEGATIVE_W_EXT = $87DC;
- GL_ZERO_EXT = $87DD;
- GL_ONE_EXT = $87DE;
- GL_NEGATIVE_ONE_EXT = $87DF;
- GL_NORMALIZED_RANGE_EXT = $87E0;
- GL_FULL_RANGE_EXT = $87E1;
- GL_CURRENT_VERTEX_EXT = $87E2;
- GL_MVP_MATRIX_EXT = $87E3;
- GL_VARIANT_VALUE_EXT = $87E4;
- GL_VARIANT_DATATYPE_EXT = $87E5;
- GL_VARIANT_ARRAY_STRIDE_EXT = $87E6;
- GL_VARIANT_ARRAY_TYPE_EXT = $87E7;
- GL_VARIANT_ARRAY_EXT = $87E8;
- GL_VARIANT_ARRAY_POINTER_EXT = $87E9;
- GL_INVARIANT_VALUE_EXT = $87EA;
- GL_INVARIANT_DATATYPE_EXT = $87EB;
- GL_LOCAL_CONSTANT_VALUE_EXT = $87EC;
- GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED;
-
- // GL_EXT_vertex_weighting
- GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3;
- GL_MODELVIEW1_STACK_DEPTH_EXT = $8502;
- GL_MODELVIEW0_MATRIX_EXT = $0BA6;
- GL_MODELVIEW1_MATRIX_EXT = $8506;
- GL_VERTEX_WEIGHTING_EXT = $8509;
- GL_MODELVIEW0_EXT = $1700;
- GL_MODELVIEW1_EXT = $850A;
- GL_CURRENT_VERTEX_WEIGHT_EXT = $850B;
- GL_VERTEX_WEIGHT_ARRAY_EXT = $850C;
- GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D;
- GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E;
- GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F;
- GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510;
-
- // GL_EXT_depth_bounds_test
- GL_DEPTH_BOUNDS_TEST_EXT = $8890;
- GL_DEPTH_BOUNDS_EXT = $8891;
-
- // GL_EXT_texture_mirror_clamp
- GL_MIRROR_CLAMP_EXT = $8742;
- GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743;
- GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912;
-
- // GL_EXT_blend_equation_separate
- GL_BLEND_EQUATION_RGB_EXT = $8009;
- GL_BLEND_EQUATION_ALPHA_EXT = $883D;
-
- // GL_EXT_pixel_buffer_object
- GL_PIXEL_PACK_BUFFER_EXT = $88EB;
- GL_PIXEL_UNPACK_BUFFER_EXT = $88EC;
- GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED;
- GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF;
-
- // GL_EXT_stencil_clear_tag
- GL_STENCIL_TAG_BITS_EXT = $88F2;
- GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3;
-
- // GL_EXT_packed_depth_stencil
- GL_DEPTH_STENCIL_EXT = $84F9;
- GL_UNSIGNED_INT_24_8_EXT = $84FA;
- GL_DEPTH24_STENCIL8_EXT = $88F0;
- GL_TEXTURE_STENCIL_SIZE_EXT = $88F1;
-
- // GL_EXT_texture_sRGB
- GL_SRGB_EXT = $8C40;
- GL_SRGB8_EXT = $8C41;
- GL_SRGB_ALPHA_EXT = $8C42;
- GL_SRGB8_ALPHA8_EXT = $8C43;
- GL_SLUMINANCE_ALPHA_EXT = $8C44;
- GL_SLUMINANCE8_ALPHA8_EXT = $8C45;
- GL_SLUMINANCE_EXT = $8C46;
- GL_SLUMINANCE8_EXT = $8C47;
- GL_COMPRESSED_SRGB_EXT = $8C48;
- GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49;
- GL_COMPRESSED_SLUMINANCE_EXT = $8C4A;
- GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B;
- GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C;
- GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D;
- GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E;
- GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F;
-
- // GL_EXT_framebuffer_blit
- GL_READ_FRAMEBUFFER_EXT = $8CA8;
- GL_DRAW_FRAMEBUFFER_EXT = $8CA9;
- GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT;
- GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA;
-
- // GL_EXT_framebuffer_multisample
- GL_RENDERBUFFER_SAMPLES_EXT = $8CAB;
- GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56;
- GL_MAX_SAMPLES_EXT = $8D57;
-
- // GL_EXT_timer_query
- GL_TIME_ELAPSED_EXT = $88BF;
-
- // GL_EXT_bindable_uniform
- GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2;
- GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3;
- GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4;
- GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED;
- GL_UNIFORM_BUFFER_EXT = $8DEE;
- GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF;
-
- // GL_EXT_framebuffer_sRGB
- GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
- WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9;
- GL_FRAMEBUFFER_SRGB_EXT = $8DB9;
- GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA;
-
- // GL_EXT_geometry_shader4
- GL_GEOMETRY_SHADER_EXT = $8DD9;
- GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA;
- GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB;
- GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC;
- GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29;
- GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD;
- GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE;
- GL_MAX_VARYING_COMPONENTS_EXT = $8B4B;
- GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF;
- GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0;
- GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1;
- GL_LINES_ADJACENCY_EXT = $A;
- GL_LINE_STRIP_ADJACENCY_EXT = $B;
- GL_TRIANGLES_ADJACENCY_EXT = $C;
- GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D;
- GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8;
- GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9;
- GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7;
- GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4;
- GL_PROGRAM_POINT_SIZE_EXT = $8642;
-
- // GL_EXT_gpu_shader4
- GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD;
- GL_SAMPLER_1D_ARRAY_EXT = $8DC0;
- GL_SAMPLER_2D_ARRAY_EXT = $8DC1;
- GL_SAMPLER_BUFFER_EXT = $8DC2;
- GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3;
- GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4;
- GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5;
- GL_UNSIGNED_INT_VEC2_EXT = $8DC6;
- GL_UNSIGNED_INT_VEC3_EXT = $8DC7;
- GL_UNSIGNED_INT_VEC4_EXT = $8DC8;
- GL_INT_SAMPLER_1D_EXT = $8DC9;
- GL_INT_SAMPLER_2D_EXT = $8DCA;
- GL_INT_SAMPLER_3D_EXT = $8DCB;
- GL_INT_SAMPLER_CUBE_EXT = $8DCC;
- GL_INT_SAMPLER_2D_RECT_EXT = $8DCD;
- GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE;
- GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF;
- GL_INT_SAMPLER_BUFFER_EXT = $8DD0;
- GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1;
- GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2;
- GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3;
- GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4;
- GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5;
- GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6;
- GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7;
- GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8;
- GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904;
- GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905;
-
- // GL_EXT_packed_float
- GL_R11F_G11F_B10F_EXT = $8C3A;
- GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B;
- RGBA_SIGNED_COMPONENTS_EXT = $8C3C;
- WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8;
- GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
- GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
-
- // GL_EXT_texture_array
- GL_TEXTURE_1D_ARRAY_EXT = $8C18;
- GL_TEXTURE_2D_ARRAY_EXT = $8C1A;
- GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B;
- GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19;
- GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C;
- GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D;
- GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF;
- GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E;
-
- // GL_EXT_texture_buffer_object
- GL_TEXTURE_BUFFER_EXT = $8C2A;
- GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B;
- GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C;
- GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D;
- GL_TEXTURE_BUFFER_FORMAT_EXT = $8C2E;
-
- // GL_EXT_texture_compression_latc
- GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70;
- GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71;
- GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72;
- GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73;
-
- // GL_EXT_texture_compression_rgtc
- GL_COMPRESSED_RED_RGTC1_EXT = $8DBB;
- GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC;
- GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD;
- GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE;
-
- // GL_EXT_texture_integer
- GL_RGBA_INTEGER_MODE_EXT = $8D9E;
- GL_RGBA32UI_EXT = $8D70;
- GL_RGB32UI_EXT = $8D71;
- GL_ALPHA32UI_EXT = $8D72;
- GL_INTENSITY32UI_EXT = $8D73;
- GL_LUMINANCE32UI_EXT = $8D74;
- GL_LUMINANCE_ALPHA32UI_EXT = $8D75;
- GL_RGBA16UI_EXT = $8D76;
- GL_RGB16UI_EXT = $8D77;
- GL_ALPHA16UI_EXT = $8D78;
- GL_INTENSITY16UI_EXT = $8D79;
- GL_LUMINANCE16UI_EXT = $8D7A;
- GL_LUMINANCE_ALPHA16UI_EXT = $8D7B;
- GL_RGBA8UI_EXT = $8D7C;
- GL_RGB8UI_EXT = $8D7D;
- GL_ALPHA8UI_EXT = $8D7E;
- GL_INTENSITY8UI_EXT = $8D7F;
- GL_LUMINANCE8UI_EXT = $8D80;
- GL_LUMINANCE_ALPHA8UI_EXT = $8D81;
- GL_RGBA32I_EXT = $8D82;
- GL_RGB32I_EXT = $8D83;
- GL_ALPHA32I_EXT = $8D84;
- GL_INTENSITY32I_EXT = $8D85;
- GL_LUMINANCE32I_EXT = $8D86;
- GL_LUMINANCE_ALPHA32I_EXT = $8D87;
- GL_RGBA16I_EXT = $8D88;
- GL_RGB16I_EXT = $8D89;
- GL_ALPHA16I_EXT = $8D8A;
- GL_INTENSITY16I_EXT = $8D8B;
- GL_LUMINANCE16I_EXT = $8D8C;
- GL_LUMINANCE_ALPHA16I_EXT = $8D8D;
- GL_RGBA8I_EXT = $8D8E;
- GL_RGB8I_EXT = $8D8F;
- GL_ALPHA8I_EXT = $8D90;
- GL_INTENSITY8I_EXT = $8D91;
- GL_LUMINANCE8I_EXT = $8D92;
- GL_LUMINANCE_ALPHA8I_EXT = $8D93;
- GL_RED_INTEGER_EXT = $8D94;
- GL_GREEN_INTEGER_EXT = $8D95;
- GL_BLUE_INTEGER_EXT = $8D96;
- GL_ALPHA_INTEGER_EXT = $8D97;
- GL_RGB_INTEGER_EXT = $8D98;
- GL_RGBA_INTEGER_EXT = $8D99;
- GL_BGR_INTEGER_EXT = $8D9A;
- GL_BGRA_INTEGER_EXT = $8D9B;
- GL_LUMINANCE_INTEGER_EXT = $8D9C;
- GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D;
-
- // GL_EXT_texture_shared_exponent
- GL_RGB9_E5_EXT = $8C3D;
- GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E;
- GL_TEXTURE_SHARED_SIZE_EXT = $8C3F;
-
- // GL_EXT_transform_feedback
- GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E;
- GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84;
- GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85;
- GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F;
- GL_INTERLEAVED_ATTRIBS_EXT = $8C8C;
- GL_SEPARATE_ATTRIBS_EXT = $8C8D;
- GL_PRIMITIVES_GENERATED_EXT = $8C87;
- GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88;
- GL_RASTERIZER_DISCARD_EXT = $8C89;
- GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80;
- GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83;
- GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F;
- GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76;
-
- // GL_EXT_direct_state_access
- GL_PROGRAM_MATRIX_EXT = $8E2D;
- GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E;
- GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F;
-
- // GL_EXT_texture_swizzle
- GL_TEXTURE_SWIZZLE_R_EXT = $8E42;
- GL_TEXTURE_SWIZZLE_G_EXT = $8E43;
- GL_TEXTURE_SWIZZLE_B_EXT = $8E44;
- GL_TEXTURE_SWIZZLE_A_EXT = $8E45;
- GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46;
-
- // GL_EXT_provoking_vertex
- GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C;
- GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D;
- GL_LAST_VERTEX_CONVENTION_EXT = $8E4E;
- GL_PROVOKING_VERTEX_EXT = $8E4F;
-
- // GL_EXT_texture_snorm
- GL_ALPHA_SNORM = $9010;
- GL_LUMINANCE_SNORM = $9011;
- GL_LUMINANCE_ALPHA_SNORM = $9012;
- GL_INTENSITY_SNORM = $9013;
- GL_ALPHA8_SNORM = $9014;
- GL_LUMINANCE8_SNORM = $9015;
- GL_LUMINANCE8_ALPHA8_SNORM = $9016;
- GL_INTENSITY8_SNORM = $9017;
- GL_ALPHA16_SNORM = $9018;
- GL_LUMINANCE16_SNORM = $9019;
- GL_LUMINANCE16_ALPHA16_SNORM = $901A;
- GL_INTENSITY16_SNORM = $901B;
- { reuse GL_RED_SNORM }
- { reuse GL_RG_SNORM }
- { reuse GL_RGB_SNORM }
- { reuse GL_RGBA_SNORM }
- { reuse GL_R8_SNORM }
- { reuse GL_RG8_SNORM }
- { reuse GL_RGB8_SNORM }
- { reuse GL_RGBA8_SNORM }
- { reuse GL_R16_SNORM }
- { reuse GL_RG16_SNORM }
- { reuse GL_RGB16_SNORM }
- { reuse GL_RGBA16_SNORM }
- { reuse GL_SIGNED_NORMALIZED }
-
- // GL_EXT_separate_shader_objects
- GL_ACTIVE_PROGRAM_EXT = $8B8D;
-
- // GL_EXT_shader_image_load_store
- GL_MAX_IMAGE_UNITS_EXT = $8F38;
- GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = $8F39;
- GL_IMAGE_BINDING_NAME_EXT = $8F3A;
- GL_IMAGE_BINDING_LEVEL_EXT = $8F3B;
- GL_IMAGE_BINDING_LAYERED_EXT = $8F3C;
- GL_IMAGE_BINDING_LAYER_EXT = $8F3D;
- GL_IMAGE_BINDING_ACCESS_EXT = $8F3E;
- GL_IMAGE_1D_EXT = $904C;
- GL_IMAGE_2D_EXT = $904D;
- GL_IMAGE_3D_EXT = $904E;
- GL_IMAGE_2D_RECT_EXT = $904F;
- GL_IMAGE_CUBE_EXT = $9050;
- GL_IMAGE_BUFFER_EXT = $9051;
- GL_IMAGE_1D_ARRAY_EXT = $9052;
- GL_IMAGE_2D_ARRAY_EXT = $9053;
- GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054;
- GL_IMAGE_2D_MULTISAMPLE_EXT = $9055;
- GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9056;
- GL_INT_IMAGE_1D_EXT = $9057;
- GL_INT_IMAGE_2D_EXT = $9058;
- GL_INT_IMAGE_3D_EXT = $9059;
- GL_INT_IMAGE_2D_RECT_EXT = $905A;
- GL_INT_IMAGE_CUBE_EXT = $905B;
- GL_INT_IMAGE_BUFFER_EXT = $905C;
- GL_INT_IMAGE_1D_ARRAY_EXT = $905D;
- GL_INT_IMAGE_2D_ARRAY_EXT = $905E;
- GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F;
- GL_INT_IMAGE_2D_MULTISAMPLE_EXT = $9060;
- GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9061;
- GL_UNSIGNED_INT_IMAGE_1D_EXT = $9062;
- GL_UNSIGNED_INT_IMAGE_2D_EXT = $9063;
- GL_UNSIGNED_INT_IMAGE_3D_EXT = $9064;
- GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = $9065;
- GL_UNSIGNED_INT_IMAGE_CUBE_EXT = $9066;
- GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067;
- GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = $9068;
- GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = $9069;
- GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A;
- GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = $906B;
- GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $906C;
- GL_MAX_IMAGE_SAMPLES_EXT = $906D;
- GL_IMAGE_BINDING_FORMAT_EXT = $906E;
- GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = $00000001;
- GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = $00000002;
- GL_UNIFORM_BARRIER_BIT_EXT = $00000004;
- GL_TEXTURE_FETCH_BARRIER_BIT_EXT = $00000008;
- GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = $00000020;
- GL_COMMAND_BARRIER_BIT_EXT = $00000040;
- GL_PIXEL_BUFFER_BARRIER_BIT_EXT = $00000080;
- GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = $00000100;
- GL_BUFFER_UPDATE_BARRIER_BIT_EXT = $00000200;
- GL_FRAMEBUFFER_BARRIER_BIT_EXT = $00000400;
- GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = $00000800;
- GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = $00001000;
- GL_ALL_BARRIER_BITS_EXT = $FFFFFFFF;
-
- // GL_EXT_vertex_attrib_64bit
- { reuse GL_DOUBLE }
- GL_DOUBLE_VEC2_EXT = $8FFC;
- GL_DOUBLE_VEC3_EXT = $8FFD;
- GL_DOUBLE_VEC4_EXT = $8FFE;
- GL_DOUBLE_MAT2_EXT = $8F46;
- GL_DOUBLE_MAT3_EXT = $8F47;
- GL_DOUBLE_MAT4_EXT = $8F48;
- GL_DOUBLE_MAT2x3_EXT = $8F49;
- GL_DOUBLE_MAT2x4_EXT = $8F4A;
- GL_DOUBLE_MAT3x2_EXT = $8F4B;
- GL_DOUBLE_MAT3x4_EXT = $8F4C;
- GL_DOUBLE_MAT4x2_EXT = $8F4D;
- GL_DOUBLE_MAT4x3_EXT = $8F4E;
-
- // GL_EXT_texture_sRGB_decode
- GL_TEXTURE_SRGB_DECODE_EXT = $8A48;
- GL_DECODE_EXT = $8A49;
- GL_SKIP_DECODE_EXT = $8A4A;
-
- // GL_NV_texture_multisample
- GL_TEXTURE_COVERAGE_SAMPLES_NV = $9045;
- GL_TEXTURE_COLOR_SAMPLES_NV = $9046;
-
- // GL_AMD_blend_minmax_factor
- GL_FACTOR_MIN_AMD = $901C;
- GL_FACTOR_MAX_AMD = $901D;
-
- // GL_AMD_sample_positions
- GL_SUBSAMPLE_DISTANCE_AMD = $883F;
-
- // GL_EXT_x11_sync_object
- GL_SYNC_X11_FENCE_EXT = $90E1;
-
- // GL_EXT_framebuffer_multisample_blit_scaled
- GL_SCALED_RESOLVE_FASTEST_EXT = $90BA;
- GL_SCALED_RESOLVE_NICEST_EXT = $90BB;
-
- // (4.3) GL_NV_path_rendering
- GL_PATH_FORMAT_SVG_NV = $9070;
- GL_PATH_FORMAT_PS_NV = $9071;
- GL_STANDARD_FONT_NAME_NV = $9072;
- GL_SYSTEM_FONT_NAME_NV = $9073;
- GL_FILE_NAME_NV = $9074;
- GL_PATH_STROKE_WIDTH_NV = $9075;
- GL_PATH_END_CAPS_NV = $9076;
- GL_PATH_INITIAL_END_CAP_NV = $9077;
- GL_PATH_TERMINAL_END_CAP_NV = $9078;
- GL_PATH_JOIN_STYLE_NV = $9079;
- GL_PATH_MITER_LIMIT_NV = $907A;
- GL_PATH_DASH_CAPS_NV = $907B;
- GL_PATH_INITIAL_DASH_CAP_NV = $907C;
- GL_PATH_TERMINAL_DASH_CAP_NV = $907D;
- GL_PATH_DASH_OFFSET_NV = $907E;
- GL_PATH_CLIENT_LENGTH_NV = $907F;
- GL_PATH_FILL_MODE_NV = $9080;
- GL_PATH_FILL_MASK_NV = $9081;
- GL_PATH_FILL_COVER_MODE_NV = $9082;
- GL_PATH_STROKE_COVER_MODE_NV = $9083;
- GL_PATH_STROKE_MASK_NV = $9084;
- GL_PATH_SAMPLE_QUALITY_NV = $9085;
- GL_PATH_STROKE_BOUND_NV = $9086;
- GL_PATH_STROKE_OVERSAMPLE_COUNT_NV= $9087;
- GL_COUNT_UP_NV = $9088;
- GL_COUNT_DOWN_NV = $9089;
- GL_PATH_OBJECT_BOUNDING_BOX_NV = $908A;
- GL_CONVEX_HULL_NV = $908B;
- GL_MULTI_HULLS_NV = $908C;
- GL_BOUNDING_BOX_NV = $908D;
- GL_TRANSLATE_X_NV = $908E;
- GL_TRANSLATE_Y_NV = $908F;
- GL_TRANSLATE_2D_NV = $9090;
- GL_TRANSLATE_3D_NV = $9091;
- GL_AFFINE_2D_NV = $9092;
- GL_PROJECTIVE_2D_NV = $9093;
- GL_AFFINE_3D_NV = $9094;
- GL_PROJECTIVE_3D_NV = $9095;
- GL_TRANSPOSE_AFFINE_2D_NV = $9096;
- GL_TRANSPOSE_PROJECTIVE_2D_NV = $9097;
- GL_TRANSPOSE_AFFINE_3D_NV = $9098;
- GL_TRANSPOSE_PROJECTIVE_3D_NV = $9099;
- GL_UTF8_NV = $909A;
- GL_UTF16_NV = $909B;
- GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV= $909C;
- GL_PATH_COMMAND_COUNT_NV = $909D;
- GL_PATH_COORD_COUNT_NV = $909E;
- GL_PATH_DASH_ARRAY_COUNT_NV = $909F;
- GL_PATH_COMPUTED_LENGTH_NV = $90A0;
- GL_PATH_FILL_BOUNDING_BOX_NV = $90A1;
- GL_PATH_STROKE_BOUNDING_BOX_NV = $90A2;
- GL_SQUARE_NV = $90A3;
- GL_ROUND_NV = $90A4;
- GL_TRIANGULAR_NV = $90A5;
- GL_BEVEL_NV = $90A6;
- GL_MITER_REVERT_NV = $90A7;
- GL_MITER_TRUNCATE_NV = $90A8;
- GL_SKIP_MISSING_GLYPH_NV = $90A9;
- GL_USE_MISSING_GLYPH_NV = $90AA;
- GL_PATH_ERROR_POSITION_NV = $90AB;
- GL_PATH_FOG_GEN_MODE_NV = $90AC;
- GL_ACCUM_ADJACENT_PAIRS_NV = $90AD;
- GL_ADJACENT_PAIRS_NV = $90AE;
- GL_FIRST_TO_REST_NV = $90AF;
- GL_PATH_GEN_MODE_NV = $90B0;
- GL_PATH_GEN_COEFF_NV = $90B1;
- GL_PATH_GEN_COLOR_FORMAT_NV = $90B2;
- GL_PATH_GEN_COMPONENTS_NV = $90B3;
- GL_PATH_STENCIL_FUNC_NV = $90B7;
- GL_PATH_STENCIL_REF_NV = $90B8;
- GL_PATH_STENCIL_VALUE_MASK_NV = $90B9;
- GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV= $90BD;
- GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV= $90BE;
- GL_PATH_COVER_DEPTH_FUNC_NV = $90BF;
- GL_PATH_DASH_OFFSET_RESET_NV = $90B4;
- GL_MOVE_TO_RESETS_NV = $90B5;
- GL_MOVE_TO_CONTINUES_NV = $90B6;
- GL_CLOSE_PATH_NV = $00;
- GL_MOVE_TO_NV = $02;
- GL_RELATIVE_MOVE_TO_NV = $03;
- GL_LINE_TO_NV = $04;
- GL_RELATIVE_LINE_TO_NV = $05;
- GL_HORIZONTAL_LINE_TO_NV = $06;
- GL_RELATIVE_HORIZONTAL_LINE_TO_NV= $07;
- GL_VERTICAL_LINE_TO_NV = $08;
- GL_RELATIVE_VERTICAL_LINE_TO_NV = $09;
- GL_QUADRATIC_CURVE_TO_NV = $0A;
- GL_RELATIVE_QUADRATIC_CURVE_TO_NV= $0B;
- GL_CUBIC_CURVE_TO_NV = $0C;
- GL_RELATIVE_CUBIC_CURVE_TO_NV = $0D;
- GL_SMOOTH_QUADRATIC_CURVE_TO_NV = $0E;
- GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV= $0F;
- GL_SMOOTH_CUBIC_CURVE_TO_NV = $10;
- GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV= $11;
- GL_SMALL_CCW_ARC_TO_NV = $12;
- GL_RELATIVE_SMALL_CCW_ARC_TO_NV = $13;
- GL_SMALL_CW_ARC_TO_NV = $14;
- GL_RELATIVE_SMALL_CW_ARC_TO_NV = $15;
- GL_LARGE_CCW_ARC_TO_NV = $16;
- GL_RELATIVE_LARGE_CCW_ARC_TO_NV = $17;
- GL_LARGE_CW_ARC_TO_NV = $18;
- GL_RELATIVE_LARGE_CW_ARC_TO_NV = $19;
- GL_RESTART_PATH_NV = $F0;
- GL_DUP_FIRST_CUBIC_CURVE_TO_NV = $F2;
- GL_DUP_LAST_CUBIC_CURVE_TO_NV = $F4;
- GL_RECT_NV = $F6;
- GL_CIRCULAR_CCW_ARC_TO_NV = $F8;
- GL_CIRCULAR_CW_ARC_TO_NV = $FA;
- GL_CIRCULAR_TANGENT_ARC_TO_NV = $FC;
- GL_ARC_TO_NV = $FE;
- GL_RELATIVE_ARC_TO_NV = $FF;
- GL_BOLD_BIT_NV = $01;
- GL_ITALIC_BIT_NV = $02;
- GL_GLYPH_WIDTH_BIT_NV = $01;
- GL_GLYPH_HEIGHT_BIT_NV = $02;
- GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV= $04;
- GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV= $08;
- GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV= $10;
- GL_GLYPH_VERTICAL_BEARING_X_BIT_NV= $20;
- GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV= $40;
- GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV= $80;
- GL_GLYPH_HAS_KERNING_NV = $100;
- GL_FONT_X_MIN_BOUNDS_NV = $00010000;
- GL_FONT_Y_MIN_BOUNDS_NV = $00020000;
- GL_FONT_X_MAX_BOUNDS_NV = $00040000;
- GL_FONT_Y_MAX_BOUNDS_NV = $00080000;
- GL_FONT_UNITS_PER_EM_NV = $00100000;
- GL_FONT_ASCENDER_NV = $00200000;
- GL_FONT_DESCENDER_NV = $00400000;
- GL_FONT_HEIGHT_NV = $00800000;
- GL_FONT_MAX_ADVANCE_WIDTH_NV = $01000000;
- GL_FONT_MAX_ADVANCE_HEIGHT_NV = $02000000;
- GL_FONT_UNDERLINE_POSITION_NV = $04000000;
- GL_FONT_UNDERLINE_THICKNESS_NV = $08000000;
- GL_FONT_HAS_KERNING_NV = $10000000;
-
- // (4.3) GL_AMD_pinned_memory
- GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD= $9160;
-
- // (4.3) GL_AMD_stencil_operation_extended
- GL_SET_AMD = $874A;
- GL_REPLACE_VALUE_AMD = $874B;
- GL_STENCIL_OP_VALUE_AMD = $874C;
- GL_STENCIL_BACK_OP_VALUE_AMD = $874D;
-
- // (4.3) GL_AMD_vertex_shader_viewport_index
-
- // (4.3) GL_AMD_vertex_shader_layer
-
- // (4.3) GL_NV_bindless_texture
-
- // (4.3) GL_NV_shader_atomic_float
-
- // (4.3) GL_AMD_query_buffer_object
- GL_QUERY_BUFFER_AMD = $9192;
- GL_QUERY_BUFFER_BINDING_AMD = $9193;
- GL_QUERY_RESULT_NO_WAIT_AMD = $9194;
-
- // GL_FfdMaskSGIX
- GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001;
- GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002;
-
- // GL_HP_convolution_border_modes
- GL_IGNORE_BORDER_HP = $8150;
- GL_CONSTANT_BORDER_HP = $8151;
- GL_REPLICATE_BORDER_HP = $8153;
- GL_CONVOLUTION_BORDER_COLOR_HP = $8154;
-
- // GL_HP_image_transform
- GL_IMAGE_SCALE_X_HP = $8155;
- GL_IMAGE_SCALE_Y_HP = $8156;
- GL_IMAGE_TRANSLATE_X_HP = $8157;
- GL_IMAGE_TRANSLATE_Y_HP = $8158;
- GL_IMAGE_ROTATE_ANGLE_HP = $8159;
- GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A;
- GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B;
- GL_IMAGE_MAG_FILTER_HP = $815C;
- GL_IMAGE_MIN_FILTER_HP = $815D;
- GL_IMAGE_CUBIC_WEIGHT_HP = $815E;
- GL_CUBIC_HP = $815F;
- GL_AVERAGE_HP = $8160;
- GL_IMAGE_TRANSFORM_2D_HP = $8161;
- GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162;
- GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163;
-
- // GL_HP_occlusion_test
- GL_OCCLUSION_TEST_HP = $8165;
- GL_OCCLUSION_TEST_RESULT_HP = $8166;
-
- // GL_HP_texture_lighting
- GL_TEXTURE_LIGHTING_MODE_HP = $8167;
- GL_TEXTURE_POST_SPECULAR_HP = $8168;
- GL_TEXTURE_PRE_SPECULAR_HP = $8169;
-
- // GL_IBM_cull_vertex
- GL_CULL_VERTEX_IBM = 103050;
-
- // GL_IBM_rasterpos_clip
- GL_RASTER_POSITION_UNCLIPPED_IBM = $19262;
-
- // GL_IBM_texture_mirrored_repeat
- GL_MIRRORED_REPEAT_IBM = $8370;
-
- // GL_IBM_vertex_array_lists
- GL_VERTEX_ARRAY_LIST_IBM = 103070;
- GL_NORMAL_ARRAY_LIST_IBM = 103071;
- GL_COLOR_ARRAY_LIST_IBM = 103072;
- GL_INDEX_ARRAY_LIST_IBM = 103073;
- GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074;
- GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075;
- GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076;
- GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077;
- GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080;
- GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081;
- GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082;
- GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083;
- GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084;
- GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085;
- GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086;
- GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087;
-
- // GL_INGR_color_clamp
- GL_RED_MIN_CLAMP_INGR = $8560;
- GL_GREEN_MIN_CLAMP_INGR = $8561;
- GL_BLUE_MIN_CLAMP_INGR = $8562;
- GL_ALPHA_MIN_CLAMP_INGR = $8563;
- GL_RED_MAX_CLAMP_INGR = $8564;
- GL_GREEN_MAX_CLAMP_INGR = $8565;
- GL_BLUE_MAX_CLAMP_INGR = $8566;
- GL_ALPHA_MAX_CLAMP_INGR = $8567;
-
- // GL_INGR_interlace_read
- GL_INTERLACE_READ_INGR = $8568;
-
- // GL_INTEL_parallel_arrays
- GL_PARALLEL_ARRAYS_INTEL = $83F4;
- GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5;
- GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6;
- GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7;
- GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8;
-
- // GL_NV_copy_depth_to_color
- GL_DEPTH_STENCIL_TO_RGBA_NV = $886E;
- GL_DEPTH_STENCIL_TO_BGRA_NV = $886F;
-
- // GL_NV_depth_clamp
- GL_DEPTH_CLAMP_NV = $864F;
-
- // GL_NV_evaluators
- GL_EVAL_2D_NV = $86C0;
- GL_EVAL_TRIANGULAR_2D_NV = $86C1;
- GL_MAP_TESSELLATION_NV = $86C2;
- GL_MAP_ATTRIB_U_ORDER_NV = $86C3;
- GL_MAP_ATTRIB_V_ORDER_NV = $86C4;
- GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5;
- GL_EVAL_VERTEX_ATTRIB0_NV = $86C6;
- GL_EVAL_VERTEX_ATTRIB1_NV = $86C7;
- GL_EVAL_VERTEX_ATTRIB2_NV = $86C8;
- GL_EVAL_VERTEX_ATTRIB3_NV = $86C9;
- GL_EVAL_VERTEX_ATTRIB4_NV = $86CA;
- GL_EVAL_VERTEX_ATTRIB5_NV = $86CB;
- GL_EVAL_VERTEX_ATTRIB6_NV = $86CC;
- GL_EVAL_VERTEX_ATTRIB7_NV = $86CD;
- GL_EVAL_VERTEX_ATTRIB8_NV = $86CE;
- GL_EVAL_VERTEX_ATTRIB9_NV = $86CF;
- GL_EVAL_VERTEX_ATTRIB10_NV = $86D0;
- GL_EVAL_VERTEX_ATTRIB11_NV = $86D1;
- GL_EVAL_VERTEX_ATTRIB12_NV = $86D2;
- GL_EVAL_VERTEX_ATTRIB13_NV = $86D3;
- GL_EVAL_VERTEX_ATTRIB14_NV = $86D4;
- GL_EVAL_VERTEX_ATTRIB15_NV = $86D5;
- GL_MAX_MAP_TESSELLATION_NV = $86D6;
- GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7;
-
- // GL_NV_fence
- GL_ALL_COMPLETED_NV = $84F2;
- GL_FENCE_STATUS_NV = $84F3;
- GL_FENCE_CONDITION_NV = $84F4;
-
- // GL_NV_float_buffer
- GL_FLOAT_R_NV = $8880;
- GL_FLOAT_RG_NV = $8881;
- GL_FLOAT_RGB_NV = $8882;
- GL_FLOAT_RGBA_NV = $8883;
- GL_FLOAT_R16_NV = $8884;
- GL_FLOAT_R32_NV = $8885;
- GL_FLOAT_RG16_NV = $8886;
- GL_FLOAT_RG32_NV = $8887;
- GL_FLOAT_RGB16_NV = $8888;
- GL_FLOAT_RGB32_NV = $8889;
- GL_FLOAT_RGBA16_NV = $888A;
- GL_FLOAT_RGBA32_NV = $888B;
- GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C;
- GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D;
- GL_FLOAT_RGBA_MODE_NV = $888E;
-
- // GL_NV_fog_distance
- GL_FOG_DISTANCE_MODE_NV = $855A;
- GL_EYE_RADIAL_NV = $855B;
- GL_EYE_PLANE_ABSOLUTE_NV = $855C;
-
- // GL_NV_fragment_program
- GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868;
- GL_FRAGMENT_PROGRAM_NV = $8870;
- GL_MAX_TEXTURE_COORDS_NV = $8871;
- GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872;
- GL_FRAGMENT_PROGRAM_BINDING_NV = $8873;
- GL_PROGRAM_ERROR_STRING_NV = $8874;
-
- // GL_NV_half_float
- GL_HALF_FLOAT_NV = $140B;
-
- // GL_NV_light_max_exponent
- GL_MAX_SHININESS_NV = $8504;
- GL_MAX_SPOT_EXPONENT_NV = $8505;
-
- // GL_NV_multisample_filter_hint
- GL_MULTISAMPLE_FILTER_HINT_NV = $8534;
-
- // GL_NV_occlusion_query
- GL_PIXEL_COUNTER_BITS_NV = $8864;
- GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865;
- GL_PIXEL_COUNT_NV = $8866;
- GL_PIXEL_COUNT_AVAILABLE_NV = $8867;
-
- // GL_NV_packed_depth_stencil
- GL_DEPTH_STENCIL_NV = $84F9;
- GL_UNSIGNED_INT_24_8_NV = $84FA;
-
- // GL_NV_pixel_data_range
- GL_WRITE_PIXEL_DATA_RANGE_NV = $8878;
- GL_READ_PIXEL_DATA_RANGE_NV = $8879;
- GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A;
- GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B;
- GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C;
- GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D;
-
- // GL_NV_point_sprite
- GL_POINT_SPRITE_NV = $8861;
- GL_COORD_REPLACE_NV = $8862;
- GL_POINT_SPRITE_R_MODE_NV = $8863;
-
- // GL_NV_primitive_restart
- GL_PRIMITIVE_RESTART_NV = $8558;
- GL_PRIMITIVE_RESTART_INDEX_NV = $8559;
-
- // GL_NV_register_combiners
- GL_REGISTER_COMBINERS_NV = $8522;
- GL_VARIABLE_A_NV = $8523;
- GL_VARIABLE_B_NV = $8524;
- GL_VARIABLE_C_NV = $8525;
- GL_VARIABLE_D_NV = $8526;
- GL_VARIABLE_E_NV = $8527;
- GL_VARIABLE_F_NV = $8528;
- GL_VARIABLE_G_NV = $8529;
- GL_CONSTANT_COLOR0_NV = $852A;
- GL_CONSTANT_COLOR1_NV = $852B;
- GL_PRIMARY_COLOR_NV = $852C;
- GL_SECONDARY_COLOR_NV = $852D;
- GL_SPARE0_NV = $852E;
- GL_SPARE1_NV = $852F;
- GL_DISCARD_NV = $8530;
- GL_E_TIMES_F_NV = $8531;
- GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532;
- GL_UNSIGNED_IDENTITY_NV = $8536;
- GL_UNSIGNED_INVERT_NV = $8537;
- GL_EXPAND_NORMAL_NV = $8538;
- GL_EXPAND_NEGATE_NV = $8539;
- GL_HALF_BIAS_NORMAL_NV = $853A;
- GL_HALF_BIAS_NEGATE_NV = $853B;
- GL_SIGNED_IDENTITY_NV = $853C;
- GL_SIGNED_NEGATE_NV = $853D;
- GL_SCALE_BY_TWO_NV = $853E;
- GL_SCALE_BY_FOUR_NV = $853F;
- GL_SCALE_BY_ONE_HALF_NV = $8540;
- GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541;
- GL_COMBINER_INPUT_NV = $8542;
- GL_COMBINER_MAPPING_NV = $8543;
- GL_COMBINER_COMPONENT_USAGE_NV = $8544;
- GL_COMBINER_AB_DOT_PRODUCT_NV = $8545;
- GL_COMBINER_CD_DOT_PRODUCT_NV = $8546;
- GL_COMBINER_MUX_SUM_NV = $8547;
- GL_COMBINER_SCALE_NV = $8548;
- GL_COMBINER_BIAS_NV = $8549;
- GL_COMBINER_AB_OUTPUT_NV = $854A;
- GL_COMBINER_CD_OUTPUT_NV = $854B;
- GL_COMBINER_SUM_OUTPUT_NV = $854C;
- GL_MAX_GENERAL_COMBINERS_NV = $854D;
- GL_NUM_GENERAL_COMBINERS_NV = $854E;
- GL_COLOR_SUM_CLAMP_NV = $854F;
- GL_COMBINER0_NV = $8550;
- GL_COMBINER1_NV = $8551;
- GL_COMBINER2_NV = $8552;
- GL_COMBINER3_NV = $8553;
- GL_COMBINER4_NV = $8554;
- GL_COMBINER5_NV = $8555;
- GL_COMBINER6_NV = $8556;
- GL_COMBINER7_NV = $8557;
-
- // GL_NV_register_combiners2
- GL_PER_STAGE_CONSTANTS_NV = $8535;
-
- // GL_NV_texgen_emboss
- GL_EMBOSS_LIGHT_NV = $855D;
- GL_EMBOSS_CONSTANT_NV = $855E;
- GL_EMBOSS_MAP_NV = $855F;
-
- // GL_NV_texgen_reflection
- GL_NORMAL_MAP_NV = $8511;
- GL_REFLECTION_MAP_NV = $8512;
-
- // GL_NV_texture_env_combine4
- GL_COMBINE4_NV = $8503;
- GL_SOURCE3_RGB_NV = $8583;
- GL_SOURCE3_ALPHA_NV = $858B;
- GL_OPERAND3_RGB_NV = $8593;
- GL_OPERAND3_ALPHA_NV = $859B;
-
- // GL_NV_texture_expand_normal
- GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F;
-
- // GL_NV_texture_rectangle
- GL_TEXTURE_RECTANGLE_NV = $84F5;
- GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6;
- GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7;
- GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8;
-
- // GL_NV_texture_shader
- GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C;
- GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D;
- GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E;
- GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9;
- GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA;
- GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB;
- GL_DSDT_MAG_INTENSITY_NV = $86DC;
- GL_SHADER_CONSISTENT_NV = $86DD;
- GL_TEXTURE_SHADER_NV = $86DE;
- GL_SHADER_OPERATION_NV = $86DF;
- GL_CULL_MODES_NV = $86E0;
- GL_OFFSET_TEXTURE_MATRIX_NV = $86E1;
- GL_OFFSET_TEXTURE_SCALE_NV = $86E2;
- GL_OFFSET_TEXTURE_BIAS_NV = $86E3;
- GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV;
- GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV;
- GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV;
- GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4;
- GL_CONST_EYE_NV = $86E5;
- GL_PASS_THROUGH_NV = $86E6;
- GL_CULL_FRAGMENT_NV = $86E7;
- GL_OFFSET_TEXTURE_2D_NV = $86E8;
- GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9;
- GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA;
- GL_DOT_PRODUCT_NV = $86EC;
- GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED;
- GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE;
- GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0;
- GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1;
- GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2;
- GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3;
- GL_HILO_NV = $86F4;
- GL_DSDT_NV = $86F5;
- GL_DSDT_MAG_NV = $86F6;
- GL_DSDT_MAG_VIB_NV = $86F7;
- GL_HILO16_NV = $86F8;
- GL_SIGNED_HILO_NV = $86F9;
- GL_SIGNED_HILO16_NV = $86FA;
- GL_SIGNED_RGBA_NV = $86FB;
- GL_SIGNED_RGBA8_NV = $86FC;
- GL_SIGNED_RGB_NV = $86FE;
- GL_SIGNED_RGB8_NV = $86FF;
- GL_SIGNED_LUMINANCE_NV = $8701;
- GL_SIGNED_LUMINANCE8_NV = $8702;
- GL_SIGNED_LUMINANCE_ALPHA_NV = $8703;
- GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704;
- GL_SIGNED_ALPHA_NV = $8705;
- GL_SIGNED_ALPHA8_NV = $8706;
- GL_SIGNED_INTENSITY_NV = $8707;
- GL_SIGNED_INTENSITY8_NV = $8708;
- GL_DSDT8_NV = $8709;
- GL_DSDT8_MAG8_NV = $870A;
- GL_DSDT8_MAG8_INTENSITY8_NV = $870B;
- GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C;
- GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D;
- GL_HI_SCALE_NV = $870E;
- GL_LO_SCALE_NV = $870F;
- GL_DS_SCALE_NV = $8710;
- GL_DT_SCALE_NV = $8711;
- GL_MAGNITUDE_SCALE_NV = $8712;
- GL_VIBRANCE_SCALE_NV = $8713;
- GL_HI_BIAS_NV = $8714;
- GL_LO_BIAS_NV = $8715;
- GL_DS_BIAS_NV = $8716;
- GL_DT_BIAS_NV = $8717;
- GL_MAGNITUDE_BIAS_NV = $8718;
- GL_VIBRANCE_BIAS_NV = $8719;
- GL_TEXTURE_BORDER_VALUES_NV = $871A;
- GL_TEXTURE_HI_SIZE_NV = $871B;
- GL_TEXTURE_LO_SIZE_NV = $871C;
- GL_TEXTURE_DS_SIZE_NV = $871D;
- GL_TEXTURE_DT_SIZE_NV = $871E;
- GL_TEXTURE_MAG_SIZE_NV = $871F;
-
- // GL_NV_texture_shader2
- GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF;
-
- // GL_NV_texture_shader3
- GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850;
- GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851;
- GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852;
- GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853;
- GL_OFFSET_HILO_TEXTURE_2D_NV = $8854;
- GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855;
- GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856;
- GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857;
- GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858;
- GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859;
- GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A;
- GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B;
- GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C;
- GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D;
- GL_HILO8_NV = $885E;
- GL_SIGNED_HILO8_NV = $885F;
- GL_FORCE_BLUE_TO_ONE_NV = $8860;
-
- // GL_NV_vertex_array_range
- GL_VERTEX_ARRAY_RANGE_NV = $851D;
- GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E;
- GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F;
- GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520;
- GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521;
-
- // GL_NV_vertex_array_range2
- GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533;
-
- // GL_NV_vertex_program
- GL_VERTEX_PROGRAM_NV = $8620;
- GL_VERTEX_STATE_PROGRAM_NV = $8621;
- GL_ATTRIB_ARRAY_SIZE_NV = $8623;
- GL_ATTRIB_ARRAY_STRIDE_NV = $8624;
- GL_ATTRIB_ARRAY_TYPE_NV = $8625;
- GL_CURRENT_ATTRIB_NV = $8626;
- GL_PROGRAM_LENGTH_NV = $8627;
- GL_PROGRAM_STRING_NV = $8628;
- GL_MODELVIEW_PROJECTION_NV = $8629;
- GL_IDENTITY_NV = $862A;
- GL_INVERSE_NV = $862B;
- GL_TRANSPOSE_NV = $862C;
- GL_INVERSE_TRANSPOSE_NV = $862D;
- GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E;
- GL_MAX_TRACK_MATRICES_NV = $862F;
- GL_MATRIX0_NV = $8630;
- GL_MATRIX1_NV = $8631;
- GL_MATRIX2_NV = $8632;
- GL_MATRIX3_NV = $8633;
- GL_MATRIX4_NV = $8634;
- GL_MATRIX5_NV = $8635;
- GL_MATRIX6_NV = $8636;
- GL_MATRIX7_NV = $8637;
- GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640;
- GL_CURRENT_MATRIX_NV = $8641;
- GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642;
- GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643;
- GL_PROGRAM_PARAMETER_NV = $8644;
- GL_ATTRIB_ARRAY_POINTER_NV = $8645;
- GL_PROGRAM_TARGET_NV = $8646;
- GL_PROGRAM_RESIDENT_NV = $8647;
- GL_TRACK_MATRIX_NV = $8648;
- GL_TRACK_MATRIX_TRANSFORM_NV = $8649;
- GL_VERTEX_PROGRAM_BINDING_NV = $864A;
- GL_PROGRAM_ERROR_POSITION_NV = $864B;
- GL_VERTEX_ATTRIB_ARRAY0_NV = $8650;
- GL_VERTEX_ATTRIB_ARRAY1_NV = $8651;
- GL_VERTEX_ATTRIB_ARRAY2_NV = $8652;
- GL_VERTEX_ATTRIB_ARRAY3_NV = $8653;
- GL_VERTEX_ATTRIB_ARRAY4_NV = $8654;
- GL_VERTEX_ATTRIB_ARRAY5_NV = $8655;
- GL_VERTEX_ATTRIB_ARRAY6_NV = $8656;
- GL_VERTEX_ATTRIB_ARRAY7_NV = $8657;
- GL_VERTEX_ATTRIB_ARRAY8_NV = $8658;
- GL_VERTEX_ATTRIB_ARRAY9_NV = $8659;
- GL_VERTEX_ATTRIB_ARRAY10_NV = $865A;
- GL_VERTEX_ATTRIB_ARRAY11_NV = $865B;
- GL_VERTEX_ATTRIB_ARRAY12_NV = $865C;
- GL_VERTEX_ATTRIB_ARRAY13_NV = $865D;
- GL_VERTEX_ATTRIB_ARRAY14_NV = $865E;
- GL_VERTEX_ATTRIB_ARRAY15_NV = $865F;
- GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660;
- GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661;
- GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662;
- GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663;
- GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664;
- GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665;
- GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666;
- GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667;
- GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668;
- GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669;
- GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A;
- GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B;
- GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C;
- GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D;
- GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E;
- GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F;
- GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670;
- GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671;
- GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672;
- GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673;
- GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674;
- GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675;
- GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676;
- GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677;
- GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678;
- GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679;
- GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A;
- GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B;
- GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C;
- GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D;
- GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E;
- GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F;
-
- // GL_NV_fragment_program2 and GL_NV_vertex_program2_option
- GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4;
- GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5;
-
- // GL_NV_fragment_program2
- GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6;
- GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7;
- GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8;
-
- // GL_NV_vertex_program3
- MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
-
- // GL_NV_depth_buffer_float
- GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD;
- GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF;
-
- // GL_NV_framebuffer_multisample_coverage
- GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB;
- GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10;
-
- // GL_NV_geometry_program4
- GL_GEOMETRY_PROGRAM_NV = $8C26;
- GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27;
- GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28;
-
- // GL_NV_gpu_program4
- GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906;
- GL_PROGRAM_RESULT_COMPONENTS_NV = $8907;
- GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908;
- GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909;
- GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5;
- GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6;
-
- // GL_NV_parameter_buffer_object
- GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0;
- GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1;
- GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2;
- GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3;
- GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4;
-
- // GL_NV_transform_feedback
- GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E;
- GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84;
- GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85;
- GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86;
- GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F;
- GL_INTERLEAVED_ATTRIBS_NV = $8C8C;
- GL_SEPARATE_ATTRIBS_NV = $8C8D;
- GL_PRIMITIVES_GENERATED_NV = $8C87;
- GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88;
- GL_RASTERIZER_DISCARD_NV = $8C89;
- GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B;
- GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80;
- GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E;
- GL_ACTIVE_VARYINGS_NV = $8C81;
- GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82;
- GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83;
- GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F;
- GL_BACK_PRIMARY_COLOR_NV = $8C77;
- GL_BACK_SECONDARY_COLOR_NV = $8C78;
- GL_TEXTURE_COORD_NV = $8C79;
- GL_CLIP_DISTANCE_NV = $8C7A;
- GL_VERTEX_ID_NV = $8C7B;
- GL_PRIMITIVE_ID_NV = $8C7C;
- GL_GENERIC_ATTRIB_NV = $8C7D;
- GL_LAYER_NV = $8DAA;
- GL_NEXT_BUFFER_NV = -2;
- GL_SKIP_COMPONENTS4_NV = -3;
- GL_SKIP_COMPONENTS3_NV = -4;
- GL_SKIP_COMPONENTS2_NV = -5;
- GL_SKIP_COMPONENTS1_NV = -6;
-
- // GL_NV_conditional_render
- GL_QUERY_WAIT_NV = $8E13;
- GL_QUERY_NO_WAIT_NV = $8E14;
- GL_QUERY_BY_REGION_WAIT_NV = $8E15;
- GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16;
-
- // GL_NV_present_video
- GL_FRAME_NV = $8E26;
- GL_FIELDS_NV = $8E27;
- GL_CURRENT_TIME_NV = $8E28;
- GL_NUM_FILL_STREAMS_NV = $8E29;
- GL_PRESENT_TIME_NV = $8E2A;
- GL_PRESENT_DURATION_NV = $8E2B;
-
- // GL_NV_explicit_multisample
- GL_SAMPLE_POSITION_NV = $8E50;
- GL_SAMPLE_MASK_NV = $8E51;
- GL_SAMPLE_MASK_VALUE_NV = $8E52;
- GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53;
- GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54;
- GL_TEXTURE_RENDERBUFFER_NV = $8E55;
- GL_SAMPLER_RENDERBUFFER_NV = $8E56;
- GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57;
- GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58;
- GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59;
-
- // GL_NV_transform_feedback2
- GL_TRANSFORM_FEEDBACK_NV = $8E22;
- GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23;
- GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24;
- GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25;
-
- // GL_NV_video_capture
- GL_VIDEO_BUFFER_NV = $9020;
- GL_VIDEO_BUFFER_BINDING_NV = $9021;
- GL_FIELD_UPPER_NV = $9022;
- GL_FIELD_LOWER_NV = $9023;
- GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024;
- GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025;
- GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026;
- GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027;
- GL_VIDEO_BUFFER_PITCH_NV = $9028;
- GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029;
- GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A;
- GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B;
- GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C;
- GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D;
- GL_PARTIAL_SUCCESS_NV = $902E;
- GL_SUCCESS_NV = $902F;
- GL_FAILURE_NV = $9030;
- GL_YCBYCR8_422_NV = $9031;
- GL_YCBAYCR8A_4224_NV = $9032;
- GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033;
- GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034;
- GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035;
- GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036;
- GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037;
- GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038;
- GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039;
- GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A;
- GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B;
- GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C;
-
- // GL_NV_shader_buffer_load
- GL_BUFFER_GPU_ADDRESS_NV = $8F1D;
- GL_GPU_ADDRESS_NV = $8F34;
- GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35;
-
- // GL_NV_vertex_buffer_unified_memory
- GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E;
- GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F;
- GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20;
- GL_VERTEX_ARRAY_ADDRESS_NV = $8F21;
- GL_NORMAL_ARRAY_ADDRESS_NV = $8F22;
- GL_COLOR_ARRAY_ADDRESS_NV = $8F23;
- GL_INDEX_ARRAY_ADDRESS_NV = $8F24;
- GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25;
- GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26;
- GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27;
- GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28;
- GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29;
- GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A;
- GL_VERTEX_ARRAY_LENGTH_NV = $8F2B;
- GL_NORMAL_ARRAY_LENGTH_NV = $8F2C;
- GL_COLOR_ARRAY_LENGTH_NV = $8F2D;
- GL_INDEX_ARRAY_LENGTH_NV = $8F2E;
- GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F;
- GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30;
- GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31;
- GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32;
- GL_ELEMENT_ARRAY_LENGTH_NV = $8F33;
- GL_DRAW_INDIRECT_UNIFIED_NV = $8F40;
- GL_DRAW_INDIRECT_ADDRESS_NV = $8F41;
- GL_DRAW_INDIRECT_LENGTH_NV = $8F42;
-
- // GL_NV_gpu_program5
- GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A;
- GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B;
- GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C;
- GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D;
- GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E;
- GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F;
- GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44;
- GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45;
-
- // GL_NV_gpu_shader5
- GL_INT64_NV = $140E;
- GL_UNSIGNED_INT64_NV = $140F;
- GL_INT8_NV = $8FE0;
- GL_INT8_VEC2_NV = $8FE1;
- GL_INT8_VEC3_NV = $8FE2;
- GL_INT8_VEC4_NV = $8FE3;
- GL_INT16_NV = $8FE4;
- GL_INT16_VEC2_NV = $8FE5;
- GL_INT16_VEC3_NV = $8FE6;
- GL_INT16_VEC4_NV = $8FE7;
- GL_INT64_VEC2_NV = $8FE9;
- GL_INT64_VEC3_NV = $8FEA;
- GL_INT64_VEC4_NV = $8FEB;
- GL_UNSIGNED_INT8_NV = $8FEC;
- GL_UNSIGNED_INT8_VEC2_NV = $8FED;
- GL_UNSIGNED_INT8_VEC3_NV = $8FEE;
- GL_UNSIGNED_INT8_VEC4_NV = $8FEF;
- GL_UNSIGNED_INT16_NV = $8FF0;
- GL_UNSIGNED_INT16_VEC2_NV = $8FF1;
- GL_UNSIGNED_INT16_VEC3_NV = $8FF2;
- GL_UNSIGNED_INT16_VEC4_NV = $8FF3;
- GL_UNSIGNED_INT64_VEC2_NV = $8FF5;
- GL_UNSIGNED_INT64_VEC3_NV = $8FF6;
- GL_UNSIGNED_INT64_VEC4_NV = $8FF7;
- GL_FLOAT16_NV = $8FF8;
- GL_FLOAT16_VEC2_NV = $8FF9;
- GL_FLOAT16_VEC3_NV = $8FFA;
- GL_FLOAT16_VEC4_NV = $8FFB;
- { reuse GL_PATCHES }
-
- // GL_NV_shader_buffer_store
- GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010;
- { reuse GL_READ_WRITE }
- { reuse GL_WRITE_ONLY }
-
- // GL_NV_tessellation_program5
- GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8;
- GL_TESS_CONTROL_PROGRAM_NV = $891E;
- GL_TESS_EVALUATION_PROGRAM_NV = $891F;
- GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74;
- GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75;
-
- // GL_NV_vertex_attrib_integer_64bit
- { reuse GL_INT64_NV }
- { reuse GL_UNSIGNED_INT64_NV }
-
- // GL_NV_multisample_coverage
- GL_COVERAGE_SAMPLES_NV = $80A9;
- GL_COLOR_SAMPLES_NV = $8E20;
-
- // GL_NV_vdpau_interop
- GL_SURFACE_STATE_NV = $86EB;
- GL_SURFACE_REGISTERED_NV = $86FD;
- GL_SURFACE_MAPPED_NV = $8700;
- GL_WRITE_DISCARD_NV = $88BE;
-
- // GL_OML_interlace
- GL_INTERLACE_OML = $8980;
- GL_INTERLACE_READ_OML = $8981;
-
- // GL_OML_resample
- GL_PACK_RESAMPLE_OML = $8984;
- GL_UNPACK_RESAMPLE_OML = $8985;
- GL_RESAMPLE_REPLICATE_OML = $8986;
- GL_RESAMPLE_ZERO_FILL_OML = $8987;
- GL_RESAMPLE_AVERAGE_OML = $8988;
- GL_RESAMPLE_DECIMATE_OML = $8989;
-
- // GL_OML_subsample
- GL_FORMAT_SUBSAMPLE_24_24_OML = $8982;
- GL_FORMAT_SUBSAMPLE_244_244_OML = $8983;
-
- // GL_PGI_misc_hints
- GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8;
- GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD;
- GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE;
- GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202;
- GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203;
- GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204;
- GL_ALWAYS_FAST_HINT_PGI = $1A20C;
- GL_ALWAYS_SOFT_HINT_PGI = $1A20D;
- GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E;
- GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F;
- GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210;
- GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211;
- GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216;
- GL_STRICT_LIGHTING_HINT_PGI = $1A217;
- GL_STRICT_SCISSOR_HINT_PGI = $1A218;
- GL_FULL_STIPPLE_HINT_PGI = $1A219;
- GL_CLIP_NEAR_HINT_PGI = $1A220;
- GL_CLIP_FAR_HINT_PGI = $1A221;
- GL_WIDE_LINE_HINT_PGI = $1A222;
- GL_BACK_NORMALS_HINT_PGI = $1A223;
-
- // GL_PGI_vertex_hints
- GL_VERTEX_DATA_HINT_PGI = $1A22A;
- GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B;
- GL_MATERIAL_SIDE_HINT_PGI = $1A22C;
- GL_MAX_VERTEX_HINT_PGI = $1A22D;
- GL_COLOR3_BIT_PGI = $00010000;
- GL_COLOR4_BIT_PGI = $00020000;
- GL_EDGEFLAG_BIT_PGI = $00040000;
- GL_INDEX_BIT_PGI = $00080000;
- GL_MAT_AMBIENT_BIT_PGI = $00100000;
- GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000;
- GL_MAT_DIFFUSE_BIT_PGI = $00400000;
- GL_MAT_EMISSION_BIT_PGI = $00800000;
- GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000;
- GL_MAT_SHININESS_BIT_PGI = $02000000;
- GL_MAT_SPECULAR_BIT_PGI = $04000000;
- GL_NORMAL_BIT_PGI = $08000000;
- GL_TEXCOORD1_BIT_PGI = $10000000;
- GL_TEXCOORD2_BIT_PGI = $20000000;
- GL_TEXCOORD3_BIT_PGI = $40000000;
- GL_TEXCOORD4_BIT_PGI = $80000000;
- GL_VERTEX23_BIT_PGI = $00000004;
- GL_VERTEX4_BIT_PGI = $00000008;
-
- // GL_REND_screen_coordinates
- GL_SCREEN_COORDINATES_REND = $8490;
- GL_INVERTED_SCREEN_W_REND = $8491;
-
- // GL_S3_s3tc
- GL_RGB_S3TC = $83A0;
- GL_RGB4_S3TC = $83A1;
- GL_RGBA_S3TC = $83A2;
- GL_RGBA4_S3TC = $83A3;
-
- // GL_SGIS_detail_texture
- GL_DETAIL_TEXTURE_2D_SGIS = $8095;
- GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096;
- GL_LINEAR_DETAIL_SGIS = $8097;
- GL_LINEAR_DETAIL_ALPHA_SGIS = $8098;
- GL_LINEAR_DETAIL_COLOR_SGIS = $8099;
- GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A;
- GL_DETAIL_TEXTURE_MODE_SGIS = $809B;
- GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C;
-
- // GL_SGIS_fog_function
- GL_FOG_FUNC_SGIS = $812A;
- GL_FOG_FUNC_POINTS_SGIS = $812B;
- GL_MAX_FOG_FUNC_POINTS_SGIS = $812C;
-
- // GL_SGIS_generate_mipmap
- GL_GENERATE_MIPMAP_SGIS = $8191;
- GL_GENERATE_MIPMAP_HINT_SGIS = $8192;
-
- // GL_SGIS_multisample
- GL_MULTISAMPLE_SGIS = $809D;
- GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E;
- GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F;
- GL_SAMPLE_MASK_SGIS = $80A0;
- GL_1PASS_SGIS = $80A1;
- GL_2PASS_0_SGIS = $80A2;
- GL_2PASS_1_SGIS = $80A3;
- GL_4PASS_0_SGIS = $80A4;
- GL_4PASS_1_SGIS = $80A5;
- GL_4PASS_2_SGIS = $80A6;
- GL_4PASS_3_SGIS = $80A7;
- GL_SAMPLE_BUFFERS_SGIS = $80A8;
- GL_SAMPLES_SGIS = $80A9;
- GL_SAMPLE_MASK_VALUE_SGIS = $80AA;
- GL_SAMPLE_MASK_INVERT_SGIS = $80AB;
- GL_SAMPLE_PATTERN_SGIS = $80AC;
-
- // GL_SGIS_pixel_texture
- GL_PIXEL_TEXTURE_SGIS = $8353;
- GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354;
- GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355;
- GL_PIXEL_GROUP_COLOR_SGIS = $8356;
-
- // GL_SGIS_point_line_texgen
- GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0;
- GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1;
- GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2;
- GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3;
- GL_EYE_POINT_SGIS = $81F4;
- GL_OBJECT_POINT_SGIS = $81F5;
- GL_EYE_LINE_SGIS = $81F6;
- GL_OBJECT_LINE_SGIS = $81F7;
-
- // GL_SGIS_point_parameters
- GL_POINT_SIZE_MIN_SGIS = $8126;
- GL_POINT_SIZE_MAX_SGIS = $8127;
- GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128;
- GL_DISTANCE_ATTENUATION_SGIS = $8129;
-
- // GL_SGIS_sharpen_texture
- GL_LINEAR_SHARPEN_SGIS = $80AD;
- GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE;
- GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF;
- GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0;
-
- // GL_SGIS_texture4D
- GL_PACK_SKIP_VOLUMES_SGIS = $8130;
- GL_PACK_IMAGE_DEPTH_SGIS = $8131;
- GL_UNPACK_SKIP_VOLUMES_SGIS = $8132;
- GL_UNPACK_IMAGE_DEPTH_SGIS = $8133;
- GL_TEXTURE_4D_SGIS = $8134;
- GL_PROXY_TEXTURE_4D_SGIS = $8135;
- GL_TEXTURE_4DSIZE_SGIS = $8136;
- GL_TEXTURE_WRAP_Q_SGIS = $8137;
- GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138;
- GL_TEXTURE_4D_BINDING_SGIS = $814F;
-
- // GL_SGIS_texture_color_mask
- GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;
-
- // GL_SGIS_texture_edge_clamp
- GL_CLAMP_TO_EDGE_SGIS = $812F;
-
- // GL_SGIS_texture_filter4
- GL_FILTER4_SGIS = $8146;
- GL_TEXTURE_FILTER4_SIZE_SGIS = $8147;
-
- // GL_SGIS_texture_lod
- GL_TEXTURE_MIN_LOD_SGIS = $813A;
- GL_TEXTURE_MAX_LOD_SGIS = $813B;
- GL_TEXTURE_BASE_LEVEL_SGIS = $813C;
- GL_TEXTURE_MAX_LEVEL_SGIS = $813D;
-
- // GL_SGIS_texture_select
- GL_DUAL_ALPHA4_SGIS = $8110;
- GL_DUAL_ALPHA8_SGIS = $8111;
- GL_DUAL_ALPHA12_SGIS = $8112;
- GL_DUAL_ALPHA16_SGIS = $8113;
- GL_DUAL_LUMINANCE4_SGIS = $8114;
- GL_DUAL_LUMINANCE8_SGIS = $8115;
- GL_DUAL_LUMINANCE12_SGIS = $8116;
- GL_DUAL_LUMINANCE16_SGIS = $8117;
- GL_DUAL_INTENSITY4_SGIS = $8118;
- GL_DUAL_INTENSITY8_SGIS = $8119;
- GL_DUAL_INTENSITY12_SGIS = $811A;
- GL_DUAL_INTENSITY16_SGIS = $811B;
- GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C;
- GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D;
- GL_QUAD_ALPHA4_SGIS = $811E;
- GL_QUAD_ALPHA8_SGIS = $811F;
- GL_QUAD_LUMINANCE4_SGIS = $8120;
- GL_QUAD_LUMINANCE8_SGIS = $8121;
- GL_QUAD_INTENSITY4_SGIS = $8122;
- GL_QUAD_INTENSITY8_SGIS = $8123;
- GL_DUAL_TEXTURE_SELECT_SGIS = $8124;
- GL_QUAD_TEXTURE_SELECT_SGIS = $8125;
-
- // GL_SGIX_async
- GL_ASYNC_MARKER_SGIX = $8329;
-
- // GL_SGIX_async_histogram
- GL_ASYNC_HISTOGRAM_SGIX = $832C;
- GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D;
-
- // GL_SGIX_async_pixel
- GL_ASYNC_TEX_IMAGE_SGIX = $835C;
- GL_ASYNC_DRAW_PIXELS_SGIX = $835D;
- GL_ASYNC_READ_PIXELS_SGIX = $835E;
- GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F;
- GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360;
- GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361;
-
- // GL_SGIX_blend_alpha_minmax
- GL_ALPHA_MIN_SGIX = $8320;
- GL_ALPHA_MAX_SGIX = $8321;
-
- // GL_SGIX_calligraphic_fragment
- GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183;
-
- // GL_SGIX_clipmap
- GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170;
- GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171;
- GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172;
- GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173;
- GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174;
- GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175;
- GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176;
- GL_MAX_CLIPMAP_DEPTH_SGIX = $8177;
- GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178;
- GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D;
- GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E;
- GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F;
-
- // GL_SGIX_convolution_accuracy
- GL_CONVOLUTION_HINT_SGIX = $8316;
-
- // GL_SGIX_depth_texture
- GL_DEPTH_COMPONENT16_SGIX = $81A5;
- GL_DEPTH_COMPONENT24_SGIX = $81A6;
- GL_DEPTH_COMPONENT32_SGIX = $81A7;
-
- // GL_SGIX_fog_offset
- GL_FOG_OFFSET_SGIX = $8198;
- GL_FOG_OFFSET_VALUE_SGIX = $8199;
-
- // GL_SGIX_fog_scale
- GL_FOG_SCALE_SGIX = $81FC;
- GL_FOG_SCALE_VALUE_SGIX = $81FD;
-
- // GL_SGIX_fragment_lighting
- GL_FRAGMENT_LIGHTING_SGIX = $8400;
- GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401;
- GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402;
- GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403;
- GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404;
- GL_MAX_ACTIVE_LIGHTS_SGIX = $8405;
- GL_CURRENT_RASTER_NORMAL_SGIX = $8406;
- GL_LIGHT_ENV_MODE_SGIX = $8407;
- GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408;
- GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409;
- GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A;
- GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B;
- GL_FRAGMENT_LIGHT0_SGIX = $840C;
- GL_FRAGMENT_LIGHT1_SGIX = $840D;
- GL_FRAGMENT_LIGHT2_SGIX = $840E;
- GL_FRAGMENT_LIGHT3_SGIX = $840F;
- GL_FRAGMENT_LIGHT4_SGIX = $8410;
- GL_FRAGMENT_LIGHT5_SGIX = $8411;
- GL_FRAGMENT_LIGHT6_SGIX = $8412;
- GL_FRAGMENT_LIGHT7_SGIX = $8413;
-
- // GL_SGIX_framezoom
- GL_FRAMEZOOM_SGIX = $818B;
- GL_FRAMEZOOM_FACTOR_SGIX = $818C;
- GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D;
-
- // GL_SGIX_impact_pixel_texture
- GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184;
- GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185;
- GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186;
- GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187;
- GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188;
- GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189;
- GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A;
-
- // GL_SGIX_instruments
- GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180;
- GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181;
-
- // GL_SGIX_interlace
- GL_INTERLACE_SGIX = $8094;
-
- // GL_SGIX_ir_instrument1
- GL_IR_INSTRUMENT1_SGIX = $817F;
-
- // GL_SGIX_list_priority
- GL_LIST_PRIORITY_SGIX = $8182;
-
- // GL_SGIX_pixel_texture
- GL_PIXEL_TEX_GEN_SGIX = $8139;
- GL_PIXEL_TEX_GEN_MODE_SGIX = $832B;
-
- // GL_SGIX_pixel_tiles
- GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E;
- GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F;
- GL_PIXEL_TILE_WIDTH_SGIX = $8140;
- GL_PIXEL_TILE_HEIGHT_SGIX = $8141;
- GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142;
- GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143;
- GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144;
- GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145;
-
- // GL_SGIX_polynomial_ffd
- GL_GEOMETRY_DEFORMATION_SGIX = $8194;
- GL_TEXTURE_DEFORMATION_SGIX = $8195;
- GL_DEFORMATIONS_MASK_SGIX = $8196;
- GL_MAX_DEFORMATION_ORDER_SGIX = $8197;
-
- // GL_SGIX_reference_plane
- GL_REFERENCE_PLANE_SGIX = $817D;
- GL_REFERENCE_PLANE_EQUATION_SGIX = $817E;
-
- // GL_SGIX_resample
- GL_PACK_RESAMPLE_SGIX = $842C;
- GL_UNPACK_RESAMPLE_SGIX = $842D;
- GL_RESAMPLE_REPLICATE_SGIX = $842E;
- GL_RESAMPLE_ZERO_FILL_SGIX = $842F;
- GL_RESAMPLE_DECIMATE_SGIX = $8430;
-
- // GL_SGIX_scalebias_hint
- GL_SCALEBIAS_HINT_SGIX = $8322;
-
- // GL_SGIX_shadow
- GL_TEXTURE_COMPARE_SGIX = $819A;
- GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B;
- GL_TEXTURE_LEQUAL_R_SGIX = $819C;
- GL_TEXTURE_GEQUAL_R_SGIX = $819D;
-
- // GL_SGIX_shadow_ambient
- GL_SHADOW_AMBIENT_SGIX = $80BF;
-
- // GL_SGIX_sprite
- GL_SPRITE_SGIX = $8148;
- GL_SPRITE_MODE_SGIX = $8149;
- GL_SPRITE_AXIS_SGIX = $814A;
- GL_SPRITE_TRANSLATION_SGIX = $814B;
- GL_SPRITE_AXIAL_SGIX = $814C;
- GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D;
- GL_SPRITE_EYE_ALIGNED_SGIX = $814E;
-
- // GL_SGIX_subsample
- GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0;
- GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1;
- GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2;
- GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3;
- GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4;
-
- // GL_SGIX_texture_add_env
- GL_TEXTURE_ENV_BIAS_SGIX = $80BE;
-
- // GL_SGIX_texture_coordinate_clamp
- GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369;
- GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A;
- GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B;
-
- // GL_SGIX_texture_lod_bias
- GL_TEXTURE_LOD_BIAS_S_SGIX = $818E;
- GL_TEXTURE_LOD_BIAS_T_SGIX = $818F;
- GL_TEXTURE_LOD_BIAS_R_SGIX = $8190;
-
- // GL_SGIX_texture_multi_buffer
- GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E;
-
- // GL_SGIX_texture_scale_bias
- GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179;
- GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A;
- GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B;
- GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C;
-
- // GL_SGIX_vertex_preclip
- GL_VERTEX_PRECLIP_SGIX = $83EE;
- GL_VERTEX_PRECLIP_HINT_SGIX = $83EF;
-
- // GL_SGIX_ycrcb
- GL_YCRCB_422_SGIX = $81BB;
- GL_YCRCB_444_SGIX = $81BC;
-
- // GL_SGIX_ycrcba
- GL_YCRCB_SGIX = $8318;
- GL_YCRCBA_SGIX = $8319;
-
- // GL_SGI_color_matrix
- GL_COLOR_MATRIX_SGI = $80B1;
- GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2;
- GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3;
- GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4;
- GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5;
- GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6;
- GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7;
- GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8;
- GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9;
- GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA;
- GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB;
-
- // GL_SGI_color_table
- GL_COLOR_TABLE_SGI = $80D0;
- GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1;
- GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2;
- GL_PROXY_COLOR_TABLE_SGI = $80D3;
- GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4;
- GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5;
- GL_COLOR_TABLE_SCALE_SGI = $80D6;
- GL_COLOR_TABLE_BIAS_SGI = $80D7;
- GL_COLOR_TABLE_FORMAT_SGI = $80D8;
- GL_COLOR_TABLE_WIDTH_SGI = $80D9;
- GL_COLOR_TABLE_RED_SIZE_SGI = $80DA;
- GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB;
- GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC;
- GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD;
- GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE;
- GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF;
-
- // GL_SGI_depth_pass_instrument
- GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310;
- GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311;
- GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312;
-
- // GL_SGI_texture_color_table
- GL_TEXTURE_COLOR_TABLE_SGI = $80BC;
- GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD;
-
- // GL_SUNX_constant_data
- GL_UNPACK_CONSTANT_DATA_SUNX = $81D5;
- GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6;
-
- // GL_SUN_convolution_border_modes
- GL_WRAP_BORDER_SUN = $81D4;
-
- // GL_SUN_global_alpha
- GL_GLOBAL_ALPHA_SUN = $81D9;
- GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA;
-
- // GL_SUN_mesh_array
- GL_QUAD_MESH_SUN = $8614;
- GL_TRIANGLE_MESH_SUN = $8615;
-
- // GL_SUN_slice_accum
- GL_SLICE_ACCUM_SUN = $85CC;
-
- // GL_SUN_triangle_list
- GL_RESTART_SUN = $0001;
- GL_REPLACE_MIDDLE_SUN = $0002;
- GL_REPLACE_OLDEST_SUN = $0003;
- GL_TRIANGLE_LIST_SUN = $81D7;
- GL_REPLACEMENT_CODE_SUN = $81D8;
- GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0;
- GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1;
- GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2;
- GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3;
- GL_R1UI_V3F_SUN = $85C4;
- GL_R1UI_C4UB_V3F_SUN = $85C5;
- GL_R1UI_C3F_V3F_SUN = $85C6;
- GL_R1UI_N3F_V3F_SUN = $85C7;
- GL_R1UI_C4F_N3F_V3F_SUN = $85C8;
- GL_R1UI_T2F_V3F_SUN = $85C9;
- GL_R1UI_T2F_N3F_V3F_SUN = $85CA;
- GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB;
-
- // GL_WIN_phong_shading
- GL_PHONG_WIN = $80EA;
- GL_PHONG_HINT_WIN = $80EB;
-
- // GL_WIN_specular_fog
- GL_FOG_SPECULAR_TEXTURE_WIN = $80EC;
-
- // GL_ARB_vertex_shader
- GL_VERTEX_SHADER_ARB = $8B31;
- GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A;
- GL_MAX_VARYING_FLOATS_ARB = $8B4B;
- GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
- GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D;
- GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89;
- GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A;
-
- // GL_ARB_fragment_shader
- GL_FRAGMENT_SHADER_ARB = $8B30;
- GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4
- GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4
-
- // GL_ARB_occlusion_query
- GL_SAMPLES_PASSED_ARB = $8914;
- GL_QUERY_COUNTER_BITS_ARB = $8864;
- GL_CURRENT_QUERY_ARB = $8865;
- GL_QUERY_RESULT_ARB = $8866;
- GL_QUERY_RESULT_AVAILABLE_ARB = $8867;
-
- // GL_ARB_point_sprite
- GL_POINT_SPRITE_ARB = $8861;
- GL_COORD_REPLACE_ARB = $8862;
-
- // GL_ARB_shading_language_100
- GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4
-
- // GL_ARB_shader_objects
- GL_PROGRAM_OBJECT_ARB = $8B40;
-
- GL_OBJECT_TYPE_ARB = $8B4E;
- GL_OBJECT_SUBTYPE_ARB = $8B4F;
- GL_OBJECT_DELETE_STATUS_ARB = $8B80;
- GL_OBJECT_COMPILE_STATUS_ARB = $8B81;
- GL_OBJECT_LINK_STATUS_ARB = $8B82;
- GL_OBJECT_VALIDATE_STATUS_ARB = $8B83;
- GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84;
- GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85;
- GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86;
- GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87;
- GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88;
-
- GL_SHADER_OBJECT_ARB = $8B48;
-
- GL_FLOAT_VEC2_ARB = $8B50;
- GL_FLOAT_VEC3_ARB = $8B51;
- GL_FLOAT_VEC4_ARB = $8B52;
- GL_INT_VEC2_ARB = $8B53;
- GL_INT_VEC3_ARB = $8B54;
- GL_INT_VEC4_ARB = $8B55;
- GL_BOOL_ARB = $8B56;
- GL_BOOL_VEC2_ARB = $8B57;
- GL_BOOL_VEC3_ARB = $8B58;
- GL_BOOL_VEC4_ARB = $8B59;
- GL_FLOAT_MAT2_ARB = $8B5A;
- GL_FLOAT_MAT3_ARB = $8B5B;
- GL_FLOAT_MAT4_ARB = $8B5C;
- GL_SAMPLER_1D_ARB = $8B5D;
- GL_SAMPLER_2D_ARB = $8B5E;
- GL_SAMPLER_3D_ARB = $8B5F;
- GL_SAMPLER_CUBE_ARB = $8B60;
- GL_SAMPLER_1D_SHADOW_ARB = $8B61;
- GL_SAMPLER_2D_SHADOW_ARB = $8B62;
- GL_SAMPLER_2D_RECT_ARB = $8B63;
- GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64;
-
- // WGL_3DFX_multisample
- WGL_SAMPLE_BUFFERS_3DFX = $2060;
- WGL_SAMPLES_3DFX = $2061;
-
- // WGL_ARB_buffer_region
- WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001;
- WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002;
- WGL_DEPTH_BUFFER_BIT_ARB = $00000004;
- WGL_STENCIL_BUFFER_BIT_ARB = $00000008;
-
- // WGL_ARB_make_current_read
- ERROR_INVALID_PIXEL_TYPE_ARB = $2043;
- ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054;
-
- // WGL_ARB_multisample
- WGL_SAMPLE_BUFFERS_ARB = $2041;
- WGL_SAMPLES_ARB = $2042;
-
- // WGL_ARB_pbuffer
- WGL_DRAW_TO_PBUFFER_ARB = $202D;
- WGL_MAX_PBUFFER_PIXELS_ARB = $202E;
- WGL_MAX_PBUFFER_WIDTH_ARB = $202F;
- WGL_MAX_PBUFFER_HEIGHT_ARB = $2030;
- WGL_PBUFFER_LARGEST_ARB = $2033;
- WGL_PBUFFER_WIDTH_ARB = $2034;
- WGL_PBUFFER_HEIGHT_ARB = $2035;
- WGL_PBUFFER_LOST_ARB = $2036;
-
- // WGL_ARB_pixel_format
- WGL_NUMBER_PIXEL_FORMATS_ARB = $2000;
- WGL_DRAW_TO_WINDOW_ARB = $2001;
- WGL_DRAW_TO_BITMAP_ARB = $2002;
- WGL_ACCELERATION_ARB = $2003;
- WGL_NEED_PALETTE_ARB = $2004;
- WGL_NEED_SYSTEM_PALETTE_ARB = $2005;
- WGL_SWAP_LAYER_BUFFERS_ARB = $2006;
- WGL_SWAP_METHOD_ARB = $2007;
- WGL_NUMBER_OVERLAYS_ARB = $2008;
- WGL_NUMBER_UNDERLAYS_ARB = $2009;
- WGL_TRANSPARENT_ARB = $200A;
- WGL_TRANSPARENT_RED_VALUE_ARB = $2037;
- WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038;
- WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039;
- WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A;
- WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B;
- WGL_SHARE_DEPTH_ARB = $200C;
- WGL_SHARE_STENCIL_ARB = $200D;
- WGL_SHARE_ACCUM_ARB = $200E;
- WGL_SUPPORT_GDI_ARB = $200F;
- WGL_SUPPORT_OPENGL_ARB = $2010;
- WGL_DOUBLE_BUFFER_ARB = $2011;
- WGL_STEREO_ARB = $2012;
- WGL_PIXEL_TYPE_ARB = $2013;
- WGL_COLOR_BITS_ARB = $2014;
- WGL_RED_BITS_ARB = $2015;
- WGL_RED_SHIFT_ARB = $2016;
- WGL_GREEN_BITS_ARB = $2017;
- WGL_GREEN_SHIFT_ARB = $2018;
- WGL_BLUE_BITS_ARB = $2019;
- WGL_BLUE_SHIFT_ARB = $201A;
- WGL_ALPHA_BITS_ARB = $201B;
- WGL_ALPHA_SHIFT_ARB = $201C;
- WGL_ACCUM_BITS_ARB = $201D;
- WGL_ACCUM_RED_BITS_ARB = $201E;
- WGL_ACCUM_GREEN_BITS_ARB = $201F;
- WGL_ACCUM_BLUE_BITS_ARB = $2020;
- WGL_ACCUM_ALPHA_BITS_ARB = $2021;
- WGL_DEPTH_BITS_ARB = $2022;
- WGL_STENCIL_BITS_ARB = $2023;
- WGL_AUX_BUFFERS_ARB = $2024;
- WGL_NO_ACCELERATION_ARB = $2025;
- WGL_GENERIC_ACCELERATION_ARB = $2026;
- WGL_FULL_ACCELERATION_ARB = $2027;
- WGL_SWAP_EXCHANGE_ARB = $2028;
- WGL_SWAP_COPY_ARB = $2029;
- WGL_SWAP_UNDEFINED_ARB = $202A;
- WGL_TYPE_RGBA_ARB = $202B;
- WGL_TYPE_COLORINDEX_ARB = $202C;
-
- // WGL_ARB_pixel_format_float
- WGL_RGBA_FLOAT_MODE_ARB = $8820;
- WGL_CLAMP_VERTEX_COLOR_ARB = $891A;
- WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
- WGL_CLAMP_READ_COLOR_ARB = $891C;
- WGL_FIXED_ONLY_ARB = $891D;
-
- // WGL_ARB_render_texture
- WGL_BIND_TO_TEXTURE_RGB_ARB = $2070;
- WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071;
- WGL_TEXTURE_FORMAT_ARB = $2072;
- WGL_TEXTURE_TARGET_ARB = $2073;
- WGL_MIPMAP_TEXTURE_ARB = $2074;
- WGL_TEXTURE_RGB_ARB = $2075;
- WGL_TEXTURE_RGBA_ARB = $2076;
- WGL_NO_TEXTURE_ARB = $2077;
- WGL_TEXTURE_CUBE_MAP_ARB = $2078;
- WGL_TEXTURE_1D_ARB = $2079;
- WGL_TEXTURE_2D_ARB = $207A;
- WGL_MIPMAP_LEVEL_ARB = $207B;
- WGL_CUBE_MAP_FACE_ARB = $207C;
- WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D;
- WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E;
- WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F;
- WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080;
- WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081;
- WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082;
- WGL_FRONT_LEFT_ARB = $2083;
- WGL_FRONT_RIGHT_ARB = $2084;
- WGL_BACK_LEFT_ARB = $2085;
- WGL_BACK_RIGHT_ARB = $2086;
- WGL_AUX0_ARB = $2087;
- WGL_AUX1_ARB = $2088;
- WGL_AUX2_ARB = $2089;
- WGL_AUX3_ARB = $208A;
- WGL_AUX4_ARB = $208B;
- WGL_AUX5_ARB = $208C;
- WGL_AUX6_ARB = $208D;
- WGL_AUX7_ARB = $208E;
- WGL_AUX8_ARB = $208F;
- WGL_AUX9_ARB = $2090;
-
- // WGL_ARB_create_context
- WGL_CONTEXT_DEBUG_BIT_ARB = $00000001;
- WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
- WGL_CONTEXT_MAJOR_VERSION_ARB = $2091;
- WGL_CONTEXT_MINOR_VERSION_ARB = $2092;
- WGL_CONTEXT_LAYER_PLANE_ARB = $2093;
- WGL_CONTEXT_FLAGS_ARB = $2094;
- ERROR_INVALID_VERSION_ARB = $2095;
-
- // WGL_ARB_create_context_profile
- WGL_CONTEXT_PROFILE_MASK_ARB = $9126;
- WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
- WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
- ERROR_INVALID_PROFILE_ARB = $2096;
-
- // WGL_ARB_framebuffer_sRGB
- WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20A9;
-
- // WGL_ARB_create_context_robustness
- WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004;
- WGL_LOSE_CONTEXT_ON_RESET_ARB = $8252;
- WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
- WGL_NO_RESET_NOTIFICATION_ARB = $8261;
-
- // WGL_ATI_pixel_format_float
- WGL_TYPE_RGBA_FLOAT_ATI = $21A0;
- GL_TYPE_RGBA_FLOAT_ATI = $8820;
- GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835;
-
- // WGL_AMD_gpu_association
- WGL_GPU_VENDOR_AMD = $1F00;
- WGL_GPU_RENDERER_STRING_AMD = $1F01;
- WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02;
- WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2;
- WGL_GPU_RAM_AMD = $21A3;
- WGL_GPU_CLOCK_AMD = $21A4;
- WGL_GPU_NUM_PIPES_AMD = $21A5;
- WGL_GPU_NUM_SIMD_AMD = $21A6;
- WGL_GPU_NUM_RB_AMD = $21A7;
- WGL_GPU_NUM_SPI_AMD = $21A8;
-
- // WGL_EXT_depth_float
- WGL_DEPTH_FLOAT_EXT = $2040;
-
- // WGL_EXT_make_current_read
- ERROR_INVALID_PIXEL_TYPE_EXT = $2043;
-
- // WGL_EXT_multisample
- WGL_SAMPLE_BUFFERS_EXT = $2041;
- WGL_SAMPLES_EXT = $2042;
-
- // WGL_EXT_pbuffer
- WGL_DRAW_TO_PBUFFER_EXT = $202D;
- WGL_MAX_PBUFFER_PIXELS_EXT = $202E;
- WGL_MAX_PBUFFER_WIDTH_EXT = $202F;
- WGL_MAX_PBUFFER_HEIGHT_EXT = $2030;
- WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031;
- WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032;
- WGL_PBUFFER_LARGEST_EXT = $2033;
- WGL_PBUFFER_WIDTH_EXT = $2034;
- WGL_PBUFFER_HEIGHT_EXT = $2035;
-
- // WGL_EXT_pixel_format
- WGL_NUMBER_PIXEL_FORMATS_EXT = $2000;
- WGL_DRAW_TO_WINDOW_EXT = $2001;
- WGL_DRAW_TO_BITMAP_EXT = $2002;
- WGL_ACCELERATION_EXT = $2003;
- WGL_NEED_PALETTE_EXT = $2004;
- WGL_NEED_SYSTEM_PALETTE_EXT = $2005;
- WGL_SWAP_LAYER_BUFFERS_EXT = $2006;
- WGL_SWAP_METHOD_EXT = $2007;
- WGL_NUMBER_OVERLAYS_EXT = $2008;
- WGL_NUMBER_UNDERLAYS_EXT = $2009;
- WGL_TRANSPARENT_EXT = $200A;
- WGL_TRANSPARENT_VALUE_EXT = $200B;
- WGL_SHARE_DEPTH_EXT = $200C;
- WGL_SHARE_STENCIL_EXT = $200D;
- WGL_SHARE_ACCUM_EXT = $200E;
- WGL_SUPPORT_GDI_EXT = $200F;
- WGL_SUPPORT_OPENGL_EXT = $2010;
- WGL_DOUBLE_BUFFER_EXT = $2011;
- WGL_STEREO_EXT = $2012;
- WGL_PIXEL_TYPE_EXT = $2013;
- WGL_COLOR_BITS_EXT = $2014;
- WGL_RED_BITS_EXT = $2015;
- WGL_RED_SHIFT_EXT = $2016;
- WGL_GREEN_BITS_EXT = $2017;
- WGL_GREEN_SHIFT_EXT = $2018;
- WGL_BLUE_BITS_EXT = $2019;
- WGL_BLUE_SHIFT_EXT = $201A;
- WGL_ALPHA_BITS_EXT = $201B;
- WGL_ALPHA_SHIFT_EXT = $201C;
- WGL_ACCUM_BITS_EXT = $201D;
- WGL_ACCUM_RED_BITS_EXT = $201E;
- WGL_ACCUM_GREEN_BITS_EXT = $201F;
- WGL_ACCUM_BLUE_BITS_EXT = $2020;
- WGL_ACCUM_ALPHA_BITS_EXT = $2021;
- WGL_DEPTH_BITS_EXT = $2022;
- WGL_STENCIL_BITS_EXT = $2023;
- WGL_AUX_BUFFERS_EXT = $2024;
- WGL_NO_ACCELERATION_EXT = $2025;
- WGL_GENERIC_ACCELERATION_EXT = $2026;
- WGL_FULL_ACCELERATION_EXT = $2027;
- WGL_SWAP_EXCHANGE_EXT = $2028;
- WGL_SWAP_COPY_EXT = $2029;
- WGL_SWAP_UNDEFINED_EXT = $202A;
- WGL_TYPE_RGBA_EXT = $202B;
- WGL_TYPE_COLORINDEX_EXT = $202C;
-
- // WGL_I3D_digital_video_control
- WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050;
- WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051;
- WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052;
- WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053;
-
- // WGL_I3D_gamma
- WGL_GAMMA_TABLE_SIZE_I3D = $204E;
- WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F;
-
- // WGL_I3D_genlock
- WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044;
- WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045;
- WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046;
- WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047;
- WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048;
- WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049;
- WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A;
- WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B;
- WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C;
-
- // WGL_I3D_image_buffer
- WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001;
- WGL_IMAGE_BUFFER_LOCK_I3D = $00000002;
-
- // WGL_NV_float_buffer
- WGL_FLOAT_COMPONENTS_NV = $20B0;
- WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1;
- WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2;
- WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3;
- WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4;
- WGL_TEXTURE_FLOAT_R_NV = $20B5;
- WGL_TEXTURE_FLOAT_RG_NV = $20B6;
- WGL_TEXTURE_FLOAT_RGB_NV = $20B7;
- WGL_TEXTURE_FLOAT_RGBA_NV = $20B8;
-
- // WGL_NV_render_depth_texture
- WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3;
- WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4;
- WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5;
- WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6;
- WGL_DEPTH_COMPONENT_NV = $20A7;
-
- // WGL_NV_render_texture_rectangle
- WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;
- WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1;
- WGL_TEXTURE_RECTANGLE_NV = $20A2;
-
- // WGL_NV_present_video
- WGL_NUM_VIDEO_SLOTS_NV = $20F0;
-
- // WGL_NV_video_output
- WGL_BIND_TO_VIDEO_RGB_NV = $20C0;
- WGL_BIND_TO_VIDEO_RGBA_NV = $20C1;
- WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2;
- WGL_VIDEO_OUT_COLOR_NV = $20C3;
- WGL_VIDEO_OUT_ALPHA_NV = $20C4;
- WGL_VIDEO_OUT_DEPTH_NV = $20C5;
- WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6;
- WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7;
- WGL_VIDEO_OUT_FRAME = $20C8;
- WGL_VIDEO_OUT_FIELD_1 = $20C9;
- WGL_VIDEO_OUT_FIELD_2 = $20CA;
- WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB;
- WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC;
-
- // WGL_NV_gpu_affinity
- WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0;
- WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1;
-
- // WGL_NV_video_capture
- WGL_UNIQUE_ID_NV = $20CE;
- WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = $20CF;
-
- // WGL_NV_multisample_coverage
- WGL_COVERAGE_SAMPLES_NV = $2042;
- WGL_COLOR_SAMPLES_NV = $20B9;
-
- // WGL_EXT_create_context_es2_profile
- WGL_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004;
-
- // WGL_NV_DX_interop
- WGL_ACCESS_READ_ONLY_NV = $00000000;
- WGL_ACCESS_READ_WRITE_NV = $00000001;
- WGL_ACCESS_WRITE_DISCARD_NV = $00000002;
-
- // WIN_draw_range_elements
- GL_MAX_ELEMENTS_VERTICES_WIN = $80E8;
- GL_MAX_ELEMENTS_INDICES_WIN = $80E9;
-
- // GLX 1.1 and later:
- GLX_VENDOR = 1;
- GLX_VERSION = 2;
- GLX_EXTENSIONS = 3;
-
- GLX_USE_GL = 1;
- GLX_BUFFER_SIZE = 2;
- GLX_LEVEL = 3;
- GLX_RGBA = 4;
- GLX_DOUBLEBUFFER = 5;
- GLX_STEREO = 6;
- GLX_AUX_BUFFERS = 7;
- GLX_RED_SIZE = 8;
- GLX_GREEN_SIZE = 9;
- GLX_BLUE_SIZE = 10;
- GLX_ALPHA_SIZE = 11;
- GLX_DEPTH_SIZE = 12;
- GLX_STENCIL_SIZE = 13;
- GLX_ACCUM_RED_SIZE = 14;
- GLX_ACCUM_GREEN_SIZE = 15;
- GLX_ACCUM_BLUE_SIZE = 16;
- GLX_ACCUM_ALPHA_SIZE = 17;
-
- // GLX_VERSION_1_3
- GLX_WINDOW_BIT = $00000001;
- GLX_PIXMAP_BIT = $00000002;
- GLX_PBUFFER_BIT = $00000004;
- GLX_RGBA_BIT = $00000001;
- GLX_COLOR_INDEX_BIT = $00000002;
- GLX_PBUFFER_CLOBBER_MASK = $08000000;
- GLX_FRONT_LEFT_BUFFER_BIT = $00000001;
- GLX_FRONT_RIGHT_BUFFER_BIT = $00000002;
- GLX_BACK_LEFT_BUFFER_BIT = $00000004;
- GLX_BACK_RIGHT_BUFFER_BIT = $00000008;
- GLX_AUX_BUFFERS_BIT = $00000010;
- GLX_DEPTH_BUFFER_BIT = $00000020;
- GLX_STENCIL_BUFFER_BIT = $00000040;
- GLX_ACCUM_BUFFER_BIT = $00000080;
- GLX_CONFIG_CAVEAT = $20;
- GLX_X_VISUAL_TYPE = $22;
- GLX_TRANSPARENT_TYPE = $23;
- GLX_TRANSPARENT_INDEX_VALUE = $24;
- GLX_TRANSPARENT_RED_VALUE = $25;
- GLX_TRANSPARENT_GREEN_VALUE = $26;
- GLX_TRANSPARENT_BLUE_VALUE = $27;
- GLX_TRANSPARENT_ALPHA_VALUE = $28;
- GLX_DONT_CARE = $FFFFFFFF;
- GLX_NONE = $8000;
- GLX_SLOW_CONFIG = $8001;
- GLX_TRUE_COLOR = $8002;
- GLX_DIRECT_COLOR = $8003;
- GLX_PSEUDO_COLOR = $8004;
- GLX_STATIC_COLOR = $8005;
- GLX_GRAY_SCALE = $8006;
- GLX_STATIC_GRAY = $8007;
- GLX_TRANSPARENT_RGB = $8008;
- GLX_TRANSPARENT_INDEX = $8009;
- GLX_VISUAL_ID = $800B;
- GLX_SCREEN = $800C;
- GLX_NON_CONFORMANT_CONFIG = $800D;
- GLX_DRAWABLE_TYPE = $8010;
- GLX_RENDER_TYPE = $8011;
- GLX_X_RENDERABLE = $8012;
- GLX_FBCONFIG_ID = $8013;
- GLX_RGBA_TYPE = $8014;
- GLX_COLOR_INDEX_TYPE = $8015;
- GLX_MAX_PBUFFER_WIDTH = $8016;
- GLX_MAX_PBUFFER_HEIGHT = $8017;
- GLX_MAX_PBUFFER_PIXELS = $8018;
- GLX_PRESERVED_CONTENTS = $801B;
- GLX_LARGEST_PBUFFER = $801C;
- GLX_WIDTH = $801D;
- GLX_HEIGHT = $801E;
- GLX_EVENT_MASK = $801F;
- GLX_DAMAGED = $8020;
- GLX_SAVED = $8021;
- GLX_WINDOW = $8022;
- GLX_PBUFFER = $8023;
- GLX_PBUFFER_HEIGHT = $8040;
- GLX_PBUFFER_WIDTH = $8041;
-
- // GLX_VERSION_1_4
- GLX_SAMPLE_BUFFERS = 100000;
- GLX_SAMPLES = 100001;
-
- // GLX_ARB_multisample
- GLX_SAMPLE_BUFFERS_ARB = 100000;
- GLX_SAMPLES_ARB = 100001;
-
- // GLX_ARB_fbconfig_float
- GLX_RGBA_FLOAT_TYPE_ARB = $20B9;
- GLX_RGBA_FLOAT_BIT_ARB = $00000004;
-
- // GLX_ARB_create_context
- GLX_CONTEXT_DEBUG_BIT_ARB = $00000001;
- GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
- GLX_CONTEXT_MAJOR_VERSION_ARB = $2091;
- GLX_CONTEXT_MINOR_VERSION_ARB = $2092;
- GLX_CONTEXT_FLAGS_ARB = $2094;
-
- // GLX_ARB_create_context_profile
- GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
- GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
- GLX_CONTEXT_PROFILE_MASK_ARB = $9126;
-
- // GLX_ARB_vertex_buffer_object
- GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = $2095;
-
- // GLX_ARB_framebuffer_sRGB
- GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20B2;
-
- // GLX_ARB_create_context_robustness
- GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004;
- GLX_LOSE_CONTEXT_ON_RESET_ARB = $8252;
- GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
- GLX_NO_RESET_NOTIFICATION_ARB = $8261;
-
- // GLX_EXT_visual_info
- GLX_X_VISUAL_TYPE_EXT = $22;
- GLX_TRANSPARENT_TYPE_EXT = $23;
- GLX_TRANSPARENT_INDEX_VALUE_EXT = $24;
- GLX_TRANSPARENT_RED_VALUE_EXT = $25;
- GLX_TRANSPARENT_GREEN_VALUE_EXT = $26;
- GLX_TRANSPARENT_BLUE_VALUE_EXT = $27;
- GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28;
- GLX_NONE_EXT = $8000;
- GLX_TRUE_COLOR_EXT = $8002;
- GLX_DIRECT_COLOR_EXT = $8003;
- GLX_PSEUDO_COLOR_EXT = $8004;
- GLX_STATIC_COLOR_EXT = $8005;
- GLX_GRAY_SCALE_EXT = $8006;
- GLX_STATIC_GRAY_EXT = $8007;
- GLX_TRANSPARENT_RGB_EXT = $8008;
- GLX_TRANSPARENT_INDEX_EXT = $8009;
-
- // GLX_EXT_visual_rating
- GLX_VISUAL_CAVEAT_EXT = $20;
- GLX_SLOW_VISUAL_EXT = $8001;
- GLX_NON_CONFORMANT_VISUAL_EXT = $800D;
- (* reuse GLX_NONE_EXT *)
-
- // GLX_EXT_import_context
- GLX_SHARE_CONTEXT_EXT = $800A;
- GLX_VISUAL_ID_EXT = $800B;
- GLX_SCREEN_EXT = $800C;
-
- // GLX_EXT_fbconfig_packed_float
-// GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
-// GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
-
- // GLX_EXT_framebuffer_sRGB
-// GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
-
- // GLX_EXT_texture_from_pixmap
- GLX_TEXTURE_1D_BIT_EXT = $00000001;
- GLX_TEXTURE_2D_BIT_EXT = $00000002;
- GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004;
- GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0;
- GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1;
- GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2;
- GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3;
- GLX_Y_INVERTED_EXT = $20D4;
- GLX_TEXTURE_FORMAT_EXT = $20D5;
- GLX_TEXTURE_TARGET_EXT = $20D6;
- GLX_MIPMAP_TEXTURE_EXT = $20D7;
- GLX_TEXTURE_FORMAT_NONE_EXT = $20D8;
- GLX_TEXTURE_FORMAT_RGB_EXT = $20D9;
- GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA;
- GLX_TEXTURE_1D_EXT = $20DB;
- GLX_TEXTURE_2D_EXT = $20DC;
- GLX_TEXTURE_RECTANGLE_EXT = $20DD;
- GLX_FRONT_LEFT_EXT = $20DE;
- GLX_FRONT_RIGHT_EXT = $20DF;
- GLX_BACK_LEFT_EXT = $20E0;
- GLX_BACK_RIGHT_EXT = $20E1;
- GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT;
- GLX_BACK_EXT = GLX_BACK_LEFT_EXT;
- GLX_AUX0_EXT = $20E2;
- GLX_AUX1_EXT = $20E3;
- GLX_AUX2_EXT = $20E4;
- GLX_AUX3_EXT = $20E5;
- GLX_AUX4_EXT = $20E6;
- GLX_AUX5_EXT = $20E7;
- GLX_AUX6_EXT = $20E8;
- GLX_AUX7_EXT = $20E9;
- GLX_AUX8_EXT = $20EA;
- GLX_AUX9_EXT = $20EB;
-
- // GLX_EXT_swap_control
- GLX_SWAP_INTERVAL_EXT = $20F1;
- GLX_MAX_SWAP_INTERVAL_EXT = $20F2;
-
- // GLX_EXT_create_context_es2_profile
- GLX_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004;
-
- // GL_EXT_Late_Swaps
- GLX_LATE_SWAPS_TEAR_EXT = $20F3;
-
- // GLU
- GLU_INVALID_ENUM = 100900;
- GLU_INVALID_VALUE = 100901;
- GLU_OUT_OF_MEMORY = 100902;
- GLU_INCOMPATIBLE_GL_VERSION = 100903;
- GLU_VERSION = 100800;
- GLU_EXTENSIONS = 100801;
- GLU_TRUE = GL_TRUE;
- GLU_FALSE = GL_FALSE;
- GLU_SMOOTH = 100000;
- GLU_FLAT = 100001;
- GLU_NONE = 100002;
- GLU_POINT = 100010;
- GLU_LINE = 100011;
- GLU_FILL = 100012;
- GLU_SILHOUETTE = 100013;
- GLU_OUTSIDE = 100020;
- GLU_INSIDE = 100021;
- GLU_TESS_MAX_COORD = 1.0E150;
- GLU_TESS_WINDING_RULE = 100140;
- GLU_TESS_BOUNDARY_ONLY = 100141;
- GLU_TESS_TOLERANCE = 100142;
- GLU_TESS_WINDING_ODD = 100130;
- GLU_TESS_WINDING_NONZERO = 100131;
- GLU_TESS_WINDING_POSITIVE = 100132;
- GLU_TESS_WINDING_NEGATIVE = 100133;
- GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
- GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc
- GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc
- GLU_TESS_END = 100102; // TGLUTessEndProc
- GLU_TESS_ERROR = 100103; // TGLUTessErrorProc
- GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc
- GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc
- GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc
- GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc
- GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc
- GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc
- GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc
- GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc
- GLU_TESS_ERROR1 = 100151;
- GLU_TESS_ERROR2 = 100152;
- GLU_TESS_ERROR3 = 100153;
- GLU_TESS_ERROR4 = 100154;
- GLU_TESS_ERROR5 = 100155;
- GLU_TESS_ERROR6 = 100156;
- GLU_TESS_ERROR7 = 100157;
- GLU_TESS_ERROR8 = 100158;
- GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1;
- GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2;
- GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3;
- GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4;
- GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5;
- GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6;
- GLU_AUTO_LOAD_MATRIX = 100200;
- GLU_CULLING = 100201;
- GLU_SAMPLING_TOLERANCE = 100203;
- GLU_DISPLAY_MODE = 100204;
- GLU_PARAMETRIC_TOLERANCE = 100202;
- GLU_SAMPLING_METHOD = 100205;
- GLU_U_STEP = 100206;
- GLU_V_STEP = 100207;
- GLU_PATH_LENGTH = 100215;
- GLU_PARAMETRIC_ERROR = 100216;
- GLU_DOMAIN_DISTANCE = 100217;
- GLU_MAP1_TRIM_2 = 100210;
- GLU_MAP1_TRIM_3 = 100211;
- GLU_OUTLINE_POLYGON = 100240;
- GLU_OUTLINE_PATCH = 100241;
- GLU_NURBS_ERROR1 = 100251;
- GLU_NURBS_ERROR2 = 100252;
- GLU_NURBS_ERROR3 = 100253;
- GLU_NURBS_ERROR4 = 100254;
- GLU_NURBS_ERROR5 = 100255;
- GLU_NURBS_ERROR6 = 100256;
- GLU_NURBS_ERROR7 = 100257;
- GLU_NURBS_ERROR8 = 100258;
- GLU_NURBS_ERROR9 = 100259;
- GLU_NURBS_ERROR10 = 100260;
- GLU_NURBS_ERROR11 = 100261;
- GLU_NURBS_ERROR12 = 100262;
- GLU_NURBS_ERROR13 = 100263;
- GLU_NURBS_ERROR14 = 100264;
- GLU_NURBS_ERROR15 = 100265;
- GLU_NURBS_ERROR16 = 100266;
- GLU_NURBS_ERROR17 = 100267;
- GLU_NURBS_ERROR18 = 100268;
- GLU_NURBS_ERROR19 = 100269;
- GLU_NURBS_ERROR20 = 100270;
- GLU_NURBS_ERROR21 = 100271;
- GLU_NURBS_ERROR22 = 100272;
- GLU_NURBS_ERROR23 = 100273;
- GLU_NURBS_ERROR24 = 100274;
- GLU_NURBS_ERROR25 = 100275;
- GLU_NURBS_ERROR26 = 100276;
- GLU_NURBS_ERROR27 = 100277;
- GLU_NURBS_ERROR28 = 100278;
- GLU_NURBS_ERROR29 = 100279;
- GLU_NURBS_ERROR30 = 100280;
- GLU_NURBS_ERROR31 = 100281;
- GLU_NURBS_ERROR32 = 100282;
- GLU_NURBS_ERROR33 = 100283;
- GLU_NURBS_ERROR34 = 100284;
- GLU_NURBS_ERROR35 = 100285;
- GLU_NURBS_ERROR36 = 100286;
- GLU_NURBS_ERROR37 = 100287;
- GLU_CW = 100120;
- GLU_CCW = 100121;
- GLU_INTERIOR = 100122;
- GLU_EXTERIOR = 100123;
- GLU_UNKNOWN = 100124;
- GLU_BEGIN = GLU_TESS_BEGIN;
- GLU_VERTEX = GLU_TESS_VERTEX;
- GLU_END = GLU_TESS_END;
- GLU_ERROR = GLU_TESS_ERROR;
- GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG;
-
-type
- // GL_VERSION_1_0
- TglCullFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFrontFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglHint = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLineWidth = procedure(width: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointSize = procedure(size: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPolygonMode = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScissor = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClear = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearStencil = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearDepth = procedure(depth: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorMask = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthMask = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinish = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFlush = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFunc = procedure(sfactor: GLenum; dfactor: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLogicOp = procedure(opcode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilFunc = procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilOp = procedure(fail: GLenum; zfail: GLenum; zpass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthFunc = procedure(func: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelStoref = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReadBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBooleanv = procedure(pname: GLenum; params: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDoublev = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetError = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFloatv = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsEnabled = function(cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthRange = procedure(zNear: GLclampd; zFar: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglViewport = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_1_1
- TglDrawArrays = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElements = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPointerv = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPolygonOffset = procedure(factor: GLfloat; units: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexImage1D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexImage2D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-{$ifdef DGL_DEPRECATED}
- TglAccum = procedure(op: GLenum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAlphaFunc = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglArrayElement = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBegin = procedure(mode: GLenum); {$IFNDEF CLR}{$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}{$ENDIF}
- TglBitmap = procedure(width: GLsizei; height: GLsizei; xorig: GLfloat; yorig: GLfloat; xmove: GLfloat; ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCallList = procedure(list: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCallLists = procedure(n: GLsizei; _type: GLenum; const lists: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearAccum = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearIndex = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClipPlane = procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte; alpha: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble; alpha: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4i = procedure(red: GLint; green: GLint; blue: GLint; alpha: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4s = procedure(red: GLshort; green: GLshort; blue: GLshort; alpha: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte; alpha: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ui = procedure(red: GLuint; green: GLuint; blue: GLuint; alpha: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4us = procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorMaterial = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; _type: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteLists = procedure(list: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawPixels = procedure(width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlag = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlagPointer = procedure(stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlagv = procedure(const flag: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnd = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndList = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord1d = procedure(u: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord1dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord1f = procedure(u: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord1fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord2d = procedure(u: GLdouble; v: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord2dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord2f = procedure(u: GLfloat; v: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalCoord2fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalMesh1 = procedure(mode: GLenum; i1: GLint; i2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalMesh2 = procedure(mode: GLenum; i1: GLint; i2: GLint; j1: GLint; j2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalPoint1 = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalPoint2 = procedure(i: GLint; j: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFeedbackBuffer = procedure(size: GLsizei; _type: GLenum; buffer: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogiv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFrustum = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenLists = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetClipPlane = procedure(plane: GLenum; equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetLightfv = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetLightiv = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapdv = procedure(target: GLenum; query: GLenum; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapfv = procedure(target: GLenum; query: GLenum; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapiv = procedure(target: GLenum; query: GLenum; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMaterialfv = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMaterialiv = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPixelMapfv = procedure(map: GLenum; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPixelMapuiv = procedure(map: GLenum; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPixelMapusv = procedure(map: GLenum; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPolygonStipple = procedure(mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexEnvfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexEnviv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexGendv = procedure(coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexGenfv = procedure(coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexGeniv = procedure(coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexd = procedure(c: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexdv = procedure(const c: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexf = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexfv = procedure(const c: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexi = procedure(c: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexiv = procedure(const c: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexs = procedure(c: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexsv = procedure(const c: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexub = procedure(c: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexubv = procedure(const c: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInitNames = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInterleavedArrays = procedure(format: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsList = function(list: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsTexture = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightModelf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightModelfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightModeli = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightModeliv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightf = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightfv = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLighti = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightiv = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLineStipple = procedure(factor: GLint; pattern: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglListBase = procedure(base: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadIdentity = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMap1d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMap1f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMap2d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMap2f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapGrid1d = procedure(un: GLint; u1: GLdouble; u2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapGrid1f = procedure(un: GLint; u1: GLfloat; u2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapGrid2d = procedure(un: GLint; u1: GLdouble; u2: GLdouble; vn: GLint; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapGrid2f = procedure(un: GLint; u1: GLfloat; u2: GLfloat; vn: GLint; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMaterialf = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMaterialfv = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMateriali = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMaterialiv = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixMode = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNewList = procedure(list: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3b = procedure(nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3d = procedure(nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3f = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3i = procedure(nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3s = procedure(nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglOrtho = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPassThrough = procedure(token: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelMapfv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelMapuiv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelMapusv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTransferf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTransferi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelZoom = procedure(xfactor: GLfloat; yfactor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPolygonStipple = procedure(const mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPopAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPopClientAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPopMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPopName = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPrioritizeTextures = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushClientAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRasterPos4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectd = procedure(x1: GLdouble; y1: GLdouble; x2: GLdouble; y2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectdv = procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectf = procedure(x1: GLfloat; y1: GLfloat; x2: GLfloat; y2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectfv = procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRecti = procedure(x1: GLint; y1: GLint; x2: GLint; y2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectiv = procedure(const v1: PGLint; const v2: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRects = procedure(x1: GLshort; y1: GLshort; x2: GLshort; y2: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRectsv = procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRenderMode = function(mode: GLenum): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRotated = procedure(angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRotatef = procedure(angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScaled = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScalef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSelectBuffer = procedure(size: GLsizei; buffer: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShadeModel = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1d = procedure(s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1f = procedure(s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1i = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1s = procedure(s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2d = procedure(s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2f = procedure(s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2i = procedure(s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2s = procedure(s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3d = procedure(s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3f = procedure(s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3i = procedure(s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3s = procedure(s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4d = procedure(s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4f = procedure(s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4i = procedure(s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4s = procedure(s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexEnvf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexEnvfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexEnvi = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexEnviv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGend = procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGendv = procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGenf = procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGenfv = procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexGeniv = procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-
- TglTranslated = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTranslatef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$endif}
-
- // GL_VERSION_1_2
- TglBlendColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquation = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawRangeElements = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$ifdef DGL_DEPRECATED}
- TglColorTable = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorTableParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorTableParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyColorTable = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTable = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorSubTable = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyColorSubTable = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameterf = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameteri = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSeparableFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSeparableFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHistogram = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHistogramParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHistogramParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmax = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmaxParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmaxParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglHistogram = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMinmax = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResetHistogram = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResetMinmax = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$endif}
-
- // GL_VERSION_1_3
- TglActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSampleCoverage = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$ifdef DGL_DEPRECATED}
- TglClientActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1d = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1f = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1i = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1s = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2d = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2f = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2i = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2s = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$endif}
-
- // GL_VERSION_1_4
- TglBlendFuncSeparate = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawArrays = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawElements = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameteri = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameteriv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$ifdef DGL_DEPRECATED}
- TglFogCoordf = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordd = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-{$endif}
-
- // GL_VERSION_1_5
- TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBuffer = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteBuffers = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenBuffers = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsBuffer = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBufferData = procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapBuffer = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUnmapBuffer = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferPointerv = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_2_0
- TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilFuncSeparate = procedure(face: GLenum; func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveAttrib = procedure(programObj: GLhandle; index: GLuint; maxlength: GLsizei; var length: GLint; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniform = procedure(programObj: GLhandle; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetAttribLocation = function(programObj: GLhandle; char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramiv = procedure(programObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; var length: GLint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; var length: glint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsProgram = function(programObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsShader = function(shaderObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; const _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_2_1
- TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_3_0
- { OpenGL 3.0 also reuses entry points from these extensions: }
- { ARB_framebuffer_object }
- { ARB_map_buffer_range }
- { ARB_vertex_array_object }
- TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_2_1
- TglEnableVertexArrayEXT = procedure(vaobj: GLuint; array_: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableVertexArrayAttribEXT = procedure(vaobj: GLuint; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; normalized: GLboolean; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_3_1
- { OpenGL 3.1 also reuses entry points from these extensions: }
- { ARB_copy_buffer }
- { ARB_uniform_buffer_object }
- TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_3_2
- { OpenGL 3.2 also reuses entry points from these extensions: }
- { ARB_draw_elements_base_vertex }
- { ARB_provoking_vertex }
- { ARB_sync }
- { ARB_texture_multisample }
- TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-// TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_3_3
- { OpenGL 3.3 also reuses entry points from these extensions: }
- { ARB_blend_func_extended }
- { ARB_sampler_objects }
- { ARB_explicit_attrib_location, but it has none }
- { ARB_occlusion_query2 (no entry points) }
- { ARB_shader_bit_encoding (no entry points) }
- { ARB_texture_rgb10_a2ui (no entry points) }
- { ARB_texture_swizzle (no entry points) }
- { ARB_timer_query }
- { ARB_vertex_type_2_10_10_10_rev }
- TglVertexAttribDivisor = procedure(index: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_4_0
- { OpenGL 4.0 also reuses entry points from these extensions: }
- { ARB_texture_query_lod (no entry points) }
- { ARB_draw_indirect }
- { ARB_gpu_shader5 (no entry points) }
- { ARB_gpu_shader_fp64 }
- { ARB_shader_subroutine }
- { ARB_tessellation_shader }
- { ARB_texture_buffer_object_rgb32 (no entry points) }
- { ARB_texture_cube_map_array (no entry points) }
- { ARB_texture_gather (no entry points) }
- { ARB_transform_feedback2 }
- { ARB_transform_feedback3 }
- TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_VERSION_4_1
- { OpenGL 4.1 also reuses entry points from these extensions: }
- { ARB_ES2_compatibility }
- { ARB_get_program_binary }
- { ARB_separate_shader_objects }
- { ARB_shader_precision (no entry points) }
- { ARB_vertex_attrib_64bit }
- { ARB_viewport_array }
-
- // GL_3DFX_tbuffer
- TglTbufferMask3DFX = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_element_array
- TglElementPointerAPPLE = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementArrayAPPLE = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawElementArrayAPPLE = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_fence
- TglGenFencesAPPLE = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteFencesAPPLE = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSetFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTestFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinishFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTestObjectAPPLE = function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinishObjectAPPLE = procedure(_object: GLenum; name: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_vertex_array_object
- TglBindVertexArrayAPPLE = procedure(_array: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsVertexArrayAPPLE = function(_array: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_vertex_array_range
- TglVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFlushVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayParameteriAPPLE = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_texture_range
- TglTextureRangeAPPLE = procedure(target: GLenum; length: GLsizei; const Pointer_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterPointervAPPLE = procedure(target: GLenum; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_vertex_program_evaluators
- TglEnableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsVertexAttribEnabledAPPLE = function(index_: GLuint; pname: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapVertexAttrib1dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapVertexAttrib1fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapVertexAttrib2dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapVertexAttrib2fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; ustride: GLint; order: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_APPLE_object_purgeable
- TglObjectPurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglObjectUnpurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectParameterivAPPLE = procedure(objectType: GLenum; name: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_matrix_palette
- TglCurrentPaletteMatrixARB = procedure(index: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixIndexubvARB = procedure(size: GLint; const indices: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixIndexusvARB = procedure(size: GLint; const indices: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixIndexuivARB = procedure(size: GLint; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixIndexPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_multisample
- TglSampleCoverageARB = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_multitexture
- TglActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClientActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1dARB = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1fARB = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1iARB = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1sARB = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2iARB = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2sARB = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_point_parameters
- TglPointParameterfARB = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterfvARB = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_texture_compression
- TglCompressedTexImage3DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexImage2DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexImage1DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage3DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage2DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTexSubImage1DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCompressedTexImageARB = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_transpose_matrix
- TglLoadTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_blend
- TglWeightbvARB = procedure(size: GLint; const weights: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightsvARB = procedure(size: GLint; const weights: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightivARB = procedure(size: GLint; const weights: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightfvARB = procedure(size: GLint; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightdvARB = procedure(size: GLint; const weights: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightubvARB = procedure(size: GLint; const weights: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightusvARB = procedure(size: GLint; const weights: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightuivARB = procedure(size: GLint; const weights: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexBlendARB = procedure(count: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_buffer_object
- TglBindBufferARB = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteBuffersARB = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenBuffersARB = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsBufferARB = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBufferDataARB = procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapBufferARB = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUnmapBufferARB = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferParameterivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferPointervARB = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_program
- TglVertexAttrib1dARB = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1fARB = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1sARB = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2sARB = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NbvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NsvARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NubARB = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NuivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4NusvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4bvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4ivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4ubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4uivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4usvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribPointerARB = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramStringARB = procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindProgramARB = procedure(target: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteProgramsARB = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenProgramsARB = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramEnvParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramEnvParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramLocalParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramLocalParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramStringARB = procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribdvARB = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribfvARB = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribivARB = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribPointervARB = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsProgramARB = function(_program: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_window_pos
- TglWindowPos2dARB = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2fARB = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2iARB = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2sARB = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3dARB = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3fARB = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3iARB = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3sARB = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_draw_buffers
- TglDrawBuffersARB = procedure(n: GLsizei; bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_color_buffer_float
- TglClampColorARB = procedure(target: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_shader
- TglGetActiveAttribARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetAttribLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindAttribLocationARB = procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_shader_objects
- TglDeleteObjectARB = procedure(Obj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHandleARB = function(pname: GlEnum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDetachObjectARB = procedure(container, attached: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateShaderObjectARB = function(shaderType: glenum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderSourceARB = procedure(shaderObj: GLHandleARB; count: glsizei; const _string: PPGLCharARB; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompileShaderARB = procedure(shaderObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateProgramObjectARB = function: GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAttachObjectARB = procedure(programObj, shaderObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLinkProgramARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUseProgramObjectARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglValidateProgramARB = procedure(programObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1fARB = procedure(location: glint; v0: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2fARB = procedure(location: glint; v0, v1: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3fARB = procedure(location: glint; v0, v1, v2: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4fARB = procedure(location: glint; v0, v1, v2, v3: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1iARB = procedure(location: glint; v0: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2iARB = procedure(location: glint; v0, v1: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3iARB = procedure(location: glint; v0, v1, v2: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4iARB = procedure(location: glint; v0, v1, v2, v3: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectParameterfvARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectParameterivARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetInfoLogARB = procedure(shaderObj: GLHandleARB; maxLength: glsizei; var length: glint; infoLog: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetAttachedObjectsARB = procedure(programobj: GLhandleARB; maxCount: GLsizei; var count: GLsizei; objects: PGLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniformARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformfvARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformivARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetShaderSourceARB = procedure(shader: GLhandleARB; maxLength: GLsizei; var length: GLsizei; source: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_Occlusion_Query
- TglGenQueriesARB = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteQueriesARB = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsQueryARB = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginQueryARB = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndQueryARB = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryivARB = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectivARB = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectuivARB = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_draw_instanced
- TglDrawArraysInstancedARB = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstancedARB = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_framebuffer_object
- TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_geometry_shader4
- TglProgramParameteriARB = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureLayerARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureFaceARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_instanced_arrays
- TglVertexAttribDivisorARB = procedure(index_: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_map_buffer_range
- TglMapBufferRange = function(target: GLenum; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_texture_buffer_object
- TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_array_object
- TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_uniform_buffer_object
- TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_copy_buffer
- TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_draw_elements_base_vertex
- TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_provoking_vertex
- TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_sync
- TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_texture_multisample
- TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_draw_buffers_blend
- TglBlendEquationiARB = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquationSeparateiARB = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFunciARB = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFuncSeparateiARB = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_sample_shading
- TglMinSampleShadingARB = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_shading_language_include
- TglNamedStringARB = procedure(type_: GLenum; namelen: GLint; const name: PGLchar; stringlen: GLint; const string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteNamedStringARB = procedure(namelen: GLint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompileShaderIncludeARB = procedure (shader: GLuint; count: GLsizei; const path: PPGLchar; const length: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsNamedStringARB = function(namelen: GLint; const name: PGLchar): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedStringARB = procedure(namelen: GLint; const name: PGLchar; bufSize: GLsizei; stringlen: GLint; string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedStringivARB = procedure(namelen: GLint; const name: PGLchar; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_blend_func_extended
- TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_sampler_objects
- TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_timer_query
- TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_type_2_10_10_10_rev
- TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_draw_indirect
- TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_gpu_shader_fp64
- TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_shader_subroutine
- TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_tessellation_shader
- TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_transform_feedback2
- TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_transform_feedback3
- TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_ES2_compatibility
- TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_get_program_binary
- TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_separate_shader_objects
- TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_attrib_64bit
- TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_viewport_array
- TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL 4.2
-
- // GL_ARB_base_instance
- TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_transform_feedback_instanced
- TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_internalformat_query
- TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_shader_atomic_counters
- TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- /// GL_ARB_shader_image_load_store
- TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_texture_storage
- TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureStorage1DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureStorage2DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureStorage3DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-
- // GL 4.3
-
- // GL_KHR_debug
- TglDebugMessageControl = procedure(source : GLenum; type_ : GLenum; severity : TGLenum; count : GLsizei; const ids : PGLUInt; enabled : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageInsert = procedure(source : GLenum; type_ : GLenum; id : GLuint; sverity : GLenum; length : GLsizei; const buf : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageCallback = procedure(callback : TGLDEBUGPROC; const userParam : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDebugMessageLog = function(count : GLuint; bufsize : GLsizei; sources : PGLenum; types : PGLenum; ids : PGLuint; sverities : PGLenum; lengths : PGLSizei; messagelog : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushDebugGroup = procedure(source : GLenum; id : GLuint; length : GLsizei; const message_ : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPopDebugGroup = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglObjectLabel = procedure(identifier : GLenum; name : GLuint; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectLabel = procedure(identifier : GLenum; name : GLuint; bufsize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglObjectPtrLabel = procedure(const ptr : Pointer; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectPtrLabel = procedure(const ptr : Pointer; bufSize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_clear_buffer_object
- TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearNamedBufferDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearNamedBufferSubDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLenum; type_ : GLenum; offset : GLsizeiptr; size : GLsizeiptr; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_compute_shader 1
- TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_copy_image
- TglCopyImageSubData = procedure(srcName : GLUInt; srcTarget : GLenum; srcLevel : GLint; srcX : GLint; srcY : GLint; srcZ : GLint; dstName : GLUInt; dstTarget : GLEnum; dstLevel : GLInt; dstX : GLInt; dstY : GLint; dstZ : GLint; srcWidth : GLsizei; srcHeight : GLsizei; srcDepth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_debug_group
- // ARB_debug_group reuses entry points from KHR_debug
-
- // GL_ARB_debug_label
- // ARB_debug_label reuses entry points from KHR_debug
-
- // GL_ARB_debug_output2
-
- // GL_ARB_ES3_compatibility
-
- // GL_ARB_explicit_uniform_location
-
- // GL_ARB_fragment_layer_viewport
-
- // GL_ARB_framebuffer_no_attachments
- TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferParameteriEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedFramebufferParameterivEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_internalformat_query2
- TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_invalidate_subdata
- TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_multi_draw_indirect
- TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_program_interface_query
- TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_robust_buffer_access_behavior
-
- // GL_ARB_shader_image_size
-
- // GL_ARB_shader_storage_buffer_object
- TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_stencil_texturing
-
- // GL_ARB_texture_buffer_range
- TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureBufferRangeEXT = procedure(texture : GLuint; target : GLenum; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_texture_query_levels
-
- // GL_ARB_texture_storage_multisample
- TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureStorage2DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureStorage3DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL 4.4
-
- TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // END GL 4.4
-
-
- // GL_ARB_texture_view
- TglTextureView = procedure(texture : GLuint; target : GLenum; origtexture : GLuint; internalformat : GLenum; minlevel : GLuint; numlevels : GLuint; minlayer : GLuint; numlayers : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_vertex_attrib_binding
- TglBindVertexBuffer = procedure(bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribIFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribLFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribBinding = procedure(attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexBindingDivisor = procedure(bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayBindVertexBufferEXT = procedure(vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribIFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribLFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribBindingEXT = procedure(vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexBindingDivisorEXT = procedure(vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_robustness_isolation
-
- //
-
- // GL_ARB_cl_event
- TglCreateSyncFromCLeventARB = function(context: p_cl_context; event: p_cl_event; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_debug_output
- TglDebugMessageControlARB = procedure(source: GLenum; type_: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageInsertARB = procedure(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageCallbackARB = procedure(callback: TglDebugProcARB; const userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDebugMessageLogARB = function(count: GLuint; bufsize: GLsizei; sources: PGLenum; types: PGLenum; ids: PGLuint; severities: PGLenum; lengths: PGLsizei; messageLog: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ARB_robustness
- TglGetGraphicsResetStatusARB = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnMapdvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnMapfvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnMapivARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnPixelMapfvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnPixelMapuivARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnPixelMapusvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnPolygonStippleARB = procedure(bufSize: GLsizei; pattern: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnColorTableARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnConvolutionFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnSeparableFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; rowBufSize: GLsizei; row: PGLvoid; columnBufSize: GLsizei; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnHistogramARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnMinmaxARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnTexImageARB = procedure(target: GLenum; level: GLint; format: GLenum; type_: GLenum; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReadnPixelsARB = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; bufSize: GLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnCompressedTexImageARB = procedure(target: GLenum; lod: GLint; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnUniformfvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnUniformivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnUniformuivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetnUniformdvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_draw_buffers
- TglDrawBuffersATI = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_element_array
- TglElementPointerATI = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementArrayATI = procedure(mode: GLenum; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawRangeElementArrayATI = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_envmap_bumpmap
- TglTexBumpParameterivATI = procedure(pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexBumpParameterfvATI = procedure(pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexBumpParameterivATI = procedure(pname: GLenum; param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexBumpParameterfvATI = procedure(pname: GLenum; param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_fragment_shader
- TglGenFragmentShadersATI = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPassTexCoordATI = procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSampleMapATI = procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAlphaFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAlphaFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglAlphaFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSetFragmentShaderConstantATI = procedure(dst: GLuint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_map_object_buffer
- TglMapObjectBufferATI = function(buffer: GLuint): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUnmapObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_pn_triangles
- TglPNTrianglesiATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPNTrianglesfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_separate_stencil
- TglStencilOpSeparateATI = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilFuncSeparateATI = procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_vertex_array_object
- TglNewObjectBufferATI = function(size: GLsizei; const _pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsObjectBufferATI = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUpdateObjectBufferATI = procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const _pointer: PGLvoid; preserve: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectBufferfvATI = procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetObjectBufferivATI = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFreeObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglArrayObjectATI = procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetArrayObjectfvATI = procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetArrayObjectivATI = procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantArrayObjectATI = procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantArrayObjectfvATI = procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantArrayObjectivATI = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_vertex_attrib_array_object
- TglVertexAttribArrayObjectATI = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribArrayObjectfvATI = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribArrayObjectivATI = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_ATI_vertex_streams
- TglVertexStream1sATI = procedure(stream: GLenum; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1iATI = procedure(stream: GLenum; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1fATI = procedure(stream: GLenum; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1dATI = procedure(stream: GLenum; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream1dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2sATI = procedure(stream: GLenum; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2iATI = procedure(stream: GLenum; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream2dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexStream4dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3bATI = procedure(stream: GLenum; nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3bvATI = procedure(stream: GLenum; const coords: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3sATI = procedure(stream: GLenum; nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3iATI = procedure(stream: GLenum; nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3fATI = procedure(stream: GLenum; nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3dATI = procedure(stream: GLenum; nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClientActiveVertexStreamATI = procedure(stream: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexBlendEnviATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexBlendEnvfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_performance_monitor
- TglGetPerfMonitorGroupsAMD = procedure(numGroups: PGLint; groupsSize: GLsizei; groups: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPerfMonitorCountersAMD = procedure(group: GLuint; numCounters: PGLint; maxActiveCouters: PGLint; counterSize: GLsizei; counters: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPerfMonitorGroupStringAMD = procedure(group: GLuint; bufSize: GLsizei; length: PGLsizei; groupString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPerfMonitorCounterStringAMD = procedure(group: GLuint; counter: GLuint; bufSize: GLsizei; length: PGLsizei; counterString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPerfMonitorCounterInfoAMD = procedure(group: GLuint; counter: GLuint; pname: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenPerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeletePerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSelectPerfMonitorCountersAMD = procedure(monitor: GLuint; enable: GLboolean; group: GLuint; numCounters: GLint; counterList: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPerfMonitorCounterDataAMD = procedure(monitor: GLuint; pname: GLenum; dataSize: GLsizei; data: PGLuint; bytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_vertex_shader_tesselator
- TglTessellationFactorAMD = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTessellationModeAMD = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_draw_buffers_blend
- TglBlendFuncIndexedAMD = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendFuncSeparateIndexedAMD = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquationIndexedAMD = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBlendEquationSeparateIndexedAMD = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_name_gen_delete
- TglGenNamesAMD = procedure(identifier: GLenum; num: GLuint; names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteNamesAMD = procedure(identifier: GLenum; num: GLuint; const names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsNameAMD = function(identifier: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_debug_output
- TglDebugMessageEnableAMD = procedure(category: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageInsertAMD = procedure(category: GLenum; severity: GLenum; id: GLuint; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDebugMessageCallbackAMD = procedure(callback: TGLDebugProcAMD; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDebugMessageLogAMD = function(count: GLuint; bufsize: GLsizei; categories: PGLenum; severities: PGLuint; ids: PGLuint; lengths: PGLsizei; message: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_blend_color
- TglBlendColorEXT = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_blend_func_separate
- TglBlendFuncSeparateEXT = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_blend_minmax
- TglBlendEquationEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_color_subtable
- TglColorSubTableEXT = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyColorSubTableEXT = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_compiled_vertex_array
- TglLockArraysEXT = procedure(first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUnlockArraysEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_convolution
- TglConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameterfEXT = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameteriEXT = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSeparableFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSeparableFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_coordinate_frame
- TglTangent3bEXT = procedure(tx: GLbyte; ty: GLbyte; tz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3dEXT = procedure(tx: GLdouble; ty: GLdouble; tz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3fEXT = procedure(tx: GLfloat; ty: GLfloat; tz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3iEXT = procedure(tx: GLint; ty: GLint; tz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3sEXT = procedure(tx: GLshort; ty: GLshort; tz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangent3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3bEXT = procedure(bx: GLbyte; by: GLbyte; bz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3dEXT = procedure(bx: GLdouble; by: GLdouble; bz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3fEXT = procedure(bx: GLfloat; by: GLfloat; bz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3iEXT = procedure(bx: GLint; by: GLint; bz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3sEXT = procedure(bx: GLshort; by: GLshort; bz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormal3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTangentPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBinormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_copy_texture
- TglCopyTexImage1DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexImage2DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_cull_vertex
- TglCullParameterdvEXT = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCullParameterfvEXT = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_draw_range_elements
- TglDrawRangeElementsEXT = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_fog_coord
- TglFogCoordfEXT = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordfvEXT = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoorddEXT = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoorddvEXT = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_framebuffer_object
- TglIsRenderbufferEXT = function(renderbuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindRenderbufferEXT = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteRenderbuffersEXT = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenRenderbuffersEXT = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRenderbufferStorageEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetRenderbufferParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsFramebufferEXT = function(framebuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindFramebufferEXT = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteFramebuffersEXT = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenFramebuffersEXT = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCheckFramebufferStatusEXT = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture1DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture2DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTexture3DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferRenderbufferEXT = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFramebufferAttachmentParameterivEXT = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenerateMipmapEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_histogram
- TglGetHistogramEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHistogramParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetHistogramParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmaxEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmaxParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMinmaxParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglHistogramEXT = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMinmaxEXT = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResetHistogramEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResetMinmaxEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_index_func
- TglIndexFuncEXT = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_index_material
- TglIndexMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_light_texture
- TglApplyTextureEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureLightEXT = procedure(pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_multi_draw_arrays
- TglMultiDrawArraysEXT = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiDrawElementsEXT = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_multisample
- TglSampleMaskEXT = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplePatternEXT = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_paletted_texture
- TglColorTableEXT = procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_pixel_transform
- TglPixelTransformParameteriEXT = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTransformParameterfEXT = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTransformParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTransformParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_point_parameters
- TglPointParameterfEXT = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterfvEXT = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_polygon_offset
- TglPolygonOffsetEXT = procedure(factor: GLfloat; bias: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_secondary_color
- TglSecondaryColor3bEXT = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3dEXT = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3fEXT = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3iEXT = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3sEXT = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ubEXT = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3ubvEXT = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3uiEXT = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3uivEXT = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3usEXT = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3usvEXT = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_stencil_two_side
- TglActiveStencilFaceEXT = procedure(face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_subtexture
- TglTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_texture3D
- TglTexImage3DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_texture_object
- TglAreTexturesResidentEXT = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindTextureEXT = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteTexturesEXT = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenTexturesEXT = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsTextureEXT = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPrioritizeTexturesEXT = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_texture_perturb_normal
- TglTextureNormalEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_vertex_array
- TglArrayElementEXT = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawArraysEXT = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlagPointerEXT = procedure(stride: GLsizei; count: GLsizei; const _pointer: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPointervEXT = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_vertex_shader
- TglBeginVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenVertexShadersEXT = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderOp1EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderOp2EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglShaderOp3EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSwizzleEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWriteMaskEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInsertComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglExtractComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenSymbolsEXT = function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSetInvariantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSetLocalConstantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantbvEXT = procedure(id: GLuint; const addr: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantsvEXT = procedure(id: GLuint; const addr: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantivEXT = procedure(id: GLuint; const addr: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantfvEXT = procedure(id: GLuint; const addr: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantdvEXT = procedure(id: GLuint; const addr: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantubvEXT = procedure(id: GLuint; const addr: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantusvEXT = procedure(id: GLuint; const addr: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantuivEXT = procedure(id: GLuint; const addr: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVariantPointerEXT = procedure(id: GLuint; _type: GLenum; stride: GLuint; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindLightParameterEXT = function(light: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindMaterialParameterEXT = function(face: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindTexGenParameterEXT = function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindTextureUnitParameterEXT = function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindParameterEXT = function(value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsVariantEnabledEXT = function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVariantPointervEXT = procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetInvariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetInvariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetInvariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetLocalConstantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetLocalConstantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetLocalConstantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_vertex_weighting
- TglVertexWeightfEXT = procedure(weight: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexWeightfvEXT = procedure(const weight: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexWeightPointerEXT = procedure(size: GLsizei; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_stencil_clear_tag
- TglStencilClearTagEXT = procedure(stencilTagBits: GLsizei; stencilClearTag: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_framebuffer_blit
- TglBlitFramebufferEXT = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_framebuffer_multisample
- TglRenderbufferStorageMultisampleEXT = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_timer_query
- TglGetQueryObjecti64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetQueryObjectui64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_gpu_program_parameters
- TglProgramEnvParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_bindable_uniform
- TglUniformBufferEXT = procedure(_program: GLuint; location: GLint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformBufferSizeEXT = function(_program: GLuint; location: GLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformOffsetEXT = function(_program: GLuint; location: GLint): GLintptr; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_draw_buffers2
- TglColorMaskIndexedEXT = procedure(buf: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBooleanIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetIntegerIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsEnabledIndexedEXT = function(target: GLenum; index: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_draw_instanced
- TglDrawArraysInstancedEXT = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawElementsInstancedEXT = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: Pointer; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_geometry_shader4
- TglProgramParameteriEXT = procedure (_program: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-// TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferTextureFaceEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_gpu_shader4
- TglVertexAttribI1iEXT = procedure(index: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2iEXT = procedure(index: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1uiEXT = procedure(index: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI1uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI2uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI3uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4bvEXT = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4svEXT = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4ubvEXT = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribI4usvEXT = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribIPointerEXT = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const _pointer: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribIivEXT = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribIuivEXT = procedure(index: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1uiEXT = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformuivEXT = procedure(_program: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindFragDataLocationEXT = procedure(_program: GLuint; colorNumber: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragDataLocationEXT = function(_program: GLuint; const name: PGLchar): GLint;
-
- // GL_EXT_texture_array
- TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_texture_buffer_object
- TglTexBufferEXT = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_texture_integer
- TglClearColorIiEXT = procedure(r: GLint; g: GLint; b: GLint; a: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearColorIuiEXT = procedure(r: GLuint; g: GLuint; b: GLuint; a: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexParameterIuivEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTexParameterIiuvEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_HP_image_transform
- TglImageTransformParameteriHP = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglImageTransformParameterfHP = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_depth_bounds_test
- TglDepthBoundsEXT = procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_blend_equation_separate
- TglBlendEquationSeparateEXT = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_transform_feedback
- TglBeginTransformFeedbackEXT = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndTransformFeedbackEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferRangeEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferOffsetEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferBaseEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformFeedbackVaryingsEXT = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTransformFeedbackVaryingEXT = procedure(program_: GLuint; index_: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_direct_state_access
- TglClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPushClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixLoadfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixLoaddEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixMultfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixMultdEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixLoadIdentityEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixRotatefEXT = procedure(mode: GLenum; angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixRotatedEXT = procedure(mode: GLenum; angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixScalefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixScaledEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixTranslatefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixTranslatedEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixFrustumEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixOrthoEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixPopEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixPushEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixLoadTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixLoadTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixMultTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMatrixMultTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameterfEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameteriEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureImageEXT = procedure(texture: GLuint; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureLevelParameterfvEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureLevelParameterivEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameterfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameteriEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexLevelParameterfvEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexLevelParameterivEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels:PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindMultiTextureEXT = procedure(texunit: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEnableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDisableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoordPointerEXT = procedure(texunit: GLenum; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexEnvfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexEnviEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGendEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGendvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGenfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGenfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGeniEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexGenivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexGendvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexGenfvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexGenivEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFloatIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDoubleIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPointerIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCompressedTextureImageEXT = procedure(texture: GLuint; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCompressedMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCompressedMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; format: GLenum; len: GLsizei; const string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameter4dEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameter4dvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameter4fEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameter4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramLocalParameterdvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramLocalParameterfvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramivEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameters4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameterI4iEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameterI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParametersI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameterI4uiEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParameterI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedProgramLocalParametersI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramLocalParameterIivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedProgramLocalParameterIuivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1iEXT = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedBufferDataEXT = procedure(buffer: GLuint; size: GLsizei; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapNamedBufferEXT = function(buffer: GLuint; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUnmapNamedBufferEXT = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapNamedBufferRangeEXT = function(buffer: GLuint; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFlushMappedNamedBufferRangeEXT = procedure(buffer: GLuint; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedCopyBufferSubDataEXT = procedure(readBuffer: GLuint; writeBuffer: GLuint; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedBufferParameterivEXT = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedBufferPointervEXT = procedure(buffer: GLuint; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureBufferEXT = procedure(texture: GLuint; target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexBufferEXT = procedure(texunit: GLenum; target: GLenum; interformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedRenderbufferStorageEXT = procedure(renderbuffer: GLuint; interformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedRenderbufferParameterivEXT = procedure(renderbuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCheckNamedFramebufferStatusEXT = function(framebuffer: GLuint; target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTexture1DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTexture2DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTexture3DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferRenderbufferEXT = procedure(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedFramebufferAttachmentParameterivEXT = procedure(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenerateTextureMipmapEXT = procedure(texture: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenerateMultiTexMipmapEXT = procedure(texunit: GLenum; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferDrawBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferDrawBuffersEXT = procedure(framebuffer: GLuint; n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFramebufferReadBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFramebufferParameterivEXT = procedure(framebuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedRenderbufferStorageMultisampleEXT = procedure(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedRenderbufferStorageMultisampleCoverageEXT = procedure(renderbuffer: GLuint; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTextureEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTextureLayerEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNamedFramebufferTextureFaceEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTextureRenderbufferEXT = procedure(texture: GLuint; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexRenderbufferEXT = procedure(texunit: GLenum; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix2x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix3x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformMatrix4x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_separate_shader_objects
- TglUseShaderProgramEXT = procedure(_type: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglActiveProgramEXT = procedure(_program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCreateShaderProgramEXT = function(_type: GLenum; const _string: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_shader_image_load_store
- TglBindImageTextureEXT = procedure(index: GLuint; texture: GLuint; level: GLint; layered: GLboolean; layer: GLint; access: GLenum; format: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMemoryBarrierEXT = procedure(barriers: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_EXT_vertex_attrib_64bit
- TglVertexAttribL1dEXT = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL1dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribLPointerEXT = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribLdvEXT = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayVertexAttribLOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_IBM_multimode_draw_arrays
- TglMultiModeDrawArraysIBM = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiModeDrawElementsIBM = procedure(const mode: PGLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_IBM_vertex_array_lists
- TglColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlagPointerListIBM = procedure(stride: GLint; const _pointer: PGLboolean; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_INGR_blend_func_separate
- TglBlendFuncSeparateINGR = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_INTEL_parallel_arrays
- TglVertexPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalPointervINTEL = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_MESA_resize_buffers
- TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_MESA_window_pos
- TglWindowPos2dMESA = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2fMESA = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2iMESA = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2sMESA = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3iMESA = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3sMESA = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4iMESA = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4sMESA = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_evaluators
- TglMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapParameterivNV = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMapParameterfvNV = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapParameterivNV = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapParameterfvNV = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapAttribParameterivNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetMapAttribParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEvalMapsNV = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_fence
- TglDeleteFencesNV = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenFencesNV = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTestFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFenceivNV = procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinishFenceNV = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSetFenceNV = procedure(fence: GLuint; condition: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_fragment_program
- TglProgramNamedParameter4fNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramNamedParameter4dNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramNamedParameter4fvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramNamedParameter4dvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramNamedParameterfvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramNamedParameterdvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_half_float
- TglVertex2hNV = procedure(x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3hNV = procedure(nx: GLhalfNV; ny: GLhalfNV; nz: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV; alpha: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1hNV = procedure(s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2hNV = procedure(s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1hNV = procedure(target: GLenum; s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord1hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord2hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord3hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMultiTexCoord4hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordhNV = procedure(fog: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexWeighthNV = procedure(weight: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1hNV = procedure(index: GLuint; x: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs1hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs2hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs3hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs4hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_occlusion_query
- TglGenOcclusionQueriesNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteOcclusionQueriesNV = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsOcclusionQueryNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBeginOcclusionQueryNV = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetOcclusionQueryivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetOcclusionQueryuivNV = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_pixel_data_range
- TglPixelDataRangeNV = procedure(target: GLenum; length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFlushPixelDataRangeNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_point_sprite
- TglPointParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_primitive_restart
- TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPrimitiveRestartIndexNV = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_register_combiners
- TglCombinerParameterfvNV = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCombinerParameterfNV = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCombinerParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCombinerParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCombinerInputNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCombinerOutputNV = procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinalCombinerInputNV = procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCombinerInputParameterfvNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCombinerInputParameterivNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCombinerOutputParameterfvNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCombinerOutputParameterivNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFinalCombinerInputParameterfvNV = procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFinalCombinerInputParameterivNV = procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_register_combiners2
- TglCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vertex_array_range
- TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexArrayRangeNV = procedure(length: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vertex_program
- TglAreProgramsResidentNV = function(n: GLsizei; const programs: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindProgramNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglExecuteProgramNV = procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenProgramsNV = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramParameterdvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramStringNV = procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTrackMatrixivNV = procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribdvNV = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribfvNV = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribivNV = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribPointervNV = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsProgramNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadProgramNV = procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameter4dNV = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameter4dvNV = procedure(target: GLenum; index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameter4fNV = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameter4fvNV = procedure(target: GLenum; index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameters4dvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramParameters4fvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglRequestResidentProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTrackMatrixNV = procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribPointerNV = procedure(index: GLuint; fsize: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1dNV = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1fNV = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1sNV = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib1svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2sNV = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib2svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib3svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4ubNV = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttrib4ubvNV = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs1dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs1fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs1svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs2dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs2fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs2svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs3dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs3fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs3svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs4dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs4fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs4svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribs4ubvNV = procedure(index: GLuint; count: GLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_depth_buffer_float
- TglDepthRangedNV = procedure(n: GLdouble; f: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglClearDepthdNV = procedure(d: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDepthBoundsdNV = procedure(zmin: GLdouble; zmax: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_framebuffer_multisample_coverage
- TglRenderbufferStorageMultsampleCoverageNV = procedure(target: GLenum; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_geometry_program4
- TglProgramVertexLimitNV = procedure(target: GLenum; limit: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_gpu_program4
- TglProgramLocalParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramLocalParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramEnvParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramLocalParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramLocalParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramEnvParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramEnvParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_parameter_buffer_object
- TglProgramBufferParametersfvNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramBufferParametersIivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramBufferParametersIuivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_transform_feedback
- TglBeginTransformFeedbackNV = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformFeedbackAttribsNV = procedure(count: GLsizei; const attribs: GLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformFeedbackVaryingsNV = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglActiveVaryingNV = procedure(program_: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVaryingLocationNV = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetActiveVaryingNV = procedure(program_: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTransformFeedbackVaryingNV = procedure(program_: GLuint; index: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformFeedbackStreamAttribsNV = procedure(count: GLsizei; const attribs: PGLint; nbuffers: GLsizei; const bufstreams: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_conditional_render
- TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_present_video
- TglPresentFrameKeyedNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDuratioId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; key0: GLuint; target1: GLenum; fill1: GLuint; key1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPresentFrameDualFillNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDurationId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; target1: GLenum; fill1: GLuint; target2: GLenum; fill2: GLuint; target3: GLenum; fill3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-// TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_explicit_multisample
- TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_transform_feedback2
- TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_video_capture
- TglBeginVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindVideoCaptureStreamBufferNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; offset: GLintptrARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglBindVideoCaptureStreamTextureNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEndVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoCaptureivNV = procedure(video_capture_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoCaptureStreamivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoCaptureStreamfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVideoCaptureStreamdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVideoCaptureNV = function(video_capture_slot: GLuint; sequence_num: PGLuint; capture_time: PGLuint64EXT): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVideoCaptureStreamParameterivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVideoCaptureStreamParameterfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVideoCaptureStreamParameterdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_copy_image
- TglCopyImageSubDataNV = procedure(srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_shader_buffer_load
- TglMakeBufferResidentNV = procedure(target: GLenum; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeBufferNonResidentNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsBufferResidentNV = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeNamedBufferResidentNV = procedure(buffer: GLuint; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeNamedBufferNonResidentNV = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsNamedBufferResidentNV = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetBufferParameterui64vNV = procedure(target: GLenum; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetNamedBufferParameterui64vNV = procedure(buffer: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetIntegerui64vNV = procedure(value: GLenum; result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformui64NV = procedure(location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformui64vNV = procedure(_program: GLuint; location: GLint; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformui64NV = procedure(_program: GLuint; location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformui64vNV = procedure(_program: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vertex_buffer_unified_memory
- TglBufferAddressRangeNV = procedure(pname: GLenum; index: GLuint; adress: GLuint64EXT; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormalFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIndexFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoordFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglEdgeFlagFormatNV = procedure(stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSecondaryColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFogCoordFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribIFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetIntegerui64i_vNV = procedure(value: GLenum; index: GLuint; Result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_gpu_program5
- TglProgramSubroutineParametersuivNV = procedure(target: GLenum; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetProgramSubroutineParameteruivNV = procedure(target: GLenum; index: GLuint; param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_gpu_shader5
- TglUniform1i64NV = procedure(location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1ui64NV = procedure(location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform1ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform2ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform3ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniform4ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetUniformi64vNV = procedure(program_: GLuint; location: GLint; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform1ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform2ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform3ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniform4ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vertex_attrib_integer_64bit
- TglVertexAttribL1i64NV = procedure(index: GLuint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL1i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL1ui64NV = procedure(index: GLuint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL1ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL2ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL3ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribL4ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribLi64vNV = procedure(index: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetVertexAttribLui64vNV = procedure(index: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVertexAttribLFormatNV = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_vdpau_interop
- TglVDPAUInitNV = procedure(const vdpDevice: PGLvoid; const getProcAddress: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUFiniNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAURegisterVideoSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAURegisterOutputSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUIsSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUUnregisterSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUGetSurfaceivNV = procedure(surface: GLvdpauSurfaceNV; pname: GLenum; bufSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUSurfaceAccessNV = procedure(surface: GLvdpauSurfaceNV; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUMapSurfacesNV = procedure(numSurfaces: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglVDPAUUnmapSurfacesNV = procedure(numSurface: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_texture_barrier
- TglTextureBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // (4.3)
- // GL_NV_path_rendering
- TglGenPathsNV = function(range : GLsizei) : GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeletePathsNV = procedure(path : GLUInt; range : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsPathNV = function(path : GLUInt) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathCommandsNV = procedure(path : GLUInt; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLsizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathCoordsNV = procedure(path : GLUInt; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathSubCommandsNV = procedure(path : GLUInt; commandStart : GLsizei; commandsToDelete : GLsizei; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathSubCoordsNV = procedure(path : GLUInt; coordStart : GLsizei; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathStringNV = procedure(path : GLUInt; format : GLenum; length : GLsizei; const pathString : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathGlyphsNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; numGlyphs : GLsizei; type_ : GLenum; const charcodes : PGLvoid; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathGlyphRangeNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; firstGlyph : GLuint; numGlyphs : GLsizei; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglWeightPathsNV = procedure(resultPath : GLUInt; numPaths : GLSizei; const paths : PGLuint; const weights : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyPathNV = procedure(resultPath : GLUInt; srcPath : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInterpolatePathsNV = procedure(resultPath : GLUInt; pathA : GLUInt; pathB : GLUInt; weight : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTransformPathNV = procedure(resultPath : GLUInt; srcPath : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathParameteriNV = procedure(path : GLUInt; pname : GLEnum; value : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathParameterfNV = procedure(path : GLUInt; pname : GLEnum; value : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathDashArrayNV = procedure(path : GLUInt; dashCount : GLsizei; const dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathStencilFuncNV = procedure(func : GLenum; ref : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathStencilDepthOffsetNV = procedure(factor : GLfloat; units : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilFillPathNV = procedure(path : GLUInt; fillMode : GLenum; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilStrokePathNV = procedure(path : GLUInt; reference : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; fillMode : GLenum; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStencilStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; reference : GLint; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathCoverDepthFuncNV = procedure(func : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathColorGenNV = procedure(color : GLenum; genMode : GLenum; colorFormat : GLenum; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathTexGenNV = procedure(texCoordSet : GLenum; genMode : GLenum; components : GLint; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPathFogGenNV = procedure(genMode : GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCoverFillPathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCoverStrokePathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCoverFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCoverStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathCommandsNV = procedure(path : GLUInt; commands : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathCoordsNV = procedure(path : GLUInt; coords : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathDashArrayNV = procedure(path : GLUInt; dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathMetricsNV = procedure(metricQueryMask : GLbitfield; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathMetricRangeNV = procedure(metricQueryMask : GLbitfield; firstPathName : GLuint; numPaths : GLSizei; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathSpacingNV = procedure(pathListMode : GLenum; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; advanceScale : GLfloat; kerningScale : GLfloat; transformType : GLenum; returnedSpacing : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathColorGenivNV = procedure(color : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathColorGenfvNV = procedure(color : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathTexGenivNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathTexGenfvNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsPointInFillPathNV = function(path : GLUInt; mask : GLuint; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsPointInStrokePathNV = function (path : GLUInt; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPathLengthNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei) : GLfloat; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointAlongPathNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei; distance : GLfloat; x : PGLfloat; y : PGLfloat; tangentX : PGLfloat; tangentY : PGLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_pinned_memory
-
- // GL_AMD_stencil_operation_extended
- TglStencilOpValueAMD = procedure(face : GLEnum; value : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_AMD_vertex_shader_viewport_index
-
- // GL_AMD_vertex_shader_layer
-
- // GL_NV_bindless_texture
- TglGetTextureHandleNV = function(texture : GLuint ) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetTextureSamplerHandleNV = function(texture : GLuint; sampler : GLuint) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeTextureHandleResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeTextureHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetImageHandleNV = function(texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeImageHandleResidentNV = procedure(handle : GLUint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglMakeImageHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformHandleui64NV = procedure(location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglUniformHandleui64vNV = procedure(location : GLint; cowunt : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformHandleui64NV = procedure(program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglProgramUniformHandleui64vNV = procedure(program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsTextureHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsImageHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_NV_shader_atomic_float
-
- // GL_AMD_query_buffer_object
-
- //
-
- // GL_PGI_misc_hints
- TglHintPGI = procedure(target: GLenum; mode: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_detail_texture
- TglDetailTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetDetailTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_fog_function
- TglFogFuncSGIS = procedure(n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFogFuncSGIS = procedure(points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_multisample
- TglSampleMaskSGIS = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSamplePatternSGIS = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_pixel_texture
- TglPixelTexGenParameteriSGIS = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTexGenParameterivSGIS = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTexGenParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPixelTexGenParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPixelTexGenParameterivSGIS = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetPixelTexGenParameterfvSGIS = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_point_parameters
- TglPointParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPointParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_sharpen_texture
- TglSharpenTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetSharpenTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_texture4D
- TglTexImage4DSGIS = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexSubImage4DSGIS = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; woffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_texture_color_mask
- TglTextureColorMaskSGIS = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIS_texture_filter4
- TglGetTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; n: GLsizei; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_async
- TglAsyncMarkerSGIX = procedure(marker: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFinishAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPollAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGenAsyncMarkersSGIX = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeleteAsyncMarkersSGIX = procedure(marker: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglIsAsyncMarkerSGIX = function(marker: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_flush_raster
- TglFlushRasterSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_fragment_lighting
- TglFragmentColorMaterialSGIX = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightfSGIX = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightiSGIX = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightModelfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightModelfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightModeliSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentLightModelivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentMaterialfSGIX = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentMaterialiSGIX = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLightEnviSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_framezoom
- TglFrameZoomSGIX = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_igloo_interface
- TglIglooInterfaceSGIX = procedure(pname: GLenum; const params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_instruments
- TglGetInstrumentsSGIX = function(): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglInstrumentsBufferSGIX = procedure(size: GLsizei; buffer: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglPollInstrumentsSGIX = function(marker_p: PGLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReadInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStartInstrumentsSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglStopInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_list_priority
- TglGetListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetListParameterivSGIX = procedure(list: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglListParameterfSGIX = procedure(list: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglListParameteriSGIX = procedure(list: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglListParameterivSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_pixel_texture
- TglPixelTexGenSGIX = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_polynomial_ffd
- TglDeformationMap3dSGIX = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; w1: GLdouble; w2: GLdouble; wstride: GLint; worder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeformationMap3fSGIX = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; w1: GLfloat; w2: GLfloat; wstride: GLint; worder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglDeformSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglLoadIdentityDeformationMapSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_reference_plane
- TglReferencePlaneSGIX = procedure(const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_sprite
- TglSpriteParameterfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSpriteParameterfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSpriteParameteriSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglSpriteParameterivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGIX_tag_sample_buffer
- TglTagSampleBufferSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SGI_color_table
- TglColorTableSGI = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglCopyColorTableSGI = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableSGI = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGetColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SUNX_constant_data
- TglFinishTextureSUNX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SUN_global_alpha
- TglGlobalAlphaFactorbSUN = procedure(factor: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactorsSUN = procedure(factor: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactoriSUN = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactorfSUN = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactordSUN = procedure(factor: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactorubSUN = procedure(factor: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactorusSUN = procedure(factor: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglGlobalAlphaFactoruiSUN = procedure(factor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SUN_mesh_array
- TglDrawMeshArraysSUN = procedure(mode: GLenum; first: GLint; count: GLsizei; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SUN_triangle_list
- TglReplacementCodeuiSUN = procedure(code: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeusSUN = procedure(code: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeubSUN = procedure(code: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuivSUN = procedure(const code: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeusvSUN = procedure(const code: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeubvSUN = procedure(const code: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodePointerSUN = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // GL_SUN_vertex
- TglColor4ubVertex2fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ubVertex2fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ubVertex3fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4ubVertex3fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor3fVertex3fvSUN = procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3fVertex3fSUN = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglNormal3fVertex3fvSUN = procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4fNormal3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglColor4fNormal3fVertex3fvSUN = procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fVertex3fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4fVertex4fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor4ubVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor4ubVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor4fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4fColor4fNormal3fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglTexCoord4fColor4fNormal3fVertex4fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiVertex3fSUN = procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiVertex3fvSUN = procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor4ubVertex3fSUN = procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor4ubVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiNormal3fVertex3fSUN = procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
- // window support functions
-{$IFDEF DGL_WIN}
- TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall;
- TwglCopyContext = function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;
- TwglCreateContext = function(DC: HDC): HGLRC; stdcall;
- TwglCreateLayerContext = function(p1: HDC; p2: Integer): HGLRC; stdcall;
- TwglDeleteContext = function(p1: HGLRC): BOOL; stdcall;
- TwglDescribeLayerPlane = function(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall;
- TwglGetCurrentContext = function: HGLRC; stdcall;
- TwglGetCurrentDC = function: HDC; stdcall;
- TwglGetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
- TwglMakeCurrent = function(DC: HDC; p2: HGLRC): BOOL; stdcall;
- TwglRealizeLayerPalette = function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;
- TwglSetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
- TwglShareLists = function(p1, p2: HGLRC): BOOL; stdcall;
- TwglSwapLayerBuffers = function(p1: HDC; p2: Cardinal): BOOL; stdcall;
- TwglSwapMultipleBuffers = function(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall;
- TwglUseFontBitmapsA = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
- TwglUseFontBitmapsW = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
- TwglUseFontBitmaps = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
-
- TwglUseFontOutlinesA = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
- TwglUseFontOutlinesW = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
- TwglUseFontOutlines = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
-
-
- // WGL_ARB_buffer_region
- TwglCreateBufferRegionARB = function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; stdcall;
- TwglDeleteBufferRegionARB = procedure(hRegion: THandle); stdcall;
- TwglSaveBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): Boolean; stdcall;
- TwglRestoreBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): Boolean; stdcall;
-
- // WGL_ARB_extensions_string
- TwglGetExtensionsStringARB = function(hdc: HDC): PAnsiChar; stdcall;
-
- // WGL_ARB_make_current_read
- TwglMakeContextCurrentARB = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
- TwglGetCurrentReadDCARB = function(): HDC; stdcall;
-
- // WGL_ARB_pbuffer
- TwglCreatePbufferARB = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFERARB; stdcall;
- TwglGetPbufferDCARB = function(hPbuffer: HPBUFFERARB): HDC; stdcall;
- TwglReleasePbufferDCARB = function(hPbuffer: HPBUFFERARB; hDC: HDC): GLint; stdcall;
- TwglDestroyPbufferARB = function(hPbuffer: HPBUFFERARB): Boolean; stdcall;
- TwglQueryPbufferARB = function(hPbuffer: HPBUFFERARB; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
-
- // WGL_ARB_pixel_format
- TwglGetPixelFormatAttribivARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
- TwglGetPixelFormatAttribfvARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
- TwglChoosePixelFormatARB = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; stdcall;
-
- // WGL_ARB_color_buffer_float
- TwglClampColorARB = procedure(target: GLenum; clamp: GLenum); stdcall;
-
- // WGL_ARB_render_texture
- TwglBindTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall;
- TwglReleaseTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall;
- TwglSetPbufferAttribARB = function(hPbuffer: HPBUFFERARB; const piAttribList: PGLint): Boolean; stdcall;
-
- // WGL_ARB_create_context
- TwglCreateContextAttribsARB = function(hDC: HDC; hShareContext: HGLRC; const attribList: PGLint): HGLRC; stdcall;
-
- // WGL_AMD_gpu_association
- TwglGetGPUIDsAMD = function(maxCount: Cardinal; ids: PCardinal): Cardinal; stdcall;
- TwglGetGPUInfoAMD = function(id: Cardinal; property_: Integer; dataType: GLenum; size: Cardinal; data: Pointer): Integer; stdcall;
- TwglGetContextGPUIDAMD = function(hglrc: HGLRC): Cardinal; stdcall;
- TwglCreateAssociatedContextAMD = function(id: Cardinal): HGLRC; stdcall;
- TwglCreateAssociatedContextAttribsAMD = function(id: Cardinal; hShareContext: HGLRC; const attribList: PInteger): HGLRC; stdcall;
- TwglDeleteAssociatedContextAMD = function(hglrc: HGLRC): Boolean; stdcall;
- TwglMakeAssociatedContextCurrentAMD = function(hglrc: HGLRC): Boolean; stdcall;
- TwglGetCurrentAssociatedContextAMD = function(): HGLRC; stdcall;
- TwglBlitContextFramebufferAMD = procedure(dstCtx: HGLRC; srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); stdcall;
-
- // WGL_EXT_display_color_table
- TwglCreateDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall;
- TwglLoadDisplayColorTableEXT = function(const table: PGLushort; length: GLuint): GLboolean; stdcall;
- TwglBindDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall;
- TwglDestroyDisplayColorTableEXT = procedure(id: GLushort); stdcall;
-
- // WGL_EXT_extensions_string
- TwglGetExtensionsStringEXT = function(): PAnsiChar; stdcall;
-
- // WGL_EXT_make_current_read
- TwglMakeContextCurrentEXT = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
- TwglGetCurrentReadDCEXT = function(): HDC; stdcall;
-
- // WGL_EXT_pbuffer
- TwglCreatePbufferEXT = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFEREXT; stdcall;
- TwglGetPbufferDCEXT = function(hPbuffer: HPBUFFEREXT): HDC; stdcall;
- TwglReleasePbufferDCEXT = function(hPbuffer: HPBUFFEREXT; hDC: HDC): GLint; stdcall;
- TwglDestroyPbufferEXT = function(hPbuffer: HPBUFFEREXT): Boolean; stdcall;
- TwglQueryPbufferEXT = function(hPbuffer: HPBUFFEREXT; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
-
- // WGL_EXT_pixel_format
- TwglGetPixelFormatAttribivEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
- TwglGetPixelFormatAttribfvEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
- TwglChoosePixelFormatEXT = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): Boolean; stdcall;
-
- // WGL_EXT_swap_control
- TwglSwapIntervalEXT = function(interval: GLint): Boolean; stdcall;
- TwglGetSwapIntervalEXT = function(): GLint; stdcall;
-
- // WGL_I3D_digital_video_control
- TwglGetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
- TwglSetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall;
-
- // WGL_I3D_gamma
- TwglGetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
- TwglSetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall;
- TwglGetGammaTableI3D = function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): Boolean; stdcall;
- TwglSetGammaTableI3D = function(hDC: HDC; iEntries: GLint; const puRed: PGLushort; const puGreen: PGLushort; const puBlue: PGLushort): Boolean; stdcall;
-
- // WGL_I3D_genlock
- TwglEnableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
- TwglDisableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
- TwglIsEnabledGenlockI3D = function(hDC: HDC; pFlag: Boolean): Boolean; stdcall;
- TwglGenlockSourceI3D = function(hDC: HDC; uSource: GLuint): Boolean; stdcall;
- TwglGetGenlockSourceI3D = function(hDC: HDC; uSource: PGLuint): Boolean; stdcall;
- TwglGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: GLuint): Boolean; stdcall;
- TwglGetGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: PGLuint): Boolean; stdcall;
- TwglGenlockSampleRateI3D = function(hDC: HDC; uRate: GLuint): Boolean; stdcall;
- TwglGetGenlockSampleRateI3D = function(hDC: HDC; uRate: PGLuint): Boolean; stdcall;
- TwglGenlockSourceDelayI3D = function(hDC: HDC; uDelay: GLuint): Boolean; stdcall;
- TwglGetGenlockSourceDelayI3D = function(hDC: HDC; uDelay: PGLuint): Boolean; stdcall;
- TwglQueryGenlockMaxSourceDelayI3D = function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): Boolean; stdcall;
-
- // WGL_I3D_image_buffer
- TwglCreateImageBufferI3D = function(hDC: HDC; dwSize: GLuint; uFlags: GLuint): GLvoid; stdcall;
- TwglDestroyImageBufferI3D = function(hDC: HDC; pAddress: GLvoid): Boolean; stdcall;
- TwglAssociateImageBufferEventsI3D = function(hDC: HDC; const pEvent: THandle; const pAddress: PGLvoid; const pSize: PGLuint; count: GLuint): Boolean; stdcall;
- TwglReleaseImageBufferEventsI3D = function(hDC: HDC; const pAddress: PGLvoid; count: GLuint): Boolean; stdcall;
-
- // WGL_I3D_swap_frame_lock
- TwglEnableFrameLockI3D = function(): Boolean; stdcall;
- TwglDisableFrameLockI3D = function(): Boolean; stdcall;
- TwglIsEnabledFrameLockI3D = function(pFlag: Boolean): Boolean; stdcall;
- TwglQueryFrameLockMasterI3D = function(pFlag: Boolean): Boolean; stdcall;
-
- // WGL_I3D_swap_frame_usage
- TwglGetFrameUsageI3D = function(pUsage: PGLfloat): Boolean; stdcall;
- TwglBeginFrameTrackingI3D = function(): Boolean; stdcall;
- TwglEndFrameTrackingI3D = function(): Boolean; stdcall;
- TwglQueryFrameTrackingI3D = function(pFrameCount: PGLuint; pMissedFrames: PGLuint; pLastMissedUsage: PGLfloat): Boolean; stdcall;
-
- // WGL_NV_vertex_array_range
- TwglAllocateMemoryNV = procedure(size: GLsizei; readfreq: GLfloat; writefreq: GLfloat; priority: GLfloat); stdcall;
- TwglFreeMemoryNV = procedure(_pointer: Pointer); stdcall;
-
- // WGL_NV_present_video
- TwglEnumerateVideoDevicesNV = function(hdc: HDC; phDeviceList: PHVIDEOOUTPUTDEVICENV): Integer; stdcall;
- TwglBindVideoDeviceNV = function(hd: HDC; uVideoSlot: Cardinal; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: PInteger): Boolean; stdcall;
- TwglQueryCurrentContextNV = function(iAttribute: Integer; piValue: PInteger): Boolean; stdcall;
-
- // WGL_NV_video_output
- TwglGetVideoDeviceNV = function(hDC: HDC; numDevices: Integer; hVideoDevice: PHPVIDEODEV): Boolean; stdcall;
- TwglReleaseVideoDeviceNV = function(hVideoDevice: HPVIDEODEV): Boolean; stdcall;
- TwglBindVideoImageNV = function(hVideoDevice: HPVIDEODEV; hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
- TwglReleaseVideoImageNV = function(hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
- TwglSendPbufferToVideoNV = function(hPbuffer: HPBUFFERARB; iBufferType: Integer; pulCounterPbuffer: PCardinal; bBlock: Boolean): Boolean; stdcall;
- TwglGetVideoInfoNV = function(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: PCardinal; pulCounterOutputVideo: PCardinal): Boolean; stdcall;
-
- // WGL_NV_swap_group
- TwglJoinSwapGroupNV = function(hDC: HDC; group: GLuint): Boolean; stdcall;
- TwglBindSwapBarrierNV = function(group: GLuint; barrier: GLuint): Boolean; stdcall;
- TwglQuerySwapGroupNV = function(hDC: HDC; group: PGLuint; barrier: PGLuint): Boolean; stdcall;
- TwglQueryMaxSwapGroupsNV = function(hDC: HDC; mxGroups: PGLuint; maxBarriers: PGLuint): Boolean; stdcall;
- TwglQueryFrameCountNV = function(hDC: HDC; count: PGLuint): Boolean; stdcall;
- TwglResetFrameCountNV = function(hDC: HDC): Boolean; stdcall;
-
- // WGL_NV_gpu_affinity
- TwglEnumGpusNV = function(iGpuIndex: Cardinal; phGpu: PHGPUNV): Boolean; stdcall;
- TwglEnumGpuDevicesNV = function(hGpu: HGPUNV; iDeviceIndex: Cardinal; lpGpuDevice: PGPU_DEVICE): Boolean; stdcall;
- TwglCreateAffinityDCNV = function(const phGpuList: PHGPUNV): HDC; stdcall;
- TwglEnumGpusFromAffinityDCNV = function(hAffinityDC: HDC; iGpuIndex: Cardinal; hGpu: PHGPUNV): Boolean; stdcall;
- TwglDeleteDCNV = function(hDC: HDC): Boolean; stdcall;
-
- // WGL_NV_video_capture
- TwglBindVideoCaptureDeviceNV = function(uVideoSlot: Cardinal; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
- TwglEnumerateVideoCaptureDevicesNV = function(hDc: HDC; phDeviceList: PHVIDEOINPUTDEVICENV): Cardinal; stdcall;
- TwglLockVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
- TwglQueryVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Integer; piValue: PInteger): Boolean; stdcall;
- TwglReleaseVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
-
- // WGL_NV_copy_image
- TwglCopyImageSubDataNV = function(hSrcRc: HGLRC; srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; hDstRC: HGLRC; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei): Boolean; stdcall;
-
- // WGL_NV_DX_interop
- TwglDXSetResourceShareHandleNV = function(dxObject : PGLVoid; hareHandle : Cardinal) : Boolean; stdcall;
- TwglDXOpenDeviceNV = function(dxDevice : PGLVoid) : Cardinal; stdcall;
- TwglDXCloseDeviceNV = function(hDevice : Cardinal) : Boolean; stdcall;
- TwglDXRegisterObjectNV = function(hDevice : Cardinal; dxObject : PGLVoid; name : GLUInt; _type : TGLEnum; access : TGLenum) : Cardinal; stdcall;
- TwglDXUnregisterObjectNV = function(hDevice : Cardinal; hObject : Cardinal) : Boolean; stdcall;
- TwglDXObjectAccessNV = function(hObject : Cardinal; access : GLenum) : Boolean; stdcall;
- TwglDXLockObjectsNV = function(hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall;
- TwglDXUnlockObjectsNV = function (hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall;
-
- // WGL_OML_sync_control
- TwglGetSyncValuesOML = function(hdc: HDC; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
- TwglGetMscRateOML = function(hdc: HDC; numerator: PGLint; denominator: PGLint): Boolean; stdcall;
- TwglSwapBuffersMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall;
- TwglSwapLayerBuffersMscOML = function(hdc: HDC; fuPlanes: GLint; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall;
- TwglWaitForMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
- TwglWaitForSbcOML = function(hdc: HDC; target_sbc: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
-
- // WGL_3DL_stereo_control
- TwglSetStereoEmitterState3DL = function(hDC: HDC; uState: UINT): Boolean; stdcall;
-
- // WIN_draw_range_elements
- TglDrawRangeElementsWIN = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); stdcall;
-
- // WIN_swap_hint
- TglAddSwapHintRectWIN = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall;
-{$ENDIF}
-
-{$IFDEF DGL_LINUX}
- TglXChooseVisual = function(dpy: PDisplay; screen: GLint; attribList: PGLint): PXVisualInfo; cdecl;
- TglXCopyContext = procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: GLuint); cdecl;
- TglXCreateContext = function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: GLboolean): GLXContext; cdecl;
- TglXCreateGLXPixmap = function(dpy: PDisplay; vis: PXVisualInfo; pixmap: Pixmap): GLXPixmap cdecl;
- TglXDestroyContext = procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
- TglXDestroyGLXPixmap = procedure(dpy : PDisplay; pix: GLXPixmap); cdecl;
- TglXGetConfig = function(dpy : PDisplay; vis: PXVisualInfo; attrib: GLint; value: PGLint): GLint; cdecl;
- TglXGetCurrentContext = function: GLXContext cdecl;
- TglXGetCurrentDrawable = function: GLXDrawable cdecl;
- TglXIsDirect = function(dpy: PDisplay; ctx: GLXContext): glboolean; cdecl;
- TglXMakeCurrent = function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): GLboolean cdecl;
- TglXQueryExtension = function(dpy: PDisplay; errorBase: PGLint; eventBase: PGLint): GLboolean; cdecl;
- TglXQueryVersion = function(dpy: PDisplay; major: PGLint; minor: PGLint): GLboolean cdecl;
- TglXSwapBuffers = procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
- TglXUseXFont = procedure(font: Font; first: GLint; count: GLint; listBase: GLint); cdecl;
- TglXWaitGL = procedure; cdecl;
- TglXWaitX = procedure; cdecl;
-
- TglXGetClientString = function(dpy: PDisplay; name: GLint): PGLchar; cdecl;
- TglXQueryServerString = function(dpy: PDisplay; screen: GLint; name: GLint): PGLchar; cdecl;
- TglXQueryExtensionsString = function(dpy: PDisplay; screen: GLint): PGLchar; cdecl;
-
- // GLX_VERSION_1_3
- TglXGetFBConfigs = function(dpy: PDisplay; screen: GLint; nelements: PGLint): GLXFBConfig; cdecl;
- TglXChooseFBConfig = function(dpy: PDisplay; screen: GLint; attrib_list: PGLint; nelements: PGLint): GLXFBConfig; cdecl;
- TglXGetFBConfigAttrib = function(dpy: PDisplay; config: GLXFBConfig; attribute: GLint; value: PGLint): glint; cdecl;
- TglXGetVisualFromFBConfig = function(dpy: PDisplay; config: GLXFBConfig) : PXVisualInfo; cdecl;
- TglXCreateWindow = function(dpy: PDisplay; config: GLXFBConfig; win: Window; attrib_list: PGLint): GLXWindow; cdecl;
- TglXDestroyWindow = procedure(dpy: PDisplay; win: GLXWindow); cdecl;
- TglXCreatePixmap = function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attrib_list: PGLint): GLXPixmap; cdecl;
-
- TglXDestroyPixmap = procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
- TglXCreatePbuffer = function(dpy: PDisplay; config: GLXFBConfig; attrib_list: PGLint): GLXPbuffer; cdecl;
- TglXDestroyPbuffer = procedure(dpy: PDisplay; pbuf: GLXPbuffer); cdecl;
- TglXQueryDrawable = procedure(dpy: PDisplay; draw: GLXDrawable; attribute: GLint; value: PGLuint); cdecl;
- TglXCreateNewContext = function(dpy: PDisplay; config: GLXFBConfig; render_type: GLint; share_list: GLXContext; direct: GLboolean): GLXContext cdecl;
- TglXMakeContextCurrent = function(display: PDisplay; draw: GLXDrawable; read_: GLXDrawable; ctx: GLXContext): GLboolean; cdecl;
- TglXGetCurrentReadDrawable = function: GLXDrawable; cdecl;
- TglXGetCurreentDisplay = function: PDisplay;
-
- TglXQueryContext = function(dpy: PDisplay; ctx: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
- TglXSelectEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: GLuint); cdecl;
- TglXGetSelectedEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: PGLuint); cdecl;
-
- // GLX_VERSION_1_4
- TglXGetProcAddress = function(const name: PAnsiChar): pointer; cdecl;
-
- // GLX_ARB_get_proc_address
- TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
-
- // GLX_ARB_create_context
- TglXCreateContextAttribsARB = function(dpy: PDisplay; config: GLXFBConfig; share_context: GLXContext; direct: GLboolean; const attrib_list: PGLint): GLXContext; cdecl;
-
- // GLX_EXT_import_context
- TglXGetCurrentDisplayEXT = function: PDisplay; cdecl;
- TglXQueryContextInfoEXT = function(dpy: PDisplay; context: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
- TglXGetContextIDEXT = function(const context: GLXContext): GLXContextID; cdecl;
- TglXImportContextEXT = function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl;
- TglXFreeContextEXT = procedure(dpy: PDisplay; context: GLXContext); cdecl;
-
- // GLX_EXT_texture_from_pixmap
- TglXBindTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint; const attrib_list: PGLint); cdecl;
- TglXReleaseTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint); cdecl;
-
- // GLX_EXT_swap_control
- TglXSwapIntervalEXT = procedure (dpy: PDisplay; drawable: GLXDrawable; interval: GLint); cdecl;
-{$ENDIF}
-
- // GL utility functions and procedures
- TgluErrorString = function(errCode: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluGetString = function(name: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluOrtho2D = procedure(left, right, bottom, top: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluPerspective = procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluPickMatrix = procedure(x, y, width, height: GLdouble; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluLookAt = procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluProject = function(objx, objy, objz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; winx, winy, winz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluUnProject = function(winx, winy, winz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; objx, objy, objz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluScaleImage = function(format: GLEnum; widthin, heightin: GLint; typein: GLEnum; datain: Pointer; widthout, heightout: GLint; typeout: GLEnum; const dataout: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNewQuadric = function: PGLUquadric; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluDeleteQuadric = procedure(state: PGLUquadric); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluQuadricNormals = procedure(quadObject: PGLUquadric; normals: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluQuadricTexture = procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluQuadricOrientation = procedure(quadObject: PGLUquadric; orientation: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluQuadricDrawStyle = procedure(quadObject: PGLUquadric; drawStyle: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluCylinder = procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluPartialDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluSphere = procedure(quadObject: PGLUquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluQuadricCallback = procedure(quadObject: PGLUquadric; which: GLEnum; fn: TGLUQuadricErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNewTess = function: PGLUtesselator; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluDeleteTess = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessBeginPolygon = procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessBeginContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessVertex = procedure(tess: PGLUtesselator; const coords: TGLArrayd3; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessEndContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessNormal = procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluTessCallback = procedure(tess: PGLUtesselator; which: GLEnum; fn: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluGetTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNewNurbsRenderer = function: PGLUnurbs; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluDeleteNurbsRenderer = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBeginSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBeginCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluEndCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluEndSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBeginTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluEndTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluPwlCurve = procedure(nobj: PGLUnurbs; count: GLint; points: PGLfloat; stride: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNurbsCurve = procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNurbsSurface = procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluLoadSamplingMatrices = procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: TGLMatrixf4; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluGetNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNurbsCallback = procedure(nobj: PGLUnurbs; which: GLEnum; fn: TGLUNurbsErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluBeginPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluNextContour = procedure(tess: PGLUtesselator; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- TgluEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-var
- // GL_VERSION_1_0
- glCullFace: TglCullFace;
- glFrontFace: TglFrontFace;
- glHint: TglHint;
- glLineWidth: TglLineWidth;
- glPointSize: TglPointSize;
- glPolygonMode: TglPolygonMode;
- glScissor: TglScissor;
- glTexParameterf: TglTexParameterf;
- glTexParameterfv: TglTexParameterfv;
- glTexParameteri: TglTexParameteri;
- glTexParameteriv: TglTexParameteriv;
- glTexImage1D: TglTexImage1D;
- glTexImage2D: TglTexImage2D;
- glDrawBuffer: TglDrawBuffer;
- glClear: TglClear;
- glClearColor: TglClearColor;
- glClearStencil: TglClearStencil;
- glClearDepth: TglClearDepth;
- glStencilMask: TglStencilMask;
- glColorMask: TglColorMask;
- glDepthMask: TglDepthMask;
- glDisable: TglDisable;
- glEnable: TglEnable;
- glFinish: TglFinish;
- glFlush: TglFlush;
- glBlendFunc: TglBlendFunc;
- glLogicOp: TglLogicOp;
- glStencilFunc: TglStencilFunc;
- glStencilOp: TglStencilOp;
- glDepthFunc: TglDepthFunc;
- glPixelStoref: TglPixelStoref;
- glPixelStorei: TglPixelStorei;
- glReadBuffer: TglReadBuffer;
- glReadPixels: TglReadPixels;
- glGetBooleanv: TglGetBooleanv;
- glGetDoublev: TglGetDoublev;
- glGetError: TglGetError;
- glGetFloatv: TglGetFloatv;
- glGetIntegerv: TglGetIntegerv;
- glGetString: TglGetString;
- glGetTexImage: TglGetTexImage;
- glGetTexParameteriv: TglGetTexParameteriv;
- glGetTexParameterfv: TglGetTexParameterfv;
- glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
- glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
- glIsEnabled: TglIsEnabled;
- glDepthRange: TglDepthRange;
- glViewport: TglViewport;
-
- // GL_VERSION_1_1
- glDrawArrays: TglDrawArrays;
- glDrawElements: TglDrawElements;
- glGetPointerv: TglGetPointerv;
- glPolygonOffset: TglPolygonOffset;
- glCopyTexImage1D: TglCopyTexImage1D;
- glCopyTexImage2D: TglCopyTexImage2D;
- glCopyTexSubImage1D: TglCopyTexSubImage1D;
- glCopyTexSubImage2D: TglCopyTexSubImage2D;
- glTexSubImage1D: TglTexSubImage1D;
- glTexSubImage2D: TglTexSubImage2D;
- glBindTexture: TglBindTexture;
- glDeleteTextures: TglDeleteTextures;
- glGenTextures: TglGenTextures;
-{$ifdef DGL_DEPRECATED}
- glAccum: TglAccum;
- glAlphaFunc: TglAlphaFunc;
- glAreTexturesResident: TglAreTexturesResident;
- glArrayElement: TglArrayElement;
- glBegin: TglBegin;
- glBitmap: TglBitmap;
- glCallList: TglCallList;
- glCallLists: TglCallLists;
- glClearAccum: TglClearAccum;
- glClearIndex: TglClearIndex;
- glClipPlane: TglClipPlane;
- glColor3b: TglColor3b;
- glColor3bv: TglColor3bv;
- glColor3d: TglColor3d;
- glColor3dv: TglColor3dv;
- glColor3f: TglColor3f;
- glColor3fv: TglColor3fv;
- glColor3i: TglColor3i;
- glColor3iv: TglColor3iv;
- glColor3s: TglColor3s;
- glColor3sv: TglColor3sv;
- glColor3ub: TglColor3ub;
- glColor3ubv: TglColor3ubv;
- glColor3ui: TglColor3ui;
- glColor3uiv: TglColor3uiv;
- glColor3us: TglColor3us;
- glColor3usv: TglColor3usv;
- glColor4b: TglColor4b;
- glColor4bv: TglColor4bv;
- glColor4d: TglColor4d;
- glColor4dv: TglColor4dv;
- glColor4f: TglColor4f;
- glColor4fv: TglColor4fv;
- glColor4i: TglColor4i;
- glColor4iv: TglColor4iv;
- glColor4s: TglColor4s;
- glColor4sv: TglColor4sv;
- glColor4ub: TglColor4ub;
- glColor4ubv: TglColor4ubv;
- glColor4ui: TglColor4ui;
- glColor4uiv: TglColor4uiv;
- glColor4us: TglColor4us;
- glColor4usv: TglColor4usv;
- glColorMaterial: TglColorMaterial;
- glColorPointer: TglColorPointer;
- glCopyPixels: TglCopyPixels;
- glDeleteLists: TglDeleteLists;
- glDisableClientState: TglDisableClientState;
- glDrawPixels: TglDrawPixels;
- glEdgeFlag: TglEdgeFlag;
- glEdgeFlagPointer: TglEdgeFlagPointer;
- glEdgeFlagv: TglEdgeFlagv;
- glEnableClientState: TglEnableClientState;
- glEnd: TglEnd;
- glEndList: TglEndList;
- glEvalCoord1d: TglEvalCoord1d;
- glEvalCoord1dv: TglEvalCoord1dv;
- glEvalCoord1f: TglEvalCoord1f;
- glEvalCoord1fv: TglEvalCoord1fv;
- glEvalCoord2d: TglEvalCoord2d;
- glEvalCoord2dv: TglEvalCoord2dv;
- glEvalCoord2f: TglEvalCoord2f;
- glEvalCoord2fv: TglEvalCoord2fv;
- glEvalMesh1: TglEvalMesh1;
- glEvalMesh2: TglEvalMesh2;
- glEvalPoint1: TglEvalPoint1;
- glEvalPoint2: TglEvalPoint2;
- glFeedbackBuffer: TglFeedbackBuffer;
- glFogf: TglFogf;
- glFogfv: TglFogfv;
- glFogi: TglFogi;
- glFogiv: TglFogiv;
- glFrustum: TglFrustum;
- glGenLists: TglGenLists;
- glGetClipPlane: TglGetClipPlane;
- glGetLightfv: TglGetLightfv;
- glGetLightiv: TglGetLightiv;
- glGetMapdv: TglGetMapdv;
- glGetMapfv: TglGetMapfv;
- glGetMapiv: TglGetMapiv;
- glGetMaterialfv: TglGetMaterialfv;
- glGetMaterialiv: TglGetMaterialiv;
- glGetPixelMapfv: TglGetPixelMapfv;
- glGetPixelMapuiv: TglGetPixelMapuiv;
- glGetPixelMapusv: TglGetPixelMapusv;
- glGetPolygonStipple: TglGetPolygonStipple;
- glGetTexEnvfv: TglGetTexEnvfv;
- glGetTexEnviv: TglGetTexEnviv;
- glGetTexGendv: TglGetTexGendv;
- glGetTexGenfv: TglGetTexGenfv;
- glGetTexGeniv: TglGetTexGeniv;
- glIndexMask: TglIndexMask;
- glIndexPointer: TglIndexPointer;
- glIndexd: TglIndexd;
- glIndexdv: TglIndexdv;
- glIndexf: TglIndexf;
- glIndexfv: TglIndexfv;
- glIndexi: TglIndexi;
- glIndexiv: TglIndexiv;
- glIndexs: TglIndexs;
- glIndexsv: TglIndexsv;
- glIndexub: TglIndexub;
- glIndexubv: TglIndexubv;
- glInitNames: TglInitNames;
- glInterleavedArrays: TglInterleavedArrays;
- glIsList: TglIsList;
- glIsTexture: TglIsTexture;
- glLightModelf: TglLightModelf;
- glLightModelfv: TglLightModelfv;
- glLightModeli: TglLightModeli;
- glLightModeliv: TglLightModeliv;
- glLightf: TglLightf;
- glLightfv: TglLightfv;
- glLighti: TglLighti;
- glLightiv: TglLightiv;
- glLineStipple: TglLineStipple;
- glListBase: TglListBase;
- glLoadIdentity: TglLoadIdentity;
- glLoadMatrixd: TglLoadMatrixd;
- glLoadMatrixf: TglLoadMatrixf;
- glLoadName: TglLoadName;
- glMap1d: TglMap1d;
- glMap1f: TglMap1f;
- glMap2d: TglMap2d;
- glMap2f: TglMap2f;
- glMapGrid1d: TglMapGrid1d;
- glMapGrid1f: TglMapGrid1f;
- glMapGrid2d: TglMapGrid2d;
- glMapGrid2f: TglMapGrid2f;
- glMaterialf: TglMaterialf;
- glMaterialfv: TglMaterialfv;
- glMateriali: TglMateriali;
- glMaterialiv: TglMaterialiv;
- glMatrixMode: TglMatrixMode;
- glMultMatrixd: TglMultMatrixd;
- glMultMatrixf: TglMultMatrixf;
- glNewList: TglNewList;
- glNormal3b: TglNormal3b;
- glNormal3bv: TglNormal3bv;
- glNormal3d: TglNormal3d;
- glNormal3dv: TglNormal3dv;
- glNormal3f: TglNormal3f;
- glNormal3fv: TglNormal3fv;
- glNormal3i: TglNormal3i;
- glNormal3iv: TglNormal3iv;
- glNormal3s: TglNormal3s;
- glNormal3sv: TglNormal3sv;
- glNormalPointer: TglNormalPointer;
- glOrtho: TglOrtho;
- glPassThrough: TglPassThrough;
- glPixelMapfv: TglPixelMapfv;
- glPixelMapuiv: TglPixelMapuiv;
- glPixelMapusv: TglPixelMapusv;
- glPixelTransferf: TglPixelTransferf;
- glPixelTransferi: TglPixelTransferi;
- glPixelZoom: TglPixelZoom;
- glPolygonStipple: TglPolygonStipple;
- glPopAttrib: TglPopAttrib;
- glPopClientAttrib: TglPopClientAttrib;
- glPopMatrix: TglPopMatrix;
- glPopName: TglPopName;
- glPrioritizeTextures: TglPrioritizeTextures;
- glPushAttrib: TglPushAttrib;
- glPushClientAttrib: TglPushClientAttrib;
- glPushMatrix: TglPushMatrix;
- glPushName: TglPushName;
- glRasterPos2d: TglRasterPos2d;
- glRasterPos2dv: TglRasterPos2dv;
- glRasterPos2f: TglRasterPos2f;
- glRasterPos2fv: TglRasterPos2fv;
- glRasterPos2i: TglRasterPos2i;
- glRasterPos2iv: TglRasterPos2iv;
- glRasterPos2s: TglRasterPos2s;
- glRasterPos2sv: TglRasterPos2sv;
- glRasterPos3d: TglRasterPos3d;
- glRasterPos3dv: TglRasterPos3dv;
- glRasterPos3f: TglRasterPos3f;
- glRasterPos3fv: TglRasterPos3fv;
- glRasterPos3i: TglRasterPos3i;
- glRasterPos3iv: TglRasterPos3iv;
- glRasterPos3s: TglRasterPos3s;
- glRasterPos3sv: TglRasterPos3sv;
- glRasterPos4d: TglRasterPos4d;
- glRasterPos4dv: TglRasterPos4dv;
- glRasterPos4f: TglRasterPos4f;
- glRasterPos4fv: TglRasterPos4fv;
- glRasterPos4i: TglRasterPos4i;
- glRasterPos4iv: TglRasterPos4iv;
- glRasterPos4s: TglRasterPos4s;
- glRasterPos4sv: TglRasterPos4sv;
- glRectd: TglRectd;
- glRectdv: TglRectdv;
- glRectf: TglRectf;
- glRectfv: TglRectfv;
- glRecti: TglRecti;
- glRectiv: TglRectiv;
- glRects: TglRects;
- glRectsv: TglRectsv;
- glRenderMode: TglRenderMode;
- glRotated: TglRotated;
- glRotatef: TglRotatef;
- glScaled: TglScaled;
- glScalef: TglScalef;
- glSelectBuffer: TglSelectBuffer;
- glShadeModel: TglShadeModel;
- glTexCoord1d: TglTexCoord1d;
- glTexCoord1dv: TglTexCoord1dv;
- glTexCoord1f: TglTexCoord1f;
- glTexCoord1fv: TglTexCoord1fv;
- glTexCoord1i: TglTexCoord1i;
- glTexCoord1iv: TglTexCoord1iv;
- glTexCoord1s: TglTexCoord1s;
- glTexCoord1sv: TglTexCoord1sv;
- glTexCoord2d: TglTexCoord2d;
- glTexCoord2dv: TglTexCoord2dv;
- glTexCoord2f: TglTexCoord2f;
- glTexCoord2fv: TglTexCoord2fv;
- glTexCoord2i: TglTexCoord2i;
- glTexCoord2iv: TglTexCoord2iv;
- glTexCoord2s: TglTexCoord2s;
- glTexCoord2sv: TglTexCoord2sv;
- glTexCoord3d: TglTexCoord3d;
- glTexCoord3dv: TglTexCoord3dv;
- glTexCoord3f: TglTexCoord3f;
- glTexCoord3fv: TglTexCoord3fv;
- glTexCoord3i: TglTexCoord3i;
- glTexCoord3iv: TglTexCoord3iv;
- glTexCoord3s: TglTexCoord3s;
- glTexCoord3sv: TglTexCoord3sv;
- glTexCoord4d: TglTexCoord4d;
- glTexCoord4dv: TglTexCoord4dv;
- glTexCoord4f: TglTexCoord4f;
- glTexCoord4fv: TglTexCoord4fv;
- glTexCoord4i: TglTexCoord4i;
- glTexCoord4iv: TglTexCoord4iv;
- glTexCoord4s: TglTexCoord4s;
- glTexCoord4sv: TglTexCoord4sv;
- glTexCoordPointer: TglTexCoordPointer;
- glTexEnvf: TglTexEnvf;
- glTexEnvfv: TglTexEnvfv;
- glTexEnvi: TglTexEnvi;
- glTexEnviv: TglTexEnviv;
- glTexGend: TglTexGend;
- glTexGendv: TglTexGendv;
- glTexGenf: TglTexGenf;
- glTexGenfv: TglTexGenfv;
- glTexGeni: TglTexGeni;
- glTexGeniv: TglTexGeniv;
- glTranslated: TglTranslated;
- glTranslatef: TglTranslatef;
- glVertex2d: TglVertex2d;
- glVertex2dv: TglVertex2dv;
- glVertex2f: TglVertex2f;
- glVertex2fv: TglVertex2fv;
- glVertex2i: TglVertex2i;
- glVertex2iv: TglVertex2iv;
- glVertex2s: TglVertex2s;
- glVertex2sv: TglVertex2sv;
- glVertex3d: TglVertex3d;
- glVertex3dv: TglVertex3dv;
- glVertex3f: TglVertex3f;
- glVertex3fv: TglVertex3fv;
- glVertex3i: TglVertex3i;
- glVertex3iv: TglVertex3iv;
- glVertex3s: TglVertex3s;
- glVertex3sv: TglVertex3sv;
- glVertex4d: TglVertex4d;
- glVertex4dv: TglVertex4dv;
- glVertex4f: TglVertex4f;
- glVertex4fv: TglVertex4fv;
- glVertex4i: TglVertex4i;
- glVertex4iv: TglVertex4iv;
- glVertex4s: TglVertex4s;
- glVertex4sv: TglVertex4sv;
- glVertexPointer: TglVertexPointer;
-{$endif}
-
- // GL_VERSION_1_2
- glBlendColor: TglBlendColor;
- glBlendEquation: TglBlendEquation;
- glDrawRangeElements: TglDrawRangeElements;
- glTexImage3D: TglTexImage3D;
- glTexSubImage3D: TglTexSubImage3D;
- glCopyTexSubImage3D: TglCopyTexSubImage3D;
-{$ifdef DGL_DEPRECATED}
- glColorTable: TglColorTable;
- glColorTableParameterfv: TglColorTableParameterfv;
- glColorTableParameteriv: TglColorTableParameteriv;
- glCopyColorTable: TglCopyColorTable;
- glGetColorTable: TglGetColorTable;
- glGetColorTableParameterfv: TglGetColorTableParameterfv;
- glGetColorTableParameteriv: TglGetColorTableParameteriv;
- glColorSubTable: TglColorSubTable;
- glCopyColorSubTable: TglCopyColorSubTable;
- glConvolutionFilter1D: TglConvolutionFilter1D;
- glConvolutionFilter2D: TglConvolutionFilter2D;
- glConvolutionParameterf: TglConvolutionParameterf;
- glConvolutionParameterfv: TglConvolutionParameterfv;
- glConvolutionParameteri: TglConvolutionParameteri;
- glConvolutionParameteriv: TglConvolutionParameteriv;
- glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D;
- glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D;
- glGetConvolutionFilter: TglGetConvolutionFilter;
- glGetConvolutionParameterfv: TglGetConvolutionParameterfv;
- glGetConvolutionParameteriv: TglGetConvolutionParameteriv;
- glGetSeparableFilter: TglGetSeparableFilter;
- glSeparableFilter2D: TglSeparableFilter2D;
- glGetHistogram: TglGetHistogram;
- glGetHistogramParameterfv: TglGetHistogramParameterfv;
- glGetHistogramParameteriv: TglGetHistogramParameteriv;
- glGetMinmax: TglGetMinmax;
- glGetMinmaxParameterfv: TglGetMinmaxParameterfv;
- glGetMinmaxParameteriv: TglGetMinmaxParameteriv;
- glHistogram: TglHistogram;
- glMinmax: TglMinmax;
- glResetHistogram: TglResetHistogram;
- glResetMinmax: TglResetMinmax;
-{$endif}
-
- // GL_VERSION_1_3
- glActiveTexture: TglActiveTexture;
- glSampleCoverage: TglSampleCoverage;
- glCompressedTexImage3D: TglCompressedTexImage3D;
- glCompressedTexImage2D: TglCompressedTexImage2D;
- glCompressedTexImage1D: TglCompressedTexImage1D;
- glCompressedTexSubImage3D: TglCompressedTexSubImage3D;
- glCompressedTexSubImage2D: TglCompressedTexSubImage2D;
- glCompressedTexSubImage1D: TglCompressedTexSubImage1D;
- glGetCompressedTexImage: TglGetCompressedTexImage;
-{$ifdef DGL_DEPRECATED}
- glClientActiveTexture: TglClientActiveTexture;
- glMultiTexCoord1d: TglMultiTexCoord1d;
- glMultiTexCoord1dv: TglMultiTexCoord1dv;
- glMultiTexCoord1f: TglMultiTexCoord1f;
- glMultiTexCoord1fv: TglMultiTexCoord1fv;
- glMultiTexCoord1i: TglMultiTexCoord1i;
- glMultiTexCoord1iv: TglMultiTexCoord1iv;
- glMultiTexCoord1s: TglMultiTexCoord1s;
- glMultiTexCoord1sv: TglMultiTexCoord1sv;
- glMultiTexCoord2d: TglMultiTexCoord2d;
- glMultiTexCoord2dv: TglMultiTexCoord2dv;
- glMultiTexCoord2f: TglMultiTexCoord2f;
- glMultiTexCoord2fv: TglMultiTexCoord2fv;
- glMultiTexCoord2i: TglMultiTexCoord2i;
- glMultiTexCoord2iv: TglMultiTexCoord2iv;
- glMultiTexCoord2s: TglMultiTexCoord2s;
- glMultiTexCoord2sv: TglMultiTexCoord2sv;
- glMultiTexCoord3d: TglMultiTexCoord3d;
- glMultiTexCoord3dv: TglMultiTexCoord3dv;
- glMultiTexCoord3f: TglMultiTexCoord3f;
- glMultiTexCoord3fv: TglMultiTexCoord3fv;
- glMultiTexCoord3i: TglMultiTexCoord3i;
- glMultiTexCoord3iv: TglMultiTexCoord3iv;
- glMultiTexCoord3s: TglMultiTexCoord3s;
- glMultiTexCoord3sv: TglMultiTexCoord3sv;
- glMultiTexCoord4d: TglMultiTexCoord4d;
- glMultiTexCoord4dv: TglMultiTexCoord4dv;
- glMultiTexCoord4f: TglMultiTexCoord4f;
- glMultiTexCoord4fv: TglMultiTexCoord4fv;
- glMultiTexCoord4i: TglMultiTexCoord4i;
- glMultiTexCoord4iv: TglMultiTexCoord4iv;
- glMultiTexCoord4s: TglMultiTexCoord4s;
- glMultiTexCoord4sv: TglMultiTexCoord4sv;
- glLoadTransposeMatrixf: TglLoadTransposeMatrixf;
- glLoadTransposeMatrixd: TglLoadTransposeMatrixd;
- glMultTransposeMatrixf: TglMultTransposeMatrixf;
- glMultTransposeMatrixd: TglMultTransposeMatrixd;
-{$endif}
-
- // GL_VERSION_1_4
- glBlendFuncSeparate: TglBlendFuncSeparate;
- glMultiDrawArrays: TglMultiDrawArrays;
- glMultiDrawElements: TglMultiDrawElements;
- glPointParameterf: TglPointParameterf;
- glPointParameterfv: TglPointParameterfv;
- glPointParameteri: TglPointParameteri;
- glPointParameteriv: TglPointParameteriv;
-{$ifdef DGL_DEPRECATED}
- glFogCoordf: TglFogCoordf;
- glFogCoordfv: TglFogCoordfv;
- glFogCoordd: TglFogCoordd;
- glFogCoorddv: TglFogCoorddv;
- glFogCoordPointer: TglFogCoordPointer;
- glSecondaryColor3b: TglSecondaryColor3b;
- glSecondaryColor3bv: TglSecondaryColor3bv;
- glSecondaryColor3d: TglSecondaryColor3d;
- glSecondaryColor3dv: TglSecondaryColor3dv;
- glSecondaryColor3f: TglSecondaryColor3f;
- glSecondaryColor3fv: TglSecondaryColor3fv;
- glSecondaryColor3i: TglSecondaryColor3i;
- glSecondaryColor3iv: TglSecondaryColor3iv;
- glSecondaryColor3s: TglSecondaryColor3s;
- glSecondaryColor3sv: TglSecondaryColor3sv;
- glSecondaryColor3ub: TglSecondaryColor3ub;
- glSecondaryColor3ubv: TglSecondaryColor3ubv;
- glSecondaryColor3ui: TglSecondaryColor3ui;
- glSecondaryColor3uiv: TglSecondaryColor3uiv;
- glSecondaryColor3us: TglSecondaryColor3us;
- glSecondaryColor3usv: TglSecondaryColor3usv;
- glSecondaryColorPointer: TglSecondaryColorPointer;
- glWindowPos2d: TglWindowPos2d;
- glWindowPos2dv: TglWindowPos2dv;
- glWindowPos2f: TglWindowPos2f;
- glWindowPos2fv: TglWindowPos2fv;
- glWindowPos2i: TglWindowPos2i;
- glWindowPos2iv: TglWindowPos2iv;
- glWindowPos2s: TglWindowPos2s;
- glWindowPos2sv: TglWindowPos2sv;
- glWindowPos3d: TglWindowPos3d;
- glWindowPos3dv: TglWindowPos3dv;
- glWindowPos3f: TglWindowPos3f;
- glWindowPos3fv: TglWindowPos3fv;
- glWindowPos3i: TglWindowPos3i;
- glWindowPos3iv: TglWindowPos3iv;
- glWindowPos3s: TglWindowPos3s;
- glWindowPos3sv: TglWindowPos3sv;
-{$endif}
-
- // GL_VERSION_1_5
- glGenQueries: TglGenQueries;
- glDeleteQueries: TglDeleteQueries;
- glIsQuery: TglIsQuery;
- glBeginQuery: TglBeginQuery;
- glEndQuery: TglEndQuery;
- glGetQueryiv: TglGetQueryiv;
- glGetQueryObjectiv: TglGetQueryObjectiv;
- glGetQueryObjectuiv: TglGetQueryObjectuiv;
- glBindBuffer: TglBindBuffer;
- glDeleteBuffers: TglDeleteBuffers;
- glGenBuffers: TglGenBuffers;
- glIsBuffer: TglIsBuffer;
- glBufferData: TglBufferData;
- glBufferSubData: TglBufferSubData;
- glGetBufferSubData: TglGetBufferSubData;
- glMapBuffer: TglMapBuffer;
- glUnmapBuffer: TglUnmapBuffer;
- glGetBufferParameteriv: TglGetBufferParameteriv;
- glGetBufferPointerv: TglGetBufferPointerv;
-
- // GL_VERSION_2_0
- glBlendEquationSeparate: TglBlendEquationSeparate;
- glDrawBuffers: TglDrawBuffers;
- glStencilOpSeparate: TglStencilOpSeparate;
- glStencilFuncSeparate: TglStencilFuncSeparate;
- glStencilMaskSeparate: TglStencilMaskSeparate;
- glAttachShader: TglAttachShader;
- glBindAttribLocation: TglBindAttribLocation;
- glCompileShader: TglCompileShader;
- glCreateProgram: TglCreateProgram;
- glCreateShader: TglCreateShader;
- glDeleteProgram: TglDeleteProgram;
- glDeleteShader: TglDeleteShader;
- glDetachShader: TglDetachShader;
- glDisableVertexAttribArray: TglDisableVertexAttribArray;
- glEnableVertexAttribArray: TglEnableVertexAttribArray;
- glGetActiveAttrib: TglGetActiveAttrib;
- glGetActiveUniform: TglGetActiveUniform;
- glGetAttachedShaders: TglGetAttachedShaders;
- glGetAttribLocation: TglGetAttribLocation;
- glGetProgramiv: TglGetProgramiv;
- glGetProgramInfoLog: TglGetProgramInfoLog;
- glGetShaderiv: TglGetShaderiv;
- glGetShaderInfoLog: TglGetShaderInfoLog;
- glGetShaderSource: TglGetShaderSource;
- glGetUniformLocation: TglGetUniformLocation;
- glGetUniformfv: TglGetUniformfv;
- glGetUniformiv: TglGetUniformiv;
- glGetVertexAttribfv: TglGetVertexAttribfv;
- glGetVertexAttribiv: TglGetVertexAttribiv;
- glGetVertexAttribPointerv: TglGetVertexAttribPointerv;
- glIsProgram: TglIsProgram;
- glIsShader: TglIsShader;
- glLinkProgram: TglLinkProgram;
- glShaderSource: TglShaderSource;
- glUseProgram: TglUseProgram;
- glUniform1f: TglUniform1f;
- glUniform2f: TglUniform2f;
- glUniform3f: TglUniform3f;
- glUniform4f: TglUniform4f;
- glUniform1i: TglUniform1i;
- glUniform2i: TglUniform2i;
- glUniform3i: TglUniform3i;
- glUniform4i: TglUniform4i;
- glUniform1fv: TglUniform1fv;
- glUniform2fv: TglUniform2fv;
- glUniform3fv: TglUniform3fv;
- glUniform4fv: TglUniform4fv;
- glUniform1iv: TglUniform1iv;
- glUniform2iv: TglUniform2iv;
- glUniform3iv: TglUniform3iv;
- glUniform4iv: TglUniform4iv;
- glUniformMatrix2fv: TglUniformMatrix2fv;
- glUniformMatrix3fv: TglUniformMatrix3fv;
- glUniformMatrix4fv: TglUniformMatrix4fv;
- glValidateProgram: TglValidateProgram;
- glVertexAttrib1d: TglVertexAttrib1d;
- glVertexAttrib1dv: TglVertexAttrib1dv;
- glVertexAttrib1f: TglVertexAttrib1f;
- glVertexAttrib1fv: TglVertexAttrib1fv;
- glVertexAttrib1s: TglVertexAttrib1s;
- glVertexAttrib1sv: TglVertexAttrib1sv;
- glVertexAttrib2d: TglVertexAttrib2d;
- glVertexAttrib2dv: TglVertexAttrib2dv;
- glVertexAttrib2f: TglVertexAttrib2f;
- glVertexAttrib2fv: TglVertexAttrib2fv;
- glVertexAttrib2s: TglVertexAttrib2s;
- glVertexAttrib2sv: TglVertexAttrib2sv;
- glVertexAttrib3d: TglVertexAttrib3d;
- glVertexAttrib3dv: TglVertexAttrib3dv;
- glVertexAttrib3f: TglVertexAttrib3f;
- glVertexAttrib3fv: TglVertexAttrib3fv;
- glVertexAttrib3s: TglVertexAttrib3s;
- glVertexAttrib3sv: TglVertexAttrib3sv;
- glVertexAttrib4Nbv: TglVertexAttrib4Nbv;
- glVertexAttrib4Niv: TglVertexAttrib4Niv;
- glVertexAttrib4Nsv: TglVertexAttrib4Nsv;
- glVertexAttrib4Nub: TglVertexAttrib4Nub;
- glVertexAttrib4Nubv: TglVertexAttrib4Nubv;
- glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv;
- glVertexAttrib4Nusv: TglVertexAttrib4Nusv;
- glVertexAttrib4bv: TglVertexAttrib4bv;
- glVertexAttrib4d: TglVertexAttrib4d;
- glVertexAttrib4dv: TglVertexAttrib4dv;
- glVertexAttrib4f: TglVertexAttrib4f;
- glVertexAttrib4fv: TglVertexAttrib4fv;
- glVertexAttrib4iv: TglVertexAttrib4iv;
- glVertexAttrib4s: TglVertexAttrib4s;
- glVertexAttrib4sv: TglVertexAttrib4sv;
- glVertexAttrib4ubv: TglVertexAttrib4ubv;
- glVertexAttrib4uiv: TglVertexAttrib4uiv;
- glVertexAttrib4usv: TglVertexAttrib4usv;
- glVertexAttribPointer: TglVertexAttribPointer;
-
- // GL_VERSION_2_1
- glUniformMatrix2x3fv: TglUniformMatrix2x3fv;
- glUniformMatrix3x2fv: TglUniformMatrix3x2fv;
- glUniformMatrix2x4fv: TglUniformMatrix2x4fv;
- glUniformMatrix4x2fv: TglUniformMatrix4x2fv;
- glUniformMatrix3x4fv: TglUniformMatrix3x4fv;
- glUniformMatrix4x3fv: TglUniformMatrix4x3fv;
-
- // GL_VERSION_3_0
- glColorMaski: TglColorMaski;
- glGetBooleani_v: TglGetBooleani_v;
- glGetIntegeri_v: TglGetIntegeri_v;
- glEnablei: TglEnablei;
- glDisablei: TglDisablei;
- glIsEnabledi: TglIsEnabledi;
- glBeginTransformFeedback: TglBeginTransformFeedback;
- glEndTransformFeedback: TglEndTransformFeedback;
- glBindBufferRange: TglBindBufferRange;
- glBindBufferBase: TglBindBufferBase;
- glTransformFeedbackVaryings: TglTransformFeedbackVaryings;
- glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying;
- glClampColor: TglClampColor;
- glBeginConditionalRender: TglBeginConditionalRender;
- glEndConditionalRender: TglEndConditionalRender;
- glVertexAttribI1i: TglVertexAttribI1i;
- glVertexAttribI2i: TglVertexAttribI2i;
- glVertexAttribI3i: TglVertexAttribI3i;
- glVertexAttribI4i: TglVertexAttribI4i;
- glVertexAttribI1ui: TglVertexAttribI1ui;
- glVertexAttribI2ui: TglVertexAttribI2ui;
- glVertexAttribI3ui: TglVertexAttribI3ui;
- glVertexAttribI4ui: TglVertexAttribI4ui;
- glVertexAttribI1iv: TglVertexAttribI1iv;
- glVertexAttribI2iv: TglVertexAttribI2iv;
- glVertexAttribI3iv: TglVertexAttribI3iv;
- glVertexAttribI4iv: TglVertexAttribI4iv;
- glVertexAttribI1uiv: TglVertexAttribI1uiv;
- glVertexAttribI2uiv: TglVertexAttribI2uiv;
- glVertexAttribI3uiv: TglVertexAttribI3uiv;
- glVertexAttribI4uiv: TglVertexAttribI4uiv;
- glVertexAttribI4bv: TglVertexAttribI4bv;
- glVertexAttribI4sv: TglVertexAttribI4sv;
- glVertexAttribI4ubv: TglVertexAttribI4ubv;
- glVertexAttribI4usv: TglVertexAttribI4usv;
- glVertexAttribIPointer: TglVertexAttribIPointer;
- glGetVertexAttribIiv: TglGetVertexAttribIiv;
- glGetVertexAttribIuiv: TglGetVertexAttribIuiv;
- glGetUniformuiv: TglGetUniformuiv;
- glBindFragDataLocation: TglBindFragDataLocation;
- glGetFragDataLocation: TglGetFragDataLocation;
- glUniform1ui: TglUniform1ui;
- glUniform2ui: TglUniform2ui;
- glUniform3ui: TglUniform3ui;
- glUniform4ui: TglUniform4ui;
- glUniform1uiv: TglUniform1uiv;
- glUniform2uiv: TglUniform2uiv;
- glUniform3uiv: TglUniform3uiv;
- glUniform4uiv: TglUniform4uiv;
- glTexParameterIiv: TglTexParameterIiv;
- glTexParameterIuiv: TglTexParameterIuiv;
- glGetTexParameterIiv: TglGetTexParameterIiv;
- glGetTexParameterIuiv: TglGetTexParameterIuiv;
- glClearBufferiv: TglClearBufferiv;
- glClearBufferuiv: TglClearBufferuiv;
- glClearBufferfv: TglClearBufferfv;
- glClearBufferfi: TglClearBufferfi;
- glGetStringi: TglGetStringi;
-
- // GL_VERSION_2_1
- glEnableVertexArrayEXT : TglEnableVertexArrayEXT;
- glEnableVertexArrayAttribEXT : TglEnableVertexArrayAttribEXT;
- glVertexArrayVertexAttribOffsetEXT : TglVertexArrayVertexAttribOffsetEXT;
-
- // GL_VERSION_3_1
- glDrawArraysInstanced: TglDrawArraysInstanced;
- glDrawElementsInstanced: TglDrawElementsInstanced;
- glTexBuffer: TglTexBuffer;
- glPrimitiveRestartIndex: TglPrimitiveRestartIndex;
-
- // GL_VERSION_3_2
- glGetInteger64i_v: TglGetInteger64i_v;
- glGetBufferParameteri64v: TglGetBufferParameteri64v;
- glFramebufferTexture: TglFramebufferTexture;
-
- // GL_VERSION_3_3
- glVertexAttribDivisor: TglVertexAttribDivisor;
-
- // GL_VERSION_4_0
- { OpenGL 4.0 also reuses entry points from these extensions: }
- { ARB_texture_query_lod (no entry points) }
- { ARB_draw_indirect }
- { ARB_gpu_shader5 (no entry points) }
- { ARB_gpu_shader_fp64 }
- { ARB_shader_subroutine }
- { ARB_tessellation_shader }
- { ARB_texture_buffer_object_rgb32 (no entry points) }
- { ARB_texture_cube_map_array (no entry points) }
- { ARB_texture_gather (no entry points) }
- { ARB_transform_feedback2 }
- { ARB_transform_feedback3 }
- glMinSampleShading: TglMinSampleShading;
- glBlendEquationi: TglBlendEquationi;
- glBlendEquationSeparatei: TglBlendEquationSeparatei;
- glBlendFunci: TglBlendFunci;
- glBlendFuncSeparatei: TglBlendFuncSeparatei;
-
- // GL_3DFX_tbuffer
- glTbufferMask3DFX: TglTbufferMask3DFX;
-
- // GL_APPLE_element_array
- glElementPointerAPPLE: TglElementPointerAPPLE;
- glDrawElementArrayAPPLE: TglDrawElementArrayAPPLE;
- glDrawRangeElementArrayAPPLE: TglDrawRangeElementArrayAPPLE;
- glMultiDrawElementArrayAPPLE: TglMultiDrawElementArrayAPPLE;
- glMultiDrawRangeElementArrayAPPLE: TglMultiDrawRangeElementArrayAPPLE;
-
- // GL_APPLE_fence
- glGenFencesAPPLE: TglGenFencesAPPLE;
- glDeleteFencesAPPLE: TglDeleteFencesAPPLE;
- glSetFenceAPPLE: TglSetFenceAPPLE;
- glIsFenceAPPLE: TglIsFenceAPPLE;
- glTestFenceAPPLE: TglTestFenceAPPLE;
- glFinishFenceAPPLE: TglFinishFenceAPPLE;
- glTestObjectAPPLE: TglTestObjectAPPLE;
- glFinishObjectAPPLE: TglFinishObjectAPPLE;
-
- // GL_APPLE_vertex_array_object
- glBindVertexArrayAPPLE: TglBindVertexArrayAPPLE;
- glDeleteVertexArraysAPPLE: TglDeleteVertexArraysAPPLE;
- glGenVertexArraysAPPLE: TglGenVertexArraysAPPLE;
- glIsVertexArrayAPPLE: TglIsVertexArrayAPPLE;
-
- // GL_APPLE_vertex_array_range
- glVertexArrayRangeAPPLE: TglVertexArrayRangeAPPLE;
- glFlushVertexArrayRangeAPPLE: TglFlushVertexArrayRangeAPPLE;
- glVertexArrayParameteriAPPLE: TglVertexArrayParameteriAPPLE;
-
- // GL_APPLE_texture_range
- glTextureRangeAPPLE: TglTextureRangeAPPLE;
- glGetTexParameterPointervAPPLE: TglGetTexParameterPointervAPPLE;
-
- // GL_APPLE_vertex_program_evaluators
- glEnableVertexAttribAPPLE: TglEnableVertexAttribAPPLE;
- glDisableVertexAttribAPPLE: TglDisableVertexAttribAPPLE;
- glIsVertexAttribEnabledAPPLE: TglIsVertexAttribEnabledAPPLE;
- glMapVertexAttrib1dAPPLE: TglMapVertexAttrib1dAPPLE;
- glMapVertexAttrib1fAPPLE: TglMapVertexAttrib1fAPPLE;
- glMapVertexAttrib2dAPPLE: TglMapVertexAttrib2dAPPLE;
- glMapVertexAttrib2fAPPLE: TglMapVertexAttrib2fAPPLE;
-
- // GL_APPLE_object_purgeable
- glObjectPurgeableAPPLE: TglObjectPurgeableAPPLE;
- glObjectUnpurgeableAPPLE: TglObjectUnpurgeableAPPLE;
- glGetObjectParameterivAPPLE: TglGetObjectParameterivAPPLE;
-
- // GL_ARB_matrix_palette
- glCurrentPaletteMatrixARB: TglCurrentPaletteMatrixARB;
- glMatrixIndexubvARB: TglMatrixIndexubvARB;
- glMatrixIndexusvARB: TglMatrixIndexusvARB;
- glMatrixIndexuivARB: TglMatrixIndexuivARB;
- glMatrixIndexPointerARB: TglMatrixIndexPointerARB;
-
- // GL_ARB_multisample
- glSampleCoverageARB: TglSampleCoverageARB;
-
- // GL_ARB_multitexture
- glActiveTextureARB: TglActiveTextureARB;
- glClientActiveTextureARB: TglClientActiveTextureARB;
- glMultiTexCoord1dARB: TglMultiTexCoord1dARB;
- glMultiTexCoord1dvARB: TglMultiTexCoord1dvARB;
- glMultiTexCoord1fARB: TglMultiTexCoord1fARB;
- glMultiTexCoord1fvARB: TglMultiTexCoord1fvARB;
- glMultiTexCoord1iARB: TglMultiTexCoord1iARB;
- glMultiTexCoord1ivARB: TglMultiTexCoord1ivARB;
- glMultiTexCoord1sARB: TglMultiTexCoord1sARB;
- glMultiTexCoord1svARB: TglMultiTexCoord1svARB;
- glMultiTexCoord2dARB: TglMultiTexCoord2dARB;
- glMultiTexCoord2dvARB: TglMultiTexCoord2dvARB;
- glMultiTexCoord2fARB: TglMultiTexCoord2fARB;
- glMultiTexCoord2fvARB: TglMultiTexCoord2fvARB;
- glMultiTexCoord2iARB: TglMultiTexCoord2iARB;
- glMultiTexCoord2ivARB: TglMultiTexCoord2ivARB;
- glMultiTexCoord2sARB: TglMultiTexCoord2sARB;
- glMultiTexCoord2svARB: TglMultiTexCoord2svARB;
- glMultiTexCoord3dARB: TglMultiTexCoord3dARB;
- glMultiTexCoord3dvARB: TglMultiTexCoord3dvARB;
- glMultiTexCoord3fARB: TglMultiTexCoord3fARB;
- glMultiTexCoord3fvARB: TglMultiTexCoord3fvARB;
- glMultiTexCoord3iARB: TglMultiTexCoord3iARB;
- glMultiTexCoord3ivARB: TglMultiTexCoord3ivARB;
- glMultiTexCoord3sARB: TglMultiTexCoord3sARB;
- glMultiTexCoord3svARB: TglMultiTexCoord3svARB;
- glMultiTexCoord4dARB: TglMultiTexCoord4dARB;
- glMultiTexCoord4dvARB: TglMultiTexCoord4dvARB;
- glMultiTexCoord4fARB: TglMultiTexCoord4fARB;
- glMultiTexCoord4fvARB: TglMultiTexCoord4fvARB;
- glMultiTexCoord4iARB: TglMultiTexCoord4iARB;
- glMultiTexCoord4ivARB: TglMultiTexCoord4ivARB;
- glMultiTexCoord4sARB: TglMultiTexCoord4sARB;
- glMultiTexCoord4svARB: TglMultiTexCoord4svARB;
-
- // GL_ARB_point_parameters
- glPointParameterfARB: TglPointParameterfARB;
- glPointParameterfvARB: TglPointParameterfvARB;
-
- // GL_ARB_texture_compression
- glCompressedTexImage3DARB: TglCompressedTexImage3DARB;
- glCompressedTexImage2DARB: TglCompressedTexImage2DARB;
- glCompressedTexImage1DARB: TglCompressedTexImage1DARB;
- glCompressedTexSubImage3DARB: TglCompressedTexSubImage3DARB;
- glCompressedTexSubImage2DARB: TglCompressedTexSubImage2DARB;
- glCompressedTexSubImage1DARB: TglCompressedTexSubImage1DARB;
- glGetCompressedTexImageARB: TglGetCompressedTexImageARB;
-
- // GL_ARB_transpose_matrix
- glLoadTransposeMatrixfARB: TglLoadTransposeMatrixfARB;
- glLoadTransposeMatrixdARB: TglLoadTransposeMatrixdARB;
- glMultTransposeMatrixfARB: TglMultTransposeMatrixfARB;
- glMultTransposeMatrixdARB: TglMultTransposeMatrixdARB;
-
- // GL_ARB_vertex_blend
- glWeightbvARB: TglWeightbvARB;
- glWeightsvARB: TglWeightsvARB;
- glWeightivARB: TglWeightivARB;
- glWeightfvARB: TglWeightfvARB;
- glWeightdvARB: TglWeightdvARB;
- glWeightubvARB: TglWeightubvARB;
- glWeightusvARB: TglWeightusvARB;
- glWeightuivARB: TglWeightuivARB;
- glWeightPointerARB: TglWeightPointerARB;
- glVertexBlendARB: TglVertexBlendARB;
-
- // GL_ARB_vertex_buffer_object
- glBindBufferARB: TglBindBufferARB;
- glDeleteBuffersARB: TglDeleteBuffersARB;
- glGenBuffersARB: TglGenBuffersARB;
- glIsBufferARB: TglIsBufferARB;
- glBufferDataARB: TglBufferDataARB;
- glBufferSubDataARB: TglBufferSubData;
- glGetBufferSubDataARB: TglGetBufferSubDataARB;
- glMapBufferARB: TglMapBufferARB;
- glUnmapBufferARB: TglUnmapBufferARB;
- glGetBufferParameterivARB: TglGetBufferParameterivARB;
- glGetBufferPointervARB: TglGetBufferPointervARB;
-
- // GL_ARB_vertex_program
- glVertexAttrib1dARB: TglVertexAttrib1dARB;
- glVertexAttrib1dvARB: TglVertexAttrib1dvARB;
- glVertexAttrib1fARB: TglVertexAttrib1fARB;
- glVertexAttrib1fvARB: TglVertexAttrib1fvARB;
- glVertexAttrib1sARB: TglVertexAttrib1sARB;
- glVertexAttrib1svARB: TglVertexAttrib1svARB;
- glVertexAttrib2dARB: TglVertexAttrib2dARB;
- glVertexAttrib2dvARB: TglVertexAttrib2dvARB;
- glVertexAttrib2fARB: TglVertexAttrib2fARB;
- glVertexAttrib2fvARB: TglVertexAttrib2fvARB;
- glVertexAttrib2sARB: TglVertexAttrib2sARB;
- glVertexAttrib2svARB: TglVertexAttrib2svARB;
- glVertexAttrib3dARB: TglVertexAttrib3dARB;
- glVertexAttrib3dvARB: TglVertexAttrib3dvARB;
- glVertexAttrib3fARB: TglVertexAttrib3fARB;
- glVertexAttrib3fvARB: TglVertexAttrib3fvARB;
- glVertexAttrib3sARB: TglVertexAttrib3sARB;
- glVertexAttrib3svARB: TglVertexAttrib3svARB;
- glVertexAttrib4NbvARB: TglVertexAttrib4NbvARB;
- glVertexAttrib4NivARB: TglVertexAttrib4NivARB;
- glVertexAttrib4NsvARB: TglVertexAttrib4NsvARB;
- glVertexAttrib4NubARB: TglVertexAttrib4NubARB;
- glVertexAttrib4NubvARB: TglVertexAttrib4NubvARB;
- glVertexAttrib4NuivARB: TglVertexAttrib4NuivARB;
- glVertexAttrib4NusvARB: TglVertexAttrib4NusvARB;
- glVertexAttrib4bvARB: TglVertexAttrib4bvARB;
- glVertexAttrib4dARB: TglVertexAttrib4dARB;
- glVertexAttrib4dvARB: TglVertexAttrib4dvARB;
- glVertexAttrib4fARB: TglVertexAttrib4fARB;
- glVertexAttrib4fvARB: TglVertexAttrib4fvARB;
- glVertexAttrib4ivARB: TglVertexAttrib4ivARB;
- glVertexAttrib4sARB: TglVertexAttrib4sARB;
- glVertexAttrib4svARB: TglVertexAttrib4svARB;
- glVertexAttrib4ubvARB: TglVertexAttrib4ubvARB;
- glVertexAttrib4uivARB: TglVertexAttrib4uivARB;
- glVertexAttrib4usvARB: TglVertexAttrib4usvARB;
- glVertexAttribPointerARB: TglVertexAttribPointerARB;
- glEnableVertexAttribArrayARB: TglEnableVertexAttribArrayARB;
- glDisableVertexAttribArrayARB: TglDisableVertexAttribArrayARB;
- glProgramStringARB: TglProgramStringARB;
- glBindProgramARB: TglBindProgramARB;
- glDeleteProgramsARB: TglDeleteProgramsARB;
- glGenProgramsARB: TglGenProgramsARB;
-
- glProgramEnvParameter4dARB: TglProgramEnvParameter4dARB;
- glProgramEnvParameter4dvARB: TglProgramEnvParameter4dvARB;
- glProgramEnvParameter4fARB: TglProgramEnvParameter4fARB;
- glProgramEnvParameter4fvARB: TglProgramEnvParameter4fvARB;
- glProgramLocalParameter4dARB: TglProgramLocalParameter4dARB;
- glProgramLocalParameter4dvARB: TglProgramLocalParameter4dvARB;
- glProgramLocalParameter4fARB: TglProgramLocalParameter4fARB;
- glProgramLocalParameter4fvARB: TglProgramLocalParameter4fvARB;
- glGetProgramEnvParameterdvARB: TglGetProgramEnvParameterdvARB;
- glGetProgramEnvParameterfvARB: TglGetProgramEnvParameterfvARB;
- glGetProgramLocalParameterdvARB: TglGetProgramLocalParameterdvARB;
- glGetProgramLocalParameterfvARB: TglGetProgramLocalParameterfvARB;
- glGetProgramivARB: TglGetProgramivARB;
- glGetProgramStringARB: TglGetProgramStringARB;
- glGetVertexAttribdvARB: TglGetVertexAttribdvARB;
- glGetVertexAttribfvARB: TglGetVertexAttribfvARB;
- glGetVertexAttribivARB: TglGetVertexAttribivARB;
- glGetVertexAttribPointervARB: TglGetVertexAttribPointervARB;
- glIsProgramARB: TglIsProgramARB;
-
- // GL_ARB_window_pos
- glWindowPos2dARB: TglWindowPos2dARB;
- glWindowPos2dvARB: TglWindowPos2dvARB;
- glWindowPos2fARB: TglWindowPos2fARB;
- glWindowPos2fvARB: TglWindowPos2fvARB;
- glWindowPos2iARB: TglWindowPos2iARB;
- glWindowPos2ivARB: TglWindowPos2ivARB;
- glWindowPos2sARB: TglWindowPos2sARB;
- glWindowPos2svARB: TglWindowPos2svARB;
- glWindowPos3dARB: TglWindowPos3dARB;
- glWindowPos3dvARB: TglWindowPos3dvARB;
- glWindowPos3fARB: TglWindowPos3fARB;
- glWindowPos3fvARB: TglWindowPos3fvARB;
- glWindowPos3iARB: TglWindowPos3iARB;
- glWindowPos3ivARB: TglWindowPos3ivARB;
- glWindowPos3sARB: TglWindowPos3sARB;
- glWindowPos3svARB: TglWindowPos3svARB;
-
- // GL_ARB_draw_buffers
- glDrawBuffersARB: TglDrawBuffersARB;
-
- // GL_ARB_color_buffer_float
- glClampColorARB: TglClampColorARB;
-
- // GL_ARB_vertex_shader
- glGetActiveAttribARB: TglGetActiveAttribARB;
- glGetAttribLocationARB: TglGetAttribLocationARB;
- glBindAttribLocationARB: TglBindAttribLocationARB;
-
- // GL_ARB_shader_objects
- glDeleteObjectARB: TglDeleteObjectARB;
- glGetHandleARB: TglGetHandleARB;
- glDetachObjectARB: TglDetachObjectARB;
- glCreateShaderObjectARB: TglCreateShaderObjectARB;
- glShaderSourceARB: TglShaderSourceARB;
- glCompileShaderARB: TglCompileShaderARB;
- glCreateProgramObjectARB: TglCreateProgramObjectARB;
- glAttachObjectARB: TglAttachObjectARB;
- glLinkProgramARB: TglLinkProgramARB;
- glUseProgramObjectARB: TglUseProgramObjectARB;
- glValidateProgramARB: TglValidateProgramARB;
- glUniform1fARB: TglUniform1fARB;
- glUniform2fARB: TglUniform2fARB;
- glUniform3fARB: TglUniform3fARB;
- glUniform4fARB: TglUniform4fARB;
- glUniform1iARB: TglUniform1iARB;
- glUniform2iARB: TglUniform2iARB;
- glUniform3iARB: TglUniform3iARB;
- glUniform4iARB: TglUniform4iARB;
- glUniform1fvARB: TglUniform1fvARB;
- glUniform2fvARB: TglUniform2fvARB;
- glUniform3fvARB: TglUniform3fvARB;
- glUniform4fvARB: TglUniform4fvARB;
- glUniform1ivARB: TglUniform1ivARB;
- glUniform2ivARB: TglUniform2ivARB;
- glUniform3ivARB: TglUniform3ivARB;
- glUniform4ivARB: TglUniform4ivARB;
- glUniformMatrix2fvARB: TglUniformMatrix2fvARB;
- glUniformMatrix3fvARB: TglUniformMatrix3fvARB;
- glUniformMatrix4fvARB: TglUniformMatrix4fvARB;
- glGetObjectParameterfvARB: TglGetObjectParameterfvARB;
- glGetObjectParameterivARB: TglGetObjectParameterivARB;
- glGetInfoLogARB: TglGetInfoLogARB;
- glGetAttachedObjectsARB: TglGetAttachedObjectsARB;
- glGetUniformLocationARB: TglGetUniformLocationARB;
- glGetActiveUniformARB: TglGetActiveUniformARB;
- glGetUniformfvARB: TglGetUniformfvARB;
- glGetUniformivARB: TglGetUniformivARB;
- glGetShaderSourceARB: TglGetShaderSourceARB;
-
- // GL_ARB_Occlusion_Query
- glGenQueriesARB: TglGenQueriesARB;
- glDeleteQueriesARB: TglDeleteQueriesARB;
- glIsQueryARB: TglIsQueryARB;
- glBeginQueryARB: TglBeginQueryARB;
- glEndQueryARB: TglEndQueryARB;
- glGetQueryivARB: TglGetQueryivARB;
- glGetQueryObjectivARB: TglGetQueryObjectivARB;
- glGetQueryObjectuivARB: TglGetQueryObjectuivARB;
-
- // GL_ARB_draw_instanced
- glDrawArraysInstancedARB: TglDrawArraysInstancedARB;
- glDrawElementsInstancedARB: TglDrawElementsInstancedARB;
-
- // GL_ARB_framebuffer_object
- glIsRenderbuffer: TglIsRenderbuffer;
- glBindRenderbuffer: TglBindRenderbuffer;
- glDeleteRenderbuffers: TglDeleteRenderbuffers;
- glGenRenderbuffers: TglGenRenderbuffers;
- glRenderbufferStorage: TglRenderbufferStorage;
- glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv;
- glIsFramebuffer: TglIsFramebuffer;
- glBindFramebuffer: TglBindFramebuffer;
- glDeleteFramebuffers: TglDeleteFramebuffers;
- glGenFramebuffers: TglGenFramebuffers;
- glCheckFramebufferStatus: TglCheckFramebufferStatus;
- glFramebufferTexture1D: TglFramebufferTexture1D;
- glFramebufferTexture2D: TglFramebufferTexture2D;
- glFramebufferTexture3D: TglFramebufferTexture3D;
- glFramebufferRenderbuffer: TglFramebufferRenderbuffer;
- glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv;
- glGenerateMipmap: TglGenerateMipmap;
- glBlitFramebuffer: TglBlitFramebuffer;
- glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample;
- glFramebufferTextureLayer: TglFramebufferTextureLayer;
-
- // GL_ARB_geometry_shader4
- glProgramParameteriARB: TglProgramParameteriARB;
- glFramebufferTextureARB: TglFramebufferTextureARB;
- glFramebufferTextureLayerARB: TglFramebufferTextureLayerARB;
- glFramebufferTextureFaceARB: TglFramebufferTextureFaceARB;
-
- // GL_ARB_instanced_arrays
- glVertexAttribDivisorARB: TglVertexAttribDivisorARB;
-
- // GL_ARB_map_buffer_range
- glMapBufferRange: TglMapBufferRange;
- glFlushMappedBufferRange: TglFlushMappedBufferRange;
-
- // GL_ARB_texture_buffer_object
- glTexBufferARB: TglTexBufferARB;
-
- // GL_ARB_vertex_array_object
- glBindVertexArray: TglBindVertexArray;
- glDeleteVertexArrays: TglDeleteVertexArrays;
- glGenVertexArrays: TglGenVertexArrays;
- glIsVertexArray: TglIsVertexArray;
-
- // GL_ARB_uniform_buffer_object
- glGetUniformIndices: TglGetUniformIndices;
- glGetActiveUniformsiv: TglGetActiveUniformsiv;
- glGetActiveUniformName: TglGetActiveUniformName;
- glGetUniformBlockIndex: TglGetUniformBlockIndex;
- glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv;
- glGetActiveUniformBlockName: TglGetActiveUniformBlockName;
- glUniformBlockBinding: TglUniformBlockBinding;
-
- // GL_ARB_copy_buffer
- glCopyBufferSubData: TglCopyBufferSubData;
-
- // GL_ARB_draw_elements_base_vertex
- glDrawElementsBaseVertex: TglDrawElementsBaseVertex;
- glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex;
- glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex;
- glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex;
-
- // GL_ARB_provoking_vertex
- glProvokingVertex: TglProvokingVertex;
-
- // GL_ARB_sync
- glFenceSync: TglFenceSync;
- glIsSync: TglIsSync;
- glDeleteSync: TglDeleteSync;
- glClientWaitSync: TglClientWaitSync;
- glWaitSync: TglWaitSync;
- glGetInteger64v: TglGetInteger64v;
- glGetSynciv: TglGetSynciv;
-
- // GL_ARB_texture_multisample
- glTexImage2DMultisample: TglTexImage2DMultisample;
- glTexImage3DMultisample: TglTexImage3DMultisample;
- glGetMultisamplefv: TglGetMultisamplefv;
- glSampleMaski: TglSampleMaski;
-
- // GL_ARB_draw_buffers_blend
- glBlendEquationiARB: TglBlendEquationiARB;
- glBlendEquationSeparateiARB: TglBlendEquationSeparateiARB;
- glBlendFunciARB: TglBlendFunciARB;
- glBlendFuncSeparateiARB: TglBlendFuncSeparateiARB;
-
- // GL_ARB_sample_shading
- glMinSampleShadingARB: TglMinSampleShadingARB;
-
- // GL_ARB_shading_language_include
- glNamedStringARB: TglNamedStringARB;
- glDeleteNamedStringARB: TglDeleteNamedStringARB;
- glCompileShaderIncludeARB: TglCompileShaderIncludeARB;
- glIsNamedStringARB: TglIsNamedStringARB;
- glGetNamedStringARB: TglGetNamedStringARB;
- glGetNamedStringivARB: TglGetNamedStringivARB;
-
- // GL_ARB_blend_func_extended
- glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed;
- glGetFragDataIndex: TglGetFragDataIndex;
-
- // GL_ARB_sampler_objects
- glGenSamplers: TglGenSamplers;
- glDeleteSamplers: TglDeleteSamplers;
- glIsSampler: TglIsSampler;
- glBindSampler: TglBindSampler;
- glSamplerParameteri: TglSamplerParameteri;
- glSamplerParameteriv: TglSamplerParameteriv;
- glSamplerParameterf: TglSamplerParameterf;
- glSamplerParameterfv: TglSamplerParameterfv;
- glSamplerParameterIiv: TglSamplerParameterIiv;
- glSamplerParameterIuiv: TglSamplerParameterIuiv;
- glGetSamplerParameteriv: TglGetSamplerParameteriv;
- glGetSamplerParameterIiv: TglGetSamplerParameterIiv;
- glGetSamplerParameterfv: TglGetSamplerParameterfv;
- glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv;
-
- // GL_ARB_timer_query
- glQueryCounter: TglQueryCounter;
- glGetQueryObjecti64v: TglGetQueryObjecti64v;
- glGetQueryObjectui64v: TglGetQueryObjectui64v;
-
- // GL_ARB_vertex_type_2_10_10_10_rev
- glVertexP2ui: TglVertexP2ui;
- glVertexP2uiv: TglVertexP2uiv;
- glVertexP3ui: TglVertexP3ui;
- glVertexP3uiv: TglVertexP3uiv;
- glVertexP4ui: TglVertexP4ui;
- glVertexP4uiv: TglVertexP4uiv;
- glTexCoordP1ui: TglTexCoordP1ui;
- glTexCoordP1uiv: TglTexCoordP1uiv;
- glTexCoordP2ui: TglTexCoordP2ui;
- glTexCoordP2uiv: TglTexCoordP2uiv;
- glTexCoordP3ui: TglTexCoordP3ui;
- glTexCoordP3uiv: TglTexCoordP3uiv;
- glTexCoordP4ui: TglTexCoordP4ui;
- glTexCoordP4uiv: TglTexCoordP4uiv;
- glMultiTexCoordP1ui: TglMultiTexCoordP1ui;
- glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv;
- glMultiTexCoordP2ui: TglMultiTexCoordP2ui;
- glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv;
- glMultiTexCoordP3ui: TglMultiTexCoordP3ui;
- glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv;
- glMultiTexCoordP4ui: TglMultiTexCoordP4ui;
- glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv;
- glNormalP3ui: TglNormalP3ui;
- glNormalP3uiv: TglNormalP3uiv;
- glColorP3ui: TglColorP3ui;
- glColorP3uiv: TglColorP3uiv;
- glColorP4ui: TglColorP4ui;
- glColorP4uiv: TglColorP4uiv;
- glSecondaryColorP3ui: TglSecondaryColorP3ui;
- glSecondaryColorP3uiv: TglSecondaryColorP3uiv;
- glVertexAttribP1ui: TglVertexAttribP1ui;
- glVertexAttribP1uiv: TglVertexAttribP1uiv;
- glVertexAttribP2ui: TglVertexAttribP2ui;
- glVertexAttribP2uiv: TglVertexAttribP2uiv;
- glVertexAttribP3ui: TglVertexAttribP3ui;
- glVertexAttribP3uiv: TglVertexAttribP3uiv;
- glVertexAttribP4ui: TglVertexAttribP4ui;
- glVertexAttribP4uiv: TglVertexAttribP4uiv;
-
- // GL_ARB_draw_indirect
- glDrawArraysIndirect: TglDrawArraysIndirect;
- glDrawElementsIndirect: TglDrawElementsIndirect;
-
- // GL_ARB_gpu_shader_fp64
- glUniform1d: TglUniform1d;
- glUniform2d: TglUniform2d;
- glUniform3d: TglUniform3d;
- glUniform4d: TglUniform4d;
- glUniform1dv: TglUniform1dv;
- glUniform2dv: TglUniform2dv;
- glUniform3dv: TglUniform3dv;
- glUniform4dv: TglUniform4dv;
- glUniformMatrix2dv: TglUniformMatrix2dv;
- glUniformMatrix3dv: TglUniformMatrix3dv;
- glUniformMatrix4dv: TglUniformMatrix4dv;
- glUniformMatrix2x3dv: TglUniformMatrix2x3dv;
- glUniformMatrix2x4dv: TglUniformMatrix2x4dv;
- glUniformMatrix3x2dv: TglUniformMatrix3x2dv;
- glUniformMatrix3x4dv: TglUniformMatrix3x4dv;
- glUniformMatrix4x2dv: TglUniformMatrix4x2dv;
- glUniformMatrix4x3dv: TglUniformMatrix4x3dv;
- glGetUniformdv: TglGetUniformdv;
-
- // GL_ARB_shader_subroutine
- glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation;
- glGetSubroutineIndex: TglGetSubroutineIndex;
- glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv;
- glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName;
- glGetActiveSubroutineName: TglGetActiveSubroutineName;
- glUniformSubroutinesuiv: TglUniformSubroutinesuiv;
- glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv;
- glGetProgramStageiv: TglGetProgramStageiv;
-
- // GL_ARB_tessellation_shader
- glPatchParameteri: TglPatchParameteri;
- glPatchParameterfv: TglPatchParameterfv;
-
- // GL_ARB_transform_feedback2
- glBindTransformFeedback: TglBindTransformFeedback;
- glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks;
- glGenTransformFeedbacks: TglGenTransformFeedbacks;
- glIsTransformFeedback: TglIsTransformFeedback;
- glPauseTransformFeedback: TglPauseTransformFeedback;
- glResumeTransformFeedback: TglResumeTransformFeedback;
- glDrawTransformFeedback: TglDrawTransformFeedback;
-
- // GL_ARB_transform_feedback3
- glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream;
- glBeginQueryIndexed: TglBeginQueryIndexed;
- glEndQueryIndexed: TglEndQueryIndexed;
- glGetQueryIndexediv: TglGetQueryIndexediv;
-
- // GL_ARB_ES2_compatibility
- glReleaseShaderCompiler: TglReleaseShaderCompiler;
- glShaderBinary: TglShaderBinary;
- glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat;
- glDepthRangef: TglDepthRangef;
- glClearDepthf: TglClearDepthf;
-
- // GL_ARB_get_program_binary
- glGetProgramBinary: TglGetProgramBinary;
- glProgramBinary: TglProgramBinary;
- glProgramParameteri: TglProgramParameteri;
-
- // GL_ARB_separate_shader_objects
- glUseProgramStages: TglUseProgramStages;
- glActiveShaderProgram: TglActiveShaderProgram;
- glCreateShaderProgramv: TglCreateShaderProgramv;
- glBindProgramPipeline: TglBindProgramPipeline;
- glDeleteProgramPipelines: TglDeleteProgramPipelines;
- glGenProgramPipelines: TglGenProgramPipelines;
- glIsProgramPipeline: TglIsProgramPipeline;
- glGetProgramPipelineiv: TglGetProgramPipelineiv;
- glProgramUniform1i: TglProgramUniform1i;
- glProgramUniform1iv: TglProgramUniform1iv;
- glProgramUniform1f: TglProgramUniform1f;
- glProgramUniform1fv: TglProgramUniform1fv;
- glProgramUniform1d: TglProgramUniform1d;
- glProgramUniform1dv: TglProgramUniform1dv;
- glProgramUniform1ui: TglProgramUniform1ui;
- glProgramUniform1uiv: TglProgramUniform1uiv;
- glProgramUniform2i: TglProgramUniform2i;
- glProgramUniform2iv: TglProgramUniform2iv;
- glProgramUniform2f: TglProgramUniform2f;
- glProgramUniform2fv: TglProgramUniform2fv;
- glProgramUniform2d: TglProgramUniform2d;
- glProgramUniform2dv: TglProgramUniform2dv;
- glProgramUniform2ui: TglProgramUniform2ui;
- glProgramUniform2uiv: TglProgramUniform2uiv;
- glProgramUniform3i: TglProgramUniform3i;
- glProgramUniform3iv: TglProgramUniform3iv;
- glProgramUniform3f: TglProgramUniform3f;
- glProgramUniform3fv: TglProgramUniform3fv;
- glProgramUniform3d: TglProgramUniform3d;
- glProgramUniform3dv: TglProgramUniform3dv;
- glProgramUniform3ui: TglProgramUniform3ui;
- glProgramUniform3uiv: TglProgramUniform3uiv;
- glProgramUniform4i: TglProgramUniform4i;
- glProgramUniform4iv: TglProgramUniform4iv;
- glProgramUniform4f: TglProgramUniform4f;
- glProgramUniform4fv: TglProgramUniform4fv;
- glProgramUniform4d: TglProgramUniform4d;
- glProgramUniform4dv: TglProgramUniform4dv;
- glProgramUniform4ui: TglProgramUniform4ui;
- glProgramUniform4uiv: TglProgramUniform4uiv;
- glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv;
- glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv;
- glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv;
- glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv;
- glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv;
- glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv;
- glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv;
- glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv;
- glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv;
- glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv;
- glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv;
- glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv;
- glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv;
- glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv;
- glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv;
- glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv;
- glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv;
- glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv;
- glValidateProgramPipeline: TglValidateProgramPipeline;
- glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog;
-
- // GL_ARB_vertex_attrib_64bit
- glVertexAttribL1d: TglVertexAttribL1d;
- glVertexAttribL2d: TglVertexAttribL2d;
- glVertexAttribL3d: TglVertexAttribL3d;
- glVertexAttribL4d: TglVertexAttribL4d;
- glVertexAttribL1dv: TglVertexAttribL1dv;
- glVertexAttribL2dv: TglVertexAttribL2dv;
- glVertexAttribL3dv: TglVertexAttribL3dv;
- glVertexAttribL4dv: TglVertexAttribL4dv;
- glVertexAttribLPointer: TglVertexAttribLPointer;
- glGetVertexAttribLdv: TglGetVertexAttribLdv;
-
- // GL_ARB_viewport_array
- glViewportArrayv: TglViewportArrayv;
- glViewportIndexedf: TglViewportIndexedf;
- glViewportIndexedfv: TglViewportIndexedfv;
- glScissorArrayv: TglScissorArrayv;
- glScissorIndexed: TglScissorIndexed;
- glScissorIndexedv: TglScissorIndexedv;
- glDepthRangeArrayv: TglDepthRangeArrayv;
- glDepthRangeIndexed: TglDepthRangeIndexed;
- glGetFloati_v: TglGetFloati_v;
- glGetDoublei_v: TglGetDoublei_v;
-
- // GL 4.2
-
- // GL_ARB_base_instance
- glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance;
- glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance;
- glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance;
-
- // GL_ARB_transform_feedback_instanced
- glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced;
- glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced;
-
- // GL_ARB_internalformat_query
- glGetInternalformativ : TglGetInternalformativ;
-
- // GL_ARB_shader_atomic_counters
- glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv;
-
- /// GL_ARB_shader_image_load_store
- glBindImageTexture : TglBindImageTexture;
- glMemoryBarrier : TglMemoryBarrier;
-
- // GL_ARB_texture_storage
- glTexStorage1D : TglTexStorage1D;
- glTexStorage2D : TglTexStorage2D;
- glTexStorage3D : TglTexStorage3D;
- glTextureStorage1DEXT : TglTextureStorage1DEXT;
- glTextureStorage2DEXT : TglTextureStorage2DEXT;
- glTextureStorage3DEXT : TglTextureStorage3DEXT;
-
-
- // GL 4.3
- // GL_KHR_debug
- glDebugMessageControl : TglDebugMessageControl;
- glDebugMessageInsert : TglDebugMessageInsert;
- glDebugMessageCallback : TglDebugMessageCallback;
- glGetDebugMessageLog : TglGetDebugMessageLog;
- glPushDebugGroup : TglPushDebugGroup;
- glPopDebugGroup : TglPopDebugGroup;
- glObjectLabel : TglObjectLabel;
- glGetObjectLabel : TglGetObjectLabel;
- glObjectPtrLabel : TglObjectPtrLabel;
- glGetObjectPtrLabel : TglGetObjectPtrLabel;
- // GL_ARB_clear_buffer_object
- glClearBufferData : TglClearBufferData;
- glClearBufferSubData : TglClearBufferSubData;
- glClearNamedBufferDataEXT : TglClearNamedBufferDataEXT;
- glClearNamedBufferSubDataEXT : TglClearNamedBufferSubDataEXT;
- // GL_ARB_compute_shader
- glDispatchCompute : TglDispatchCompute;
- glDispatchComputeIndirect : TglDispatchComputeIndirect;
- // GL_ARB_copy_image
- glCopyImageSubData : TglCopyImageSubData;
- // GL_ARB_framebuffer_no_attachments
- glFramebufferParameteri : TglFramebufferParameteri;
- glGetFramebufferParameteriv : TglGetFramebufferParameteriv;
- glNamedFramebufferParameteriEXT : TglNamedFramebufferParameteriEXT;
- glGetNamedFramebufferParameterivEXT : TglGetNamedFramebufferParameterivEXT;
- // GL_ARB_internalformat_query2
- glGetInternalformati64v : TglGetInternalformati64v;
- // GL_ARB_invalidate_subdata
- glInvalidateTexSubImage : TglInvalidateTexSubImage;
- glInvalidateTexImage : TglInvalidateTexImage;
- glInvalidateBufferSubData : TglInvalidateBufferSubData;
- glInvalidateBufferData : TglInvalidateBufferData;
- glInvalidateFramebuffer : TglInvalidateFramebuffer;
- glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer;
- // GL_ARB_multi_draw_indirect
- glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect;
- glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect;
- // GL_ARB_program_interface_query
- glGetProgramInterfaceiv : TglGetProgramInterfaceiv;
- glGetProgramResourceIndex : TglGetProgramResourceIndex;
- glGetProgramResourceName : TglGetProgramResourceName;
- glGetProgramResourceiv : TglGetProgramResourceiv;
- glGetProgramResourceLocation : TglGetProgramResourceLocation;
- glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex;
- // GL_ARB_shader_storage_buffer_object
- glShaderStorageBlockBinding : TglShaderStorageBlockBinding;
- // GL_ARB_texture_buffer_range
- glTexBufferRange : TglTexBufferRange;
- glTextureBufferRangeEXT : TglTextureBufferRangeEXT;
- // GL_ARB_texture_storage_multisample
- glTexStorage2DMultisample : TglTexStorage2DMultisample;
- glTexStorage3DMultisample : TglTexStorage3DMultisample;
- glTextureStorage2DMultisampleEXT : TglTextureStorage2DMultisampleEXT;
- glTextureStorage3DMultisampleEXT : TglTextureStorage3DMultisampleEXT;
- // GL_ARB_texture_view
- glTextureView : TglTextureView;
- // GL_ARB_vertex_attrib_binding
- glBindVertexBuffer : TglBindVertexBuffer;
- glVertexAttribFormat : TglVertexAttribFormat;
- glVertexAttribIFormat : TglVertexAttribIFormat;
- glVertexAttribLFormat : TglVertexAttribLFormat;
- glVertexAttribBinding : TglVertexAttribBinding;
- glVertexBindingDivisor : TglVertexBindingDivisor;
- glVertexArrayBindVertexBufferEXT : TglVertexArrayBindVertexBufferEXT;
- glVertexArrayVertexAttribFormatEXT : TglVertexArrayVertexAttribFormatEXT;
- glVertexArrayVertexAttribIFormatEXT : TglVertexArrayVertexAttribIFormatEXT;
- glVertexArrayVertexAttribLFormatEXT : TglVertexArrayVertexAttribLFormatEXT;
- glVertexArrayVertexAttribBindingEXT : TglVertexArrayVertexAttribBindingEXT;
- glVertexArrayVertexBindingDivisorEXT : TglVertexArrayVertexBindingDivisorEXT;
- // END GL 4.3
-
-
- // GL 4.4
- glBufferStorage : TglBufferStorage;
- glClearTexImage : TglClearTexImage;
- glClearTexSubImage : TglClearTexSubImage;
- glBindBuffersBase : TglBindBuffersBase;
- glBindBuffersRange : TglBindBuffersRange;
- glBindTextures : TglBindTextures;
- glBindSamplers : TglBindSamplers;
- glBindImageTextures : TglBindImageTextures;
- glBindVertexBuffers : TglBindVertexBuffers;
- // END GL 4.4
-
-
- // GL_ARB_cl_event
- glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB;
-
- // GL_ARB_debug_output
- glDebugMessageControlARB: TglDebugMessageControlARB;
- glDebugMessageInsertARB: TglDebugMessageInsertARB;
- glDebugMessageCallbackARB: TglDebugMessageCallbackARB;
- glGetDebugMessageLogARB: TglGetDebugMessageLogARB;
-
- // GL_ARB_robustness
- glGetGraphicsResetStatusARB: TglGetGraphicsResetStatusARB;
- glGetnMapdvARB: TglGetnMapdvARB;
- glGetnMapfvARB: TglGetnMapfvARB;
- glGetnMapivARB: TglGetnMapivARB;
- glGetnPixelMapfvARB: TglGetnPixelMapfvARB;
- glGetnPixelMapuivARB: TglGetnPixelMapuivARB;
- glGetnPixelMapusvARB: TglGetnPixelMapusvARB;
- glGetnPolygonStippleARB: TglGetnPolygonStippleARB;
- glGetnColorTableARB: TglGetnColorTableARB;
- glGetnConvolutionFilterARB: TglGetnConvolutionFilterARB;
- glGetnSeparableFilterARB: TglGetnSeparableFilterARB;
- glGetnHistogramARB: TglGetnHistogramARB;
- glGetnMinmaxARB: TglGetnMinmaxARB;
- glGetnTexImageARB: TglGetnTexImageARB;
- glReadnPixelsARB: TglReadnPixelsARB;
- glGetnCompressedTexImageARB: TglGetnCompressedTexImageARB;
- glGetnUniformfvARB: TglGetnUniformfvARB;
- glGetnUniformivARB: TglGetnUniformivARB;
- glGetnUniformuivARB: TglGetnUniformuivARB;
- glGetnUniformdvARB: TglGetnUniformdvARB;
-
- // GL_ATI_draw_buffers
- glDrawBuffersATI: TglDrawBuffersATI;
-
- // GL_ATI_element_array
- glElementPointerATI: TglElementPointerATI;
- glDrawElementArrayATI: TglDrawElementArrayATI;
- glDrawRangeElementArrayATI: TglDrawRangeElementArrayATI;
-
- // GL_ATI_envmap_bumpmap
- glTexBumpParameterivATI: TglTexBumpParameterivATI;
- glTexBumpParameterfvATI: TglTexBumpParameterfvATI;
- glGetTexBumpParameterivATI: TglGetTexBumpParameterivATI;
- glGetTexBumpParameterfvATI: TglGetTexBumpParameterfvATI;
-
- // GL_ATI_fragment_shader
- glGenFragmentShadersATI: TglGenFragmentShadersATI;
- glBindFragmentShaderATI: TglBindFragmentShaderATI;
- glDeleteFragmentShaderATI: TglDeleteFragmentShaderATI;
- glBeginFragmentShaderATI: TglBeginFragmentShaderATI;
- glEndFragmentShaderATI: TglEndFragmentShaderATI;
- glPassTexCoordATI: TglPassTexCoordATI;
- glSampleMapATI: TglSampleMapATI;
- glColorFragmentOp1ATI: TglColorFragmentOp1ATI;
- glColorFragmentOp2ATI: TglColorFragmentOp2ATI;
- glColorFragmentOp3ATI: TglColorFragmentOp3ATI;
- glAlphaFragmentOp1ATI: TglAlphaFragmentOp1ATI;
- glAlphaFragmentOp2ATI: TglAlphaFragmentOp2ATI;
- glAlphaFragmentOp3ATI: TglAlphaFragmentOp3ATI;
- glSetFragmentShaderConstantATI: TglSetFragmentShaderConstantATI;
-
- // GL_ATI_map_object_buffer
- glMapObjectBufferATI: TglMapObjectBufferATI;
- glUnmapObjectBufferATI: TglUnmapObjectBufferATI;
-
- // GL_ATI_pn_triangles
- glPNTrianglesiATI: TglPNTrianglesiATI;
- glPNTrianglesfATI: TglPNTrianglesfATI;
-
- // GL_ATI_separate_stencil
- glStencilOpSeparateATI: TglStencilOpSeparateATI;
- glStencilFuncSeparateATI: TglStencilFuncSeparateATI;
-
- // GL_ATI_vertex_array_object
- glNewObjectBufferATI: TglNewObjectBufferATI;
- glIsObjectBufferATI: TglIsObjectBufferATI;
- glUpdateObjectBufferATI: TglUpdateObjectBufferATI;
- glGetObjectBufferfvATI: TglGetObjectBufferfvATI;
- glGetObjectBufferivATI: TglGetObjectBufferivATI;
- glFreeObjectBufferATI: TglFreeObjectBufferATI;
- glArrayObjectATI: TglArrayObjectATI;
- glGetArrayObjectfvATI: TglGetArrayObjectfvATI;
- glGetArrayObjectivATI: TglGetArrayObjectivATI;
- glVariantArrayObjectATI: TglVariantArrayObjectATI;
- glGetVariantArrayObjectfvATI: TglGetVariantArrayObjectfvATI;
- glGetVariantArrayObjectivATI: TglGetVariantArrayObjectivATI;
- glVertexAttribArrayObjectATI: TglVertexAttribArrayObjectATI;
- glGetVertexAttribArrayObjectfvATI: TglGetVertexAttribArrayObjectfvATI;
- glGetVertexAttribArrayObjectivATI: TglGetVertexAttribArrayObjectivATI;
-
- // GL_ATI_vertex_streams
- glVertexStream1sATI: TglVertexStream1sATI;
- glVertexStream1svATI: TglVertexStream1svATI;
- glVertexStream1iATI: TglVertexStream1iATI;
- glVertexStream1ivATI: TglVertexStream1ivATI;
- glVertexStream1fATI: TglVertexStream1fATI;
- glVertexStream1fvATI: TglVertexStream1fvATI;
- glVertexStream1dATI: TglVertexStream1dATI;
- glVertexStream1dvATI: TglVertexStream1dvATI;
- glVertexStream2sATI: TglVertexStream2sATI;
- glVertexStream2svATI: TglVertexStream2svATI;
- glVertexStream2iATI: TglVertexStream2iATI;
- glVertexStream2ivATI: TglVertexStream2ivATI;
- glVertexStream2fATI: TglVertexStream2fATI;
- glVertexStream2fvATI: TglVertexStream2fvATI;
- glVertexStream2dATI: TglVertexStream2dATI;
- glVertexStream2dvATI: TglVertexStream2dvATI;
- glVertexStream3sATI: TglVertexStream3sATI;
- glVertexStream3svATI: TglVertexStream3svATI;
- glVertexStream3iATI: TglVertexStream3iATI;
- glVertexStream3ivATI: TglVertexStream3ivATI;
- glVertexStream3fATI: TglVertexStream3fATI;
- glVertexStream3fvATI: TglVertexStream3fvATI;
- glVertexStream3dATI: TglVertexStream3dATI;
- glVertexStream3dvATI: TglVertexStream3dvATI;
- glVertexStream4sATI: TglVertexStream4sATI;
- glVertexStream4svATI: TglVertexStream4svATI;
- glVertexStream4iATI: TglVertexStream4iATI;
- glVertexStream4ivATI: TglVertexStream4ivATI;
- glVertexStream4fATI: TglVertexStream4fATI;
- glVertexStream4fvATI: TglVertexStream4fvATI;
- glVertexStream4dATI: TglVertexStream4dATI;
- glVertexStream4dvATI: TglVertexStream4dvATI;
- glNormalStream3bATI: TglNormalStream3bATI;
- glNormalStream3bvATI: TglNormalStream3bvATI;
- glNormalStream3sATI: TglNormalStream3sATI;
- glNormalStream3svATI: TglNormalStream3svATI;
- glNormalStream3iATI: TglNormalStream3iATI;
- glNormalStream3ivATI: TglNormalStream3ivATI;
- glNormalStream3fATI: TglNormalStream3fATI;
- glNormalStream3fvATI: TglNormalStream3fvATI;
- glNormalStream3dATI: TglNormalStream3dATI;
- glNormalStream3dvATI: TglNormalStream3dvATI;
- glClientActiveVertexStreamATI: TglClientActiveVertexStreamATI;
- glVertexBlendEnviATI: TglVertexBlendEnviATI;
- glVertexBlendEnvfATI: TglVertexBlendEnvfATI;
-
- // GL_AMD_performance_monitor
- glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD;
- glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD;
- glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD;
- glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD;
- glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD;
- glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD;
- glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD;
- glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD;
- glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD;
- glEndPerfMonitorAMD: TglEndPerfMonitorAMD;
- glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD;
-
- // GL_AMD_vertex_shader_tesselator
- glTessellationFactorAMD: TglTessellationFactorAMD;
- glTessellationModeAMD: TglTessellationModeAMD;
-
- // GL_AMD_draw_buffers_blend
- glBlendFuncIndexedAMD: TglBlendFuncIndexedAMD;
- glBlendFuncSeparateIndexedAMD: TglBlendFuncSeparateIndexedAMD;
- glBlendEquationIndexedAMD: TglBlendEquationIndexedAMD;
- glBlendEquationSeparateIndexedAMD: TglBlendEquationSeparateIndexedAMD;
-
- // GL_AMD_name_gen_delete
- glGenNamesAMD: TglGenNamesAMD;
- glDeleteNamesAMD: TglDeleteNamesAMD;
- glIsNameAMD: TglIsNameAMD;
-
- // GL_AMD_debug_output
- glDebugMessageEnableAMD: TglDebugMessageEnableAMD;
- glDebugMessageInsertAMD: TglDebugMessageInsertAMD;
- glDebugMessageCallbackAMD: TglDebugMessageCallbackAMD;
- glGetDebugMessageLogAMD: TglGetDebugMessageLogAMD;
-
- // GL_EXT_blend_color
- glBlendColorEXT: TglBlendColorEXT;
-
- // GL_EXT_blend_func_separate
- glBlendFuncSeparateEXT: TglBlendFuncSeparateEXT;
-
- // GL_EXT_blend_minmax
- glBlendEquationEXT: TglBlendEquationEXT;
-
- // GL_EXT_color_subtable
- glColorSubTableEXT: TglColorSubTableEXT;
- glCopyColorSubTableEXT: TglCopyColorSubTableEXT;
-
- // GL_EXT_compiled_vertex_array
- glLockArraysEXT: TglLockArraysEXT;
- glUnlockArraysEXT: TglUnlockArraysEXT;
-
- // GL_EXT_convolution
- glConvolutionFilter1DEXT: TglConvolutionFilter1DEXT;
- glConvolutionFilter2DEXT: TglConvolutionFilter2DEXT;
- glConvolutionParameterfEXT: TglConvolutionParameterfEXT;
- glConvolutionParameterfvEXT: TglConvolutionParameterfvEXT;
- glConvolutionParameteriEXT: TglConvolutionParameteriEXT;
- glConvolutionParameterivEXT: TglConvolutionParameterivEXT;
- glCopyConvolutionFilter1DEXT: TglCopyConvolutionFilter1DEXT;
- glCopyConvolutionFilter2DEXT: TglCopyConvolutionFilter2DEXT;
- glGetConvolutionFilterEXT: TglGetConvolutionFilterEXT;
- glGetConvolutionParameterfvEXT: TglGetConvolutionParameterfvEXT;
- glGetConvolutionParameterivEXT: TglGetConvolutionParameterivEXT;
- glGetSeparableFilterEXT: TglGetSeparableFilterEXT;
- glSeparableFilter2DEXT: TglSeparableFilter2DEXT;
-
- // GL_EXT_coordinate_frame
- glTangent3bEXT: TglTangent3bEXT;
- glTangent3bvEXT: TglTangent3bvEXT;
- glTangent3dEXT: TglTangent3dEXT;
- glTangent3dvEXT: TglTangent3dvEXT;
- glTangent3fEXT: TglTangent3fEXT;
- glTangent3fvEXT: TglTangent3fvEXT;
- glTangent3iEXT: TglTangent3iEXT;
- glTangent3ivEXT: TglTangent3ivEXT;
- glTangent3sEXT: TglTangent3sEXT;
- glTangent3svEXT: TglTangent3svEXT;
- glBinormal3bEXT: TglBinormal3bEXT;
- glBinormal3bvEXT: TglBinormal3bvEXT;
- glBinormal3dEXT: TglBinormal3dEXT;
- glBinormal3dvEXT: TglBinormal3dvEXT;
- glBinormal3fEXT: TglBinormal3fEXT;
- glBinormal3fvEXT: TglBinormal3fvEXT;
- glBinormal3iEXT: TglBinormal3iEXT;
- glBinormal3ivEXT: TglBinormal3ivEXT;
- glBinormal3sEXT: TglBinormal3sEXT;
- glBinormal3svEXT: TglBinormal3svEXT;
- glTangentPointerEXT: TglTangentPointerEXT;
- glBinormalPointerEXT: TglBinormalPointerEXT;
-
- // GL_EXT_copy_texture
- glCopyTexImage1DEXT: TglCopyTexImage1DEXT;
- glCopyTexImage2DEXT: TglCopyTexImage2DEXT;
- glCopyTexSubImage1DEXT: TglCopyTexSubImage1DEXT;
- glCopyTexSubImage2DEXT: TglCopyTexSubImage2DEXT;
- glCopyTexSubImage3DEXT: TglCopyTexSubImage3DEXT;
-
- // GL_EXT_cull_vertex
- glCullParameterdvEXT: TglCullParameterdvEXT;
- glCullParameterfvEXT: TglCullParameterfvEXT;
-
- // GL_EXT_draw_range_elements
- glDrawRangeElementsEXT: TglDrawRangeElementsEXT;
-
- // GL_EXT_fog_coord
- glFogCoordfEXT: TglFogCoordfEXT;
- glFogCoordfvEXT: TglFogCoordfvEXT;
- glFogCoorddEXT: TglFogCoorddEXT;
- glFogCoorddvEXT: TglFogCoorddvEXT;
- glFogCoordPointerEXT: TglFogCoordPointerEXT;
-
- // GL_EXT_framebuffer_object
- glIsRenderbufferEXT: TglIsRenderbufferEXT;
- glBindRenderbufferEXT: TglBindRenderbufferEXT;
- glDeleteRenderbuffersEXT: TglDeleteRenderbuffersEXT;
- glGenRenderbuffersEXT: TglGenRenderbuffersEXT;
- glRenderbufferStorageEXT: TglRenderbufferStorageEXT;
- glGetRenderbufferParameterivEXT: TglGetRenderbufferParameterivEXT;
- glIsFramebufferEXT: TglIsFramebufferEXT;
- glBindFramebufferEXT: TglBindFramebufferEXT;
- glDeleteFramebuffersEXT: TglDeleteFramebuffersEXT;
- glGenFramebuffersEXT: TglGenFramebuffersEXT;
- glCheckFramebufferStatusEXT: TglCheckFramebufferStatusEXT;
- glFramebufferTexture1DEXT: TglFramebufferTexture1DEXT;
- glFramebufferTexture2DEXT: TglFramebufferTexture2DEXT;
- glFramebufferTexture3DEXT: TglFramebufferTexture3DEXT;
- glFramebufferRenderbufferEXT: TglFramebufferRenderbufferEXT;
- glGetFramebufferAttachmentParameterivEXT: TglGetFramebufferAttachmentParameterivEXT;
- glGenerateMipmapEXT: TglGenerateMipmapEXT;
-
- // GL_EXT_histogram
- glGetHistogramEXT: TglGetHistogramEXT;
- glGetHistogramParameterfvEXT: TglGetHistogramParameterfvEXT;
- glGetHistogramParameterivEXT: TglGetHistogramParameterivEXT;
- glGetMinmaxEXT: TglGetMinmaxEXT;
- glGetMinmaxParameterfvEXT: TglGetMinmaxParameterfvEXT;
- glGetMinmaxParameterivEXT: TglGetMinmaxParameterivEXT;
- glHistogramEXT: TglHistogramEXT;
- glMinmaxEXT: TglMinmaxEXT;
- glResetHistogramEXT: TglResetHistogramEXT;
- glResetMinmaxEXT: TglResetMinmaxEXT;
-
- // GL_EXT_index_func
- glIndexFuncEXT: TglIndexFuncEXT;
-
- // GL_EXT_index_material
- glIndexMaterialEXT: TglIndexMaterialEXT;
-
- // GL_EXT_light_texture
- glApplyTextureEXT: TglApplyTextureEXT;
- glTextureLightEXT: TglTextureLightEXT;
- glTextureMaterialEXT: TglTextureMaterialEXT;
-
- // GL_EXT_multi_draw_arrays
- glMultiDrawArraysEXT: TglMultiDrawArraysEXT;
- glMultiDrawElementsEXT: TglMultiDrawElementsEXT;
-
- // GL_EXT_multisample
- glSampleMaskEXT: TglSampleMaskEXT;
- glSamplePatternEXT: TglSamplePatternEXT;
-
- // GL_EXT_paletted_texture
- glColorTableEXT: TglColorTableEXT;
- glGetColorTableEXT: TglGetColorTableEXT;
- glGetColorTableParameterivEXT: TglGetColorTableParameterivEXT;
- glGetColorTableParameterfvEXT: TglGetColorTableParameterfvEXT;
-
- // GL_EXT_pixel_transform
- glPixelTransformParameteriEXT: TglPixelTransformParameteriEXT;
- glPixelTransformParameterfEXT: TglPixelTransformParameterfEXT;
- glPixelTransformParameterivEXT: TglPixelTransformParameterivEXT;
- glPixelTransformParameterfvEXT: TglPixelTransformParameterfvEXT;
-
- // GL_EXT_point_parameters
- glPointParameterfEXT: TglPointParameterfEXT;
- glPointParameterfvEXT: TglPointParameterfvEXT;
-
- // GL_EXT_polygon_offset
- glPolygonOffsetEXT: TglPolygonOffsetEXT;
-
- // GL_EXT_secondary_color
- glSecondaryColor3bEXT: TglSecondaryColor3bEXT;
- glSecondaryColor3bvEXT: TglSecondaryColor3bvEXT;
- glSecondaryColor3dEXT: TglSecondaryColor3dEXT;
- glSecondaryColor3dvEXT: TglSecondaryColor3dvEXT;
- glSecondaryColor3fEXT: TglSecondaryColor3fEXT;
- glSecondaryColor3fvEXT: TglSecondaryColor3fvEXT;
- glSecondaryColor3iEXT: TglSecondaryColor3iEXT;
- glSecondaryColor3ivEXT: TglSecondaryColor3ivEXT;
- glSecondaryColor3sEXT: TglSecondaryColor3sEXT;
- glSecondaryColor3svEXT: TglSecondaryColor3svEXT;
- glSecondaryColor3ubEXT: TglSecondaryColor3ubEXT;
- glSecondaryColor3ubvEXT: TglSecondaryColor3ubvEXT;
- glSecondaryColor3uiEXT: TglSecondaryColor3uiEXT;
- glSecondaryColor3uivEXT: TglSecondaryColor3uivEXT;
- glSecondaryColor3usEXT: TglSecondaryColor3usEXT;
- glSecondaryColor3usvEXT: TglSecondaryColor3usvEXT;
- glSecondaryColorPointerEXT: TglSecondaryColorPointerEXT;
-
- // GL_EXT_stencil_two_side
- glActiveStencilFaceEXT: TglActiveStencilFaceEXT;
-
- // GL_EXT_subtexture
- glTexSubImage1DEXT: TglTexSubImage1DEXT;
- glTexSubImage2DEXT: TglTexSubImage2DEXT;
-
- // GL_EXT_texture3D
- glTexImage3DEXT: TglTexImage3DEXT;
- glTexSubImage3DEXT: TglTexSubImage3DEXT;
-
- // GL_EXT_texture_object
- glAreTexturesResidentEXT: TglAreTexturesResidentEXT;
- glBindTextureEXT: TglBindTextureEXT;
- glDeleteTexturesEXT: TglDeleteTexturesEXT;
- glGenTexturesEXT: TglGenTexturesEXT;
- glIsTextureEXT: TglIsTextureEXT;
- glPrioritizeTexturesEXT: TglPrioritizeTexturesEXT;
-
- // GL_EXT_texture_perturb_normal
- glTextureNormalEXT: TglTextureNormalEXT;
-
- // GL_EXT_vertex_array
- glArrayElementEXT: TglArrayElementEXT;
- glColorPointerEXT: TglColorPointerEXT;
- glDrawArraysEXT: TglDrawArraysEXT;
- glEdgeFlagPointerEXT: TglEdgeFlagPointerEXT;
- glGetPointervEXT: TglGetPointervEXT;
- glIndexPointerEXT: TglIndexPointerEXT;
- glNormalPointerEXT: TglNormalPointerEXT;
- glTexCoordPointerEXT: TglTexCoordPointerEXT;
- glVertexPointerEXT: TglVertexPointerEXT;
-
- // GL_EXT_vertex_shader
- glBeginVertexShaderEXT: TglBeginVertexShaderEXT;
- glEndVertexShaderEXT: TglEndVertexShaderEXT;
- glBindVertexShaderEXT: TglBindVertexShaderEXT;
- glGenVertexShadersEXT: TglGenVertexShadersEXT;
- glDeleteVertexShaderEXT: TglDeleteVertexShaderEXT;
- glShaderOp1EXT: TglShaderOp1EXT;
- glShaderOp2EXT: TglShaderOp2EXT;
- glShaderOp3EXT: TglShaderOp3EXT;
- glSwizzleEXT: TglSwizzleEXT;
- glWriteMaskEXT: TglWriteMaskEXT;
- glInsertComponentEXT: TglInsertComponentEXT;
- glExtractComponentEXT: TglExtractComponentEXT;
- glGenSymbolsEXT: TglGenSymbolsEXT;
- glSetInvariantEXT: TglSetInvariantEXT;
- glSetLocalConstantEXT: TglSetLocalConstantEXT;
- glVariantbvEXT: TglVariantbvEXT;
- glVariantsvEXT: TglVariantsvEXT;
- glVariantivEXT: TglVariantivEXT;
- glVariantfvEXT: TglVariantfvEXT;
- glVariantdvEXT: TglVariantdvEXT;
- glVariantubvEXT: TglVariantubvEXT;
- glVariantusvEXT: TglVariantusvEXT;
- glVariantuivEXT: TglVariantuivEXT;
- glVariantPointerEXT: TglVariantPointerEXT;
- glEnableVariantClientStateEXT: TglEnableVariantClientStateEXT;
- glDisableVariantClientStateEXT: TglDisableVariantClientStateEXT;
- glBindLightParameterEXT: TglBindLightParameterEXT;
- glBindMaterialParameterEXT: TglBindMaterialParameterEXT;
- glBindTexGenParameterEXT: TglBindTexGenParameterEXT;
- glBindTextureUnitParameterEXT: TglBindTextureUnitParameterEXT;
- glBindParameterEXT: TglBindParameterEXT;
- glIsVariantEnabledEXT: TglIsVariantEnabledEXT;
- glGetVariantBooleanvEXT: TglGetVariantBooleanvEXT;
- glGetVariantIntegervEXT: TglGetVariantIntegervEXT;
- glGetVariantFloatvEXT: TglGetVariantFloatvEXT;
- glGetVariantPointervEXT: TglGetVariantPointervEXT;
- glGetInvariantBooleanvEXT: TglGetInvariantBooleanvEXT;
- glGetInvariantIntegervEXT: TglGetInvariantIntegervEXT;
- glGetInvariantFloatvEXT: TglGetInvariantFloatvEXT;
- glGetLocalConstantBooleanvEXT: TglGetLocalConstantBooleanvEXT;
- glGetLocalConstantIntegervEXT: TglGetLocalConstantIntegervEXT;
- glGetLocalConstantFloatvEXT: TglGetLocalConstantFloatvEXT;
-
- // GL_EXT_vertex_weighting
- glVertexWeightfEXT: TglVertexWeightfEXT;
- glVertexWeightfvEXT: TglVertexWeightfvEXT;
- glVertexWeightPointerEXT: TglVertexWeightPointerEXT;
-
- // GL_EXT_stencil_clear_tag
- glStencilClearTagEXT: TglStencilClearTagEXT;
-
- // GL_EXT_framebuffer_blit
- glBlitFramebufferEXT: TglBlitFramebufferEXT;
-
- // GL_EXT_framebuffer_multisample
- glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT;
-
- // GL_EXT_timer_query
- glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT;
- glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT;
-
- // GL_EXT_gpu_program_parameters
- glProgramEnvParameters4fvEXT: TglProgramEnvParameters4fvEXT;
- glProgramLocalParameters4fvEXT: TglProgramLocalParameters4fvEXT;
-
- // GL_EXT_bindable_uniform
- glUniformBufferEXT: TglUniformBufferEXT;
- glGetUniformBufferSizeEXT: TglGetUniformBufferSizeEXT;
- glGetUniformOffsetEXT: TglGetUniformOffsetEXT;
-
- // GL_EXT_draw_buffers2
- glColorMaskIndexedEXT: TglColorMaskIndexedEXT;
- glGetBooleanIndexedvEXT: TglGetBooleanIndexedvEXT;
- glGetIntegerIndexedvEXT: TglGetIntegerIndexedvEXT;
- glEnableIndexedEXT: TglEnableIndexedEXT;
- glDisableIndexedEXT: TglDisableIndexedEXT;
- glIsEnabledIndexedEXT: TglIsEnabledIndexedEXT;
-
- // GL_EXT_draw_instanced
- glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT;
- glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT;
-
- // GL_EXT_geometry_shader4
- glProgramParameteriEXT: TglProgramParameteriEXT;
- glFramebufferTextureEXT: TglFramebufferTextureEXT;
-// glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
- glFramebufferTextureFaceEXT: TglFramebufferTextureFaceEXT;
-
- // GL_EXT_gpu_shader4
- glVertexAttribI1iEXT: TglVertexAttribI1iEXT;
- glVertexAttribI2iEXT: TglVertexAttribI2iEXT;
- glVertexAttribI3iEXT: TglVertexAttribI3iEXT;
- glVertexAttribI4iEXT: TglVertexAttribI4iEXT;
- glVertexAttribI1uiEXT: TglVertexAttribI1uiEXT;
- glVertexAttribI2uiEXT: TglVertexAttribI2uiEXT;
- glVertexAttribI3uiEXT: TglVertexAttribI3uiEXT;
- glVertexAttribI4uiEXT: TglVertexAttribI4uiEXT;
- glVertexAttribI1ivEXT: TglVertexAttribI1ivEXT;
- glVertexAttribI2ivEXT: TglVertexAttribI2ivEXT;
- glVertexAttribI3ivEXT: TglVertexAttribI3ivEXT;
- glVertexAttribI4ivEXT: TglVertexAttribI4ivEXT;
- glVertexAttribI1uivEXT: TglVertexAttribI1uivEXT;
- glVertexAttribI2uivEXT: TglVertexAttribI2uivEXT;
- glVertexAttribI3uivEXT: TglVertexAttribI3uivEXT;
- glVertexAttribI4uivEXT: TglVertexAttribI4uivEXT;
- glVertexAttribI4bvEXT: TglVertexAttribI4bvEXT;
- glVertexAttribI4svEXT: TglVertexAttribI4svEXT;
- glVertexAttribI4ubvEXT: TglVertexAttribI4ubvEXT;
- glVertexAttribI4usvEXT: TglVertexAttribI4usvEXT;
- glVertexAttribIPointerEXT: TglVertexAttribIPointerEXT;
- glGetVertexAttribIivEXT: TglGetVertexAttribIivEXT;
- glGetVertexAttribIuivEXT: TglGetVertexAttribIuivEXT;
- glUniform1uiEXT: TglUniform1uiEXT;
- glUniform2uiEXT: TglUniform2uiEXT;
- glUniform3uiEXT: TglUniform3uiEXT;
- glUniform4uiEXT: TglUniform4uiEXT;
- glUniform1uivEXT: TglUniform1uivEXT;
- glUniform2uivEXT: TglUniform2uivEXT;
- glUniform3uivEXT: TglUniform3uivEXT;
- glUniform4uivEXT: TglUniform4uivEXT;
- glGetUniformuivEXT: TglGetUniformuivEXT;
- glBindFragDataLocationEXT: TglBindFragDataLocationEXT;
- glGetFragDataLocationEXT: TglGetFragDataLocationEXT;
-
- // GL_EXT_texture_array
- glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
-
- // GL_EXT_texture_buffer_object
- glTexBufferEXT: TglTexBufferEXT;
-
- // GL_EXT_texture_integer
- glClearColorIiEXT: TglClearColorIiEXT;
- glClearColorIuiEXT: TglClearColorIuiEXT;
- glTexParameterIivEXT: TglTexParameterIivEXT;
- glTexParameterIuivEXT: TglTexParameterIuivEXT;
- glGetTexParameterIivEXT: TglGetTexParameterIivEXT;
- glGetTexParameterIiuvEXT: TglGetTexParameterIiuvEXT;
-
- // GL_EXT_transform_feedback
- glBeginTransformFeedbackEXT: TglBeginTransformFeedbackEXT;
- glEndTransformFeedbackEXT: TglEndTransformFeedbackEXT;
- glBindBufferRangeEXT: TglBindBufferRangeEXT;
- glBindBufferOffsetEXT: TglBindBufferOffsetEXT;
- glBindBufferBaseEXT: TglBindBufferBaseEXT;
- glTransformFeedbackVaryingsEXT: TglTransformFeedbackVaryingsEXT;
- glGetTransformFeedbackVaryingEXT: TglGetTransformFeedbackVaryingEXT;
-
- // GL_EXT_direct_state_access
- glClientAttribDefaultEXT: TglClientAttribDefaultEXT;
- glPushClientAttribDefaultEXT: TglPushClientAttribDefaultEXT;
- glMatrixLoadfEXT: TglMatrixLoadfEXT;
- glMatrixLoaddEXT: TglMatrixLoaddEXT;
- glMatrixMultfEXT: TglMatrixMultfEXT;
- glMatrixMultdEXT: TglMatrixMultdEXT;
- glMatrixLoadIdentityEXT: TglMatrixLoadIdentityEXT;
- glMatrixRotatefEXT: TglMatrixRotatefEXT;
- glMatrixRotatedEXT: TglMatrixRotatedEXT;
- glMatrixScalefEXT: TglMatrixScalefEXT;
- glMatrixScaledEXT: TglMatrixScaledEXT;
- glMatrixTranslatefEXT: TglMatrixTranslatefEXT;
- glMatrixTranslatedEXT: TglMatrixTranslatedEXT;
- glMatrixFrustumEXT: TglMatrixFrustumEXT;
- glMatrixOrthoEXT: TglMatrixOrthoEXT;
- glMatrixPopEXT: TglMatrixPopEXT;
- glMatrixPushEXT: TglMatrixPushEXT;
- glMatrixLoadTransposefEXT: TglMatrixLoadTransposefEXT;
- glMatrixLoadTransposedEXT: TglMatrixLoadTransposedEXT;
- glMatrixMultTransposefEXT: TglMatrixMultTransposefEXT;
- glMatrixMultTransposedEXT: TglMatrixMultTransposedEXT;
- glTextureParameterfEXT: TglTextureParameterfEXT;
- glTextureParameterfvEXT: TglTextureParameterfvEXT;
- glTextureParameteriEXT: TglTextureParameteriEXT;
- glTextureParameterivEXT: TglTextureParameterivEXT;
- glTextureImage1DEXT: TglTextureImage1DEXT;
- glTextureImage2DEXT: TglTextureImage2DEXT;
- glTextureSubImage1DEXT: TglTextureSubImage1DEXT;
- glTextureSubImage2DEXT: TglTextureSubImage2DEXT;
- glCopyTextureImage1DEXT: TglCopyTextureImage1DEXT;
- glCopyTextureImage2DEXT: TglCopyTextureImage2DEXT;
- glCopyTextureSubImage1DEXT: TglCopyTextureSubImage1DEXT;
- glCopyTextureSubImage2DEXT: TglCopyTextureSubImage2DEXT;
- glGetTextureImageEXT: TglGetTextureImageEXT;
- glGetTextureParameterfvEXT: TglGetTextureParameterfvEXT;
- glGetTextureParameterivEXT: TglGetTextureParameterivEXT;
- glGetTextureLevelParameterfvEXT: TglGetTextureLevelParameterfvEXT;
- glGetTextureLevelParameterivEXT: TglGetTextureLevelParameterivEXT;
- glTextureImage3DEXT: TglTextureImage3DEXT;
- glTextureSubImage3DEXT: TglTextureSubImage3DEXT;
- glCopyTextureSubImage3DEXT: TglCopyTextureSubImage3DEXT;
- glMultiTexParameterfEXT: TglMultiTexParameterfEXT;
- glMultiTexParameterfvEXT: TglMultiTexParameterfvEXT;
- glMultiTexParameteriEXT: TglMultiTexParameteriEXT;
- glMultiTexParameterivEXT: TglMultiTexParameterivEXT;
- glMultiTexImage1DEXT: TglMultiTexImage1DEXT;
- glMultiTexImage2DEXT: TglMultiTexImage2DEXT;
- glMultiTexSubImage1DEXT: TglMultiTexSubImage1DEXT;
- glMultiTexSubImage2DEXT: TglMultiTexSubImage2DEXT;
- glCopyMultiTexImage1DEXT: TglCopyMultiTexImage1DEXT;
- glCopyMultiTexImage2DEXT: TglCopyMultiTexImage2DEXT;
- glCopyMultiTexSubImage1DEXT: TglCopyMultiTexSubImage1DEXT;
- glCopyMultiTexSubImage2DEXT: TglCopyMultiTexSubImage2DEXT;
- glGetMultiTexImageEXT: TglGetMultiTexImageEXT;
- glGetMultiTexParameterfvEXT: TglGetMultiTexParameterfvEXT;
- glGetMultiTexParameterivEXT: TglGetMultiTexParameterivEXT;
- glGetMultiTexLevelParameterfvEXT: TglGetMultiTexLevelParameterfvEXT;
- glGetMultiTexLevelParameterivEXT: TglGetMultiTexLevelParameterivEXT;
- glMultiTexImage3DEXT: TglMultiTexImage3DEXT;
- glMultiTexSubImage3DEXT: TglMultiTexSubImage3DEXT;
- glCopyMultiTexSubImage3DEXT: TglCopyMultiTexSubImage3DEXT;
- glBindMultiTextureEXT: TglBindMultiTextureEXT;
- glEnableClientStateIndexedEXT: TglEnableClientStateIndexedEXT;
- glDisableClientStateIndexedEXT: TglDisableClientStateIndexedEXT;
- glMultiTexCoordPointerEXT: TglMultiTexCoordPointerEXT;
- glMultiTexEnvfEXT: TglMultiTexEnvfEXT;
- glMultiTexEnvfvEXT: TglMultiTexEnvfvEXT;
- glMultiTexEnviEXT: TglMultiTexEnviEXT;
- glMultiTexEnvivEXT: TglMultiTexEnvivEXT;
- glMultiTexGendEXT: TglMultiTexGendEXT;
- glMultiTexGendvEXT: TglMultiTexGendvEXT;
- glMultiTexGenfEXT: TglMultiTexGenfEXT;
- glMultiTexGenfvEXT: TglMultiTexGenfvEXT;
- glMultiTexGeniEXT: TglMultiTexGeniEXT;
- glMultiTexGenivEXT: TglMultiTexGenivEXT;
- glGetMultiTexEnvfvEXT: TglGetMultiTexEnvfvEXT;
- glGetMultiTexEnvivEXT: TglGetMultiTexEnvivEXT;
- glGetMultiTexGendvEXT: TglGetMultiTexGendvEXT;
- glGetMultiTexGenfvEXT: TglGetMultiTexGenfvEXT;
- glGetMultiTexGenivEXT: TglGetMultiTexGenivEXT;
- glGetFloatIndexedvEXT: TglGetFloatIndexedvEXT;
- glGetDoubleIndexedvEXT: TglGetDoubleIndexedvEXT;
- glGetPointerIndexedvEXT: TglGetPointerIndexedvEXT;
- glCompressedTextureImage3DEXT: TglCompressedTextureImage3DEXT;
- glCompressedTextureImage2DEXT: TglCompressedTextureImage2DEXT;
- glCompressedTextureImage1DEXT: TglCompressedTextureImage1DEXT;
- glCompressedTextureSubImage3DEXT: TglCompressedTextureSubImage3DEXT;
- glCompressedTextureSubImage2DEXT: TglCompressedTextureSubImage2DEXT;
- glCompressedTextureSubImage1DEXT: TglCompressedTextureSubImage1DEXT;
- glGetCompressedTextureImageEXT: TglGetCompressedTextureImageEXT;
- glCompressedMultiTexImage3DEXT: TglCompressedMultiTexImage3DEXT;
- glCompressedMultiTexImage2DEXT: TglCompressedMultiTexImage2DEXT;
- glCompressedMultiTexImage1DEXT: TglCompressedMultiTexImage1DEXT;
- glCompressedMultiTexSubImage3DEXT: TglCompressedMultiTexSubImage3DEXT;
- glCompressedMultiTexSubImage2DEXT: TglCompressedMultiTexSubImage2DEXT;
- glCompressedMultiTexSubImage1DEXT: TglCompressedMultiTexSubImage1DEXT;
- glGetCompressedMultiTexImageEXT: TglGetCompressedMultiTexImageEXT;
- glNamedProgramStringEXT: TglNamedProgramStringEXT;
- glNamedProgramLocalParameter4dEXT: TglNamedProgramLocalParameter4dEXT;
- glNamedProgramLocalParameter4dvEXT: TglNamedProgramLocalParameter4dvEXT;
- glNamedProgramLocalParameter4fEXT: TglNamedProgramLocalParameter4fEXT;
- glNamedProgramLocalParameter4fvEXT: TglNamedProgramLocalParameter4fvEXT;
- glGetNamedProgramLocalParameterdvEXT: TglGetNamedProgramLocalParameterdvEXT;
- glGetNamedProgramLocalParameterfvEXT: TglGetNamedProgramLocalParameterfvEXT;
- glGetNamedProgramivEXT: TglGetNamedProgramivEXT;
- glGetNamedProgramStringEXT: TglGetNamedProgramStringEXT;
- glNamedProgramLocalParameters4fvEXT: TglNamedProgramLocalParameters4fvEXT;
- glNamedProgramLocalParameterI4iEXT: TglNamedProgramLocalParameterI4iEXT;
- glNamedProgramLocalParameterI4ivEXT: TglNamedProgramLocalParameterI4ivEXT;
- glNamedProgramLocalParametersI4ivEXT: TglNamedProgramLocalParametersI4ivEXT;
- glNamedProgramLocalParameterI4uiEXT: TglNamedProgramLocalParameterI4uiEXT;
- glNamedProgramLocalParameterI4uivEXT: TglNamedProgramLocalParameterI4uivEXT;
- glNamedProgramLocalParametersI4uivEXT: TglNamedProgramLocalParametersI4uivEXT;
- glGetNamedProgramLocalParameterIivEXT: TglGetNamedProgramLocalParameterIivEXT;
- glGetNamedProgramLocalParameterIuivEXT: TglGetNamedProgramLocalParameterIuivEXT;
- glTextureParameterIivEXT: TglTextureParameterIivEXT;
- glTextureParameterIuivEXT: TglTextureParameterIuivEXT;
- glGetTextureParameterIivEXT: TglGetTextureParameterIivEXT;
- glGetTextureParameterIuivEXT: TglGetTextureParameterIuivEXT;
- glMultiTexParameterIivEXT: TglMultiTexParameterIivEXT;
- glMultiTexParameterIuivEXT: TglMultiTexParameterIuivEXT;
- glGetMultiTexParameterIivEXT: TglGetMultiTexParameterIivEXT;
- glGetMultiTexParameterIuivEXT: TglGetMultiTexParameterIuivEXT;
- glProgramUniform1fEXT: TglProgramUniform1fEXT;
- glProgramUniform2fEXT: TglProgramUniform2fEXT;
- glProgramUniform3fEXT: TglProgramUniform3fEXT;
- glProgramUniform4fEXT: TglProgramUniform4fEXT;
- glProgramUniform1iEXT: TglProgramUniform1iEXT;
- glProgramUniform2iEXT: TglProgramUniform2iEXT;
- glProgramUniform3iEXT: TglProgramUniform3iEXT;
- glProgramUniform4iEXT: TglProgramUniform4iEXT;
- glProgramUniform1fvEXT: TglProgramUniform1fvEXT;
- glProgramUniform2fvEXT: TglProgramUniform2fvEXT;
- glProgramUniform3fvEXT: TglProgramUniform3fvEXT;
- glProgramUniform4fvEXT: TglProgramUniform4fvEXT;
- glProgramUniform1ivEXT: TglProgramUniform1ivEXT;
- glProgramUniform2ivEXT: TglProgramUniform2ivEXT;
- glProgramUniform3ivEXT: TglProgramUniform3ivEXT;
- glProgramUniform4ivEXT: TglProgramUniform4ivEXT;
- glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT;
- glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT;
- glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT;
- glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT;
- glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT;
- glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT;
- glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT;
- glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT;
- glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT;
- glProgramUniform1uiEXT: TglProgramUniform1uiEXT;
- glProgramUniform2uiEXT: TglProgramUniform2uiEXT;
- glProgramUniform3uiEXT: TglProgramUniform3uiEXT;
- glProgramUniform4uiEXT: TglProgramUniform4uiEXT;
- glProgramUniform1uivEXT: TglProgramUniform1uivEXT;
- glProgramUniform2uivEXT: TglProgramUniform2uivEXT;
- glProgramUniform3uivEXT: TglProgramUniform3uivEXT;
- glProgramUniform4uivEXT: TglProgramUniform4uivEXT;
- glNamedBufferDataEXT: TglNamedBufferDataEXT;
- glNamedBufferSubDataEXT: TglNamedBufferSubDataEXT;
- glMapNamedBufferEXT: TglMapNamedBufferEXT;
- glUnmapNamedBufferEXT: TglUnmapNamedBufferEXT;
- glMapNamedBufferRangeEXT: TglMapNamedBufferRangeEXT;
- glFlushMappedNamedBufferRangeEXT: TglFlushMappedNamedBufferRangeEXT;
- glNamedCopyBufferSubDataEXT: TglNamedCopyBufferSubDataEXT;
- glGetNamedBufferParameterivEXT: TglGetNamedBufferParameterivEXT;
- glGetNamedBufferPointervEXT: TglGetNamedBufferPointervEXT;
- glGetNamedBufferSubDataEXT: TglGetNamedBufferSubDataEXT;
- glTextureBufferEXT: TglTextureBufferEXT;
- glMultiTexBufferEXT: TglMultiTexBufferEXT;
- glNamedRenderbufferStorageEXT: TglNamedRenderbufferStorageEXT;
- glGetNamedRenderbufferParameterivEXT: TglGetNamedRenderbufferParameterivEXT;
- glCheckNamedFramebufferStatusEXT: TglCheckNamedFramebufferStatusEXT;
- glNamedFramebufferTexture1DEXT: TglNamedFramebufferTexture1DEXT;
- glNamedFramebufferTexture2DEXT: TglNamedFramebufferTexture2DEXT;
- glNamedFramebufferTexture3DEXT: TglNamedFramebufferTexture3DEXT;
- glNamedFramebufferRenderbufferEXT: TglNamedFramebufferRenderbufferEXT;
- glGetNamedFramebufferAttachmentParameterivEXT: TglGetNamedFramebufferAttachmentParameterivEXT;
- glGenerateTextureMipmapEXT: TglGenerateTextureMipmapEXT;
- glGenerateMultiTexMipmapEXT: TglGenerateMultiTexMipmapEXT;
- glFramebufferDrawBufferEXT: TglFramebufferDrawBufferEXT;
- glFramebufferDrawBuffersEXT: TglFramebufferDrawBuffersEXT;
- glFramebufferReadBufferEXT: TglFramebufferReadBufferEXT;
- glGetFramebufferParameterivEXT: TglGetFramebufferParameterivEXT;
- glNamedRenderbufferStorageMultisampleEXT: TglNamedRenderbufferStorageMultisampleEXT;
- glNamedRenderbufferStorageMultisampleCoverageEXT: TglNamedRenderbufferStorageMultisampleCoverageEXT;
- glNamedFramebufferTextureEXT: TglNamedFramebufferTextureEXT;
- glNamedFramebufferTextureLayerEXT: TglNamedFramebufferTextureLayerEXT;
- glNamedFramebufferTextureFaceEXT: TglNamedFramebufferTextureFaceEXT;
- glTextureRenderbufferEXT: TglTextureRenderbufferEXT;
- glMultiTexRenderbufferEXT: TglMultiTexRenderbufferEXT;
- glProgramUniform1dEXT: TglProgramUniform1dEXT;
- glProgramUniform2dEXT: TglProgramUniform2dEXT;
- glProgramUniform3dEXT: TglProgramUniform3dEXT;
- glProgramUniform4dEXT: TglProgramUniform4dEXT;
- glProgramUniform1dvEXT: TglProgramUniform1dvEXT;
- glProgramUniform2dvEXT: TglProgramUniform2dvEXT;
- glProgramUniform3dvEXT: TglProgramUniform3dvEXT;
- glProgramUniform4dvEXT: TglProgramUniform4dvEXT;
- glProgramUniformMatrix2dvEXT: TglProgramUniformMatrix2dvEXT;
- glProgramUniformMatrix3dvEXT: TglProgramUniformMatrix3dvEXT;
- glProgramUniformMatrix4dvEXT: TglProgramUniformMatrix4dvEXT;
- glProgramUniformMatrix2x3dvEXT: TglProgramUniformMatrix2x3dvEXT;
- glProgramUniformMatrix2x4dvEXT: TglProgramUniformMatrix2x4dvEXT;
- glProgramUniformMatrix3x2dvEXT: TglProgramUniformMatrix3x2dvEXT;
- glProgramUniformMatrix3x4dvEXT: TglProgramUniformMatrix3x4dvEXT;
- glProgramUniformMatrix4x2dvEXT: TglProgramUniformMatrix4x2dvEXT;
- glProgramUniformMatrix4x3dvEXT: TglProgramUniformMatrix4x3dvEXT;
-
- // GL_EXT_separate_shader_objects
- glUseShaderProgramEXT: TglUseShaderProgramEXT;
- glActiveProgramEXT: TglActiveProgramEXT;
- glCreateShaderProgramEXT: TglCreateShaderProgramEXT;
-
- // GL_EXT_shader_image_load_store
- glBindImageTextureEXT: TglBindImageTextureEXT;
- glMemoryBarrierEXT: TglMemoryBarrierEXT;
-
- // GL_EXT_vertex_attrib_64bit
- glVertexAttribL1dEXT: TglVertexAttribL1dEXT;
- glVertexAttribL2dEXT: TglVertexAttribL2dEXT;
- glVertexAttribL3dEXT: TglVertexAttribL3dEXT;
- glVertexAttribL4dEXT: TglVertexAttribL4dEXT;
- glVertexAttribL1dvEXT: TglVertexAttribL1dvEXT;
- glVertexAttribL2dvEXT: TglVertexAttribL2dvEXT;
- glVertexAttribL3dvEXT: TglVertexAttribL3dvEXT;
- glVertexAttribL4dvEXT: TglVertexAttribL4dvEXT;
- glVertexAttribLPointerEXT: TglVertexAttribLPointerEXT;
- glGetVertexAttribLdvEXT: TglGetVertexAttribLdvEXT;
- glVertexArrayVertexAttribLOffsetEXT: TglVertexArrayVertexAttribLOffsetEXT;
-
- // GL_HP_image_transform
- glImageTransformParameteriHP: TglImageTransformParameteriHP;
- glImageTransformParameterfHP: TglImageTransformParameterfHP;
- glImageTransformParameterivHP: TglImageTransformParameterivHP;
- glImageTransformParameterfvHP: TglImageTransformParameterfvHP;
- glGetImageTransformParameterivHP: TglGetImageTransformParameterivHP;
- glGetImageTransformParameterfvHP: TglGetImageTransformParameterfvHP;
-
- // GL_EXT_depth_bounds_test
- glDepthBoundsEXT: TglDepthBoundsEXT;
-
- // GL_EXT_blend_equation_separate
- glBlendEquationSeparateEXT: TglBlendEquationSeparateEXT;
-
- // GL_IBM_multimode_draw_arrays
- glMultiModeDrawArraysIBM: TglMultiModeDrawArraysIBM;
- glMultiModeDrawElementsIBM: TglMultiModeDrawElementsIBM;
-
- // GL_IBM_vertex_array_lists
- glColorPointerListIBM: TglColorPointerListIBM;
- glSecondaryColorPointerListIBM: TglSecondaryColorPointerListIBM;
- glEdgeFlagPointerListIBM: TglEdgeFlagPointerListIBM;
- glFogCoordPointerListIBM: TglFogCoordPointerListIBM;
- glIndexPointerListIBM: TglIndexPointerListIBM;
- glNormalPointerListIBM: TglNormalPointerListIBM;
- glTexCoordPointerListIBM: TglTexCoordPointerListIBM;
- glVertexPointerListIBM: TglVertexPointerListIBM;
-
- // GL_INGR_blend_func_separate
- glBlendFuncSeparateINGR: TglBlendFuncSeparateINGR;
-
- // GL_INTEL_parallel_arrays
- glVertexPointervINTEL: TglVertexPointervINTEL;
- glNormalPointervINTEL: TglNormalPointervINTEL;
- glColorPointervINTEL: TglColorPointervINTEL;
- glTexCoordPointervINTEL: TglTexCoordPointervINTEL;
-
- // GL_MESA_resize_buffers
- glResizeBuffersMESA: TglResizeBuffersMESA;
-
- // GL_MESA_window_pos
- glWindowPos2dMESA: TglWindowPos2dMESA;
- glWindowPos2dvMESA: TglWindowPos2dvMESA;
- glWindowPos2fMESA: TglWindowPos2fMESA;
- glWindowPos2fvMESA: TglWindowPos2fvMESA;
- glWindowPos2iMESA: TglWindowPos2iMESA;
- glWindowPos2ivMESA: TglWindowPos2ivMESA;
- glWindowPos2sMESA: TglWindowPos2sMESA;
- glWindowPos2svMESA: TglWindowPos2svMESA;
- glWindowPos3dMESA: TglWindowPos3dMESA;
- glWindowPos3dvMESA: TglWindowPos3dvMESA;
- glWindowPos3fMESA: TglWindowPos3fMESA;
- glWindowPos3fvMESA: TglWindowPos3fvMESA;
- glWindowPos3iMESA: TglWindowPos3iMESA;
- glWindowPos3ivMESA: TglWindowPos3ivMESA;
- glWindowPos3sMESA: TglWindowPos3sMESA;
- glWindowPos3svMESA: TglWindowPos3svMESA;
- glWindowPos4dMESA: TglWindowPos4dMESA;
- glWindowPos4dvMESA: TglWindowPos4dvMESA;
- glWindowPos4fMESA: TglWindowPos4fMESA;
- glWindowPos4fvMESA: TglWindowPos4fvMESA;
- glWindowPos4iMESA: TglWindowPos4iMESA;
- glWindowPos4ivMESA: TglWindowPos4ivMESA;
- glWindowPos4sMESA: TglWindowPos4sMESA;
- glWindowPos4svMESA: TglWindowPos4svMESA;
-
- // GL_NV_evaluators
- glMapControlPointsNV: TglMapControlPointsNV;
- glMapParameterivNV: TglMapParameterivNV;
- glMapParameterfvNV: TglMapParameterfvNV;
- glGetMapControlPointsNV: TglGetMapControlPointsNV;
- glGetMapParameterivNV: TglGetMapParameterivNV;
- glGetMapParameterfvNV: TglGetMapParameterfvNV;
- glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV;
- glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV;
- glEvalMapsNV: TglEvalMapsNV;
-
- // GL_NV_fence
- glDeleteFencesNV: TglDeleteFencesNV;
- glGenFencesNV: TglGenFencesNV;
- glIsFenceNV: TglIsFenceNV;
- glTestFenceNV: TglTestFenceNV;
- glGetFenceivNV: TglGetFenceivNV;
- glFinishFenceNV: TglFinishFenceNV;
- glSetFenceNV: TglSetFenceNV;
-
- // GL_NV_fragment_program
- glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV;
- glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV;
- glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV;
- glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV;
- glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV;
- glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV;
-
- // GL_NV_half_float
- glVertex2hNV: TglVertex2hNV;
- glVertex2hvNV: TglVertex2hvNV;
- glVertex3hNV: TglVertex3hNV;
- glVertex3hvNV: TglVertex3hvNV;
- glVertex4hNV: TglVertex4hNV;
- glVertex4hvNV: TglVertex4hvNV;
- glNormal3hNV: TglNormal3hNV;
- glNormal3hvNV: TglNormal3hvNV;
- glColor3hNV: TglColor3hNV;
- glColor3hvNV: TglColor3hvNV;
- glColor4hNV: TglColor4hNV;
- glColor4hvNV: TglColor4hvNV;
- glTexCoord1hNV: TglTexCoord1hNV;
- glTexCoord1hvNV: TglTexCoord1hvNV;
- glTexCoord2hNV: TglTexCoord2hNV;
- glTexCoord2hvNV: TglTexCoord2hvNV;
- glTexCoord3hNV: TglTexCoord3hNV;
- glTexCoord3hvNV: TglTexCoord3hvNV;
- glTexCoord4hNV: TglTexCoord4hNV;
- glTexCoord4hvNV: TglTexCoord4hvNV;
- glMultiTexCoord1hNV: TglMultiTexCoord1hNV;
- glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV;
- glMultiTexCoord2hNV: TglMultiTexCoord2hNV;
- glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV;
- glMultiTexCoord3hNV: TglMultiTexCoord3hNV;
- glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV;
- glMultiTexCoord4hNV: TglMultiTexCoord4hNV;
- glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV;
- glFogCoordhNV: TglFogCoordhNV;
- glFogCoordhvNV: TglFogCoordhvNV;
- glSecondaryColor3hNV: TglSecondaryColor3hNV;
- glSecondaryColor3hvNV: TglSecondaryColor3hvNV;
- glVertexWeighthNV: TglVertexWeighthNV;
- glVertexWeighthvNV: TglVertexWeighthvNV;
- glVertexAttrib1hNV: TglVertexAttrib1hNV;
- glVertexAttrib1hvNV: TglVertexAttrib1hvNV;
- glVertexAttrib2hNV: TglVertexAttrib2hNV;
- glVertexAttrib2hvNV: TglVertexAttrib2hvNV;
- glVertexAttrib3hNV: TglVertexAttrib3hNV;
- glVertexAttrib3hvNV: TglVertexAttrib3hvNV;
- glVertexAttrib4hNV: TglVertexAttrib4hNV;
- glVertexAttrib4hvNV: TglVertexAttrib4hvNV;
- glVertexAttribs1hvNV: TglVertexAttribs1hvNV;
- glVertexAttribs2hvNV: TglVertexAttribs2hvNV;
- glVertexAttribs3hvNV: TglVertexAttribs3hvNV;
- glVertexAttribs4hvNV: TglVertexAttribs4hvNV;
-
- // GL_NV_occlusion_query
- glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV;
- glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV;
- glIsOcclusionQueryNV: TglIsOcclusionQueryNV;
- glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV;
- glEndOcclusionQueryNV: TglEndOcclusionQueryNV;
- glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV;
- glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV;
-
- // GL_NV_pixel_data_range
- glPixelDataRangeNV: TglPixelDataRangeNV;
- glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV;
-
- // GL_NV_point_sprite
- glPointParameteriNV: TglPointParameteriNV;
- glPointParameterivNV: TglPointParameterivNV;
-
- // GL_NV_primitive_restart
- glPrimitiveRestartNV: TglPrimitiveRestartNV;
- glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV;
-
- // GL_NV_register_combiners
- glCombinerParameterfvNV: TglCombinerParameterfvNV;
- glCombinerParameterfNV: TglCombinerParameterfNV;
- glCombinerParameterivNV: TglCombinerParameterivNV;
- glCombinerParameteriNV: TglCombinerParameteriNV;
- glCombinerInputNV: TglCombinerInputNV;
- glCombinerOutputNV: TglCombinerOutputNV;
- glFinalCombinerInputNV: TglFinalCombinerInputNV;
- glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV;
- glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV;
- glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV;
- glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV;
- glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV;
- glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV;
-
- // GL_NV_register_combiners2
- glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV;
- glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV;
-
- // GL_NV_vertex_array_range
- glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV;
- glVertexArrayRangeNV: TglVertexArrayRangeNV;
-
- // GL_NV_vertex_program
- glAreProgramsResidentNV: TglAreProgramsResidentNV;
- glBindProgramNV: TglBindProgramNV;
- glDeleteProgramsNV: TglDeleteProgramsNV;
- glExecuteProgramNV: TglExecuteProgramNV;
- glGenProgramsNV: TglGenProgramsNV;
- glGetProgramParameterdvNV: TglGetProgramParameterdvNV;
- glGetProgramParameterfvNV: TglGetProgramParameterfvNV;
- glGetProgramivNV: TglGetProgramivNV;
- glGetProgramStringNV: TglGetProgramStringNV;
- glGetTrackMatrixivNV: TglGetTrackMatrixivNV;
- glGetVertexAttribdvNV: TglGetVertexAttribdvNV;
- glGetVertexAttribfvNV: TglGetVertexAttribfvNV;
- glGetVertexAttribivNV: TglGetVertexAttribivNV;
- glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV;
- glIsProgramNV: TglIsProgramNV;
- glLoadProgramNV: TglLoadProgramNV;
- glProgramParameter4dNV: TglProgramParameter4dNV;
- glProgramParameter4dvNV: TglProgramParameter4dvNV;
- glProgramParameter4fNV: TglProgramParameter4fNV;
- glProgramParameter4fvNV: TglProgramParameter4fvNV;
- glProgramParameters4dvNV: TglProgramParameters4dvNV;
- glProgramParameters4fvNV: TglProgramParameters4fvNV;
- glRequestResidentProgramsNV: TglRequestResidentProgramsNV;
- glTrackMatrixNV: TglTrackMatrixNV;
- glVertexAttribPointerNV: TglVertexAttribPointerNV;
- glVertexAttrib1dNV: TglVertexAttrib1dNV;
- glVertexAttrib1dvNV: TglVertexAttrib1dvNV;
- glVertexAttrib1fNV: TglVertexAttrib1fNV;
- glVertexAttrib1fvNV: TglVertexAttrib1fvNV;
- glVertexAttrib1sNV: TglVertexAttrib1sNV;
- glVertexAttrib1svNV: TglVertexAttrib1svNV;
- glVertexAttrib2dNV: TglVertexAttrib2dNV;
- glVertexAttrib2dvNV: TglVertexAttrib2dvNV;
- glVertexAttrib2fNV: TglVertexAttrib2fNV;
- glVertexAttrib2fvNV: TglVertexAttrib2fvNV;
- glVertexAttrib2sNV: TglVertexAttrib2sNV;
- glVertexAttrib2svNV: TglVertexAttrib2svNV;
- glVertexAttrib3dNV: TglVertexAttrib3dNV;
- glVertexAttrib3dvNV: TglVertexAttrib3dvNV;
- glVertexAttrib3fNV: TglVertexAttrib3fNV;
- glVertexAttrib3fvNV: TglVertexAttrib3fvNV;
- glVertexAttrib3sNV: TglVertexAttrib3sNV;
- glVertexAttrib3svNV: TglVertexAttrib3svNV;
- glVertexAttrib4dNV: TglVertexAttrib4dNV;
- glVertexAttrib4dvNV: TglVertexAttrib4dvNV;
- glVertexAttrib4fNV: TglVertexAttrib4fNV;
- glVertexAttrib4fvNV: TglVertexAttrib4fvNV;
- glVertexAttrib4sNV: TglVertexAttrib4sNV;
- glVertexAttrib4svNV: TglVertexAttrib4svNV;
- glVertexAttrib4ubNV: TglVertexAttrib4ubNV;
- glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV;
- glVertexAttribs1dvNV: TglVertexAttribs1dvNV;
- glVertexAttribs1fvNV: TglVertexAttribs1fvNV;
- glVertexAttribs1svNV: TglVertexAttribs1svNV;
- glVertexAttribs2dvNV: TglVertexAttribs2dvNV;
- glVertexAttribs2fvNV: TglVertexAttribs2fvNV;
- glVertexAttribs2svNV: TglVertexAttribs2svNV;
- glVertexAttribs3dvNV: TglVertexAttribs3dvNV;
- glVertexAttribs3fvNV: TglVertexAttribs3fvNV;
- glVertexAttribs3svNV: TglVertexAttribs3svNV;
- glVertexAttribs4dvNV: TglVertexAttribs4dvNV;
- glVertexAttribs4fvNV: TglVertexAttribs4fvNV;
- glVertexAttribs4svNV: TglVertexAttribs4svNV;
- glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV;
-
- // GL_NV_depth_buffer_float
- glDepthRangedNV: TglDepthRangedNV;
- glClearDepthdNV: TglClearDepthdNV;
- glDepthBoundsdNV: TglDepthBoundsdNV;
-
- // GL_NV_framebuffer_multisample_coverage
- glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV;
-
- // GL_NV_geometry_program4
- glProgramVertexLimitNV: TglProgramVertexLimitNV;
-
- // GL_NV_gpu_program4
- glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV;
- glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV;
- glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV;
- glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV;
- glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV;
- glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV;
- glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV;
- glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV;
- glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV;
- glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV;
- glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV;
- glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV;
- glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV;
- glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV;
- glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV;
- glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV;
-
- // GL_NV_parameter_buffer_object
- glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV;
- glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV;
- glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV;
-
- // GL_NV_transform_feedback
- glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV;
- glEndTransformFeedbackNV: TglEndTransformFeedbackNV;
- glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV;
- glBindBufferRangeNV: TglBindBufferRangeNV;
- glBindBufferOffsetNV: TglBindBufferOffsetNV;
- glBindBufferBaseNV: TglBindBufferBaseNV;
- glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV;
- glActiveVaryingNV: TglActiveVaryingNV;
- glGetVaryingLocationNV: TglGetVaryingLocationNV;
- glGetActiveVaryingNV: TglGetActiveVaryingNV;
- glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV;
- glTransformFeedbackStreamAttribsNV: TglTransformFeedbackStreamAttribsNV;
-
- // GL_NV_conditional_render
- glBeginConditionalRenderNV: TglBeginConditionalRenderNV;
- glEndConditionalRenderNV: TglEndConditionalRenderNV;
-
- // GL_NV_present_video
- glPresentFrameKeyedNV: TglPresentFrameKeyedNV;
- glPresentFrameDualFillNV: TglPresentFrameDualFillNV;
- glGetVideoivNV: TglGetVideoivNV;
- glGetVideouivNV: TglGetVideouivNV;
- glGetVideoi64vNV: TglGetVideoi64vNV;
- glGetVideoui64vNV: TglGetVideoui64vNV;
-// glVideoParameterivNV: TglVideoParameterivNV;
-
- // GL_NV_explicit_multisample
- glGetMultisamplefvNV: TglGetMultisamplefvNV;
- glSampleMaskIndexedNV: TglSampleMaskIndexedNV;
- glTexRenderbufferNV: TglTexRenderbufferNV;
-
- // GL_NV_transform_feedback2
- glBindTransformFeedbackNV: TglBindTransformFeedbackNV;
- glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV;
- glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV;
- glIsTransformFeedbackNV: TglIsTransformFeedbackNV;
- glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV;
- glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV;
- glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV;
-
- // GL_NV_video_capture
- glBeginVideoCaptureNV: TglBeginVideoCaptureNV;
- glBindVideoCaptureStreamBufferNV: TglBindVideoCaptureStreamBufferNV;
- glBindVideoCaptureStreamTextureNV: TglBindVideoCaptureStreamTextureNV;
- glEndVideoCaptureNV: TglEndVideoCaptureNV;
- glGetVideoCaptureivNV: TglGetVideoCaptureivNV;
- glGetVideoCaptureStreamivNV: TglGetVideoCaptureStreamivNV;
- glGetVideoCaptureStreamfvNV: TglGetVideoCaptureStreamfvNV;
- glGetVideoCaptureStreamdvNV: TglGetVideoCaptureStreamdvNV;
- glVideoCaptureNV: TglVideoCaptureNV;
- glVideoCaptureStreamParameterivNV: TglVideoCaptureStreamParameterivNV;
- glVideoCaptureStreamParameterfvNV: TglVideoCaptureStreamParameterfvNV;
- glVideoCaptureStreamParameterdvNV: TglVideoCaptureStreamParameterdvNV;
-
- // GL_NV_copy_image
- glCopyImageSubDataNV: TglCopyImageSubDataNV;
-
- // GL_NV_shader_buffer_load
- glMakeBufferResidentNV: TglMakeBufferResidentNV;
- glMakeBufferNonResidentNV: TglMakeBufferNonResidentNV;
- glIsBufferResidentNV: TglIsBufferResidentNV;
- glMakeNamedBufferResidentNV: TglMakeNamedBufferResidentNV;
- glMakeNamedBufferNonResidentNV: TglMakeNamedBufferNonResidentNV;
- glIsNamedBufferResidentNV: TglIsNamedBufferResidentNV;
- glGetBufferParameterui64vNV: TglGetBufferParameterui64vNV;
- glGetNamedBufferParameterui64vNV: TglGetNamedBufferParameterui64vNV;
- glGetIntegerui64vNV: TglGetIntegerui64vNV;
- glUniformui64NV: TglUniformui64NV;
- glUniformui64vNV: TglUniformui64vNV;
- glGetUniformui64vNV: TglGetUniformui64vNV;
- glProgramUniformui64NV: TglProgramUniformui64NV;
- glProgramUniformui64vNV: TglProgramUniformui64vNV;
-
- // GL_NV_vertex_buffer_unified_memory
- glBufferAddressRangeNV: TglBufferAddressRangeNV;
- glVertexFormatNV: TglVertexFormatNV;
- glNormalFormatNV: TglNormalFormatNV;
- glColorFormatNV: TglColorFormatNV;
- glIndexFormatNV: TglIndexFormatNV;
- glTexCoordFormatNV: TglTexCoordFormatNV;
- glEdgeFlagFormatNV: TglEdgeFlagFormatNV;
- glSecondaryColorFormatNV: TglSecondaryColorFormatNV;
- glFogCoordFormatNV: TglFogCoordFormatNV;
- glVertexAttribFormatNV: TglVertexAttribFormatNV;
- glVertexAttribIFormatNV: TglVertexAttribIFormatNV;
- glGetIntegerui64i_vNV: TglGetIntegerui64i_vNV;
-
- // GL_NV_gpu_program5
- glProgramSubroutineParametersuivNV: TglProgramSubroutineParametersuivNV;
- glGetProgramSubroutineParameteruivNV: TglGetProgramSubroutineParameteruivNV;
-
- // GL_NV_gpu_shader5
- glUniform1i64NV: TglUniform1i64NV;
- glUniform2i64NV: TglUniform2i64NV;
- glUniform3i64NV: TglUniform3i64NV;
- glUniform4i64NV: TglUniform4i64NV;
- glUniform1i64vNV: TglUniform1i64vNV;
- glUniform2i64vNV: TglUniform2i64vNV;
- glUniform3i64vNV: TglUniform3i64vNV;
- glUniform4i64vNV: TglUniform4i64vNV;
- glUniform1ui64NV: TglUniform1ui64NV;
- glUniform2ui64NV: TglUniform2ui64NV;
- glUniform3ui64NV: TglUniform3ui64NV;
- glUniform4ui64NV: TglUniform4ui64NV;
- glUniform1ui64vNV: TglUniform1ui64vNV;
- glUniform2ui64vNV: TglUniform2ui64vNV;
- glUniform3ui64vNV: TglUniform3ui64vNV;
- glUniform4ui64vNV: TglUniform4ui64vNV;
- glGetUniformi64vNV: TglGetUniformi64vNV;
- glProgramUniform1i64NV: TglProgramUniform1i64NV;
- glProgramUniform2i64NV: TglProgramUniform2i64NV;
- glProgramUniform3i64NV: TglProgramUniform3i64NV;
- glProgramUniform4i64NV: TglProgramUniform4i64NV;
- glProgramUniform1i64vNV: TglProgramUniform1i64vNV;
- glProgramUniform2i64vNV: TglProgramUniform2i64vNV;
- glProgramUniform3i64vNV: TglProgramUniform3i64vNV;
- glProgramUniform4i64vNV: TglProgramUniform4i64vNV;
- glProgramUniform1ui64NV: TglProgramUniform1ui64NV;
- glProgramUniform2ui64NV: TglProgramUniform2ui64NV;
- glProgramUniform3ui64NV: TglProgramUniform3ui64NV;
- glProgramUniform4ui64NV: TglProgramUniform4ui64NV;
- glProgramUniform1ui64vNV: TglProgramUniform1ui64vNV;
- glProgramUniform2ui64vNV: TglProgramUniform2ui64vNV;
- glProgramUniform3ui64vNV: TglProgramUniform3ui64vNV;
- glProgramUniform4ui64vNV: TglProgramUniform4ui64vNV;
-
- // GL_NV_vertex_attrib_integer_64bit
- glVertexAttribL1i64NV: TglVertexAttribL1i64NV;
- glVertexAttribL2i64NV: TglVertexAttribL2i64NV;
- glVertexAttribL3i64NV: TglVertexAttribL3i64NV;
- glVertexAttribL4i64NV: TglVertexAttribL4i64NV;
- glVertexAttribL1i64vNV: TglVertexAttribL1i64vNV;
- glVertexAttribL2i64vNV: TglVertexAttribL2i64vNV;
- glVertexAttribL3i64vNV: TglVertexAttribL3i64vNV;
- glVertexAttribL4i64vNV: TglVertexAttribL4i64vNV;
- glVertexAttribL1ui64NV: TglVertexAttribL1ui64NV;
- glVertexAttribL2ui64NV: TglVertexAttribL2ui64NV;
- glVertexAttribL3ui64NV: TglVertexAttribL3ui64NV;
- glVertexAttribL4ui64NV: TglVertexAttribL4ui64NV;
- glVertexAttribL1ui64vNV: TglVertexAttribL1ui64vNV;
- glVertexAttribL2ui64vNV: TglVertexAttribL2ui64vNV;
- glVertexAttribL3ui64vNV: TglVertexAttribL3ui64vNV;
- glVertexAttribL4ui64vNV: TglVertexAttribL4ui64vNV;
- glGetVertexAttribLi64vNV: TglGetVertexAttribLi64vNV;
- glGetVertexAttribLui64vNV: TglGetVertexAttribLui64vNV;
- glVertexAttribLFormatNV: TglVertexAttribLFormatNV;
-
- // GL_NV_vdpau_interop
- glVDPAUInitNV: TglVDPAUInitNV;
- glVDPAUFiniNV: TglVDPAUFiniNV;
- glVDPAURegisterVideoSurfaceNV: TglVDPAURegisterVideoSurfaceNV;
- glVDPAURegisterOutputSurfaceNV: TglVDPAURegisterOutputSurfaceNV;
- glVDPAUIsSurfaceNV: TglVDPAUIsSurfaceNV;
- glVDPAUUnregisterSurfaceNV: TglVDPAUUnregisterSurfaceNV;
- glVDPAUGetSurfaceivNV: TglVDPAUGetSurfaceivNV;
- glVDPAUSurfaceAccessNV: TglVDPAUSurfaceAccessNV;
- glVDPAUMapSurfacesNV: TglVDPAUMapSurfacesNV;
- glVDPAUUnmapSurfacesNV: TglVDPAUUnmapSurfacesNV;
-
- // GL_NV_texture_barrier
- glTextureBarrierNV: TglTextureBarrierNV;
-
- // (4.3) GL_NV_path_rendering
- glGenPathsNV : TglGenPathsNV;
- glDeletePathsNV : TglDeletePathsNV;
- glIsPathNV : TglIsPathNV;
- glPathCommandsNV : TglPathCommandsNV;
- glPathCoordsNV : TglPathCoordsNV;
- glPathSubCommandsNV : TglPathSubCommandsNV;
- glPathSubCoordsNV : TglPathSubCoordsNV;
- glPathStringNV : TglPathStringNV;
- glPathGlyphsNV : TglPathGlyphsNV;
- glPathGlyphRangeNV : TglPathGlyphRangeNV;
- glWeightPathsNV : TglWeightPathsNV;
- glCopyPathNV : TglCopyPathNV;
- glInterpolatePathsNV : TglInterpolatePathsNV;
- glTransformPathNV : TglTransformPathNV;
- glPathParameterivNV : TglPathParameterivNV;
- glPathParameteriNV : TglPathParameteriNV;
- glPathParameterfvNV : TglPathParameterfvNV;
- glPathParameterfNV : TglPathParameterfNV;
- glPathDashArrayNV : TglPathDashArrayNV;
- glPathStencilFuncNV : TglPathStencilFuncNV;
- glPathStencilDepthOffsetNV : TglPathStencilDepthOffsetNV;
- glStencilFillPathNV : TglStencilFillPathNV;
- glStencilStrokePathNV : TglStencilStrokePathNV;
- glStencilFillPathInstancedNV : TglStencilFillPathInstancedNV;
- glStencilStrokePathInstancedNV : TglStencilStrokePathInstancedNV;
- glPathCoverDepthFuncNV : TglPathCoverDepthFuncNV;
- glPathColorGenNV : TglPathColorGenNV;
- glPathTexGenNV : TglPathTexGenNV;
- glPathFogGenNV : TglPathFogGenNV;
- glCoverFillPathNV : TglCoverFillPathNV;
- glCoverStrokePathNV : TglCoverStrokePathNV;
- glCoverFillPathInstancedNV : TglCoverFillPathInstancedNV;
- glCoverStrokePathInstancedNV : TglCoverStrokePathInstancedNV;
- glGetPathParameterivNV : TglGetPathParameterivNV;
- glGetPathParameterfvNV : TglGetPathParameterfvNV;
- glGetPathCommandsNV : TglGetPathCommandsNV;
- glGetPathCoordsNV : TglGetPathCoordsNV;
- glGetPathDashArrayNV : TglGetPathDashArrayNV;
- glGetPathMetricsNV : TglGetPathMetricsNV;
- glGetPathMetricRangeNV : TglGetPathMetricRangeNV;
- glGetPathSpacingNV : TglGetPathSpacingNV;
- glGetPathColorGenivNV : TglGetPathColorGenivNV;
- glGetPathColorGenfvNV : TglGetPathColorGenfvNV;
- glGetPathTexGenivNV : TglGetPathTexGenivNV;
- glGetPathTexGenfvNV : TglGetPathTexGenfvNV;
- glIsPointInFillPathNV : TglIsPointInFillPathNV;
- glIsPointInStrokePathNV : TglIsPointInStrokePathNV;
- glGetPathLengthNV : TglGetPathLengthNV;
- glPointAlongPathNV : TglPointAlongPathNV;
-
- // GL_AMD_pinned_memory
-
- // GL_AMD_stencil_operation_extended
- glStencilOpValueAMD : TglStencilOpValueAMD;
-
- // GL_AMD_vertex_shader_viewport_index
-
- // GL_AMD_vertex_shader_layer
-
- // GL_NV_bindless_texture
- glGetTextureHandleNV : TglGetTextureHandleNV;
- glGetTextureSamplerHandleNV : TglGetTextureSamplerHandleNV;
- glMakeTextureHandleResidentNV : TglMakeTextureHandleResidentNV;
- glMakeTextureHandleNonResidentNV : TglMakeTextureHandleNonResidentNV;
- glGetImageHandleNV : TglGetImageHandleNV;
- glMakeImageHandleResidentNV : TglMakeImageHandleResidentNV;
- glMakeImageHandleNonResidentNV : TglMakeImageHandleNonResidentNV;
- glUniformHandleui64NV : TglUniformHandleui64NV;
- glUniformHandleui64vNV : TglUniformHandleui64vNV;
- glProgramUniformHandleui64NV : TglProgramUniformHandleui64NV;
- glProgramUniformHandleui64vNV : TglProgramUniformHandleui64vNV;
- glIsTextureHandleResidentNV : TglIsTextureHandleResidentNV;
- glIsImageHandleResidentNV : TglIsImageHandleResidentNV;
-
- //
-
- // GL_PGI_misc_hints
- glHintPGI: TglHintPGI;
-
- // GL_SGIS_detail_texture
- glDetailTexFuncSGIS: TglDetailTexFuncSGIS;
- glGetDetailTexFuncSGIS: TglGetDetailTexFuncSGIS;
-
- // GL_SGIS_fog_function
- glFogFuncSGIS: TglFogFuncSGIS;
- glGetFogFuncSGIS: TglGetFogFuncSGIS;
-
- // GL_SGIS_multisample
- glSampleMaskSGIS: TglSampleMaskSGIS;
- glSamplePatternSGIS: TglSamplePatternSGIS;
-
- // GL_SGIS_pixel_texture
- glPixelTexGenParameteriSGIS: TglPixelTexGenParameteriSGIS;
- glPixelTexGenParameterivSGIS: TglPixelTexGenParameterivSGIS;
- glPixelTexGenParameterfSGIS: TglPixelTexGenParameterfSGIS;
- glPixelTexGenParameterfvSGIS: TglPixelTexGenParameterfvSGIS;
- glGetPixelTexGenParameterivSGIS: TglGetPixelTexGenParameterivSGIS;
- glGetPixelTexGenParameterfvSGIS: TglGetPixelTexGenParameterfvSGIS;
-
- // GL_SGIS_point_parameters
- glPointParameterfSGIS: TglPointParameterfSGIS;
- glPointParameterfvSGIS: TglPointParameterfvSGIS;
-
- // GL_SGIS_sharpen_texture
- glSharpenTexFuncSGIS: TglSharpenTexFuncSGIS;
- glGetSharpenTexFuncSGIS: TglGetSharpenTexFuncSGIS;
-
- // GL_SGIS_texture4D
- glTexImage4DSGIS: TglTexImage4DSGIS;
- glTexSubImage4DSGIS: TglTexSubImage4DSGIS;
-
- // GL_SGIS_texture_color_mask
- glTextureColorMaskSGIS: TglTextureColorMaskSGIS;
-
- // GL_SGIS_texture_filter4
- glGetTexFilterFuncSGIS: TglGetTexFilterFuncSGIS;
- glTexFilterFuncSGIS: TglTexFilterFuncSGIS;
-
- // GL_SGIX_async
- glAsyncMarkerSGIX: TglAsyncMarkerSGIX;
- glFinishAsyncSGIX: TglFinishAsyncSGIX;
- glPollAsyncSGIX: TglPollAsyncSGIX;
- glGenAsyncMarkersSGIX: TglGenAsyncMarkersSGIX;
- glDeleteAsyncMarkersSGIX: TglDeleteAsyncMarkersSGIX;
- glIsAsyncMarkerSGIX: TglIsAsyncMarkerSGIX;
-
- // GL_SGIX_flush_raster
- glFlushRasterSGIX: TglFlushRasterSGIX;
-
- // GL_SGIX_fragment_lighting
- glFragmentColorMaterialSGIX: TglFragmentColorMaterialSGIX;
- glFragmentLightfSGIX: TglFragmentLightfSGIX;
- glFragmentLightfvSGIX: TglFragmentLightfvSGIX;
- glFragmentLightiSGIX: TglFragmentLightiSGIX;
- glFragmentLightivSGIX: TglFragmentLightivSGIX;
- glFragmentLightModelfSGIX: TglFragmentLightModelfSGIX;
- glFragmentLightModelfvSGIX: TglFragmentLightModelfvSGIX;
- glFragmentLightModeliSGIX: TglFragmentLightModeliSGIX;
- glFragmentLightModelivSGIX: TglFragmentLightModelivSGIX;
- glFragmentMaterialfSGIX: TglFragmentMaterialfSGIX;
- glFragmentMaterialfvSGIX: TglFragmentMaterialfvSGIX;
- glFragmentMaterialiSGIX: TglFragmentMaterialiSGIX;
- glFragmentMaterialivSGIX: TglFragmentMaterialivSGIX;
- glGetFragmentLightfvSGIX: TglGetFragmentLightfvSGIX;
- glGetFragmentLightivSGIX: TglGetFragmentLightivSGIX;
- glGetFragmentMaterialfvSGIX: TglGetFragmentMaterialfvSGIX;
- glGetFragmentMaterialivSGIX: TglGetFragmentMaterialivSGIX;
- glLightEnviSGIX: TglLightEnviSGIX;
-
- // GL_SGIX_framezoom
- glFrameZoomSGIX: TglFrameZoomSGIX;
-
- // GL_SGIX_igloo_interface
- glIglooInterfaceSGIX: TglIglooInterfaceSGIX;
-
- // GL_SGIX_instruments
- glGetInstrumentsSGIX: TglGetInstrumentsSGIX;
- glInstrumentsBufferSGIX: TglInstrumentsBufferSGIX;
- glPollInstrumentsSGIX: TglPollInstrumentsSGIX;
- glReadInstrumentsSGIX: TglReadInstrumentsSGIX;
- glStartInstrumentsSGIX: TglStartInstrumentsSGIX;
- glStopInstrumentsSGIX: TglStopInstrumentsSGIX;
-
- // GL_SGIX_list_priority
- glGetListParameterfvSGIX: TglGetListParameterfvSGIX;
- glGetListParameterivSGIX: TglGetListParameterivSGIX;
- glListParameterfSGIX: TglListParameterfSGIX;
- glListParameterfvSGIX: TglListParameterfvSGIX;
- glListParameteriSGIX: TglListParameteriSGIX;
- glListParameterivSGIX: TglListParameterivSGIX;
-
- // GL_SGIX_pixel_texture
- glPixelTexGenSGIX: TglPixelTexGenSGIX;
-
- // GL_SGIX_polynomial_ffd
- glDeformationMap3dSGIX: TglDeformationMap3dSGIX;
- glDeformationMap3fSGIX: TglDeformationMap3fSGIX;
- glDeformSGIX: TglDeformSGIX;
- glLoadIdentityDeformationMapSGIX: TglLoadIdentityDeformationMapSGIX;
-
- // GL_SGIX_reference_plane
- glReferencePlaneSGIX: TglReferencePlaneSGIX;
-
- // GL_SGIX_sprite
- glSpriteParameterfSGIX: TglSpriteParameterfSGIX;
- glSpriteParameterfvSGIX: TglSpriteParameterfvSGIX;
- glSpriteParameteriSGIX: TglSpriteParameteriSGIX;
- glSpriteParameterivSGIX: TglSpriteParameterivSGIX;
-
- // GL_SGIX_tag_sample_buffer
- glTagSampleBufferSGIX: TglTagSampleBufferSGIX;
-
- // GL_SGI_color_table
- glColorTableSGI: TglColorTableSGI;
- glColorTableParameterfvSGI: TglColorTableParameterfvSGI;
- glColorTableParameterivSGI: TglColorTableParameterivSGI;
- glCopyColorTableSGI: TglCopyColorTableSGI;
- glGetColorTableSGI: TglGetColorTableSGI;
- glGetColorTableParameterfvSGI: TglGetColorTableParameterfvSGI;
- glGetColorTableParameterivSGI: TglGetColorTableParameterivSGI;
-
- // GL_SUNX_constant_data
- glFinishTextureSUNX: TglFinishTextureSUNX;
-
- // GL_SUN_global_alpha
- glGlobalAlphaFactorbSUN: TglGlobalAlphaFactorbSUN;
- glGlobalAlphaFactorsSUN: TglGlobalAlphaFactorsSUN;
- glGlobalAlphaFactoriSUN: TglGlobalAlphaFactoriSUN;
- glGlobalAlphaFactorfSUN: TglGlobalAlphaFactorfSUN;
- glGlobalAlphaFactordSUN: TglGlobalAlphaFactordSUN;
- glGlobalAlphaFactorubSUN: TglGlobalAlphaFactorubSUN;
- glGlobalAlphaFactorusSUN: TglGlobalAlphaFactorusSUN;
- glGlobalAlphaFactoruiSUN: TglGlobalAlphaFactoruiSUN;
-
- // GL_SUN_mesh_array
- glDrawMeshArraysSUN: TglDrawMeshArraysSUN;
-
- // GL_SUN_triangle_list
- glReplacementCodeuiSUN: TglReplacementCodeuiSUN;
- glReplacementCodeusSUN: TglReplacementCodeusSUN;
- glReplacementCodeubSUN: TglReplacementCodeubSUN;
- glReplacementCodeuivSUN: TglReplacementCodeuivSUN;
- glReplacementCodeusvSUN: TglReplacementCodeusvSUN;
- glReplacementCodeubvSUN: TglReplacementCodeubvSUN;
- glReplacementCodePointerSUN: TglReplacementCodePointerSUN;
-
- // GL_SUN_vertex
- glColor4ubVertex2fSUN: TglColor4ubVertex2fSUN;
- glColor4ubVertex2fvSUN: TglColor4ubVertex2fvSUN;
- glColor4ubVertex3fSUN: TglColor4ubVertex3fSUN;
- glColor4ubVertex3fvSUN: TglColor4ubVertex3fvSUN;
- glColor3fVertex3fSUN: TglColor3fVertex3fSUN;
- glColor3fVertex3fvSUN: TglColor3fVertex3fvSUN;
- glNormal3fVertex3fSUN: TglNormal3fVertex3fSUN;
- glNormal3fVertex3fvSUN: TglNormal3fVertex3fvSUN;
- glColor4fNormal3fVertex3fSUN: TglColor4fNormal3fVertex3fSUN;
- glColor4fNormal3fVertex3fvSUN: TglColor4fNormal3fVertex3fvSUN;
- glTexCoord2fVertex3fSUN: TglTexCoord2fVertex3fSUN;
- glTexCoord2fVertex3fvSUN: TglTexCoord2fVertex3fvSUN;
- glTexCoord4fVertex4fSUN: TglTexCoord4fVertex4fSUN;
- glTexCoord4fVertex4fvSUN: TglTexCoord4fVertex4fvSUN;
- glTexCoord2fColor4ubVertex3fSUN: TglTexCoord2fColor4ubVertex3fSUN;
- glTexCoord2fColor4ubVertex3fvSUN: TglTexCoord2fColor4ubVertex3fvSUN;
- glTexCoord2fColor3fVertex3fSUN: TglTexCoord2fColor3fVertex3fSUN;
- glTexCoord2fColor3fVertex3fvSUN: TglTexCoord2fColor3fVertex3fvSUN;
- glTexCoord2fNormal3fVertex3fSUN: TglTexCoord2fNormal3fVertex3fSUN;
- glTexCoord2fNormal3fVertex3fvSUN: TglTexCoord2fNormal3fVertex3fvSUN;
- glTexCoord2fColor4fNormal3fVertex3fSUN: TglTexCoord2fColor4fNormal3fVertex3fSUN;
- glTexCoord2fColor4fNormal3fVertex3fvSUN: TglTexCoord2fColor4fNormal3fVertex3fvSUN;
- glTexCoord4fColor4fNormal3fVertex4fSUN: TglTexCoord4fColor4fNormal3fVertex4fSUN;
- glTexCoord4fColor4fNormal3fVertex4fvSUN: TglTexCoord4fColor4fNormal3fVertex4fvSUN;
- glReplacementCodeuiVertex3fSUN: TglReplacementCodeuiVertex3fSUN;
- glReplacementCodeuiVertex3fvSUN: TglReplacementCodeuiVertex3fvSUN;
- glReplacementCodeuiColor4ubVertex3fSUN: TglReplacementCodeuiColor4ubVertex3fSUN;
- glReplacementCodeuiColor4ubVertex3fvSUN: TglReplacementCodeuiColor4ubVertex3fvSUN;
- glReplacementCodeuiColor3fVertex3fSUN: TglReplacementCodeuiColor3fVertex3fSUN;
- glReplacementCodeuiColor3fVertex3fvSUN: TglReplacementCodeuiColor3fVertex3fvSUN;
- glReplacementCodeuiNormal3fVertex3fSUN: TglReplacementCodeuiNormal3fVertex3fSUN;
- glReplacementCodeuiNormal3fVertex3fvSUN: TglReplacementCodeuiNormal3fVertex3fvSUN;
- glReplacementCodeuiColor4fNormal3fVertex3fSUN: TglReplacementCodeuiColor4fNormal3fVertex3fSUN;
- glReplacementCodeuiColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiColor4fNormal3fVertex3fvSUN;
- glReplacementCodeuiTexCoord2fVertex3fSUN: TglReplacementCodeuiTexCoord2fVertex3fSUN;
- glReplacementCodeuiTexCoord2fVertex3fvSUN: TglReplacementCodeuiTexCoord2fVertex3fvSUN;
- glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
- glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
- glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
- glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
-
-{$IFDEF DGL_WIN}
- wglGetProcAddress: TwglGetProcAddress;
- wglCopyContext: TwglCopyContext;
- wglCreateContext: TwglCreateContext;
- wglCreateLayerContext: TwglCreateLayerContext;
- wglDeleteContext: TwglDeleteContext;
- wglDescribeLayerPlane: TwglDescribeLayerPlane;
- wglGetCurrentContext: TwglGetCurrentContext;
- wglGetCurrentDC: TwglGetCurrentDC;
- wglGetLayerPaletteEntries: TwglGetLayerPaletteEntries;
- wglMakeCurrent: TwglMakeCurrent;
- wglRealizeLayerPalette: TwglRealizeLayerPalette;
- wglSetLayerPaletteEntries: TwglSetLayerPaletteEntries;
- wglShareLists: TwglShareLists;
- wglSwapLayerBuffers: TwglSwapLayerBuffers;
- wglSwapMultipleBuffers: TwglSwapMultipleBuffers;
- wglUseFontBitmapsA: TwglUseFontBitmapsA;
- wglUseFontOutlinesA: TwglUseFontOutlinesA;
- wglUseFontBitmapsW: TwglUseFontBitmapsW;
- wglUseFontOutlinesW: TwglUseFontOutlinesW;
- wglUseFontBitmaps: TwglUseFontBitmaps;
- wglUseFontOutlines: TwglUseFontOutlines;
-
- // WGL_ARB_buffer_region
- wglCreateBufferRegionARB: TwglCreateBufferRegionARB;
- wglDeleteBufferRegionARB: TwglDeleteBufferRegionARB;
- wglSaveBufferRegionARB: TwglSaveBufferRegionARB;
- wglRestoreBufferRegionARB: TwglRestoreBufferRegionARB;
-
- // WGL_ARB_extensions_string
- wglGetExtensionsStringARB: TwglGetExtensionsStringARB;
-
- // WGL_ARB_make_current_read
- wglMakeContextCurrentARB: TwglMakeContextCurrentARB;
- wglGetCurrentReadDCARB: TwglGetCurrentReadDCARB;
-
- // WGL_ARB_pbuffer
- wglCreatePbufferARB: TwglCreatePbufferARB;
- wglGetPbufferDCARB: TwglGetPbufferDCARB;
- wglReleasePbufferDCARB: TwglReleasePbufferDCARB;
- wglDestroyPbufferARB: TwglDestroyPbufferARB;
- wglQueryPbufferARB: TwglQueryPbufferARB;
-
- // WGL_ARB_pixel_format
- wglGetPixelFormatAttribivARB: TwglGetPixelFormatAttribivARB;
- wglGetPixelFormatAttribfvARB: TwglGetPixelFormatAttribfvARB;
- wglChoosePixelFormatARB: TwglChoosePixelFormatARB;
- // WGL_ARB_color_buffer_float
- wglClampColorARB: TwglClampColorARB;
-
- // WGL_ARB_render_texture
- wglBindTexImageARB: TwglBindTexImageARB;
- wglReleaseTexImageARB: TwglReleaseTexImageARB;
- wglSetPbufferAttribARB: TwglSetPbufferAttribARB;
-
- // WGL_ARB_create_context
- wglCreateContextAttribsARB: TwglCreateContextAttribsARB;
-
- // WGL_AMD_gpu_association
- wglGetGPUIDsAMD: TwglGetGPUIDsAMD;
- wglGetGPUInfoAMD: TwglGetGPUInfoAMD;
- wglGetContextGPUIDAMD: TwglGetContextGPUIDAMD;
- wglCreateAssociatedContextAMD: TwglCreateAssociatedContextAMD;
- wglCreateAssociatedContextAttribsAMD: TwglCreateAssociatedContextAttribsAMD;
- wglDeleteAssociatedContextAMD: TwglDeleteAssociatedContextAMD;
- wglMakeAssociatedContextCurrentAMD: TwglMakeAssociatedContextCurrentAMD;
- wglGetCurrentAssociatedContextAMD: TwglGetCurrentAssociatedContextAMD;
- wglBlitContextFramebufferAMD: TwglBlitContextFramebufferAMD;
-
- // WGL_EXT_display_color_table
- wglCreateDisplayColorTableEXT: TwglCreateDisplayColorTableEXT;
- wglLoadDisplayColorTableEXT: TwglLoadDisplayColorTableEXT;
- wglBindDisplayColorTableEXT: TwglBindDisplayColorTableEXT;
- wglDestroyDisplayColorTableEXT: TwglDestroyDisplayColorTableEXT;
-
- // WGL_EXT_extensions_string
- wglGetExtensionsStringEXT: TwglGetExtensionsStringEXT;
-
- // WGL_EXT_make_current_read
- wglMakeContextCurrentEXT: TwglMakeContextCurrentEXT;
- wglGetCurrentReadDCEXT: TwglGetCurrentReadDCEXT;
-
- // WGL_EXT_pbuffer
- wglCreatePbufferEXT: TwglCreatePbufferEXT;
- wglGetPbufferDCEXT: TwglGetPbufferDCEXT;
- wglReleasePbufferDCEXT: TwglReleasePbufferDCEXT;
- wglDestroyPbufferEXT: TwglDestroyPbufferEXT;
- wglQueryPbufferEXT: TwglQueryPbufferEXT;
-
- // WGL_EXT_pixel_format
- wglGetPixelFormatAttribivEXT: TwglGetPixelFormatAttribivEXT;
- wglGetPixelFormatAttribfvEXT: TwglGetPixelFormatAttribfvEXT;
- wglChoosePixelFormatEXT: TwglChoosePixelFormatEXT;
-
- // WGL_EXT_swap_control
- wglSwapIntervalEXT: TwglSwapIntervalEXT;
- wglGetSwapIntervalEXT: TwglGetSwapIntervalEXT;
-
- // WGL_I3D_digital_video_control
- wglGetDigitalVideoParametersI3D: TwglGetDigitalVideoParametersI3D;
- wglSetDigitalVideoParametersI3D: TwglSetDigitalVideoParametersI3D;
-
- // WGL_I3D_gamma
- wglGetGammaTableParametersI3D: TwglGetGammaTableParametersI3D;
- wglSetGammaTableParametersI3D: TwglSetGammaTableParametersI3D;
- wglGetGammaTableI3D: TwglGetGammaTableI3D;
- wglSetGammaTableI3D: TwglSetGammaTableI3D;
-
- // WGL_I3D_genlock
- wglEnableGenlockI3D: TwglEnableGenlockI3D;
- wglDisableGenlockI3D: TwglDisableGenlockI3D;
- wglIsEnabledGenlockI3D: TwglIsEnabledGenlockI3D;
- wglGenlockSourceI3D: TwglGenlockSourceI3D;
- wglGetGenlockSourceI3D: TwglGetGenlockSourceI3D;
- wglGenlockSourceEdgeI3D: TwglGenlockSourceEdgeI3D;
- wglGetGenlockSourceEdgeI3D: TwglGetGenlockSourceEdgeI3D;
- wglGenlockSampleRateI3D: TwglGenlockSampleRateI3D;
- wglGetGenlockSampleRateI3D: TwglGetGenlockSampleRateI3D;
- wglGenlockSourceDelayI3D: TwglGenlockSourceDelayI3D;
- wglGetGenlockSourceDelayI3D: TwglGetGenlockSourceDelayI3D;
- wglQueryGenlockMaxSourceDelayI3D: TwglQueryGenlockMaxSourceDelayI3D;
-
- // WGL_I3D_image_buffer
- wglCreateImageBufferI3D: TwglCreateImageBufferI3D;
- wglDestroyImageBufferI3D: TwglDestroyImageBufferI3D;
- wglAssociateImageBufferEventsI3D: TwglAssociateImageBufferEventsI3D;
- wglReleaseImageBufferEventsI3D: TwglReleaseImageBufferEventsI3D;
-
- // WGL_I3D_swap_frame_lock
- wglEnableFrameLockI3D: TwglEnableFrameLockI3D;
- wglDisableFrameLockI3D: TwglDisableFrameLockI3D;
- wglIsEnabledFrameLockI3D: TwglIsEnabledFrameLockI3D;
- wglQueryFrameLockMasterI3D: TwglQueryFrameLockMasterI3D;
-
- // WGL_I3D_swap_frame_usage
- wglGetFrameUsageI3D: TwglGetFrameUsageI3D;
- wglBeginFrameTrackingI3D: TwglBeginFrameTrackingI3D;
- wglEndFrameTrackingI3D: TwglEndFrameTrackingI3D;
- wglQueryFrameTrackingI3D: TwglQueryFrameTrackingI3D;
-
- // WGL_NV_vertex_array_range
- wglAllocateMemoryNV: TwglAllocateMemoryNV;
- wglFreeMemoryNV: TwglFreeMemoryNV;
-
- // WGL_NV_present_video
- wglEnumerateVideoDevicesNV: TwglEnumerateVideoDevicesNV;
- wglBindVideoDeviceNV: TwglBindVideoDeviceNV;
- wglQueryCurrentContextNV: TwglQueryCurrentContextNV;
-
- // WGL_NV_video_output
- wglGetVideoDeviceNV: TwglGetVideoDeviceNV;
- wglReleaseVideoDeviceNV: TwglReleaseVideoDeviceNV;
- wglBindVideoImageNV: TwglBindVideoImageNV;
- wglReleaseVideoImageNV: TwglReleaseVideoImageNV;
- wglSendPbufferToVideoNV: TwglSendPbufferToVideoNV;
- wglGetVideoInfoNV: TwglGetVideoInfoNV;
-
- // WGL_NV_swap_group
- wglJoinSwapGroupNV: TwglJoinSwapGroupNV;
- wglBindSwapBarrierNV: TwglBindSwapBarrierNV;
- wglQuerySwapGroupNV: TwglQuerySwapGroupNV;
- wglQueryMaxSwapGroupsNV: TwglQueryMaxSwapGroupsNV;
- wglQueryFrameCountNV: TwglQueryFrameCountNV;
- wglResetFrameCountNV: TwglResetFrameCountNV;
-
- // WGL_NV_gpu_affinity
- wglEnumGpusNV: TwglEnumGpusNV;
- wglEnumGpuDevicesNV: TwglEnumGpuDevicesNV;
- wglCreateAffinityDCNV: TwglCreateAffinityDCNV;
- wglEnumGpusFromAffinityDCNV: TwglEnumGpusFromAffinityDCNV;
- wglDeleteDCNV: TwglDeleteDCNV;
-
- // WGL_NV_video_capture
- wglBindVideoCaptureDeviceNV: TwglBindVideoCaptureDeviceNV;
- wglEnumerateVideoCaptureDevicesNV: TwglEnumerateVideoCaptureDevicesNV;
- wglLockVideoCaptureDeviceNV: TwglLockVideoCaptureDeviceNV;
- wglQueryVideoCaptureDeviceNV: TwglQueryVideoCaptureDeviceNV;
- wglReleaseVideoCaptureDeviceNV: TwglReleaseVideoCaptureDeviceNV;
-
- // WGL_NV_copy_image
- wglCopyImageSubDataNV: TwglCopyImageSubDataNV;
-
- // WGL_NV_DX_interop
- wglDXSetResourceShareHandleNV : TwglDXSetResourceShareHandleNV;
- wglDXOpenDeviceNV : TwglDXOpenDeviceNV;
- wglDXCloseDeviceNV : TwglDXCloseDeviceNV;
- wglDXRegisterObjectNV : TwglDXRegisterObjectNV;
- wglDXUnregisterObjectNV : TwglDXUnregisterObjectNV;
- wglDXObjectAccessNV : TwglDXObjectAccessNV;
- wglDXLockObjectsNV : TwglDXLockObjectsNV;
- wglDXUnlockObjectsNV : TwglDXUnlockObjectsNV;
-
- // WGL_OML_sync_control
- wglGetSyncValuesOML: TwglGetSyncValuesOML;
- wglGetMscRateOML: TwglGetMscRateOML;
- wglSwapBuffersMscOML: TwglSwapBuffersMscOML;
- wglSwapLayerBuffersMscOML: TwglSwapLayerBuffersMscOML;
- wglWaitForMscOML: TwglWaitForMscOML;
- wglWaitForSbcOML: TwglWaitForSbcOML;
-
- // WGL_3DL_stereo_control
- wglSetStereoEmitterState3DL: TwglSetStereoEmitterState3DL;
-
- // WIN_draw_range_elements
- glDrawRangeElementsWIN: TglDrawRangeElementsWIN;
-
- // WIN_swap_hint
- glAddSwapHintRectWIN: TglAddSwapHintRectWIN;
-{$ENDIF}
-
-{$IFDEF DGL_LINUX}
- glXChooseVisual: TglXChooseVisual;
- glXCopyContext: TglXCopyContext;
- glXCreateContext: TglXCreateContext;
- glXCreateGLXPixmap: TglXCreateGLXPixmap;
- glXDestroyContext: TglXDestroyContext;
- glXDestroyGLXPixmap: TglXDestroyGLXPixmap;
- glXGetConfig: TglXGetConfig;
- glXGetCurrentContext: TglXGetCurrentContext;
- glXGetCurrentDrawable: TglXGetCurrentDrawable;
- glXIsDirect: TglXIsDirect;
- glXMakeCurrent: TglXMakeCurrent;
- glXQueryExtension: TglXQueryExtension;
- glXQueryVersion: TglXQueryVersion;
- glXSwapBuffers: TglXSwapBuffers;
- glXUseXFont: TglXUseXFont;
- glXWaitGL: TglXWaitGL;
- glXWaitX: TglXWaitX;
-
- glXGetClientString: TglXGetClientString;
- glXQueryServerString: TglXQueryServerString;
- glXQueryExtensionsString: TglXQueryExtensionsString;
-
- // GLX_VERSION_1_3
- glXGetFBConfigs: TglXGetFBConfigs;
- glXChooseFBConfig: TglXChooseFBConfig;
- glXGetFBConfigAttrib: TglXGetFBConfigAttrib;
- glXGetVisualFromFBConfig: TglXGetVisualFromFBConfig;
- glXCreateWindow: TglXCreateWindow;
- glXDestroyWindow: TglXDestroyWindow;
- glXCreatePixmap: TglXCreatePixmap;
-
- glXDestroyPixmap: TglXDestroyPixmap;
- glXCreatePbuffer: TglXCreatePbuffer;
- glXDestroyPbuffer: TglXDestroyPbuffer;
- glXQueryDrawable: TglXQueryDrawable;
- glXCreateNewContext: TglXCreateNewContext;
- glXMakeContextCurrent: TglXMakeContextCurrent;
- glXGetCurrentReadDrawable: TglXGetCurrentReadDrawable;
- glXGetCurreentDisplay: TglXGetCurreentDisplay;
-
- glXQueryContext: TglXQueryContext;
- glXSelectEvent: TglXSelectEvent;
- glXGetSelectedEvent: TglXGetSelectedEvent;
-
- // GLX_VERSION_1_4
- glXGetProcAddress: TglXGetProcAddress;
-
- // GLX_ARB_get_proc_address
- glXGetProcAddressARB: TglXGetProcAddressARB;
-
- // GLX_ARB_create_context
- glXCreateContextAttribsARB: TglXCreateContextAttribsARB;
-
- // GLX_EXT_import_context
- glXGetCurrentDisplayEXT: TglXGetCurrentDisplayEXT;
- glXQueryContextInfoEXT: TglXQueryContextInfoEXT;
- glXGetContextIDEXT: TglXGetContextIDEXT;
- glXImportContextEXT: TglXImportContextEXT;
- glXFreeContextEXT: TglXFreeContextEXT;
-
- // GLX_EXT_texture_from_pixmap
- glXBindTexImageEXT: TglXBindTexImageEXT;
- glXReleaseTexImageEXT: TglXReleaseTexImageEXT;
-
- // GLX_EXT_swap_control
- glXSwapIntervalEXT: TglXSwapIntervalEXT;
-{$ENDIF}
-
- // GL utility functions and procedures
- gluErrorString: TgluErrorString;
- gluGetString: TgluGetString;
- gluOrtho2D: TgluOrtho2D;
- gluPerspective: TgluPerspective;
- gluPickMatrix: TgluPickMatrix;
- gluLookAt: TgluLookAt;
- gluProject: TgluProject;
- gluUnProject: TgluUnProject;
- gluScaleImage: TgluScaleImage;
- gluBuild1DMipmaps: TgluBuild1DMipmaps;
- gluBuild2DMipmaps: TgluBuild2DMipmaps;
- gluNewQuadric: TgluNewQuadric;
- gluDeleteQuadric: TgluDeleteQuadric;
- gluQuadricNormals: TgluQuadricNormals;
- gluQuadricTexture: TgluQuadricTexture;
- gluQuadricOrientation: TgluQuadricOrientation;
- gluQuadricDrawStyle: TgluQuadricDrawStyle;
- gluCylinder: TgluCylinder;
- gluDisk: TgluDisk;
- gluPartialDisk: TgluPartialDisk;
- gluSphere: TgluSphere;
- gluQuadricCallback: TgluQuadricCallback;
- gluNewTess: TgluNewTess;
- gluDeleteTess: TgluDeleteTess;
- gluTessBeginPolygon: TgluTessBeginPolygon;
- gluTessBeginContour: TgluTessBeginContour;
- gluTessVertex: TgluTessVertex;
- gluTessEndContour: TgluTessEndContour;
- gluTessEndPolygon: TgluTessEndPolygon;
- gluTessProperty: TgluTessProperty;
- gluTessNormal: TgluTessNormal;
- gluTessCallback: TgluTessCallback;
- gluGetTessProperty: TgluGetTessProperty;
- gluNewNurbsRenderer: TgluNewNurbsRenderer;
- gluDeleteNurbsRenderer: TgluDeleteNurbsRenderer;
- gluBeginSurface: TgluBeginSurface;
- gluBeginCurve: TgluBeginCurve;
- gluEndCurve: TgluEndCurve;
- gluEndSurface: TgluEndSurface;
- gluBeginTrim: TgluBeginTrim;
- gluEndTrim: TgluEndTrim;
- gluPwlCurve: TgluPwlCurve;
- gluNurbsCurve: TgluNurbsCurve;
- gluNurbsSurface: TgluNurbsSurface;
- gluLoadSamplingMatrices: TgluLoadSamplingMatrices;
- gluNurbsProperty: TgluNurbsProperty;
- gluGetNurbsProperty: TgluGetNurbsProperty;
- gluNurbsCallback: TgluNurbsCallback;
- gluBeginPolygon: TgluBeginPolygon;
- gluNextContour: TgluNextContour;
- gluEndPolygon: TgluEndPolygon;
-
-
-type
- TRCOptions = set of (opDoubleBuffered, opGDI, opStereo);
-
-var
- GL_LibHandle: Pointer = nil;
- GLU_LibHandle: Pointer = nil;
-
- LastPixelFormat: Integer;
- ExtensionsRead: Boolean;
- ImplementationRead: Boolean;
-
-
-const
-{$IFDEF DGL_WIN}
- OPENGL_LIBNAME = 'OpenGL32.dll';
- GLU_LIBNAME = 'GLU32.dll';
-{$ELSE}
- {$IFDEF darwin}
- OPENGL_LIBNAME = 'libGL.dylib';
- GLU_LIBNAME = 'libGLU.dylib';
- {$ELSE}
- OPENGL_LIBNAME = 'libGL.so.1';
- GLU_LIBNAME = 'libGLU.so.1';
- {$ENDIF}
-{$ENDIF}
-
-function InitOpenGL(LibName: String = OPENGL_LIBNAME; GLULibName: String = GLU_LIBNAME): Boolean;
-
-function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer;
-function dglCheckExtension(Extension: AnsiString): Boolean;
-
-procedure ReadExtensions;
-procedure ReadImplementationProperties;
-
-// =============================================================================
-// Helper-Functions
-// =============================================================================
-{$IFDEF DGL_WIN}
- function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
- function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
- procedure DestroyRenderingContext(RC: HGLRC);
-
- procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
- procedure DeactivateRenderingContext;
-{$ENDIF}
-
-
-procedure ReadOpenGLCore;
-procedure Read_GL_3DFX_tbuffer;
-procedure Read_GL_APPLE_element_array;
-procedure Read_GL_APPLE_fence;
-procedure Read_GL_APPLE_vertex_array_object;
-procedure Read_GL_APPLE_vertex_array_range;
-procedure Read_GL_APPLE_texture_range;
-procedure Read_GL_APPLE_vertex_program_evaluators;
-procedure Read_GL_APPLE_object_purgeable;
-procedure Read_GL_ARB_matrix_palette;
-procedure Read_GL_ARB_multitexture;
-procedure Read_GL_ARB_point_parameters;
-procedure Read_GL_ARB_texture_compression;
-procedure Read_GL_ARB_transpose_matrix;
-procedure Read_GL_ARB_vertex_blend;
-procedure Read_GL_ARB_vertex_buffer_object;
-procedure Read_GL_ARB_vertex_program;
-procedure Read_GL_ARB_window_pos;
-procedure Read_GL_ARB_color_buffer_float;
-procedure Read_GL_ARB_Shader_Objects;
-procedure Read_GL_ARB_occlusion_query;
-procedure Read_GL_ARB_draw_instanced;
-procedure Read_GL_ARB_framebuffer_object;
-procedure Read_GL_ARB_geometry_shader4;
-procedure Read_GL_ARB_instanced_arrays;
-procedure Read_GL_ARB_map_buffer_range;
-procedure Read_GL_ARB_texture_buffer_object;
-procedure Read_GL_ARB_vertex_array_object;
-procedure Read_GL_ARB_uniform_buffer_object;
-procedure Read_GL_ARB_copy_buffer;
-procedure Read_GL_ARB_draw_elements_base_vertex;
-procedure Read_GL_ARB_provoking_vertex;
-procedure Read_GL_ARB_sync;
-procedure Read_GL_ARB_texture_multisample;
-procedure Read_GL_ARB_draw_buffers_blend;
-procedure Read_GL_ARB_sample_shading;
-procedure Read_GL_ARB_shading_language_include;
-procedure Read_GL_ARB_blend_func_extended;
-procedure Read_GL_ARB_sampler_objects;
-procedure Read_GL_ARB_timer_query;
-procedure Read_GL_ARB_vertex_type_2_10_10_10_rev;
-procedure Read_GL_ARB_draw_indirect;
-procedure Read_GL_ARB_gpu_shader_fp64;
-procedure Read_GL_ARB_shader_subroutine;
-procedure Read_GL_ARB_tessellation_shader;
-procedure Read_GL_ARB_transform_feedback2;
-procedure Read_GL_ARB_transform_feedback3;
-procedure Read_GL_ARB_ES2_compatibility;
-procedure Read_GL_ARB_get_program_binary;
-procedure Read_GL_ARB_separate_shader_objects;
-procedure Read_GL_ARB_vertex_attrib_64bit;
-procedure Read_GL_ARB_viewport_array;
-// GL 4.2
-procedure Read_GL_ARB_base_instance;
-procedure Read_GL_ARB_transform_feedback_instanced;
-procedure Read_GL_ARB_internalformat_query;
-procedure Read_GL_ARB_shader_atomic_counters;
-procedure Read_GL_ARB_shader_image_load_store;
-procedure Read_GL_ARB_texture_storage;
-// GL 4.3
-procedure Read_GL_KHR_debug;
-procedure Read_GL_ARB_clear_buffer_object;
-procedure Read_GL_ARB_compute_shader;
-procedure Read_GL_ARB_copy_image;
-procedure Read_GL_ARB_framebuffer_no_attachments;
-procedure Read_GL_ARB_internalformat_query2;
-procedure Read_GL_ARB_invalidate_subdata;
-procedure Read_GL_ARB_multi_draw_indirect;
-procedure Read_GL_ARB_program_interface_query;
-procedure Read_GL_ARB_shader_storage_buffer_object;
-procedure Read_GL_ARB_texture_buffer_range;
-procedure Read_GL_ARB_texture_storage_multisample;
-procedure Read_GL_ARB_texture_view;
-procedure Read_GL_ARB_vertex_attrib_binding;
-
-// GL 4.4
-procedure Read_GL_4_4;
-
-//
-procedure Read_GL_ARB_cl_event;
-procedure Read_GL_ARB_debug_output;
-procedure Read_GL_ARB_robustness;
-procedure Read_GL_ATI_draw_buffers;
-procedure Read_GL_ATI_element_array;
-procedure Read_GL_ATI_envmap_bumpmap;
-procedure Read_GL_ATI_fragment_shader;
-procedure Read_GL_ATI_map_object_buffer;
-procedure Read_GL_ATI_pn_triangles;
-procedure Read_GL_ATI_separate_stencil;
-procedure Read_GL_ATI_vertex_array_object;
-procedure Read_GL_ATI_vertex_attrib_array_object;
-procedure Read_GL_ATI_vertex_streams;
-procedure Read_GL_AMD_performance_monitor;
-procedure Read_GL_AMD_vertex_shader_tesselator;
-procedure Read_GL_AMD_draw_buffers_blend;
-procedure Read_GL_AMD_name_gen_delete;
-procedure Read_GL_AMD_debug_output;
-procedure Read_GL_EXT_blend_color;
-procedure Read_GL_EXT_blend_func_separate;
-procedure Read_GL_EXT_blend_minmax;
-procedure Read_GL_EXT_color_subtable;
-procedure Read_GL_EXT_compiled_vertex_array;
-procedure Read_GL_EXT_convolution;
-procedure Read_GL_EXT_coordinate_frame;
-procedure Read_GL_EXT_copy_texture;
-procedure Read_GL_EXT_cull_vertex;
-procedure Read_GL_EXT_draw_range_elements;
-procedure Read_GL_EXT_fog_coord;
-procedure Read_GL_EXT_framebuffer_object;
-procedure Read_GL_EXT_histogram;
-procedure Read_GL_EXT_index_func;
-procedure Read_GL_EXT_index_material;
-procedure Read_GL_EXT_multi_draw_arrays;
-procedure Read_GL_EXT_multisample;
-procedure Read_GL_EXT_paletted_texture;
-procedure Read_GL_EXT_pixel_transform;
-procedure Read_GL_EXT_point_parameters;
-procedure Read_GL_EXT_polygon_offset;
-procedure Read_GL_EXT_secondary_color;
-procedure Read_GL_EXT_stencil_two_side;
-procedure Read_GL_EXT_subtexture;
-procedure Read_GL_EXT_texture3D;
-procedure Read_GL_EXT_texture_object;
-procedure Read_GL_EXT_texture_perturb_normal;
-procedure Read_GL_EXT_vertex_array;
-procedure Read_GL_EXT_vertex_shader;
-procedure Read_GL_EXT_vertex_weighting;
-procedure Read_GL_EXT_depth_bounds_test;
-procedure Read_GL_EXT_blend_equation_separate;
-procedure Read_GL_EXT_stencil_clear_tag;
-procedure Read_GL_EXT_framebuffer_blit;
-procedure Read_GL_EXT_framebuffer_multisample;
-procedure Read_GL_EXT_timer_query;
-procedure Read_GL_EXT_gpu_program_parameters;
-procedure Read_GL_EXT_bindable_uniform;
-procedure Read_GL_EXT_draw_buffers2;
-procedure Read_GL_EXT_draw_instanced;
-procedure Read_GL_EXT_geometry_shader4;
-procedure Read_GL_EXT_gpu_shader4;
-procedure Read_GL_EXT_texture_array;
-procedure Read_GL_EXT_texture_buffer_object;
-procedure Read_GL_EXT_texture_integer;
-procedure Read_GL_EXT_transform_feedback;
-procedure Read_GL_EXT_direct_state_access;
-procedure Read_GL_EXT_separate_shader_objects;
-procedure Read_GL_EXT_shader_image_load_store;
-procedure Read_GL_EXT_vertex_attrib_64bit;
-procedure Read_GL_HP_image_transform;
-procedure Read_GL_IBM_multimode_draw_arrays;
-procedure Read_GL_IBM_vertex_array_lists;
-procedure Read_GL_INGR_blend_func_separate;
-procedure Read_GL_INTEL_parallel_arrays;
-procedure Read_GL_MESA_resize_buffers;
-procedure Read_GL_MESA_window_pos;
-procedure Read_GL_NV_evaluators;
-procedure Read_GL_NV_fence;
-procedure Read_GL_NV_fragment_program;
-procedure Read_GL_NV_half_float;
-procedure Read_GL_NV_occlusion_query;
-procedure Read_GL_NV_pixel_data_range;
-procedure Read_GL_NV_point_sprite;
-procedure Read_GL_NV_primitive_restart;
-procedure Read_GL_NV_register_combiners;
-procedure Read_GL_NV_register_combiners2;
-procedure Read_GL_NV_vertex_array_range;
-procedure Read_GL_NV_vertex_program;
-procedure Read_GL_NV_depth_buffer_float;
-procedure Read_GL_NV_framebuffer_multisample_coverage;
-procedure Read_GL_NV_geometry_program4;
-procedure Read_GL_NV_gpu_program4;
-procedure Read_GL_NV_parameter_buffer_object;
-procedure Read_GL_NV_transform_feedback;
-procedure Read_GL_NV_conditional_render;
-procedure Read_GL_NV_present_video;
-procedure Read_GL_NV_explicit_multisample;
-procedure Read_GL_NV_transform_feedback2;
-procedure Read_GL_NV_video_capture;
-procedure Read_GL_NV_copy_image;
-procedure Read_GL_NV_shader_buffer_load;
-procedure Read_GL_NV_vertex_buffer_unified_memory;
-procedure Read_GL_NV_gpu_program5;
-procedure Read_GL_NV_gpu_shader5;
-procedure Read_GL_NV_vertex_attrib_integer_64bit;
-procedure Read_GL_NV_vdpau_interop;
-procedure Read_GL_NV_texture_barrier;
-procedure Read_GL_PGI_misc_hints;
-procedure Read_GL_SGIS_detail_texture;
-procedure Read_GL_SGIS_fog_function;
-procedure Read_GL_SGIS_multisample;
-procedure Read_GL_SGIS_pixel_texture;
-procedure Read_GL_SGIS_point_parameters;
-procedure Read_GL_SGIS_sharpen_texture;
-procedure Read_GL_SGIS_texture4D;
-procedure Read_GL_SGIS_texture_color_mask;
-procedure Read_GL_SGIS_texture_filter4;
-procedure Read_GL_SGIX_async;
-procedure Read_GL_SGIX_flush_raster;
-procedure Read_GL_SGIX_fragment_lighting;
-procedure Read_GL_SGIX_framezoom;
-procedure Read_GL_SGIX_igloo_interface;
-procedure Read_GL_SGIX_instruments;
-procedure Read_GL_SGIX_list_priority;
-procedure Read_GL_SGIX_pixel_texture;
-procedure Read_GL_SGIX_polynomial_ffd;
-procedure Read_GL_SGIX_reference_plane;
-procedure Read_GL_SGIX_sprite;
-procedure Read_GL_SGIX_tag_sample_buffer;
-procedure Read_GL_SGI_color_table;
-procedure Read_GL_SUNX_constant_data;
-procedure Read_GL_SUN_global_alpha;
-procedure Read_GL_SUN_mesh_array;
-procedure Read_GL_SUN_triangle_list;
-procedure Read_GL_SUN_vertex;
-
-{$IFDEF DGL_WIN}
-procedure Read_WGL_ARB_buffer_region;
-procedure Read_WGL_ARB_extensions_string;
-procedure Read_WGL_ARB_make_current_read;
-procedure Read_WGL_ARB_pbuffer;
-procedure Read_WGL_ARB_pixel_format;
-procedure Read_WGL_ARB_pixel_format_float;
-procedure Read_WGL_ARB_render_texture;
-procedure Read_WGL_ARB_create_context;
-procedure Read_WGL_AMD_gpu_association;
-procedure Read_WGL_EXT_display_color_table;
-procedure Read_WGL_EXT_extensions_string;
-procedure Read_WGL_EXT_make_current_read;
-procedure Read_WGL_EXT_pbuffer;
-procedure Read_WGL_EXT_pixel_format;
-procedure Read_WGL_EXT_swap_control;
-procedure Read_WGL_I3D_digital_video_control;
-procedure Read_WGL_I3D_gamma;
-procedure Read_WGL_I3D_genlock;
-procedure Read_WGL_I3D_image_buffer;
-procedure Read_WGL_I3D_swap_frame_lock;
-procedure Read_WGL_I3D_swap_frame_usage;
-procedure Read_WGL_NV_vertex_array_range;
-procedure Read_WGL_NV_present_video;
-procedure Read_WGL_NV_video_output;
-procedure Read_WGL_NV_swap_group;
-procedure Read_WGL_NV_gpu_affinity;
-procedure Read_WGL_NV_video_capture;
-procedure Read_WGL_NV_copy_image;
-procedure Read_WGL_OML_sync_control;
-procedure Read_WGL_3DL_stereo_control;
-
-procedure Read_WIN_draw_range_elements;
-procedure Read_WIN_swap_hint;
-{$ENDIF}
-
-
-implementation
-
-
-{$IFDEF DGL_LINUX}
-const
- RTLD_LAZY = $001;
- RTLD_NOW = $002;
- RTLD_BINDING_MASK = $003;
-
- // Seems to work on Debian / Fedora
- LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF};
-
-function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen';
-function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose';
-
-function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym';
-{$ENDIF}
-
-{$IFDEF DGL_MAC}{$IFDEF OPENGL_FRAMEWORK} // OpenGL framework used
-const
- RTLD_DEFAULT = Pointer(-2);
-{$ENDIF}{$ENDIF}
-
-function dglLoadLibrary(Name: PChar): Pointer;
-begin
- {$IFDEF DGL_WIN}
- Result := {%H-}Pointer(LoadLibrary(Name));
- {$ENDIF}
-
- {$IFDEF DGL_LINUX}
- Result := dlopen(Name, RTLD_LAZY);
- {$ENDIF}
-
- {$IFDEF DGL_MAC}
- {$IFDEF OPENGL_FRAMEWORK}
- Result := RTLD_DEFAULT;
- {$ELSE}
- Result := Pointer(LoadLibrary(Name));
- {$ENDIF}
- {$ENDIF}
-end;
-
-
-function dglFreeLibrary(LibHandle: Pointer): Boolean;
-begin
- if LibHandle = nil then
- Result := False
- else
- {$IFDEF DGL_WIN}
- Result := FreeLibrary({%H-}HMODULE(LibHandle));
- {$ENDIF}
-
- {$IFDEF DGL_LINUX}
- Result := dlclose(LibHandle) = 0;
- {$ENDIF}
-
- {$IFDEF DGL_MAC}
- {$IFDEF OPENGL_FRAMEWORK}
- Result := true;
- {$ELSE}
- Result := FreeLibrary(HMODULE(LibHandle));
- {$ENDIF}
- {$ENDIF}
-end;
-
-
-function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer;
-begin
- if LibHandle = nil then
- LibHandle := GL_LibHandle;
-
- Result := nil;
-
- {$IFDEF DGL_WIN}
- Result := GetProcAddress({%H-}HMODULE(LibHandle), ProcName);
-
- if result <> nil then
- exit;
-
- if Addr(wglGetProcAddress) <> nil then
- Result := wglGetProcAddress(ProcName);
- {$ENDIF}
-
- {$IFDEF DGL_LINUX}
- if not ForceDLSym then begin
- if Addr(glXGetProcAddress) <> nil then
- Result := glXGetProcAddress(ProcName);
-
- if result <> nil then
- exit;
-
- if Addr(glXGetProcAddressARB) <> nil then
- Result := glXGetProcAddressARB(ProcName);
-
- if result <> nil then
- exit;
- end;
-
- Result := dlsym(LibHandle, ProcName);
- {$ENDIF}
-
- {$IFDEF DGL_MAC}
- Result := GetProcAddress(HMODULE(LibHandle), ProcName);
- {$ENDIF}
-end;
-
-
-function Int_GetExtensionString: AnsiString;
-var
- ExtensionCount : GLint;
- i : Integer;
-begin
- if GL_VERSION_3_0
- then
- begin
- if not Assigned(@glGetIntegerv) then glGetIntegerv := dglGetProcAddress('glGetIntegerv');
- if not Assigned(@glGetStringi) then glGetStringi := dglGetProcAddress('glGetStringi');
-
- result := '';
-
- if Assigned(@glGetIntegerv) and Assigned(@glGetStringi)
- then
- begin
- glGetIntegerv(GL_NUM_EXTENSIONS, @extensionCount);
-
- For I := 0 to extensionCount - 1 do
- result := result + #32 + PAnsiChar(glGetStringi(GL_EXTENSIONS, I));
- end;
- end
- else
- begin
- if not Assigned(@glGetString) then glGetString := dglGetProcAddress('glGetString');
-
- if Assigned(@glGetString)
- then result := glGetString(GL_EXTENSIONS)
- else result := '';
- end;
-
- if (GL_LibHandle <> nil) then begin
- {$IFDEF DGL_WIN}
- // wglGetExtensionsStringEXT
- if not Assigned(@wglGetExtensionsStringEXT) then
- wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
-
- if Assigned(@wglGetExtensionsStringEXT) then
- Result := Result + #32 + wglGetExtensionsStringEXT;
-
- // wglGetExtensionsStringARB
- if not Assigned(@wglGetExtensionsStringARB) then
- wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
-
- if Assigned(@wglGetExtensionsStringARB) then
- Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC);
- {$ENDIF}
- end;
-
- Result := #32 + Result + #32;
-end;
-
-
-function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean;
-begin
- Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0;
-end;
-
-
-function dglCheckExtension(Extension: AnsiString): Boolean;
-var
- Extensions: AnsiString;
-begin
- Extensions := Int_GetExtensionString;
- Result := Int_CheckExtension(Extensions, Extension);
-end;
-
-
-
-function InitOpenGL(LibName: String; GLULibName: String): Boolean;
-begin
- Result := False;
-
- // free opened libraries
- if GL_LibHandle <> nil then
- dglFreeLibrary(GL_LibHandle);
-
- if GLU_LibHandle <> nil then
- dglFreeLibrary(GLU_LibHandle);
-
- // load library
- GL_LibHandle := dglLoadLibrary(PChar(LibName));
- GLU_LibHandle := dglLoadLibrary(PChar(GLULibName));
-
- // load GL functions
- if (GL_LibHandle <> nil) then begin
- {$IFDEF DGL_WIN}
- wglCopyContext := dglGetProcAddress('wglCopyContext');
- wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext');
- wglCreateContext := dglGetProcAddress('wglCreateContext');
- wglDeleteContext := dglGetProcAddress('wglDeleteContext');
- wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane');
- wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext');
- wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC');
- wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries');
- wglGetProcAddress := dglGetProcAddress('wglGetProcAddress');
- wglMakeCurrent := dglGetProcAddress('wglMakeCurrent');
- wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette');
- wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries');
- wglShareLists := dglGetProcAddress('wglShareLists');
- wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers');
- wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers');
- wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA');
- wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA');
- wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW');
- wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW');
- wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA');
- wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA');
- {$ENDIF}
-
- {$IFDEF DGL_LINUX}
- // GLX_VERSION_1_4 (needs to be first)
- glXGetProcAddress := dglGetProcAddress('glXGetProcAddress', nil, True);
-
- // GLX_ARB_get_proc_address (also needs to be first)
- glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB', nil, True);
-
- glXChooseVisual := dglGetProcAddress('glXChooseVisual');
- glXCopyContext := dglGetProcAddress('glXCopyContext');
- glXCreateContext := dglGetProcAddress('glXCreateContext');
- glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap');
- glXDestroyContext := dglGetProcAddress('glXDestroyContext');
- glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap');
- glXGetConfig := dglGetProcAddress('glXGetConfig');
- glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext');
- glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable');
- glXIsDirect := dglGetProcAddress('glXIsDirect');
- glXMakeCurrent := dglGetProcAddress('glXMakeCurrent');
- glXQueryExtension := dglGetProcAddress('glXQueryExtension');
- glXQueryVersion := dglGetProcAddress('glXQueryVersion');
- glXSwapBuffers := dglGetProcAddress('glXSwapBuffers');
- glXUseXFont := dglGetProcAddress('glXUseXFont');
- glXWaitGL := dglGetProcAddress('glXWaitGL');
- glXWaitX := dglGetProcAddress('glXWaitX');
-
- glXGetClientString := dglGetProcAddress('glXGetClientString');
- glXQueryServerString := dglGetProcAddress('glXQueryServerString');
- glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString');
-
- // GLX_VERSION_1_3
- glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs');
- glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig');
- glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib');
- glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig');
- glXCreateWindow := dglGetProcAddress('glXCreateWindow');
- glXDestroyWindow := dglGetProcAddress('glXDestroyWindow');
- glXCreatePixmap := dglGetProcAddress('glXCreatePixmap');
-
- glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap');
- glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer');
- glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer');
- glXQueryDrawable := dglGetProcAddress('glXQueryDrawable');
- glXCreateNewContext := dglGetProcAddress('glXCreateNewContext');
- glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent');
- glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable');
- glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay');
-
- glXQueryContext := dglGetProcAddress('glXQueryContext');
- glXSelectEvent := dglGetProcAddress('glXSelectEvent');
- glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent');
-
- // GLX_ARB_create_context
- glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB');
-
- // GLX_EXT_import_context
- glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT');
- glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT');
- glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT');
- glXImportContextEXT := dglGetProcAddress('glXImportContextEXT');
- glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT');
-
- // GLX_EXT_texture_from_pixmap
- glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT');
- glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT');
-
- // GLX_EXT_swap_control
- glXSwapIntervalEXT := dglGetProcAddress('glXSwapIntervalEXT');
- {$ENDIF}
-
- Result := True;
- end;
-
- // load GLU functions
- if GLU_LibHandle <> nil then begin
- // GLU ========================================================================
- gluBeginCurve := dglGetProcAddress('gluBeginCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluBeginPolygon := dglGetProcAddress('gluBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluBeginSurface := dglGetProcAddress('gluBeginSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluBeginTrim := dglGetProcAddress('gluBeginTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluBuild1DMipmaps := dglGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluBuild2DMipmaps := dglGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluCylinder := dglGetProcAddress('gluCylinder', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluDeleteNurbsRenderer := dglGetProcAddress('gluDeleteNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluDeleteQuadric := dglGetProcAddress('gluDeleteQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluDeleteTess := dglGetProcAddress('gluDeleteTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluDisk := dglGetProcAddress('gluDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluEndCurve := dglGetProcAddress('gluEndCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluEndPolygon := dglGetProcAddress('gluEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluEndSurface := dglGetProcAddress('gluEndSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluEndTrim := dglGetProcAddress('gluEndTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluErrorString := dglGetProcAddress('gluErrorString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluGetNurbsProperty := dglGetProcAddress('gluGetNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluGetString := dglGetProcAddress('gluGetString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluGetTessProperty := dglGetProcAddress('gluGetTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluLoadSamplingMatrices := dglGetProcAddress('gluLoadSamplingMatrices', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluLookAt := dglGetProcAddress('gluLookAt', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNewNurbsRenderer := dglGetProcAddress('gluNewNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNewQuadric := dglGetProcAddress('gluNewQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNewTess := dglGetProcAddress('gluNewTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNextContour := dglGetProcAddress('gluNextContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNurbsCallback := dglGetProcAddress('gluNurbsCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNurbsCurve := dglGetProcAddress('gluNurbsCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNurbsProperty := dglGetProcAddress('gluNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluNurbsSurface := dglGetProcAddress('gluNurbsSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluOrtho2D := dglGetProcAddress('gluOrtho2D', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluPartialDisk := dglGetProcAddress('gluPartialDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluPerspective := dglGetProcAddress('gluPerspective', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluPickMatrix := dglGetProcAddress('gluPickMatrix', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluProject := dglGetProcAddress('gluProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluPwlCurve := dglGetProcAddress('gluPwlCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluQuadricCallback := dglGetProcAddress('gluQuadricCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluQuadricDrawStyle := dglGetProcAddress('gluQuadricDrawStyle', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluQuadricNormals := dglGetProcAddress('gluQuadricNormals', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluQuadricOrientation := dglGetProcAddress('gluQuadricOrientation', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluQuadricTexture := dglGetProcAddress('gluQuadricTexture', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluScaleImage := dglGetProcAddress('gluScaleImage', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluSphere := dglGetProcAddress('gluSphere', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessBeginContour := dglGetProcAddress('gluTessBeginContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessBeginPolygon := dglGetProcAddress('gluTessBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessCallback := dglGetProcAddress('gluTessCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessEndContour := dglGetProcAddress('gluTessEndContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessEndPolygon := dglGetProcAddress('gluTessEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessNormal := dglGetProcAddress('gluTessNormal', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessProperty := dglGetProcAddress('gluTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluTessVertex := dglGetProcAddress('gluTessVertex', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- gluUnProject := dglGetProcAddress('gluUnProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
- end;
-end;
-
-procedure ReadOpenGLCore;
-begin
- // GL_VERSION_1_0
- glCullFace := dglGetProcAddress('glCullFace');
- glFrontFace := dglGetProcAddress('glFrontFace');
- glHint := dglGetProcAddress('glHint');
- glLineWidth := dglGetProcAddress('glLineWidth');
- glPointSize := dglGetProcAddress('glPointSize');
- glPolygonMode := dglGetProcAddress('glPolygonMode');
- glScissor := dglGetProcAddress('glScissor');
- glTexParameterf := dglGetProcAddress('glTexParameterf');
- glTexParameterfv := dglGetProcAddress('glTexParameterfv');
- glTexParameteri := dglGetProcAddress('glTexParameteri');
- glTexParameteriv := dglGetProcAddress('glTexParameteriv');
- glTexImage1D := dglGetProcAddress('glTexImage1D');
- glTexImage2D := dglGetProcAddress('glTexImage2D');
- glDrawBuffer := dglGetProcAddress('glDrawBuffer');
- glClear := dglGetProcAddress('glClear');
- glClearColor := dglGetProcAddress('glClearColor');
- glClearStencil := dglGetProcAddress('glClearStencil');
- glClearDepth := dglGetProcAddress('glClearDepth');
- glStencilMask := dglGetProcAddress('glStencilMask');
- glColorMask := dglGetProcAddress('glColorMask');
- glDepthMask := dglGetProcAddress('glDepthMask');
- glDisable := dglGetProcAddress('glDisable');
- glEnable := dglGetProcAddress('glEnable');
- glFinish := dglGetProcAddress('glFinish');
- glFlush := dglGetProcAddress('glFlush');
- glBlendFunc := dglGetProcAddress('glBlendFunc');
- glLogicOp := dglGetProcAddress('glLogicOp');
- glStencilFunc := dglGetProcAddress('glStencilFunc');
- glStencilOp := dglGetProcAddress('glStencilOp');
- glDepthFunc := dglGetProcAddress('glDepthFunc');
- glPixelStoref := dglGetProcAddress('glPixelStoref');
- glPixelStorei := dglGetProcAddress('glPixelStorei');
- glReadBuffer := dglGetProcAddress('glReadBuffer');
- glReadPixels := dglGetProcAddress('glReadPixels');
- glGetBooleanv := dglGetProcAddress('glGetBooleanv');
- glGetDoublev := dglGetProcAddress('glGetDoublev');
- glGetError := dglGetProcAddress('glGetError');
- glGetFloatv := dglGetProcAddress('glGetFloatv');
- glGetIntegerv := dglGetProcAddress('glGetIntegerv');
- glGetString := dglGetProcAddress('glGetString');
- glGetTexImage := dglGetProcAddress('glGetTexImage');
- glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv');
- glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv');
- glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv');
- glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv');
- glIsEnabled := dglGetProcAddress('glIsEnabled');
- glDepthRange := dglGetProcAddress('glDepthRange');
- glViewport := dglGetProcAddress('glViewport');
-
- // GL_VERSION_1_1
- glDrawArrays := dglGetProcAddress('glDrawArrays');
- glDrawElements := dglGetProcAddress('glDrawElements');
- glGetPointerv := dglGetProcAddress('glGetPointerv');
- glPolygonOffset := dglGetProcAddress('glPolygonOffset');
- glCopyTexImage1D := dglGetProcAddress('glCopyTexImage1D');
- glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D');
- glCopyTexSubImage1D := dglGetProcAddress('glCopyTexSubImage1D');
- glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D');
- glTexSubImage1D := dglGetProcAddress('glTexSubImage1D');
- glTexSubImage2D := dglGetProcAddress('glTexSubImage2D');
- glBindTexture := dglGetProcAddress('glBindTexture');
- glDeleteTextures := dglGetProcAddress('glDeleteTextures');
- glGenTextures := dglGetProcAddress('glGenTextures');
-
-{$ifdef DGL_DEPRECATED}
- glAccum := dglGetProcAddress('glAccum');
- glAlphaFunc := dglGetProcAddress('glAlphaFunc');
- glAreTexturesResident := dglGetProcAddress('glAreTexturesResident');
- glArrayElement := dglGetProcAddress('glArrayElement');
- glBegin := dglGetProcAddress('glBegin');
- glBitmap := dglGetProcAddress('glBitmap');
- glCallList := dglGetProcAddress('glCallList');
- glCallLists := dglGetProcAddress('glCallLists');
- glClearAccum := dglGetProcAddress('glClearAccum');
- glClearIndex := dglGetProcAddress('glClearIndex');
- glClipPlane := dglGetProcAddress('glClipPlane');
- glColor3b := dglGetProcAddress('glColor3b');
- glColor3bv := dglGetProcAddress('glColor3bv');
- glColor3d := dglGetProcAddress('glColor3d');
- glColor3dv := dglGetProcAddress('glColor3dv');
- glColor3f := dglGetProcAddress('glColor3f');
- glColor3fv := dglGetProcAddress('glColor3fv');
- glColor3i := dglGetProcAddress('glColor3i');
- glColor3iv := dglGetProcAddress('glColor3iv');
- glColor3s := dglGetProcAddress('glColor3s');
- glColor3sv := dglGetProcAddress('glColor3sv');
- glColor3ub := dglGetProcAddress('glColor3ub');
- glColor3ubv := dglGetProcAddress('glColor3ubv');
- glColor3ui := dglGetProcAddress('glColor3ui');
- glColor3uiv := dglGetProcAddress('glColor3uiv');
- glColor3us := dglGetProcAddress('glColor3us');
- glColor3usv := dglGetProcAddress('glColor3usv');
- glColor4b := dglGetProcAddress('glColor4b');
- glColor4bv := dglGetProcAddress('glColor4bv');
- glColor4d := dglGetProcAddress('glColor4d');
- glColor4dv := dglGetProcAddress('glColor4dv');
- glColor4f := dglGetProcAddress('glColor4f');
- glColor4fv := dglGetProcAddress('glColor4fv');
- glColor4i := dglGetProcAddress('glColor4i');
- glColor4iv := dglGetProcAddress('glColor4iv');
- glColor4s := dglGetProcAddress('glColor4s');
- glColor4sv := dglGetProcAddress('glColor4sv');
- glColor4ub := dglGetProcAddress('glColor4ub');
- glColor4ubv := dglGetProcAddress('glColor4ubv');
- glColor4ui := dglGetProcAddress('glColor4ui');
- glColor4uiv := dglGetProcAddress('glColor4uiv');
- glColor4us := dglGetProcAddress('glColor4us');
- glColor4usv := dglGetProcAddress('glColor4usv');
- glColorMaterial := dglGetProcAddress('glColorMaterial');
- glColorPointer := dglGetProcAddress('glColorPointer');
- glCopyPixels := dglGetProcAddress('glCopyPixels');
- glDeleteLists := dglGetProcAddress('glDeleteLists');
- glDisableClientState := dglGetProcAddress('glDisableClientState');
- glDrawPixels := dglGetProcAddress('glDrawPixels');
- glEdgeFlag := dglGetProcAddress('glEdgeFlag');
- glEdgeFlagPointer := dglGetProcAddress('glEdgeFlagPointer');
- glEdgeFlagv := dglGetProcAddress('glEdgeFlagv');
- glEnableClientState := dglGetProcAddress('glEnableClientState');
- glEnd := dglGetProcAddress('glEnd');
- glEndList := dglGetProcAddress('glEndList');
- glEvalCoord1d := dglGetProcAddress('glEvalCoord1d');
- glEvalCoord1dv := dglGetProcAddress('glEvalCoord1dv');
- glEvalCoord1f := dglGetProcAddress('glEvalCoord1f');
- glEvalCoord1fv := dglGetProcAddress('glEvalCoord1fv');
- glEvalCoord2d := dglGetProcAddress('glEvalCoord2d');
- glEvalCoord2dv := dglGetProcAddress('glEvalCoord2dv');
- glEvalCoord2f := dglGetProcAddress('glEvalCoord2f');
- glEvalCoord2fv := dglGetProcAddress('glEvalCoord2fv');
- glEvalMesh1 := dglGetProcAddress('glEvalMesh1');
- glEvalMesh2 := dglGetProcAddress('glEvalMesh2');
- glEvalPoint1 := dglGetProcAddress('glEvalPoint1');
- glEvalPoint2 := dglGetProcAddress('glEvalPoint2');
- glFeedbackBuffer := dglGetProcAddress('glFeedbackBuffer');
- glFogf := dglGetProcAddress('glFogf');
- glFogfv := dglGetProcAddress('glFogfv');
- glFogi := dglGetProcAddress('glFogi');
- glFogiv := dglGetProcAddress('glFogiv');
- glFrustum := dglGetProcAddress('glFrustum');
- glGenLists := dglGetProcAddress('glGenLists');
- glGetClipPlane := dglGetProcAddress('glGetClipPlane');
- glGetLightfv := dglGetProcAddress('glGetLightfv');
- glGetLightiv := dglGetProcAddress('glGetLightiv');
- glGetMapdv := dglGetProcAddress('glGetMapdv');
- glGetMapfv := dglGetProcAddress('glGetMapfv');
- glGetMapiv := dglGetProcAddress('glGetMapiv');
- glGetMaterialfv := dglGetProcAddress('glGetMaterialfv');
- glGetMaterialiv := dglGetProcAddress('glGetMaterialiv');
- glGetPixelMapfv := dglGetProcAddress('glGetPixelMapfv');
- glGetPixelMapuiv := dglGetProcAddress('glGetPixelMapuiv');
- glGetPixelMapusv := dglGetProcAddress('glGetPixelMapusv');
- glGetPolygonStipple := dglGetProcAddress('glGetPolygonStipple');
- glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv');
- glGetTexEnviv := dglGetProcAddress('glGetTexEnviv');
- glGetTexGendv := dglGetProcAddress('glGetTexGendv');
- glGetTexGenfv := dglGetProcAddress('glGetTexGenfv');
- glGetTexGeniv := dglGetProcAddress('glGetTexGeniv');
- glIndexMask := dglGetProcAddress('glIndexMask');
- glIndexPointer := dglGetProcAddress('glIndexPointer');
- glIndexd := dglGetProcAddress('glIndexd');
- glIndexdv := dglGetProcAddress('glIndexdv');
- glIndexf := dglGetProcAddress('glIndexf');
- glIndexfv := dglGetProcAddress('glIndexfv');
- glIndexi := dglGetProcAddress('glIndexi');
- glIndexiv := dglGetProcAddress('glIndexiv');
- glIndexs := dglGetProcAddress('glIndexs');
- glIndexsv := dglGetProcAddress('glIndexsv');
- glIndexub := dglGetProcAddress('glIndexub');
- glIndexubv := dglGetProcAddress('glIndexubv');
- glInitNames := dglGetProcAddress('glInitNames');
- glInterleavedArrays := dglGetProcAddress('glInterleavedArrays');
- glIsList := dglGetProcAddress('glIsList');
- glIsTexture := dglGetProcAddress('glIsTexture');
- glLightModelf := dglGetProcAddress('glLightModelf');
- glLightModelfv := dglGetProcAddress('glLightModelfv');
- glLightModeli := dglGetProcAddress('glLightModeli');
- glLightModeliv := dglGetProcAddress('glLightModeliv');
- glLightf := dglGetProcAddress('glLightf');
- glLightfv := dglGetProcAddress('glLightfv');
- glLighti := dglGetProcAddress('glLighti');
- glLightiv := dglGetProcAddress('glLightiv');
- glLineStipple := dglGetProcAddress('glLineStipple');
- glListBase := dglGetProcAddress('glListBase');
- glLoadIdentity := dglGetProcAddress('glLoadIdentity');
- glLoadMatrixd := dglGetProcAddress('glLoadMatrixd');
- glLoadMatrixf := dglGetProcAddress('glLoadMatrixf');
- glLoadName := dglGetProcAddress('glLoadName');
- glMap1d := dglGetProcAddress('glMap1d');
- glMap1f := dglGetProcAddress('glMap1f');
- glMap2d := dglGetProcAddress('glMap2d');
- glMap2f := dglGetProcAddress('glMap2f');
- glMapGrid1d := dglGetProcAddress('glMapGrid1d');
- glMapGrid1f := dglGetProcAddress('glMapGrid1f');
- glMapGrid2d := dglGetProcAddress('glMapGrid2d');
- glMapGrid2f := dglGetProcAddress('glMapGrid2f');
- glMaterialf := dglGetProcAddress('glMaterialf');
- glMaterialfv := dglGetProcAddress('glMaterialfv');
- glMateriali := dglGetProcAddress('glMateriali');
- glMaterialiv := dglGetProcAddress('glMaterialiv');
- glMatrixMode := dglGetProcAddress('glMatrixMode');
- glMultMatrixd := dglGetProcAddress('glMultMatrixd');
- glMultMatrixf := dglGetProcAddress('glMultMatrixf');
- glNewList := dglGetProcAddress('glNewList');
- glNormal3b := dglGetProcAddress('glNormal3b');
- glNormal3bv := dglGetProcAddress('glNormal3bv');
- glNormal3d := dglGetProcAddress('glNormal3d');
- glNormal3dv := dglGetProcAddress('glNormal3dv');
- glNormal3f := dglGetProcAddress('glNormal3f');
- glNormal3fv := dglGetProcAddress('glNormal3fv');
- glNormal3i := dglGetProcAddress('glNormal3i');
- glNormal3iv := dglGetProcAddress('glNormal3iv');
- glNormal3s := dglGetProcAddress('glNormal3s');
- glNormal3sv := dglGetProcAddress('glNormal3sv');
- glNormalPointer := dglGetProcAddress('glNormalPointer');
- glOrtho := dglGetProcAddress('glOrtho');
- glPassThrough := dglGetProcAddress('glPassThrough');
- glPixelMapfv := dglGetProcAddress('glPixelMapfv');
- glPixelMapuiv := dglGetProcAddress('glPixelMapuiv');
- glPixelMapusv := dglGetProcAddress('glPixelMapusv');
- glPixelTransferf := dglGetProcAddress('glPixelTransferf');
- glPixelTransferi := dglGetProcAddress('glPixelTransferi');
- glPixelZoom := dglGetProcAddress('glPixelZoom');
- glPolygonStipple := dglGetProcAddress('glPolygonStipple');
- glPopAttrib := dglGetProcAddress('glPopAttrib');
- glPopClientAttrib := dglGetProcAddress('glPopClientAttrib');
- glPopMatrix := dglGetProcAddress('glPopMatrix');
- glPopName := dglGetProcAddress('glPopName');
- glPrioritizeTextures := dglGetProcAddress('glPrioritizeTextures');
- glPushAttrib := dglGetProcAddress('glPushAttrib');
- glPushClientAttrib := dglGetProcAddress('glPushClientAttrib');
- glPushMatrix := dglGetProcAddress('glPushMatrix');
- glPushName := dglGetProcAddress('glPushName');
- glRasterPos2d := dglGetProcAddress('glRasterPos2d');
- glRasterPos2dv := dglGetProcAddress('glRasterPos2dv');
- glRasterPos2f := dglGetProcAddress('glRasterPos2f');
- glRasterPos2fv := dglGetProcAddress('glRasterPos2fv');
- glRasterPos2i := dglGetProcAddress('glRasterPos2i');
- glRasterPos2iv := dglGetProcAddress('glRasterPos2iv');
- glRasterPos2s := dglGetProcAddress('glRasterPos2s');
- glRasterPos2sv := dglGetProcAddress('glRasterPos2sv');
- glRasterPos3d := dglGetProcAddress('glRasterPos3d');
- glRasterPos3dv := dglGetProcAddress('glRasterPos3dv');
- glRasterPos3f := dglGetProcAddress('glRasterPos3f');
- glRasterPos3fv := dglGetProcAddress('glRasterPos3fv');
- glRasterPos3i := dglGetProcAddress('glRasterPos3i');
- glRasterPos3iv := dglGetProcAddress('glRasterPos3iv');
- glRasterPos3s := dglGetProcAddress('glRasterPos3s');
- glRasterPos3sv := dglGetProcAddress('glRasterPos3sv');
- glRasterPos4d := dglGetProcAddress('glRasterPos4d');
- glRasterPos4dv := dglGetProcAddress('glRasterPos4dv');
- glRasterPos4f := dglGetProcAddress('glRasterPos4f');
- glRasterPos4fv := dglGetProcAddress('glRasterPos4fv');
- glRasterPos4i := dglGetProcAddress('glRasterPos4i');
- glRasterPos4iv := dglGetProcAddress('glRasterPos4iv');
- glRasterPos4s := dglGetProcAddress('glRasterPos4s');
- glRasterPos4sv := dglGetProcAddress('glRasterPos4sv');
- glRectd := dglGetProcAddress('glRectd');
- glRectdv := dglGetProcAddress('glRectdv');
- glRectf := dglGetProcAddress('glRectf');
- glRectfv := dglGetProcAddress('glRectfv');
- glRecti := dglGetProcAddress('glRecti');
- glRectiv := dglGetProcAddress('glRectiv');
- glRects := dglGetProcAddress('glRects');
- glRectsv := dglGetProcAddress('glRectsv');
- glRenderMode := dglGetProcAddress('glRenderMode');
- glRotated := dglGetProcAddress('glRotated');
- glRotatef := dglGetProcAddress('glRotatef');
- glScaled := dglGetProcAddress('glScaled');
- glScalef := dglGetProcAddress('glScalef');
- glSelectBuffer := dglGetProcAddress('glSelectBuffer');
- glShadeModel := dglGetProcAddress('glShadeModel');
- glTexCoord1d := dglGetProcAddress('glTexCoord1d');
- glTexCoord1dv := dglGetProcAddress('glTexCoord1dv');
- glTexCoord1f := dglGetProcAddress('glTexCoord1f');
- glTexCoord1fv := dglGetProcAddress('glTexCoord1fv');
- glTexCoord1i := dglGetProcAddress('glTexCoord1i');
- glTexCoord1iv := dglGetProcAddress('glTexCoord1iv');
- glTexCoord1s := dglGetProcAddress('glTexCoord1s');
- glTexCoord1sv := dglGetProcAddress('glTexCoord1sv');
- glTexCoord2d := dglGetProcAddress('glTexCoord2d');
- glTexCoord2dv := dglGetProcAddress('glTexCoord2dv');
- glTexCoord2f := dglGetProcAddress('glTexCoord2f');
- glTexCoord2fv := dglGetProcAddress('glTexCoord2fv');
- glTexCoord2i := dglGetProcAddress('glTexCoord2i');
- glTexCoord2iv := dglGetProcAddress('glTexCoord2iv');
- glTexCoord2s := dglGetProcAddress('glTexCoord2s');
- glTexCoord2sv := dglGetProcAddress('glTexCoord2sv');
- glTexCoord3d := dglGetProcAddress('glTexCoord3d');
- glTexCoord3dv := dglGetProcAddress('glTexCoord3dv');
- glTexCoord3f := dglGetProcAddress('glTexCoord3f');
- glTexCoord3fv := dglGetProcAddress('glTexCoord3fv');
- glTexCoord3i := dglGetProcAddress('glTexCoord3i');
- glTexCoord3iv := dglGetProcAddress('glTexCoord3iv');
- glTexCoord3s := dglGetProcAddress('glTexCoord3s');
- glTexCoord3sv := dglGetProcAddress('glTexCoord3sv');
- glTexCoord4d := dglGetProcAddress('glTexCoord4d');
- glTexCoord4dv := dglGetProcAddress('glTexCoord4dv');
- glTexCoord4f := dglGetProcAddress('glTexCoord4f');
- glTexCoord4fv := dglGetProcAddress('glTexCoord4fv');
- glTexCoord4i := dglGetProcAddress('glTexCoord4i');
- glTexCoord4iv := dglGetProcAddress('glTexCoord4iv');
- glTexCoord4s := dglGetProcAddress('glTexCoord4s');
- glTexCoord4sv := dglGetProcAddress('glTexCoord4sv');
- glTexCoordPointer := dglGetProcAddress('glTexCoordPointer');
- glTexEnvf := dglGetProcAddress('glTexEnvf');
- glTexEnvfv := dglGetProcAddress('glTexEnvfv');
- glTexEnvi := dglGetProcAddress('glTexEnvi');
- glTexEnviv := dglGetProcAddress('glTexEnviv');
- glTexGend := dglGetProcAddress('glTexGend');
- glTexGendv := dglGetProcAddress('glTexGendv');
- glTexGenf := dglGetProcAddress('glTexGenf');
- glTexGenfv := dglGetProcAddress('glTexGenfv');
- glTexGeni := dglGetProcAddress('glTexGeni');
- glTexGeniv := dglGetProcAddress('glTexGeniv');
- glTranslated := dglGetProcAddress('glTranslated');
- glTranslatef := dglGetProcAddress('glTranslatef');
- glVertex2d := dglGetProcAddress('glVertex2d');
- glVertex2dv := dglGetProcAddress('glVertex2dv');
- glVertex2f := dglGetProcAddress('glVertex2f');
- glVertex2fv := dglGetProcAddress('glVertex2fv');
- glVertex2i := dglGetProcAddress('glVertex2i');
- glVertex2iv := dglGetProcAddress('glVertex2iv');
- glVertex2s := dglGetProcAddress('glVertex2s');
- glVertex2sv := dglGetProcAddress('glVertex2sv');
- glVertex3d := dglGetProcAddress('glVertex3d');
- glVertex3dv := dglGetProcAddress('glVertex3dv');
- glVertex3f := dglGetProcAddress('glVertex3f');
- glVertex3fv := dglGetProcAddress('glVertex3fv');
- glVertex3i := dglGetProcAddress('glVertex3i');
- glVertex3iv := dglGetProcAddress('glVertex3iv');
- glVertex3s := dglGetProcAddress('glVertex3s');
- glVertex3sv := dglGetProcAddress('glVertex3sv');
- glVertex4d := dglGetProcAddress('glVertex4d');
- glVertex4dv := dglGetProcAddress('glVertex4dv');
- glVertex4f := dglGetProcAddress('glVertex4f');
- glVertex4fv := dglGetProcAddress('glVertex4fv');
- glVertex4i := dglGetProcAddress('glVertex4i');
- glVertex4iv := dglGetProcAddress('glVertex4iv');
- glVertex4s := dglGetProcAddress('glVertex4s');
- glVertex4sv := dglGetProcAddress('glVertex4sv');
- glVertexPointer := dglGetProcAddress('glVertexPointer');
-{$endif}
-
- // GL_VERSION_1_2
- glBlendColor := dglGetProcAddress('glBlendColor');
- glBlendEquation := dglGetProcAddress('glBlendEquation');
- glDrawRangeElements := dglGetProcAddress('glDrawRangeElements');
- glTexImage3D := dglGetProcAddress('glTexImage3D');
- glTexSubImage3D := dglGetProcAddress('glTexSubImage3D');
- glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D');
-{$ifdef DGL_DEPRECATED}
- glColorTable := dglGetProcAddress('glColorTable');
- glColorTableParameterfv := dglGetProcAddress('glColorTableParameterfv');
- glColorTableParameteriv := dglGetProcAddress('glColorTableParameteriv');
- glCopyColorTable := dglGetProcAddress('glCopyColorTable');
- glGetColorTable := dglGetProcAddress('glGetColorTable');
- glGetColorTableParameterfv := dglGetProcAddress('glGetColorTableParameterfv');
- glGetColorTableParameteriv := dglGetProcAddress('glGetColorTableParameteriv');
- glColorSubTable := dglGetProcAddress('glColorSubTable');
- glCopyColorSubTable := dglGetProcAddress('glCopyColorSubTable');
- glConvolutionFilter1D := dglGetProcAddress('glConvolutionFilter1D');
- glConvolutionFilter2D := dglGetProcAddress('glConvolutionFilter2D');
- glConvolutionParameterf := dglGetProcAddress('glConvolutionParameterf');
- glConvolutionParameterfv := dglGetProcAddress('glConvolutionParameterfv');
- glConvolutionParameteri := dglGetProcAddress('glConvolutionParameteri');
- glConvolutionParameteriv := dglGetProcAddress('glConvolutionParameteriv');
- glCopyConvolutionFilter1D := dglGetProcAddress('glCopyConvolutionFilter1D');
- glCopyConvolutionFilter2D := dglGetProcAddress('glCopyConvolutionFilter2D');
- glGetConvolutionFilter := dglGetProcAddress('glGetConvolutionFilter');
- glGetConvolutionParameterfv := dglGetProcAddress('glGetConvolutionParameterfv');
- glGetConvolutionParameteriv := dglGetProcAddress('glGetConvolutionParameteriv');
- glGetSeparableFilter := dglGetProcAddress('glGetSeparableFilter');
- glSeparableFilter2D := dglGetProcAddress('glSeparableFilter2D');
- glGetHistogram := dglGetProcAddress('glGetHistogram');
- glGetHistogramParameterfv := dglGetProcAddress('glGetHistogramParameterfv');
- glGetHistogramParameteriv := dglGetProcAddress('glGetHistogramParameteriv');
- glGetMinmax := dglGetProcAddress('glGetMinmax');
- glGetMinmaxParameterfv := dglGetProcAddress('glGetMinmaxParameterfv');
- glGetMinmaxParameteriv := dglGetProcAddress('glGetMinmaxParameteriv');
- glHistogram := dglGetProcAddress('glHistogram');
- glMinmax := dglGetProcAddress('glMinmax');
- glResetHistogram := dglGetProcAddress('glResetHistogram');
- glResetMinmax := dglGetProcAddress('glResetMinmax');
-{$endif}
-
- // GL_VERSION_1_3
- glActiveTexture := dglGetProcAddress('glActiveTexture');
- glSampleCoverage := dglGetProcAddress('glSampleCoverage');
- glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D');
- glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D');
- glCompressedTexImage1D := dglGetProcAddress('glCompressedTexImage1D');
- glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D');
- glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D');
- glCompressedTexSubImage1D := dglGetProcAddress('glCompressedTexSubImage1D');
- glGetCompressedTexImage := dglGetProcAddress('glGetCompressedTexImage');
-{$ifdef DGL_DEPRECATED}
- glClientActiveTexture := dglGetProcAddress('glClientActiveTexture');
- glMultiTexCoord1d := dglGetProcAddress('glMultiTexCoord1d');
- glMultiTexCoord1dv := dglGetProcAddress('glMultiTexCoord1dv');
- glMultiTexCoord1f := dglGetProcAddress('glMultiTexCoord1f');
- glMultiTexCoord1fv := dglGetProcAddress('glMultiTexCoord1fv');
- glMultiTexCoord1i := dglGetProcAddress('glMultiTexCoord1i');
- glMultiTexCoord1iv := dglGetProcAddress('glMultiTexCoord1iv');
- glMultiTexCoord1s := dglGetProcAddress('glMultiTexCoord1s');
- glMultiTexCoord1sv := dglGetProcAddress('glMultiTexCoord1sv');
- glMultiTexCoord2d := dglGetProcAddress('glMultiTexCoord2d');
- glMultiTexCoord2dv := dglGetProcAddress('glMultiTexCoord2dv');
- glMultiTexCoord2f := dglGetProcAddress('glMultiTexCoord2f');
- glMultiTexCoord2fv := dglGetProcAddress('glMultiTexCoord2fv');
- glMultiTexCoord2i := dglGetProcAddress('glMultiTexCoord2i');
- glMultiTexCoord2iv := dglGetProcAddress('glMultiTexCoord2iv');
- glMultiTexCoord2s := dglGetProcAddress('glMultiTexCoord2s');
- glMultiTexCoord2sv := dglGetProcAddress('glMultiTexCoord2sv');
- glMultiTexCoord3d := dglGetProcAddress('glMultiTexCoord3d');
- glMultiTexCoord3dv := dglGetProcAddress('glMultiTexCoord3dv');
- glMultiTexCoord3f := dglGetProcAddress('glMultiTexCoord3f');
- glMultiTexCoord3fv := dglGetProcAddress('glMultiTexCoord3fv');
- glMultiTexCoord3i := dglGetProcAddress('glMultiTexCoord3i');
- glMultiTexCoord3iv := dglGetProcAddress('glMultiTexCoord3iv');
- glMultiTexCoord3s := dglGetProcAddress('glMultiTexCoord3s');
- glMultiTexCoord3sv := dglGetProcAddress('glMultiTexCoord3sv');
- glMultiTexCoord4d := dglGetProcAddress('glMultiTexCoord4d');
- glMultiTexCoord4dv := dglGetProcAddress('glMultiTexCoord4dv');
- glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f');
- glMultiTexCoord4fv := dglGetProcAddress('glMultiTexCoord4fv');
- glMultiTexCoord4i := dglGetProcAddress('glMultiTexCoord4i');
- glMultiTexCoord4iv := dglGetProcAddress('glMultiTexCoord4iv');
- glMultiTexCoord4s := dglGetProcAddress('glMultiTexCoord4s');
- glMultiTexCoord4sv := dglGetProcAddress('glMultiTexCoord4sv');
- glLoadTransposeMatrixf := dglGetProcAddress('glLoadTransposeMatrixf');
- glLoadTransposeMatrixd := dglGetProcAddress('glLoadTransposeMatrixd');
- glMultTransposeMatrixf := dglGetProcAddress('glMultTransposeMatrixf');
- glMultTransposeMatrixd := dglGetProcAddress('glMultTransposeMatrixd');
-{$endif}
-
- // GL_VERSION_1_4
- glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate');
- glMultiDrawArrays := dglGetProcAddress('glMultiDrawArrays');
- glMultiDrawElements := dglGetProcAddress('glMultiDrawElements');
- glPointParameterf := dglGetProcAddress('glPointParameterf');
- glPointParameterfv := dglGetProcAddress('glPointParameterfv');
- glPointParameteri := dglGetProcAddress('glPointParameteri');
- glPointParameteriv := dglGetProcAddress('glPointParameteriv');
-{$ifdef DGL_DEPRECATED}
- glFogCoordf := dglGetProcAddress('glFogCoordf');
- glFogCoordfv := dglGetProcAddress('glFogCoordfv');
- glFogCoordd := dglGetProcAddress('glFogCoordd');
- glFogCoorddv := dglGetProcAddress('glFogCoorddv');
- glFogCoordPointer := dglGetProcAddress('glFogCoordPointer');
- glSecondaryColor3b := dglGetProcAddress('glSecondaryColor3b');
- glSecondaryColor3bv := dglGetProcAddress('glSecondaryColor3bv');
- glSecondaryColor3d := dglGetProcAddress('glSecondaryColor3d');
- glSecondaryColor3dv := dglGetProcAddress('glSecondaryColor3dv');
- glSecondaryColor3f := dglGetProcAddress('glSecondaryColor3f');
- glSecondaryColor3fv := dglGetProcAddress('glSecondaryColor3fv');
- glSecondaryColor3i := dglGetProcAddress('glSecondaryColor3i');
- glSecondaryColor3iv := dglGetProcAddress('glSecondaryColor3iv');
- glSecondaryColor3s := dglGetProcAddress('glSecondaryColor3s');
- glSecondaryColor3sv := dglGetProcAddress('glSecondaryColor3sv');
- glSecondaryColor3ub := dglGetProcAddress('glSecondaryColor3ub');
- glSecondaryColor3ubv := dglGetProcAddress('glSecondaryColor3ubv');
- glSecondaryColor3ui := dglGetProcAddress('glSecondaryColor3ui');
- glSecondaryColor3uiv := dglGetProcAddress('glSecondaryColor3uiv');
- glSecondaryColor3us := dglGetProcAddress('glSecondaryColor3us');
- glSecondaryColor3usv := dglGetProcAddress('glSecondaryColor3usv');
- glSecondaryColorPointer := dglGetProcAddress('glSecondaryColorPointer');
- glWindowPos2d := dglGetProcAddress('glWindowPos2d');
- glWindowPos2dv := dglGetProcAddress('glWindowPos2dv');
- glWindowPos2f := dglGetProcAddress('glWindowPos2f');
- glWindowPos2fv := dglGetProcAddress('glWindowPos2fv');
- glWindowPos2i := dglGetProcAddress('glWindowPos2i');
- glWindowPos2iv := dglGetProcAddress('glWindowPos2iv');
- glWindowPos2s := dglGetProcAddress('glWindowPos2s');
- glWindowPos2sv := dglGetProcAddress('glWindowPos2sv');
- glWindowPos3d := dglGetProcAddress('glWindowPos3d');
- glWindowPos3dv := dglGetProcAddress('glWindowPos3dv');
- glWindowPos3f := dglGetProcAddress('glWindowPos3f');
- glWindowPos3fv := dglGetProcAddress('glWindowPos3fv');
- glWindowPos3i := dglGetProcAddress('glWindowPos3i');
- glWindowPos3iv := dglGetProcAddress('glWindowPos3iv');
- glWindowPos3s := dglGetProcAddress('glWindowPos3s');
- glWindowPos3sv := dglGetProcAddress('glWindowPos3sv');
-{$endif}
-
- // GL_VERSION_1_5
- glGenQueries := dglGetProcAddress('glGenQueries');
- glDeleteQueries := dglGetProcAddress('glDeleteQueries');
- glIsQuery := dglGetProcAddress('glIsQuery');
- glBeginQuery := dglGetProcAddress('glBeginQuery');
- glEndQuery := dglGetProcAddress('glEndQuery');
- glGetQueryiv := dglGetProcAddress('glGetQueryiv');
- glGetQueryObjectiv := dglGetProcAddress('glGetQueryObjectiv');
- glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv');
- glBindBuffer := dglGetProcAddress('glBindBuffer');
- glDeleteBuffers := dglGetProcAddress('glDeleteBuffers');
- glGenBuffers := dglGetProcAddress('glGenBuffers');
- glIsBuffer := dglGetProcAddress('glIsBuffer');
- glBufferData := dglGetProcAddress('glBufferData');
- glBufferSubData := dglGetProcAddress('glBufferSubData');
- glGetBufferSubData := dglGetProcAddress('glGetBufferSubData');
- glMapBuffer := dglGetProcAddress('glMapBuffer');
- glUnmapBuffer := dglGetProcAddress('glUnmapBuffer');
- glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv');
- glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv');
-
- // GL_VERSION_2_0
- glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate');
- glDrawBuffers := dglGetProcAddress('glDrawBuffers');
- glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate');
- glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate');
- glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate');
- glAttachShader := dglGetProcAddress('glAttachShader');
- glBindAttribLocation := dglGetProcAddress('glBindAttribLocation');
- glCompileShader := dglGetProcAddress('glCompileShader');
- glCreateProgram := dglGetProcAddress('glCreateProgram');
- glCreateShader := dglGetProcAddress('glCreateShader');
- glDeleteProgram := dglGetProcAddress('glDeleteProgram');
- glDeleteShader := dglGetProcAddress('glDeleteShader');
- glDetachShader := dglGetProcAddress('glDetachShader');
- glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray');
- glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray');
- glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib');
- glGetActiveUniform := dglGetProcAddress('glGetActiveUniform');
- glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders');
- glGetAttribLocation := dglGetProcAddress('glGetAttribLocation');
- glGetProgramiv := dglGetProcAddress('glGetProgramiv');
- glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog');
- glGetShaderiv := dglGetProcAddress('glGetShaderiv');
- glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog');
- glGetShaderSource := dglGetProcAddress('glGetShaderSource');
- glGetUniformLocation := dglGetProcAddress('glGetUniformLocation');
- glGetUniformfv := dglGetProcAddress('glGetUniformfv');
- glGetUniformiv := dglGetProcAddress('glGetUniformiv');
- glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv');
- glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv');
- glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv');
- glIsProgram := dglGetProcAddress('glIsProgram');
- glIsShader := dglGetProcAddress('glIsShader');
- glLinkProgram := dglGetProcAddress('glLinkProgram');
- glShaderSource := dglGetProcAddress('glShaderSource');
- glUseProgram := dglGetProcAddress('glUseProgram');
- glUniform1f := dglGetProcAddress('glUniform1f');
- glUniform2f := dglGetProcAddress('glUniform2f');
- glUniform3f := dglGetProcAddress('glUniform3f');
- glUniform4f := dglGetProcAddress('glUniform4f');
- glUniform1i := dglGetProcAddress('glUniform1i');
- glUniform2i := dglGetProcAddress('glUniform2i');
- glUniform3i := dglGetProcAddress('glUniform3i');
- glUniform4i := dglGetProcAddress('glUniform4i');
- glUniform1fv := dglGetProcAddress('glUniform1fv');
- glUniform2fv := dglGetProcAddress('glUniform2fv');
- glUniform3fv := dglGetProcAddress('glUniform3fv');
- glUniform4fv := dglGetProcAddress('glUniform4fv');
- glUniform1iv := dglGetProcAddress('glUniform1iv');
- glUniform2iv := dglGetProcAddress('glUniform2iv');
- glUniform3iv := dglGetProcAddress('glUniform3iv');
- glUniform4iv := dglGetProcAddress('glUniform4iv');
- glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv');
- glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv');
- glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv');
- glValidateProgram := dglGetProcAddress('glValidateProgram');
- glVertexAttrib1d := dglGetProcAddress('glVertexAttrib1d');
- glVertexAttrib1dv := dglGetProcAddress('glVertexAttrib1dv');
- glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f');
- glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv');
- glVertexAttrib1s := dglGetProcAddress('glVertexAttrib1s');
- glVertexAttrib1sv := dglGetProcAddress('glVertexAttrib1sv');
- glVertexAttrib2d := dglGetProcAddress('glVertexAttrib2d');
- glVertexAttrib2dv := dglGetProcAddress('glVertexAttrib2dv');
- glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f');
- glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv');
- glVertexAttrib2s := dglGetProcAddress('glVertexAttrib2s');
- glVertexAttrib2sv := dglGetProcAddress('glVertexAttrib2sv');
- glVertexAttrib3d := dglGetProcAddress('glVertexAttrib3d');
- glVertexAttrib3dv := dglGetProcAddress('glVertexAttrib3dv');
- glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f');
- glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv');
- glVertexAttrib3s := dglGetProcAddress('glVertexAttrib3s');
- glVertexAttrib3sv := dglGetProcAddress('glVertexAttrib3sv');
- glVertexAttrib4Nbv := dglGetProcAddress('glVertexAttrib4Nbv');
- glVertexAttrib4Niv := dglGetProcAddress('glVertexAttrib4Niv');
- glVertexAttrib4Nsv := dglGetProcAddress('glVertexAttrib4Nsv');
- glVertexAttrib4Nub := dglGetProcAddress('glVertexAttrib4Nub');
- glVertexAttrib4Nubv := dglGetProcAddress('glVertexAttrib4Nubv');
- glVertexAttrib4Nuiv := dglGetProcAddress('glVertexAttrib4Nuiv');
- glVertexAttrib4Nusv := dglGetProcAddress('glVertexAttrib4Nusv');
- glVertexAttrib4bv := dglGetProcAddress('glVertexAttrib4bv');
- glVertexAttrib4d := dglGetProcAddress('glVertexAttrib4d');
- glVertexAttrib4dv := dglGetProcAddress('glVertexAttrib4dv');
- glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f');
- glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv');
- glVertexAttrib4iv := dglGetProcAddress('glVertexAttrib4iv');
- glVertexAttrib4s := dglGetProcAddress('glVertexAttrib4s');
- glVertexAttrib4sv := dglGetProcAddress('glVertexAttrib4sv');
- glVertexAttrib4ubv := dglGetProcAddress('glVertexAttrib4ubv');
- glVertexAttrib4uiv := dglGetProcAddress('glVertexAttrib4uiv');
- glVertexAttrib4usv := dglGetProcAddress('glVertexAttrib4usv');
- glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer');
-
- // GL_VERSION_2_1
- glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv');
- glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv');
- glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv');
- glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv');
- glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv');
- glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv');
-
- // GL_VERSION_3_0
- { OpenGL 3.0 also reuses entry points from these extensions: }
- Read_GL_ARB_framebuffer_object;
- Read_GL_ARB_map_buffer_range;
- Read_GL_ARB_vertex_array_object;
-
- glColorMaski := dglGetProcAddress('glColorMaski');
- glGetBooleani_v := dglGetProcAddress('glGetBooleani_v');
- glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v');
- glEnablei := dglGetProcAddress('glEnablei');
- glDisablei := dglGetProcAddress('glDisablei');
- glIsEnabledi := dglGetProcAddress('glIsEnabledi');
- glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback');
- glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback');
- glBindBufferRange := dglGetProcAddress('glBindBufferRange');
- glBindBufferBase := dglGetProcAddress('glBindBufferBase');
- glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings');
- glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying');
- glClampColor := dglGetProcAddress('glClampColor');
- glBeginConditionalRender := dglGetProcAddress('glBeginConditionalRender');
- glEndConditionalRender := dglGetProcAddress('glEndConditionalRender');
- glVertexAttribI1i := dglGetProcAddress('glVertexAttribI1i');
- glVertexAttribI2i := dglGetProcAddress('glVertexAttribI2i');
- glVertexAttribI3i := dglGetProcAddress('glVertexAttribI3i');
- glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i');
- glVertexAttribI1ui := dglGetProcAddress('glVertexAttribI1ui');
- glVertexAttribI2ui := dglGetProcAddress('glVertexAttribI2ui');
- glVertexAttribI3ui := dglGetProcAddress('glVertexAttribI3ui');
- glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui');
- glVertexAttribI1iv := dglGetProcAddress('glVertexAttribI1iv');
- glVertexAttribI2iv := dglGetProcAddress('glVertexAttribI2iv');
- glVertexAttribI3iv := dglGetProcAddress('glVertexAttribI3iv');
- glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv');
- glVertexAttribI1uiv := dglGetProcAddress('glVertexAttribI1uiv');
- glVertexAttribI2uiv := dglGetProcAddress('glVertexAttribI2uiv');
- glVertexAttribI3uiv := dglGetProcAddress('glVertexAttribI3uiv');
- glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv');
- glVertexAttribI4bv := dglGetProcAddress('glVertexAttribI4bv');
- glVertexAttribI4sv := dglGetProcAddress('glVertexAttribI4sv');
- glVertexAttribI4ubv := dglGetProcAddress('glVertexAttribI4ubv');
- glVertexAttribI4usv := dglGetProcAddress('glVertexAttribI4usv');
- glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer');
- glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv');
- glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv');
- glGetUniformuiv := dglGetProcAddress('glGetUniformuiv');
- glBindFragDataLocation := dglGetProcAddress('glBindFragDataLocation');
- glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation');
- glUniform1ui := dglGetProcAddress('glUniform1ui');
- glUniform2ui := dglGetProcAddress('glUniform2ui');
- glUniform3ui := dglGetProcAddress('glUniform3ui');
- glUniform4ui := dglGetProcAddress('glUniform4ui');
- glUniform1uiv := dglGetProcAddress('glUniform1uiv');
- glUniform2uiv := dglGetProcAddress('glUniform2uiv');
- glUniform3uiv := dglGetProcAddress('glUniform3uiv');
- glUniform4uiv := dglGetProcAddress('glUniform4uiv');
- glTexParameterIiv := dglGetProcAddress('glTexParameterIiv');
- glTexParameterIuiv := dglGetProcAddress('glTexParameterIuiv');
- glGetTexParameterIiv := dglGetProcAddress('glGetTexParameterIiv');
- glGetTexParameterIuiv := dglGetProcAddress('glGetTexParameterIuiv');
- glClearBufferiv := dglGetProcAddress('glClearBufferiv');
- glClearBufferuiv := dglGetProcAddress('glClearBufferuiv');
- glClearBufferfv := dglGetProcAddress('glClearBufferfv');
- glClearBufferfi := dglGetProcAddress('glClearBufferfi');
- glGetStringi := dglGetProcAddress('glGetStringi');
-
- // GL_VERSION_2_1
- glEnableVertexArrayEXT := dglGetProcAddress('glEnableVertexArrayEXT');
- glEnableVertexArrayAttribEXT := dglGetProcAddress('glEnableVertexArrayAttribEXT');
- glVertexArrayVertexAttribOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribOffsetEXT');
-
- // GL_VERSION_3_1
- { OpenGL 3.1 also reuses entry points from these extensions: }
- Read_GL_ARB_copy_buffer;
- Read_GL_ARB_uniform_buffer_object;
-
- glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced');
- glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced');
- glTexBuffer := dglGetProcAddress('glTexBuffer');
- glPrimitiveRestartIndex := dglGetProcAddress('glPrimitiveRestartIndex');
-
- // GL_VERSION_3_2
- { OpenGL 3.2 also reuses entry points from these extensions: }
- Read_GL_ARB_draw_elements_base_vertex;
- Read_GL_ARB_provoking_vertex;
- Read_GL_ARB_sync;
- Read_GL_ARB_texture_multisample;
-
- glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v');
- glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v');
- glFramebufferTexture := dglGetProcAddress('glFramebufferTexture');
-// glFramebufferTextureFace := dglGetProcAddress('glFramebufferTextureFace');
-
- // GL_VERSION_3_3
- { OpenGL 3.3 also reuses entry points from these extensions: }
- Read_GL_ARB_blend_func_extended;
- Read_GL_ARB_sampler_objects;
- { ARB_explicit_attrib_location, but it has none }
- { ARB_occlusion_query2 (no entry points) }
- { ARB_shader_bit_encoding (no entry points) }
- { ARB_texture_rgb10_a2ui (no entry points) }
- { ARB_texture_swizzle (no entry points) }
- Read_GL_ARB_timer_query;
- Read_GL_ARB_vertex_type_2_10_10_10_rev;
-
- glVertexAttribDivisor := dglGetProcAddress('glVertexAttribDivisor');
-
- // GL_VERSION_4_0
- { OpenGL 4.0 also reuses entry points from these extensions: }
- { ARB_texture_query_lod (no entry points) }
- Read_GL_ARB_draw_indirect;
- { ARB_gpu_shader5 (no entry points) }
- Read_GL_ARB_gpu_shader_fp64;
- Read_GL_ARB_shader_subroutine;
- Read_GL_ARB_tessellation_shader;
- { ARB_texture_buffer_object_rgb32 (no entry points) }
- { ARB_texture_cube_map_array (no entry points) }
- { ARB_texture_gather (no entry points) }
- Read_GL_ARB_transform_feedback2;
- Read_GL_ARB_transform_feedback3;
-
- glMinSampleShading := dglGetProcAddress('glMinSampleShading');
- glBlendEquationi := dglGetProcAddress('glBlendEquationi');
- glBlendEquationSeparatei := dglGetProcAddress('glBlendEquationSeparatei');
- glBlendFunci := dglGetProcAddress('glBlendFunci');
- glBlendFuncSeparatei := dglGetProcAddress('glBlendFuncSeparatei');
-
- // GL_VERSION_4_1
- { OpenGL 4.1 also reuses entry points from these extensions: }
- Read_GL_ARB_ES2_compatibility;
- Read_GL_ARB_get_program_binary;
- Read_GL_ARB_separate_shader_objects;
- { ARB_shader_precision (no entry points) }
- Read_GL_ARB_vertex_attrib_64bit;
- Read_GL_ARB_viewport_array;
-
- // GL_VERSION_4_2
- { OpenGL 4.2 reuses entry points from these extensions: }
- Read_GL_ARB_base_instance;
- //Read_GL_ARB_shading_language_420pack (no entry points)
- Read_GL_ARB_transform_feedback_instanced;
- //Read_GL_ARB_compressed_texture_pixel_storage (no entry points)
- //Read_GL_ARB_conservative_depth;
- Read_GL_ARB_internalformat_query;
- //Read_GL_ARB_map_buffer_alignment;
- Read_GL_ARB_shader_atomic_counters;
- Read_GL_ARB_shader_image_load_store;
- //Read_GL_ARB_shading_language_packing;
- Read_GL_ARB_texture_storage;
-
- // GL_VERSION_4_3
- // OpenGL 4.3 reuses entry points from these extensions:
- // Read_GL_ARB_arrays_of_arrays (none, GLSL only) (no entry points)
- // Read_GL_ARB_fragment_layer_viewport (none, GLSL only) (no entry points)
- // Read_GL_ARB_shader_image_size (none, GLSL only) (no entry points)
- // Read_GL_ARB_ES3_compatibility (no entry points)
- Read_GL_ARB_clear_buffer_object;
- Read_GL_ARB_compute_shader;
- Read_GL_ARB_copy_image;
- Read_GL_KHR_debug;
- // Read_GL_ARB_explicit_uniform_location (no entry points)
- Read_GL_ARB_framebuffer_no_attachments;
- Read_GL_ARB_internalformat_query2;
- Read_GL_ARB_invalidate_subdata;
- Read_GL_ARB_multi_draw_indirect;
- Read_GL_ARB_program_interface_query;
- // Read_GL_ARB_robust_buffer_access_behavior (none) (no entry points)
- Read_GL_ARB_shader_storage_buffer_object;
- // Read_GL_ARB_stencil_texturing (no entry points)
- Read_GL_ARB_texture_buffer_range;
- // Read_GL_ARB_texture_query_levels (none) (no entry points)
- Read_GL_ARB_texture_storage_multisample;
- Read_GL_ARB_texture_view;
- Read_GL_ARB_vertex_attrib_binding;
-
- // GL_VERSION_4_4
- // Note (Due to Khronos' change in header conventions, no more single read_ functions)
- Read_GL_4_4;
-end;
-
-procedure Read_GL_3DFX_tbuffer;
-begin
- glTbufferMask3DFX := dglGetProcAddress('glTbufferMask3DFX');
-end;
-
-procedure Read_GL_APPLE_element_array;
-begin
- glElementPointerAPPLE := dglGetProcAddress('glElementPointerAPPLE');
- glDrawElementArrayAPPLE := dglGetProcAddress('glDrawElementArrayAPPLE');
- glDrawRangeElementArrayAPPLE := dglGetProcAddress('glDrawRangeElementArrayAPPLE');
- glMultiDrawElementArrayAPPLE := dglGetProcAddress('glMultiDrawElementArrayAPPLE');
- glMultiDrawRangeElementArrayAPPLE := dglGetProcAddress('glMultiDrawRangeElementArrayAPPLE');
-end;
-
-procedure Read_GL_APPLE_fence;
-begin
- glGenFencesAPPLE := dglGetProcAddress('glGenFencesAPPLE');
- glDeleteFencesAPPLE := dglGetProcAddress('glDeleteFencesAPPLE');
- glSetFenceAPPLE := dglGetProcAddress('glSetFenceAPPLE');
- glIsFenceAPPLE := dglGetProcAddress('glIsFenceAPPLE');
- glTestFenceAPPLE := dglGetProcAddress('glTestFenceAPPLE');
- glFinishFenceAPPLE := dglGetProcAddress('glFinishFenceAPPLE');
- glTestObjectAPPLE := dglGetProcAddress('glTestObjectAPPLE');
- glFinishObjectAPPLE := dglGetProcAddress('glFinishObjectAPPLE');
-end;
-
-procedure Read_GL_APPLE_vertex_array_object;
-begin
- glBindVertexArrayAPPLE := dglGetProcAddress('glBindVertexArrayAPPLE');
- glDeleteVertexArraysAPPLE := dglGetProcAddress('glDeleteVertexArraysAPPLE');
- glGenVertexArraysAPPLE := dglGetProcAddress('glGenVertexArraysAPPLE');
- glIsVertexArrayAPPLE := dglGetProcAddress('glIsVertexArrayAPPLE');
-end;
-
-procedure Read_GL_APPLE_vertex_array_range;
-begin
- glVertexArrayRangeAPPLE := dglGetProcAddress('glVertexArrayRangeAPPLE');
- glFlushVertexArrayRangeAPPLE := dglGetProcAddress('glFlushVertexArrayRangeAPPLE');
- glVertexArrayParameteriAPPLE := dglGetProcAddress('glVertexArrayParameteriAPPLE');
-end;
-
-procedure Read_GL_APPLE_texture_range;
-begin
- glTextureRangeAPPLE := dglGetProcAddress('glTextureRangeAPPLE');
- glGetTexParameterPointervAPPLE := dglGetProcAddress('glGetTexParameterPointervAPPLE');
-end;
-
-procedure Read_GL_APPLE_vertex_program_evaluators;
-begin
- glEnableVertexAttribAPPLE := dglGetProcAddress('glEnableVertexAttribAPPLE');
- glDisableVertexAttribAPPLE := dglGetProcAddress('glDisableVertexAttribAPPLE');
- glIsVertexAttribEnabledAPPLE := dglGetProcAddress('glIsVertexAttribEnabledAPPLE');
- glMapVertexAttrib1dAPPLE := dglGetProcAddress('glMapVertexAttrib1dAPPLE');
- glMapVertexAttrib1fAPPLE := dglGetProcAddress('glMapVertexAttrib1fAPPLE');
- glMapVertexAttrib2dAPPLE := dglGetProcAddress('glMapVertexAttrib2dAPPLE');
- glMapVertexAttrib2fAPPLE := dglGetProcAddress('glMapVertexAttrib2fAPPLE');
-end;
-
-procedure Read_GL_APPLE_object_purgeable;
-begin
- glObjectPurgeableAPPLE := dglGetProcAddress('glObjectPurgeableAPPLE');
- glObjectUnpurgeableAPPLE := dglGetProcAddress('glObjectUnpurgeableAPPLE');
- glGetObjectParameterivAPPLE := dglGetProcAddress('glGetObjectParameterivAPPLE');
-end;
-
-procedure Read_GL_ARB_matrix_palette;
-begin
- glCurrentPaletteMatrixARB := dglGetProcAddress('glCurrentPaletteMatrixARB');
- glMatrixIndexubvARB := dglGetProcAddress('glMatrixIndexubvARB');
- glMatrixIndexusvARB := dglGetProcAddress('glMatrixIndexusvARB');
- glMatrixIndexuivARB := dglGetProcAddress('glMatrixIndexuivARB');
- glMatrixIndexPointerARB := dglGetProcAddress('glMatrixIndexPointerARB');
-end;
-
-procedure Read_GL_ARB_multisample;
-begin
- glSampleCoverageARB := dglGetProcAddress('glSampleCoverageARB');
-end;
-
-procedure Read_GL_ARB_multitexture;
-begin
- glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
- glClientActiveTextureARB := dglGetProcAddress('glClientActiveTextureARB');
- glMultiTexCoord1dARB := dglGetProcAddress('glMultiTexCoord1dARB');
- glMultiTexCoord1dvARB := dglGetProcAddress('glMultiTexCoord1dvARB');
- glMultiTexCoord1fARB := dglGetProcAddress('glMultiTexCoord1fARB');
- glMultiTexCoord1fvARB := dglGetProcAddress('glMultiTexCoord1fvARB');
- glMultiTexCoord1iARB := dglGetProcAddress('glMultiTexCoord1iARB');
- glMultiTexCoord1ivARB := dglGetProcAddress('glMultiTexCoord1ivARB');
- glMultiTexCoord1sARB := dglGetProcAddress('glMultiTexCoord1sARB');
- glMultiTexCoord1svARB := dglGetProcAddress('glMultiTexCoord1svARB');
- glMultiTexCoord2dARB := dglGetProcAddress('glMultiTexCoord2dARB');
- glMultiTexCoord2dvARB := dglGetProcAddress('glMultiTexCoord2dvARB');
- glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
- glMultiTexCoord2fvARB := dglGetProcAddress('glMultiTexCoord2fvARB');
- glMultiTexCoord2iARB := dglGetProcAddress('glMultiTexCoord2iARB');
- glMultiTexCoord2ivARB := dglGetProcAddress('glMultiTexCoord2ivARB');
- glMultiTexCoord2sARB := dglGetProcAddress('glMultiTexCoord2sARB');
- glMultiTexCoord2svARB := dglGetProcAddress('glMultiTexCoord2svARB');
- glMultiTexCoord3dARB := dglGetProcAddress('glMultiTexCoord3dARB');
- glMultiTexCoord3dvARB := dglGetProcAddress('glMultiTexCoord3dvARB');
- glMultiTexCoord3fARB := dglGetProcAddress('glMultiTexCoord3fARB');
- glMultiTexCoord3fvARB := dglGetProcAddress('glMultiTexCoord3fvARB');
- glMultiTexCoord3iARB := dglGetProcAddress('glMultiTexCoord3iARB');
- glMultiTexCoord3ivARB := dglGetProcAddress('glMultiTexCoord3ivARB');
- glMultiTexCoord3sARB := dglGetProcAddress('glMultiTexCoord3sARB');
- glMultiTexCoord3svARB := dglGetProcAddress('glMultiTexCoord3svARB');
- glMultiTexCoord4dARB := dglGetProcAddress('glMultiTexCoord4dARB');
- glMultiTexCoord4dvARB := dglGetProcAddress('glMultiTexCoord4dvARB');
- glMultiTexCoord4fARB := dglGetProcAddress('glMultiTexCoord4fARB');
- glMultiTexCoord4fvARB := dglGetProcAddress('glMultiTexCoord4fvARB');
- glMultiTexCoord4iARB := dglGetProcAddress('glMultiTexCoord4iARB');
- glMultiTexCoord4ivARB := dglGetProcAddress('glMultiTexCoord4ivARB');
- glMultiTexCoord4sARB := dglGetProcAddress('glMultiTexCoord4sARB');
- glMultiTexCoord4svARB := dglGetProcAddress('glMultiTexCoord4svARB');
-end;
-
-procedure Read_GL_ARB_point_parameters;
-begin
- glPointParameterfARB := dglGetProcAddress('glPointParameterfARB');
- glPointParameterfvARB := dglGetProcAddress('glPointParameterfvARB');
-end;
-
-procedure Read_GL_ARB_texture_compression;
-begin
- glCompressedTexImage3DARB := dglGetProcAddress('glCompressedTexImage3DARB');
- glCompressedTexImage2DARB := dglGetProcAddress('glCompressedTexImage2DARB');
- glCompressedTexImage1DARB := dglGetProcAddress('glCompressedTexImage1DARB');
- glCompressedTexSubImage3DARB := dglGetProcAddress('glCompressedTexSubImage3DARB');
- glCompressedTexSubImage2DARB := dglGetProcAddress('glCompressedTexSubImage2DARB');
- glCompressedTexSubImage1DARB := dglGetProcAddress('glCompressedTexSubImage1DARB');
- glGetCompressedTexImageARB := dglGetProcAddress('glGetCompressedTexImageARB');
-end;
-
-procedure Read_GL_ARB_transpose_matrix;
-begin
- glLoadTransposeMatrixfARB := dglGetProcAddress('glLoadTransposeMatrixfARB');
- glLoadTransposeMatrixdARB := dglGetProcAddress('glLoadTransposeMatrixdARB');
- glMultTransposeMatrixfARB := dglGetProcAddress('glMultTransposeMatrixfARB');
- glMultTransposeMatrixdARB := dglGetProcAddress('glMultTransposeMatrixdARB');
-end;
-
-procedure Read_GL_ARB_vertex_blend;
-begin
- glWeightbvARB := dglGetProcAddress('glWeightbvARB');
- glWeightsvARB := dglGetProcAddress('glWeightsvARB');
- glWeightivARB := dglGetProcAddress('glWeightivARB');
- glWeightfvARB := dglGetProcAddress('glWeightfvARB');
- glWeightdvARB := dglGetProcAddress('glWeightdvARB');
- glWeightubvARB := dglGetProcAddress('glWeightubvARB');
- glWeightusvARB := dglGetProcAddress('glWeightusvARB');
- glWeightuivARB := dglGetProcAddress('glWeightuivARB');
- glWeightPointerARB := dglGetProcAddress('glWeightPointerARB');
- glVertexBlendARB := dglGetProcAddress('glVertexBlendARB');
-end;
-
-procedure Read_GL_ARB_vertex_buffer_object;
-begin
- glBindBufferARB := dglGetProcAddress('glBindBufferARB');
- glDeleteBuffersARB := dglGetProcAddress('glDeleteBuffersARB');
- glGenBuffersARB := dglGetProcAddress('glGenBuffersARB');
- glIsBufferARB := dglGetProcAddress('glIsBufferARB');
- glBufferDataARB := dglGetProcAddress('glBufferDataARB');
- glBufferSubDataARB := dglGetProcAddress('glBufferSubDataARB');
- glGetBufferSubDataARB := dglGetProcAddress('glGetBufferSubDataARB');
- glMapBufferARB := dglGetProcAddress('glMapBufferARB');
- glUnmapBufferARB := dglGetProcAddress('glUnmapBufferARB');
- glGetBufferParameterivARB := dglGetProcAddress('glGetBufferParameterivARB');
- glGetBufferPointervARB := dglGetProcAddress('glGetBufferPointervARB');
-end;
-
-procedure Read_GL_ARB_vertex_program;
-begin
- glVertexAttrib1dARB := dglGetProcAddress('glVertexAttrib1dARB');
- glVertexAttrib1dvARB := dglGetProcAddress('glVertexAttrib1dvARB');
- glVertexAttrib1fARB := dglGetProcAddress('glVertexAttrib1fARB');
- glVertexAttrib1fvARB := dglGetProcAddress('glVertexAttrib1fvARB');
- glVertexAttrib1sARB := dglGetProcAddress('glVertexAttrib1sARB');
- glVertexAttrib1svARB := dglGetProcAddress('glVertexAttrib1svARB');
- glVertexAttrib2dARB := dglGetProcAddress('glVertexAttrib2dARB');
- glVertexAttrib2dvARB := dglGetProcAddress('glVertexAttrib2dvARB');
- glVertexAttrib2fARB := dglGetProcAddress('glVertexAttrib2fARB');
- glVertexAttrib2fvARB := dglGetProcAddress('glVertexAttrib2fvARB');
- glVertexAttrib2sARB := dglGetProcAddress('glVertexAttrib2sARB');
- glVertexAttrib2svARB := dglGetProcAddress('glVertexAttrib2svARB');
- glVertexAttrib3dARB := dglGetProcAddress('glVertexAttrib3dARB');
- glVertexAttrib3dvARB := dglGetProcAddress('glVertexAttrib3dvARB');
- glVertexAttrib3fARB := dglGetProcAddress('glVertexAttrib3fARB');
- glVertexAttrib3fvARB := dglGetProcAddress('glVertexAttrib3fvARB');
- glVertexAttrib3sARB := dglGetProcAddress('glVertexAttrib3sARB');
- glVertexAttrib3svARB := dglGetProcAddress('glVertexAttrib3svARB');
- glVertexAttrib4NbvARB := dglGetProcAddress('glVertexAttrib4NbvARB');
- glVertexAttrib4NivARB := dglGetProcAddress('glVertexAttrib4NivARB');
- glVertexAttrib4NsvARB := dglGetProcAddress('glVertexAttrib4NsvARB');
- glVertexAttrib4NubARB := dglGetProcAddress('glVertexAttrib4NubARB');
- glVertexAttrib4NubvARB := dglGetProcAddress('glVertexAttrib4NubvARB');
- glVertexAttrib4NuivARB := dglGetProcAddress('glVertexAttrib4NuivARB');
- glVertexAttrib4NusvARB := dglGetProcAddress('glVertexAttrib4NusvARB');
- glVertexAttrib4bvARB := dglGetProcAddress('glVertexAttrib4bvARB');
- glVertexAttrib4dARB := dglGetProcAddress('glVertexAttrib4dARB');
- glVertexAttrib4dvARB := dglGetProcAddress('glVertexAttrib4dvARB');
- glVertexAttrib4fARB := dglGetProcAddress('glVertexAttrib4fARB');
- glVertexAttrib4fvARB := dglGetProcAddress('glVertexAttrib4fvARB');
- glVertexAttrib4ivARB := dglGetProcAddress('glVertexAttrib4ivARB');
- glVertexAttrib4sARB := dglGetProcAddress('glVertexAttrib4sARB');
- glVertexAttrib4svARB := dglGetProcAddress('glVertexAttrib4svARB');
- glVertexAttrib4ubvARB := dglGetProcAddress('glVertexAttrib4ubvARB');
- glVertexAttrib4uivARB := dglGetProcAddress('glVertexAttrib4uivARB');
- glVertexAttrib4usvARB := dglGetProcAddress('glVertexAttrib4usvARB');
- glVertexAttribPointerARB := dglGetProcAddress('glVertexAttribPointerARB');
- glEnableVertexAttribArrayARB := dglGetProcAddress('glEnableVertexAttribArrayARB');
- glDisableVertexAttribArrayARB := dglGetProcAddress('glDisableVertexAttribArrayARB');
- glProgramStringARB := dglGetProcAddress('glProgramStringARB');
- glBindProgramARB := dglGetProcAddress('glBindProgramARB');
- glDeleteProgramsARB := dglGetProcAddress('glDeleteProgramsARB');
- glGenProgramsARB := dglGetProcAddress('glGenProgramsARB');
- glProgramEnvParameter4dARB := dglGetProcAddress('glProgramEnvParameter4dARB');
- glProgramEnvParameter4dvARB := dglGetProcAddress('glProgramEnvParameter4dvARB');
- glProgramEnvParameter4fARB := dglGetProcAddress('glProgramEnvParameter4fARB');
- glProgramEnvParameter4fvARB := dglGetProcAddress('glProgramEnvParameter4fvARB');
- glProgramLocalParameter4dARB := dglGetProcAddress('glProgramLocalParameter4dARB');
- glProgramLocalParameter4dvARB := dglGetProcAddress('glProgramLocalParameter4dvARB');
- glProgramLocalParameter4fARB := dglGetProcAddress('glProgramLocalParameter4fARB');
- glProgramLocalParameter4fvARB := dglGetProcAddress('glProgramLocalParameter4fvARB');
- glGetProgramEnvParameterdvARB := dglGetProcAddress('glGetProgramEnvParameterdvARB');
- glGetProgramEnvParameterfvARB := dglGetProcAddress('glGetProgramEnvParameterfvARB');
- glGetProgramLocalParameterdvARB := dglGetProcAddress('glGetProgramLocalParameterdvARB');
- glGetProgramLocalParameterfvARB := dglGetProcAddress('glGetProgramLocalParameterfvARB');
- glGetProgramivARB := dglGetProcAddress('glGetProgramivARB');
- glGetProgramStringARB := dglGetProcAddress('glGetProgramStringARB');
- glGetVertexAttribdvARB := dglGetProcAddress('glGetVertexAttribdvARB');
- glGetVertexAttribfvARB := dglGetProcAddress('glGetVertexAttribfvARB');
- glGetVertexAttribivARB := dglGetProcAddress('glGetVertexAttribivARB');
- glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
- glIsProgramARB := dglGetProcAddress('glIsProgramARB');
-end;
-
-procedure Read_GL_ARB_window_pos;
-begin
- glWindowPos2dARB := dglGetProcAddress('glWindowPos2dARB');
- glWindowPos2dvARB := dglGetProcAddress('glWindowPos2dvARB');
- glWindowPos2fARB := dglGetProcAddress('glWindowPos2fARB');
- glWindowPos2fvARB := dglGetProcAddress('glWindowPos2fvARB');
- glWindowPos2iARB := dglGetProcAddress('glWindowPos2iARB');
- glWindowPos2ivARB := dglGetProcAddress('glWindowPos2ivARB');
- glWindowPos2sARB := dglGetProcAddress('glWindowPos2sARB');
- glWindowPos2svARB := dglGetProcAddress('glWindowPos2svARB');
- glWindowPos3dARB := dglGetProcAddress('glWindowPos3dARB');
- glWindowPos3dvARB := dglGetProcAddress('glWindowPos3dvARB');
- glWindowPos3fARB := dglGetProcAddress('glWindowPos3fARB');
- glWindowPos3fvARB := dglGetProcAddress('glWindowPos3fvARB');
- glWindowPos3iARB := dglGetProcAddress('glWindowPos3iARB');
- glWindowPos3ivARB := dglGetProcAddress('glWindowPos3ivARB');
- glWindowPos3sARB := dglGetProcAddress('glWindowPos3sARB');
- glWindowPos3svARB := dglGetProcAddress('glWindowPos3svARB');
-end;
-
-procedure Read_GL_ARB_draw_buffers;
-begin
- glDrawBuffersARB := dglGetProcAddress('glDrawBuffersARB');
-end;
-
-procedure Read_GL_ARB_color_buffer_float;
-begin
- glClampColorARB := dglGetProcAddress('glClampColorARB');
-end;
-
-procedure Read_GL_ARB_Shader_Objects;
-begin
- // GL_ARB_Shader_Objects
- glCreateShaderObjectARB := dglGetProcAddress('glCreateShaderObjectARB');
- glShaderSourceARB := dglGetProcAddress('glShaderSourceARB');
- glCompileShaderARB := dglGetProcAddress('glCompileShaderARB');
- glDeleteObjectARB := dglGetProcAddress('glDeleteObjectARB');
- glGetHandleARB := dglGetProcAddress('glGetHandleARB');
- glDetachObjectARB := dglGetProcAddress('glDetachObjectARB');
- glCreateProgramObjectARB := dglGetProcAddress('glCreateProgramObjectARB');
- glAttachObjectARB := dglGetProcAddress('glAttachObjectARB');
- glLinkProgramARB := dglGetProcAddress('glLinkProgramARB');
- glUseProgramObjectARB := dglGetProcAddress('glUseProgramObjectARB');
- glValidateProgramARB := dglGetProcAddress('glValidateProgramARB');
- glGetObjectParameterfvARB := dglGetProcAddress('glGetObjectParameterfvARB');
- glGetObjectParameterivARB := dglGetProcAddress('glGetObjectParameterivARB');
- glGetActiveUniformARB := dglGetProcAddress('glGetActiveUniformARB');
- glGetAttachedObjectsARB := dglGetProcAddress('glGetAttachedObjectsARB');
- glGetShaderSourceARB := dglGetProcAddress('glGetShaderSourceARB');
- glGetUniformfvARB := dglGetProcAddress('glGetUniformfvARB');
- glGetUniformivARB := dglGetProcAddress('glGetUniformivARB');
- glGetUniformLocationARB := dglGetProcAddress('glGetUniformLocationARB');
- glGetInfoLogARB := dglGetProcAddress('glGetInfoLogARB');
- glUniform1fARB := dglGetProcAddress('glUniform1fARB');
- glUniform2fARB := dglGetProcAddress('glUniform2fARB');
- glUniform3fARB := dglGetProcAddress('glUniform3fARB');
- glUniform4fARB := dglGetProcAddress('glUniform4fARB');
- glUniform1iARB := dglGetProcAddress('glUniform1iARB');
- glUniform2iARB := dglGetProcAddress('glUniform2iARB');
- glUniform3iARB := dglGetProcAddress('glUniform3iARB');
- glUniform4iARB := dglGetProcAddress('glUniform4iARB');
- glUniform1fvARB := dglGetProcAddress('glUniform1fvARB');
- glUniform2fvARB := dglGetProcAddress('glUniform2fvARB');
- glUniform3fvARB := dglGetProcAddress('glUniform3fvARB');
- glUniform4fvARB := dglGetProcAddress('glUniform4fvARB');
- glUniform1ivARB := dglGetProcAddress('glUniform1ivARB');
- glUniform2ivARB := dglGetProcAddress('glUniform2ivARB');
- glUniform3ivARB := dglGetProcAddress('glUniform3ivARB');
- glUniform4ivARB := dglGetProcAddress('glUniform4ivARB');
- glUniformMatrix2fvARB := dglGetProcAddress('glUniformMatrix2fvARB');
- glUniformMatrix3fvARB := dglGetProcAddress('glUniformMatrix3fvARB');
- glUniformMatrix4fvARB := dglGetProcAddress('glUniformMatrix4fvARB');
-
- // GL_ARB_vertex_shader
- glGetActiveAttribARB := dglGetProcAddress('glGetActiveAttribARB');
- glGetAttribLocationARB := dglGetProcAddress('glGetAttribLocationARB');
- glBindAttribLocationARB := dglGetProcAddress('glBindAttribLocationARB');
- glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
-end;
-
-procedure Read_GL_ARB_occlusion_query;
-begin
- glGenQueriesARB := dglGetProcAddress('glGenQueriesARB');
- glDeleteQueriesARB := dglGetProcAddress('glDeleteQueriesARB');
- glIsQueryARB := dglGetProcAddress('glIsQueryARB');
- glBeginQueryARB := dglGetProcAddress('glBeginQueryARB');
- glEndQueryARB := dglGetProcAddress('glEndQueryARB');
- glGetQueryivARB := dglGetProcAddress('glGetQueryivARB');
- glGetQueryObjectivARB := dglGetProcAddress('glGetQueryObjectivARB');
- glGetQueryObjectuivARB := dglGetProcAddress('glGetQueryObjectuivARB');
-end;
-
-procedure Read_GL_ARB_draw_instanced;
-begin
- glDrawArraysInstancedARB := dglGetProcAddress('glDrawArraysInstancedARB');
- glDrawElementsInstancedARB := dglGetProcAddress('glDrawElementsInstancedARB');
-end;
-
-procedure Read_GL_ARB_framebuffer_object;
-begin
- glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer');
- glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer');
- glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers');
- glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers');
- glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage');
- glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv');
- glIsFramebuffer := dglGetProcAddress('glIsFramebuffer');
- glBindFramebuffer := dglGetProcAddress('glBindFramebuffer');
- glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers');
- glGenFramebuffers := dglGetProcAddress('glGenFramebuffers');
- glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus');
- glFramebufferTexture1D := dglGetProcAddress('glFramebufferTexture1D');
- glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D');
- glFramebufferTexture3D := dglGetProcAddress('glFramebufferTexture3D');
- glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer');
- glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
- glGenerateMipmap := dglGetProcAddress('glGenerateMipmap');
- glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer');
- glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample');
- glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer');
-end;
-
-procedure Read_GL_ARB_geometry_shader4;
-begin
- glProgramParameteriARB := dglGetProcAddress('glProgramParameteriARB');
- glFramebufferTextureARB := dglGetProcAddress('glFramebufferTextureARB');
- glFramebufferTextureLayerARB := dglGetProcAddress('glFramebufferTextureLayerARB');
- glFramebufferTextureFaceARB := dglGetProcAddress('glFramebufferTextureFaceARB');
-end;
-
-procedure Read_GL_ARB_instanced_arrays;
-begin
- glVertexAttribDivisorARB := dglGetProcAddress('glVertexAttribDivisorARB');
-end;
-
-procedure Read_GL_ARB_map_buffer_range;
-begin
- glMapBufferRange := dglGetProcAddress('glMapBufferRange');
- glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange');
-end;
-
-procedure Read_GL_ARB_texture_buffer_object;
-begin
- glTexBufferARB := dglGetProcAddress('glTexBufferARB');
-end;
-
-procedure Read_GL_ARB_vertex_array_object;
-begin
- glBindVertexArray := dglGetProcAddress('glBindVertexArray');
- glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays');
- glGenVertexArrays := dglGetProcAddress('glGenVertexArrays');
- glIsVertexArray := dglGetProcAddress('glIsVertexArray');
-end;
-
-procedure Read_GL_ARB_uniform_buffer_object;
-begin
- glGetUniformIndices := dglGetProcAddress('glGetUniformIndices');
- glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv');
- glGetActiveUniformName := dglGetProcAddress('glGetActiveUniformName');
- glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex');
- glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv');
- glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName');
- glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding');
-end;
-
-procedure Read_GL_ARB_copy_buffer;
-begin
- glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData');
-end;
-
-procedure Read_GL_ARB_draw_elements_base_vertex;
-begin
- glDrawElementsBaseVertex := dglGetProcAddress('glDrawElementsBaseVertex');
- glDrawRangeElementsBaseVertex := dglGetProcAddress('glDrawRangeElementsBaseVertex');
- glDrawElementsInstancedBaseVertex := dglGetProcAddress('glDrawElementsInstancedBaseVertex');
- glMultiDrawElementsBaseVertex := dglGetProcAddress('glMultiDrawElementsBaseVertex');
-end;
-
-procedure Read_GL_ARB_provoking_vertex;
-begin
- glProvokingVertex := dglGetProcAddress('glProvokingVertex');
-end;
-
-procedure Read_GL_ARB_sync;
-begin
- glFenceSync := dglGetProcAddress('glFenceSync');
- glIsSync := dglGetProcAddress('glIsSync');
- glDeleteSync := dglGetProcAddress('glDeleteSync');
- glClientWaitSync := dglGetProcAddress('glClientWaitSync');
- glWaitSync := dglGetProcAddress('glWaitSync');
- glGetInteger64v := dglGetProcAddress('glGetInteger64v');
- glGetSynciv := dglGetProcAddress('glGetSynciv');
-end;
-
-procedure Read_GL_ARB_texture_multisample;
-begin
- glTexImage2DMultisample := dglGetProcAddress('glTexImage2DMultisample');
- glTexImage3DMultisample := dglGetProcAddress('glTexImage3DMultisample');
- glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv');
- glSampleMaski := dglGetProcAddress('glSampleMaski');
-end;
-
-procedure Read_GL_ARB_draw_buffers_blend;
-begin
- glBlendEquationiARB := dglGetProcAddress('glBlendEquationiARB');
- glBlendEquationSeparateiARB := dglGetProcAddress('glBlendEquationSeparateiARB');
- glBlendFunciARB := dglGetProcAddress('glBlendFunciARB');
- glBlendFuncSeparateiARB := dglGetProcAddress('glBlendFuncSeparateiARB');
-end;
-
-procedure Read_GL_ARB_sample_shading;
-begin
- glMinSampleShadingARB := dglGetProcAddress('glMinSampleShadingARB');
-end;
-
-procedure Read_GL_ARB_shading_language_include;
-begin
- glNamedStringARB := dglGetProcAddress('glNamedStringARB');
- glDeleteNamedStringARB := dglGetProcAddress('glDeleteNamedStringARB');
- glCompileShaderIncludeARB := dglGetProcAddress('glCompileShaderIncludeARB');
- glIsNamedStringARB := dglGetProcAddress('glIsNamedStringARB');
- glGetNamedStringARB := dglGetProcAddress('glGetNamedStringARB');
- glGetNamedStringivARB := dglGetProcAddress('glGetNamedStringivARB');
-end;
-
-procedure Read_GL_ARB_blend_func_extended;
-begin
- glBindFragDataLocationIndexed := dglGetProcAddress('glBindFragDataLocationIndexed');
- glGetFragDataIndex := dglGetProcAddress('glGetFragDataIndex');
-end;
-
-procedure Read_GL_ARB_sampler_objects;
-begin
- glGenSamplers := dglGetProcAddress('glGenSamplers');
- glDeleteSamplers := dglGetProcAddress('glDeleteSamplers');
- glIsSampler := dglGetProcAddress('glIsSampler');
- glBindSampler := dglGetProcAddress('glBindSampler');
- glSamplerParameteri := dglGetProcAddress('glSamplerParameteri');
- glSamplerParameteriv := dglGetProcAddress('glSamplerParameteriv');
- glSamplerParameterf := dglGetProcAddress('glSamplerParameterf');
- glSamplerParameterfv := dglGetProcAddress('glSamplerParameterfv');
- glSamplerParameterIiv := dglGetProcAddress('glSamplerParameterIiv');
- glSamplerParameterIuiv := dglGetProcAddress('glSamplerParameterIuiv');
- glGetSamplerParameteriv := dglGetProcAddress('glGetSamplerParameteriv');
- glGetSamplerParameterIiv := dglGetProcAddress('glGetSamplerParameterIiv');
- glGetSamplerParameterfv := dglGetProcAddress('glGetSamplerParameterfv');
- glGetSamplerParameterIuiv := dglGetProcAddress('glGetSamplerParameterIuiv');
-end;
-
-procedure Read_GL_ARB_timer_query;
-begin
- glQueryCounter := dglGetProcAddress('glQueryCounter');
- glGetQueryObjecti64v := dglGetProcAddress('glGetQueryObjecti64v');
- glGetQueryObjectui64v := dglGetProcAddress('glGetQueryObjectui64v');
-end;
-
-procedure Read_GL_ARB_vertex_type_2_10_10_10_rev;
-begin
- glVertexP2ui := dglGetProcAddress('glVertexP2ui');
- glVertexP2uiv := dglGetProcAddress('glVertexP2uiv');
- glVertexP3ui := dglGetProcAddress('glVertexP3ui');
- glVertexP3uiv := dglGetProcAddress('glVertexP3uiv');
- glVertexP4ui := dglGetProcAddress('glVertexP4ui');
- glVertexP4uiv := dglGetProcAddress('glVertexP4uiv');
- glTexCoordP1ui := dglGetProcAddress('glTexCoordP1ui');
- glTexCoordP1uiv := dglGetProcAddress('glTexCoordP1uiv');
- glTexCoordP2ui := dglGetProcAddress('glTexCoordP2ui');
- glTexCoordP2uiv := dglGetProcAddress('glTexCoordP2uiv');
- glTexCoordP3ui := dglGetProcAddress('glTexCoordP3ui');
- glTexCoordP3uiv := dglGetProcAddress('glTexCoordP3uiv');
- glTexCoordP4ui := dglGetProcAddress('glTexCoordP4ui');
- glTexCoordP4uiv := dglGetProcAddress('glTexCoordP4uiv');
- glMultiTexCoordP1ui := dglGetProcAddress('glMultiTexCoordP1ui');
- glMultiTexCoordP1uiv := dglGetProcAddress('glMultiTexCoordP1uiv');
- glMultiTexCoordP2ui := dglGetProcAddress('glMultiTexCoordP2ui');
- glMultiTexCoordP2uiv := dglGetProcAddress('glMultiTexCoordP2uiv');
- glMultiTexCoordP3ui := dglGetProcAddress('glMultiTexCoordP3ui');
- glMultiTexCoordP3uiv := dglGetProcAddress('glMultiTexCoordP3uiv');
- glMultiTexCoordP4ui := dglGetProcAddress('glMultiTexCoordP4ui');
- glMultiTexCoordP4uiv := dglGetProcAddress('glMultiTexCoordP4uiv');
- glNormalP3ui := dglGetProcAddress('glNormalP3ui');
- glNormalP3uiv := dglGetProcAddress('glNormalP3uiv');
- glColorP3ui := dglGetProcAddress('glColorP3ui');
- glColorP3uiv := dglGetProcAddress('glColorP3uiv');
- glColorP4ui := dglGetProcAddress('glColorP4ui');
- glColorP4uiv := dglGetProcAddress('glColorP4uiv');
- glSecondaryColorP3ui := dglGetProcAddress('glSecondaryColorP3ui');
- glSecondaryColorP3uiv := dglGetProcAddress('glSecondaryColorP3uiv');
- glVertexAttribP1ui := dglGetProcAddress('glVertexAttribP1ui');
- glVertexAttribP1uiv := dglGetProcAddress('glVertexAttribP1uiv');
- glVertexAttribP2ui := dglGetProcAddress('glVertexAttribP2ui');
- glVertexAttribP2uiv := dglGetProcAddress('glVertexAttribP2uiv');
- glVertexAttribP3ui := dglGetProcAddress('glVertexAttribP3ui');
- glVertexAttribP3uiv := dglGetProcAddress('glVertexAttribP3uiv');
- glVertexAttribP4ui := dglGetProcAddress('glVertexAttribP4ui');
- glVertexAttribP4uiv := dglGetProcAddress('glVertexAttribP4uiv');
-end;
-
-procedure Read_GL_ARB_draw_indirect;
-begin
- glDrawArraysIndirect := dglGetProcAddress('glDrawArraysIndirect');
- glDrawElementsIndirect := dglGetProcAddress('glDrawElementsIndirect');
-end;
-
-procedure Read_GL_ARB_gpu_shader_fp64;
-begin
- glUniform1d := dglGetProcAddress('glUniform1d');
- glUniform2d := dglGetProcAddress('glUniform2d');
- glUniform3d := dglGetProcAddress('glUniform3d');
- glUniform4d := dglGetProcAddress('glUniform4d');
- glUniform1dv := dglGetProcAddress('glUniform1dv');
- glUniform2dv := dglGetProcAddress('glUniform2dv');
- glUniform3dv := dglGetProcAddress('glUniform3dv');
- glUniform4dv := dglGetProcAddress('glUniform4dv');
- glUniformMatrix2dv := dglGetProcAddress('glUniformMatrix2dv');
- glUniformMatrix3dv := dglGetProcAddress('glUniformMatrix3dv');
- glUniformMatrix4dv := dglGetProcAddress('glUniformMatrix4dv');
- glUniformMatrix2x3dv := dglGetProcAddress('glUniformMatrix2x3dv');
- glUniformMatrix2x4dv := dglGetProcAddress('glUniformMatrix2x4dv');
- glUniformMatrix3x2dv := dglGetProcAddress('glUniformMatrix3x2dv');
- glUniformMatrix3x4dv := dglGetProcAddress('glUniformMatrix3x4dv');
- glUniformMatrix4x2dv := dglGetProcAddress('glUniformMatrix4x2dv');
- glUniformMatrix4x3dv := dglGetProcAddress('glUniformMatrix4x3dv');
- glGetUniformdv := dglGetProcAddress('glGetUniformdv');
-end;
-
-procedure Read_GL_ARB_shader_subroutine;
-begin
- glGetSubroutineUniformLocation := dglGetProcAddress('glGetSubroutineUniformLocation');
- glGetSubroutineIndex := dglGetProcAddress('glGetSubroutineIndex');
- glGetActiveSubroutineUniformiv := dglGetProcAddress('glGetActiveSubroutineUniformiv');
- glGetActiveSubroutineUniformName := dglGetProcAddress('glGetActiveSubroutineUniformName');
- glGetActiveSubroutineName := dglGetProcAddress('glGetActiveSubroutineName');
- glUniformSubroutinesuiv := dglGetProcAddress('glUniformSubroutinesuiv');
- glGetUniformSubroutineuiv := dglGetProcAddress('glGetUniformSubroutineuiv');
- glGetProgramStageiv := dglGetProcAddress('glGetProgramStageiv');
-end;
-
-procedure Read_GL_ARB_tessellation_shader;
-begin
- glPatchParameteri := dglGetProcAddress('glPatchParameteri');
- glPatchParameterfv := dglGetProcAddress('glPatchParameterfv');
-end;
-
-procedure Read_GL_ARB_transform_feedback2;
-begin
- glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback');
- glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks');
- glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks');
- glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback');
- glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback');
- glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback');
- glDrawTransformFeedback := dglGetProcAddress('glDrawTransformFeedback');
-end;
-
-procedure Read_GL_ARB_transform_feedback3;
-begin
- glDrawTransformFeedbackStream := dglGetProcAddress('glDrawTransformFeedbackStream');
- glBeginQueryIndexed := dglGetProcAddress('glBeginQueryIndexed');
- glEndQueryIndexed := dglGetProcAddress('glEndQueryIndexed');
- glGetQueryIndexediv := dglGetProcAddress('glGetQueryIndexediv');
-end;
-
-procedure Read_GL_ARB_ES2_compatibility;
-begin
- glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler');
- glShaderBinary := dglGetProcAddress('glShaderBinary');
- glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat');
- glDepthRangef := dglGetProcAddress('glDepthRangef');
- glClearDepthf := dglGetProcAddress('glClearDepthf');
-end;
-
-procedure Read_GL_ARB_get_program_binary;
-begin
- glGetProgramBinary := dglGetProcAddress('glGetProgramBinary');
- glProgramBinary := dglGetProcAddress('glProgramBinary');
- glProgramParameteri := dglGetProcAddress('glProgramParameteri');
-end;
-
-procedure Read_GL_ARB_separate_shader_objects;
-begin
- glUseProgramStages := dglGetProcAddress('glUseProgramStages');
- glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram');
- glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv');
- glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline');
- glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines');
- glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines');
- glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline');
- glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv');
- glProgramUniform1i := dglGetProcAddress('glProgramUniform1i');
- glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv');
- glProgramUniform1f := dglGetProcAddress('glProgramUniform1f');
- glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv');
- glProgramUniform1d := dglGetProcAddress('glProgramUniform1d');
- glProgramUniform1dv := dglGetProcAddress('glProgramUniform1dv');
- glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui');
- glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv');
- glProgramUniform2i := dglGetProcAddress('glProgramUniform2i');
- glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv');
- glProgramUniform2f := dglGetProcAddress('glProgramUniform2f');
- glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv');
- glProgramUniform2d := dglGetProcAddress('glProgramUniform2d');
- glProgramUniform2dv := dglGetProcAddress('glProgramUniform2dv');
- glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui');
- glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv');
- glProgramUniform3i := dglGetProcAddress('glProgramUniform3i');
- glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv');
- glProgramUniform3f := dglGetProcAddress('glProgramUniform3f');
- glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv');
- glProgramUniform3d := dglGetProcAddress('glProgramUniform3d');
- glProgramUniform3dv := dglGetProcAddress('glProgramUniform3dv');
- glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui');
- glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv');
- glProgramUniform4i := dglGetProcAddress('glProgramUniform4i');
- glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv');
- glProgramUniform4f := dglGetProcAddress('glProgramUniform4f');
- glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv');
- glProgramUniform4d := dglGetProcAddress('glProgramUniform4d');
- glProgramUniform4dv := dglGetProcAddress('glProgramUniform4dv');
- glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui');
- glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv');
- glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv');
- glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv');
- glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv');
- glProgramUniformMatrix2dv := dglGetProcAddress('glProgramUniformMatrix2dv');
- glProgramUniformMatrix3dv := dglGetProcAddress('glProgramUniformMatrix3dv');
- glProgramUniformMatrix4dv := dglGetProcAddress('glProgramUniformMatrix4dv');
- glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv');
- glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv');
- glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv');
- glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv');
- glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv');
- glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv');
- glProgramUniformMatrix2x3dv := dglGetProcAddress('glProgramUniformMatrix2x3dv');
- glProgramUniformMatrix3x2dv := dglGetProcAddress('glProgramUniformMatrix3x2dv');
- glProgramUniformMatrix2x4dv := dglGetProcAddress('glProgramUniformMatrix2x4dv');
- glProgramUniformMatrix4x2dv := dglGetProcAddress('glProgramUniformMatrix4x2dv');
- glProgramUniformMatrix3x4dv := dglGetProcAddress('glProgramUniformMatrix3x4dv');
- glProgramUniformMatrix4x3dv := dglGetProcAddress('glProgramUniformMatrix4x3dv');
- glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline');
- glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog');
-end;
-
-procedure Read_GL_ARB_vertex_attrib_64bit;
-begin
- glVertexAttribL1d := dglGetProcAddress('glVertexAttribL1d');
- glVertexAttribL2d := dglGetProcAddress('glVertexAttribL2d');
- glVertexAttribL3d := dglGetProcAddress('glVertexAttribL3d');
- glVertexAttribL4d := dglGetProcAddress('glVertexAttribL4d');
- glVertexAttribL1dv := dglGetProcAddress('glVertexAttribL1dv');
- glVertexAttribL2dv := dglGetProcAddress('glVertexAttribL2dv');
- glVertexAttribL3dv := dglGetProcAddress('glVertexAttribL3dv');
- glVertexAttribL4dv := dglGetProcAddress('glVertexAttribL4dv');
- glVertexAttribLPointer := dglGetProcAddress('glVertexAttribLPointer');
- glGetVertexAttribLdv := dglGetProcAddress('glGetVertexAttribLdv');
-end;
-
-procedure Read_GL_ARB_viewport_array;
-begin
- glViewportArrayv := dglGetProcAddress('glViewportArrayv');
- glViewportIndexedf := dglGetProcAddress('glViewportIndexedf');
- glViewportIndexedfv := dglGetProcAddress('glViewportIndexedfv');
- glScissorArrayv := dglGetProcAddress('glScissorArrayv');
- glScissorIndexed := dglGetProcAddress('glScissorIndexed');
- glScissorIndexedv := dglGetProcAddress('glScissorIndexedv');
- glDepthRangeArrayv := dglGetProcAddress('glDepthRangeArrayv');
- glDepthRangeIndexed := dglGetProcAddress('glDepthRangeIndexed');
- glGetFloati_v := dglGetProcAddress('glGetFloati_v');
- glGetDoublei_v := dglGetProcAddress('glGetDoublei_v');
-end;
-
-// GL 4.2
-
-procedure Read_GL_ARB_base_instance;
-begin
-glDrawArraysInstancedBaseInstance := dglGetProcAddress('glDrawArraysInstancedBaseInstance');
-glDrawElementsInstancedBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseInstance');
-glDrawElementsInstancedBaseVertexBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstance');
-end;
-
-procedure Read_GL_ARB_transform_feedback_instanced;
-begin
-glDrawTransformFeedbackInstanced := dglGetProcAddress('glDrawTransformFeedbackInstanced');
-glDrawTransformFeedbackStreamInstanced := dglGetProcAddress('glDrawTransformFeedbackStreamInstanced');
-end;
-
-procedure Read_GL_ARB_internalformat_query;
-begin
-glGetInternalformativ := dglGetProcAddress('glGetInternalformativ');
-end;
-
-procedure Read_GL_ARB_shader_atomic_counters;
-begin
-glGetActiveAtomicCounterBufferiv := dglGetProcAddress('glGetActiveAtomicCounterBufferiv');
-end;
-
-procedure Read_GL_ARB_shader_image_load_store;
-begin
-glBindImageTexture := dglGetProcAddress('glBindImageTexture');
-glMemoryBarrier := dglGetProcAddress('glMemoryBarrier');
-end;
-
-procedure Read_GL_ARB_texture_storage;
-begin
-glTexStorage1D := dglGetProcAddress('glTexStorage1D');
-glTexStorage2D := dglGetProcAddress('glTexStorage2D');
-glTexStorage3D := dglGetProcAddress('glTexStorage3D');
-glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT');
-glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT');
-glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT');
-end;
-
-
-// GL 4.3
-procedure Read_GL_KHR_debug;
-begin
- glDebugMessageControl := dglGetProcAddress('glDebugMessageControl');
- glDebugMessageInsert := dglGetProcAddress('glDebugMessageInsert');
- glDebugMessageCallback := dglGetProcAddress('glDebugMessageCallback');
- glGetDebugMessageLog := dglGetProcAddress('glGetDebugMessageLog');
- glPushDebugGroup := dglGetProcAddress('glPushDebugGroup');
- glPopDebugGroup := dglGetProcAddress('glPopDebugGroup');
- glObjectLabel := dglGetProcAddress('glObjectLabel');
- glGetObjectLabel := dglGetProcAddress('glGetObjectLabel');
- glObjectPtrLabel := dglGetProcAddress('glObjectPtrLabel');
- glGetObjectPtrLabel := dglGetProcAddress('glGetObjectPtrLabel');
-end;
-
-procedure Read_GL_ARB_clear_buffer_object;
-begin
- glClearBufferData := dglGetProcAddress('glClearBufferData');
- glClearBufferSubData := dglGetProcAddress('glClearBufferSubData');
- glClearNamedBufferDataEXT := dglGetProcAddress('glClearNamedBufferDataEXT');
- glClearNamedBufferSubDataEXT := dglGetProcAddress('glClearNamedBufferSubDataEXT');
-end;
-
-procedure Read_GL_ARB_compute_shader;
-begin
- glDispatchCompute := dglGetProcAddress('glDispatchCompute');
- glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect');
-end;
-
-procedure Read_GL_ARB_copy_image;
-begin
- glCopyImageSubData := dglGetProcAddress('glCopyImageSubData');
-end;
-
-procedure Read_GL_ARB_framebuffer_no_attachments;
-begin
- glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri');
- glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv');
- glNamedFramebufferParameteriEXT := dglGetProcAddress('glNamedFramebufferParameteriEXT');
- glGetNamedFramebufferParameterivEXT := dglGetProcAddress('glGetNamedFramebufferParameterivEXT');
-end;
-
-procedure Read_GL_ARB_internalformat_query2;
-begin
- glGetInternalformati64v := dglGetProcAddress('glGetInternalformati64v');;
-end;
-
-procedure Read_GL_ARB_invalidate_subdata;
-begin
- glInvalidateTexSubImage := dglGetProcAddress('glInvalidateTexSubImage');
- glInvalidateTexImage := dglGetProcAddress('glInvalidateTexImage');
- glInvalidateBufferSubData := dglGetProcAddress('glInvalidateBufferSubData');
- glInvalidateBufferData := dglGetProcAddress('glInvalidateBufferData');
- glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer');
- glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer');
-end;
-
-procedure Read_GL_ARB_multi_draw_indirect;
-begin
- glMultiDrawArraysIndirect := dglGetProcAddress('glMultiDrawArraysIndirect');
- glMultiDrawElementsIndirect := dglGetProcAddress('glMultiDrawElementsIndirect');
-end;
-
-procedure Read_GL_ARB_program_interface_query;
-begin
- glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv');
- glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex');
- glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName');
- glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv');
- glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation');
- glGetProgramResourceLocationIndex := dglGetProcAddress('glGetProgramResourceLocationIndex');
-end;
-
-procedure Read_GL_ARB_shader_storage_buffer_object;
-begin
- glShaderStorageBlockBinding := dglGetProcAddress('glShaderStorageBlockBinding');
-end;
-
-procedure Read_GL_ARB_texture_buffer_range;
-begin
- glTexBufferRange := dglGetProcAddress('glTexBufferRange');
- glTextureBufferRangeEXT := dglGetProcAddress('glTextureBufferRangeEXT');
-end;
-
-procedure Read_GL_ARB_texture_storage_multisample;
-begin
- glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample');
- glTexStorage3DMultisample := dglGetProcAddress('glTexStorage3DMultisample');
- glTextureStorage2DMultisampleEXT := dglGetProcAddress('glTextureStorage2DMultisampleEXT');
- glTextureStorage3DMultisampleEXT := dglGetProcAddress('glTextureStorage3DMultisampleEXT');
-end;
-
-procedure Read_GL_ARB_texture_view;
-begin
- glTextureView := dglGetProcAddress('glTextureView');
-end;
-
-procedure Read_GL_ARB_vertex_attrib_binding;
-begin
- glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer');
- glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat');
- glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat');
- glVertexAttribLFormat := dglGetProcAddress('glVertexAttribLFormat');
- glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding');
- glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor');
- glVertexArrayBindVertexBufferEXT := dglGetProcAddress('glVertexArrayBindVertexBufferEXT');
- glVertexArrayVertexAttribFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribFormatEXT');
- glVertexArrayVertexAttribIFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribIFormatEXT');
- glVertexArrayVertexAttribLFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribLFormatEXT');
- glVertexArrayVertexAttribBindingEXT := dglGetProcAddress('glVertexArrayVertexAttribBindingEXT');
- glVertexArrayVertexBindingDivisorEXT := dglGetProcAddress('glVertexArrayVertexBindingDivisorEXT');
-end;
-
-procedure Read_GL_4_4;
-begin
- glBufferStorage := dglGetProcAddress('glBufferStorage');
- glClearTexImage := dglGetProcAddress('glClearTexImage');
- glClearTexSubImage := dglGetProcAddress('glClearTexSubImage');
- glBindBuffersBase := dglGetProcAddress('glBindBuffersBase');
- glBindBuffersRange := dglGetProcAddress('glBindBuffersRange');
- glBindTextures := dglGetProcAddress('glBindTextures');
- glBindSamplers := dglGetProcAddress('glBindSamplers');
- glBindImageTextures := dglGetProcAddress('glBindImageTextures');
- glBindVertexBuffers := dglGetProcAddress('glBindVertexBuffers');
-end;
-
-
-procedure Read_GL_NV_path_rendering;
-begin
- glGenPathsNV := dglGetProcAddress('glGenPathsNV');
- glDeletePathsNV := dglGetProcAddress('glDeletePathsNV');
- glIsPathNV := dglGetProcAddress('glIsPathNV');
- glPathCommandsNV := dglGetProcAddress('glPathCommandsNV');
- glPathCoordsNV := dglGetProcAddress('glPathCoordsNV');
- glPathSubCommandsNV := dglGetProcAddress('glPathSubCommandsNV');
- glPathSubCoordsNV := dglGetProcAddress('glPathSubCoordsNV');
- glPathStringNV := dglGetProcAddress('glPathStringNV');
- glPathGlyphsNV := dglGetProcAddress('glPathGlyphsNV');
- glPathGlyphRangeNV := dglGetProcAddress('glPathGlyphRangeNV');
- glWeightPathsNV := dglGetProcAddress('glWeightPathsNV');
- glCopyPathNV := dglGetProcAddress('glCopyPathNV');
- glInterpolatePathsNV := dglGetProcAddress('glInterpolatePathsNV');
- glTransformPathNV := dglGetProcAddress('glTransformPathNV');
- glPathParameterivNV := dglGetProcAddress('glPathParameterivNV');
- glPathParameteriNV := dglGetProcAddress('glPathParameteriNV');
- glPathParameterfvNV := dglGetProcAddress('glPathParameterfvNV');
- glPathParameterfNV := dglGetProcAddress('glPathParameterfNV');
- glPathDashArrayNV := dglGetProcAddress('glPathDashArrayNV');
- glPathStencilFuncNV := dglGetProcAddress('glPathStencilFuncNV');
- glPathStencilDepthOffsetNV := dglGetProcAddress('glPathStencilDepthOffsetNV');
- glStencilFillPathNV := dglGetProcAddress('glStencilFillPathNV');
- glStencilStrokePathNV := dglGetProcAddress('glStencilStrokePathNV');
- glStencilFillPathInstancedNV := dglGetProcAddress('glStencilFillPathInstancedNV');
- glStencilStrokePathInstancedNV := dglGetProcAddress('glStencilStrokePathInstancedNV');
- glPathCoverDepthFuncNV := dglGetProcAddress('glPathCoverDepthFuncNV');
- glPathColorGenNV := dglGetProcAddress('glPathColorGenNV');
- glPathTexGenNV := dglGetProcAddress('glPathTexGenNV');
- glPathFogGenNV := dglGetProcAddress('glPathFogGenNV');
- glCoverFillPathNV := dglGetProcAddress('glCoverFillPathNV');
- glCoverStrokePathNV := dglGetProcAddress('glCoverStrokePathNV');
- glCoverFillPathInstancedNV := dglGetProcAddress('glCoverFillPathInstancedNV');
- glCoverStrokePathInstancedNV := dglGetProcAddress('glCoverStrokePathInstancedNV');
- glGetPathParameterivNV := dglGetProcAddress('glGetPathParameterivNV');
- glGetPathParameterfvNV := dglGetProcAddress('glGetPathParameterfvNV');
- glGetPathCommandsNV := dglGetProcAddress('glGetPathCommandsNV');
- glGetPathCoordsNV := dglGetProcAddress('glGetPathCoordsNV');
- glGetPathDashArrayNV := dglGetProcAddress('glGetPathDashArrayNV');
- glGetPathMetricsNV := dglGetProcAddress('glGetPathMetricsNV');
- glGetPathMetricRangeNV := dglGetProcAddress('glGetPathMetricRangeNV');
- glGetPathSpacingNV := dglGetProcAddress('glGetPathSpacingNV');
- glGetPathColorGenivNV := dglGetProcAddress('glGetPathColorGenivNV');
- glGetPathColorGenfvNV := dglGetProcAddress('glGetPathColorGenfvNV');
- glGetPathTexGenivNV := dglGetProcAddress('glGetPathTexGenivNV');
- glGetPathTexGenfvNV := dglGetProcAddress('glGetPathTexGenfvNV');
- glIsPointInFillPathNV := dglGetProcAddress('glIsPointInFillPathNV');
- glIsPointInStrokePathNV := dglGetProcAddress('glIsPointInStrokePathNV');
- glGetPathLengthNV := dglGetProcAddress('glGetPathLengthNV');
- glPointAlongPathNV := dglGetProcAddress('glPointAlongPathNV');
-end;
-
-procedure Read_GL_AMD_stencil_operation_extended;
-begin
- glStencilOpValueAMD := dglGetProcAddress('glStencilOpValueAMD');
-end;
-
-procedure Read_GL_NV_bindless_texture;
-begin
- glGetTextureHandleNV := dglGetProcAddress('glGetTextureHandleNV');
- glGetTextureSamplerHandleNV := dglGetProcAddress('glGetTextureSamplerHandleNV');
- glMakeTextureHandleResidentNV := dglGetProcAddress('glMakeTextureHandleResidentNV');
- glMakeTextureHandleNonResidentNV := dglGetProcAddress('glMakeTextureHandleNonResidentNV');
- glGetImageHandleNV := dglGetProcAddress('glGetImageHandleNV');
- glMakeImageHandleResidentNV := dglGetProcAddress('glMakeImageHandleResidentNV');
- glMakeImageHandleNonResidentNV := dglGetProcAddress('glMakeImageHandleNonResidentNV');
- glUniformHandleui64NV := dglGetProcAddress('glUniformHandleui64NV');
- glUniformHandleui64vNV := dglGetProcAddress('glUniformHandleui64vNV');
- glProgramUniformHandleui64NV := dglGetProcAddress('glProgramUniformHandleui64NV');
- glProgramUniformHandleui64vNV := dglGetProcAddress('glProgramUniformHandleui64vNV');
- glIsTextureHandleResidentNV := dglGetProcAddress('glIsTextureHandleResidentNV');
- glIsImageHandleResidentNV := dglGetProcAddress('glIsImageHandleResidentNV');
-end;
-
-procedure Read_GL_ARB_cl_event;
-begin
- glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB');
-end;
-
-procedure Read_GL_ARB_debug_output;
-begin
- glDebugMessageControlARB := dglGetProcAddress('glDebugMessageControlARB');
- glDebugMessageInsertARB := dglGetProcAddress('glDebugMessageInsertARB');
- glDebugMessageCallbackARB := dglGetProcAddress('glDebugMessageCallbackARB');
- glGetDebugMessageLogARB := dglGetProcAddress('glGetDebugMessageLogARB');
-end;
-
-procedure Read_GL_ARB_robustness;
-begin
- glGetGraphicsResetStatusARB := dglGetProcAddress('glGetGraphicsResetStatusARB');
- glGetnMapdvARB := dglGetProcAddress('glGetnMapdvARB');
- glGetnMapfvARB := dglGetProcAddress('glGetnMapfvARB');
- glGetnMapivARB := dglGetProcAddress('glGetnMapivARB');
- glGetnPixelMapfvARB := dglGetProcAddress('glGetnPixelMapfvARB');
- glGetnPixelMapuivARB := dglGetProcAddress('glGetnPixelMapuivARB');
- glGetnPixelMapusvARB := dglGetProcAddress('glGetnPixelMapusvARB');
- glGetnPolygonStippleARB := dglGetProcAddress('glGetnPolygonStippleARB');
- glGetnColorTableARB := dglGetProcAddress('glGetnColorTableARB');
- glGetnConvolutionFilterARB := dglGetProcAddress('glGetnConvolutionFilterARB');
- glGetnSeparableFilterARB := dglGetProcAddress('glGetnSeparableFilterARB');
- glGetnHistogramARB := dglGetProcAddress('glGetnHistogramARB');
- glGetnMinmaxARB := dglGetProcAddress('glGetnMinmaxARB');
- glGetnTexImageARB := dglGetProcAddress('glGetnTexImageARB');
- glReadnPixelsARB := dglGetProcAddress('glReadnPixelsARB');
- glGetnCompressedTexImageARB := dglGetProcAddress('glGetnCompressedTexImageARB');
- glGetnUniformfvARB := dglGetProcAddress('glGetnUniformfvARB');
- glGetnUniformivARB := dglGetProcAddress('glGetnUniformivARB');
- glGetnUniformuivARB := dglGetProcAddress('glGetnUniformuivARB');
- glGetnUniformdvARB := dglGetProcAddress('glGetnUniformdvARB');
-end;
-
-procedure Read_GL_ATI_draw_buffers;
-begin
- glDrawBuffersATI := dglGetProcAddress('glDrawBuffersATI');
-end;
-
-procedure Read_GL_ATI_element_array;
-begin
- glElementPointerATI := dglGetProcAddress('glElementPointerATI');
- glDrawElementArrayATI := dglGetProcAddress('glDrawElementArrayATI');
- glDrawRangeElementArrayATI := dglGetProcAddress('glDrawRangeElementArrayATI');
-end;
-
-procedure Read_GL_ATI_envmap_bumpmap;
-begin
- glTexBumpParameterivATI := dglGetProcAddress('glTexBumpParameterivATI');
- glTexBumpParameterfvATI := dglGetProcAddress('glTexBumpParameterfvATI');
- glGetTexBumpParameterivATI := dglGetProcAddress('glGetTexBumpParameterivATI');
- glGetTexBumpParameterfvATI := dglGetProcAddress('glGetTexBumpParameterfvATI');
-end;
-
-procedure Read_GL_ATI_fragment_shader;
-begin
- glGenFragmentShadersATI := dglGetProcAddress('glGenFragmentShadersATI');
- glBindFragmentShaderATI := dglGetProcAddress('glBindFragmentShaderATI');
- glDeleteFragmentShaderATI := dglGetProcAddress('glDeleteFragmentShaderATI');
- glBeginFragmentShaderATI := dglGetProcAddress('glBeginFragmentShaderATI');
- glEndFragmentShaderATI := dglGetProcAddress('glEndFragmentShaderATI');
- glPassTexCoordATI := dglGetProcAddress('glPassTexCoordATI');
- glSampleMapATI := dglGetProcAddress('glSampleMapATI');
- glColorFragmentOp1ATI := dglGetProcAddress('glColorFragmentOp1ATI');
- glColorFragmentOp2ATI := dglGetProcAddress('glColorFragmentOp2ATI');
- glColorFragmentOp3ATI := dglGetProcAddress('glColorFragmentOp3ATI');
- glAlphaFragmentOp1ATI := dglGetProcAddress('glAlphaFragmentOp1ATI');
- glAlphaFragmentOp2ATI := dglGetProcAddress('glAlphaFragmentOp2ATI');
- glAlphaFragmentOp3ATI := dglGetProcAddress('glAlphaFragmentOp3ATI');
- glSetFragmentShaderConstantATI := dglGetProcAddress('glSetFragmentShaderConstantATI');
-end;
-
-procedure Read_GL_ATI_map_object_buffer;
-begin
- glMapObjectBufferATI := dglGetProcAddress('glMapObjectBufferATI');
- glUnmapObjectBufferATI := dglGetProcAddress('glUnmapObjectBufferATI');
-end;
-
-procedure Read_GL_ATI_pn_triangles;
-begin
- glPNTrianglesiATI := dglGetProcAddress('glPNTrianglesiATI');
- glPNTrianglesfATI := dglGetProcAddress('glPNTrianglesfATI');
-end;
-
-procedure Read_GL_ATI_separate_stencil;
-begin
- glStencilOpSeparateATI := dglGetProcAddress('glStencilOpSeparateATI');
- glStencilFuncSeparateATI := dglGetProcAddress('glStencilFuncSeparateATI');
-end;
-
-procedure Read_GL_ATI_vertex_array_object;
-begin
- glNewObjectBufferATI := dglGetProcAddress('glNewObjectBufferATI');
- glIsObjectBufferATI := dglGetProcAddress('glIsObjectBufferATI');
- glUpdateObjectBufferATI := dglGetProcAddress('glUpdateObjectBufferATI');
- glGetObjectBufferfvATI := dglGetProcAddress('glGetObjectBufferfvATI');
- glGetObjectBufferivATI := dglGetProcAddress('glGetObjectBufferivATI');
- glFreeObjectBufferATI := dglGetProcAddress('glFreeObjectBufferATI');
- glArrayObjectATI := dglGetProcAddress('glArrayObjectATI');
- glGetArrayObjectfvATI := dglGetProcAddress('glGetArrayObjectfvATI');
- glGetArrayObjectivATI := dglGetProcAddress('glGetArrayObjectivATI');
- glVariantArrayObjectATI := dglGetProcAddress('glVariantArrayObjectATI');
- glGetVariantArrayObjectfvATI := dglGetProcAddress('glGetVariantArrayObjectfvATI');
- glGetVariantArrayObjectivATI := dglGetProcAddress('glGetVariantArrayObjectivATI');
-
-end;
-
-procedure Read_GL_ATI_vertex_attrib_array_object;
-begin
- glVertexAttribArrayObjectATI := dglGetProcAddress('glVertexAttribArrayObjectATI');
- glGetVertexAttribArrayObjectfvATI := dglGetProcAddress('glGetVertexAttribArrayObjectfvATI');
- glGetVertexAttribArrayObjectivATI := dglGetProcAddress('glGetVertexAttribArrayObjectivATI');
-end;
-
-procedure Read_GL_ATI_vertex_streams;
-begin
- glVertexStream1sATI := dglGetProcAddress('glVertexStream1sATI');
- glVertexStream1svATI := dglGetProcAddress('glVertexStream1svATI');
- glVertexStream1iATI := dglGetProcAddress('glVertexStream1iATI');
- glVertexStream1ivATI := dglGetProcAddress('glVertexStream1ivATI');
- glVertexStream1fATI := dglGetProcAddress('glVertexStream1fATI');
- glVertexStream1fvATI := dglGetProcAddress('glVertexStream1fvATI');
- glVertexStream1dATI := dglGetProcAddress('glVertexStream1dATI');
- glVertexStream1dvATI := dglGetProcAddress('glVertexStream1dvATI');
- glVertexStream2sATI := dglGetProcAddress('glVertexStream2sATI');
- glVertexStream2svATI := dglGetProcAddress('glVertexStream2svATI');
- glVertexStream2iATI := dglGetProcAddress('glVertexStream2iATI');
- glVertexStream2ivATI := dglGetProcAddress('glVertexStream2ivATI');
- glVertexStream2fATI := dglGetProcAddress('glVertexStream2fATI');
- glVertexStream2fvATI := dglGetProcAddress('glVertexStream2fvATI');
- glVertexStream2dATI := dglGetProcAddress('glVertexStream2dATI');
- glVertexStream2dvATI := dglGetProcAddress('glVertexStream2dvATI');
- glVertexStream3sATI := dglGetProcAddress('glVertexStream3sATI');
- glVertexStream3svATI := dglGetProcAddress('glVertexStream3svATI');
- glVertexStream3iATI := dglGetProcAddress('glVertexStream3iATI');
- glVertexStream3ivATI := dglGetProcAddress('glVertexStream3ivATI');
- glVertexStream3fATI := dglGetProcAddress('glVertexStream3fATI');
- glVertexStream3fvATI := dglGetProcAddress('glVertexStream3fvATI');
- glVertexStream3dATI := dglGetProcAddress('glVertexStream3dATI');
- glVertexStream3dvATI := dglGetProcAddress('glVertexStream3dvATI');
- glVertexStream4sATI := dglGetProcAddress('glVertexStream4sATI');
- glVertexStream4svATI := dglGetProcAddress('glVertexStream4svATI');
- glVertexStream4iATI := dglGetProcAddress('glVertexStream4iATI');
- glVertexStream4ivATI := dglGetProcAddress('glVertexStream4ivATI');
- glVertexStream4fATI := dglGetProcAddress('glVertexStream4fATI');
- glVertexStream4fvATI := dglGetProcAddress('glVertexStream4fvATI');
- glVertexStream4dATI := dglGetProcAddress('glVertexStream4dATI');
- glVertexStream4dvATI := dglGetProcAddress('glVertexStream4dvATI');
- glNormalStream3bATI := dglGetProcAddress('glNormalStream3bATI');
- glNormalStream3bvATI := dglGetProcAddress('glNormalStream3bvATI');
- glNormalStream3sATI := dglGetProcAddress('glNormalStream3sATI');
- glNormalStream3svATI := dglGetProcAddress('glNormalStream3svATI');
- glNormalStream3iATI := dglGetProcAddress('glNormalStream3iATI');
- glNormalStream3ivATI := dglGetProcAddress('glNormalStream3ivATI');
- glNormalStream3fATI := dglGetProcAddress('glNormalStream3fATI');
- glNormalStream3fvATI := dglGetProcAddress('glNormalStream3fvATI');
- glNormalStream3dATI := dglGetProcAddress('glNormalStream3dATI');
- glNormalStream3dvATI := dglGetProcAddress('glNormalStream3dvATI');
- glClientActiveVertexStreamATI := dglGetProcAddress('glClientActiveVertexStreamATI');
- glVertexBlendEnviATI := dglGetProcAddress('glVertexBlendEnviATI');
- glVertexBlendEnvfATI := dglGetProcAddress('glVertexBlendEnvfATI');
-end;
-
-procedure Read_GL_AMD_performance_monitor;
-begin
- glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD');
- glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD');
- glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD');
- glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD');
- glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD');
- glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD');
- glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD');
- glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD');
- glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD');
- glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD');
- glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD');
-end;
-
-procedure Read_GL_AMD_vertex_shader_tesselator;
-begin
- glTessellationFactorAMD := dglGetProcAddress('glTessellationFactorAMD');
- glTessellationModeAMD := dglGetProcAddress('glTessellationModeAMD');
-end;
-
-procedure Read_GL_AMD_draw_buffers_blend;
-begin
- glBlendFuncIndexedAMD := dglGetProcAddress('glBlendFuncIndexedAMD');
- glBlendFuncSeparateIndexedAMD := dglGetProcAddress('glBlendFuncSeparateIndexedAMD');
- glBlendEquationIndexedAMD := dglGetProcAddress('glBlendEquationIndexedAMD');
- glBlendEquationSeparateIndexedAMD := dglGetProcAddress('glBlendEquationSeparateIndexedAMD');
-end;
-
-procedure Read_GL_AMD_name_gen_delete;
-begin
- glGenNamesAMD := dglGetProcAddress('glGenNamesAMD');
- glDeleteNamesAMD := dglGetProcAddress('glDeleteNamesAMD');
- glIsNameAMD := dglGetProcAddress('glIsNameAMD');
-end;
-
-procedure Read_GL_AMD_debug_output;
-begin
- glDebugMessageEnableAMD := dglGetProcAddress('glDebugMessageEnableAMD');
- glDebugMessageInsertAMD := dglGetProcAddress('glDebugMessageInsertAMD');
- glDebugMessageCallbackAMD := dglGetProcAddress('glDebugMessageCallbackAMD');
- glGetDebugMessageLogAMD := dglGetProcAddress('glGetDebugMessageLogAMD');
-end;
-
-procedure Read_GL_EXT_blend_color;
-begin
- glBlendColorEXT := dglGetProcAddress('glBlendColorEXT');
-end;
-
-procedure Read_GL_EXT_blend_func_separate;
-begin
- glBlendFuncSeparateEXT := dglGetProcAddress('glBlendFuncSeparateEXT');
-end;
-
-procedure Read_GL_EXT_blend_minmax;
-begin
- glBlendEquationEXT := dglGetProcAddress('glBlendEquationEXT');
-end;
-
-procedure Read_GL_EXT_color_subtable;
-begin
- glColorSubTableEXT := dglGetProcAddress('glColorSubTableEXT');
- glCopyColorSubTableEXT := dglGetProcAddress('glCopyColorSubTableEXT');
-end;
-
-procedure Read_GL_EXT_compiled_vertex_array;
-begin
- glLockArraysEXT := dglGetProcAddress('glLockArraysEXT');
- glUnlockArraysEXT := dglGetProcAddress('glUnlockArraysEXT');
-end;
-
-procedure Read_GL_EXT_convolution;
-begin
- glConvolutionFilter1DEXT := dglGetProcAddress('glConvolutionFilter1DEXT');
- glConvolutionFilter2DEXT := dglGetProcAddress('glConvolutionFilter2DEXT');
- glConvolutionParameterfEXT := dglGetProcAddress('glConvolutionParameterfEXT');
- glConvolutionParameterfvEXT := dglGetProcAddress('glConvolutionParameterfvEXT');
- glConvolutionParameteriEXT := dglGetProcAddress('glConvolutionParameteriEXT');
- glConvolutionParameterivEXT := dglGetProcAddress('glConvolutionParameterivEXT');
- glCopyConvolutionFilter1DEXT := dglGetProcAddress('glCopyConvolutionFilter1DEXT');
- glCopyConvolutionFilter2DEXT := dglGetProcAddress('glCopyConvolutionFilter2DEXT');
- glGetConvolutionFilterEXT := dglGetProcAddress('glGetConvolutionFilterEXT');
- glGetConvolutionParameterfvEXT := dglGetProcAddress('glGetConvolutionParameterfvEXT');
- glGetConvolutionParameterivEXT := dglGetProcAddress('glGetConvolutionParameterivEXT');
- glGetSeparableFilterEXT := dglGetProcAddress('glGetSeparableFilterEXT');
- glSeparableFilter2DEXT := dglGetProcAddress('glSeparableFilter2DEXT');
-end;
-
-procedure Read_GL_EXT_coordinate_frame;
-begin
- glTangent3bEXT := dglGetProcAddress('glTangent3bEXT');
- glTangent3bvEXT := dglGetProcAddress('glTangent3bvEXT');
- glTangent3dEXT := dglGetProcAddress('glTangent3dEXT');
- glTangent3dvEXT := dglGetProcAddress('glTangent3dvEXT');
- glTangent3fEXT := dglGetProcAddress('glTangent3fEXT');
- glTangent3fvEXT := dglGetProcAddress('glTangent3fvEXT');
- glTangent3iEXT := dglGetProcAddress('glTangent3iEXT');
- glTangent3ivEXT := dglGetProcAddress('glTangent3ivEXT');
- glTangent3sEXT := dglGetProcAddress('glTangent3sEXT');
- glTangent3svEXT := dglGetProcAddress('glTangent3svEXT');
- glBinormal3bEXT := dglGetProcAddress('glBinormal3bEXT');
- glBinormal3bvEXT := dglGetProcAddress('glBinormal3bvEXT');
- glBinormal3dEXT := dglGetProcAddress('glBinormal3dEXT');
- glBinormal3dvEXT := dglGetProcAddress('glBinormal3dvEXT');
- glBinormal3fEXT := dglGetProcAddress('glBinormal3fEXT');
- glBinormal3fvEXT := dglGetProcAddress('glBinormal3fvEXT');
- glBinormal3iEXT := dglGetProcAddress('glBinormal3iEXT');
- glBinormal3ivEXT := dglGetProcAddress('glBinormal3ivEXT');
- glBinormal3sEXT := dglGetProcAddress('glBinormal3sEXT');
- glBinormal3svEXT := dglGetProcAddress('glBinormal3svEXT');
- glTangentPointerEXT := dglGetProcAddress('glTangentPointerEXT');
- glBinormalPointerEXT := dglGetProcAddress('glBinormalPointerEXT');
-end;
-
-procedure Read_GL_EXT_copy_texture;
-begin
- glCopyTexImage1DEXT := dglGetProcAddress('glCopyTexImage1DEXT');
- glCopyTexImage2DEXT := dglGetProcAddress('glCopyTexImage2DEXT');
- glCopyTexSubImage1DEXT := dglGetProcAddress('glCopyTexSubImage1DEXT');
- glCopyTexSubImage2DEXT := dglGetProcAddress('glCopyTexSubImage2DEXT');
- glCopyTexSubImage3DEXT := dglGetProcAddress('glCopyTexSubImage3DEXT');
-end;
-
-procedure Read_GL_EXT_cull_vertex;
-begin
- glCullParameterdvEXT := dglGetProcAddress('glCullParameterdvEXT');
- glCullParameterfvEXT := dglGetProcAddress('glCullParameterfvEXT');
-end;
-
-procedure Read_GL_EXT_draw_range_elements;
-begin
- glDrawRangeElementsEXT := dglGetProcAddress('glDrawRangeElementsEXT');
-end;
-
-procedure Read_GL_EXT_fog_coord;
-begin
- glFogCoordfEXT := dglGetProcAddress('glFogCoordfEXT');
- glFogCoordfvEXT := dglGetProcAddress('glFogCoordfvEXT');
- glFogCoorddEXT := dglGetProcAddress('glFogCoorddEXT');
- glFogCoorddvEXT := dglGetProcAddress('glFogCoorddvEXT');
- glFogCoordPointerEXT := dglGetProcAddress('glFogCoordPointerEXT');
-end;
-
-procedure Read_GL_EXT_framebuffer_object;
-begin
- glIsRenderbufferEXT := dglGetProcAddress('glIsRenderbufferEXT');
- glBindRenderbufferEXT := dglGetProcAddress('glBindRenderbufferEXT');
- glDeleteRenderbuffersEXT := dglGetProcAddress('glDeleteRenderbuffersEXT');
- glGenRenderbuffersEXT := dglGetProcAddress('glGenRenderbuffersEXT');
- glRenderbufferStorageEXT := dglGetProcAddress('glRenderbufferStorageEXT');
- glGetRenderbufferParameterivEXT := dglGetProcAddress('glGetRenderbufferParameterivEXT');
- glIsFramebufferEXT := dglGetProcAddress('glIsFramebufferEXT');
- glBindFramebufferEXT := dglGetProcAddress('glBindFramebufferEXT');
- glDeleteFramebuffersEXT := dglGetProcAddress('glDeleteFramebuffersEXT');
- glGenFramebuffersEXT := dglGetProcAddress('glGenFramebuffersEXT');
- glCheckFramebufferStatusEXT := dglGetProcAddress('glCheckFramebufferStatusEXT');
- glFramebufferTexture1DEXT := dglGetProcAddress('glFramebufferTexture1DEXT');
- glFramebufferTexture2DEXT := dglGetProcAddress('glFramebufferTexture2DEXT');
- glFramebufferTexture3DEXT := dglGetProcAddress('glFramebufferTexture3DEXT');
- glFramebufferRenderbufferEXT := dglGetProcAddress('glFramebufferRenderbufferEXT');
- glGetFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetFramebufferAttachmentParameterivEXT');
- glGenerateMipmapEXT := dglGetProcAddress('glGenerateMipmapEXT');
-end;
-
-procedure Read_GL_EXT_histogram;
-begin
- glGetHistogramEXT := dglGetProcAddress('glGetHistogramEXT');
- glGetHistogramParameterfvEXT := dglGetProcAddress('glGetHistogramParameterfvEXT');
- glGetHistogramParameterivEXT := dglGetProcAddress('glGetHistogramParameterivEXT');
- glGetMinmaxEXT := dglGetProcAddress('glGetMinmaxEXT');
- glGetMinmaxParameterfvEXT := dglGetProcAddress('glGetMinmaxParameterfvEXT');
- glGetMinmaxParameterivEXT := dglGetProcAddress('glGetMinmaxParameterivEXT');
- glHistogramEXT := dglGetProcAddress('glHistogramEXT');
- glMinmaxEXT := dglGetProcAddress('glMinmaxEXT');
- glResetHistogramEXT := dglGetProcAddress('glResetHistogramEXT');
- glResetMinmaxEXT := dglGetProcAddress('glResetMinmaxEXT');
-end;
-
-procedure Read_GL_EXT_index_func;
-begin
- glIndexFuncEXT := dglGetProcAddress('glIndexFuncEXT');
-end;
-
-procedure Read_GL_EXT_index_material;
-begin
- glIndexMaterialEXT := dglGetProcAddress('glIndexMaterialEXT');
-end;
-
-procedure Read_GL_EXT_light_texture;
-begin
- glApplyTextureEXT := dglGetProcAddress('glApplyTextureEXT');
- glTextureLightEXT := dglGetProcAddress('glTextureLightEXT');
- glTextureMaterialEXT := dglGetProcAddress('glTextureMaterialEXT');
-end;
-
-procedure Read_GL_EXT_multi_draw_arrays;
-begin
- glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT');
- glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT');
-end;
-
-procedure Read_GL_EXT_multisample;
-begin
- glSampleMaskEXT := dglGetProcAddress('glSampleMaskEXT');
- glSamplePatternEXT := dglGetProcAddress('glSamplePatternEXT');
-end;
-
-procedure Read_GL_EXT_paletted_texture;
-begin
- glColorTableEXT := dglGetProcAddress('glColorTableEXT');
- glGetColorTableEXT := dglGetProcAddress('glGetColorTableEXT');
- glGetColorTableParameterivEXT := dglGetProcAddress('glGetColorTableParameterivEXT');
- glGetColorTableParameterfvEXT := dglGetProcAddress('glGetColorTableParameterfvEXT');
-end;
-
-procedure Read_GL_EXT_pixel_transform;
-begin
- glPixelTransformParameteriEXT := dglGetProcAddress('glPixelTransformParameteriEXT');
- glPixelTransformParameterfEXT := dglGetProcAddress('glPixelTransformParameterfEXT');
- glPixelTransformParameterivEXT := dglGetProcAddress('glPixelTransformParameterivEXT');
- glPixelTransformParameterfvEXT := dglGetProcAddress('glPixelTransformParameterfvEXT');
-end;
-
-procedure Read_GL_EXT_point_parameters;
-begin
- glPointParameterfEXT := dglGetProcAddress('glPointParameterfEXT');
- glPointParameterfvEXT := dglGetProcAddress('glPointParameterfvEXT');
-end;
-
-procedure Read_GL_EXT_polygon_offset;
-begin
- glPolygonOffsetEXT := dglGetProcAddress('glPolygonOffsetEXT');
-end;
-
-procedure Read_GL_EXT_secondary_color;
-begin
- glSecondaryColor3bEXT := dglGetProcAddress('glSecondaryColor3bEXT');
- glSecondaryColor3bvEXT := dglGetProcAddress('glSecondaryColor3bvEXT');
- glSecondaryColor3dEXT := dglGetProcAddress('glSecondaryColor3dEXT');
- glSecondaryColor3dvEXT := dglGetProcAddress('glSecondaryColor3dvEXT');
- glSecondaryColor3fEXT := dglGetProcAddress('glSecondaryColor3fEXT');
- glSecondaryColor3fvEXT := dglGetProcAddress('glSecondaryColor3fvEXT');
- glSecondaryColor3iEXT := dglGetProcAddress('glSecondaryColor3iEXT');
- glSecondaryColor3ivEXT := dglGetProcAddress('glSecondaryColor3ivEXT');
- glSecondaryColor3sEXT := dglGetProcAddress('glSecondaryColor3sEXT');
- glSecondaryColor3svEXT := dglGetProcAddress('glSecondaryColor3svEXT');
- glSecondaryColor3ubEXT := dglGetProcAddress('glSecondaryColor3ubEXT');
- glSecondaryColor3ubvEXT := dglGetProcAddress('glSecondaryColor3ubvEXT');
- glSecondaryColor3uiEXT := dglGetProcAddress('glSecondaryColor3uiEXT');
- glSecondaryColor3uivEXT := dglGetProcAddress('glSecondaryColor3uivEXT');
- glSecondaryColor3usEXT := dglGetProcAddress('glSecondaryColor3usEXT');
- glSecondaryColor3usvEXT := dglGetProcAddress('glSecondaryColor3usvEXT');
- glSecondaryColorPointerEXT := dglGetProcAddress('glSecondaryColorPointerEXT');
-end;
-
-procedure Read_GL_EXT_stencil_two_side;
-begin
- glActiveStencilFaceEXT := dglGetProcAddress('glActiveStencilFaceEXT');
-end;
-
-procedure Read_GL_EXT_subtexture;
-begin
- glTexSubImage1DEXT := dglGetProcAddress('glTexSubImage1DEXT');
- glTexSubImage2DEXT := dglGetProcAddress('glTexSubImage2DEXT');
-end;
-
-procedure Read_GL_EXT_texture3D;
-begin
- glTexImage3DEXT := dglGetProcAddress('glTexImage3DEXT');
- glTexSubImage3DEXT := dglGetProcAddress('glTexSubImage3DEXT');
-end;
-
-procedure Read_GL_EXT_texture_object;
-begin
- glAreTexturesResidentEXT := dglGetProcAddress('glAreTexturesResidentEXT');
- glBindTextureEXT := dglGetProcAddress('glBindTextureEXT');
- glDeleteTexturesEXT := dglGetProcAddress('glDeleteTexturesEXT');
- glGenTexturesEXT := dglGetProcAddress('glGenTexturesEXT');
- glIsTextureEXT := dglGetProcAddress('glIsTextureEXT');
- glPrioritizeTexturesEXT := dglGetProcAddress('glPrioritizeTexturesEXT');
-end;
-
-procedure Read_GL_EXT_texture_perturb_normal;
-begin
- glTextureNormalEXT := dglGetProcAddress('glTextureNormalEXT');
-end;
-
-procedure Read_GL_EXT_vertex_array;
-begin
- glArrayElementEXT := dglGetProcAddress('glArrayElementEXT');
- glColorPointerEXT := dglGetProcAddress('glColorPointerEXT');
- glDrawArraysEXT := dglGetProcAddress('glDrawArraysEXT');
- glEdgeFlagPointerEXT := dglGetProcAddress('glEdgeFlagPointerEXT');
- glGetPointervEXT := dglGetProcAddress('glGetPointervEXT');
- glIndexPointerEXT := dglGetProcAddress('glIndexPointerEXT');
- glNormalPointerEXT := dglGetProcAddress('glNormalPointerEXT');
- glTexCoordPointerEXT := dglGetProcAddress('glTexCoordPointerEXT');
- glVertexPointerEXT := dglGetProcAddress('glVertexPointerEXT');
-end;
-
-procedure Read_GL_EXT_vertex_shader;
-begin
- glBeginVertexShaderEXT := dglGetProcAddress('glBeginVertexShaderEXT');
- glEndVertexShaderEXT := dglGetProcAddress('glEndVertexShaderEXT');
- glBindVertexShaderEXT := dglGetProcAddress('glBindVertexShaderEXT');
- glGenVertexShadersEXT := dglGetProcAddress('glGenVertexShadersEXT');
- glDeleteVertexShaderEXT := dglGetProcAddress('glDeleteVertexShaderEXT');
- glShaderOp1EXT := dglGetProcAddress('glShaderOp1EXT');
- glShaderOp2EXT := dglGetProcAddress('glShaderOp2EXT');
- glShaderOp3EXT := dglGetProcAddress('glShaderOp3EXT');
- glSwizzleEXT := dglGetProcAddress('glSwizzleEXT');
- glWriteMaskEXT := dglGetProcAddress('glWriteMaskEXT');
- glInsertComponentEXT := dglGetProcAddress('glInsertComponentEXT');
- glExtractComponentEXT := dglGetProcAddress('glExtractComponentEXT');
- glGenSymbolsEXT := dglGetProcAddress('glGenSymbolsEXT');
- glSetInvariantEXT := dglGetProcAddress('glSetInvariantEXT');
- glSetLocalConstantEXT := dglGetProcAddress('glSetLocalConstantEXT');
- glVariantbvEXT := dglGetProcAddress('glVariantbvEXT');
- glVariantsvEXT := dglGetProcAddress('glVariantsvEXT');
- glVariantivEXT := dglGetProcAddress('glVariantivEXT');
- glVariantfvEXT := dglGetProcAddress('glVariantfvEXT');
- glVariantdvEXT := dglGetProcAddress('glVariantdvEXT');
- glVariantubvEXT := dglGetProcAddress('glVariantubvEXT');
- glVariantusvEXT := dglGetProcAddress('glVariantusvEXT');
- glVariantuivEXT := dglGetProcAddress('glVariantuivEXT');
- glVariantPointerEXT := dglGetProcAddress('glVariantPointerEXT');
- glEnableVariantClientStateEXT := dglGetProcAddress('glEnableVariantClientStateEXT');
- glDisableVariantClientStateEXT := dglGetProcAddress('glDisableVariantClientStateEXT');
- glBindLightParameterEXT := dglGetProcAddress('glBindLightParameterEXT');
- glBindMaterialParameterEXT := dglGetProcAddress('glBindMaterialParameterEXT');
- glBindTexGenParameterEXT := dglGetProcAddress('glBindTexGenParameterEXT');
- glBindTextureUnitParameterEXT := dglGetProcAddress('glBindTextureUnitParameterEXT');
- glBindParameterEXT := dglGetProcAddress('glBindParameterEXT');
- glIsVariantEnabledEXT := dglGetProcAddress('glIsVariantEnabledEXT');
- glGetVariantBooleanvEXT := dglGetProcAddress('glGetVariantBooleanvEXT');
- glGetVariantIntegervEXT := dglGetProcAddress('glGetVariantIntegervEXT');
- glGetVariantFloatvEXT := dglGetProcAddress('glGetVariantFloatvEXT');
- glGetVariantPointervEXT := dglGetProcAddress('glGetVariantPointervEXT');
- glGetInvariantBooleanvEXT := dglGetProcAddress('glGetInvariantBooleanvEXT');
- glGetInvariantIntegervEXT := dglGetProcAddress('glGetInvariantIntegervEXT');
- glGetInvariantFloatvEXT := dglGetProcAddress('glGetInvariantFloatvEXT');
- glGetLocalConstantBooleanvEXT := dglGetProcAddress('glGetLocalConstantBooleanvEXT');
- glGetLocalConstantIntegervEXT := dglGetProcAddress('glGetLocalConstantIntegervEXT');
- glGetLocalConstantFloatvEXT := dglGetProcAddress('glGetLocalConstantFloatvEXT');
-end;
-
-procedure Read_GL_EXT_vertex_weighting;
-begin
- glVertexWeightfEXT := dglGetProcAddress('glVertexWeightfEXT');
- glVertexWeightfvEXT := dglGetProcAddress('glVertexWeightfvEXT');
- glVertexWeightPointerEXT := dglGetProcAddress('glVertexWeightPointerEXT');
-end;
-
-procedure Read_GL_EXT_depth_bounds_test;
-begin
- glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
- glDepthBoundsEXT := dglGetProcAddress('glDepthBoundsEXT');
-end;
-
-procedure Read_GL_EXT_blend_equation_separate;
-begin
- glBlendEquationSeparateEXT := dglGetProcAddress('glBlendEquationSeparateEXT');
-end;
-
-procedure Read_GL_EXT_stencil_clear_tag;
-begin
- glStencilClearTagEXT := dglGetProcAddress('glStencilClearTagEXT');
-end;
-
-procedure Read_GL_EXT_framebuffer_blit;
-begin
- glBlitFramebufferEXT := dglGetProcAddress('glBlitFramebufferEXT');
-end;
-
-procedure Read_GL_EXT_framebuffer_multisample;
-begin
- glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT');
-end;
-
-procedure Read_GL_EXT_timer_query;
-begin
- glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT');
- glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT');
-end;
-
-procedure Read_GL_EXT_gpu_program_parameters;
-begin
- glProgramEnvParameters4fvEXT := dglGetProcAddress('glProgramEnvParameters4fvEXT');
- glProgramLocalParameters4fvEXT := dglGetProcAddress('glProgramLocalParameters4fvEXT');
-end;
-
-procedure Read_GL_EXT_bindable_uniform;
-begin
- glUniformBufferEXT := dglGetProcAddress('glUniformBufferEXT');
- glGetUniformBufferSizeEXT := dglGetProcAddress('glGetUniformBufferSizeEXT');
- glGetUniformOffsetEXT := dglGetProcAddress('glGetUniformOffsetEXT');
-end;
-
-procedure Read_GL_EXT_draw_buffers2;
-begin
- glColorMaskIndexedEXT := dglGetProcAddress('glColorMaskIndexedEXT');
- glGetBooleanIndexedvEXT := dglGetProcAddress('glGetBooleanIndexedvEXT');
- glGetIntegerIndexedvEXT := dglGetProcAddress('glGetIntegerIndexedvEXT');
- glEnableIndexedEXT := dglGetProcAddress('glEnableIndexedEXT');
- glDisableIndexedEXT := dglGetProcAddress('glDisableIndexedEXT');
- glIsEnabledIndexedEXT := dglGetProcAddress('glIsEnabledIndexedEXT');
-end;
-
-procedure Read_GL_EXT_draw_instanced;
-begin
- glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT');
- glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT');
-end;
-
-procedure Read_GL_EXT_geometry_shader4;
-begin
- glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT');
- glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT');
-// glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
- glFramebufferTextureFaceEXT := dglGetProcAddress('glFramebufferTextureFaceEXT');
-end;
-
-procedure Read_GL_EXT_gpu_shader4;
-begin
- glVertexAttribI1iEXT := dglGetProcAddress('glVertexAttribI1iEXT');
- glVertexAttribI2iEXT := dglGetProcAddress('glVertexAttribI2iEXT');
- glVertexAttribI3iEXT := dglGetProcAddress('glVertexAttribI3iEXT');
- glVertexAttribI4iEXT := dglGetProcAddress('glVertexAttribI4iEXT');
- glVertexAttribI1uiEXT := dglGetProcAddress('glVertexAttribI1uiEXT');
- glVertexAttribI2uiEXT := dglGetProcAddress('glVertexAttribI2uiEXT');
- glVertexAttribI3uiEXT := dglGetProcAddress('glVertexAttribI3uiEXT');
- glVertexAttribI4uiEXT := dglGetProcAddress('glVertexAttribI4uiEXT');
- glVertexAttribI1ivEXT := dglGetProcAddress('glVertexAttribI1ivEXT');
- glVertexAttribI2ivEXT := dglGetProcAddress('glVertexAttribI2ivEXT');
- glVertexAttribI3ivEXT := dglGetProcAddress('glVertexAttribI3ivEXT');
- glVertexAttribI4ivEXT := dglGetProcAddress('glVertexAttribI4ivEXT');
- glVertexAttribI1uivEXT := dglGetProcAddress('glVertexAttribI1uivEXT');
- glVertexAttribI2uivEXT := dglGetProcAddress('glVertexAttribI2uivEXT');
- glVertexAttribI3uivEXT := dglGetProcAddress('glVertexAttribI3uivEXT');
- glVertexAttribI4uivEXT := dglGetProcAddress('glVertexAttribI4uivEXT');
- glVertexAttribI4bvEXT := dglGetProcAddress('glVertexAttribI4bvEXT');
- glVertexAttribI4svEXT := dglGetProcAddress('glVertexAttribI4svEXT');
- glVertexAttribI4ubvEXT := dglGetProcAddress('glVertexAttribI4ubvEXT');
- glVertexAttribI4usvEXT := dglGetProcAddress('glVertexAttribI4usvEXT');
- glVertexAttribIPointerEXT := dglGetProcAddress('glVertexAttribIPointerEXT');
- glGetVertexAttribIivEXT := dglGetProcAddress('glGetVertexAttribIivEXT');
- glGetVertexAttribIuivEXT := dglGetProcAddress('glGetVertexAttribIuivEXT');
- glUniform1uiEXT := dglGetProcAddress('glUniform1uiEXT');
- glUniform2uiEXT := dglGetProcAddress('glUniform2uiEXT');
- glUniform3uiEXT := dglGetProcAddress('glUniform3uiEXT');
- glUniform4uiEXT := dglGetProcAddress('glUniform4uiEXT');
- glUniform1uivEXT := dglGetProcAddress('glUniform1uivEXT');
- glUniform2uivEXT := dglGetProcAddress('glUniform2uivEXT');
- glUniform3uivEXT := dglGetProcAddress('glUniform3uivEXT');
- glUniform4uivEXT := dglGetProcAddress('glUniform4uivEXT');
- glGetUniformuivEXT := dglGetProcAddress('glGetUniformuivEXT');
- glBindFragDataLocationEXT := dglGetProcAddress('glBindFragDataLocationEXT');
- glGetFragDataLocationEXT := dglGetProcAddress('glGetFragDataLocationEXT');
-end;
-
-procedure Read_GL_EXT_texture_array;
-begin
- glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
-end;
-
-procedure Read_GL_EXT_texture_buffer_object;
-begin
- glTexBufferEXT := dglGetProcAddress('glTexBufferEXT');
-end;
-
-procedure Read_GL_EXT_texture_integer;
-begin
- glClearColorIiEXT := dglGetProcAddress('glClearColorIiEXT');
- glClearColorIuiEXT := dglGetProcAddress('glClearColorIuiEXT');
- glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT');
- glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT');
- glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT');
- glGetTexParameterIiuvEXT := dglGetProcAddress('glGetTexParameterIiuvEXT');
-end;
-
-procedure Read_GL_EXT_transform_feedback;
-begin
- glBeginTransformFeedbackEXT := dglGetProcAddress('lBeginTransformFeedbackEXT');
- glEndTransformFeedbackEXT := dglGetProcAddress('glEndTransformFeedbackEXT');
- glBindBufferRangeEXT := dglGetProcAddress('glBindBufferRangeEXT');
- glBindBufferOffsetEXT := dglGetProcAddress('glBindBufferOffsetEXT');
- glBindBufferBaseEXT := dglGetProcAddress('glBindBufferBaseEXT');
- glTransformFeedbackVaryingsEXT := dglGetProcAddress('glTransformFeedbackVaryingsEXT');
- glGetTransformFeedbackVaryingEXT := dglGetProcAddress('glGetTransformFeedbackVaryingEXT');
-end;
-
-procedure Read_GL_EXT_direct_state_access;
-begin
- glClientAttribDefaultEXT := dglGetProcAddress('glClientAttribDefaultEXT');
- glPushClientAttribDefaultEXT := dglGetProcAddress('glPushClientAttribDefaultEXT');
- glMatrixLoadfEXT := dglGetProcAddress('glMatrixLoadfEXT');
- glMatrixLoaddEXT := dglGetProcAddress('glMatrixLoaddEXT');
- glMatrixMultfEXT := dglGetProcAddress('glMatrixMultfEXT');
- glMatrixMultdEXT := dglGetProcAddress('glMatrixMultdEXT');
- glMatrixLoadIdentityEXT := dglGetProcAddress('glMatrixLoadIdentityEXT');
- glMatrixRotatefEXT := dglGetProcAddress('glMatrixRotatefEXT');
- glMatrixRotatedEXT := dglGetProcAddress('glMatrixRotatedEXT');
- glMatrixScalefEXT := dglGetProcAddress('glMatrixScalefEXT');
- glMatrixScaledEXT := dglGetProcAddress('glMatrixScaledEXT');
- glMatrixTranslatefEXT := dglGetProcAddress('glMatrixTranslatefEXT');
- glMatrixTranslatedEXT := dglGetProcAddress('glMatrixTranslatedEXT');
- glMatrixFrustumEXT := dglGetProcAddress('glMatrixFrustumEXT');
- glMatrixOrthoEXT := dglGetProcAddress('glMatrixOrthoEXT');
- glMatrixPopEXT := dglGetProcAddress('glMatrixPopEXT');
- glMatrixPushEXT := dglGetProcAddress('glMatrixPushEXT');
- glMatrixLoadTransposefEXT := dglGetProcAddress('glMatrixLoadTransposefEXT');
- glMatrixLoadTransposedEXT := dglGetProcAddress('glMatrixLoadTransposedEXT');
- glMatrixMultTransposefEXT := dglGetProcAddress('glMatrixMultTransposefEXT');
- glMatrixMultTransposedEXT := dglGetProcAddress('glMatrixMultTransposedEXT');
- glTextureParameterfEXT := dglGetProcAddress('glTextureParameterfEXT');
- glTextureParameterfvEXT := dglGetProcAddress('glTextureParameterfvEXT');
- glTextureParameteriEXT := dglGetProcAddress('glTextureParameteriEXT');
- glTextureParameterivEXT := dglGetProcAddress('glTextureParameterivEXT');
- glTextureImage1DEXT := dglGetProcAddress('glTextureImage1DEXT');
- glTextureImage2DEXT := dglGetProcAddress('glTextureImage2DEXT');
- glTextureSubImage1DEXT := dglGetProcAddress('glTextureSubImage1DEXT');
- glTextureSubImage2DEXT := dglGetProcAddress('glTextureSubImage2DEXT');
- glCopyTextureImage1DEXT := dglGetProcAddress('glCopyTextureImage1DEXT');
- glCopyTextureImage2DEXT := dglGetProcAddress('glCopyTextureImage2DEXT');
- glCopyTextureSubImage1DEXT := dglGetProcAddress('glCopyTextureSubImage1DEXT');
- glCopyTextureSubImage2DEXT := dglGetProcAddress('glCopyTextureSubImage2DEXT');
- glGetTextureImageEXT := dglGetProcAddress('glGetTextureImageEXT');
- glGetTextureParameterfvEXT := dglGetProcAddress('glGetTextureParameterfvEXT');
- glGetTextureParameterivEXT := dglGetProcAddress('glGetTextureParameterivEXT');
- glGetTextureLevelParameterfvEXT := dglGetProcAddress('glGetTextureLevelParameterfvEXT');
- glGetTextureLevelParameterivEXT := dglGetProcAddress('glGetTextureLevelParameterivEXT');
- glTextureImage3DEXT := dglGetProcAddress('glTextureImage3DEXT');
- glTextureSubImage3DEXT := dglGetProcAddress('glTextureSubImage3DEXT');
- glCopyTextureSubImage3DEXT := dglGetProcAddress('glCopyTextureSubImage3DEXT');
- glMultiTexParameterfEXT := dglGetProcAddress('glMultiTexParameterfEXT');
- glMultiTexParameterfvEXT := dglGetProcAddress('glMultiTexParameterfvEXT');
- glMultiTexParameteriEXT := dglGetProcAddress('glMultiTexParameteriEXT');
- glMultiTexParameterivEXT := dglGetProcAddress('glMultiTexParameterivEXT');
- glMultiTexImage1DEXT := dglGetProcAddress('glMultiTexImage1DEXT');
- glMultiTexImage2DEXT := dglGetProcAddress('glMultiTexImage2DEXT');
- glMultiTexSubImage1DEXT := dglGetProcAddress('glMultiTexSubImage1DEXT');
- glMultiTexSubImage2DEXT := dglGetProcAddress('glMultiTexSubImage2DEXT');
- glCopyMultiTexImage1DEXT := dglGetProcAddress('glCopyMultiTexImage1DEXT');
- glCopyMultiTexImage2DEXT := dglGetProcAddress('glCopyMultiTexImage2DEXT');
- glCopyMultiTexSubImage1DEXT := dglGetProcAddress('glCopyMultiTexSubImage1DEXT');
- glCopyMultiTexSubImage2DEXT := dglGetProcAddress('glCopyMultiTexSubImage2DEXT');
- glGetMultiTexImageEXT := dglGetProcAddress('glGetMultiTexImageEXT');
- glGetMultiTexParameterfvEXT := dglGetProcAddress('glGetMultiTexParameterfvEXT');
- glGetMultiTexParameterivEXT := dglGetProcAddress('glGetMultiTexParameterivEXT');
- glGetMultiTexLevelParameterfvEXT := dglGetProcAddress('glGetMultiTexLevelParameterfvEXT');
- glGetMultiTexLevelParameterivEXT := dglGetProcAddress('glGetMultiTexLevelParameterivEXT');
- glMultiTexImage3DEXT := dglGetProcAddress('glMultiTexImage3DEXT');
- glMultiTexSubImage3DEXT := dglGetProcAddress('glMultiTexSubImage3DEXT');
- glCopyMultiTexSubImage3DEXT := dglGetProcAddress('glCopyMultiTexSubImage3DEXT');
- glBindMultiTextureEXT := dglGetProcAddress('glBindMultiTextureEXT');
- glEnableClientStateIndexedEXT := dglGetProcAddress('glEnableClientStateIndexedEXT');
- glDisableClientStateIndexedEXT := dglGetProcAddress('glDisableClientStateIndexedEXT');
- glMultiTexCoordPointerEXT := dglGetProcAddress('glMultiTexCoordPointerEXT');
- glMultiTexEnvfEXT := dglGetProcAddress('glMultiTexEnvfEXT');
- glMultiTexEnvfvEXT := dglGetProcAddress('glMultiTexEnvfvEXT');
- glMultiTexEnviEXT := dglGetProcAddress('glMultiTexEnviEXT');
- glMultiTexEnvivEXT := dglGetProcAddress('glMultiTexEnvivEXT');
- glMultiTexGendEXT := dglGetProcAddress('glMultiTexGendEXT');
- glMultiTexGendvEXT := dglGetProcAddress('glMultiTexGendvEXT');
- glMultiTexGenfEXT := dglGetProcAddress('glMultiTexGenfEXT');
- glMultiTexGenfvEXT := dglGetProcAddress('glMultiTexGenfvEXT');
- glMultiTexGeniEXT := dglGetProcAddress('glMultiTexGeniEXT');
- glMultiTexGenivEXT := dglGetProcAddress('glMultiTexGenivEXT');
- glGetMultiTexEnvfvEXT := dglGetProcAddress('glGetMultiTexEnvfvEXT');
- glGetMultiTexEnvivEXT := dglGetProcAddress('glGetMultiTexEnvivEXT');
- glGetMultiTexGendvEXT := dglGetProcAddress('glGetMultiTexGendvEXT');
- glGetMultiTexGenfvEXT := dglGetProcAddress('glGetMultiTexGenfvEXT');
- glGetMultiTexGenivEXT := dglGetProcAddress('glGetMultiTexGenivEXT');
- glGetFloatIndexedvEXT := dglGetProcAddress('glGetFloatIndexedvEXT');
- glGetDoubleIndexedvEXT := dglGetProcAddress('glGetDoubleIndexedvEXT');
- glGetPointerIndexedvEXT := dglGetProcAddress('glGetPointerIndexedvEXT');
- glCompressedTextureImage3DEXT := dglGetProcAddress('glCompressedTextureImage3DEXT');
- glCompressedTextureImage2DEXT := dglGetProcAddress('glCompressedTextureImage2DEXT');
- glCompressedTextureImage1DEXT := dglGetProcAddress('glCompressedTextureImage1DEXT');
- glCompressedTextureSubImage3DEXT := dglGetProcAddress('glCompressedTextureSubImage3DEXT');
- glCompressedTextureSubImage2DEXT := dglGetProcAddress('glCompressedTextureSubImage2DEXT');
- glCompressedTextureSubImage1DEXT := dglGetProcAddress('glCompressedTextureSubImage1DEXT');
- glGetCompressedTextureImageEXT := dglGetProcAddress('glGetCompressedTextureImageEXT');
- glCompressedMultiTexImage3DEXT := dglGetProcAddress('glCompressedMultiTexImage3DEXT');
- glCompressedMultiTexImage2DEXT := dglGetProcAddress('glCompressedMultiTexImage2DEXT');
- glCompressedMultiTexImage1DEXT := dglGetProcAddress('glCompressedMultiTexImage1DEXT');
- glCompressedMultiTexSubImage3DEXT := dglGetProcAddress('glCompressedMultiTexSubImage3DEXT');
- glCompressedMultiTexSubImage2DEXT := dglGetProcAddress('glCompressedMultiTexSubImage2DEXT');
- glCompressedMultiTexSubImage1DEXT := dglGetProcAddress('glCompressedMultiTexSubImage1DEXT');
- glGetCompressedMultiTexImageEXT := dglGetProcAddress('glGetCompressedMultiTexImageEXT');
- glNamedProgramStringEXT := dglGetProcAddress('glNamedProgramStringEXT');
- glNamedProgramLocalParameter4dEXT := dglGetProcAddress('glNamedProgramLocalParameter4dEXT');
- glNamedProgramLocalParameter4dvEXT := dglGetProcAddress('glNamedProgramLocalParameter4dvEXT');
- glNamedProgramLocalParameter4fEXT := dglGetProcAddress('glNamedProgramLocalParameter4fEXT');
- glNamedProgramLocalParameter4fvEXT := dglGetProcAddress('glNamedProgramLocalParameter4fvEXT');
- glGetNamedProgramLocalParameterdvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterdvEXT');
- glGetNamedProgramLocalParameterfvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterfvEXT');
- glGetNamedProgramivEXT := dglGetProcAddress('glGetNamedProgramivEXT');
- glGetNamedProgramStringEXT := dglGetProcAddress('glGetNamedProgramStringEXT');
- glNamedProgramLocalParameters4fvEXT := dglGetProcAddress('glNamedProgramLocalParameters4fvEXT');
- glNamedProgramLocalParameterI4iEXT := dglGetProcAddress('glNamedProgramLocalParameterI4iEXT');
- glNamedProgramLocalParameterI4ivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4ivEXT');
- glNamedProgramLocalParametersI4ivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4ivEXT');
- glNamedProgramLocalParameterI4uiEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uiEXT');
- glNamedProgramLocalParameterI4uivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uivEXT');
- glNamedProgramLocalParametersI4uivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4uivEXT');
- glGetNamedProgramLocalParameterIivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIivEXT');
- glGetNamedProgramLocalParameterIuivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIuivEXT');
- glTextureParameterIivEXT := dglGetProcAddress('glTextureParameterIivEXT');
- glTextureParameterIuivEXT := dglGetProcAddress('glTextureParameterIuivEXT');
- glGetTextureParameterIivEXT := dglGetProcAddress('glGetTextureParameterIivEXT');
- glGetTextureParameterIuivEXT := dglGetProcAddress('glGetTextureParameterIuivEXT');
- glMultiTexParameterIivEXT := dglGetProcAddress('glMultiTexParameterIivEXT');
- glMultiTexParameterIuivEXT := dglGetProcAddress('glMultiTexParameterIuivEXT');
- glGetMultiTexParameterIivEXT := dglGetProcAddress('glGetMultiTexParameterIivEXT');
- glGetMultiTexParameterIuivEXT := dglGetProcAddress('glGetMultiTexParameterIuivEXT');
- glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT');
- glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT');
- glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT');
- glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT');
- glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT');
- glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT');
- glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT');
- glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT');
- glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT');
- glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT');
- glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT');
- glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT');
- glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT');
- glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT');
- glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT');
- glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT');
- glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT');
- glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT');
- glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT');
- glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT');
- glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT');
- glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT');
- glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT');
- glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT');
- glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT');
- glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT');
- glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT');
- glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT');
- glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT');
- glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT');
- glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT');
- glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT');
- glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT');
- glNamedBufferDataEXT := dglGetProcAddress('glNamedBufferDataEXT');
- glNamedBufferSubDataEXT := dglGetProcAddress('glNamedBufferSubDataEXT');
- glMapNamedBufferEXT := dglGetProcAddress('glMapNamedBufferEXT');
- glUnmapNamedBufferEXT := dglGetProcAddress('glUnmapNamedBufferEXT');
- glMapNamedBufferRangeEXT := dglGetProcAddress('glMapNamedBufferRangeEXT');
- glFlushMappedNamedBufferRangeEXT := dglGetProcAddress('glFlushMappedNamedBufferRangeEXT');
- glNamedCopyBufferSubDataEXT := dglGetProcAddress('glNamedCopyBufferSubDataEXT');
- glGetNamedBufferParameterivEXT := dglGetProcAddress('glGetNamedBufferParameterivEXT');
- glGetNamedBufferPointervEXT := dglGetProcAddress('glGetNamedBufferPointervEXT');
- glGetNamedBufferSubDataEXT := dglGetProcAddress('glGetNamedBufferSubDataEXT');
- glTextureBufferEXT := dglGetProcAddress('glTextureBufferEXT');
- glMultiTexBufferEXT := dglGetProcAddress('glMultiTexBufferEXT');
- glNamedRenderbufferStorageEXT := dglGetProcAddress('glNamedRenderbufferStorageEXT');
- glGetNamedRenderbufferParameterivEXT := dglGetProcAddress('glGetNamedRenderbufferParameterivEXT');
- glCheckNamedFramebufferStatusEXT := dglGetProcAddress('glCheckNamedFramebufferStatusEXT');
- glNamedFramebufferTexture1DEXT := dglGetProcAddress('glNamedFramebufferTexture1DEXT');
- glNamedFramebufferTexture2DEXT := dglGetProcAddress('glNamedFramebufferTexture2DEXT');
- glNamedFramebufferTexture3DEXT := dglGetProcAddress('glNamedFramebufferTexture3DEXT');
- glNamedFramebufferRenderbufferEXT := dglGetProcAddress('glNamedFramebufferRenderbufferEXT');
- glGetNamedFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetNamedFramebufferAttachmentParameterivEXT');
- glGenerateTextureMipmapEXT := dglGetProcAddress('glGenerateTextureMipmapEXT');
- glGenerateMultiTexMipmapEXT := dglGetProcAddress('glGenerateMultiTexMipmapEXT');
- glFramebufferDrawBufferEXT := dglGetProcAddress('glFramebufferDrawBufferEXT');
- glFramebufferDrawBuffersEXT := dglGetProcAddress('glFramebufferDrawBuffersEXT');
- glFramebufferReadBufferEXT := dglGetProcAddress('glFramebufferReadBufferEXT');
- glGetFramebufferParameterivEXT := dglGetProcAddress('glGetFramebufferParameterivEXT');
- glNamedRenderbufferStorageMultisampleEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleEXT');
- glNamedRenderbufferStorageMultisampleCoverageEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleCoverageEXT');
- glNamedFramebufferTextureEXT := dglGetProcAddress('glNamedFramebufferTextureEXT');
- glNamedFramebufferTextureLayerEXT := dglGetProcAddress('glNamedFramebufferTextureLayerEXT');
- glNamedFramebufferTextureFaceEXT := dglGetProcAddress('glNamedFramebufferTextureFaceEXT');
- glTextureRenderbufferEXT := dglGetProcAddress('glTextureRenderbufferEXT');
- glMultiTexRenderbufferEXT := dglGetProcAddress('glMultiTexRenderbufferEXT');
- glProgramUniform1dEXT := dglGetProcAddress('glProgramUniform1dEXT');
- glProgramUniform2dEXT := dglGetProcAddress('glProgramUniform2dEXT');
- glProgramUniform3dEXT := dglGetProcAddress('glProgramUniform3dEXT');
- glProgramUniform4dEXT := dglGetProcAddress('glProgramUniform4dEXT');
- glProgramUniform1dvEXT := dglGetProcAddress('glProgramUniform1dvEXT');
- glProgramUniform2dvEXT := dglGetProcAddress('glProgramUniform2dvEXT');
- glProgramUniform3dvEXT := dglGetProcAddress('glProgramUniform3dvEXT');
- glProgramUniform4dvEXT := dglGetProcAddress('glProgramUniform4dvEXT');
- glProgramUniformMatrix2dvEXT := dglGetProcAddress('glProgramUniformMatrix2dvEXT');
- glProgramUniformMatrix3dvEXT := dglGetProcAddress('glProgramUniformMatrix3dvEXT');
- glProgramUniformMatrix4dvEXT := dglGetProcAddress('glProgramUniformMatrix4dvEXT');
- glProgramUniformMatrix2x3dvEXT := dglGetProcAddress('glProgramUniformMatrix2x3dvEXT');
- glProgramUniformMatrix2x4dvEXT := dglGetProcAddress('glProgramUniformMatrix2x4dvEXT');
- glProgramUniformMatrix3x2dvEXT := dglGetProcAddress('glProgramUniformMatrix3x2dvEXT');
- glProgramUniformMatrix3x4dvEXT := dglGetProcAddress('glProgramUniformMatrix3x4dvEXT');
- glProgramUniformMatrix4x2dvEXT := dglGetProcAddress('glProgramUniformMatrix4x2dvEXT');
- glProgramUniformMatrix4x3dvEXT := dglGetProcAddress('glProgramUniformMatrix4x3dvEXT');
-end;
-
-procedure Read_GL_EXT_separate_shader_objects;
-begin
- glUseShaderProgramEXT := dglGetProcAddress('glUseShaderProgramEXT');
- glActiveProgramEXT := dglGetProcAddress('glActiveProgramEXT');
- glCreateShaderProgramEXT := dglGetProcAddress('glCreateShaderProgramEXT');
-end;
-
-procedure Read_GL_EXT_shader_image_load_store;
-begin
- glBindImageTextureEXT := dglGetProcAddress('glBindImageTextureEXT');
- glMemoryBarrierEXT := dglGetProcAddress('glMemoryBarrierEXT');
-end;
-
-procedure Read_GL_EXT_vertex_attrib_64bit;
-begin
- glVertexAttribL1dEXT := dglGetProcAddress('glVertexAttribL1dEXT');
- glVertexAttribL2dEXT := dglGetProcAddress('glVertexAttribL2dEXT');
- glVertexAttribL3dEXT := dglGetProcAddress('glVertexAttribL3dEXT');
- glVertexAttribL4dEXT := dglGetProcAddress('glVertexAttribL4dEXT');
- glVertexAttribL1dvEXT := dglGetProcAddress('glVertexAttribL1dvEXT');
- glVertexAttribL2dvEXT := dglGetProcAddress('glVertexAttribL2dvEXT');
- glVertexAttribL3dvEXT := dglGetProcAddress('glVertexAttribL3dvEXT');
- glVertexAttribL4dvEXT := dglGetProcAddress('glVertexAttribL4dvEXT');
- glVertexAttribLPointerEXT := dglGetProcAddress('glVertexAttribLPointerEXT');
- glGetVertexAttribLdvEXT := dglGetProcAddress('glGetVertexAttribLdvEXT');
- glVertexArrayVertexAttribLOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribLOffsetEXT');
-end;
-
-procedure Read_GL_HP_image_transform;
-begin
- glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
- glImageTransformParameterfHP := dglGetProcAddress('glImageTransformParameterfHP');
- glImageTransformParameterivHP := dglGetProcAddress('glImageTransformParameterivHP');
- glImageTransformParameterfvHP := dglGetProcAddress('glImageTransformParameterfvHP');
- glGetImageTransformParameterivHP := dglGetProcAddress('glGetImageTransformParameterivHP');
- glGetImageTransformParameterfvHP := dglGetProcAddress('glGetImageTransformParameterfvHP');
-end;
-
-procedure Read_GL_IBM_multimode_draw_arrays;
-begin
- glMultiModeDrawArraysIBM := dglGetProcAddress('glMultiModeDrawArraysIBM');
- glMultiModeDrawElementsIBM := dglGetProcAddress('glMultiModeDrawElementsIBM');
-end;
-
-procedure Read_GL_IBM_vertex_array_lists;
-begin
- glColorPointerListIBM := dglGetProcAddress('glColorPointerListIBM');
- glSecondaryColorPointerListIBM := dglGetProcAddress('glSecondaryColorPointerListIBM');
- glEdgeFlagPointerListIBM := dglGetProcAddress('glEdgeFlagPointerListIBM');
- glFogCoordPointerListIBM := dglGetProcAddress('glFogCoordPointerListIBM');
- glIndexPointerListIBM := dglGetProcAddress('glIndexPointerListIBM');
- glNormalPointerListIBM := dglGetProcAddress('glNormalPointerListIBM');
- glTexCoordPointerListIBM := dglGetProcAddress('glTexCoordPointerListIBM');
- glVertexPointerListIBM := dglGetProcAddress('glVertexPointerListIBM');
-end;
-
-procedure Read_GL_INGR_blend_func_separate;
-begin
- glBlendFuncSeparateINGR := dglGetProcAddress('glBlendFuncSeparateINGR');
-end;
-
-procedure Read_GL_INTEL_parallel_arrays;
-begin
- glVertexPointervINTEL := dglGetProcAddress('glVertexPointervINTEL');
- glNormalPointervINTEL := dglGetProcAddress('glNormalPointervINTEL');
- glColorPointervINTEL := dglGetProcAddress('glColorPointervINTEL');
- glTexCoordPointervINTEL := dglGetProcAddress('glTexCoordPointervINTEL');
-end;
-
-procedure Read_GL_MESA_resize_buffers;
-begin
- glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA');
-end;
-
-procedure Read_GL_MESA_window_pos;
-begin
- glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA');
- glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA');
- glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA');
- glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA');
- glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA');
- glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA');
- glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA');
- glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA');
- glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA');
- glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA');
- glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA');
- glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA');
- glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA');
- glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA');
- glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA');
- glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA');
- glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA');
- glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA');
- glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA');
- glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA');
- glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA');
- glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA');
- glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA');
- glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA');
-end;
-
-procedure Read_GL_NV_evaluators;
-begin
- glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV');
- glMapParameterivNV := dglGetProcAddress('glMapParameterivNV');
- glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV');
- glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV');
- glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV');
- glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV');
- glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV');
- glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV');
- glEvalMapsNV := dglGetProcAddress('glEvalMapsNV');
-end;
-
-procedure Read_GL_NV_fence;
-begin
- glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV');
- glGenFencesNV := dglGetProcAddress('glGenFencesNV');
- glIsFenceNV := dglGetProcAddress('glIsFenceNV');
- glTestFenceNV := dglGetProcAddress('glTestFenceNV');
- glGetFenceivNV := dglGetProcAddress('glGetFenceivNV');
- glFinishFenceNV := dglGetProcAddress('glFinishFenceNV');
- glSetFenceNV := dglGetProcAddress('glSetFenceNV');
-end;
-
-procedure Read_GL_NV_fragment_program;
-begin
- glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV');
- glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV');
- glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV');
- glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV');
- glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV');
- glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV');
-end;
-
-procedure Read_GL_NV_half_float;
-begin
- glVertex2hNV := dglGetProcAddress('glVertex2hNV');
- glVertex2hvNV := dglGetProcAddress('glVertex2hvNV');
- glVertex3hNV := dglGetProcAddress('glVertex3hNV');
- glVertex3hvNV := dglGetProcAddress('glVertex3hvNV');
- glVertex4hNV := dglGetProcAddress('glVertex4hNV');
- glVertex4hvNV := dglGetProcAddress('glVertex4hvNV');
- glNormal3hNV := dglGetProcAddress('glNormal3hNV');
- glNormal3hvNV := dglGetProcAddress('glNormal3hvNV');
- glColor3hNV := dglGetProcAddress('glColor3hNV');
- glColor3hvNV := dglGetProcAddress('glColor3hvNV');
- glColor4hNV := dglGetProcAddress('glColor4hNV');
- glColor4hvNV := dglGetProcAddress('glColor4hvNV');
- glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV');
- glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV');
- glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV');
- glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV');
- glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV');
- glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV');
- glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV');
- glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV');
- glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV');
- glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV');
- glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV');
- glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV');
- glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV');
- glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV');
- glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV');
- glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV');
- glFogCoordhNV := dglGetProcAddress('glFogCoordhNV');
- glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV');
- glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV');
- glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV');
- glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV');
- glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV');
- glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV');
- glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV');
- glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV');
- glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV');
- glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV');
- glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV');
- glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV');
- glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV');
- glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV');
- glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV');
- glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV');
- glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV');
-end;
-
-procedure Read_GL_NV_occlusion_query;
-begin
- glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV');
- glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV');
- glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV');
- glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV');
- glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV');
- glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV');
- glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV');
-end;
-
-procedure Read_GL_NV_pixel_data_range;
-begin
- glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV');
- glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV');
-end;
-
-procedure Read_GL_NV_point_sprite;
-begin
- glPointParameteriNV := dglGetProcAddress('glPointParameteriNV');
- glPointParameterivNV := dglGetProcAddress('glPointParameterivNV');
-end;
-
-procedure Read_GL_NV_primitive_restart;
-begin
- glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV');
- glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV');
-end;
-
-procedure Read_GL_NV_register_combiners;
-begin
- glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV');
- glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV');
- glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV');
- glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV');
- glCombinerInputNV := dglGetProcAddress('glCombinerInputNV');
- glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV');
- glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV');
- glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV');
- glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV');
- glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV');
- glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV');
- glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV');
- glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV');
-end;
-
-procedure Read_GL_NV_register_combiners2;
-begin
- glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV');
- glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV');
-end;
-
-procedure Read_GL_NV_vertex_array_range;
-begin
- glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV');
- glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV');
-end;
-
-procedure Read_GL_NV_vertex_program;
-begin
- glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV');
- glBindProgramNV := dglGetProcAddress('glBindProgramNV');
- glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV');
- glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV');
- glGenProgramsNV := dglGetProcAddress('glGenProgramsNV');
- glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV');
- glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV');
- glGetProgramivNV := dglGetProcAddress('glGetProgramivNV');
- glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV');
- glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV');
- glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV');
- glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV');
- glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV');
- glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV');
- glIsProgramNV := dglGetProcAddress('glIsProgramNV');
- glLoadProgramNV := dglGetProcAddress('glLoadProgramNV');
- glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV');
- glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV');
- glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV');
- glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV');
- glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV');
- glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV');
- glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV');
- glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV');
- glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV');
- glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV');
- glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV');
- glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV');
- glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV');
- glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV');
- glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV');
- glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV');
- glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV');
- glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV');
- glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV');
- glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV');
- glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV');
- glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV');
- glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV');
- glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV');
- glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV');
- glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV');
- glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV');
- glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV');
- glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV');
- glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV');
- glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV');
- glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV');
- glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV');
- glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV');
- glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV');
- glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV');
- glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV');
- glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV');
- glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV');
- glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV');
- glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV');
- glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV');
- glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV');
- glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV');
- glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV');
- glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV');
- glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV');
- glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV');
-end;
-
-procedure Read_GL_NV_depth_buffer_float;
-begin
- glDepthRangedNV := dglGetProcAddress('glDepthRangedNV');
- glClearDepthdNV := dglGetProcAddress('glClearDepthdNV');
- glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV');
-end;
-
-procedure Read_GL_NV_framebuffer_multisample_coverage;
-begin
- glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV');
-end;
-
-procedure Read_GL_NV_geometry_program4;
-begin
- glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV');
-end;
-
-procedure Read_GL_NV_gpu_program4;
-begin
- glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV');
- glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV');
- glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV');
- glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV');
- glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV');
- glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV');
- glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV');
- glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV');
- glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV');
- glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV');
- glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV');
- glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV');
- glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV');
- glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV');
- glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV');
- glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV');
-end;
-
-procedure Read_GL_NV_parameter_buffer_object;
-begin
- glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV');
- glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV');
- glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV');
-end;
-
-procedure Read_GL_NV_transform_feedback;
-begin
- glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV');
- glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV');
- glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV');
- glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV');
- glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV');
- glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV');
- glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV');
- glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV');
- glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV');
- glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV');
- glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV');
- glTransformFeedbackStreamAttribsNV := dglGetProcAddress('glTransformFeedbackStreamAttribsNV');
-end;
-
-procedure Read_GL_NV_conditional_render;
-begin
- glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV');
- glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV');
-end;
-
-procedure Read_GL_NV_present_video;
-begin
- glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV');
- glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV');
- glGetVideoivNV := dglGetProcAddress('glGetVideoivNV');
- glGetVideouivNV := dglGetProcAddress('glGetVideouivNV');
- glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV');
- glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV');
-// glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV');
-end;
-
-procedure Read_GL_NV_explicit_multisample;
-begin
- glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV');
- glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV');
- glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV');
-end;
-
-procedure Read_GL_NV_transform_feedback2;
-begin
- glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV');
- glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV');
- glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV');
- glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV');
- glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV');
- glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV');
- glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV');
-end;
-
-procedure Read_GL_NV_video_capture;
-begin
- glBeginVideoCaptureNV := dglGetProcAddress('glBeginVideoCaptureNV');
- glBindVideoCaptureStreamBufferNV := dglGetProcAddress('glBindVideoCaptureStreamBufferNV');
- glBindVideoCaptureStreamTextureNV := dglGetProcAddress('glBindVideoCaptureStreamTextureNV');
- glEndVideoCaptureNV := dglGetProcAddress('glEndVideoCaptureNV');
- glGetVideoCaptureivNV := dglGetProcAddress('glGetVideoCaptureivNV');
- glGetVideoCaptureStreamivNV := dglGetProcAddress('glGetVideoCaptureStreamivNV');
- glGetVideoCaptureStreamfvNV := dglGetProcAddress('glGetVideoCaptureStreamfvNV');
- glGetVideoCaptureStreamdvNV := dglGetProcAddress('glGetVideoCaptureStreamdvNV');
- glVideoCaptureNV := dglGetProcAddress('glVideoCaptureNV');
- glVideoCaptureStreamParameterivNV := dglGetProcAddress('glVideoCaptureStreamParameterivNV');
- glVideoCaptureStreamParameterfvNV := dglGetProcAddress('glVideoCaptureStreamParameterfvNV');
- glVideoCaptureStreamParameterdvNV := dglGetProcAddress('glVideoCaptureStreamParameterdvNV');
-end;
-
-procedure Read_GL_NV_copy_image;
-begin
- glCopyImageSubDataNV := dglGetProcAddress('glCopyImageSubDataNV');
-end;
-
-procedure Read_GL_NV_shader_buffer_load;
-begin
- glMakeBufferResidentNV := dglGetProcAddress('glMakeBufferResidentNV');
- glMakeBufferNonResidentNV := dglGetProcAddress('glMakeBufferNonResidentNV');
- glIsBufferResidentNV := dglGetProcAddress('glIsBufferResidentNV');
- glMakeNamedBufferResidentNV := dglGetProcAddress('glMakeNamedBufferResidentNV');
- glMakeNamedBufferNonResidentNV := dglGetProcAddress('glMakeNamedBufferNonResidentNV');
- glIsNamedBufferResidentNV := dglGetProcAddress('glIsNamedBufferResidentNV');
- glGetBufferParameterui64vNV := dglGetProcAddress('glGetBufferParameterui64vNV');
- glGetNamedBufferParameterui64vNV := dglGetProcAddress('glGetNamedBufferParameterui64vNV');
- glGetIntegerui64vNV := dglGetProcAddress('glGetIntegerui64vNV');
- glUniformui64NV := dglGetProcAddress('glUniformui64NV');
- glUniformui64vNV := dglGetProcAddress('glUniformui64vNV');
- glGetUniformui64vNV := dglGetProcAddress('glGetUniformui64vNV');
- glProgramUniformui64NV := dglGetProcAddress('glProgramUniformui64NV');
- glProgramUniformui64vNV := dglGetProcAddress('glProgramUniformui64vNV');
-end;
-
-procedure Read_GL_NV_vertex_buffer_unified_memory;
-begin
- glBufferAddressRangeNV := dglGetProcAddress('glBufferAddressRangeNV');
- glVertexFormatNV := dglGetProcAddress('glVertexFormatNV');
- glNormalFormatNV := dglGetProcAddress('glNormalFormatNV');
- glColorFormatNV := dglGetProcAddress('glColorFormatNV');
- glIndexFormatNV := dglGetProcAddress('glIndexFormatNV');
- glTexCoordFormatNV := dglGetProcAddress('glTexCoordFormatNV');
- glEdgeFlagFormatNV := dglGetProcAddress('glEdgeFlagFormatNV');
- glSecondaryColorFormatNV := dglGetProcAddress('glSecondaryColorFormatNV');
- glFogCoordFormatNV := dglGetProcAddress('glFogCoordFormatNV');
- glVertexAttribFormatNV := dglGetProcAddress('glVertexAttribFormatNV');
- glVertexAttribIFormatNV := dglGetProcAddress('glVertexAttribIFormatNV');
- glGetIntegerui64i_vNV := dglGetProcAddress('glGetIntegerui64i_vNV');
-end;
-
-procedure Read_GL_NV_gpu_program5;
-begin
- glProgramSubroutineParametersuivNV := dglGetProcAddress('glProgramSubroutineParametersuivNV');
- glGetProgramSubroutineParameteruivNV := dglGetProcAddress('glGetProgramSubroutineParameteruivNV');
-end;
-
-procedure Read_GL_NV_gpu_shader5;
-begin
- glUniform1i64NV := dglGetProcAddress('glUniform1i64NV');
- glUniform2i64NV := dglGetProcAddress('glUniform2i64NV');
- glUniform3i64NV := dglGetProcAddress('glUniform3i64NV');
- glUniform4i64NV := dglGetProcAddress('glUniform4i64NV');
- glUniform1i64vNV := dglGetProcAddress('glUniform1i64vNV');
- glUniform2i64vNV := dglGetProcAddress('glUniform2i64vNV');
- glUniform3i64vNV := dglGetProcAddress('glUniform3i64vNV');
- glUniform4i64vNV := dglGetProcAddress('glUniform4i64vNV');
- glUniform1ui64NV := dglGetProcAddress('glUniform1ui64NV');
- glUniform2ui64NV := dglGetProcAddress('glUniform2ui64NV');
- glUniform3ui64NV := dglGetProcAddress('glUniform3ui64NV');
- glUniform4ui64NV := dglGetProcAddress('glUniform4ui64NV');
- glUniform1ui64vNV := dglGetProcAddress('glUniform1ui64vNV');
- glUniform2ui64vNV := dglGetProcAddress('glUniform2ui64vNV');
- glUniform3ui64vNV := dglGetProcAddress('glUniform3ui64vNV');
- glUniform4ui64vNV := dglGetProcAddress('glUniform4ui64vNV');
- glGetUniformi64vNV := dglGetProcAddress('glGetUniformi64vNV');
- glProgramUniform1i64NV := dglGetProcAddress('glProgramUniform1i64NV');
- glProgramUniform2i64NV := dglGetProcAddress('glProgramUniform2i64NV');
- glProgramUniform3i64NV := dglGetProcAddress('glProgramUniform3i64NV');
- glProgramUniform4i64NV := dglGetProcAddress('glProgramUniform4i64NV');
- glProgramUniform1i64vNV := dglGetProcAddress('glProgramUniform1i64vNV');
- glProgramUniform2i64vNV := dglGetProcAddress('glProgramUniform2i64vNV');
- glProgramUniform3i64vNV := dglGetProcAddress('glProgramUniform3i64vNV');
- glProgramUniform4i64vNV := dglGetProcAddress('glProgramUniform4i64vNV');
- glProgramUniform1ui64NV := dglGetProcAddress('glProgramUniform1ui64NV');
- glProgramUniform2ui64NV := dglGetProcAddress('glProgramUniform2ui64NV');
- glProgramUniform3ui64NV := dglGetProcAddress('glProgramUniform3ui64NV');
- glProgramUniform4ui64NV := dglGetProcAddress('glProgramUniform4ui64NV');
- glProgramUniform1ui64vNV := dglGetProcAddress('glProgramUniform1ui64vNV');
- glProgramUniform2ui64vNV := dglGetProcAddress('glProgramUniform2ui64vNV');
- glProgramUniform3ui64vNV := dglGetProcAddress('glProgramUniform3ui64vNV');
- glProgramUniform4ui64vNV := dglGetProcAddress('glProgramUniform4ui64vNV');
-end;
-
-procedure Read_GL_NV_vertex_attrib_integer_64bit;
-begin
- glVertexAttribL1i64NV := dglGetProcAddress('glVertexAttribL1i64NV');
- glVertexAttribL2i64NV := dglGetProcAddress('glVertexAttribL2i64NV');
- glVertexAttribL3i64NV := dglGetProcAddress('glVertexAttribL3i64NV');
- glVertexAttribL4i64NV := dglGetProcAddress('glVertexAttribL4i64NV');
- glVertexAttribL1i64vNV := dglGetProcAddress('glVertexAttribL1i64vNV');
- glVertexAttribL2i64vNV := dglGetProcAddress('glVertexAttribL2i64vNV');
- glVertexAttribL3i64vNV := dglGetProcAddress('glVertexAttribL3i64vNV');
- glVertexAttribL4i64vNV := dglGetProcAddress('glVertexAttribL4i64vNV');
- glVertexAttribL1ui64NV := dglGetProcAddress('glVertexAttribL1ui64NV');
- glVertexAttribL2ui64NV := dglGetProcAddress('glVertexAttribL2ui64NV');
- glVertexAttribL3ui64NV := dglGetProcAddress('glVertexAttribL3ui64NV');
- glVertexAttribL4ui64NV := dglGetProcAddress('glVertexAttribL4ui64NV');
- glVertexAttribL1ui64vNV := dglGetProcAddress('glVertexAttribL1ui64vNV');
- glVertexAttribL2ui64vNV := dglGetProcAddress('glVertexAttribL2ui64vNV');
- glVertexAttribL3ui64vNV := dglGetProcAddress('glVertexAttribL3ui64vNV');
- glVertexAttribL4ui64vNV := dglGetProcAddress('glVertexAttribL4ui64vNV');
- glGetVertexAttribLi64vNV := dglGetProcAddress('glGetVertexAttribLi64vNV');
- glGetVertexAttribLui64vNV := dglGetProcAddress('glGetVertexAttribLui64vNV');
- glVertexAttribLFormatNV := dglGetProcAddress('glVertexAttribLFormatNV');
-end;
-
-procedure Read_GL_NV_vdpau_interop;
-begin
- glVDPAUInitNV := dglGetProcAddress('glVDPAUInitNV');
- glVDPAUFiniNV := dglGetProcAddress('glVDPAUFiniNV');
- glVDPAURegisterVideoSurfaceNV := dglGetProcAddress('glVDPAURegisterVideoSurfaceNV');
- glVDPAURegisterOutputSurfaceNV := dglGetProcAddress('glVDPAURegisterOutputSurfaceNV');
- glVDPAUIsSurfaceNV := dglGetProcAddress('glVDPAUIsSurfaceNV');
- glVDPAUUnregisterSurfaceNV := dglGetProcAddress('glVDPAUUnregisterSurfaceNV');
- glVDPAUGetSurfaceivNV := dglGetProcAddress('glVDPAUGetSurfaceivNV');
- glVDPAUSurfaceAccessNV := dglGetProcAddress('glVDPAUSurfaceAccessNV');
- glVDPAUMapSurfacesNV := dglGetProcAddress('glVDPAUMapSurfacesNV');
- glVDPAUUnmapSurfacesNV := dglGetProcAddress('glVDPAUUnmapSurfacesNV');
-end;
-
-procedure Read_GL_NV_texture_barrier;
-begin
- glTextureBarrierNV := dglGetProcAddress('glTextureBarrierNV');
-end;
-
-procedure Read_GL_PGI_misc_hints;
-begin
- glHintPGI := dglGetProcAddress('glHintPGI');
-end;
-
-procedure Read_GL_SGIS_detail_texture;
-begin
- glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS');
- glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS');
-end;
-
-procedure Read_GL_SGIS_fog_function;
-begin
- glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS');
- glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS');
-end;
-
-procedure Read_GL_SGIS_multisample;
-begin
- glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS');
- glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS');
-end;
-
-procedure Read_GL_SGIS_pixel_texture;
-begin
- glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS');
- glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS');
- glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS');
- glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS');
- glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS');
- glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS');
-end;
-
-procedure Read_GL_SGIS_point_parameters;
-begin
- glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS');
- glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS');
-end;
-
-procedure Read_GL_SGIS_sharpen_texture;
-begin
- glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS');
- glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS');
-end;
-
-procedure Read_GL_SGIS_texture4D;
-begin
- glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS');
- glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS');
-end;
-
-procedure Read_GL_SGIS_texture_color_mask;
-begin
- glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS');
-end;
-
-procedure Read_GL_SGIS_texture_filter4;
-begin
- glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS');
- glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS');
-end;
-
-procedure Read_GL_SGIX_async;
-begin
- glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX');
- glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX');
- glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX');
- glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX');
- glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX');
- glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX');
-end;
-
-procedure Read_GL_SGIX_flush_raster;
-begin
- glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX');
-end;
-
-procedure Read_GL_SGIX_fragment_lighting;
-begin
- glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX');
- glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX');
- glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX');
- glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX');
- glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX');
- glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX');
- glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX');
- glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX');
- glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX');
- glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX');
- glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX');
- glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX');
- glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX');
- glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX');
- glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX');
- glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX');
- glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX');
- glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX');
-end;
-
-procedure Read_GL_SGIX_framezoom;
-begin
- glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX');
-end;
-
-procedure Read_GL_SGIX_igloo_interface;
-begin
- glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX');
-end;
-
-procedure Read_GL_SGIX_instruments;
-begin
- glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX');
- glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX');
- glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX');
- glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX');
- glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX');
- glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX');
-end;
-
-procedure Read_GL_SGIX_list_priority;
-begin
- glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX');
- glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX');
- glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX');
- glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX');
- glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX');
- glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX');
-end;
-
-procedure Read_GL_SGIX_pixel_texture;
-begin
- glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX');
-end;
-
-procedure Read_GL_SGIX_polynomial_ffd;
-begin
- glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX');
- glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX');
- glDeformSGIX := dglGetProcAddress('glDeformSGIX');
- glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX');
-end;
-
-procedure Read_GL_SGIX_reference_plane;
-begin
- glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX');
-end;
-
-procedure Read_GL_SGIX_sprite;
-begin
- glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX');
- glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX');
- glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX');
- glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX');
-end;
-
-procedure Read_GL_SGIX_tag_sample_buffer;
-begin
- glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX');
-end;
-
-procedure Read_GL_SGI_color_table;
-begin
- glColorTableSGI := dglGetProcAddress('glColorTableSGI');
- glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI');
- glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI');
- glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI');
- glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI');
- glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI');
- glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI');
-end;
-
-procedure Read_GL_SUNX_constant_data;
-begin
- glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX');
-end;
-
-procedure Read_GL_SUN_global_alpha;
-begin
- glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN');
- glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN');
- glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN');
- glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN');
- glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN');
- glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN');
- glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN');
- glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN');
-end;
-
-procedure Read_GL_SUN_mesh_array;
-begin
- glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN');
-end;
-
-procedure Read_GL_SUN_triangle_list;
-begin
- glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN');
- glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN');
- glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN');
- glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN');
- glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN');
- glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN');
- glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN');
-end;
-
-procedure Read_GL_SUN_vertex;
-begin
- glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN');
- glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN');
- glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN');
- glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN');
- glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN');
- glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN');
- glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN');
- glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN');
- glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN');
- glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN');
- glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN');
- glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN');
- glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN');
- glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN');
- glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN');
- glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN');
- glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN');
- glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN');
- glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN');
- glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN');
- glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN');
- glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN');
- glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN');
- glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN');
- glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN');
- glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN');
- glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN');
- glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN');
- glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN');
- glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN');
- glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN');
- glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN');
- glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
- glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
- glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN');
- glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN');
- glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
- glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
- glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
- glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
-end;
-
-{$IFDEF DGL_WIN}
-procedure Read_WGL_ARB_buffer_region;
-begin
- wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB');
- wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB');
- wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB');
- wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB');
-end;
-
-procedure Read_WGL_ARB_extensions_string;
-begin
- wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
-end;
-
-procedure Read_WGL_ARB_make_current_read;
-begin
- wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB');
- wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB');
-end;
-
-procedure Read_WGL_ARB_pbuffer;
-begin
- wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB');
- wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB');
- wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB');
- wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB');
- wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB');
-end;
-
-procedure Read_WGL_ARB_pixel_format;
-begin
- wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB');
- wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB');
- wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB');
-end;
-
-procedure Read_WGL_ARB_pixel_format_float;
-begin
- wglClampColorARB := dglGetProcAddress('wglClampColorARB');
-end;
-
-procedure Read_WGL_ARB_render_texture;
-begin
- wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB');
- wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB');
- wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB');
-end;
-
-procedure Read_WGL_ARB_create_context;
-begin
- wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB');
-end;
-
-procedure Read_WGL_AMD_gpu_association;
-begin
- wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD');
- wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD');
- wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD');
- wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD');
- wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD');
- wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD');
- wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD');
- wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD');
- wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD');
-end;
-
-procedure Read_WGL_EXT_display_color_table;
-begin
- wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT');
- wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT');
- wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT');
- wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT');
-end;
-
-procedure Read_WGL_EXT_extensions_string;
-begin
- wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
-end;
-
-procedure Read_WGL_EXT_make_current_read;
-begin
- wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT');
- wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT');
-end;
-
-procedure Read_WGL_EXT_pbuffer;
-begin
- wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT');
- wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT');
- wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT');
- wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT');
- wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT');
-end;
-
-procedure Read_WGL_EXT_pixel_format;
-begin
- wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT');
- wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT');
- wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT');
-end;
-
-procedure Read_WGL_EXT_swap_control;
-begin
- wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT');
- wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT');
-end;
-
-procedure Read_WGL_I3D_digital_video_control;
-begin
- wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D');
- wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D');
-end;
-
-procedure Read_WGL_I3D_gamma;
-begin
- wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D');
- wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D');
- wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D');
- wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D');
-end;
-
-procedure Read_WGL_I3D_genlock;
-begin
- wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D');
- wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D');
- wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D');
- wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D');
- wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D');
- wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D');
- wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D');
- wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D');
- wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D');
- wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D');
- wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D');
- wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
-end;
-
-procedure Read_WGL_I3D_image_buffer;
-begin
- wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D');
- wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D');
- wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D');
- wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D');
-end;
-
-procedure Read_WGL_I3D_swap_frame_lock;
-begin
- wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D');
- wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D');
- wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D');
- wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D');
-end;
-
-procedure Read_WGL_I3D_swap_frame_usage;
-begin
- wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D');
- wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D');
- wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D');
- wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D');
-end;
-
-procedure Read_WGL_NV_vertex_array_range;
-begin
- wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV');
- wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV');
-end;
-
-procedure Read_WGL_NV_present_video;
-begin
- wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV');
- wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV');
- wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV');
-end;
-
-procedure Read_WGL_NV_video_output;
-begin
- wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV');
- wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV');
- wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV');
- wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV');
- wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV');
- wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV');
-end;
-
-procedure Read_WGL_NV_swap_group;
-begin
- wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV');
- wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV');
- wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV');
- wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV');
- wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV');
- wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV');
-end;
-
-procedure Read_WGL_NV_gpu_affinity;
-begin
- wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV');
- wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV');
- wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV');
- wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV');
- wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV');
-end;
-
-procedure Read_WGL_NV_video_capture;
-begin
- wglBindVideoCaptureDeviceNV := dglGetProcAddress('wglBindVideoCaptureDeviceNV');
- wglEnumerateVideoCaptureDevicesNV := dglGetProcAddress('wglEnumerateVideoCaptureDevicesNV');
- wglLockVideoCaptureDeviceNV := dglGetProcAddress('wglLockVideoCaptureDeviceNV');
- wglQueryVideoCaptureDeviceNV := dglGetProcAddress('wglQueryVideoCaptureDeviceNV');
- wglReleaseVideoCaptureDeviceNV := dglGetProcAddress('wglReleaseVideoCaptureDeviceNV');
-end;
-
-procedure Read_WGL_NV_copy_image;
-begin
- wglCopyImageSubDataNV := dglGetProcAddress('wglCopyImageSubDataNV');
-end;
-
-procedure Read_WGL_NV_DX_interop;
-begin
- wglDXSetResourceShareHandleNV := dglGetProcAddress('wglDXSetResourceShareHandleNV');
- wglDXOpenDeviceNV := dglGetProcAddress('wglDXOpenDeviceNV');
- wglDXCloseDeviceNV := dglGetProcAddress('wglDXCloseDeviceNV');
- wglDXRegisterObjectNV := dglGetProcAddress('wglDXRegisterObjectNV');
- wglDXUnregisterObjectNV := dglGetProcAddress('wglDXUnregisterObjectNV');
- wglDXObjectAccessNV := dglGetProcAddress('wglDXObjectAccessNV');
- wglDXLockObjectsNV := dglGetProcAddress('wglDXLockObjectsNV');
- wglDXUnlockObjectsNV := dglGetProcAddress('wglDXUnlockObjectsNV');
-end;
-
-
-procedure Read_WGL_OML_sync_control;
-begin
- wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML');
- wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML');
- wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML');
- wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML');
- wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML');
- wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML');
-end;
-
-procedure Read_WGL_3DL_stereo_control;
-begin
- wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL');
-end;
-
-procedure Read_WIN_draw_range_elements;
-begin
- glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN');
-end;
-
-procedure Read_WIN_swap_hint;
-begin
- glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN');
-end;
-{$ENDIF}
-
-
-procedure ReadExtensions;
-begin
- ReadOpenGLCore;
-
- Read_GL_3DFX_tbuffer;
- Read_GL_APPLE_element_array;
- Read_GL_APPLE_fence;
- Read_GL_APPLE_vertex_array_object;
- Read_GL_APPLE_vertex_array_range;
- Read_GL_APPLE_texture_range;
- Read_GL_APPLE_vertex_program_evaluators;
- Read_GL_APPLE_object_purgeable;
- Read_GL_ARB_matrix_palette;
- Read_GL_ARB_multitexture;
- Read_GL_ARB_point_parameters;
- Read_GL_ARB_texture_compression;
- Read_GL_ARB_transpose_matrix;
- Read_GL_ARB_vertex_blend;
- Read_GL_ARB_vertex_buffer_object;
- Read_GL_ARB_vertex_program;
- Read_GL_ARB_window_pos;
- Read_GL_ARB_color_buffer_float;
- Read_GL_ARB_Shader_Objects;
- Read_GL_ARB_occlusion_query;
- Read_GL_ARB_draw_instanced;
- Read_GL_ARB_framebuffer_object;
- Read_GL_ARB_geometry_shader4;
- Read_GL_ARB_instanced_arrays;
- Read_GL_ARB_map_buffer_range;
- Read_GL_ARB_texture_buffer_object;
- Read_GL_ARB_vertex_array_object;
- Read_GL_ARB_uniform_buffer_object;
- Read_GL_ARB_copy_buffer;
- Read_GL_ARB_draw_elements_base_vertex;
- Read_GL_ARB_provoking_vertex;
- Read_GL_ARB_sync;
- Read_GL_ARB_texture_multisample;
- Read_GL_ARB_draw_buffers_blend;
- Read_GL_ARB_sample_shading;
- Read_GL_ARB_shading_language_include;
- Read_GL_ARB_blend_func_extended;
- Read_GL_ARB_sampler_objects;
- Read_GL_ARB_timer_query;
- Read_GL_ARB_vertex_type_2_10_10_10_rev;
- Read_GL_ARB_draw_indirect;
- Read_GL_ARB_gpu_shader_fp64;
- Read_GL_ARB_shader_subroutine;
- Read_GL_ARB_tessellation_shader;
- Read_GL_ARB_transform_feedback2;
- Read_GL_ARB_transform_feedback3;
- Read_GL_ARB_ES2_compatibility;
- Read_GL_ARB_get_program_binary;
- Read_GL_ARB_separate_shader_objects;
- Read_GL_ARB_vertex_attrib_64bit;
- Read_GL_ARB_viewport_array;
- Read_GL_ARB_cl_event;
- Read_GL_ARB_debug_output;
- Read_GL_ARB_robustness;
- //
- Read_GL_ATI_draw_buffers;
- Read_GL_ATI_element_array;
- Read_GL_ATI_envmap_bumpmap;
- Read_GL_ATI_fragment_shader;
- Read_GL_ATI_map_object_buffer;
- Read_GL_ATI_pn_triangles;
- Read_GL_ATI_separate_stencil;
- Read_GL_ATI_vertex_array_object;
- Read_GL_ATI_vertex_attrib_array_object;
- Read_GL_ATI_vertex_streams;
- Read_GL_AMD_performance_monitor;
- Read_GL_AMD_vertex_shader_tesselator;
- Read_GL_AMD_draw_buffers_blend;
- Read_GL_AMD_name_gen_delete;
- Read_GL_AMD_debug_output;
- Read_GL_AMD_stencil_operation_extended;
- Read_GL_EXT_blend_color;
- Read_GL_EXT_blend_func_separate;
- Read_GL_EXT_blend_minmax;
- Read_GL_EXT_color_subtable;
- Read_GL_EXT_compiled_vertex_array;
- Read_GL_EXT_convolution;
- Read_GL_EXT_coordinate_frame;
- Read_GL_EXT_copy_texture;
- Read_GL_EXT_cull_vertex;
- Read_GL_EXT_draw_range_elements;
- Read_GL_EXT_fog_coord;
- Read_GL_EXT_framebuffer_object;
- Read_GL_EXT_histogram;
- Read_GL_EXT_index_func;
- Read_GL_EXT_index_material;
- Read_GL_EXT_multi_draw_arrays;
- Read_GL_EXT_multisample;
- Read_GL_EXT_paletted_texture;
- Read_GL_EXT_pixel_transform;
- Read_GL_EXT_point_parameters;
- Read_GL_EXT_polygon_offset;
- Read_GL_EXT_secondary_color;
- Read_GL_EXT_stencil_two_side;
- Read_GL_EXT_subtexture;
- Read_GL_EXT_texture3D;
- Read_GL_EXT_texture_object;
- Read_GL_EXT_texture_perturb_normal;
- Read_GL_EXT_vertex_array;
- Read_GL_EXT_vertex_shader;
- Read_GL_EXT_vertex_weighting;
- Read_GL_EXT_depth_bounds_test;
- Read_GL_EXT_blend_equation_separate;
- Read_GL_EXT_stencil_clear_tag;
- Read_GL_EXT_framebuffer_blit;
- Read_GL_EXT_framebuffer_multisample;
- Read_GL_EXT_timer_query;
- Read_GL_EXT_gpu_program_parameters;
- Read_GL_EXT_bindable_uniform;
- Read_GL_EXT_draw_buffers2;
- Read_GL_EXT_draw_instanced;
- Read_GL_EXT_geometry_shader4;
- Read_GL_EXT_gpu_shader4;
- Read_GL_EXT_texture_array;
- Read_GL_EXT_texture_buffer_object;
- Read_GL_EXT_texture_integer;
- Read_GL_EXT_transform_feedback;
- Read_GL_EXT_direct_state_access;
- Read_GL_EXT_separate_shader_objects;
- Read_GL_EXT_shader_image_load_store;
- Read_GL_EXT_vertex_attrib_64bit;
- Read_GL_HP_image_transform;
- Read_GL_IBM_multimode_draw_arrays;
- Read_GL_IBM_vertex_array_lists;
- Read_GL_INGR_blend_func_separate;
- Read_GL_INTEL_parallel_arrays;
- Read_GL_MESA_resize_buffers;
- Read_GL_MESA_window_pos;
- Read_GL_NV_evaluators;
- Read_GL_NV_fence;
- Read_GL_NV_fragment_program;
- Read_GL_NV_half_float;
- Read_GL_NV_occlusion_query;
- Read_GL_NV_pixel_data_range;
- Read_GL_NV_point_sprite;
- Read_GL_NV_primitive_restart;
- Read_GL_NV_register_combiners;
- Read_GL_NV_register_combiners2;
- Read_GL_NV_vertex_array_range;
- Read_GL_NV_vertex_program;
- Read_GL_NV_depth_buffer_float;
- Read_GL_NV_framebuffer_multisample_coverage;
- Read_GL_NV_geometry_program4;
- Read_GL_NV_gpu_program4;
- Read_GL_NV_parameter_buffer_object;
- Read_GL_NV_transform_feedback;
- Read_GL_NV_conditional_render;
- Read_GL_NV_present_video;
- Read_GL_NV_explicit_multisample;
- Read_GL_NV_transform_feedback2;
- Read_GL_NV_video_capture;
- Read_GL_NV_copy_image;
- Read_GL_NV_shader_buffer_load;
- Read_GL_NV_vertex_buffer_unified_memory;
- Read_GL_NV_gpu_program5;
- Read_GL_NV_gpu_shader5;
- Read_GL_NV_vertex_attrib_integer_64bit;
- Read_GL_NV_vdpau_interop;
- Read_GL_NV_texture_barrier;
- Read_GL_NV_path_rendering;
- Read_GL_NV_bindless_texture;
- Read_GL_PGI_misc_hints;
- Read_GL_SGIS_detail_texture;
- Read_GL_SGIS_fog_function;
- Read_GL_SGIS_multisample;
- Read_GL_SGIS_pixel_texture;
- Read_GL_SGIS_point_parameters;
- Read_GL_SGIS_sharpen_texture;
- Read_GL_SGIS_texture4D;
- Read_GL_SGIS_texture_color_mask;
- Read_GL_SGIS_texture_filter4;
- Read_GL_SGIX_async;
- Read_GL_SGIX_flush_raster;
- Read_GL_SGIX_fragment_lighting;
- Read_GL_SGIX_framezoom;
- Read_GL_SGIX_igloo_interface;
- Read_GL_SGIX_instruments;
- Read_GL_SGIX_list_priority;
- Read_GL_SGIX_pixel_texture;
- Read_GL_SGIX_polynomial_ffd;
- Read_GL_SGIX_reference_plane;
- Read_GL_SGIX_sprite;
- Read_GL_SGIX_tag_sample_buffer;
- Read_GL_SGI_color_table;
- Read_GL_SUNX_constant_data;
- Read_GL_SUN_global_alpha;
- Read_GL_SUN_mesh_array;
- Read_GL_SUN_triangle_list;
- Read_GL_SUN_vertex;
-
-{$IFDEF DGL_WIN}
- Read_WGL_ARB_buffer_region;
- Read_WGL_ARB_extensions_string;
- Read_WGL_ARB_make_current_read;
- Read_WGL_ARB_pbuffer;
- Read_WGL_ARB_pixel_format;
- Read_WGL_ARB_pixel_format_float;
- Read_WGL_ARB_render_texture;
- Read_WGL_ARB_create_context;
- Read_WGL_AMD_gpu_association;
- Read_WGL_EXT_display_color_table;
- Read_WGL_EXT_extensions_string;
- Read_WGL_EXT_make_current_read;
- Read_WGL_EXT_pbuffer;
- Read_WGL_EXT_pixel_format;
- Read_WGL_EXT_swap_control;
- Read_WGL_I3D_digital_video_control;
- Read_WGL_I3D_gamma;
- Read_WGL_I3D_genlock;
- Read_WGL_I3D_image_buffer;
- Read_WGL_I3D_swap_frame_lock;
- Read_WGL_I3D_swap_frame_usage;
- Read_WGL_NV_vertex_array_range;
- Read_WGL_NV_present_video;
- Read_WGL_NV_video_output;
- Read_WGL_NV_swap_group;
- Read_WGL_NV_gpu_affinity;
- Read_WGL_NV_video_capture;
- Read_WGL_NV_copy_image;
- Read_WGL_NV_DX_interop;
- Read_WGL_OML_sync_control;
- Read_WGL_3DL_stereo_control;
-
- Read_WIN_draw_range_elements;
- Read_WIN_swap_hint;
-{$ENDIF}
-
- ExtensionsRead := True;
-end;
-
-// =============================================================================
-// ReadCoreVersion
-// =============================================================================
-
-procedure ReadCoreVersion;
-var
- AnsiBuffer: AnsiString;
- Buffer: String;
- MajorVersion, MinorVersion: Integer;
-
- procedure TrimAndSplitVersionString(Buffer: String; out Max, Min: Integer);
- // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
- // at least however "Major.Minor".
- var
- Separator: Integer;
- begin
- try
- // There must be at least one dot to separate major and minor version number.
- Separator := Pos('.', Buffer);
- // At least one number must be before and one after the dot.
- if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and
- (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then
- begin
- // OK, it's a valid version string. Now remove unnecessary parts.
- Dec(Separator);
- // Find last non-numeric character before version number.
- while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
- Dec(Separator);
- // Delete leading characters which do not belong to the version string.
- Delete(Buffer, 1, Separator);
- Separator := Pos('.', Buffer) + 1;
- // Find first non-numeric character after version number
- while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
- Inc(Separator);
- // delete trailing characters not belonging to the version string
- Delete(Buffer, Separator, 255);
- // Now translate the numbers.
- Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.
- Max := StrToInt(Copy(Buffer, 1, Separator - 1));
- Min := StrToInt(Copy(Buffer, Separator + 1, 1));
- end
- else
- Abort;
- except
- Min := 0;
- Max := 0;
- end;
- end;
-
-
-begin
- // determine version of implementation
- // GL
- if not Assigned(@glGetString) then
- glGetString := dglGetProcAddress('glGetString');
-
- AnsiBuffer := glGetString(GL_VERSION);
- Buffer := String(AnsiBuffer);
-
- TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion);
-
- GL_VERSION_1_0 := True;
- GL_VERSION_1_1 := False;
- GL_VERSION_1_2 := False;
- GL_VERSION_1_3 := False;
- GL_VERSION_1_4 := False;
- GL_VERSION_1_5 := False;
- GL_VERSION_2_0 := False;
- GL_VERSION_2_1 := False;
- GL_VERSION_3_0 := False;
- GL_VERSION_3_1 := False;
- GL_VERSION_3_2 := False;
- GL_VERSION_3_3 := False;
- GL_VERSION_4_0 := False;
- GL_VERSION_4_1 := False;
- GL_VERSION_4_2 := False;
- GL_VERSION_4_3 := False;
- GL_VERSION_4_4 := False;
-
- if MajorVersion = 1 then
- begin
- if MinorVersion >= 1 then
- GL_VERSION_1_1 := True;
- if MinorVersion >= 2 then
- GL_VERSION_1_2 := True;
- if MinorVersion >= 3 then
- GL_VERSION_1_3 := True;
- if MinorVersion >= 4 then
- GL_VERSION_1_4 := True;
- if MinorVersion >= 5 then
- GL_VERSION_1_5 := True;
- end;
-
- if MajorVersion >= 2 then
- begin
- GL_VERSION_1_1 := True;
- GL_VERSION_1_2 := True;
- GL_VERSION_1_3 := True;
- GL_VERSION_1_4 := True;
- GL_VERSION_1_5 := True;
- GL_VERSION_2_0 := True;
-
- if MinorVersion >= 1 then
- GL_VERSION_2_1 := True;
- end;
-
- if MajorVersion >= 3 then
- begin
- GL_VERSION_2_1 := True;
- GL_VERSION_3_0 := True;
-
- if MinorVersion >= 1 then
- GL_VERSION_3_1 := True;
- if MinorVersion >= 2 then
- GL_VERSION_3_2 := True;
- if MinorVersion >= 3 then
- GL_VERSION_3_3 := True;
- end;
-
- if MajorVersion >= 4 then
- begin
- GL_VERSION_3_1 := True;
- GL_VERSION_3_2 := True;
- GL_VERSION_3_3 := True;
- GL_VERSION_4_0 := True;
-
- if MinorVersion >= 1 then
- GL_VERSION_4_1 := True;
- if MinorVersion >= 2 then
- GL_VERSION_4_2 := True;
- if MinorVersion >= 3 then
- GL_VERSION_4_3 := True;
- if MinorVersion >= 4 then
- GL_VERSION_4_4 := True;
- end;
-
- // GLU
- GLU_VERSION_1_1 := False;
- GLU_VERSION_1_2 := False;
- GLU_VERSION_1_3 := False;
-
- if Assigned(gluGetString) then begin
- AnsiBuffer := gluGetString(GLU_VERSION);
- Buffer := String(AnsiBuffer);
-
- TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion);
-
- GLU_VERSION_1_1 := True;
-
- if MinorVersion >= 2 then
- GLU_VERSION_1_2 := True;
-
- if MinorVersion >= 3 then
- GLU_VERSION_1_3 := True;
- end;
-end;
-
-
-// =============================================================================
-// ReadImplementationProperties
-// =============================================================================
-
-procedure ReadImplementationProperties;
-var
- Buffer: Ansistring;
-begin
- ReadCoreVersion;
-
- // Check all extensions
- Buffer := Int_GetExtensionString;
-
- // === 3DFX ====================================================================
- GL_3DFX_multisample := Int_CheckExtension(Buffer, 'GL_3DFX_multisample');
- GL_3DFX_tbuffer := Int_CheckExtension(Buffer, 'GL_3DFX_tbuffer');
- GL_3DFX_texture_compression_FXT1 := Int_CheckExtension(Buffer, 'GL_3DFX_texture_compression_FXT1');
-
- // === APPLE ===================================================================
- GL_APPLE_client_storage := Int_CheckExtension(Buffer, 'GL_APPLE_client_storage');
- GL_APPLE_element_array := Int_CheckExtension(Buffer, 'GL_APPLE_element_array');
- GL_APPLE_fence := Int_CheckExtension(Buffer, 'GL_APPLE_fence');
- GL_APPLE_specular_vector := Int_CheckExtension(Buffer, 'GL_APPLE_specular_vector');
- GL_APPLE_transform_hint := Int_CheckExtension(Buffer, 'GL_APPLE_transform_hint');
- GL_APPLE_vertex_array_object := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_object');
- GL_APPLE_vertex_array_range := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_range');
- GL_APPLE_ycbcr_422 := Int_CheckExtension(Buffer, 'GL_APPLE_ycbcr_422');
- GL_APPLE_texture_range := Int_CheckExtension(Buffer, 'GL_APPLE_texture_range');
- GL_APPLE_float_pixels := Int_CheckExtension(Buffer, 'GL_APPLE_float_pixels');
- GL_APPLE_vertex_program_evaluators := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_program_evaluators');
- GL_APPLE_aux_depth_stencil := Int_CheckExtension(Buffer, 'GL_APPLE_aux_depth_stencil');
- GL_APPLE_object_purgeable := Int_CheckExtension(Buffer, 'GL_APPLE_object_purgeable');
- GL_APPLE_row_bytes := Int_CheckExtension(Buffer, 'GL_APPLE_row_bytes');
- GL_APPLE_rgb_422 := Int_CheckExtension(Buffer, 'GL_APPLE_rgb_422');
-
- // === ARB =====================================================================
- GL_ARB_depth_texture := Int_CheckExtension(Buffer, 'GL_ARB_depth_texture');
- GL_ARB_fragment_program := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program');
- GL_ARB_imaging := Int_CheckExtension(Buffer, 'GL_ARB_imaging');
- GL_ARB_matrix_palette := Int_CheckExtension(Buffer, 'GL_ARB_matrix_palette');
- GL_ARB_multisample := Int_CheckExtension(Buffer, 'GL_ARB_multisample');
- GL_ARB_multitexture := Int_CheckExtension(Buffer, 'GL_ARB_multitexture');
- GL_ARB_point_parameters := Int_CheckExtension(Buffer, 'GL_ARB_point_parameters');
- GL_ARB_shadow := Int_CheckExtension(Buffer, 'GL_ARB_shadow');
- GL_ARB_shadow_ambient := Int_CheckExtension(Buffer, 'GL_ARB_shadow_ambient');
- GL_ARB_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp');
- GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression');
- GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map');
- GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add');
- GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine');
- GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar');
- GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3');
- GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat');
- GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix');
- GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend');
- GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object');
- GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program');
- GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos');
- GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects');
- GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader');
- GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader');
- GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query');
- GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100');
- GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite');
- GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two');
- GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow');
- GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers');
- GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle');
- GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float');
- GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel');
- GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float');
- GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object');
- GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float');
- GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced');
- GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object');
- GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB');
- GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4');
- GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex');
- GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays');
- GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range');
- GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object');
- GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc');
- GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg');
- GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object');
- GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object');
- GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility');
- GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer');
- GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod');
- GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp');
- GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex');
- GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions');
- GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex');
- GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map');
- GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync');
- GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample');
- GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra');
- GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend');
- GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading');
- GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array');
- GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather');
- GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod');
- GL_ARB_shading_language_include := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_include');
- GL_ARB_texture_compression_bptc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_bptc');
- GL_ARB_blend_func_extended := Int_CheckExtension(Buffer, 'GL_ARB_blend_func_extended');
- GL_ARB_explicit_attrib_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_attrib_location');
- GL_ARB_occlusion_query2 := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query2');
- GL_ARB_sampler_objects := Int_CheckExtension(Buffer, 'GL_ARB_sampler_objects');
- GL_ARB_shader_bit_encoding := Int_CheckExtension(Buffer, 'GL_ARB_shader_bit_encoding');
- GL_ARB_texture_rgb10_a2ui := Int_CheckExtension(Buffer, 'GL_ARB_texture_rgb10_a2ui');
- GL_ARB_texture_swizzle := Int_CheckExtension(Buffer, 'GL_ARB_texture_swizzle');
- GL_ARB_timer_query := Int_CheckExtension(Buffer, 'GL_ARB_timer_query');
- GL_ARB_vertex_type_2_10_10_10_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_2_10_10_10_rev');
- GL_ARB_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_draw_indirect');
- GL_ARB_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader5');
- GL_ARB_gpu_shader_fp64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_fp64');
- GL_ARB_shader_subroutine := Int_CheckExtension(Buffer, 'GL_ARB_shader_subroutine');
- GL_ARB_tessellation_shader := Int_CheckExtension(Buffer, 'GL_ARB_tessellation_shader');
- GL_ARB_texture_buffer_object_rgb32 := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object_rgb32');
- GL_ARB_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback2');
- GL_ARB_transform_feedback3 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback3');
- GL_ARB_ES2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES2_compatibility');
- GL_ARB_get_program_binary := Int_CheckExtension(Buffer, 'GL_ARB_get_program_binary');
- GL_ARB_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_separate_shader_objects');
- GL_ARB_shader_precision := Int_CheckExtension(Buffer, 'GL_ARB_shader_precision');
- GL_ARB_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_64bit');
- GL_ARB_viewport_array := Int_CheckExtension(Buffer, 'GL_ARB_viewport_array');
-
- // GL 4.2
- GL_ARB_base_instance := Int_CheckExtension(Buffer, 'GL_ARB_base_instance');
- GL_ARB_shading_language_420pack := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_420pack');
- GL_ARB_transform_feedback_instanced := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback_instanced');
- GL_ARB_compressed_texture_pixel_storage := Int_CheckExtension(Buffer, 'GL_ARB_compressed_texture_pixel_storage');
- GL_ARB_conservative_depth := Int_CheckExtension(Buffer, 'GL_ARB_conservative_depth');
- GL_ARB_internalformat_query := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query');
- GL_ARB_map_buffer_alignment := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_alignment');
- GL_ARB_shader_atomic_counters := Int_CheckExtension(Buffer, 'GL_ARB_shader_atomic_counters');
- GL_ARB_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_load_store');
- GL_ARB_shading_language_packing := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_packing');
- GL_ARB_texture_storage := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage');
- // END GL 4.2
-
- // GL 4.3
- GL_ARB_arrays_of_arrays := Int_CheckExtension(Buffer, 'GL_ARB_arrays_of_arrays');
- GL_ARB_fragment_layer_viewport := Int_CheckExtension(Buffer, 'GL_ARB_fragment_layer_viewport');
- GL_ARB_shader_image_size := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_size');
- GL_ARB_ES3_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_compatibility');
- GL_ARB_clear_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_clear_buffer_object');
- GL_ARB_compute_shader := Int_CheckExtension(Buffer, 'GL_ARB_compute_shader');
- GL_ARB_copy_image := Int_CheckExtension(Buffer, 'GL_ARB_copy_image');
- GL_KHR_debug := Int_CheckExtension(Buffer, 'GL_KHR_debug');
- GL_ARB_explicit_uniform_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_uniform_location');
- GL_ARB_framebuffer_no_attachments := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_no_attachments');
- GL_ARB_internalformat_query2 := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query2');
- GL_ARB_invalidate_subdata := Int_CheckExtension(Buffer, 'GL_ARB_invalidate_subdata');
- GL_ARB_multi_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_multi_draw_indirect');
- GL_ARB_program_interface_query := Int_CheckExtension(Buffer, 'GL_ARB_program_interface_query');
- GL_ARB_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_ARB_robust_buffer_access_behavior');
- GL_ARB_shader_storage_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_shader_storage_buffer_object');
- GL_ARB_stencil_texturing := Int_CheckExtension(Buffer, 'GL_ARB_stencil_texturing');
- GL_ARB_texture_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_range');
- GL_ARB_texture_query_levels := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_levels');
- GL_ARB_texture_storage_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage_multisample');
- GL_ARB_texture_view := Int_CheckExtension(Buffer, 'GL_ARB_texture_view');
- GL_ARB_vertex_attrib_binding := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_binding');
- GL_ARB_cl_event := Int_CheckExtension(Buffer, 'GL_ARB_cl_event');
- GL_ARB_debug_output := Int_CheckExtension(Buffer, 'GL_ARB_debug_output');
- GL_ARB_robustness := Int_CheckExtension(Buffer, 'GL_ARB_robustness');
- GL_ARB_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_ARB_shader_stencil_export');
- // END GL 4.3
-
- // GL 4.4
- GL_ARB_buffer_storage := Int_CheckExtension(Buffer, 'GL_ARB_buffer_storage');
- GL_ARB_clear_texture := Int_CheckExtension(Buffer, 'GL_ARB_clear_texture');
- GL_ARB_enhanced_layouts := Int_CheckExtension(Buffer, 'GL_ARB_enhanced_layouts');
- GL_ARB_multi_bind := Int_CheckExtension(Buffer, 'GL_ARB_multi_bind');
- GL_ARB_query_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_query_buffer_object');
- GL_ARB_texture_mirror_clamp_to_edge := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirror_clamp_to_edge');
- GL_ARB_texture_stencil8 := Int_CheckExtension(Buffer, 'GL_ARB_texture_stencil8');
- GL_ARB_vertex_type_10f_11f_11f_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_10f_11f_11f_rev');
- // END GL 4.4
-
- // === ATI/AMD ================================================================
- GL_ATI_draw_buffers := Int_CheckExtension(Buffer, 'GL_ATI_draw_buffers');
- GL_ATI_element_array := Int_CheckExtension(Buffer, 'GL_ATI_element_array');
- GL_ATI_envmap_bumpmap := Int_CheckExtension(Buffer, 'GL_ATI_envmap_bumpmap');
- GL_ATI_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_fragment_shader');
- GL_ATI_map_object_buffer := Int_CheckExtension(Buffer, 'GL_ATI_map_object_buffer');
- GL_ATI_pn_triangles := Int_CheckExtension(Buffer, 'GL_ATI_pn_triangles');
- GL_ATI_separate_stencil := Int_CheckExtension(Buffer, 'GL_ATI_separate_stencil');
- GL_ATI_text_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_text_fragment_shader');
- GL_ATI_texture_env_combine3 := Int_CheckExtension(Buffer, 'GL_ATI_texture_env_combine3');
- GL_ATI_texture_float := Int_CheckExtension(Buffer, 'GL_ATI_texture_float');
- GL_ATI_texture_mirror_once := Int_CheckExtension(Buffer, 'GL_ATI_texture_mirror_once');
- GL_ATI_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_array_object');
- GL_ATI_vertex_attrib_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_attrib_array_object');
- GL_ATI_vertex_streams := Int_CheckExtension(Buffer, 'GL_ATI_vertex_streams');
- GL_ATI_meminfo := Int_CheckExtension(Buffer, 'GL_ATI_meminfo');
- GL_AMD_performance_monitor := Int_CheckExtension(Buffer, 'GL_AMD_performance_monitor');
- GL_AMD_texture_texture4 := Int_CheckExtension(Buffer, 'GL_AMD_texture_texture4');
- GL_AMD_vertex_shader_tesselator := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_tesselator');
- GL_AMD_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_AMD_draw_buffers_blend');
- GL_AMD_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_AMD_shader_stencil_export');
- GL_AMD_seamless_cubemap_per_texture := Int_CheckExtension(Buffer, 'GL_AMD_seamless_cubemap_per_texture');
- GL_AMD_conservative_depth := Int_CheckExtension(Buffer, 'GL_AMD_conservative_depth');
- GL_AMD_name_gen_delete := Int_CheckExtension(Buffer, 'GL_AMD_name_gen_delete');
- GL_AMD_debug_output := Int_CheckExtension(Buffer, 'GL_AMD_debug_output');
- GL_AMD_transform_feedback3_lines_triangles := Int_CheckExtension(Buffer, 'GL_AMD_transform_feedback3_lines_triangles');
- GL_AMD_depth_clamp_separate := Int_CheckExtension(Buffer, 'GL_AMD_depth_clamp_separate');
- // 4.3
- GL_AMD_pinned_memory := Int_CheckExtension(Buffer, 'GL_AMD_pinned_memory');
- GL_AMD_stencil_operation_extended := Int_CheckExtension(Buffer, 'GL_AMD_stencil_operation_extended');
- GL_AMD_vertex_shader_viewport_index := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_viewport_index');
- GL_AMD_vertex_shader_layer := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_layer');
- GL_AMD_query_buffer_object := Int_CheckExtension(Buffer, 'GL_AMD_query_buffer_object');
-
- // === EXT =====================================================================
- GL_EXT_422_pixels := Int_CheckExtension(Buffer, 'GL_EXT_422_pixels');
- GL_EXT_abgr := Int_CheckExtension(Buffer, 'GL_EXT_abgr');
- GL_EXT_bgra := Int_CheckExtension(Buffer, 'GL_EXT_bgra');
- GL_EXT_blend_color := Int_CheckExtension(Buffer, 'GL_EXT_blend_color');
- GL_EXT_blend_func_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_func_separate');
- GL_EXT_blend_logic_op := Int_CheckExtension(Buffer, 'GL_EXT_blend_logic_op');
- GL_EXT_blend_minmax := Int_CheckExtension(Buffer, 'GL_EXT_blend_minmax');
- GL_EXT_blend_subtract := Int_CheckExtension(Buffer, 'GL_EXT_blend_subtract');
- GL_EXT_clip_volume_hint := Int_CheckExtension(Buffer, 'GL_EXT_clip_volume_hint');
- GL_EXT_cmyka := Int_CheckExtension(Buffer, 'GL_EXT_cmyka');
- GL_EXT_color_matrix := Int_CheckExtension(Buffer, 'GL_EXT_color_matrix');
- GL_EXT_color_subtable := Int_CheckExtension(Buffer, 'GL_EXT_color_subtable');
- GL_EXT_compiled_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_compiled_vertex_array');
- GL_EXT_convolution := Int_CheckExtension(Buffer, 'GL_EXT_convolution');
- GL_EXT_coordinate_frame := Int_CheckExtension(Buffer, 'GL_EXT_coordinate_frame');
- GL_EXT_copy_texture := Int_CheckExtension(Buffer, 'GL_EXT_copy_texture');
- GL_EXT_cull_vertex := Int_CheckExtension(Buffer, 'GL_EXT_cull_vertex');
- GL_EXT_draw_range_elements := Int_CheckExtension(Buffer, 'GL_EXT_draw_range_elements');
- GL_EXT_fog_coord := Int_CheckExtension(Buffer, 'GL_EXT_fog_coord');
- GL_EXT_framebuffer_object := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_object');
- GL_EXT_histogram := Int_CheckExtension(Buffer, 'GL_EXT_histogram');
- GL_EXT_index_array_formats := Int_CheckExtension(Buffer, 'GL_EXT_index_array_formats');
- GL_EXT_index_func := Int_CheckExtension(Buffer, 'GL_EXT_index_func');
- GL_EXT_index_material := Int_CheckExtension(Buffer, 'GL_EXT_index_material');
- GL_EXT_index_texture := Int_CheckExtension(Buffer, 'GL_EXT_index_texture');
- GL_EXT_light_texture := Int_CheckExtension(Buffer, 'GL_EXT_light_texture');
- GL_EXT_misc_attribute := Int_CheckExtension(Buffer, 'GL_EXT_misc_attribute');
- GL_EXT_multi_draw_arrays := Int_CheckExtension(Buffer, 'GL_EXT_multi_draw_arrays');
- GL_EXT_multisample := Int_CheckExtension(Buffer, 'GL_EXT_multisample');
- GL_EXT_packed_pixels := Int_CheckExtension(Buffer, 'GL_EXT_packed_pixels');
- GL_EXT_paletted_texture := Int_CheckExtension(Buffer, 'GL_EXT_paletted_texture');
- GL_EXT_pixel_transform := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform');
- GL_EXT_pixel_transform_color_table := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform_color_table');
- GL_EXT_point_parameters := Int_CheckExtension(Buffer, 'GL_EXT_point_parameters');
- GL_EXT_polygon_offset := Int_CheckExtension(Buffer, 'GL_EXT_polygon_offset');
- GL_EXT_rescale_normal := Int_CheckExtension(Buffer, 'GL_EXT_rescale_normal');
- GL_EXT_secondary_color := Int_CheckExtension(Buffer, 'GL_EXT_secondary_color');
- GL_EXT_separate_specular_color := Int_CheckExtension(Buffer, 'GL_EXT_separate_specular_color');
- GL_EXT_shadow_funcs := Int_CheckExtension(Buffer, 'GL_EXT_shadow_funcs');
- GL_EXT_shared_texture_palette := Int_CheckExtension(Buffer, 'GL_EXT_shared_texture_palette');
- GL_EXT_stencil_two_side := Int_CheckExtension(Buffer, 'GL_EXT_stencil_two_side');
- GL_EXT_stencil_wrap := Int_CheckExtension(Buffer, 'GL_EXT_stencil_wrap');
- GL_EXT_subtexture := Int_CheckExtension(Buffer, 'GL_EXT_subtexture');
- GL_EXT_texture := Int_CheckExtension(Buffer, 'GL_EXT_texture');
- GL_EXT_texture3D := Int_CheckExtension(Buffer, 'GL_EXT_texture3D');
- GL_EXT_texture_compression_s3tc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_s3tc');
- GL_EXT_texture_cube_map := Int_CheckExtension(Buffer, 'GL_EXT_texture_cube_map');
- GL_EXT_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_edge_clamp');
- GL_EXT_texture_env_add := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_add');
- GL_EXT_texture_env_combine := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_combine');
- GL_EXT_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_dot3');
- GL_EXT_texture_filter_anisotropic := Int_CheckExtension(Buffer, 'GL_EXT_texture_filter_anisotropic');
- GL_EXT_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_EXT_texture_lod_bias');
- GL_EXT_texture_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_object');
- GL_EXT_texture_perturb_normal := Int_CheckExtension(Buffer, 'GL_EXT_texture_perturb_normal');
- GL_EXT_texture_rectangle := Int_CheckExtension(Buffer, 'GL_EXT_texture_rectangle');
- GL_EXT_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array');
- GL_EXT_vertex_shader := Int_CheckExtension(Buffer, 'GL_EXT_vertex_shader');
- GL_EXT_vertex_weighting := Int_CheckExtension(Buffer, 'GL_EXT_vertex_weighting');
- GL_EXT_depth_bounds_test := Int_CheckExtension(Buffer, 'GL_EXT_depth_bounds_test');
- GL_EXT_texture_mirror_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_mirror_clamp');
- GL_EXT_blend_equation_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_equation_separate');
- GL_EXT_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_pixel_buffer_object');
- GL_EXT_texture_compression_dxt1 := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_dxt1');
- GL_EXT_stencil_clear_tag := Int_CheckExtension(Buffer, 'GL_EXT_stencil_clear_tag');
- GL_EXT_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_EXT_packed_depth_stencil');
- GL_EXT_texture_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB');
- GL_EXT_framebuffer_blit := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_blit');
- GL_EXT_framebuffer_multisample := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_multisample');
- GL_EXT_timer_query := Int_CheckExtension(Buffer, 'GL_EXT_timer_query');
- GL_EXT_gpu_program_parameters := Int_CheckExtension(Buffer, 'GL_EXT_gpu_program_parameters');
- GL_EXT_bindable_uniform := Int_CheckExtension(Buffer, 'GL_EXT_bindable_uniform');
- GL_EXT_draw_buffers2 := Int_CheckExtension(Buffer, 'GL_EXT_draw_buffers2');
- GL_EXT_draw_instanced := Int_CheckExtension(Buffer, 'GL_EXT_draw_instanced');
- GL_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_sRGB');
- GL_EXT_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_geometry_shader4');
- GL_EXT_gpu_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_gpu_shader4');
- GL_EXT_packed_float := Int_CheckExtension(Buffer, 'GL_EXT_packed_float');
- GL_EXT_texture_array := Int_CheckExtension(Buffer, 'GL_EXT_texture_array');
- GL_EXT_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_buffer_object');
- GL_EXT_texture_compression_latc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_latc');
- GL_EXT_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_rgtc');
- GL_EXT_texture_integer := Int_CheckExtension(Buffer, 'GL_EXT_texture_integer');
- GL_EXT_texture_shared_exponent := Int_CheckExtension(Buffer, 'GL_EXT_texture_shared_exponent');
- GL_EXT_transform_feedback := Int_CheckExtension(Buffer, 'GL_EXT_transform_feedback');
- GL_EXT_direct_state_access := Int_CheckExtension(Buffer, 'GL_EXT_direct_state_access');
- GL_EXT_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array_bgra');
- GL_EXT_texture_swizzle := Int_CheckExtension(Buffer, 'GL_EXT_texture_swizzle');
- GL_EXT_provoking_vertex := Int_CheckExtension(Buffer, 'GL_EXT_provoking_vertex');
- GL_EXT_texture_snorm := Int_CheckExtension(Buffer, 'GL_EXT_texture_snorm');
- GL_EXT_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_EXT_separate_shader_objects');
- GL_EXT_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_EXT_shader_image_load_store');
- GL_EXT_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_EXT_vertex_attrib_64bit');
- GL_EXT_texture_sRGB_decode := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB_decode');
-
- // === HP ======================================================================
- GL_HP_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_HP_convolution_border_modes');
- GL_HP_image_transform := Int_CheckExtension(Buffer, 'GL_HP_image_transform');
- GL_HP_occlusion_test := Int_CheckExtension(Buffer, 'GL_HP_occlusion_test');
- GL_HP_texture_lighting := Int_CheckExtension(Buffer, 'GL_HP_texture_lighting');
-
- // === IBM =====================================================================
- GL_IBM_cull_vertex := Int_CheckExtension(Buffer, 'GL_IBM_cull_vertex');
- GL_IBM_multimode_draw_arrays := Int_CheckExtension(Buffer, 'GL_IBM_multimode_draw_arrays');
- GL_IBM_rasterpos_clip := Int_CheckExtension(Buffer, 'GL_IBM_rasterpos_clip');
- GL_IBM_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_IBM_texture_mirrored_repeat');
- GL_IBM_vertex_array_lists := Int_CheckExtension(Buffer, 'GL_IBM_vertex_array_lists');
-
- // === INGR ====================================================================
- GL_INGR_blend_func_separate := Int_CheckExtension(Buffer, 'GL_INGR_blend_func_separate');
- GL_INGR_color_clamp := Int_CheckExtension(Buffer, 'GL_INGR_color_clamp');
- GL_INGR_interlace_read := Int_CheckExtension(Buffer, 'GL_INGR_interlace_read');
- GL_INGR_palette_buffer := Int_CheckExtension(Buffer, 'GL_INGR_palette_buffer');
-
- // === INTEL ===================================================================
- GL_INTEL_parallel_arrays := Int_CheckExtension(Buffer, 'GL_INTEL_parallel_arrays');
- GL_INTEL_texture_scissor := Int_CheckExtension(Buffer, 'GL_INTEL_texture_scissor');
-
- // === MESA ====================================================================
- GL_MESA_resize_buffers := Int_CheckExtension(Buffer, 'GL_MESA_resize_buffers');
- GL_MESA_window_pos := Int_CheckExtension(Buffer, 'GL_MESA_window_pos');
-
- // === NVIDIA ==================================================================
- GL_NV_blend_square := Int_CheckExtension(Buffer, 'GL_NV_blend_square');
- GL_NV_copy_depth_to_color := Int_CheckExtension(Buffer, 'GL_NV_copy_depth_to_color');
- GL_NV_depth_clamp := Int_CheckExtension(Buffer, 'GL_NV_depth_clamp');
- GL_NV_evaluators := Int_CheckExtension(Buffer, 'GL_NV_evaluators');
- GL_NV_fence := Int_CheckExtension(Buffer, 'GL_NV_fence');
- GL_NV_float_buffer := Int_CheckExtension(Buffer, 'GL_NV_float_buffer');
- GL_NV_fog_distance := Int_CheckExtension(Buffer, 'GL_NV_fog_distance');
- GL_NV_fragment_program := Int_CheckExtension(Buffer, 'GL_NV_fragment_program');
- GL_NV_half_float := Int_CheckExtension(Buffer, 'GL_NV_half_float');
- GL_NV_light_max_exponent := Int_CheckExtension(Buffer, 'GL_NV_light_max_exponent');
- GL_NV_multisample_filter_hint := Int_CheckExtension(Buffer, 'GL_NV_multisample_filter_hint');
- GL_NV_occlusion_query := Int_CheckExtension(Buffer, 'GL_NV_occlusion_query');
- GL_NV_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_NV_packed_depth_stencil');
- GL_NV_pixel_data_range := Int_CheckExtension(Buffer, 'GL_NV_pixel_data_range');
- GL_NV_point_sprite := Int_CheckExtension(Buffer, 'GL_NV_point_sprite');
- GL_NV_primitive_restart := Int_CheckExtension(Buffer, 'GL_NV_primitive_restart');
- GL_NV_register_combiners := Int_CheckExtension(Buffer, 'GL_NV_register_combiners');
- GL_NV_register_combiners2 := Int_CheckExtension(Buffer, 'GL_NV_register_combiners2');
- GL_NV_texgen_emboss := Int_CheckExtension(Buffer, 'GL_NV_texgen_emboss');
- GL_NV_texgen_reflection := Int_CheckExtension(Buffer, 'GL_NV_texgen_reflection');
- GL_NV_texture_compression_vtc := Int_CheckExtension(Buffer, 'GL_NV_texture_compression_vtc');
- GL_NV_texture_env_combine4 := Int_CheckExtension(Buffer, 'GL_NV_texture_env_combine4');
- GL_NV_texture_expand_normal := Int_CheckExtension(Buffer, 'GL_NV_texture_expand_normal');
- GL_NV_texture_rectangle := Int_CheckExtension(Buffer, 'GL_NV_texture_rectangle');
- GL_NV_texture_shader := Int_CheckExtension(Buffer, 'GL_NV_texture_shader');
- GL_NV_texture_shader2 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader2');
- GL_NV_texture_shader3 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader3');
- GL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range');
- GL_NV_vertex_array_range2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range2');
- GL_NV_vertex_program := Int_CheckExtension(Buffer, 'GL_NV_vertex_program');
- GL_NV_vertex_program1_1 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program1_1');
- GL_NV_vertex_program2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2');
- GL_NV_fragment_program_option := Int_CheckExtension(Buffer, 'GL_NV_fragment_program_option');
- GL_NV_fragment_program2 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program2');
- GL_NV_vertex_program2_option := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2_option');
- GL_NV_vertex_program3 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program3');
- GL_NV_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_NV_depth_buffer_float');
- GL_NV_fragment_program4 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program4');
- GL_NV_framebuffer_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_framebuffer_multisample_coverage');
- GL_NV_geometry_program4 := Int_CheckExtension(Buffer, 'GL_NV_geometry_program4');
- GL_NV_gpu_program4 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program4');
- GL_NV_parameter_buffer_object := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object');
- GL_NV_transform_feedback := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback');
- GL_NV_vertex_program4 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program4');
- GL_NV_conditional_render := Int_CheckExtension(Buffer, 'GL_NV_conditional_render');
- GL_NV_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video');
- GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample');
- GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2');
- GL_NV_video_capture := Int_CheckExtension(Buffer, 'GL_NV_video_capture');
- GL_NV_copy_image := Int_CheckExtension(Buffer, 'GL_NV_copy_image');
- GL_NV_parameter_buffer_object2 := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object2');
- GL_NV_shader_buffer_load := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_load');
- GL_NV_vertex_buffer_unified_memory := Int_CheckExtension(Buffer, 'GL_NV_vertex_buffer_unified_memory');
- GL_NV_gpu_program5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program5');
- GL_NV_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_shader5');
- GL_NV_shader_buffer_store := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_store');
- GL_NV_tessellation_program5 := Int_CheckExtension(Buffer, 'GL_NV_tessellation_program5');
- GL_NV_vertex_attrib_integer_64bit := Int_CheckExtension(Buffer, 'GL_NV_vertex_attrib_integer_64bit');
- GL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_multisample_coverage');
- GL_NV_vdpau_interop := Int_CheckExtension(Buffer, 'GL_NV_vdpau_interop');
- GL_NV_texture_barrier := Int_CheckExtension(Buffer, 'GL_NV_texture_barrier');
- // 4.3
- GL_NV_path_rendering := Int_CheckExtension(Buffer, 'GL_NV_path_rendering');
- GL_NV_bindless_texture := Int_CheckExtension(Buffer, 'GL_NV_bindless_texture');
- GL_NV_shader_atomic_float := Int_CheckExtension(Buffer, 'GL_NV_shader_atomic_float');
-
- // === OML =====================================================================
- GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace');
- GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample');
- GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample');
-
- // === PGI =====================================================================
- GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints');
- GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints');
-
- // === REND ====================================================================
- GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates');
-
- // === S3 ======================================================================
- GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc');
-
- // === SGIS ====================================================================
- GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture');
- GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function');
- GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap');
- GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample');
- GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture');
- GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen');
- GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters');
- GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture');
- GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D');
- GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp');
- GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask');
- GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp');
- GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4');
- GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod');
- GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select');
-
- // === SGIX ====================================================================
- GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX');
- GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async');
- GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram');
- GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel');
- GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax');
- GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment');
- GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap');
- GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy');
- GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument');
- GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture');
- GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster');
- GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset');
- GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale');
- GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting');
- GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom');
- GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface');
- GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture');
- GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments');
- GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace');
- GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1');
- GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority');
- GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture');
- GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles');
- GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd');
- GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane');
- GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample');
- GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint');
- GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow');
- GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient');
- GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite');
- GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample');
- GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer');
- GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env');
- GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp');
- GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias');
- GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer');
- GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias');
- GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select');
- GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip');
- GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb');
- GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample');
- GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba');
-
- // === SGI =====================================================================
- GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix');
- GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table');
- GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument');
- GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table');
-
- // === SUN =====================================================================
- GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data');
- GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes');
- GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha');
- GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array');
- GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum');
- GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list');
- GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex');
-
- // === WIN =====================================================================
- GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading');
- GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog');
-
- {$IFDEF DGL_WIN}
- // === WGL =====================================================================
- WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample');
- WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region');
- WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string');
- WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read');
- WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample');
- WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer');
- WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format');
- WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float');
- WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture');
- WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context');
- WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile');
- WGL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'WGL_ARB_framebuffer_sRGB');
- WGL_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_robustness');
- WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float');
- WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association');
- WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float');
- WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table');
- WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string');
- WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read');
- WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample');
- WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer');
- WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format');
- WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control');
- WGL_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'WGL_EXT_create_context_es2_profile');
- WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control');
- WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma');
- WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock');
- WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer');
- WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock');
- WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage');
- WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer');
- WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture');
- WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle');
- WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range');
- WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video');
- WGL_NV_video_output := Int_CheckExtension(Buffer, 'WGL_NV_video_output');
- WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group');
- WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity');
- WGL_NV_video_capture := Int_CheckExtension(Buffer, 'WGL_NV_video_capture');
- WGL_NV_copy_image := Int_CheckExtension(Buffer, 'WGL_NV_copy_image');
- WGL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
- WGL_NV_DX_interop := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
- WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control');
- WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control');
-
- WIN_draw_range_elements := Int_CheckExtension(Buffer, 'WIN_draw_range_elements');
- WIN_swap_hint := Int_CheckExtension(Buffer, 'WIN_swap_hint');
- {$ENDIF}
-
- {$IFDEF DGL_LINUX}
- // === GLX =====================================================================
- GLX_ARB_multisample := Int_CheckExtension(Buffer, 'GLX_ARB_multisample');
- GLX_ARB_fbconfig_float := Int_CheckExtension(Buffer, 'GLX_ARB_fbconfig_float');
- GLX_ARB_get_proc_address := Int_CheckExtension(Buffer, 'GLX_ARB_get_proc_address');
- GLX_ARB_create_context := Int_CheckExtension(Buffer, 'GLX_ARB_create_context');
- GLX_ARB_create_context_profile := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_profile');
- GLX_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GLX_ARB_vertex_buffer_object');
- GLX_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_ARB_framebuffer_sRGB');
- GLX_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_robustness');
- GLX_EXT_visual_info := Int_CheckExtension(Buffer, 'GLX_EXT_visual_info');
- GLX_EXT_visual_rating := Int_CheckExtension(Buffer, 'GLX_EXT_visual_rating');
- GLX_EXT_import_context := Int_CheckExtension(Buffer, 'GLX_EXT_import_context');
- GLX_EXT_fbconfig_packed_float := Int_CheckExtension(Buffer, 'GLX_EXT_fbconfig_packed_float');
- GLX_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_EXT_framebuffer_sRGB');
- GLX_EXT_texture_from_pixmap := Int_CheckExtension(Buffer, 'GLX_EXT_texture_from_pixmap');
- GLX_EXT_swap_control := Int_CheckExtension(Buffer, 'GLX_EXT_swap_control');
- GLX_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'GLX_EXT_create_context_es2_profile');
- {$ENDIF}
- ImplementationRead := True;
-end;
-
-{$IFDEF DGL_WIN}
-// =============================================================================
-// RaiseLastOSError
-// =============================================================================
-// Needed for compatibility with older Delphiversions
-// =============================================================================
-
-procedure RaiseLastOSError;
-begin
-{$IFDEF FPC}
- raise Exception.Create('RaiseLastOSError!'); // To-Do: find a better solution
-{$ELSE}
- {$IFDEF DELPHI6_AND_DOWN} // If Delphi 6 or later
- SysUtils.RaiseLastWin32Error;
- {$ELSE}
- SysUtils.RaiseLastOSError;
- {$ENDIF}
-{$ENDIF}
-end;
-
-// =============================================================================
-// CreateRenderingContext
-// =============================================================================
-
-function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
-const
- OBJ_MEMDC = 10;
- OBJ_ENHMETADC = 12;
- OBJ_METADC = 4;
- PFD_DOUBLEBUFFER = $00000001;
- PFD_STEREO = $00000002;
- PFD_DRAW_TO_WINDOW = $00000004;
- PFD_DRAW_TO_BITMAP = $00000008;
- PFD_SUPPORT_GDI = $00000010;
- PFD_SUPPORT_OPENGL = $00000020;
- PFD_TYPE_RGBA = 0;
- PFD_MAIN_PLANE = 0;
- PFD_OVERLAY_PLANE = 1;
- PFD_UNDERLAY_PLANE = LongWord(-1);
- MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
-var
- PFDescriptor: TPixelFormatDescriptor;
- PixelFormat: Integer;
- AType: DWORD;
-begin
- if GL_LibHandle = nil then
- InitOpenGL;
-
- FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0);
-
- with PFDescriptor do
- begin
- nSize := SizeOf(PFDescriptor);
- nVersion := 1;
- dwFlags := PFD_SUPPORT_OPENGL;
-
- AType := GetObjectType(DC);
-
- if AType = 0 then
- RaiseLastOSError;
-
- if AType in MemoryDCs then
- dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
- else
- dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
-
- if opDoubleBuffered in Options then
- dwFlags := dwFlags or PFD_DOUBLEBUFFER;
-
- if opGDI in Options then
- dwFlags := dwFlags or PFD_SUPPORT_GDI;
-
- if opStereo in Options then
- dwFlags := dwFlags or PFD_STEREO;
-
- iPixelType := PFD_TYPE_RGBA;
- cColorBits := ColorBits;
- cDepthBits := zBits;
- cStencilBits := StencilBits;
- cAccumBits := AccumBits;
- cAuxBuffers := AuxBuffers;
-
- if Layer = 0 then
- iLayerType := PFD_MAIN_PLANE
- else
- if Layer > 0 then
- iLayerType := PFD_OVERLAY_PLANE
- else
- iLayerType := Byte(PFD_UNDERLAY_PLANE);
- end;
-
- PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
-
- if PixelFormat = 0 then
- RaiseLastOSError;
-
- if GetPixelFormat(DC) <> PixelFormat then
- if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
- RaiseLastOSError;
-
- DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
-
- Result := wglCreateContext(DC);
-
- if Result = 0 then
- RaiseLastOSError
- else
- LastPixelFormat := 0;
-end;
-
-// =============================================================================
-// CreateRenderingContextVersion
-// =============================================================================
-// Creates a context for the more recent OpenGL versions (3.0) and up
-// For that we first need to get a normal GL context for getting the
-// function pointer to wglCreateContextAttribsARB first
-// =============================================================================
-function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
-const
- OBJ_MEMDC = 10;
- OBJ_ENHMETADC = 12;
- OBJ_METADC = 4;
- PFD_DOUBLEBUFFER = $00000001;
- PFD_STEREO = $00000002;
- PFD_DRAW_TO_WINDOW = $00000004;
- PFD_DRAW_TO_BITMAP = $00000008;
- PFD_SUPPORT_GDI = $00000010;
- PFD_SUPPORT_OPENGL = $00000020;
- PFD_TYPE_RGBA = 0;
- PFD_MAIN_PLANE = 0;
- PFD_OVERLAY_PLANE = 1;
- PFD_UNDERLAY_PLANE = LongWord(-1);
- MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
-var
- PFDescriptor : TPixelFormatDescriptor;
- PixelFormat : Integer;
- AType : DWORD;
- LegacyRC : HGLRC;
- Attribs : array of Integer;
-begin
- if GL_LibHandle = nil then
- InitOpenGL;
-
- if not Assigned(GL_LibHandle) then
- raise Exception.Create('GL_LibHandle is NIL. Could not load OpenGL library!');
-
- FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0);
-
- with PFDescriptor do
- begin
- nSize := SizeOf(PFDescriptor);
- nVersion := 1;
- dwFlags := PFD_SUPPORT_OPENGL;
- AType := GetObjectType(DC);
-
- if AType = 0 then
- RaiseLastOSError;
-
- if AType in MemoryDCs then
- dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
- else
- dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
-
- if opDoubleBuffered in Options then
- dwFlags := dwFlags or PFD_DOUBLEBUFFER;
-
- if opGDI in Options then
- dwFlags := dwFlags or PFD_SUPPORT_GDI;
-
- if opStereo in Options then
- dwFlags := dwFlags or PFD_STEREO;
-
- iPixelType := PFD_TYPE_RGBA;
- cColorBits := ColorBits;
- cDepthBits := zBits;
- cStencilBits := StencilBits;
- cAccumBits := AccumBits;
- cAuxBuffers := AuxBuffers;
-
- if Layer = 0 then
- iLayerType := PFD_MAIN_PLANE
- else
- if Layer > 0 then
- iLayerType := PFD_OVERLAY_PLANE
- else
- iLayerType := Byte(PFD_UNDERLAY_PLANE);
- end;
-
- PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
-
- if PixelFormat = 0 then
- RaiseLastOSError;
-
- if GetPixelFormat(DC) <> PixelFormat then
- if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
- RaiseLastOSError;
-
- DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
-
- // Create legacy render context first for we need function pointers to
- // create new OpenGL render contexts
- LegacyRC := wglCreateContext(DC);
- wglMakeCurrent(DC, LegacyRC);
-
- // Set attributes to describe our requested context
- SetLength(Attribs, 5);
- Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;
- Attribs[1] := MajorVersion;
- Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;
- Attribs[3] := MinorVersion;
-
- // Add context flag for forward compatible context
- // Forward compatible means no more support for legacy functions like
- // immediate mode (glvertex, glrotate, gltranslate, etc.)
- if ForwardCompatible then
- begin
- SetLength(Attribs, Length(Attribs)+2);
- Attribs[4] := WGL_CONTEXT_FLAGS_ARB;
- Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
- end;
-
- // Attribute flags must be finalized with a zero
- Attribs[High(Attribs)] := 0;
-
- // Get function pointer for new context creation function
- wglCreateContextAttribsARB := wglGetProcAddress('wglCreateContextAttribsARB');
-
- if not Assigned(wglCreateContextAttribsARB) then
- begin
- raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!');
- wglDeleteContext(LegacyRC);
- exit;
- end;
-
- // Create context
- Result := wglCreateContextAttribsARB(DC, 0, @Attribs[0]);
-
- if Result = 0 then
- begin
- raise Exception.Create('Could not create the desired OpenGL rendering context!');
- wglDeleteContext(LegacyRC);
- exit;
- end;
-
- wglDeleteContext(LegacyRC);
-
- if Result = 0 then
- RaiseLastOSError
- else
- LastPixelFormat := 0;
-end;
-
-// =============================================================================
-// DestroyRenderingContext
-// =============================================================================
-
-procedure DestroyRenderingContext(RC: HGLRC);
-begin
- wglDeleteContext(RC);
-end;
-
-
-// =============================================================================
-// ActivateRenderingContext
-// =============================================================================
-
-procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
-begin
- Assert((DC <> 0), 'DC must not be 0');
- Assert((RC <> 0), 'RC must not be 0');
-
- wglMakeCurrent(DC, RC);
-
- {$ifdef DGL_TINY_HEADER}
- ReadCoreVersion;
- {$else}
- ReadImplementationProperties;
-
- if (loadext) then
- ReadExtensions;
- {$endif}
-end;
-
-// =============================================================================
-// DeactivateRenderingContext
-// =============================================================================
-
-procedure DeactivateRenderingContext;
-begin
- wglMakeCurrent(0, 0);
-end;
-{$ENDIF}
-
-
-initialization
-
-{$IFDEF CPU386}
- Set8087CW($133F);
-{$ENDIF}
-
-finalization
-
-end.
+++ /dev/null
-{ this is the default configuration file of the glBitmap.pas
- please uncomment you preferences below, rename this file to glBitmapConf.inc
- and make it available to your compilers include paths }
-
-
-// enable support for OpenGL ES 1.1
-{.$DEFINE OPENGL_ES_1_1}
-
-// enable support for OpenGL ES 2.0
-{.$DEFINE OPENGL_ES_2_0}
-
-// enable support for OpenGL ES 3.0
-{.$DEFINE OPENGL_ES_3_0}
-
-// enable support for all OpenGL ES extensions
-{.$DEFINE OPENGL_ES_EXT}
-
-
-
-// activate to enable the support for SDL_surfaces
-{.$DEFINE GLB_SDL}
-
-// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
-{.$DEFINE GLB_DELPHI}
-
-// activate to enable the support for TLazIntfImage from Lazarus
-{.$DEFINE GLB_LAZARUS}
-
-
-
-// activate to enable the support of SDL_image to load files. (READ ONLY)
-// If you enable SDL_image all other libraries will be ignored!
-{.$DEFINE GLB_SDL_IMAGE}
-
-
-
-// activate to enable Lazarus TPortableNetworkGraphic support
-// if you enable this pngImage and libPNG will be ignored
-{.$DEFINE GLB_LAZ_PNG}
-
-// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
-// if you enable pngimage the libPNG will be ignored
-{.$DEFINE GLB_PNGIMAGE}
-
-// activate to use the libPNG -> http://www.libpng.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
-{.$DEFINE GLB_LIB_PNG}
-
-
-
-// activate to enable Lazarus TJPEGImage support
-// if you enable this delphi jpegs and libJPEG will be ignored
-{.$DEFINE GLB_LAZ_JPEG}
-
-// if you enable delphi jpegs the libJPEG will be ignored
-{.$DEFINE GLB_DELPHI_JPEG}
-
-// activate to use the libJPEG -> http://www.ijg.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
-{.$DEFINE GLB_LIB_JPEG}
-
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+ <ProjectOptions>
+ <Version Value="9"/>
+ <PathDelim Value="\"/>
+ <General>
+ <SessionStorage Value="InProjectDir"/>
+ <MainUnit Value="0"/>
+ <Title Value="project1"/>
+ <ResourceType Value="res"/>
+ <UseXPManifest Value="True"/>
+ </General>
+ <i18n>
+ <EnableI18N LFM="False"/>
+ </i18n>
+ <VersionInfo>
+ <StringTable ProductVersion=""/>
+ </VersionInfo>
+ <BuildModes Count="1">
+ <Item1 Name="Default" Default="True"/>
+ </BuildModes>
+ <PublishOptions>
+ <Version Value="2"/>
+ </PublishOptions>
+ <RunParams>
+ <local>
+ <FormatVersion Value="1"/>
+ </local>
+ </RunParams>
+ <RequiredPackages Count="1">
+ <Item1>
+ <PackageName Value="LCL"/>
+ </Item1>
+ </RequiredPackages>
+ <Units Count="2">
+ <Unit0>
+ <Filename Value="project1.lpr"/>
+ <IsPartOfProject Value="True"/>
+ </Unit0>
+ <Unit1>
+ <Filename Value="uMainForm.pas"/>
+ <IsPartOfProject Value="True"/>
+ <ComponentName Value="MainForm"/>
+ <HasResources Value="True"/>
+ <ResourceBaseClass Value="Form"/>
+ <UnitName Value="uMainForm"/>
+ </Unit1>
+ </Units>
+ </ProjectOptions>
+ <CompilerOptions>
+ <Version Value="11"/>
+ <PathDelim Value="\"/>
+ <Target>
+ <Filename Value="project1"/>
+ </Target>
+ <SearchPaths>
+ <IncludeFiles Value="$(ProjOutDir);..\.."/>
+ <OtherUnitFiles Value="..\.."/>
+ <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
+ </SearchPaths>
+ <Linking>
+ <Options>
+ <Win32>
+ <GraphicApplication Value="True"/>
+ </Win32>
+ </Options>
+ </Linking>
+ </CompilerOptions>
+ <Debugging>
+ <Exceptions Count="3">
+ <Item1>
+ <Name Value="EAbort"/>
+ </Item1>
+ <Item2>
+ <Name Value="ECodetoolError"/>
+ </Item2>
+ <Item3>
+ <Name Value="EFOpenError"/>
+ </Item3>
+ </Exceptions>
+ </Debugging>
+</CONFIG>
--- /dev/null
+program project1;
+
+{$mode objfpc}{$H+}
+
+uses
+ {$IFDEF UNIX}{$IFDEF UseCThreads}
+ cthreads,
+ {$ENDIF}{$ENDIF}
+ Interfaces, // this includes the LCL widgetset
+ Forms, uMainForm
+ { you can add units after this };
+
+{$R *.res}
+
+begin
+ RequireDerivedFormResource := True;
+ Application.Initialize;
+ Application.CreateForm(TMainForm, MainForm);
+ Application.Run;
+end.
+
--- /dev/null
+/* ShaderObject: GL_VERTEX_SHADER */
+#version 330
+uniform mat4 uModelViewProjMat;
+layout(location = 0) in vec3 inPos;
+
+void main(void)
+{
+ gl_Position = vec4(inPos, 1.0);
+}
+
+/* ShaderObject: GL_FRAGMENT_SHADER */
+#version 330
+
+out vec4 outColor; // ausgegebene Farbe
+
+void main(void)
+{
+ outColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
\ No newline at end of file
--- /dev/null
+object MainForm: TMainForm
+ Left = 465
+ Height = 451
+ Top = 217
+ Width = 411
+ Caption = 'MainForm'
+ ClientHeight = 451
+ ClientWidth = 411
+ OnCreate = FormCreate
+ OnDestroy = FormDestroy
+ LCLVersion = '1.3'
+ object RenderPanel: TPanel
+ Left = 0
+ Height = 371
+ Top = 0
+ Width = 411
+ Align = alClient
+ TabOrder = 0
+ OnResize = RenderPanelResize
+ end
+ object LogLB: TListBox
+ Left = 0
+ Height = 80
+ Top = 371
+ Width = 411
+ Align = alBottom
+ ItemHeight = 0
+ TabOrder = 1
+ end
+ object ApplicationProperties: TApplicationProperties
+ OnIdle = ApplicationPropertiesIdle
+ left = 64
+ top = 24
+ end
+end
--- /dev/null
+unit uMainForm;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
+ uglcContext, uglcShader, uglcArrayBuffer, uglcTypes;
+
+type
+ TMainForm = class(TForm)
+ ApplicationProperties: TApplicationProperties;
+ LogLB: TListBox;
+ RenderPanel: TPanel;
+ procedure ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+ procedure FormCreate(Sender: TObject);
+ procedure FormDestroy(Sender: TObject);
+ procedure RenderPanelResize(Sender: TObject);
+ private
+ fContext: TglcContext;
+ fShader: TglcShaderProgram;
+ fVBO: TglcArrayBuffer;
+ procedure Log(aSender: TObject; const aMsg: String);
+ procedure Render;
+ public
+ { public declarations }
+ end;
+
+var
+ MainForm: TMainForm;
+
+implementation
+
+{$R *.lfm}
+
+uses
+ dglOpenGL, ugluVector;
+
+const
+ SHADER_FILE = 'shader.glsl';
+
+ LAYOUT_LOCATION_POS = 0;
+
+procedure TMainForm.FormCreate(Sender: TObject);
+type
+ TVertex = packed record
+ pos: TgluVector3f;
+ end;
+ PVertex = ^TVertex;
+var
+ pf: TglcContextPixelFormatSettings;
+ p: PVertex;
+begin
+ pf := TglcContext.MakePF();
+ fContext := TglcContext.GetPlatformClass.Create(RenderPanel, pf);
+ fContext.BuildContext;
+
+ fShader := TglcShaderProgram.Create(@Log);
+ fShader.LoadFromFile(ExtractFilePath(Application.ExeName) + SHADER_FILE);
+ fShader.Compile;
+
+ fVBO := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
+ fVBO.BufferData(4, sizeof(TVertex), TglcBufferUsage.buStaticDraw, nil);
+ p := fVBO.MapBuffer(TglcBufferAccess.baWriteOnly);
+ try
+ p^.pos := gluVector3f(-0.5, -0.5, 0); inc(p);
+ p^.pos := gluVector3f( 0.5, -0.5, 0); inc(p);
+ p^.pos := gluVector3f( 0.5, 0.5, 0); inc(p);
+ p^.pos := gluVector3f(-0.5, 0.5, 0); inc(p);
+ finally
+ fVBO.UnmapBuffer;
+ end;
+end;
+
+procedure TMainForm.ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+begin
+ Render;
+ Done := false;
+end;
+
+procedure TMainForm.FormDestroy(Sender: TObject);
+begin
+ FreeAndNil(fVBO);
+ FreeAndNil(fShader);
+ FreeAndNil(fContext);
+end;
+
+procedure TMainForm.RenderPanelResize(Sender: TObject);
+begin
+ if Assigned(fContext) then begin
+ glViewport(0, 0, RenderPanel.ClientWidth, RenderPanel.ClientHeight);
+ end;
+end;
+
+procedure TMainForm.Log(aSender: TObject; const aMsg: String);
+begin
+ LogLB.Items.Add(aMsg);
+end;
+
+procedure TMainForm.Render;
+begin
+ glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
+
+ fVBO.Bind;
+ fShader.Enable;
+
+ glEnableVertexAttribArray(LAYOUT_LOCATION_POS);
+ glVertexAttribPointer(LAYOUT_LOCATION_POS, 3, GL_FLOAT, False, 0, nil);
+
+ glDrawArrays(GL_QUADS, 0, fVBO.DataCount);
+
+ glDisableVertexAttribArray(LAYOUT_LOCATION_POS);
+
+ fShader.Disable;
+ fVBO.Unbind;
+
+ fContext.SwapBuffers;
+end;
+
+end.
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+ <ProjectOptions>
+ <Version Value="9"/>
+ <PathDelim Value="\"/>
+ <General>
+ <SessionStorage Value="InProjectDir"/>
+ <MainUnit Value="0"/>
+ <Title Value="project1"/>
+ <ResourceType Value="res"/>
+ <UseXPManifest Value="True"/>
+ </General>
+ <i18n>
+ <EnableI18N LFM="False"/>
+ </i18n>
+ <VersionInfo>
+ <StringTable ProductVersion=""/>
+ </VersionInfo>
+ <BuildModes Count="1">
+ <Item1 Name="Default" Default="True"/>
+ </BuildModes>
+ <PublishOptions>
+ <Version Value="2"/>
+ </PublishOptions>
+ <RunParams>
+ <local>
+ <FormatVersion Value="1"/>
+ </local>
+ </RunParams>
+ <RequiredPackages Count="1">
+ <Item1>
+ <PackageName Value="LCL"/>
+ </Item1>
+ </RequiredPackages>
+ <Units Count="2">
+ <Unit0>
+ <Filename Value="project1.lpr"/>
+ <IsPartOfProject Value="True"/>
+ </Unit0>
+ <Unit1>
+ <Filename Value="uMainForm.pas"/>
+ <IsPartOfProject Value="True"/>
+ <ComponentName Value="MainForm"/>
+ <HasResources Value="True"/>
+ <ResourceBaseClass Value="Form"/>
+ <UnitName Value="uMainForm"/>
+ </Unit1>
+ </Units>
+ </ProjectOptions>
+ <CompilerOptions>
+ <Version Value="11"/>
+ <PathDelim Value="\"/>
+ <Target>
+ <Filename Value="project1"/>
+ </Target>
+ <SearchPaths>
+ <IncludeFiles Value="$(ProjOutDir);..\.."/>
+ <OtherUnitFiles Value="..\.."/>
+ <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
+ </SearchPaths>
+ <Linking>
+ <Options>
+ <Win32>
+ <GraphicApplication Value="True"/>
+ </Win32>
+ </Options>
+ </Linking>
+ </CompilerOptions>
+ <Debugging>
+ <Exceptions Count="3">
+ <Item1>
+ <Name Value="EAbort"/>
+ </Item1>
+ <Item2>
+ <Name Value="ECodetoolError"/>
+ </Item2>
+ <Item3>
+ <Name Value="EFOpenError"/>
+ </Item3>
+ </Exceptions>
+ </Debugging>
+</CONFIG>
--- /dev/null
+program project1;
+
+{$mode objfpc}{$H+}
+
+uses
+ {$IFDEF UNIX}{$IFDEF UseCThreads}
+ cthreads,
+ {$ENDIF}{$ENDIF}
+ Interfaces, // this includes the LCL widgetset
+ Forms, uMainForm
+ { you can add units after this };
+
+{$R *.res}
+
+begin
+ RequireDerivedFormResource := True;
+ Application.Initialize;
+ Application.CreateForm(TMainForm, MainForm);
+ Application.Run;
+end.
+
--- /dev/null
+/* ShaderObject: GL_VERTEX_SHADER */
+#version 330
+uniform mat4 uModelViewProjMat;
+layout(location = 0) in vec3 inPos;
+layout(location = 1) in vec2 inTexCoord;
+out vec2 vTexCoord;
+
+void main(void)
+{
+ gl_Position = vec4(inPos, 1.0);
+ vTexCoord = inTexCoord;
+}
+
+/* ShaderObject: GL_FRAGMENT_SHADER */
+#version 330
+uniform sampler2D uTexture;
+in vec2 vTexCoord;
+out vec4 outColor;
+
+void main(void)
+{
+ outColor = texture(uTexture, vTexCoord);
+}
\ No newline at end of file
--- /dev/null
+object MainForm: TMainForm
+ Left = 465
+ Height = 451
+ Top = 217
+ Width = 411
+ Caption = 'MainForm'
+ ClientHeight = 451
+ ClientWidth = 411
+ OnCreate = FormCreate
+ OnDestroy = FormDestroy
+ LCLVersion = '1.3'
+ object RenderPanel: TPanel
+ Left = 0
+ Height = 371
+ Top = 0
+ Width = 411
+ Align = alClient
+ TabOrder = 0
+ OnResize = RenderPanelResize
+ end
+ object LogLB: TListBox
+ Left = 0
+ Height = 80
+ Top = 371
+ Width = 411
+ Align = alBottom
+ ItemHeight = 0
+ TabOrder = 1
+ end
+ object ApplicationProperties: TApplicationProperties
+ OnIdle = ApplicationPropertiesIdle
+ left = 64
+ top = 24
+ end
+end
--- /dev/null
+unit uMainForm;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
+ uglcContext, uglcShader, uglcArrayBuffer, uglcTypes, uglcBitmap;
+
+type
+ TMainForm = class(TForm)
+ ApplicationProperties: TApplicationProperties;
+ LogLB: TListBox;
+ RenderPanel: TPanel;
+ procedure ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+ procedure FormCreate(Sender: TObject);
+ procedure FormDestroy(Sender: TObject);
+ procedure RenderPanelResize(Sender: TObject);
+ private
+ fContext: TglcContext;
+ fShader: TglcShaderProgram;
+ fVBO: TglcArrayBuffer;
+ fTexture: TglcBitmap2D;
+ procedure Log(aSender: TObject; const aMsg: String);
+ procedure Render;
+ public
+ { public declarations }
+ end;
+
+var
+ MainForm: TMainForm;
+
+implementation
+
+{$R *.lfm}
+
+uses
+ dglOpenGL, ugluVector;
+
+const
+ SHADER_FILE = 'shader.glsl';
+ TEXTURE_FILE = 'data\texture.png';
+
+ LAYOUT_LOCATION_POS = 0;
+ LAYOUT_LOCATION_TEX = 1;
+
+ UNIFORM_NAME_TEXTURE = 'uTexture';
+
+type
+ TVertex = packed record
+ pos: TgluVector3f;
+ tex: TgluVector2f;
+ end;
+ PVertex = ^TVertex;
+
+procedure TMainForm.FormCreate(Sender: TObject);
+var
+ pf: TglcContextPixelFormatSettings;
+ p: PVertex;
+ texData: TglcBitmapData;
+begin
+ pf := TglcContext.MakePF();
+ fContext := TglcContext.GetPlatformClass.Create(RenderPanel, pf);
+ fContext.BuildContext;
+
+ fShader := TglcShaderProgram.Create(@Log);
+ fShader.LoadFromFile(ExtractFilePath(Application.ExeName) + SHADER_FILE);
+ fShader.Compile;
+ fShader.Uniform1i(UNIFORM_NAME_TEXTURE, 0);
+
+ fVBO := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
+ fVBO.BufferData(4, sizeof(TVertex), TglcBufferUsage.buStaticDraw, nil);
+ p := fVBO.MapBuffer(TglcBufferAccess.baWriteOnly);
+ try
+ p^.pos := gluVector3f(-0.5, -0.5, 0);
+ p^.tex := gluVector2f( 0.0, 1.0);
+ inc(p);
+
+ p^.pos := gluVector3f( 0.5, -0.5, 0);
+ p^.tex := gluVector2f( 1.0, 1.0);
+ inc(p);
+
+ p^.pos := gluVector3f( 0.5, 0.5, 0);
+ p^.tex := gluVector2f( 1.0, 0.0);
+ inc(p);
+
+ p^.pos := gluVector3f(-0.5, 0.5, 0);
+ p^.tex := gluVector2f( 0.0, 0.0);
+ inc(p);
+ finally
+ fVBO.UnmapBuffer;
+ end;
+
+ fTexture := TglcBitmap2D.Create;
+ texData := TglcBitmapData.Create;
+ try
+ texData.LoadFromFile(ExtractFilePath(Application.ExeName) + TEXTURE_FILE);
+ fTexture.UploadData(texData);
+ finally
+ FreeAndNil(texData);
+ end;
+end;
+
+procedure TMainForm.ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+begin
+ Render;
+ Done := false;
+end;
+
+procedure TMainForm.FormDestroy(Sender: TObject);
+begin
+ FreeAndNil(fVBO);
+ FreeAndNil(fShader);
+ FreeAndNil(fContext);
+end;
+
+procedure TMainForm.RenderPanelResize(Sender: TObject);
+begin
+ if Assigned(fContext) then begin
+ glViewport(0, 0, RenderPanel.ClientWidth, RenderPanel.ClientHeight);
+ end;
+end;
+
+procedure TMainForm.Log(aSender: TObject; const aMsg: String);
+begin
+ LogLB.Items.Add(aMsg);
+end;
+
+procedure TMainForm.Render;
+begin
+ glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
+ fVBO.Bind;
+ fTexture.Bind;
+ fShader.Enable;
+
+ glEnableVertexAttribArray(LAYOUT_LOCATION_POS);
+ glVertexAttribPointer(LAYOUT_LOCATION_POS, 3, GL_FLOAT, False, SizeOf(TVertex), @PVertex(nil)^.pos);
+
+ glEnableVertexAttribArray(LAYOUT_LOCATION_TEX);
+ glVertexAttribPointer(LAYOUT_LOCATION_TEX, 2, GL_FLOAT, False, SizeOf(TVertex), @PVertex(nil)^.tex);
+
+ glDrawArrays(GL_QUADS, 0, fVBO.DataCount);
+
+ glDisableVertexAttribArray(LAYOUT_LOCATION_POS);
+ glDisableVertexAttribArray(LAYOUT_LOCATION_TEX);
+
+ fShader.Disable;
+ fTexture.Unbind;
+ fVBO.Unbind;
+
+ fContext.SwapBuffers;
+end;
+
+end.
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+ <ProjectOptions>
+ <Version Value="9"/>
+ <PathDelim Value="\"/>
+ <General>
+ <SessionStorage Value="InProjectDir"/>
+ <MainUnit Value="0"/>
+ <Title Value="project1"/>
+ <ResourceType Value="res"/>
+ <UseXPManifest Value="True"/>
+ </General>
+ <i18n>
+ <EnableI18N LFM="False"/>
+ </i18n>
+ <VersionInfo>
+ <StringTable ProductVersion=""/>
+ </VersionInfo>
+ <BuildModes Count="1">
+ <Item1 Name="Default" Default="True"/>
+ </BuildModes>
+ <PublishOptions>
+ <Version Value="2"/>
+ </PublishOptions>
+ <RunParams>
+ <local>
+ <FormatVersion Value="1"/>
+ </local>
+ </RunParams>
+ <RequiredPackages Count="1">
+ <Item1>
+ <PackageName Value="LCL"/>
+ </Item1>
+ </RequiredPackages>
+ <Units Count="3">
+ <Unit0>
+ <Filename Value="project1.lpr"/>
+ <IsPartOfProject Value="True"/>
+ </Unit0>
+ <Unit1>
+ <Filename Value="uMainForm.pas"/>
+ <IsPartOfProject Value="True"/>
+ <ComponentName Value="MainForm"/>
+ <HasResources Value="True"/>
+ <ResourceBaseClass Value="Form"/>
+ <UnitName Value="uMainForm"/>
+ </Unit1>
+ <Unit2>
+ <Filename Value="..\..\uglcVertexArrayObject.pas"/>
+ <IsPartOfProject Value="True"/>
+ <UnitName Value="uglcVertexArrayObject"/>
+ </Unit2>
+ </Units>
+ </ProjectOptions>
+ <CompilerOptions>
+ <Version Value="11"/>
+ <PathDelim Value="\"/>
+ <Target>
+ <Filename Value="project1"/>
+ </Target>
+ <SearchPaths>
+ <IncludeFiles Value="$(ProjOutDir);..\.."/>
+ <OtherUnitFiles Value="..\.."/>
+ <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)"/>
+ </SearchPaths>
+ <Linking>
+ <Debugging>
+ <UseHeaptrc Value="True"/>
+ <UseExternalDbgSyms Value="True"/>
+ </Debugging>
+ <Options>
+ <Win32>
+ <GraphicApplication Value="True"/>
+ </Win32>
+ </Options>
+ </Linking>
+ </CompilerOptions>
+ <Debugging>
+ <Exceptions Count="3">
+ <Item1>
+ <Name Value="EAbort"/>
+ </Item1>
+ <Item2>
+ <Name Value="ECodetoolError"/>
+ </Item2>
+ <Item3>
+ <Name Value="EFOpenError"/>
+ </Item3>
+ </Exceptions>
+ </Debugging>
+</CONFIG>
--- /dev/null
+program project1;
+
+{$mode objfpc}{$H+}
+
+uses
+ {$IFDEF UNIX}{$IFDEF UseCThreads}
+ cthreads,
+ {$ENDIF}{$ENDIF}
+ Interfaces, // this includes the LCL widgetset
+ Forms, uMainForm, uglcVertexArrayObject
+ { you can add units after this };
+
+{$R *.res}
+
+begin
+ RequireDerivedFormResource := True;
+ Application.Initialize;
+ Application.CreateForm(TMainForm, MainForm);
+ Application.Run;
+end.
+
--- /dev/null
+/* ShaderObject: GL_VERTEX_SHADER */
+#version 330
+uniform mat4 uModelViewProjMat;
+layout(location = 0) in vec3 inPos;
+layout(location = 1) in vec2 inTexCoord;
+out vec2 vTexCoord;
+
+void main(void)
+{
+ gl_Position = vec4(inPos, 1.0);
+ vTexCoord = inTexCoord;
+}
+
+/* ShaderObject: GL_FRAGMENT_SHADER */
+#version 330
+uniform sampler2D uTexture;
+in vec2 vTexCoord;
+out vec4 outColor;
+
+void main(void)
+{
+ outColor = texture(uTexture, vTexCoord);
+}
\ No newline at end of file
--- /dev/null
+object MainForm: TMainForm
+ Left = 465
+ Height = 451
+ Top = 217
+ Width = 411
+ Caption = 'MainForm'
+ ClientHeight = 451
+ ClientWidth = 411
+ OnCreate = FormCreate
+ OnDestroy = FormDestroy
+ LCLVersion = '1.3'
+ object RenderPanel: TPanel
+ Left = 0
+ Height = 371
+ Top = 0
+ Width = 411
+ Align = alClient
+ TabOrder = 0
+ OnResize = RenderPanelResize
+ end
+ object LogLB: TListBox
+ Left = 0
+ Height = 80
+ Top = 371
+ Width = 411
+ Align = alBottom
+ ItemHeight = 0
+ TabOrder = 1
+ end
+ object ApplicationProperties: TApplicationProperties
+ OnIdle = ApplicationPropertiesIdle
+ left = 64
+ top = 24
+ end
+end
--- /dev/null
+unit uMainForm;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
+ uglcContext, uglcShader, uglcArrayBuffer, uglcTypes, uglcBitmap, uglcVertexArrayObject;
+
+type
+ TMainForm = class(TForm)
+ ApplicationProperties: TApplicationProperties;
+ LogLB: TListBox;
+ RenderPanel: TPanel;
+ procedure ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+ procedure FormCreate(Sender: TObject);
+ procedure FormDestroy(Sender: TObject);
+ procedure RenderPanelResize(Sender: TObject);
+ private
+ fContext: TglcContext;
+ fShader: TglcShaderProgram;
+ fVAO: TglcVertexArrayObject;
+ fTexture: TglcBitmap2D;
+ procedure Log(aSender: TObject; const aMsg: String);
+ procedure Render;
+ public
+ { public declarations }
+ end;
+
+var
+ MainForm: TMainForm;
+
+implementation
+
+{$R *.lfm}
+
+uses
+ dglOpenGL, ugluVector;
+
+const
+ SHADER_FILE = 'shader.glsl';
+ TEXTURE_FILE = 'data\texture.png';
+
+ LAYOUT_LOCATION_POS = 0;
+ LAYOUT_LOCATION_TEX = 1;
+
+ UNIFORM_NAME_TEXTURE = 'uTexture';
+
+type
+ TVertex = packed record
+ pos: TgluVector3f;
+ tex: TgluVector2f;
+ end;
+ PVertex = ^TVertex;
+
+procedure CheckGlError;
+var
+ err: GLenum;
+begin
+ err := glGetError();
+ if (err <> 0) then begin
+ ShowMessage('ERROR: 0x' + IntToHex(err, 16));
+ halt;
+ end;
+end;
+
+procedure TMainForm.FormCreate(Sender: TObject);
+var
+ pf: TglcContextPixelFormatSettings;
+ p: PVertex;
+ texData: TglcBitmapData;
+ vbo: TglcArrayBuffer;
+begin
+ pf := TglcContext.MakePF();
+ fContext := TglcContext.GetPlatformClass.Create(RenderPanel, pf);
+ fContext.BuildContext;
+
+ Log(self, glGetString(GL_VERSION));
+
+ fShader := TglcShaderProgram.Create(@Log);
+ fShader.LoadFromFile(ExtractFilePath(Application.ExeName) + SHADER_FILE);
+ fShader.Compile;
+ fShader.Uniform1i(UNIFORM_NAME_TEXTURE, 0);
+
+ vbo := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
+ vbo.BufferData(4, sizeof(TVertex), TglcBufferUsage.buStaticDraw, nil);
+ p := vbo.MapBuffer(TglcBufferAccess.baWriteOnly);
+ try
+ p^.pos := gluVector3f(-0.5, -0.5, 0);
+ p^.tex := gluVector2f( 0.0, 1.0);
+ inc(p);
+
+ p^.pos := gluVector3f( 0.5, -0.5, 0);
+ p^.tex := gluVector2f( 1.0, 1.0);
+ inc(p);
+
+ p^.pos := gluVector3f( 0.5, 0.5, 0);
+ p^.tex := gluVector2f( 1.0, 0.0);
+ inc(p);
+
+ p^.pos := gluVector3f(-0.5, 0.5, 0);
+ p^.tex := gluVector2f( 0.0, 0.0);
+ inc(p);
+ finally
+ vbo.UnmapBuffer;
+ end;
+
+ fVAO := TglcVertexArrayObject.Create;
+ fVAO.BindArrayBuffer(vbo, true);
+ fVAO.VertexAttribPointer(LAYOUT_LOCATION_POS, 3, GL_FLOAT, False, SizeOf(TVertex), GLint(@PVertex(nil)^.pos));
+ fVAO.VertexAttribPointer(LAYOUT_LOCATION_TEX, 2, GL_FLOAT, False, SizeOf(TVertex), GLint(@PVertex(nil)^.tex));
+
+ fTexture := TglcBitmap2D.Create;
+ texData := TglcBitmapData.Create;
+ try
+ texData.LoadFromFile(ExtractFilePath(Application.ExeName) + TEXTURE_FILE);
+ fTexture.UploadData(texData);
+ finally
+ FreeAndNil(texData);
+ end;
+end;
+
+procedure TMainForm.ApplicationPropertiesIdle(Sender: TObject; var Done: Boolean);
+begin
+ Render;
+ Done := false;
+end;
+
+procedure TMainForm.FormDestroy(Sender: TObject);
+begin
+ FreeAndNil(fTexture);
+ FreeAndNil(fVAO);
+ FreeAndNil(fShader);
+ FreeAndNil(fContext);
+end;
+
+procedure TMainForm.RenderPanelResize(Sender: TObject);
+begin
+ if Assigned(fContext) then begin
+ glViewport(0, 0, RenderPanel.ClientWidth, RenderPanel.ClientHeight);
+ end;
+end;
+
+procedure TMainForm.Log(aSender: TObject; const aMsg: String);
+begin
+ LogLB.Items.Add(aMsg);
+end;
+
+procedure TMainForm.Render;
+begin
+ CheckGlError;
+
+ glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
+
+ fTexture.Bind;
+ fShader.Enable;
+ fVAO.Bind;
+
+ glDrawArrays(GL_QUADS, 0, 4);
+
+ fVAO.Unbind;
+ fShader.Disable;
+ fTexture.Unbind;
+
+ fContext.SwapBuffers;
+end;
+
+end.
+
+++ /dev/null
-{ glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
- http://www.opengl24.de/index.php?cat=header&file=glbitmap
-
- modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
-
- The contents of this file are used with permission, subject to
- the Mozilla Public License Version 1.1 (the "License"); you may
- not use this file except in compliance with the License. You may
- obtain a copy of the License at
- http://www.mozilla.org/MPL/MPL-1.1.html
-
- The glBitmap is a Delphi/FPC unit that contains several wrapper classes
- to manage OpenGL texture objects. Below you can find a list of the main
- functionality of this classes:
- - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
- - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
- - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
- - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
- - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...)
- - manage texture properties (e.g. Filter, Clamp, Mipmap, ...)
- - upload texture data to video card
- - download texture data from video card
- - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...) }
-
-unit glBitmap;
-
-{$I glBitmapConf.inc}
-
-// Delphi Versions
-{$IFDEF fpc}
- {$MODE Delphi}
-
- {$IFDEF CPUI386}
- {$DEFINE CPU386}
- {$ASMMODE INTEL}
- {$ENDIF}
-
- {$IFNDEF WINDOWS}
- {$linklib c}
- {$ENDIF}
-{$ENDIF}
-
-// Operation System
-{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
- {$DEFINE GLB_WIN}
-{$ELSEIF DEFINED(LINUX)}
- {$DEFINE GLB_LINUX}
-{$IFEND}
-
-// OpenGL ES
-{$IF DEFINED(OPENGL_ES_EXT)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
-{$IF DEFINED(OPENGL_ES_3_0)} {$DEFINE OPENGL_ES_2_0} {$IFEND}
-{$IF DEFINED(OPENGL_ES_2_0)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
-{$IF DEFINED(OPENGL_ES_1_1)} {$DEFINE OPENGL_ES} {$IFEND}
-
-// checking define combinations
-//SDL Image
-{$IFDEF GLB_SDL_IMAGE}
- {$IFNDEF GLB_SDL}
- {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'}
- {$DEFINE GLB_SDL}
- {$ENDIF}
-
- {$IFDEF GLB_LAZ_PNG}
- {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'}
- {$undef GLB_LAZ_PNG}
- {$ENDIF}
-
- {$IFDEF GLB_PNGIMAGE}
- {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'}
- {$undef GLB_PNGIMAGE}
- {$ENDIF}
-
- {$IFDEF GLB_LAZ_JPEG}
- {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'}
- {$undef GLB_LAZ_JPEG}
- {$ENDIF}
-
- {$IFDEF GLB_DELPHI_JPEG}
- {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'}
- {$undef GLB_DELPHI_JPEG}
- {$ENDIF}
-
- {$IFDEF GLB_LIB_PNG}
- {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'}
- {$undef GLB_LIB_PNG}
- {$ENDIF}
-
- {$IFDEF GLB_LIB_JPEG}
- {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'}
- {$undef GLB_LIB_JPEG}
- {$ENDIF}
-
- {$DEFINE GLB_SUPPORT_PNG_READ}
- {$DEFINE GLB_SUPPORT_JPEG_READ}
-{$ENDIF}
-
-// Lazarus TPortableNetworkGraphic
-{$IFDEF GLB_LAZ_PNG}
- {$IFNDEF GLB_LAZARUS}
- {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'}
- {$DEFINE GLB_LAZARUS}
- {$ENDIF}
-
- {$IFDEF GLB_PNGIMAGE}
- {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
- {$undef GLB_PNGIMAGE}
- {$ENDIF}
-
- {$IFDEF GLB_LIB_PNG}
- {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
- {$undef GLB_LIB_PNG}
- {$ENDIF}
-
- {$DEFINE GLB_SUPPORT_PNG_READ}
- {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// PNG Image
-{$IFDEF GLB_PNGIMAGE}
- {$IFDEF GLB_LIB_PNG}
- {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'}
- {$undef GLB_LIB_PNG}
- {$ENDIF}
-
- {$DEFINE GLB_SUPPORT_PNG_READ}
- {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// libPNG
-{$IFDEF GLB_LIB_PNG}
- {$DEFINE GLB_SUPPORT_PNG_READ}
- {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// Lazarus TJPEGImage
-{$IFDEF GLB_LAZ_JPEG}
- {$IFNDEF GLB_LAZARUS}
- {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'}
- {$DEFINE GLB_LAZARUS}
- {$ENDIF}
-
- {$IFDEF GLB_DELPHI_JPEG}
- {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'}
- {$undef GLB_DELPHI_JPEG}
- {$ENDIF}
-
- {$IFDEF GLB_LIB_JPEG}
- {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'}
- {$undef GLB_LIB_JPEG}
- {$ENDIF}
-
- {$DEFINE GLB_SUPPORT_JPEG_READ}
- {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// JPEG Image
-{$IFDEF GLB_DELPHI_JPEG}
- {$IFDEF GLB_LIB_JPEG}
- {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'}
- {$undef GLB_LIB_JPEG}
- {$ENDIF}
-
- {$DEFINE GLB_SUPPORT_JPEG_READ}
- {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// libJPEG
-{$IFDEF GLB_LIB_JPEG}
- {$DEFINE GLB_SUPPORT_JPEG_READ}
- {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// general options
-{$EXTENDEDSYNTAX ON}
-{$LONGSTRINGS ON}
-{$ALIGN ON}
-{$IFNDEF FPC}
- {$OPTIMIZATION ON}
-{$ENDIF}
-
-interface
-
-uses
- {$IFDEF OPENGL_ES} dglOpenGLES,
- {$ELSE} dglOpenGL, {$ENDIF}
-
- {$IF DEFINED(GLB_WIN) AND
- DEFINED(GLB_DELPHI)} windows, {$IFEND}
-
- {$IFDEF GLB_SDL} SDL, {$ENDIF}
- {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, Graphics, {$ENDIF}
- {$IFDEF GLB_DELPHI} Dialogs, Graphics, Types, {$ENDIF}
-
- {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF}
- {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF}
- {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF}
- {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF}
- {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF}
-
- Classes, SysUtils;
-
-type
-{$IFNDEF fpc}
- QWord = System.UInt64;
- PQWord = ^QWord;
-
- PtrInt = Longint;
- PtrUInt = DWord;
-{$ENDIF}
-
-
- { type that describes the format of the data stored in a texture.
- the name of formats is composed of the following constituents:
- - multiple channels:
- - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved))
- - width of the chanel in bit (4, 8, 16, ...)
- - data type (e.g. ub, us, ui)
- - number of elements of data types }
- TglBitmapFormat = (
- tfEmpty = 0,
-
- tfAlpha4ub1, //< 1 x unsigned byte
- tfAlpha8ub1, //< 1 x unsigned byte
- tfAlpha16us1, //< 1 x unsigned short
-
- tfLuminance4ub1, //< 1 x unsigned byte
- tfLuminance8ub1, //< 1 x unsigned byte
- tfLuminance16us1, //< 1 x unsigned short
-
- tfLuminance4Alpha4ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
- tfLuminance6Alpha2ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
- tfLuminance8Alpha8ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
- tfLuminance12Alpha4us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha)
- tfLuminance16Alpha16us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha)
-
- tfR3G3B2ub1, //< 1 x unsigned byte (3bit red, 3bit green, 2bit blue)
- tfRGBX4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd)
- tfXRGB4us1, //< 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue)
- tfR5G6B5us1, //< 1 x unsigned short (5bit red, 6bit green, 5bit blue)
- tfRGB5X1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved)
- tfX1RGB5us1, //< 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue)
- tfRGB8ub3, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue)
- tfRGBX8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved)
- tfXRGB8ui1, //< 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue)
- tfRGB10X2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved)
- tfX2RGB10ui1, //< 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue)
- tfRGB16us3, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue)
-
- tfRGBA4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha)
- tfARGB4us1, //< 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue)
- tfRGB5A1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha)
- tfA1RGB5us1, //< 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue)
- tfRGBA8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha)
- tfARGB8ui1, //< 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue)
- tfRGBA8ub4, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha)
- tfRGB10A2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha)
- tfA2RGB10ui1, //< 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue)
- tfRGBA16us4, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha)
-
- tfBGRX4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved)
- tfXBGR4us1, //< 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red)
- tfB5G6R5us1, //< 1 x unsigned short (5bit blue, 6bit green, 5bit red)
- tfBGR5X1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved)
- tfX1BGR5us1, //< 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red)
- tfBGR8ub3, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red)
- tfBGRX8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved)
- tfXBGR8ui1, //< 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red)
- tfBGR10X2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved)
- tfX2BGR10ui1, //< 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red)
- tfBGR16us3, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red)
-
- tfBGRA4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha)
- tfABGR4us1, //< 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red)
- tfBGR5A1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha)
- tfA1BGR5us1, //< 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red)
- tfBGRA8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha)
- tfABGR8ui1, //< 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red)
- tfBGRA8ub4, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha)
- tfBGR10A2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha)
- tfA2BGR10ui1, //< 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red)
- tfBGRA16us4, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha)
-
- tfDepth16us1, //< 1 x unsigned short (depth)
- tfDepth24ui1, //< 1 x unsigned int (depth)
- tfDepth32ui1, //< 1 x unsigned int (depth)
-
- tfS3tcDtx1RGBA,
- tfS3tcDtx3RGBA,
- tfS3tcDtx5RGBA
- );
-
- { type to define suitable file formats }
- TglBitmapFileType = (
- {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} //< Portable Network Graphic file (PNG)
- {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} //< JPEG file
- ftDDS, //< Direct Draw Surface file (DDS)
- ftTGA, //< Targa Image File (TGA)
- ftBMP, //< Windows Bitmap File (BMP)
- ftRAW); //< glBitmap RAW file format
- TglBitmapFileTypes = set of TglBitmapFileType;
-
- { possible mipmap types }
- TglBitmapMipMap = (
- mmNone, //< no mipmaps
- mmMipmap, //< normal mipmaps
- mmMipmapGlu); //< mipmaps generated with glu functions
-
- { possible normal map functions }
- TglBitmapNormalMapFunc = (
- nm4Samples,
- nmSobel,
- nm3x3,
- nm5x5);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- EglBitmap = class(Exception); //< glBitmap exception
- EglBitmapNotSupported = class(Exception); //< exception for not supported functions
- EglBitmapSizeToLarge = class(EglBitmap); //< exception for to large textures
- EglBitmapNonPowerOfTwo = class(EglBitmap); //< exception for non power of two textures
- EglBitmapUnsupportedFormat = class(EglBitmap) //< exception for unsupporetd formats
- public
- constructor Create(const aFormat: TglBitmapFormat); overload;
- constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
- end;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
- { record that stores 4 unsigned integer values }
- TglBitmapRec4ui = packed record
- case Integer of
- 0: (r, g, b, a: Cardinal);
- 1: (arr: array[0..3] of Cardinal);
- end;
-
- { record that stores 4 unsigned byte values }
- TglBitmapRec4ub = packed record
- case Integer of
- 0: (r, g, b, a: Byte);
- 1: (arr: array[0..3] of Byte);
- end;
-
- { record that stores 4 unsigned long integer values }
- TglBitmapRec4ul = packed record
- case Integer of
- 0: (r, g, b, a: QWord);
- 1: (arr: array[0..3] of QWord);
- end;
-
- { structure to store pixel data in }
- TglBitmapPixelData = packed record
- Data: TglBitmapRec4ui; //< color data for each color channel
- Range: TglBitmapRec4ui; //< maximal color value for each channel
- Format: TglBitmapFormat; //< format of the pixel
- end;
- PglBitmapPixelData = ^TglBitmapPixelData;
-
- TglBitmapSizeFields = set of (ffX, ffY);
- TglBitmapSize = packed record
- Fields: TglBitmapSizeFields;
- X: Word;
- Y: Word;
- end;
- TglBitmapPixelPosition = TglBitmapSize;
-
- { describes the properties of a given texture data format }
- TglBitmapFormatDescriptor = class(TObject)
- private
- // cached properties
- fBytesPerPixel: Single; //< number of bytes for each pixel
- fChannelCount: Integer; //< number of color channels
- fMask: TglBitmapRec4ul; //< bitmask for each color channel
- fRange: TglBitmapRec4ui; //< maximal value of each color channel
-
- { @return @true if the format has a red color channel, @false otherwise }
- function GetHasRed: Boolean;
-
- { @return @true if the format has a green color channel, @false otherwise }
- function GetHasGreen: Boolean;
-
- { @return @true if the format has a blue color channel, @false otherwise }
- function GetHasBlue: Boolean;
-
- { @return @true if the format has a alpha color channel, @false otherwise }
- function GetHasAlpha: Boolean;
-
- { @return @true if the format has any color color channel, @false otherwise }
- function GetHasColor: Boolean;
-
- { @return @true if the format is a grayscale format, @false otherwise }
- function GetIsGrayscale: Boolean;
-
- { @return @true if the format is supported by OpenGL, @false otherwise }
- function GetHasOpenGLSupport: Boolean;
-
- protected
- fFormat: TglBitmapFormat; //< format this descriptor belongs to
- fWithAlpha: TglBitmapFormat; //< suitable format with alpha channel
- fWithoutAlpha: TglBitmapFormat; //< suitable format without alpha channel
- fOpenGLFormat: TglBitmapFormat; //< suitable format that is supported by OpenGL
- fRGBInverted: TglBitmapFormat; //< suitable format with inverted RGB channels
- fUncompressed: TglBitmapFormat; //< suitable format with uncompressed data
-
- fBitsPerPixel: Integer; //< number of bits per pixel
- fIsCompressed: Boolean; //< @true if the format is compressed, @false otherwise
-
- fPrecision: TglBitmapRec4ub; //< number of bits for each color channel
- fShift: TglBitmapRec4ub; //< bit offset for each color channel
-
- fglFormat: GLenum; //< OpenGL format enum (e.g. GL_RGB)
- fglInternalFormat: GLenum; //< OpenGL internal format enum (e.g. GL_RGB8)
- fglDataFormat: GLenum; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)
-
- { set values for this format descriptor }
- procedure SetValues; virtual;
-
- { calculate cached values }
- procedure CalcValues;
- public
- property Format: TglBitmapFormat read fFormat; //< format this descriptor belongs to
- property ChannelCount: Integer read fChannelCount; //< number of color channels
- property IsCompressed: Boolean read fIsCompressed; //< @true if the format is compressed, @false otherwise
- property BitsPerPixel: Integer read fBitsPerPixel; //< number of bytes per pixel
- property BytesPerPixel: Single read fBytesPerPixel; //< number of bits per pixel
-
- property Precision: TglBitmapRec4ub read fPrecision; //< number of bits for each color channel
- property Shift: TglBitmapRec4ub read fShift; //< bit offset for each color channel
- property Range: TglBitmapRec4ui read fRange; //< maximal value of each color channel
- property Mask: TglBitmapRec4ul read fMask; //< bitmask for each color channel
-
- property RGBInverted: TglBitmapFormat read fRGBInverted; //< suitable format with inverted RGB channels
- property WithAlpha: TglBitmapFormat read fWithAlpha; //< suitable format with alpha channel
- property WithoutAlpha: TglBitmapFormat read fWithAlpha; //< suitable format without alpha channel
- property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; //< suitable format that is supported by OpenGL
- property Uncompressed: TglBitmapFormat read fUncompressed; //< suitable format with uncompressed data
-
- property glFormat: GLenum read fglFormat; //< OpenGL format enum (e.g. GL_RGB)
- property glInternalFormat: GLenum read fglInternalFormat; //< OpenGL internal format enum (e.g. GL_RGB8)
- property glDataFormat: GLenum read fglDataFormat; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)
-
- property HasRed: Boolean read GetHasRed; //< @true if the format has a red color channel, @false otherwise
- property HasGreen: Boolean read GetHasGreen; //< @true if the format has a green color channel, @false otherwise
- property HasBlue: Boolean read GetHasBlue; //< @true if the format has a blue color channel, @false otherwise
- property HasAlpha: Boolean read GetHasAlpha; //< @true if the format has a alpha color channel, @false otherwise
- property HasColor: Boolean read GetHasColor; //< @true if the format has any color color channel, @false otherwise
- property IsGrayscale: Boolean read GetIsGrayscale; //< @true if the format is a grayscale format, @false otherwise
-
- property HasOpenGLSupport: Boolean read GetHasOpenGLSupport; //< @true if the format is supported by OpenGL, @false otherwise
-
- function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual;
- function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
-
- { constructor }
- constructor Create;
- public
- { get the format descriptor by a given OpenGL internal format
- @param aInternalFormat OpenGL internal format to get format descriptor for
- @returns suitable format descriptor or tfEmpty-Descriptor }
- class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
- end;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
- TglBitmapData = class;
-
- { structure to store data for converting in }
- TglBitmapFunctionRec = record
- Sender: TglBitmapData; //< texture object that stores the data to convert
- Size: TglBitmapSize; //< size of the texture
- Position: TglBitmapPixelPosition; //< position of the currently pixel
- Source: TglBitmapPixelData; //< pixel data of the current pixel
- Dest: TglBitmapPixelData; //< new data of the pixel (must be filled in)
- Args: Pointer; //< user defined args that was passed to the convert function
- end;
-
- { callback to use for converting texture data }
- TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- { class to store texture data in. used to load, save and
- manipulate data before assigned to texture object
- all operations on a data object can be done from a background thread }
- TglBitmapData = class
- private { fields }
-
- fData: PByte; //< texture data
- fDimension: TglBitmapSize; //< pixel size of the data
- fFormat: TglBitmapFormat; //< format the texture data is stored in
- fFilename: String; //< file the data was load from
-
- fScanlines: array of PByte; //< pointer to begin of each line
- fHasScanlines: Boolean; //< @true if scanlines are initialized, @false otherwise
-
- private { getter / setter }
-
- { @returns the format descriptor suitable to the texture data format }
- function GetFormatDescriptor: TglBitmapFormatDescriptor;
-
- { @returns the width of the texture data (in pixel) or -1 if no data is set }
- function GetWidth: Integer;
-
- { @returns the height of the texture data (in pixel) or -1 if no data is set }
- function GetHeight: Integer;
-
- { get scanline at index aIndex
- @returns Pointer to start of line or @nil }
- function GetScanlines(const aIndex: Integer): PByte;
-
- { set new value for the data format. only possible if new format has the same pixel size.
- if you want to convert the texture data, see ConvertTo function }
- procedure SetFormat(const aValue: TglBitmapFormat);
-
- private { internal misc }
-
- { splits a resource identifier into the resource and it's type
- @param aResource resource identifier to split and store name in
- @param aResType type of the resource }
- procedure PrepareResType(var aResource: String; var aResType: PChar);
-
- { updates scanlines array }
- procedure UpdateScanlines;
-
- private { internal load and save }
-{$IFDEF GLB_SUPPORT_PNG_READ}
- { try to load a PNG from a stream
- @param aStream stream to load PNG from
- @returns @true on success, @false otherwise }
- function LoadPNG(const aStream: TStream): Boolean; virtual;
-{$ENDIF}
-
-{$ifdef GLB_SUPPORT_PNG_WRITE}
- { save texture data as PNG to stream
- @param aStream stream to save data to}
- procedure SavePNG(const aStream: TStream); virtual;
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_READ}
- { try to load a JPEG from a stream
- @param aStream stream to load JPEG from
- @returns @true on success, @false otherwise }
- function LoadJPEG(const aStream: TStream): Boolean; virtual;
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_WRITE}
- { save texture data as JPEG to stream
- @param aStream stream to save data to}
- procedure SaveJPEG(const aStream: TStream); virtual;
-{$ENDIF}
-
- { try to load a RAW image from a stream
- @param aStream stream to load RAW image from
- @returns @true on success, @false otherwise }
- function LoadRAW(const aStream: TStream): Boolean;
-
- { save texture data as RAW image to stream
- @param aStream stream to save data to}
- procedure SaveRAW(const aStream: TStream);
-
- { try to load a BMP from a stream
- @param aStream stream to load BMP from
- @returns @true on success, @false otherwise }
- function LoadBMP(const aStream: TStream): Boolean;
-
- { save texture data as BMP to stream
- @param aStream stream to save data to}
- procedure SaveBMP(const aStream: TStream);
-
- { try to load a TGA from a stream
- @param aStream stream to load TGA from
- @returns @true on success, @false otherwise }
- function LoadTGA(const aStream: TStream): Boolean;
-
- { save texture data as TGA to stream
- @param aStream stream to save data to}
- procedure SaveTGA(const aStream: TStream);
-
- { try to load a DDS from a stream
- @param aStream stream to load DDS from
- @returns @true on success, @false otherwise }
- function LoadDDS(const aStream: TStream): Boolean;
-
- { save texture data as DDS to stream
- @param aStream stream to save data to}
- procedure SaveDDS(const aStream: TStream);
-
- public { properties }
- property Data: PByte read fData; //< texture data (be carefull with this!)
- property Dimension: TglBitmapSize read fDimension; //< size of the texture data (in pixel)
- property Filename: String read fFilename; //< file the data was loaded from
- property Width: Integer read GetWidth; //< width of the texture data (in pixel)
- property Height: Integer read GetHeight; //< height of the texture data (in pixel)
- property Format: TglBitmapFormat read fFormat write SetFormat; //< format the texture data is stored in
- property Scanlines[const aIndex: Integer]: PByte read GetScanlines; //< pointer to begin of line at given index or @nil
-
- property FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor; //< descriptor object that describes the format of the stored data
-
- public { flip }
-
- { flip texture horizontal
- @returns @true in success, @false otherwise }
- function FlipHorz: Boolean; virtual;
-
- { flip texture vertical
- @returns @true in success, @false otherwise }
- function FlipVert: Boolean; virtual;
-
- public { load }
-
- { load a texture from a file
- @param aFilename file to load texuture from }
- procedure LoadFromFile(const aFilename: String);
-
- { load a texture from a stream
- @param aStream stream to load texture from }
- procedure LoadFromStream(const aStream: TStream); virtual;
-
- { use a function to generate texture data
- @param aSize size of the texture
- @param aFormat format of the texture data
- @param aFunc callback to use for generation
- @param aArgs user defined paramaters (use at will) }
- procedure LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil);
-
- { load a texture from a resource
- @param aInstance resource handle
- @param aResource resource indentifier
- @param aResType resource type (if known) }
- procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
-
- { load a texture from a resource id
- @param aInstance resource handle
- @param aResource resource ID
- @param aResType resource type }
- procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-
- public { save }
-
- { save texture data to a file
- @param aFilename filename to store texture in
- @param aFileType file type to store data into }
- procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
-
- { save texture data to a stream
- @param aFilename filename to store texture in
- @param aFileType file type to store data into }
- procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
-
- public { convert }
-
- { convert texture data using a user defined callback
- @param aFunc callback to use for converting
- @param aCreateTemp create a temporary buffer to use for converting
- @param aArgs user defined paramters (use at will)
- @returns @true if converting was successful, @false otherwise }
- function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
-
- { convert texture data using a user defined callback
- @param aSource glBitmap to read data from
- @param aFunc callback to use for converting
- @param aCreateTemp create a temporary buffer to use for converting
- @param aFormat format of the new data
- @param aArgs user defined paramters (use at will)
- @returns @true if converting was successful, @false otherwise }
- function Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
- const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
-
- { convert texture data using a specific format
- @param aFormat new format of texture data
- @returns @true if converting was successful, @false otherwise }
- function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
-
-{$IFDEF GLB_SDL}
- public { SDL }
-
- { assign texture data to SDL surface
- @param aSurface SDL surface to write data to
- @returns @true on success, @false otherwise }
- function AssignToSurface(out aSurface: PSDL_Surface): Boolean;
-
- { assign texture data from SDL surface
- @param aSurface SDL surface to read data from
- @returns @true on success, @false otherwise }
- function AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
-
- { assign alpha channel data to SDL surface
- @param aSurface SDL surface to write alpha channel data to
- @returns @true on success, @false otherwise }
- function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
-
- { assign alpha channel data from SDL surface
- @param aSurface SDL surface to read data from
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-{$ENDIF}
-
-{$IFDEF GLB_DELPHI}
- public { Delphi }
-
- { assign texture data to TBitmap object
- @param aBitmap TBitmap to write data to
- @returns @true on success, @false otherwise }
- function AssignToBitmap(const aBitmap: TBitmap): Boolean;
-
- { assign texture data from TBitmap object
- @param aBitmap TBitmap to read data from
- @returns @true on success, @false otherwise }
- function AssignFromBitmap(const aBitmap: TBitmap): Boolean;
-
- { assign alpha channel data to TBitmap object
- @param aBitmap TBitmap to write data to
- @returns @true on success, @false otherwise }
- function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
-
- { assign alpha channel data from TBitmap object
- @param aBitmap TBitmap to read data from
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-{$ENDIF}
-
-{$IFDEF GLB_LAZARUS}
- public { Lazarus }
-
- { assign texture data to TLazIntfImage object
- @param aImage TLazIntfImage to write data to
- @returns @true on success, @false otherwise }
- function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-
- { assign texture data from TLazIntfImage object
- @param aImage TLazIntfImage to read data from
- @returns @true on success, @false otherwise }
- function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
-
- { assign alpha channel data to TLazIntfImage object
- @param aImage TLazIntfImage to write data to
- @returns @true on success, @false otherwise }
- function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-
- { assign alpha channel data from TLazIntfImage object
- @param aImage TLazIntfImage to read data from
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-{$ENDIF}
-
- public { Alpha }
- { load alpha channel data from resource
- @param aInstance resource handle
- @param aResource resource ID
- @param aResType resource type
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
- { load alpha channel data from resource ID
- @param aInstance resource handle
- @param aResourceID resource ID
- @param aResType resource type
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
- { add alpha channel data from function
- @param aFunc callback to get data from
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
-
- { add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap)
- @param aFilename file to load alpha channel data from
- @param aFunc callback to use for converting
- @param aArgs SetFormat user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
- { add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap)
- @param aStream stream to load alpha channel data from
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
- { add alpha channel data from existing glBitmap object
- @param aBitmap TglBitmap to copy alpha channel data from
- @param aFunc callback to use for converting
- @param aArgs user defined parameters (use at will)
- @returns @true on success, @false otherwise }
- function AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-
- { add alpha to pixel if the pixels color is greter than the given color value
- @param aRed red threshold (0-255)
- @param aGreen green threshold (0-255)
- @param aBlue blue threshold (0-255)
- @param aDeviatation accepted deviatation (0-255)
- @returns @true on success, @false otherwise }
- function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
-
- { add alpha to pixel if the pixels color is greter than the given color value
- @param aRed red threshold (0-Range.r)
- @param aGreen green threshold (0-Range.g)
- @param aBlue blue threshold (0-Range.b)
- @param aDeviatation accepted deviatation (0-max(Range.rgb))
- @returns @true on success, @false otherwise }
- function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
-
- { add alpha to pixel if the pixels color is greter than the given color value
- @param aRed red threshold (0.0-1.0)
- @param aGreen green threshold (0.0-1.0)
- @param aBlue blue threshold (0.0-1.0)
- @param aDeviatation accepted deviatation (0.0-1.0)
- @returns @true on success, @false otherwise }
- function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
-
- { add a constand alpha value to all pixels
- @param aAlpha alpha value to add (0-255)
- @returns @true on success, @false otherwise }
- function AddAlphaFromValue(const aAlpha: Byte): Boolean;
-
- { add a constand alpha value to all pixels
- @param aAlpha alpha value to add (0-max(Range.rgb))
- @returns @true on success, @false otherwise }
- function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
-
- { add a constand alpha value to all pixels
- @param aAlpha alpha value to add (0.0-1.0)
- @returns @true on success, @false otherwise }
- function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
-
- { remove alpha channel
- @returns @true on success, @false otherwise }
- function RemoveAlpha: Boolean; virtual;
-
- public { fill }
- { fill complete texture with one color
- @param aRed red color for border (0-255)
- @param aGreen green color for border (0-255)
- @param aBlue blue color for border (0-255)
- @param aAlpha alpha color for border (0-255) }
- procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
-
- { fill complete texture with one color
- @param aRed red color for border (0-Range.r)
- @param aGreen green color for border (0-Range.g)
- @param aBlue blue color for border (0-Range.b)
- @param aAlpha alpha color for border (0-Range.a) }
- procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
-
- { fill complete texture with one color
- @param aRed red color for border (0.0-1.0)
- @param aGreen green color for border (0.0-1.0)
- @param aBlue blue color for border (0.0-1.0)
- @param aAlpha alpha color for border (0.0-1.0) }
- procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);
-
- public { Misc }
-
- { set data pointer of texture data
- @param aData pointer to new texture data
- @param aFormat format of the data stored at aData
- @param aWidth width of the texture data
- @param aHeight height of the texture data }
- procedure SetData(const aData: PByte; const aFormat: TglBitmapFormat;
- const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;
-
- { create a clone of the current object
- @returns clone of this object}
- function Clone: TglBitmapData;
-
- { invert color data (bitwise not)
- @param aRed invert red channel
- @param aGreen invert green channel
- @param aBlue invert blue channel
- @param aAlpha invert alpha channel }
- procedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
-
- { create normal map from texture data
- @param aFunc normal map function to generate normalmap with
- @param aScale scale of the normale stored in the normal map
- @param aUseAlpha generate normalmap from alpha channel data (if present) }
- procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3;
- const aScale: Single = 2; const aUseAlpha: Boolean = false);
-
- public { constructor }
-
- { constructor - creates a texutre data object }
- constructor Create; overload;
-
- { constructor - creates a texture data object and loads it from a file
- @param aFilename file to load texture from }
- constructor Create(const aFileName: String); overload;
-
- { constructor - creates a texture data object and loads it from a stream
- @param aStream stream to load texture from }
- constructor Create(const aStream: TStream); overload;
-
- { constructor - creates a texture data object with the given size, format and data
- @param aSize size of the texture
- @param aFormat format of the given data
- @param aData texture data - be carefull: the data will now be managed by the texture data object }
- constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
-
- { constructor - creates a texture data object with the given size and format and uses the given callback to create the data
- @param aSize size of the texture
- @param aFormat format of the given data
- @param aFunc callback to use for generating the data
- @param aArgs user defined parameters (use at will) }
- constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
-
- { constructor - creates a texture data object and loads it from a resource
- @param aInstance resource handle
- @param aResource resource indentifier
- @param aResType resource type (if known) }
- constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
-
- { constructor - creates a texture data object and loads it from a resource
- @param aInstance resource handle
- @param aResourceID resource ID
- @param aResType resource type (if known) }
- constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
-
- { destructor }
- destructor Destroy; override;
-
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- { base class for all glBitmap classes. used to manage OpenGL texture objects
- all operations on a bitmap object must be done from the render thread }
- TglBitmap = class
- protected
- fID: GLuint; //< name of the OpenGL texture object
- fTarget: GLuint; //< texture target (e.g. GL_TEXTURE_2D)
- fDeleteTextureOnFree: Boolean; //< delete OpenGL texture object when this object is destroyed
-
- // texture properties
- fFilterMin: GLenum; //< min filter to apply to the texture
- fFilterMag: GLenum; //< mag filter to apply to the texture
- fWrapS: GLenum; //< texture wrapping for x axis
- fWrapT: GLenum; //< texture wrapping for y axis
- fWrapR: GLenum; //< texture wrapping for z axis
- fAnisotropic: Integer; //< anisotropic level
- fBorderColor: array[0..3] of Single; //< color of the texture border
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- //Swizzle
- fSwizzle: array[0..3] of GLenum; //< color channel swizzle
-{$IFEND}
-{$IFNDEF OPENGL_ES}
- fIsResident: GLboolean; //< @true if OpenGL texture object has data, @false otherwise
-{$ENDIF}
-
- fDimension: TglBitmapSize; //< size of this texture
- fMipMap: TglBitmapMipMap; //< mipmap type
-
- // CustomData
- fCustomData: Pointer; //< user defined data
- fCustomName: String; //< user defined name
- fCustomNameW: WideString; //< user defined name
- protected
- { @returns the actual width of the texture }
- function GetWidth: Integer; virtual;
-
- { @returns the actual height of the texture }
- function GetHeight: Integer; virtual;
-
- protected
- { set a new value for fCustomData }
- procedure SetCustomData(const aValue: Pointer);
-
- { set a new value for fCustomName }
- procedure SetCustomName(const aValue: String);
-
- { set a new value for fCustomNameW }
- procedure SetCustomNameW(const aValue: WideString);
-
- { set new value for fDeleteTextureOnFree }
- procedure SetDeleteTextureOnFree(const aValue: Boolean);
-
- { set name of OpenGL texture object }
- procedure SetID(const aValue: Cardinal);
-
- { set new value for fMipMap }
- procedure SetMipMap(const aValue: TglBitmapMipMap);
-
- { set new value for target }
- procedure SetTarget(const aValue: Cardinal);
-
- { set new value for fAnisotrophic }
- procedure SetAnisotropic(const aValue: Integer);
-
- protected
- { create OpenGL texture object (delete exisiting object if exists) }
- procedure CreateID;
-
- { setup texture parameters }
- procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF});
-
- protected
- property Width: Integer read GetWidth; //< the actual width of the texture
- property Height: Integer read GetHeight; //< the actual height of the texture
-
- public
- property ID: Cardinal read fID write SetID; //< name of the OpenGL texture object
- property Target: Cardinal read fTarget write SetTarget; //< texture target (e.g. GL_TEXTURE_2D)
- property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; //< delete texture object when this object is destroyed
-
- property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; //< mipmap type
- property Anisotropic: Integer read fAnisotropic write SetAnisotropic; //< anisotropic level
-
- property CustomData: Pointer read fCustomData write SetCustomData; //< user defined data (use at will)
- property CustomName: String read fCustomName write SetCustomName; //< user defined name (use at will)
- property CustomNameW: WideString read fCustomNameW write SetCustomNameW; //< user defined name (as WideString; use at will)
-
- property Dimension: TglBitmapSize read fDimension; //< size of the texture
-{$IFNDEF OPENGL_ES}
- property IsResident: GLboolean read fIsResident; //< @true if OpenGL texture object has data, @false otherwise
-{$ENDIF}
-
- { this method is called after the constructor and sets the default values of this object }
- procedure AfterConstruction; override;
-
- { this method is called before the destructor and does some cleanup }
- procedure BeforeDestruction; override;
-
- public
-{$IFNDEF OPENGL_ES}
- { set the new value for texture border color
- @param aRed red color for border (0.0-1.0)
- @param aGreen green color for border (0.0-1.0)
- @param aBlue blue color for border (0.0-1.0)
- @param aAlpha alpha color for border (0.0-1.0) }
- procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
-{$ENDIF}
-
- public
- { set new texture filer
- @param aMin min filter
- @param aMag mag filter }
- procedure SetFilter(const aMin, aMag: GLenum);
-
- { set new texture wrapping
- @param S texture wrapping for x axis
- @param T texture wrapping for y axis
- @param R texture wrapping for z axis }
- procedure SetWrap(
- const S: GLenum = GL_CLAMP_TO_EDGE;
- const T: GLenum = GL_CLAMP_TO_EDGE;
- const R: GLenum = GL_CLAMP_TO_EDGE);
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- { set new swizzle
- @param r swizzle for red channel
- @param g swizzle for green channel
- @param b swizzle for blue channel
- @param a swizzle for alpha channel }
- procedure SetSwizzle(const r, g, b, a: GLenum);
-{$IFEND}
-
- public
- { bind texture
- @param aEnableTextureUnit enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) }
- procedure Bind({$IFNDEF OPENGL_ES}const aEnableTextureUnit: Boolean = true{$ENDIF}); virtual;
-
- { bind texture
- @param aDisableTextureUnit disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) }
- procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTextureUnit: Boolean = true{$ENDIF}); virtual;
-
- { upload texture data from given data object to video card
- @param aData texture data object that contains the actual data
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual;
-
-{$IFNDEF OPENGL_ES}
- { download texture data from video card and store it into given data object
- @returns @true when download was successfull, @false otherwise }
- function DownloadData(const aDataObj: TglBitmapData): Boolean; virtual;
-{$ENDIF}
- public
- { constructor - creates an empty texture }
- constructor Create; overload;
-
- { constructor - creates an texture object and uploads the given data }
- constructor Create(const aData: TglBitmapData); overload;
-
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{$IF NOT DEFINED(OPENGL_ES)}
- { wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D
- all operations on a bitmap object must be done from the render thread }
- TglBitmap1D = class(TglBitmap)
- protected
-
- { upload the texture data to video card
- @param aDataObj texture data object that contains the actual data
- @param aBuildWithGlu use glu functions to build mipmaps }
- procedure UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
-
- public
- property Width; //< actual with of the texture
-
- { this method is called after constructor and initializes the object }
- procedure AfterConstruction; override;
-
- { upload texture data from given data object to video card
- @param aData texture data object that contains the actual data
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-
- end;
-{$IFEND}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- { wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D)
- all operations on a bitmap object must be done from the render thread }
- TglBitmap2D = class(TglBitmap)
- protected
-
- { upload the texture data to video card
- @param aDataObj texture data object that contains the actual data
- @param aTarget target o upload data to (e.g. GL_TEXTURE_2D)
- @param aBuildWithGlu use glu functions to build mipmaps }
- procedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum
- {$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF});
-
- public
- property Width; //< actual width of the texture
- property Height; //< actual height of the texture
-
- { this method is called after constructor and initializes the object }
- procedure AfterConstruction; override;
-
- { upload texture data from given data object to video card
- @param aData texture data object that contains the actual data
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-
- public
-
- { copy a part of the frame buffer to the texture
- @param aTop topmost pixel to copy
- @param aLeft leftmost pixel to copy
- @param aRight rightmost pixel to copy
- @param aBottom bottommost pixel to copy
- @param aFormat format to store data in
- @param aDataObj texture data object to store the data in }
- class procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
-
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
- { wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP)
- all operations on a bitmap object must be done from the render thread }
- TglBitmapCubeMap = class(TglBitmap2D)
- protected
- {$IFNDEF OPENGL_ES}
- fGenMode: Integer; //< generation mode for the cube map (e.g. GL_REFLECTION_MAP)
- {$ENDIF}
-
- public
- { this method is called after constructor and initializes the object }
- procedure AfterConstruction; override;
-
- { upload texture data from given data object to video card
- @param aData texture data object that contains the actual data
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-
- { upload texture data from given data object to video card
- @param aData texture data object that contains the actual data
- @param aCubeTarget cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X)
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
-
- { bind texture
- @param aEnableTexCoordsGen enable cube map generator
- @param aEnableTextureUnit enable texture unit }
- procedure Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true{$ENDIF}); reintroduce; virtual;
-
- { unbind texture
- @param aDisableTexCoordsGen disable cube map generator
- @param aDisableTextureUnit disable texture unit }
- procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true{$ENDIF}); reintroduce; virtual;
- end;
-{$IFEND}
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- { wrapper class for cube normal maps
- all operations on a bitmap object must be done from the render thread }
- TglBitmapNormalMap = class(TglBitmapCubeMap)
- public
- { this method is called after constructor and initializes the object }
- procedure AfterConstruction; override;
-
- { create cube normal map from texture data and upload it to video card
- @param aSize size of each cube map texture
- @param aCheckSize check size before upload and throw exception if something is wrong }
- procedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);
- end;
-{$IFEND}
-
-const
- NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0);
-
-procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
-procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
-procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
-procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
-procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
-procedure glBitmapSetDefaultWrap(
- const S: Cardinal = GL_CLAMP_TO_EDGE;
- const T: Cardinal = GL_CLAMP_TO_EDGE;
- const R: Cardinal = GL_CLAMP_TO_EDGE);
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
-procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
-{$IFEND}
-
-function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
-function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
-function glBitmapGetDefaultMipmap: TglBitmapMipMap;
-function glBitmapGetDefaultFormat: TglBitmapFormat;
-procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
-procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
-{$IFEND}
-
-function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;
-function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
-function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
-function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
-function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
-function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
-function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
-
-function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
-
-{$IFDEF GLB_DELPHI}
-function CreateGrayPalette: HPALETTE;
-{$ENDIF}
-
-implementation
-
-uses
- Math, syncobjs, typinfo
- {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND};
-
-
-var
- glBitmapDefaultDeleteTextureOnFree: Boolean;
- glBitmapDefaultFreeDataAfterGenTextures: Boolean;
- glBitmapDefaultFormat: TglBitmapFormat;
- glBitmapDefaultMipmap: TglBitmapMipMap;
- glBitmapDefaultFilterMin: Cardinal;
- glBitmapDefaultFilterMag: Cardinal;
- glBitmapDefaultWrapS: Cardinal;
- glBitmapDefaultWrapT: Cardinal;
- glBitmapDefaultWrapR: Cardinal;
- glDefaultSwizzle: array[0..3] of GLenum;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-type
- TFormatDescriptor = class(TglBitmapFormatDescriptor)
- public
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
-
- function CreateMappingData: Pointer; virtual;
- procedure FreeMappingData(var aMappingData: Pointer); virtual;
-
- function IsEmpty: Boolean; virtual;
- function MaskMatch(const aMask: TglBitmapRec4ul): Boolean; virtual;
-
- procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
-
- constructor Create; virtual;
- public
- class procedure Init;
- class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
- class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
- class function GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer = 0): TFormatDescriptor;
- class function GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor;
- class procedure Clear;
- class procedure Finalize;
- end;
- TFormatDescriptorClass = class of TFormatDescriptor;
-
- TfdEmpty = class(TFormatDescriptor);
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdAlphaUB1 = class(TFormatDescriptor) //1* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdLuminanceUB1 = class(TFormatDescriptor) //1* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdUniversalUB1 = class(TFormatDescriptor) //1* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdLuminanceAlphaUB2 = class(TfdLuminanceUB1) //2* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdRGBub3 = class(TFormatDescriptor) //3* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdBGRub3 = class(TFormatDescriptor) //3* unsigned byte (inverse)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdRGBAub4 = class(TfdRGBub3) //3* unsigned byte
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdBGRAub4 = class(TfdBGRub3) //3* unsigned byte (inverse)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdAlphaUS1 = class(TFormatDescriptor) //1* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdLuminanceUS1 = class(TFormatDescriptor) //1* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdUniversalUS1 = class(TFormatDescriptor) //1* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdDepthUS1 = class(TFormatDescriptor) //1* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdLuminanceAlphaUS2 = class(TfdLuminanceUS1) //2* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdRGBus3 = class(TFormatDescriptor) //3* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdBGRus3 = class(TFormatDescriptor) //3* unsigned short (inverse)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdRGBAus4 = class(TfdRGBus3) //4* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdARGBus4 = class(TfdRGBus3) //4* unsigned short
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdBGRAus4 = class(TfdBGRus3) //4* unsigned short (inverse)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdABGRus4 = class(TfdBGRus3) //4* unsigned short (inverse)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdUniversalUI1 = class(TFormatDescriptor) //1* unsigned int
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
- TfdDepthUI1 = class(TFormatDescriptor) //1* unsigned int
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdAlpha4ub1 = class(TfdAlphaUB1)
- procedure SetValues; override;
- end;
-
- TfdAlpha8ub1 = class(TfdAlphaUB1)
- procedure SetValues; override;
- end;
-
- TfdAlpha16us1 = class(TfdAlphaUS1)
- procedure SetValues; override;
- end;
-
- TfdLuminance4ub1 = class(TfdLuminanceUB1)
- procedure SetValues; override;
- end;
-
- TfdLuminance8ub1 = class(TfdLuminanceUB1)
- procedure SetValues; override;
- end;
-
- TfdLuminance16us1 = class(TfdLuminanceUS1)
- procedure SetValues; override;
- end;
-
- TfdLuminance4Alpha4ub2 = class(TfdLuminanceAlphaUB2)
- procedure SetValues; override;
- end;
-
- TfdLuminance6Alpha2ub2 = class(TfdLuminanceAlphaUB2)
- procedure SetValues; override;
- end;
-
- TfdLuminance8Alpha8ub2 = class(TfdLuminanceAlphaUB2)
- procedure SetValues; override;
- end;
-
- TfdLuminance12Alpha4us2 = class(TfdLuminanceAlphaUS2)
- procedure SetValues; override;
- end;
-
- TfdLuminance16Alpha16us2 = class(TfdLuminanceAlphaUS2)
- procedure SetValues; override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdR3G3B2ub1 = class(TfdUniversalUB1)
- procedure SetValues; override;
- end;
-
- TfdRGBX4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdXRGB4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdR5G6B5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdRGB5X1us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdX1RGB5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdRGB8ub3 = class(TfdRGBub3)
- procedure SetValues; override;
- end;
-
- TfdRGBX8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdXRGB8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdRGB10X2ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdX2RGB10ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdRGB16us3 = class(TfdRGBus3)
- procedure SetValues; override;
- end;
-
- TfdRGBA4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdARGB4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdRGB5A1us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdA1RGB5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdRGBA8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdARGB8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdRGBA8ub4 = class(TfdRGBAub4)
- procedure SetValues; override;
- end;
-
- TfdRGB10A2ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdA2RGB10ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdRGBA16us4 = class(TfdRGBAus4)
- procedure SetValues; override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TfdBGRX4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdXBGR4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdB5G6R5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdBGR5X1us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdX1BGR5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdBGR8ub3 = class(TfdBGRub3)
- procedure SetValues; override;
- end;
-
- TfdBGRX8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdXBGR8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdBGR10X2ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdX2BGR10ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdBGR16us3 = class(TfdBGRus3)
- procedure SetValues; override;
- end;
-
- TfdBGRA4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdABGR4us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdBGR5A1us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdA1BGR5us1 = class(TfdUniversalUS1)
- procedure SetValues; override;
- end;
-
- TfdBGRA8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdABGR8ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdBGRA8ub4 = class(TfdBGRAub4)
- procedure SetValues; override;
- end;
-
- TfdBGR10A2ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdA2BGR10ui1 = class(TfdUniversalUI1)
- procedure SetValues; override;
- end;
-
- TfdBGRA16us4 = class(TfdBGRAus4)
- procedure SetValues; override;
- end;
-
- TfdDepth16us1 = class(TfdDepthUS1)
- procedure SetValues; override;
- end;
-
- TfdDepth24ui1 = class(TfdDepthUI1)
- procedure SetValues; override;
- end;
-
- TfdDepth32ui1 = class(TfdDepthUI1)
- procedure SetValues; override;
- end;
-
- TfdS3tcDtx1RGBA = class(TFormatDescriptor)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- procedure SetValues; override;
- end;
-
- TfdS3tcDtx3RGBA = class(TFormatDescriptor)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- procedure SetValues; override;
- end;
-
- TfdS3tcDtx5RGBA = class(TFormatDescriptor)
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- procedure SetValues; override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TbmpBitfieldFormat = class(TFormatDescriptor)
- public
- procedure SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul); overload;
- procedure SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- TbmpColorTableEnty = packed record
- b, g, r, a: Byte;
- end;
- TbmpColorTable = array of TbmpColorTableEnty;
- TbmpColorTableFormat = class(TFormatDescriptor)
- private
- fColorTable: TbmpColorTable;
- protected
- procedure SetValues; override;
- public
- property ColorTable: TbmpColorTable read fColorTable write fColorTable;
-
- procedure SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
- procedure CalcValues;
- procedure CreateColorTable;
-
- function CreateMappingData: Pointer; override;
- procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
- procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
- destructor Destroy; override;
- end;
-
-const
- LUMINANCE_WEIGHT_R = 0.30;
- LUMINANCE_WEIGHT_G = 0.59;
- LUMINANCE_WEIGHT_B = 0.11;
-
- ALPHA_WEIGHT_R = 0.30;
- ALPHA_WEIGHT_G = 0.59;
- ALPHA_WEIGHT_B = 0.11;
-
- DEPTH_WEIGHT_R = 0.333333333;
- DEPTH_WEIGHT_G = 0.333333333;
- DEPTH_WEIGHT_B = 0.333333333;
-
- FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
- TfdEmpty,
-
- TfdAlpha4ub1,
- TfdAlpha8ub1,
- TfdAlpha16us1,
-
- TfdLuminance4ub1,
- TfdLuminance8ub1,
- TfdLuminance16us1,
-
- TfdLuminance4Alpha4ub2,
- TfdLuminance6Alpha2ub2,
- TfdLuminance8Alpha8ub2,
- TfdLuminance12Alpha4us2,
- TfdLuminance16Alpha16us2,
-
- TfdR3G3B2ub1,
- TfdRGBX4us1,
- TfdXRGB4us1,
- TfdR5G6B5us1,
- TfdRGB5X1us1,
- TfdX1RGB5us1,
- TfdRGB8ub3,
- TfdRGBX8ui1,
- TfdXRGB8ui1,
- TfdRGB10X2ui1,
- TfdX2RGB10ui1,
- TfdRGB16us3,
-
- TfdRGBA4us1,
- TfdARGB4us1,
- TfdRGB5A1us1,
- TfdA1RGB5us1,
- TfdRGBA8ui1,
- TfdARGB8ui1,
- TfdRGBA8ub4,
- TfdRGB10A2ui1,
- TfdA2RGB10ui1,
- TfdRGBA16us4,
-
- TfdBGRX4us1,
- TfdXBGR4us1,
- TfdB5G6R5us1,
- TfdBGR5X1us1,
- TfdX1BGR5us1,
- TfdBGR8ub3,
- TfdBGRX8ui1,
- TfdXBGR8ui1,
- TfdBGR10X2ui1,
- TfdX2BGR10ui1,
- TfdBGR16us3,
-
- TfdBGRA4us1,
- TfdABGR4us1,
- TfdBGR5A1us1,
- TfdA1BGR5us1,
- TfdBGRA8ui1,
- TfdABGR8ui1,
- TfdBGRA8ub4,
- TfdBGR10A2ui1,
- TfdA2BGR10ui1,
- TfdBGRA16us4,
-
- TfdDepth16us1,
- TfdDepth24ui1,
- TfdDepth32ui1,
-
- TfdS3tcDtx1RGBA,
- TfdS3tcDtx3RGBA,
- TfdS3tcDtx5RGBA
- );
-
-var
- FormatDescriptorCS: TCriticalSection;
- FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
-begin
- inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat);
-begin
- inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapSize(X: Integer; Y: Integer): TglBitmapSize;
-begin
- result.Fields := [];
- if (X >= 0) then
- result.Fields := result.Fields + [ffX];
- if (Y >= 0) then
- result.Fields := result.Fields + [ffY];
- result.X := Max(0, X);
- result.Y := Max(0, Y);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition;
-begin
- result := glBitmapSize(X, Y);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
-begin
- result.r := r;
- result.g := g;
- result.b := b;
- result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
-begin
- result.r := r;
- result.g := g;
- result.b := b;
- result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
-begin
- result.r := r;
- result.g := g;
- result.b := b;
- result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
-var
- i: Integer;
-begin
- result := false;
- for i := 0 to high(r1.arr) do
- if (r1.arr[i] <> r2.arr[i]) then
- exit;
- result := true;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
-var
- i: Integer;
-begin
- result := false;
- for i := 0 to high(r1.arr) do
- if (r1.arr[i] <> r2.arr[i]) then
- exit;
- result := true;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
-var
- desc: TFormatDescriptor;
- p, tmp: PByte;
- x, y, i: Integer;
- md: Pointer;
- px: TglBitmapPixelData;
-begin
- result := nil;
- desc := TFormatDescriptor.Get(aFormat);
- if (desc.IsCompressed) or (desc.glFormat = 0) then
- exit;
-
- p := GetMemory(ceil(25 * desc.BytesPerPixel)); // 5 x 5 pixel
- md := desc.CreateMappingData;
- try
- tmp := p;
- desc.PreparePixel(px);
- for y := 0 to 4 do
- for x := 0 to 4 do begin
- px.Data := glBitmapRec4ui(0, 0, 0, 0);
- for i := 0 to 3 do begin
- if ((y < 3) and (y = i)) or
- ((y = 3) and (i < 3)) or
- ((y = 4) and (i = 3))
- then
- px.Data.arr[i] := Trunc(px.Range.arr[i] / 4 * x)
- else if ((y < 4) and (i = 3)) or
- ((y = 4) and (i < 3))
- then
- px.Data.arr[i] := px.Range.arr[i]
- else
- px.Data.arr[i] := 0; //px.Range.arr[i];
- end;
- desc.Map(px, tmp, md);
- end;
- finally
- desc.FreeMappingData(md);
- end;
-
- result := TglBitmapData.Create(glBitmapPosition(5, 5), aFormat, p);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapShiftRec(const r, g, b, a: Byte): TglBitmapRec4ub;
-begin
- result.r := r;
- result.g := g;
- result.b := b;
- result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
-begin
- result := [];
-
- if (aFormat in [
- //8bpp
- tfAlpha4ub1, tfAlpha8ub1,
- tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1,
-
- //16bpp
- tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
- tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1,
- tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1,
-
- //24bpp
- tfBGR8ub3, tfRGB8ub3,
-
- //32bpp
- tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1,
- tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1])
- then
- result := result + [ ftBMP ];
-
- if (aFormat in [
- //8bbp
- tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1,
-
- //16bbp
- tfAlpha16us1, tfLuminance16us1,
- tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
- tfX1RGB5us1, tfARGB4us1, tfA1RGB5us1, tfDepth16us1,
-
- //24bbp
- tfBGR8ub3,
-
- //32bbp
- tfX2RGB10ui1, tfARGB8ui1, tfBGRA8ub4, tfA2RGB10ui1,
- tfDepth24ui1, tfDepth32ui1])
- then
- result := result + [ftTGA];
-
- if not (aFormat in [tfEmpty, tfRGB16us3, tfBGR16us3]) then
- result := result + [ftDDS];
-
-{$IFDEF GLB_SUPPORT_PNG_WRITE}
- if aFormat in [
- tfAlpha8ub1, tfLuminance8ub1, tfLuminance8Alpha8ub2,
- tfRGB8ub3, tfRGBA8ui1,
- tfBGR8ub3, tfBGRA8ui1] then
- result := result + [ftPNG];
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_WRITE}
- if aFormat in [tfAlpha8ub1, tfLuminance8ub1, tfRGB8ub3, tfBGR8ub3] then
- result := result + [ftJPEG];
-{$ENDIF}
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function IsPowerOfTwo(aNumber: Integer): Boolean;
-begin
- while (aNumber and 1) = 0 do
- aNumber := aNumber shr 1;
- result := aNumber = 1;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function GetTopMostBit(aBitSet: QWord): Integer;
-begin
- result := 0;
- while aBitSet > 0 do begin
- inc(result);
- aBitSet := aBitSet shr 1;
- end;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function CountSetBits(aBitSet: QWord): Integer;
-begin
- result := 0;
- while aBitSet > 0 do begin
- if (aBitSet and 1) = 1 then
- inc(result);
- aBitSet := aBitSet shr 1;
- end;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function LuminanceWeight(const aPixel: TglBitmapPixelData): Cardinal;
-begin
- result := Trunc(
- LUMINANCE_WEIGHT_R * aPixel.Data.r +
- LUMINANCE_WEIGHT_G * aPixel.Data.g +
- LUMINANCE_WEIGHT_B * aPixel.Data.b);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
-begin
- result := Trunc(
- DEPTH_WEIGHT_R * aPixel.Data.r +
- DEPTH_WEIGHT_G * aPixel.Data.g +
- DEPTH_WEIGHT_B * aPixel.Data.b);
-end;
-
-{$IFDEF GLB_SDL_IMAGE}
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
-begin
- result := TStream(context^.unknown.data1).Seek(offset, whence);
-end;
-
-function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
-begin
- result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
-end;
-
-function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
-begin
- result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
-end;
-
-function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
-begin
- result := 0;
-end;
-
-function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
-begin
- result := SDL_AllocRW;
-
- if result = nil then
- raise EglBitmap.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
-
- result^.seek := glBitmapRWseek;
- result^.read := glBitmapRWread;
- result^.write := glBitmapRWwrite;
- result^.close := glBitmapRWclose;
- result^.unknown.data1 := Stream;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
-begin
- glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
-begin
- glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
-begin
- glBitmapDefaultMipmap := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
-begin
- glBitmapDefaultFormat := aFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
-begin
- glBitmapDefaultFilterMin := aMin;
- glBitmapDefaultFilterMag := aMag;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
-begin
- glBitmapDefaultWrapS := S;
- glBitmapDefaultWrapT := T;
- glBitmapDefaultWrapR := R;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
-procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
-begin
- glDefaultSwizzle[0] := r;
- glDefaultSwizzle[1] := g;
- glDefaultSwizzle[2] := b;
- glDefaultSwizzle[3] := a;
-end;
-{$IFEND}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
-begin
- result := glBitmapDefaultDeleteTextureOnFree;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
-begin
- result := glBitmapDefaultFreeDataAfterGenTextures;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultMipmap: TglBitmapMipMap;
-begin
- result := glBitmapDefaultMipmap;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultFormat: TglBitmapFormat;
-begin
- result := glBitmapDefaultFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
-begin
- aMin := glBitmapDefaultFilterMin;
- aMag := glBitmapDefaultFilterMag;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
-begin
- S := glBitmapDefaultWrapS;
- T := glBitmapDefaultWrapT;
- R := glBitmapDefaultWrapR;
-end;
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
-begin
- r := glDefaultSwizzle[0];
- g := glDefaultSwizzle[1];
- b := glDefaultSwizzle[2];
- a := glDefaultSwizzle[3];
-end;
-{$IFEND}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.CreateMappingData: Pointer;
-begin
- result := nil;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer);
-begin
- //DUMMY
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.IsEmpty: Boolean;
-begin
- result := (fFormat = tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.MaskMatch(const aMask: TglBitmapRec4ul): Boolean;
-var
- i: Integer;
- m: TglBitmapRec4ul;
-begin
- result := false;
- if (aMask.r = 0) and (aMask.g = 0) and (aMask.b = 0) and (aMask.a = 0) then
- raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
- m := Mask;
- for i := 0 to 3 do
- if (aMask.arr[i] <> m.arr[i]) then
- exit;
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData);
-begin
- FillChar(aPixel{%H-}, SizeOf(aPixel), 0);
- aPixel.Data := Range;
- aPixel.Format := fFormat;
- aPixel.Range := Range;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TFormatDescriptor.Create;
-begin
- inherited Create;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlphaUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- aData^ := aPixel.Data.a;
- inc(aData);
-end;
-
-procedure TfdAlphaUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := 0;
- aPixel.Data.g := 0;
- aPixel.Data.b := 0;
- aPixel.Data.a := aData^;
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- aData^ := LuminanceWeight(aPixel);
- inc(aData);
-end;
-
-procedure TfdLuminanceUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := aData^;
- aPixel.Data.g := aData^;
- aPixel.Data.b := aData^;
- aPixel.Data.a := 0;
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversalUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
- i: Integer;
-begin
- aData^ := 0;
- for i := 0 to 3 do
- if (Range.arr[i] > 0) then
- aData^ := aData^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
- inc(aData);
-end;
-
-procedure TfdUniversalUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
- i: Integer;
-begin
- for i := 0 to 3 do
- aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and Range.arr[i];
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceAlphaUB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- aData^ := aPixel.Data.a;
- inc(aData);
-end;
-
-procedure TfdLuminanceAlphaUB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := aData^;
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- aData^ := aPixel.Data.r;
- inc(aData);
- aData^ := aPixel.Data.g;
- inc(aData);
- aData^ := aPixel.Data.b;
- inc(aData);
-end;
-
-procedure TfdRGBub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := aData^;
- inc(aData);
- aPixel.Data.g := aData^;
- inc(aData);
- aPixel.Data.b := aData^;
- inc(aData);
- aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- aData^ := aPixel.Data.b;
- inc(aData);
- aData^ := aPixel.Data.g;
- inc(aData);
- aData^ := aPixel.Data.r;
- inc(aData);
-end;
-
-procedure TfdBGRub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.b := aData^;
- inc(aData);
- aPixel.Data.g := aData^;
- inc(aData);
- aPixel.Data.r := aData^;
- inc(aData);
- aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGBA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- aData^ := aPixel.Data.a;
- inc(aData);
-end;
-
-procedure TfdRGBAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := aData^;
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGRA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- aData^ := aPixel.Data.a;
- inc(aData);
-end;
-
-procedure TfdBGRAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := aData^;
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlphaUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
-end;
-
-procedure TfdAlphaUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := 0;
- aPixel.Data.g := 0;
- aPixel.Data.b := 0;
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := LuminanceWeight(aPixel);
- inc(aData, 2);
-end;
-
-procedure TfdLuminanceUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := PWord(aData)^;
- aPixel.Data.g := PWord(aData)^;
- aPixel.Data.b := PWord(aData)^;
- aPixel.Data.a := 0;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversalUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
- i: Integer;
-begin
- PWord(aData)^ := 0;
- for i := 0 to 3 do
- if (Range.arr[i] > 0) then
- PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
- inc(aData, 2);
-end;
-
-procedure TfdUniversalUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
- i: Integer;
-begin
- for i := 0 to 3 do
- aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and Range.arr[i];
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdDepthUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := DepthWeight(aPixel);
- inc(aData, 2);
-end;
-
-procedure TfdDepthUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := PWord(aData)^;
- aPixel.Data.g := PWord(aData)^;
- aPixel.Data.b := PWord(aData)^;
- aPixel.Data.a := PWord(aData)^;;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceAlphaUS2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
-end;
-
-procedure TfdLuminanceAlphaUS2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := aPixel.Data.r;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Data.g;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Data.b;
- inc(aData, 2);
-end;
-
-procedure TfdRGBus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.g := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.b := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := aPixel.Data.b;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Data.g;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Data.r;
- inc(aData, 2);
-end;
-
-procedure TfdBGRus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.b := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.g := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.r := PWord(aData)^;
- inc(aData, 2);
- aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
-end;
-
-procedure TfdRGBAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdARGBus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
- inherited Map(aPixel, aData, aMapData);
-end;
-
-procedure TfdARGBus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
- inherited Unmap(aData, aPixel, aMapData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- inherited Map(aPixel, aData, aMapData);
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
-end;
-
-procedure TfdBGRAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- inherited Unmap(aData, aPixel, aMapData);
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdABGRus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PWord(aData)^ := aPixel.Data.a;
- inc(aData, 2);
- inherited Map(aPixel, aData, aMapData);
-end;
-
-procedure TfdABGRus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.a := PWord(aData)^;
- inc(aData, 2);
- inherited Unmap(aData, aPixel, aMapData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversalUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
- i: Integer;
-begin
- PCardinal(aData)^ := 0;
- for i := 0 to 3 do
- if (Range.arr[i] > 0) then
- PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
- inc(aData, 4);
-end;
-
-procedure TfdUniversalUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
- i: Integer;
-begin
- for i := 0 to 3 do
- aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and Range.arr[i];
- inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdDepthUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- PCardinal(aData)^ := DepthWeight(aPixel);
- inc(aData, 4);
-end;
-
-procedure TfdDepthUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- aPixel.Data.r := PCardinal(aData)^;
- aPixel.Data.g := PCardinal(aData)^;
- aPixel.Data.b := PCardinal(aData)^;
- aPixel.Data.a := PCardinal(aData)^;
- inc(aData, 4);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlpha4ub1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 8;
- fFormat := tfAlpha4ub1;
- fWithAlpha := tfAlpha4ub1;
- fPrecision := glBitmapRec4ub(0, 0, 0, 8);
- fShift := glBitmapRec4ub(0, 0, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfAlpha4ub1;
- fglFormat := GL_ALPHA;
- fglInternalFormat := GL_ALPHA4;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfAlpha8ub1;
-{$ENDIF}
-end;
-
-procedure TfdAlpha8ub1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 8;
- fFormat := tfAlpha8ub1;
- fWithAlpha := tfAlpha8ub1;
- fPrecision := glBitmapRec4ub(0, 0, 0, 8);
- fShift := glBitmapRec4ub(0, 0, 0, 0);
- fOpenGLFormat := tfAlpha8ub1;
- fglFormat := GL_ALPHA;
- fglInternalFormat := {$IFNDEF OPENGL_ES}GL_ALPHA8{$ELSE}GL_ALPHA{$ENDIF};
- fglDataFormat := GL_UNSIGNED_BYTE;
-end;
-
-procedure TfdAlpha16us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfAlpha16us1;
- fWithAlpha := tfAlpha16us1;
- fPrecision := glBitmapRec4ub(0, 0, 0, 16);
- fShift := glBitmapRec4ub(0, 0, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfAlpha16us1;
- fglFormat := GL_ALPHA;
- fglInternalFormat := GL_ALPHA16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfAlpha8ub1;
-{$ENDIF}
-end;
-
-procedure TfdLuminance4ub1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 8;
- fFormat := tfLuminance4ub1;
- fWithAlpha := tfLuminance4Alpha4ub2;
- fWithoutAlpha := tfLuminance4ub1;
- fPrecision := glBitmapRec4ub(8, 8, 8, 0);
- fShift := glBitmapRec4ub(0, 0, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance4ub1;
- fglFormat := GL_LUMINANCE;
- fglInternalFormat := GL_LUMINANCE4;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfLuminance8ub1;
-{$ENDIF}
-end;
-
-procedure TfdLuminance8ub1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 8;
- fFormat := tfLuminance8ub1;
- fWithAlpha := tfLuminance8Alpha8ub2;
- fWithoutAlpha := tfLuminance8ub1;
- fOpenGLFormat := tfLuminance8ub1;
- fPrecision := glBitmapRec4ub(8, 8, 8, 0);
- fShift := glBitmapRec4ub(0, 0, 0, 0);
- fglFormat := GL_LUMINANCE;
- fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8{$ELSE}GL_LUMINANCE{$ENDIF};
- fglDataFormat := GL_UNSIGNED_BYTE;
-end;
-
-procedure TfdLuminance16us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfLuminance16us1;
- fWithAlpha := tfLuminance16Alpha16us2;
- fWithoutAlpha := tfLuminance16us1;
- fPrecision := glBitmapRec4ub(16, 16, 16, 0);
- fShift := glBitmapRec4ub( 0, 0, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance16us1;
- fglFormat := GL_LUMINANCE;
- fglInternalFormat := GL_LUMINANCE16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfLuminance8ub1;
-{$ENDIF}
-end;
-
-procedure TfdLuminance4Alpha4ub2.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfLuminance4Alpha4ub2;
- fWithAlpha := tfLuminance4Alpha4ub2;
- fWithoutAlpha := tfLuminance4ub1;
- fPrecision := glBitmapRec4ub(8, 8, 8, 8);
- fShift := glBitmapRec4ub(0, 0, 0, 8);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance4Alpha4ub2;
- fglFormat := GL_LUMINANCE_ALPHA;
- fglInternalFormat := GL_LUMINANCE4_ALPHA4;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfLuminance8Alpha8ub2;
-{$ENDIF}
-end;
-
-procedure TfdLuminance6Alpha2ub2.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfLuminance6Alpha2ub2;
- fWithAlpha := tfLuminance6Alpha2ub2;
- fWithoutAlpha := tfLuminance8ub1;
- fPrecision := glBitmapRec4ub(8, 8, 8, 8);
- fShift := glBitmapRec4ub(0, 0, 0, 8);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance6Alpha2ub2;
- fglFormat := GL_LUMINANCE_ALPHA;
- fglInternalFormat := GL_LUMINANCE6_ALPHA2;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfLuminance8Alpha8ub2;
-{$ENDIF}
-end;
-
-procedure TfdLuminance8Alpha8ub2.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfLuminance8Alpha8ub2;
- fWithAlpha := tfLuminance8Alpha8ub2;
- fWithoutAlpha := tfLuminance8ub1;
- fOpenGLFormat := tfLuminance8Alpha8ub2;
- fPrecision := glBitmapRec4ub(8, 8, 8, 8);
- fShift := glBitmapRec4ub(0, 0, 0, 8);
- fglFormat := GL_LUMINANCE_ALPHA;
- fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8_ALPHA8{$ELSE}GL_LUMINANCE_ALPHA{$ENDIF};
- fglDataFormat := GL_UNSIGNED_BYTE;
-end;
-
-procedure TfdLuminance12Alpha4us2.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfLuminance12Alpha4us2;
- fWithAlpha := tfLuminance12Alpha4us2;
- fWithoutAlpha := tfLuminance16us1;
- fPrecision := glBitmapRec4ub(16, 16, 16, 16);
- fShift := glBitmapRec4ub( 0, 0, 0, 16);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance12Alpha4us2;
- fglFormat := GL_LUMINANCE_ALPHA;
- fglInternalFormat := GL_LUMINANCE12_ALPHA4;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfLuminance8Alpha8ub2;
-{$ENDIF}
-end;
-
-procedure TfdLuminance16Alpha16us2.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfLuminance16Alpha16us2;
- fWithAlpha := tfLuminance16Alpha16us2;
- fWithoutAlpha := tfLuminance16us1;
- fPrecision := glBitmapRec4ub(16, 16, 16, 16);
- fShift := glBitmapRec4ub( 0, 0, 0, 16);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfLuminance16Alpha16us2;
- fglFormat := GL_LUMINANCE_ALPHA;
- fglInternalFormat := GL_LUMINANCE16_ALPHA16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfLuminance8Alpha8ub2;
-{$ENDIF}
-end;
-
-procedure TfdR3G3B2ub1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 8;
- fFormat := tfR3G3B2ub1;
- fWithAlpha := tfRGBA4us1;
- fWithoutAlpha := tfR3G3B2ub1;
- fRGBInverted := tfEmpty;
- fPrecision := glBitmapRec4ub(3, 3, 2, 0);
- fShift := glBitmapRec4ub(5, 2, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfR3G3B2ub1;
- fglFormat := GL_RGB;
- fglInternalFormat := GL_R3_G3_B2;
- fglDataFormat := GL_UNSIGNED_BYTE_3_3_2;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdRGBX4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfRGBX4us1;
- fWithAlpha := tfRGBA4us1;
- fWithoutAlpha := tfRGBX4us1;
- fRGBInverted := tfBGRX4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
- fShift := glBitmapRec4ub(12, 8, 4, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGBX4us1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdXRGB4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfXRGB4us1;
- fWithAlpha := tfARGB4us1;
- fWithoutAlpha := tfXRGB4us1;
- fRGBInverted := tfXBGR4us1;
- fPrecision := glBitmapRec4ub(4, 4, 4, 0);
- fShift := glBitmapRec4ub(8, 4, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfXRGB4us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdR5G6B5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfR5G6B5us1;
- fWithAlpha := tfRGB5A1us1;
- fWithoutAlpha := tfR5G6B5us1;
- fRGBInverted := tfB5G6R5us1;
- fPrecision := glBitmapRec4ub( 5, 6, 5, 0);
- fShift := glBitmapRec4ub(11, 5, 0, 0);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
- fOpenGLFormat := tfR5G6B5us1;
- fglFormat := GL_RGB;
- fglInternalFormat := GL_RGB565;
- fglDataFormat := GL_UNSIGNED_SHORT_5_6_5;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$IFEND}
-end;
-
-procedure TfdRGB5X1us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfRGB5X1us1;
- fWithAlpha := tfRGB5A1us1;
- fWithoutAlpha := tfRGB5X1us1;
- fRGBInverted := tfBGR5X1us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
- fShift := glBitmapRec4ub(11, 6, 1, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGB5X1us1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB5;
- fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdX1RGB5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfX1RGB5us1;
- fWithAlpha := tfA1RGB5us1;
- fWithoutAlpha := tfX1RGB5us1;
- fRGBInverted := tfX1BGR5us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
- fShift := glBitmapRec4ub(10, 5, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfX1RGB5us1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB5;
- fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdRGB8ub3.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 24;
- fFormat := tfRGB8ub3;
- fWithAlpha := tfRGBA8ub4;
- fWithoutAlpha := tfRGB8ub3;
- fRGBInverted := tfBGR8ub3;
- fPrecision := glBitmapRec4ub(8, 8, 8, 0);
- fShift := glBitmapRec4ub(0, 8, 16, 0);
- fOpenGLFormat := tfRGB8ub3;
- fglFormat := GL_RGB;
- fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGB8{$ELSE}GL_RGB{$IFEND};
- fglDataFormat := GL_UNSIGNED_BYTE;
-end;
-
-procedure TfdRGBX8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfRGBX8ui1;
- fWithAlpha := tfRGBA8ui1;
- fWithoutAlpha := tfRGBX8ui1;
- fRGBInverted := tfBGRX8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
- fShift := glBitmapRec4ub(24, 16, 8, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGBX8ui1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$ENDIF}
-end;
-
-procedure TfdXRGB8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfXRGB8ui1;
- fWithAlpha := tfXRGB8ui1;
- fWithoutAlpha := tfXRGB8ui1;
- fOpenGLFormat := tfXRGB8ui1;
- fRGBInverted := tfXBGR8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
- fShift := glBitmapRec4ub(16, 8, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfXRGB8ui1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$ENDIF}
-end;
-
-procedure TfdRGB10X2ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfRGB10X2ui1;
- fWithAlpha := tfRGB10A2ui1;
- fWithoutAlpha := tfRGB10X2ui1;
- fRGBInverted := tfBGR10X2ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 0);
- fShift := glBitmapRec4ub(22, 12, 2, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGB10X2ui1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB10;
- fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
-{$ELSE}
- fOpenGLFormat := tfRGB16us3;
-{$ENDIF}
-end;
-
-procedure TfdX2RGB10ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfX2RGB10ui1;
- fWithAlpha := tfA2RGB10ui1;
- fWithoutAlpha := tfX2RGB10ui1;
- fRGBInverted := tfX2BGR10ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 0);
- fShift := glBitmapRec4ub(20, 10, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfX2RGB10ui1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB10;
- fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB16us3;
-{$ENDIF}
-end;
-
-procedure TfdRGB16us3.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 48;
- fFormat := tfRGB16us3;
- fWithAlpha := tfRGBA16us4;
- fWithoutAlpha := tfRGB16us3;
- fRGBInverted := tfBGR16us3;
- fPrecision := glBitmapRec4ub(16, 16, 16, 0);
- fShift := glBitmapRec4ub( 0, 16, 32, 0);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- fOpenGLFormat := tfRGB16us3;
- fglFormat := GL_RGB;
- fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGB16{$ELSE}GL_RGB16UI{$ENDIF};
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$IFEND}
-end;
-
-procedure TfdRGBA4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfRGBA4us1;
- fWithAlpha := tfRGBA4us1;
- fWithoutAlpha := tfRGBX4us1;
- fOpenGLFormat := tfRGBA4us1;
- fRGBInverted := tfBGRA4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
- fShift := glBitmapRec4ub(12, 8, 4, 0);
- fglFormat := GL_RGBA;
- fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
-end;
-
-procedure TfdARGB4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfARGB4us1;
- fWithAlpha := tfARGB4us1;
- fWithoutAlpha := tfXRGB4us1;
- fRGBInverted := tfABGR4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
- fShift := glBitmapRec4ub( 8, 4, 0, 12);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfARGB4us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-{$ELSE}
- fOpenGLFormat := tfRGBA4us1;
-{$ENDIF}
-end;
-
-procedure TfdRGB5A1us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfRGB5A1us1;
- fWithAlpha := tfRGB5A1us1;
- fWithoutAlpha := tfRGB5X1us1;
- fOpenGLFormat := tfRGB5A1us1;
- fRGBInverted := tfBGR5A1us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
- fShift := glBitmapRec4ub(11, 6, 1, 0);
- fglFormat := GL_RGBA;
- fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}GL_RGB5_A1{$ELSE}GL_RGBA{$IFEND};
- fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
-end;
-
-procedure TfdA1RGB5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfA1RGB5us1;
- fWithAlpha := tfA1RGB5us1;
- fWithoutAlpha := tfX1RGB5us1;
- fRGBInverted := tfA1BGR5us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
- fShift := glBitmapRec4ub(10, 5, 0, 15);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfA1RGB5us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB5_A1;
- fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB5A1us1;
-{$ENDIF}
-end;
-
-procedure TfdRGBA8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfRGBA8ui1;
- fWithAlpha := tfRGBA8ui1;
- fWithoutAlpha := tfRGBX8ui1;
- fRGBInverted := tfBGRA8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub(24, 16, 8, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGBA8ui1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGBA8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4;
-{$ENDIF}
-end;
-
-procedure TfdARGB8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfARGB8ui1;
- fWithAlpha := tfARGB8ui1;
- fWithoutAlpha := tfXRGB8ui1;
- fRGBInverted := tfABGR8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub(16, 8, 0, 24);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfARGB8ui1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4;
-{$ENDIF}
-end;
-
-procedure TfdRGBA8ub4.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfRGBA8ub4;
- fWithAlpha := tfRGBA8ub4;
- fWithoutAlpha := tfRGB8ub3;
- fOpenGLFormat := tfRGBA8ub4;
- fRGBInverted := tfBGRA8ub4;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub( 0, 8, 16, 24);
- fglFormat := GL_RGBA;
- fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
- fglDataFormat := GL_UNSIGNED_BYTE;
-end;
-
-procedure TfdRGB10A2ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfRGB10A2ui1;
- fWithAlpha := tfRGB10A2ui1;
- fWithoutAlpha := tfRGB10X2ui1;
- fRGBInverted := tfBGR10A2ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 2);
- fShift := glBitmapRec4ub(22, 12, 2, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfRGB10A2ui1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGB10_A2;
- fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
-{$ELSE}
- fOpenGLFormat := tfA2RGB10ui1;
-{$ENDIF}
-end;
-
-procedure TfdA2RGB10ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfA2RGB10ui1;
- fWithAlpha := tfA2RGB10ui1;
- fWithoutAlpha := tfX2RGB10ui1;
- fRGBInverted := tfA2BGR10ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 2);
- fShift := glBitmapRec4ub(20, 10, 0, 30);
-{$IF NOT DEFINED(OPENGL_ES)}
- fOpenGLFormat := tfA2RGB10ui1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB10_A2;
- fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
-{$ELSEIF DEFINED(OPENGL_ES_3_0)}
- fOpenGLFormat := tfA2RGB10ui1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGB10_A2;
- fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ui1;
-{$IFEND}
-end;
-
-procedure TfdRGBA16us4.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 64;
- fFormat := tfRGBA16us4;
- fWithAlpha := tfRGBA16us4;
- fWithoutAlpha := tfRGB16us3;
- fRGBInverted := tfBGRA16us4;
- fPrecision := glBitmapRec4ub(16, 16, 16, 16);
- fShift := glBitmapRec4ub( 0, 16, 32, 48);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- fOpenGLFormat := tfRGBA16us4;
- fglFormat := GL_RGBA;
- fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGBA16{$ELSE}GL_RGBA16UI{$ENDIF};
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4;
-{$IFEND}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRX4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfBGRX4us1;
- fWithAlpha := tfBGRA4us1;
- fWithoutAlpha := tfBGRX4us1;
- fRGBInverted := tfRGBX4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
- fShift := glBitmapRec4ub( 4, 8, 12, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRX4us1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdXBGR4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfXBGR4us1;
- fWithAlpha := tfABGR4us1;
- fWithoutAlpha := tfXBGR4us1;
- fRGBInverted := tfXRGB4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
- fShift := glBitmapRec4ub( 0, 4, 8, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfXBGR4us1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdB5G6R5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfB5G6R5us1;
- fWithAlpha := tfBGR5A1us1;
- fWithoutAlpha := tfB5G6R5us1;
- fRGBInverted := tfR5G6B5us1;
- fPrecision := glBitmapRec4ub( 5, 6, 5, 0);
- fShift := glBitmapRec4ub( 0, 5, 11, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfB5G6R5us1;
- fglFormat := GL_RGB;
- fglInternalFormat := GL_RGB565;
- fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdBGR5X1us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfBGR5X1us1;
- fWithAlpha := tfBGR5A1us1;
- fWithoutAlpha := tfBGR5X1us1;
- fRGBInverted := tfRGB5X1us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
- fShift := glBitmapRec4ub( 1, 6, 11, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR5X1us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB5;
- fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdX1BGR5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfX1BGR5us1;
- fWithAlpha := tfA1BGR5us1;
- fWithoutAlpha := tfX1BGR5us1;
- fRGBInverted := tfX1RGB5us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
- fShift := glBitmapRec4ub( 0, 5, 10, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfX1BGR5us1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB5;
- fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-{$ELSE}
- fOpenGLFormat := tfR5G6B5us1;
-{$ENDIF}
-end;
-
-procedure TfdBGR8ub3.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 24;
- fFormat := tfBGR8ub3;
- fWithAlpha := tfBGRA8ub4;
- fWithoutAlpha := tfBGR8ub3;
- fRGBInverted := tfRGB8ub3;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
- fShift := glBitmapRec4ub(16, 8, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR8ub3;
- fglFormat := GL_BGR;
- fglInternalFormat := GL_RGB8;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$ENDIF}
-end;
-
-procedure TfdBGRX8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfBGRX8ui1;
- fWithAlpha := tfBGRA8ui1;
- fWithoutAlpha := tfBGRX8ui1;
- fRGBInverted := tfRGBX8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
- fShift := glBitmapRec4ub( 8, 16, 24, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRX8ui1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$ENDIF}
-end;
-
-procedure TfdXBGR8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfXBGR8ui1;
- fWithAlpha := tfABGR8ui1;
- fWithoutAlpha := tfXBGR8ui1;
- fRGBInverted := tfXRGB8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
- fShift := glBitmapRec4ub( 0, 8, 16, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfXBGR8ui1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB8ub3;
-{$ENDIF}
-end;
-
-procedure TfdBGR10X2ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfBGR10X2ui1;
- fWithAlpha := tfBGR10A2ui1;
- fWithoutAlpha := tfBGR10X2ui1;
- fRGBInverted := tfRGB10X2ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 0);
- fShift := glBitmapRec4ub( 2, 12, 22, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR10X2ui1;
- fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB10;
- fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
-{$ELSE}
- fOpenGLFormat := tfRGB16us3;
-{$ENDIF}
-end;
-
-procedure TfdX2BGR10ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfX2BGR10ui1;
- fWithAlpha := tfA2BGR10ui1;
- fWithoutAlpha := tfX2BGR10ui1;
- fRGBInverted := tfX2RGB10ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 0);
- fShift := glBitmapRec4ub( 0, 10, 20, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfX2BGR10ui1;
- fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
- fglInternalFormat := GL_RGB10;
- fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB16us3;
-{$ENDIF}
-end;
-
-procedure TfdBGR16us3.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 48;
- fFormat := tfBGR16us3;
- fWithAlpha := tfBGRA16us4;
- fWithoutAlpha := tfBGR16us3;
- fRGBInverted := tfRGB16us3;
- fPrecision := glBitmapRec4ub(16, 16, 16, 0);
- fShift := glBitmapRec4ub(32, 16, 0, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR16us3;
- fglFormat := GL_BGR;
- fglInternalFormat := GL_RGB16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfRGB16us3;
-{$ENDIF}
-end;
-
-procedure TfdBGRA4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfBGRA4us1;
- fWithAlpha := tfBGRA4us1;
- fWithoutAlpha := tfBGRX4us1;
- fRGBInverted := tfRGBA4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
- fShift := glBitmapRec4ub( 4, 8, 12, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRA4us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
-{$ELSE}
- fOpenGLFormat := tfRGBA4us1;
-{$ENDIF}
-end;
-
-procedure TfdABGR4us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfABGR4us1;
- fWithAlpha := tfABGR4us1;
- fWithoutAlpha := tfXBGR4us1;
- fRGBInverted := tfARGB4us1;
- fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
- fShift := glBitmapRec4ub( 0, 4, 8, 12);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfABGR4us1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGBA4;
- fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-{$ELSE}
- fOpenGLFormat := tfRGBA4us1;
-{$ENDIF}
-end;
-
-procedure TfdBGR5A1us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfBGR5A1us1;
- fWithAlpha := tfBGR5A1us1;
- fWithoutAlpha := tfBGR5X1us1;
- fRGBInverted := tfRGB5A1us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
- fShift := glBitmapRec4ub( 1, 6, 11, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR5A1us1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB5_A1;
- fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
-{$ELSE}
- fOpenGLFormat := tfRGB5A1us1;
-{$ENDIF}
-end;
-
-procedure TfdA1BGR5us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfA1BGR5us1;
- fWithAlpha := tfA1BGR5us1;
- fWithoutAlpha := tfX1BGR5us1;
- fRGBInverted := tfA1RGB5us1;
- fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
- fShift := glBitmapRec4ub( 0, 5, 10, 15);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfA1BGR5us1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGB5_A1;
- fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-{$ELSE}
- fOpenGLFormat := tfRGB5A1us1;
-{$ENDIF}
-end;
-
-procedure TfdBGRA8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfBGRA8ui1;
- fWithAlpha := tfBGRA8ui1;
- fWithoutAlpha := tfBGRX8ui1;
- fRGBInverted := tfRGBA8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub( 8, 16, 24, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRA8ui1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4;
-{$ENDIF}
-end;
-
-procedure TfdABGR8ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfABGR8ui1;
- fWithAlpha := tfABGR8ui1;
- fWithoutAlpha := tfXBGR8ui1;
- fRGBInverted := tfARGB8ui1;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub( 0, 8, 16, 24);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfABGR8ui1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGBA8;
- fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4
-{$ENDIF}
-end;
-
-procedure TfdBGRA8ub4.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfBGRA8ub4;
- fWithAlpha := tfBGRA8ub4;
- fWithoutAlpha := tfBGR8ub3;
- fRGBInverted := tfRGBA8ub4;
- fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
- fShift := glBitmapRec4ub(16, 8, 0, 24);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRA8ub4;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA8;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := tfRGBA8ub4;
-{$ENDIF}
-end;
-
-procedure TfdBGR10A2ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfBGR10A2ui1;
- fWithAlpha := tfBGR10A2ui1;
- fWithoutAlpha := tfBGR10X2ui1;
- fRGBInverted := tfRGB10A2ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 2);
- fShift := glBitmapRec4ub( 2, 12, 22, 0);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGR10A2ui1;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGB10_A2;
- fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
-{$ELSE}
- fOpenGLFormat := tfA2RGB10ui1;
-{$ENDIF}
-end;
-
-procedure TfdA2BGR10ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfA2BGR10ui1;
- fWithAlpha := tfA2BGR10ui1;
- fWithoutAlpha := tfX2BGR10ui1;
- fRGBInverted := tfA2RGB10ui1;
- fPrecision := glBitmapRec4ub(10, 10, 10, 2);
- fShift := glBitmapRec4ub( 0, 10, 20, 30);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfA2BGR10ui1;
- fglFormat := GL_RGBA;
- fglInternalFormat := GL_RGB10_A2;
- fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
-{$ELSE}
- fOpenGLFormat := tfA2RGB10ui1;
-{$ENDIF}
-end;
-
-procedure TfdBGRA16us4.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 64;
- fFormat := tfBGRA16us4;
- fWithAlpha := tfBGRA16us4;
- fWithoutAlpha := tfBGR16us3;
- fRGBInverted := tfRGBA16us4;
- fPrecision := glBitmapRec4ub(16, 16, 16, 16);
- fShift := glBitmapRec4ub(32, 16, 0, 48);
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfBGRA16us4;
- fglFormat := GL_BGRA;
- fglInternalFormat := GL_RGBA16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$ELSE}
- fOpenGLFormat := tfRGBA16us4;
-{$ENDIF}
-end;
-
-procedure TfdDepth16us1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 16;
- fFormat := tfDepth16us1;
- fWithoutAlpha := tfDepth16us1;
- fPrecision := glBitmapRec4ub(16, 16, 16, 16);
- fShift := glBitmapRec4ub( 0, 0, 0, 0);
-{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
- fOpenGLFormat := tfDepth16us1;
- fglFormat := GL_DEPTH_COMPONENT;
- fglInternalFormat := GL_DEPTH_COMPONENT16;
- fglDataFormat := GL_UNSIGNED_SHORT;
-{$IFEND}
-end;
-
-procedure TfdDepth24ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfDepth24ui1;
- fWithoutAlpha := tfDepth24ui1;
- fOpenGLFormat := tfDepth24ui1;
- fPrecision := glBitmapRec4ub(32, 32, 32, 32);
- fShift := glBitmapRec4ub( 0, 0, 0, 0);
-{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- fOpenGLFormat := tfDepth24ui1;
- fglFormat := GL_DEPTH_COMPONENT;
- fglInternalFormat := GL_DEPTH_COMPONENT24;
- fglDataFormat := GL_UNSIGNED_INT;
-{$IFEND}
-end;
-
-procedure TfdDepth32ui1.SetValues;
-begin
- inherited SetValues;
- fBitsPerPixel := 32;
- fFormat := tfDepth32ui1;
- fWithoutAlpha := tfDepth32ui1;
- fPrecision := glBitmapRec4ub(32, 32, 32, 32);
- fShift := glBitmapRec4ub( 0, 0, 0, 0);
-{$IF NOT DEFINED(OPENGL_ES)}
- fOpenGLFormat := tfDepth32ui1;
- fglFormat := GL_DEPTH_COMPONENT;
- fglInternalFormat := GL_DEPTH_COMPONENT32;
- fglDataFormat := GL_UNSIGNED_INT;
-{$ELSEIF DEFINED(OPENGL_ES_3_0)}
- fOpenGLFormat := tfDepth24ui1;
-{$ELSEIF DEFINED(OPENGL_ES_2_0)}
- fOpenGLFormat := tfDepth16us1;
-{$IFEND}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx1RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx1RGBA.SetValues;
-begin
- inherited SetValues;
- fFormat := tfS3tcDtx1RGBA;
- fWithAlpha := tfS3tcDtx1RGBA;
- fUncompressed := tfRGB5A1us1;
- fBitsPerPixel := 4;
- fIsCompressed := true;
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfS3tcDtx1RGBA;
- fglFormat := GL_COMPRESSED_RGBA;
- fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := fUncompressed;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx3RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx3RGBA.SetValues;
-begin
- inherited SetValues;
- fFormat := tfS3tcDtx3RGBA;
- fWithAlpha := tfS3tcDtx3RGBA;
- fUncompressed := tfRGBA8ub4;
- fBitsPerPixel := 8;
- fIsCompressed := true;
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfS3tcDtx3RGBA;
- fglFormat := GL_COMPRESSED_RGBA;
- fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := fUncompressed;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx5RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
- raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx5RGBA.SetValues;
-begin
- inherited SetValues;
- fFormat := tfS3tcDtx3RGBA;
- fWithAlpha := tfS3tcDtx3RGBA;
- fUncompressed := tfRGBA8ub4;
- fBitsPerPixel := 8;
- fIsCompressed := true;
-{$IFNDEF OPENGL_ES}
- fOpenGLFormat := tfS3tcDtx3RGBA;
- fglFormat := GL_COMPRESSED_RGBA;
- fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
- fglDataFormat := GL_UNSIGNED_BYTE;
-{$ELSE}
- fOpenGLFormat := fUncompressed;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapFormatDescriptor.GetHasRed: Boolean;
-begin
- result := (fPrecision.r > 0);
-end;
-
-function TglBitmapFormatDescriptor.GetHasGreen: Boolean;
-begin
- result := (fPrecision.g > 0);
-end;
-
-function TglBitmapFormatDescriptor.GetHasBlue: Boolean;
-begin
- result := (fPrecision.b > 0);
-end;
-
-function TglBitmapFormatDescriptor.GetHasAlpha: Boolean;
-begin
- result := (fPrecision.a > 0);
-end;
-
-function TglBitmapFormatDescriptor.GetHasColor: Boolean;
-begin
- result := HasRed or HasGreen or HasBlue;
-end;
-
-function TglBitmapFormatDescriptor.GetIsGrayscale: Boolean;
-begin
- result := (Mask.r = Mask.g) and (Mask.g = Mask.b) and (Mask.r > 0);
-end;
-
-function TglBitmapFormatDescriptor.GetHasOpenGLSupport: Boolean;
-begin
- result := (OpenGLFormat = Format);
-end;
-
-procedure TglBitmapFormatDescriptor.SetValues;
-begin
- fFormat := tfEmpty;
- fWithAlpha := tfEmpty;
- fWithoutAlpha := tfEmpty;
- fOpenGLFormat := tfEmpty;
- fRGBInverted := tfEmpty;
- fUncompressed := tfEmpty;
-
- fBitsPerPixel := 0;
- fIsCompressed := false;
-
- fglFormat := 0;
- fglInternalFormat := 0;
- fglDataFormat := 0;
-
- FillChar(fPrecision, 0, SizeOf(fPrecision));
- FillChar(fShift, 0, SizeOf(fShift));
-end;
-
-procedure TglBitmapFormatDescriptor.CalcValues;
-var
- i: Integer;
-begin
- fBytesPerPixel := fBitsPerPixel / 8;
- fChannelCount := 0;
- for i := 0 to 3 do begin
- if (fPrecision.arr[i] > 0) then
- inc(fChannelCount);
- fRange.arr[i] := (1 shl fPrecision.arr[i]) - 1;
- fMask.arr[i] := fRange.arr[i] shl fShift.arr[i];
- end;
-end;
-
-function TglBitmapFormatDescriptor.GetSize(const aSize: TglBitmapSize): Integer;
-var
- w, h: Integer;
-begin
- if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin
- w := Max(1, aSize.X);
- h := Max(1, aSize.Y);
- result := GetSize(w, h);
- end else
- result := 0;
-end;
-
-function TglBitmapFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer;
-begin
- result := 0;
- if (aWidth <= 0) or (aHeight <= 0) then
- exit;
- result := Ceil(aWidth * aHeight * BytesPerPixel);
-end;
-
-constructor TglBitmapFormatDescriptor.Create;
-begin
- inherited Create;
- SetValues;
- CalcValues;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
-var
- f: TglBitmapFormat;
-begin
- for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin
- result := TFormatDescriptor.Get(f);
- if (result.glInternalFormat = aInternalFormat) then
- exit;
- end;
- result := TFormatDescriptor.Get(tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Init;
-begin
- if not Assigned(FormatDescriptorCS) then
- FormatDescriptorCS := TCriticalSection.Create;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
-begin
- FormatDescriptorCS.Enter;
- try
- result := FormatDescriptors[aFormat];
- if not Assigned(result) then begin
- result := FORMAT_DESCRIPTOR_CLASSES[aFormat].Create;
- FormatDescriptors[aFormat] := result;
- end;
- finally
- FormatDescriptorCS.Leave;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
-begin
- result := Get(Get(aFormat).WithAlpha);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer): TFormatDescriptor;
-var
- ft: TglBitmapFormat;
-begin
- // find matching format with OpenGL support
- for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
- result := Get(ft);
- if (result.MaskMatch(aMask)) and
- (result.glFormat <> 0) and
- (result.glInternalFormat <> 0) and
- ((aBitCount = 0) or (aBitCount = result.BitsPerPixel))
- then
- exit;
- end;
-
- // find matching format without OpenGL Support
- for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
- result := Get(ft);
- if result.MaskMatch(aMask) and ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then
- exit;
- end;
-
- result := TFormatDescriptor.Get(tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor;
-var
- ft: TglBitmapFormat;
-begin
- // find matching format with OpenGL support
- for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
- result := Get(ft);
- if glBitmapRec4ubCompare(result.Shift, aShift) and
- glBitmapRec4ubCompare(result.Precision, aPrec) and
- (result.glFormat <> 0) and
- (result.glInternalFormat <> 0) and
- ((aBitCount = 0) or (aBitCount = result.BitsPerPixel))
- then
- exit;
- end;
-
- // find matching format without OpenGL Support
- for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
- result := Get(ft);
- if glBitmapRec4ubCompare(result.Shift, aShift) and
- glBitmapRec4ubCompare(result.Precision, aPrec) and
- ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then
- exit;
- end;
-
- result := TFormatDescriptor.Get(tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Clear;
-var
- f: TglBitmapFormat;
-begin
- FormatDescriptorCS.Enter;
- try
- for f := low(FormatDescriptors) to high(FormatDescriptors) do
- FreeAndNil(FormatDescriptors[f]);
- finally
- FormatDescriptorCS.Leave;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Finalize;
-begin
- Clear;
- FreeAndNil(FormatDescriptorCS);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul);
-var
- i: Integer;
-begin
- for i := 0 to 3 do begin
- fShift.arr[i] := 0;
- while (aMask.arr[i] > 0) and ((aMask.arr[i] and 1) = 0) do begin
- aMask.arr[i] := aMask.arr[i] shr 1;
- inc(fShift.arr[i]);
- end;
- fPrecision.arr[i] := CountSetBits(aMask.arr[i]);
- end;
- fBitsPerPixel := aBPP;
- CalcValues;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub);
-begin
- fBitsPerPixel := aBBP;
- fPrecision := aPrec;
- fShift := aShift;
- CalcValues;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
- data: QWord;
-begin
- data :=
- ((aPixel.Data.r and Range.r) shl Shift.r) or
- ((aPixel.Data.g and Range.g) shl Shift.g) or
- ((aPixel.Data.b and Range.b) shl Shift.b) or
- ((aPixel.Data.a and Range.a) shl Shift.a);
- case BitsPerPixel of
- 8: aData^ := data;
- 16: PWord(aData)^ := data;
- 32: PCardinal(aData)^ := data;
- 64: PQWord(aData)^ := data;
- else
- raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]);
- end;
- inc(aData, Round(BytesPerPixel));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
- data: QWord;
- i: Integer;
-begin
- case BitsPerPixel of
- 8: data := aData^;
- 16: data := PWord(aData)^;
- 32: data := PCardinal(aData)^;
- 64: data := PQWord(aData)^;
- else
- raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]);
- end;
- for i := 0 to 3 do
- aPixel.Data.arr[i] := (data shr fShift.arr[i]) and Range.arr[i];
- inc(aData, Round(BytesPerPixel));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TColorTableFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.SetValues;
-begin
- inherited SetValues;
- fShift := glBitmapRec4ub(8, 8, 8, 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub);
-begin
- fFormat := aFormat;
- fBitsPerPixel := aBPP;
- fPrecision := aPrec;
- fShift := aShift;
- CalcValues;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.CalcValues;
-begin
- inherited CalcValues;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.CreateColorTable;
-var
- i: Integer;
-begin
- SetLength(fColorTable, 256);
- if not HasColor then begin
- // alpha
- for i := 0 to High(fColorTable) do begin
- fColorTable[i].r := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
- fColorTable[i].g := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
- fColorTable[i].b := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
- fColorTable[i].a := 0;
- end;
- end else begin
- // normal
- for i := 0 to High(fColorTable) do begin
- fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255);
- fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255);
- fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255);
- fColorTable[i].a := 0;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TbmpColorTableFormat.CreateMappingData: Pointer;
-begin
- result := Pointer(0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
- if (BitsPerPixel <> 8) then
- raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats');
- if not HasColor then
- // alpha
- aData^ := aPixel.Data.a
- else
- // normal
- aData^ := Round(
- ((aPixel.Data.r shr Shift.r) and Range.r) * LUMINANCE_WEIGHT_R +
- ((aPixel.Data.g shr Shift.g) and Range.g) * LUMINANCE_WEIGHT_G +
- ((aPixel.Data.b shr Shift.b) and Range.b) * LUMINANCE_WEIGHT_B);
- inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-
- function ReadValue: Byte;
- var
- i: PtrUInt;
- begin
- if (BitsPerPixel = 8) then begin
- result := aData^;
- inc(aData);
- end else begin
- i := {%H-}PtrUInt(aMapData);
- if (BitsPerPixel > 1) then
- result := (aData^ shr i) and ((1 shl BitsPerPixel) - 1)
- else
- result := (aData^ shr (7-i)) and ((1 shl BitsPerPixel) - 1);
- inc(i, BitsPerPixel);
- while (i >= 8) do begin
- inc(aData);
- dec(i, 8);
- end;
- aMapData := {%H-}Pointer(i);
- end;
- end;
-
-begin
- if (BitsPerPixel > 8) then
- raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats');
- with fColorTable[ReadValue] do begin
- aPixel.Data.r := r;
- aPixel.Data.g := g;
- aPixel.Data.b := b;
- aPixel.Data.a := a;
- end;
-end;
-
-destructor TbmpColorTableFormat.Destroy;
-begin
- SetLength(fColorTable, 0);
- inherited Destroy;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - Helper//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertPixel(var aPixel: TglBitmapPixelData; const aSourceFD, aDestFD: TFormatDescriptor);
-var
- i: Integer;
-begin
- for i := 0 to 3 do begin
- if (aSourceFD.Range.arr[i] <> aDestFD.Range.arr[i]) then begin
- if (aSourceFD.Range.arr[i] > 0) then
- aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i])
- else
- aPixel.Data.arr[i] := 0;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertCopyFunc(var aFuncRec: TglBitmapFunctionRec);
-begin
- with aFuncRec do begin
- if (Source.Range.r > 0) then
- Dest.Data.r := Source.Data.r;
- if (Source.Range.g > 0) then
- Dest.Data.g := Source.Data.g;
- if (Source.Range.b > 0) then
- Dest.Data.b := Source.Data.b;
- if (Source.Range.a > 0) then
- Dest.Data.a := Source.Data.a;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertCalculateRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
-var
- i: Integer;
-begin
- with aFuncRec do begin
- for i := 0 to 3 do
- if (Source.Range.arr[i] > 0) then
- Dest.Data.arr[i] := Round(Dest.Range.arr[i] * Source.Data.arr[i] / Source.Range.arr[i]);
- end;
-end;
-
-type
- TShiftData = packed record
- case Integer of
- 0: (r, g, b, a: SmallInt);
- 1: (arr: array[0..3] of SmallInt);
- end;
- PShiftData = ^TShiftData;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertShiftRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
-var
- i: Integer;
-begin
- with aFuncRec do
- for i := 0 to 3 do
- if (Source.Range.arr[i] > 0) then
- Dest.Data.arr[i] := Source.Data.arr[i] shr PShiftData(Args)^.arr[i];
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec);
-var
- i: Integer;
-begin
- with aFuncRec do begin
- Dest.Data := Source.Data;
- for i := 0 to 3 do
- if ({%H-}PtrUInt(Args) and (1 shl i) > 0) then
- Dest.Data.arr[i] := Dest.Data.arr[i] xor Dest.Range.arr[i];
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapFillWithColorFunc(var aFuncRec: TglBitmapFunctionRec);
-var
- i: Integer;
-begin
- with aFuncRec do begin
- for i := 0 to 3 do
- Dest.Data.arr[i] := PglBitmapPixelData(Args)^.Data.arr[i];
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-var
- Temp: Single;
-begin
- with FuncRec do begin
- if (FuncRec.Args = nil) then begin //source has no alpha
- Temp :=
- Source.Data.r / Source.Range.r * ALPHA_WEIGHT_R +
- Source.Data.g / Source.Range.g * ALPHA_WEIGHT_G +
- Source.Data.b / Source.Range.b * ALPHA_WEIGHT_B;
- Dest.Data.a := Round(Dest.Range.a * Temp);
- end else
- Dest.Data.a := Round(Source.Data.a / Source.Range.a * Dest.Range.a);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapColorKeyAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-type
- PglBitmapPixelData = ^TglBitmapPixelData;
-begin
- with FuncRec do begin
- Dest.Data.r := Source.Data.r;
- Dest.Data.g := Source.Data.g;
- Dest.Data.b := Source.Data.b;
-
- with PglBitmapPixelData(Args)^ do
- if ((Dest.Data.r <= Data.r) and (Dest.Data.r >= Range.r) and
- (Dest.Data.g <= Data.g) and (Dest.Data.g >= Range.g) and
- (Dest.Data.b <= Data.b) and (Dest.Data.b >= Range.b)) then
- Dest.Data.a := 0
- else
- Dest.Data.a := Dest.Range.a;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapValueAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-begin
- with FuncRec do begin
- Dest.Data.r := Source.Data.r;
- Dest.Data.g := Source.Data.g;
- Dest.Data.b := Source.Data.b;
- Dest.Data.a := PCardinal(Args)^;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure SwapRGB(aData: PByte; aWidth: Integer; const aHasAlpha: Boolean);
-type
- PRGBPix = ^TRGBPix;
- TRGBPix = array [0..2] of byte;
-var
- Temp: Byte;
-begin
- while aWidth > 0 do begin
- Temp := PRGBPix(aData)^[0];
- PRGBPix(aData)^[0] := PRGBPix(aData)^[2];
- PRGBPix(aData)^[2] := Temp;
-
- if aHasAlpha then
- Inc(aData, 4)
- else
- Inc(aData, 3);
- dec(aWidth);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapData///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.GetFormatDescriptor: TglBitmapFormatDescriptor;
-begin
- result := TFormatDescriptor.Get(fFormat);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.GetWidth: Integer;
-begin
- if (ffX in fDimension.Fields) then
- result := fDimension.X
- else
- result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.GetHeight: Integer;
-begin
- if (ffY in fDimension.Fields) then
- result := fDimension.Y
- else
- result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.GetScanlines(const aIndex: Integer): PByte;
-begin
- if fHasScanlines and (aIndex >= Low(fScanlines)) and (aIndex <= High(fScanlines)) then
- result := fScanlines[aIndex]
- else
- result := nil;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SetFormat(const aValue: TglBitmapFormat);
-begin
- if fFormat = aValue then
- exit;
- if TFormatDescriptor.Get(Format).BitsPerPixel <> TFormatDescriptor.Get(aValue).BitsPerPixel then
- raise EglBitmapUnsupportedFormat.Create(Format);
- SetData(fData, aValue, Width, Height);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.PrepareResType(var aResource: String; var aResType: PChar);
-var
- TempPos: Integer;
-begin
- if not Assigned(aResType) then begin
- TempPos := Pos('.', aResource);
- aResType := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos)));
- aResource := UpperCase(Copy(aResource, 0, TempPos -1));
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.UpdateScanlines;
-var
- w, h, i, LineWidth: Integer;
-begin
- w := Width;
- h := Height;
- fHasScanlines := Assigned(fData) and (w > 0) and (h > 0);
- if fHasScanlines then begin
- SetLength(fScanlines, h);
- LineWidth := Trunc(w * FormatDescriptor.BytesPerPixel);
- for i := 0 to h-1 do begin
- fScanlines[i] := fData;
- Inc(fScanlines[i], i * LineWidth);
- end;
- end else
- SetLength(fScanlines, 0);
-end;
-
-{$IFDEF GLB_SUPPORT_PNG_READ}
-{$IF DEFINED(GLB_LAZ_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//PNG/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
-const
- MAGIC_LEN = 8;
- PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A;
-var
- reader: TLazReaderPNG;
- intf: TLazIntfImage;
- StreamPos: Int64;
- magic: String[MAGIC_LEN];
-begin
- result := true;
- StreamPos := aStream.Position;
-
- SetLength(magic, MAGIC_LEN);
- aStream.Read(magic[1], MAGIC_LEN);
- aStream.Position := StreamPos;
- if (magic <> PNG_MAGIC) then begin
- result := false;
- exit;
- end;
-
- intf := TLazIntfImage.Create(0, 0);
- reader := TLazReaderPNG.Create;
- try try
- reader.UpdateDescription := true;
- reader.ImageRead(aStream, intf);
- AssignFromLazIntfImage(intf);
- except
- result := false;
- aStream.Position := StreamPos;
- exit;
- end;
- finally
- reader.Free;
- intf.Free;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
-var
- Surface: PSDL_Surface;
- RWops: PSDL_RWops;
-begin
- result := false;
- RWops := glBitmapCreateRWops(aStream);
- try
- if IMG_isPNG(RWops) > 0 then begin
- Surface := IMG_LoadPNG_RW(RWops);
- try
- AssignFromSurface(Surface);
- result := true;
- finally
- SDL_FreeSurface(Surface);
- end;
- end;
- finally
- SDL_FreeRW(RWops);
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
-begin
- TStream(png_get_io_ptr(png)).Read(buffer^, size);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
-var
- StreamPos: Int64;
- signature: array [0..7] of byte;
- png: png_structp;
- png_info: png_infop;
-
- TempHeight, TempWidth: Integer;
- Format: TglBitmapFormat;
-
- png_data: pByte;
- png_rows: array of pByte;
- Row, LineSize: Integer;
-begin
- result := false;
-
- if not init_libPNG then
- raise Exception.Create('LoadPNG - unable to initialize libPNG.');
-
- try
- // signature
- StreamPos := aStream.Position;
- aStream.Read(signature{%H-}, 8);
- aStream.Position := StreamPos;
-
- if png_check_sig(@signature, 8) <> 0 then begin
- // png read struct
- png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
- if png = nil then
- raise EglBitmapException.Create('LoadPng - couldn''t create read struct.');
-
- // png info
- png_info := png_create_info_struct(png);
- if png_info = nil then begin
- png_destroy_read_struct(@png, nil, nil);
- raise EglBitmapException.Create('LoadPng - couldn''t create info struct.');
- end;
-
- // set read callback
- png_set_read_fn(png, aStream, glBitmap_libPNG_read_func);
-
- // read informations
- png_read_info(png, png_info);
-
- // size
- TempHeight := png_get_image_height(png, png_info);
- TempWidth := png_get_image_width(png, png_info);
-
- // format
- case png_get_color_type(png, png_info) of
- PNG_COLOR_TYPE_GRAY:
- Format := tfLuminance8ub1;
- PNG_COLOR_TYPE_GRAY_ALPHA:
- Format := tfLuminance8Alpha8us1;
- PNG_COLOR_TYPE_RGB:
- Format := tfRGB8ub3;
- PNG_COLOR_TYPE_RGB_ALPHA:
- Format := tfRGBA8ub4;
- else
- raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
- end;
-
- // cut upper 8 bit from 16 bit formats
- if png_get_bit_depth(png, png_info) > 8 then
- png_set_strip_16(png);
-
- // expand bitdepth smaller than 8
- if png_get_bit_depth(png, png_info) < 8 then
- png_set_expand(png);
-
- // allocating mem for scanlines
- LineSize := png_get_rowbytes(png, png_info);
- GetMem(png_data, TempHeight * LineSize);
- try
- SetLength(png_rows, TempHeight);
- for Row := Low(png_rows) to High(png_rows) do begin
- png_rows[Row] := png_data;
- Inc(png_rows[Row], Row * LineSize);
- end;
-
- // read complete image into scanlines
- png_read_image(png, @png_rows[0]);
-
- // read end
- png_read_end(png, png_info);
-
- // destroy read struct
- png_destroy_read_struct(@png, @png_info, nil);
-
- SetLength(png_rows, 0);
-
- // set new data
- SetData(png_data, Format, TempWidth, TempHeight);
-
- result := true;
- except
- if Assigned(png_data) then
- FreeMem(png_data);
- raise;
- end;
- end;
- finally
- quit_libPNG;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_PNGIMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
-var
- StreamPos: Int64;
- Png: TPNGObject;
- Header: String[8];
- Row, Col, PixSize, LineSize: Integer;
- NewImage, pSource, pDest, pAlpha: pByte;
- PngFormat: TglBitmapFormat;
- FormatDesc: TFormatDescriptor;
-
-const
- PngHeader: String[8] = #137#80#78#71#13#10#26#10;
-
-begin
- result := false;
-
- StreamPos := aStream.Position;
- aStream.Read(Header[0], SizeOf(Header));
- aStream.Position := StreamPos;
-
- {Test if the header matches}
- if Header = PngHeader then begin
- Png := TPNGObject.Create;
- try
- Png.LoadFromStream(aStream);
-
- case Png.Header.ColorType of
- COLOR_GRAYSCALE:
- PngFormat := tfLuminance8ub1;
- COLOR_GRAYSCALEALPHA:
- PngFormat := tfLuminance8Alpha8us1;
- COLOR_RGB:
- PngFormat := tfBGR8ub3;
- COLOR_RGBALPHA:
- PngFormat := tfBGRA8ub4;
- else
- raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
- end;
-
- FormatDesc := TFormatDescriptor.Get(PngFormat);
- PixSize := Round(FormatDesc.PixelSize);
- LineSize := FormatDesc.GetSize(Png.Header.Width, 1);
-
- GetMem(NewImage, LineSize * Integer(Png.Header.Height));
- try
- pDest := NewImage;
-
- case Png.Header.ColorType of
- COLOR_RGB, COLOR_GRAYSCALE:
- begin
- for Row := 0 to Png.Height -1 do begin
- Move (Png.Scanline[Row]^, pDest^, LineSize);
- Inc(pDest, LineSize);
- end;
- end;
- COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA:
- begin
- PixSize := PixSize -1;
-
- for Row := 0 to Png.Height -1 do begin
- pSource := Png.Scanline[Row];
- pAlpha := pByte(Png.AlphaScanline[Row]);
-
- for Col := 0 to Png.Width -1 do begin
- Move (pSource^, pDest^, PixSize);
- Inc(pSource, PixSize);
- Inc(pDest, PixSize);
-
- pDest^ := pAlpha^;
- inc(pAlpha);
- Inc(pDest);
- end;
- end;
- end;
- else
- raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
- end;
-
- SetData(NewImage, PngFormat, Png.Header.Width, Png.Header.Height);
-
- result := true;
- except
- if Assigned(NewImage) then
- FreeMem(NewImage);
- raise;
- end;
- finally
- Png.Free;
- end;
- end;
-end;
-{$IFEND}
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_PNG_WRITE}
-{$IFDEF GLB_LIB_PNG}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
-begin
- TStream(png_get_io_ptr(png)).Write(buffer^, size);
-end;
-{$ENDIF}
-
-{$IF DEFINED(GLB_LAZ_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SavePNG(const aStream: TStream);
-var
- png: TPortableNetworkGraphic;
- intf: TLazIntfImage;
- raw: TRawImage;
-begin
- png := TPortableNetworkGraphic.Create;
- intf := TLazIntfImage.Create(0, 0);
- try
- if not AssignToLazIntfImage(intf) then
- raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
- intf.GetRawImage(raw);
- png.LoadFromRawImage(raw, false);
- png.SaveToStream(aStream);
- finally
- png.Free;
- intf.Free;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SavePNG(const aStream: TStream);
-var
- png: png_structp;
- png_info: png_infop;
- png_rows: array of pByte;
- LineSize: Integer;
- ColorType: Integer;
- Row: Integer;
- FormatDesc: TFormatDescriptor;
-begin
- if not (ftPNG in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- if not init_libPNG then
- raise Exception.Create('unable to initialize libPNG.');
-
- try
- case Format of
- tfAlpha8ub1, tfLuminance8ub1:
- ColorType := PNG_COLOR_TYPE_GRAY;
- tfLuminance8Alpha8us1:
- ColorType := PNG_COLOR_TYPE_GRAY_ALPHA;
- tfBGR8ub3, tfRGB8ub3:
- ColorType := PNG_COLOR_TYPE_RGB;
- tfBGRA8ub4, tfRGBA8ub4:
- ColorType := PNG_COLOR_TYPE_RGBA;
- else
- raise EglBitmapUnsupportedFormat.Create(Format);
- end;
-
- FormatDesc := TFormatDescriptor.Get(Format);
- LineSize := FormatDesc.GetSize(Width, 1);
-
- // creating array for scanline
- SetLength(png_rows, Height);
- try
- for Row := 0 to Height - 1 do begin
- png_rows[Row] := Data;
- Inc(png_rows[Row], Row * LineSize)
- end;
-
- // write struct
- png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
- if png = nil then
- raise EglBitmapException.Create('SavePng - couldn''t create write struct.');
-
- // create png info
- png_info := png_create_info_struct(png);
- if png_info = nil then begin
- png_destroy_write_struct(@png, nil);
- raise EglBitmapException.Create('SavePng - couldn''t create info struct.');
- end;
-
- // set read callback
- png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil);
-
- // set compression
- png_set_compression_level(png, 6);
-
- if Format in [tfBGR8ub3, tfBGRA8ub4] then
- png_set_bgr(png);
-
- png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
- png_write_info(png, png_info);
- png_write_image(png, @png_rows[0]);
- png_write_end(png, png_info);
- png_destroy_write_struct(@png, @png_info);
- finally
- SetLength(png_rows, 0);
- end;
- finally
- quit_libPNG;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_PNGIMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SavePNG(const aStream: TStream);
-var
- Png: TPNGObject;
-
- pSource, pDest: pByte;
- X, Y, PixSize: Integer;
- ColorType: Cardinal;
- Alpha: Boolean;
-
- pTemp: pByte;
- Temp: Byte;
-begin
- if not (ftPNG in FormatGetSupportedFiles (Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- case Format of
- tfAlpha8ub1, tfLuminance8ub1: begin
- ColorType := COLOR_GRAYSCALE;
- PixSize := 1;
- Alpha := false;
- end;
- tfLuminance8Alpha8us1: begin
- ColorType := COLOR_GRAYSCALEALPHA;
- PixSize := 1;
- Alpha := true;
- end;
- tfBGR8ub3, tfRGB8ub3: begin
- ColorType := COLOR_RGB;
- PixSize := 3;
- Alpha := false;
- end;
- tfBGRA8ub4, tfRGBA8ub4: begin
- ColorType := COLOR_RGBALPHA;
- PixSize := 3;
- Alpha := true
- end;
- else
- raise EglBitmapUnsupportedFormat.Create(Format);
- end;
-
- Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height);
- try
- // Copy ImageData
- pSource := Data;
- for Y := 0 to Height -1 do begin
- pDest := png.ScanLine[Y];
- for X := 0 to Width -1 do begin
- Move(pSource^, pDest^, PixSize);
- Inc(pDest, PixSize);
- Inc(pSource, PixSize);
- if Alpha then begin
- png.AlphaScanline[Y]^[X] := pSource^;
- Inc(pSource);
- end;
- end;
-
- // convert RGB line to BGR
- if Format in [tfRGB8ub3, tfRGBA8ub4] then begin
- pTemp := png.ScanLine[Y];
- for X := 0 to Width -1 do begin
- Temp := pByteArray(pTemp)^[0];
- pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2];
- pByteArray(pTemp)^[2] := Temp;
- Inc(pTemp, 3);
- end;
- end;
- end;
-
- // Save to Stream
- Png.CompressionLevel := 6;
- Png.SaveToStream(aStream);
- finally
- FreeAndNil(Png);
- end;
-end;
-{$IFEND}
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//JPEG////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{$IFDEF GLB_LIB_JPEG}
-type
- glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr;
- glBitmap_libJPEG_source_mgr = record
- pub: jpeg_source_mgr;
-
- SrcStream: TStream;
- SrcBuffer: array [1..4096] of byte;
- end;
-
- glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr;
- glBitmap_libJPEG_dest_mgr = record
- pub: jpeg_destination_mgr;
-
- DestStream: TStream;
- DestBuffer: array [1..4096] of byte;
- end;
-
-procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
-begin
- //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
-begin
- //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
-begin
- //DUMMY
-end;
-
-procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
-begin
- //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
-begin
- //DUMMY
-end;
-
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
-var
- src: glBitmap_libJPEG_source_mgr_ptr;
- bytes: integer;
-begin
- src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
-
- bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096);
- if (bytes <= 0) then begin
- src^.SrcBuffer[1] := $FF;
- src^.SrcBuffer[2] := JPEG_EOI;
- bytes := 2;
- end;
-
- src^.pub.next_input_byte := @(src^.SrcBuffer[1]);
- src^.pub.bytes_in_buffer := bytes;
-
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl;
-var
- src: glBitmap_libJPEG_source_mgr_ptr;
-begin
- src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
-
- if num_bytes > 0 then begin
- // wanted byte isn't in buffer so set stream position and read buffer
- if num_bytes > src^.pub.bytes_in_buffer then begin
- src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer;
- src^.pub.fill_input_buffer(cinfo);
- end else begin
- // wanted byte is in buffer so only skip
- inc(src^.pub.next_input_byte, num_bytes);
- dec(src^.pub.bytes_in_buffer, num_bytes);
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
-var
- dest: glBitmap_libJPEG_dest_mgr_ptr;
-begin
- dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
-
- if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin
- // write complete buffer
- dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer));
-
- // reset buffer
- dest^.pub.next_output_byte := @dest^.DestBuffer[1];
- dest^.pub.free_in_buffer := Length(dest^.DestBuffer);
- end;
-
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl;
-var
- Idx: Integer;
- dest: glBitmap_libJPEG_dest_mgr_ptr;
-begin
- dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
-
- for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin
- // check for endblock
- if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin
- // write endblock
- dest^.DestStream.Write(dest^.DestBuffer[Idx], 2);
-
- // leave
- break;
- end else
- dest^.DestStream.Write(dest^.DestBuffer[Idx], 1);
- end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_READ}
-{$IF DEFINED(GLB_LAZ_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
-const
- MAGIC_LEN = 2;
- JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8;
-var
- intf: TLazIntfImage;
- reader: TFPReaderJPEG;
- StreamPos: Int64;
- magic: String[MAGIC_LEN];
-begin
- result := true;
- StreamPos := aStream.Position;
-
- SetLength(magic, MAGIC_LEN);
- aStream.Read(magic[1], MAGIC_LEN);
- aStream.Position := StreamPos;
- if (magic <> JPEG_MAGIC) then begin
- result := false;
- exit;
- end;
-
- reader := TFPReaderJPEG.Create;
- intf := TLazIntfImage.Create(0, 0);
- try try
- intf.DataDescription := GetDescriptionFromDevice(0, 0, 0);
- reader.ImageRead(aStream, intf);
- AssignFromLazIntfImage(intf);
- except
- result := false;
- aStream.Position := StreamPos;
- exit;
- end;
- finally
- reader.Free;
- intf.Free;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
-var
- Surface: PSDL_Surface;
- RWops: PSDL_RWops;
-begin
- result := false;
-
- RWops := glBitmapCreateRWops(aStream);
- try
- if IMG_isJPG(RWops) > 0 then begin
- Surface := IMG_LoadJPG_RW(RWops);
- try
- AssignFromSurface(Surface);
- result := true;
- finally
- SDL_FreeSurface(Surface);
- end;
- end;
- finally
- SDL_FreeRW(RWops);
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
-var
- StreamPos: Int64;
- Temp: array[0..1]of Byte;
-
- jpeg: jpeg_decompress_struct;
- jpeg_err: jpeg_error_mgr;
-
- IntFormat: TglBitmapFormat;
- pImage: pByte;
- TempHeight, TempWidth: Integer;
-
- pTemp: pByte;
- Row: Integer;
-
- FormatDesc: TFormatDescriptor;
-begin
- result := false;
-
- if not init_libJPEG then
- raise Exception.Create('LoadJPG - unable to initialize libJPEG.');
-
- try
- // reading first two bytes to test file and set cursor back to begin
- StreamPos := aStream.Position;
- aStream.Read({%H-}Temp[0], 2);
- aStream.Position := StreamPos;
-
- // if Bitmap then read file.
- if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
- FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00);
- FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
-
- // error managment
- jpeg.err := jpeg_std_error(@jpeg_err);
- jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
- jpeg_err.output_message := glBitmap_libJPEG_output_message;
-
- // decompression struct
- jpeg_create_decompress(@jpeg);
-
- // allocation space for streaming methods
- jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr));
-
- // seeting up custom functions
- with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin
- pub.init_source := glBitmap_libJPEG_init_source;
- pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer;
- pub.skip_input_data := glBitmap_libJPEG_skip_input_data;
- pub.resync_to_restart := jpeg_resync_to_restart; // use default method
- pub.term_source := glBitmap_libJPEG_term_source;
-
- pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read
- pub.next_input_byte := nil; // until buffer loaded
-
- SrcStream := aStream;
- end;
-
- // set global decoding state
- jpeg.global_state := DSTATE_START;
-
- // read header of jpeg
- jpeg_read_header(@jpeg, false);
-
- // setting output parameter
- case jpeg.jpeg_color_space of
- JCS_GRAYSCALE:
- begin
- jpeg.out_color_space := JCS_GRAYSCALE;
- IntFormat := tfLuminance8ub1;
- end;
- else
- jpeg.out_color_space := JCS_RGB;
- IntFormat := tfRGB8ub3;
- end;
-
- // reading image
- jpeg_start_decompress(@jpeg);
-
- TempHeight := jpeg.output_height;
- TempWidth := jpeg.output_width;
-
- FormatDesc := TFormatDescriptor.Get(IntFormat);
-
- // creating new image
- GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight));
- try
- pTemp := pImage;
-
- for Row := 0 to TempHeight -1 do begin
- jpeg_read_scanlines(@jpeg, @pTemp, 1);
- Inc(pTemp, FormatDesc.GetSize(TempWidth, 1));
- end;
-
- // finish decompression
- jpeg_finish_decompress(@jpeg);
-
- // destroy decompression
- jpeg_destroy_decompress(@jpeg);
-
- SetData(pImage, IntFormat, TempWidth, TempHeight);
-
- result := true;
- except
- if Assigned(pImage) then
- FreeMem(pImage);
- raise;
- end;
- end;
- finally
- quit_libJPEG;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
-var
- bmp: TBitmap;
- jpg: TJPEGImage;
- StreamPos: Int64;
- Temp: array[0..1]of Byte;
-begin
- result := false;
-
- // reading first two bytes to test file and set cursor back to begin
- StreamPos := aStream.Position;
- aStream.Read(Temp[0], 2);
- aStream.Position := StreamPos;
-
- // if Bitmap then read file.
- if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
- bmp := TBitmap.Create;
- try
- jpg := TJPEGImage.Create;
- try
- jpg.LoadFromStream(aStream);
- bmp.Assign(jpg);
- result := AssignFromBitmap(bmp);
- finally
- jpg.Free;
- end;
- finally
- bmp.Free;
- end;
- end;
-end;
-{$IFEND}
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_WRITE}
-{$IF DEFINED(GLB_LAZ_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveJPEG(const aStream: TStream);
-var
- jpeg: TJPEGImage;
- intf: TLazIntfImage;
- raw: TRawImage;
-begin
- jpeg := TJPEGImage.Create;
- intf := TLazIntfImage.Create(0, 0);
- try
- if not AssignToLazIntfImage(intf) then
- raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
- intf.GetRawImage(raw);
- jpeg.LoadFromRawImage(raw, false);
- jpeg.SaveToStream(aStream);
- finally
- intf.Free;
- jpeg.Free;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveJPEG(const aStream: TStream);
-var
- jpeg: jpeg_compress_struct;
- jpeg_err: jpeg_error_mgr;
- Row: Integer;
- pTemp, pTemp2: pByte;
-
- procedure CopyRow(pDest, pSource: pByte);
- var
- X: Integer;
- begin
- for X := 0 to Width - 1 do begin
- pByteArray(pDest)^[0] := pByteArray(pSource)^[2];
- pByteArray(pDest)^[1] := pByteArray(pSource)^[1];
- pByteArray(pDest)^[2] := pByteArray(pSource)^[0];
- Inc(pDest, 3);
- Inc(pSource, 3);
- end;
- end;
-
-begin
- if not (ftJPEG in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- if not init_libJPEG then
- raise Exception.Create('SaveJPG - unable to initialize libJPEG.');
-
- try
- FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00);
- FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
-
- // error managment
- jpeg.err := jpeg_std_error(@jpeg_err);
- jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
- jpeg_err.output_message := glBitmap_libJPEG_output_message;
-
- // compression struct
- jpeg_create_compress(@jpeg);
-
- // allocation space for streaming methods
- jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr));
-
- // seeting up custom functions
- with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin
- pub.init_destination := glBitmap_libJPEG_init_destination;
- pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer;
- pub.term_destination := glBitmap_libJPEG_term_destination;
-
- pub.next_output_byte := @DestBuffer[1];
- pub.free_in_buffer := Length(DestBuffer);
-
- DestStream := aStream;
- end;
-
- // very important state
- jpeg.global_state := CSTATE_START;
- jpeg.image_width := Width;
- jpeg.image_height := Height;
- case Format of
- tfAlpha8ub1, tfLuminance8ub1: begin
- jpeg.input_components := 1;
- jpeg.in_color_space := JCS_GRAYSCALE;
- end;
- tfRGB8ub3, tfBGR8ub3: begin
- jpeg.input_components := 3;
- jpeg.in_color_space := JCS_RGB;
- end;
- end;
-
- jpeg_set_defaults(@jpeg);
- jpeg_set_quality(@jpeg, 95, true);
- jpeg_start_compress(@jpeg, true);
- pTemp := Data;
-
- if Format = tfBGR8ub3 then
- GetMem(pTemp2, fRowSize)
- else
- pTemp2 := pTemp;
-
- try
- for Row := 0 to jpeg.image_height -1 do begin
- // prepare row
- if Format = tfBGR8ub3 then
- CopyRow(pTemp2, pTemp)
- else
- pTemp2 := pTemp;
-
- // write row
- jpeg_write_scanlines(@jpeg, @pTemp2, 1);
- inc(pTemp, fRowSize);
- end;
- finally
- // free memory
- if Format = tfBGR8ub3 then
- FreeMem(pTemp2);
- end;
- jpeg_finish_compress(@jpeg);
- jpeg_destroy_compress(@jpeg);
- finally
- quit_libJPEG;
- end;
-end;
-
-{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveJPEG(const aStream: TStream);
-var
- Bmp: TBitmap;
- Jpg: TJPEGImage;
-begin
- if not (ftJPEG in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- Bmp := TBitmap.Create;
- try
- Jpg := TJPEGImage.Create;
- try
- AssignToBitmap(Bmp);
- if (Format in [tfAlpha8ub1, tfLuminance8ub1]) then begin
- Jpg.Grayscale := true;
- Jpg.PixelFormat := jf8Bit;
- end;
- Jpg.Assign(Bmp);
- Jpg.SaveToStream(aStream);
- finally
- FreeAndNil(Jpg);
- end;
- finally
- FreeAndNil(Bmp);
- end;
-end;
-{$IFEND}
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//RAW/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
- RawHeader = packed record
- Magic: String[5];
- Version: Byte;
- Width: Integer;
- Height: Integer;
- DataSize: Integer;
- BitsPerPixel: Integer;
- Precision: TglBitmapRec4ub;
- Shift: TglBitmapRec4ub;
- end;
-
-function TglBitmapData.LoadRAW(const aStream: TStream): Boolean;
-var
- header: RawHeader;
- StartPos: Int64;
- fd: TFormatDescriptor;
- buf: PByte;
-begin
- result := false;
- StartPos := aStream.Position;
- aStream.Read(header{%H-}, SizeOf(header));
- if (header.Magic <> 'glBMP') then begin
- aStream.Position := StartPos;
- exit;
- end;
-
- fd := TFormatDescriptor.GetFromPrecShift(header.Precision, header.Shift, header.BitsPerPixel);
- if (fd.Format = tfEmpty) then
- raise EglBitmapUnsupportedFormat.Create('no supported format found');
-
- buf := GetMemory(header.DataSize);
- aStream.Read(buf^, header.DataSize);
- SetData(buf, fd.Format, header.Width, header.Height);
-
- result := true;
-end;
-
-procedure TglBitmapData.SaveRAW(const aStream: TStream);
-var
- header: RawHeader;
- fd: TFormatDescriptor;
-begin
- fd := TFormatDescriptor.Get(Format);
- header.Magic := 'glBMP';
- header.Version := 1;
- header.Width := Width;
- header.Height := Height;
- header.DataSize := fd.GetSize(fDimension);
- header.BitsPerPixel := fd.BitsPerPixel;
- header.Precision := fd.Precision;
- header.Shift := fd.Shift;
- aStream.Write(header, SizeOf(header));
- aStream.Write(Data^, header.DataSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//BMP/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const
- BMP_MAGIC = $4D42;
-
- BMP_COMP_RGB = 0;
- BMP_COMP_RLE8 = 1;
- BMP_COMP_RLE4 = 2;
- BMP_COMP_BITFIELDS = 3;
-
-type
- TBMPHeader = packed record
- bfType: Word;
- bfSize: Cardinal;
- bfReserved1: Word;
- bfReserved2: Word;
- bfOffBits: Cardinal;
- end;
-
- TBMPInfo = packed record
- biSize: Cardinal;
- biWidth: Longint;
- biHeight: Longint;
- biPlanes: Word;
- biBitCount: Word;
- biCompression: Cardinal;
- biSizeImage: Cardinal;
- biXPelsPerMeter: Longint;
- biYPelsPerMeter: Longint;
- biClrUsed: Cardinal;
- biClrImportant: Cardinal;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadBMP(const aStream: TStream): Boolean;
-
- //////////////////////////////////////////////////////////////////////////////////////////////////
- function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat;
- var
- tmp, i: Cardinal;
- begin
- result := tfEmpty;
- aStream.Read(aInfo{%H-}, SizeOf(aInfo));
- FillChar(aMask{%H-}, SizeOf(aMask), 0);
-
- //Read Compression
- case aInfo.biCompression of
- BMP_COMP_RLE4,
- BMP_COMP_RLE8: begin
- raise EglBitmap.Create('RLE compression is not supported');
- end;
- BMP_COMP_BITFIELDS: begin
- if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
- for i := 0 to 2 do begin
- aStream.Read(tmp{%H-}, SizeOf(tmp));
- aMask.arr[i] := tmp;
- end;
- end else
- raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
- end;
- end;
-
- //get suitable format
- case aInfo.biBitCount of
- 8: result := tfLuminance8ub1;
- 16: result := tfX1RGB5us1;
- 24: result := tfBGR8ub3;
- 32: result := tfXRGB8ui1;
- end;
- end;
-
- function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat;
- var
- i, c: Integer;
- fd: TFormatDescriptor;
- ColorTable: TbmpColorTable;
- begin
- result := nil;
- if (aInfo.biBitCount >= 16) then
- exit;
- aFormat := tfLuminance8ub1;
- c := aInfo.biClrUsed;
- if (c = 0) then
- c := 1 shl aInfo.biBitCount;
- SetLength(ColorTable, c);
- for i := 0 to c-1 do begin
- aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty));
- if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then
- aFormat := tfRGB8ub3;
- end;
-
- fd := TFormatDescriptor.Get(aFormat);
- result := TbmpColorTableFormat.Create;
- result.ColorTable := ColorTable;
- result.SetCustomValues(aFormat, aInfo.biBitCount, fd.Precision, fd.Shift);
- end;
-
- //////////////////////////////////////////////////////////////////////////////////////////////////
- function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat;
- var
- fd: TFormatDescriptor;
- begin
- result := nil;
- if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin
-
- // find suitable format ...
- fd := TFormatDescriptor.GetFromMask(aMask);
- if (fd.Format <> tfEmpty) then begin
- aFormat := fd.Format;
- exit;
- end;
-
- // or create custom bitfield format
- result := TbmpBitfieldFormat.Create;
- result.SetCustomValues(aInfo.biBitCount, aMask);
- end;
- end;
-
-var
- //simple types
- StartPos: Int64;
- ImageSize, rbLineSize, wbLineSize, Padding, i: Integer;
- PaddingBuff: Cardinal;
- LineBuf, ImageData, TmpData: PByte;
- SourceMD, DestMD: Pointer;
- BmpFormat: TglBitmapFormat;
-
- //records
- Mask: TglBitmapRec4ul;
- Header: TBMPHeader;
- Info: TBMPInfo;
-
- //classes
- SpecialFormat: TFormatDescriptor;
- FormatDesc: TFormatDescriptor;
-
- //////////////////////////////////////////////////////////////////////////////////////////////////
- procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte);
- var
- i: Integer;
- Pixel: TglBitmapPixelData;
- begin
- aStream.Read(aLineBuf^, rbLineSize);
- SpecialFormat.PreparePixel(Pixel);
- for i := 0 to Info.biWidth-1 do begin
- SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD);
- glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc);
- FormatDesc.Map(Pixel, aData, DestMD);
- end;
- end;
-
-begin
- result := false;
- BmpFormat := tfEmpty;
- SpecialFormat := nil;
- LineBuf := nil;
- SourceMD := nil;
- DestMD := nil;
-
- // Header
- StartPos := aStream.Position;
- aStream.Read(Header{%H-}, SizeOf(Header));
-
- if Header.bfType = BMP_MAGIC then begin
- try try
- BmpFormat := ReadInfo(Info, Mask);
- SpecialFormat := ReadColorTable(BmpFormat, Info);
- if not Assigned(SpecialFormat) then
- SpecialFormat := CheckBitfields(BmpFormat, Mask, Info);
- aStream.Position := StartPos + Header.bfOffBits;
-
- if (BmpFormat <> tfEmpty) then begin
- FormatDesc := TFormatDescriptor.Get(BmpFormat);
- rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize
- wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel);
- Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize;
-
- //get Memory
- DestMD := FormatDesc.CreateMappingData;
- ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight));
- GetMem(ImageData, ImageSize);
- if Assigned(SpecialFormat) then begin
- GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields
- SourceMD := SpecialFormat.CreateMappingData;
- end;
-
- //read Data
- try try
- FillChar(ImageData^, ImageSize, $FF);
- TmpData := ImageData;
- if (Info.biHeight > 0) then
- Inc(TmpData, wbLineSize * (Info.biHeight-1));
- for i := 0 to Abs(Info.biHeight)-1 do begin
- if Assigned(SpecialFormat) then
- SpecialFormatReadLine(TmpData, LineBuf) //if is special format read and convert data
- else
- aStream.Read(TmpData^, wbLineSize); //else only read data
- if (Info.biHeight > 0) then
- dec(TmpData, wbLineSize)
- else
- inc(TmpData, wbLineSize);
- aStream.Read(PaddingBuff{%H-}, Padding);
- end;
- SetData(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight));
- result := true;
- finally
- if Assigned(LineBuf) then
- FreeMem(LineBuf);
- if Assigned(SourceMD) then
- SpecialFormat.FreeMappingData(SourceMD);
- FormatDesc.FreeMappingData(DestMD);
- end;
- except
- if Assigned(ImageData) then
- FreeMem(ImageData);
- raise;
- end;
- end else
- raise EglBitmap.Create('LoadBMP - No suitable format found');
- except
- aStream.Position := StartPos;
- raise;
- end;
- finally
- FreeAndNil(SpecialFormat);
- end;
- end
- else aStream.Position := StartPos;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveBMP(const aStream: TStream);
-var
- Header: TBMPHeader;
- Info: TBMPInfo;
- Converter: TFormatDescriptor;
- FormatDesc: TFormatDescriptor;
- SourceFD, DestFD: Pointer;
- pData, srcData, dstData, ConvertBuffer: pByte;
-
- Pixel: TglBitmapPixelData;
- ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer;
- RedMask, GreenMask, BlueMask, AlphaMask: Cardinal;
-
- PaddingBuff: Cardinal;
-
- function GetLineWidth : Integer;
- begin
- result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3;
- end;
-
-begin
- if not (ftBMP in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- Converter := nil;
- FormatDesc := TFormatDescriptor.Get(Format);
- ImageSize := FormatDesc.GetSize(Dimension);
-
- FillChar(Header{%H-}, SizeOf(Header), 0);
- Header.bfType := BMP_MAGIC;
- Header.bfSize := SizeOf(Header) + SizeOf(Info) + ImageSize;
- Header.bfReserved1 := 0;
- Header.bfReserved2 := 0;
- Header.bfOffBits := SizeOf(Header) + SizeOf(Info);
-
- FillChar(Info{%H-}, SizeOf(Info), 0);
- Info.biSize := SizeOf(Info);
- Info.biWidth := Width;
- Info.biHeight := Height;
- Info.biPlanes := 1;
- Info.biCompression := BMP_COMP_RGB;
- Info.biSizeImage := ImageSize;
-
- try
- case Format of
- tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1:
- begin
- Info.biBitCount := 8;
- Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal);
- Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries
- Converter := TbmpColorTableFormat.Create;
- with (Converter as TbmpColorTableFormat) do begin
- SetCustomValues(fFormat, 8, FormatDesc.Precision, FormatDesc.Shift);
- CreateColorTable;
- end;
- end;
-
- tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
- tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1,
- tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1:
- begin
- Info.biBitCount := 16;
- Info.biCompression := BMP_COMP_BITFIELDS;
- end;
-
- tfBGR8ub3, tfRGB8ub3:
- begin
- Info.biBitCount := 24;
- if (Format = tfRGB8ub3) then
- Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values
- end;
-
- tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1,
- tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1:
- begin
- Info.biBitCount := 32;
- Info.biCompression := BMP_COMP_BITFIELDS;
- end;
- else
- raise EglBitmapUnsupportedFormat.Create(Format);
- end;
- Info.biXPelsPerMeter := 2835;
- Info.biYPelsPerMeter := 2835;
-
- // prepare bitmasks
- if Info.biCompression = BMP_COMP_BITFIELDS then begin
- Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal);
- Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal);
-
- RedMask := FormatDesc.Mask.r;
- GreenMask := FormatDesc.Mask.g;
- BlueMask := FormatDesc.Mask.b;
- AlphaMask := FormatDesc.Mask.a;
- end;
-
- // headers
- aStream.Write(Header, SizeOf(Header));
- aStream.Write(Info, SizeOf(Info));
-
- // colortable
- if Assigned(Converter) and (Converter is TbmpColorTableFormat) then
- with (Converter as TbmpColorTableFormat) do
- aStream.Write(ColorTable[0].b,
- SizeOf(TbmpColorTableEnty) * Length(ColorTable));
-
- // bitmasks
- if Info.biCompression = BMP_COMP_BITFIELDS then begin
- aStream.Write(RedMask, SizeOf(Cardinal));
- aStream.Write(GreenMask, SizeOf(Cardinal));
- aStream.Write(BlueMask, SizeOf(Cardinal));
- aStream.Write(AlphaMask, SizeOf(Cardinal));
- end;
-
- // image data
- rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel);
- wbLineSize := Round(Info.biWidth * Info.biBitCount / 8);
- Padding := GetLineWidth - wbLineSize;
- PaddingBuff := 0;
-
- pData := Data;
- inc(pData, (Height-1) * rbLineSize);
-
- // prepare row buffer. But only for RGB because RGBA supports color masks
- // so it's possible to change color within the image.
- if Assigned(Converter) then begin
- FormatDesc.PreparePixel(Pixel);
- GetMem(ConvertBuffer, wbLineSize);
- SourceFD := FormatDesc.CreateMappingData;
- DestFD := Converter.CreateMappingData;
- end else
- ConvertBuffer := nil;
-
- try
- for LineIdx := 0 to Height - 1 do begin
- // preparing row
- if Assigned(Converter) then begin
- srcData := pData;
- dstData := ConvertBuffer;
- for PixelIdx := 0 to Info.biWidth-1 do begin
- FormatDesc.Unmap(srcData, Pixel, SourceFD);
- glBitmapConvertPixel(Pixel, FormatDesc, Converter);
- Converter.Map(Pixel, dstData, DestFD);
- end;
- aStream.Write(ConvertBuffer^, wbLineSize);
- end else begin
- aStream.Write(pData^, rbLineSize);
- end;
- dec(pData, rbLineSize);
- if (Padding > 0) then
- aStream.Write(PaddingBuff, Padding);
- end;
- finally
- // destroy row buffer
- if Assigned(ConvertBuffer) then begin
- FormatDesc.FreeMappingData(SourceFD);
- Converter.FreeMappingData(DestFD);
- FreeMem(ConvertBuffer);
- end;
- end;
- finally
- if Assigned(Converter) then
- Converter.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TGA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
- TTGAHeader = packed record
- ImageID: Byte;
- ColorMapType: Byte;
- ImageType: Byte;
- //ColorMapSpec: Array[0..4] of Byte;
- ColorMapStart: Word;
- ColorMapLength: Word;
- ColorMapEntrySize: Byte;
- OrigX: Word;
- OrigY: Word;
- Width: Word;
- Height: Word;
- Bpp: Byte;
- ImageDesc: Byte;
- end;
-
-const
- TGA_UNCOMPRESSED_RGB = 2;
- TGA_UNCOMPRESSED_GRAY = 3;
- TGA_COMPRESSED_RGB = 10;
- TGA_COMPRESSED_GRAY = 11;
-
- TGA_NONE_COLOR_TABLE = 0;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadTGA(const aStream: TStream): Boolean;
-var
- Header: TTGAHeader;
- ImageData: System.PByte;
- StartPosition: Int64;
- PixelSize, LineSize: Integer;
- tgaFormat: TglBitmapFormat;
- FormatDesc: TFormatDescriptor;
- Counter: packed record
- X, Y: packed record
- low, high, dir: Integer;
- end;
- end;
-
-const
- CACHE_SIZE = $4000;
-
- ////////////////////////////////////////////////////////////////////////////////////////
- procedure ReadUncompressed;
- var
- i, j: Integer;
- buf, tmp1, tmp2: System.PByte;
- begin
- buf := nil;
- if (Counter.X.dir < 0) then
- GetMem(buf, LineSize);
- try
- while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin
- tmp1 := ImageData;
- inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart
- if (Counter.X.dir < 0) then begin //flip X
- aStream.Read(buf^, LineSize);
- tmp2 := buf;
- inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line
- for i := 0 to Header.Width-1 do begin //for all pixels in line
- for j := 0 to PixelSize-1 do begin //for all bytes in pixel
- tmp1^ := tmp2^;
- inc(tmp1);
- inc(tmp2);
- end;
- dec(tmp2, 2*PixelSize); //move 2 backwards, because j-loop moved 1 forward
- end;
- end else
- aStream.Read(tmp1^, LineSize);
- inc(Counter.Y.low, Counter.Y.dir); //move to next line index
- end;
- finally
- if Assigned(buf) then
- FreeMem(buf);
- end;
- end;
-
- ////////////////////////////////////////////////////////////////////////////////////////
- procedure ReadCompressed;
-
- /////////////////////////////////////////////////////////////////
- var
- TmpData: System.PByte;
- LinePixelsRead: Integer;
- procedure CheckLine;
- begin
- if (LinePixelsRead >= Header.Width) then begin
- LinePixelsRead := 0;
- inc(Counter.Y.low, Counter.Y.dir); //next line index
- TmpData := ImageData;
- inc(TmpData, Counter.Y.low * LineSize); //set line
- if (Counter.X.dir < 0) then //if x flipped then
- inc(TmpData, LineSize - PixelSize); //set last pixel
- end;
- end;
-
- /////////////////////////////////////////////////////////////////
- var
- Cache: PByte;
- CacheSize, CachePos: Integer;
- procedure CachedRead(out Buffer; Count: Integer);
- var
- BytesRead: Integer;
- begin
- if (CachePos + Count > CacheSize) then begin
- //if buffer overflow save non read bytes
- BytesRead := 0;
- if (CacheSize - CachePos > 0) then begin
- BytesRead := CacheSize - CachePos;
- Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead);
- inc(CachePos, BytesRead);
- end;
-
- //load cache from file
- CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position);
- aStream.Read(Cache^, CacheSize);
- CachePos := 0;
-
- //read rest of requested bytes
- if (Count - BytesRead > 0) then begin
- Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead);
- inc(CachePos, Count - BytesRead);
- end;
- end else begin
- //if no buffer overflow just read the data
- Move(PByteArray(Cache)^[CachePos], Buffer, Count);
- inc(CachePos, Count);
- end;
- end;
-
- procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte);
- begin
- case PixelSize of
- 1: begin
- aBuffer^ := aData^;
- inc(aBuffer, Counter.X.dir);
- end;
- 2: begin
- PWord(aBuffer)^ := PWord(aData)^;
- inc(aBuffer, 2 * Counter.X.dir);
- end;
- 3: begin
- PByteArray(aBuffer)^[0] := PByteArray(aData)^[0];
- PByteArray(aBuffer)^[1] := PByteArray(aData)^[1];
- PByteArray(aBuffer)^[2] := PByteArray(aData)^[2];
- inc(aBuffer, 3 * Counter.X.dir);
- end;
- 4: begin
- PCardinal(aBuffer)^ := PCardinal(aData)^;
- inc(aBuffer, 4 * Counter.X.dir);
- end;
- end;
- end;
-
- var
- TotalPixelsToRead, TotalPixelsRead: Integer;
- Temp: Byte;
- buf: array [0..3] of Byte; //1 pixel is max 32bit long
- PixelRepeat: Boolean;
- PixelsToRead, PixelCount: Integer;
- begin
- CacheSize := 0;
- CachePos := 0;
-
- TotalPixelsToRead := Header.Width * Header.Height;
- TotalPixelsRead := 0;
- LinePixelsRead := 0;
-
- GetMem(Cache, CACHE_SIZE);
- try
- TmpData := ImageData;
- inc(TmpData, Counter.Y.low * LineSize); //set line
- if (Counter.X.dir < 0) then //if x flipped then
- inc(TmpData, LineSize - PixelSize); //set last pixel
-
- repeat
- //read CommandByte
- CachedRead(Temp, 1);
- PixelRepeat := (Temp and $80) > 0;
- PixelsToRead := (Temp and $7F) + 1;
- inc(TotalPixelsRead, PixelsToRead);
-
- if PixelRepeat then
- CachedRead(buf[0], PixelSize);
- while (PixelsToRead > 0) do begin
- CheckLine;
- PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF
- while (PixelCount > 0) do begin
- if not PixelRepeat then
- CachedRead(buf[0], PixelSize);
- PixelToBuffer(@buf[0], TmpData);
- inc(LinePixelsRead);
- dec(PixelsToRead);
- dec(PixelCount);
- end;
- end;
- until (TotalPixelsRead >= TotalPixelsToRead);
- finally
- FreeMem(Cache);
- end;
- end;
-
- function IsGrayFormat: Boolean;
- begin
- result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY];
- end;
-
-begin
- result := false;
-
- // reading header to test file and set cursor back to begin
- StartPosition := aStream.Position;
- aStream.Read(Header{%H-}, SizeOf(Header));
-
- // no colormapped files
- if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [
- TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then
- begin
- try
- if Header.ImageID <> 0 then // skip image ID
- aStream.Position := aStream.Position + Header.ImageID;
-
- tgaFormat := tfEmpty;
- case Header.Bpp of
- 8: if IsGrayFormat then case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfLuminance8ub1;
- 8: tgaFormat := tfAlpha8ub1;
- end;
-
- 16: if IsGrayFormat then case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfLuminance16us1;
- 8: tgaFormat := tfLuminance8Alpha8ub2;
- end else case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfX1RGB5us1;
- 1: tgaFormat := tfA1RGB5us1;
- 4: tgaFormat := tfARGB4us1;
- end;
-
- 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfBGR8ub3;
- end;
-
- 32: if IsGrayFormat then case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfDepth32ui1;
- end else case (Header.ImageDesc and $F) of
- 0: tgaFormat := tfX2RGB10ui1;
- 2: tgaFormat := tfA2RGB10ui1;
- 8: tgaFormat := tfARGB8ui1;
- end;
- end;
-
- if (tgaFormat = tfEmpty) then
- raise EglBitmap.Create('LoadTga - unsupported format');
-
- FormatDesc := TFormatDescriptor.Get(tgaFormat);
- PixelSize := FormatDesc.GetSize(1, 1);
- LineSize := FormatDesc.GetSize(Header.Width, 1);
-
- GetMem(ImageData, LineSize * Header.Height);
- try
- //column direction
- if ((Header.ImageDesc and (1 shl 4)) > 0) then begin
- Counter.X.low := Header.Height-1;;
- Counter.X.high := 0;
- Counter.X.dir := -1;
- end else begin
- Counter.X.low := 0;
- Counter.X.high := Header.Height-1;
- Counter.X.dir := 1;
- end;
-
- // Row direction
- if ((Header.ImageDesc and (1 shl 5)) > 0) then begin
- Counter.Y.low := 0;
- Counter.Y.high := Header.Height-1;
- Counter.Y.dir := 1;
- end else begin
- Counter.Y.low := Header.Height-1;;
- Counter.Y.high := 0;
- Counter.Y.dir := -1;
- end;
-
- // Read Image
- case Header.ImageType of
- TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY:
- ReadUncompressed;
- TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY:
- ReadCompressed;
- end;
-
- SetData(ImageData, tgaFormat, Header.Width, Header.Height);
- result := true;
- except
- if Assigned(ImageData) then
- FreeMem(ImageData);
- raise;
- end;
- finally
- aStream.Position := StartPosition;
- end;
- end
- else aStream.Position := StartPosition;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveTGA(const aStream: TStream);
-var
- Header: TTGAHeader;
- Size: Integer;
- FormatDesc: TFormatDescriptor;
-begin
- if not (ftTGA in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- //prepare header
- FormatDesc := TFormatDescriptor.Get(Format);
- FillChar(Header{%H-}, SizeOf(Header), 0);
- Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F;
- Header.Bpp := FormatDesc.BitsPerPixel;
- Header.Width := Width;
- Header.Height := Height;
- Header.ImageDesc := Header.ImageDesc or $20; //flip y
- if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then
- Header.ImageType := TGA_UNCOMPRESSED_GRAY
- else
- Header.ImageType := TGA_UNCOMPRESSED_RGB;
- aStream.Write(Header, SizeOf(Header));
-
- // write Data
- Size := FormatDesc.GetSize(Dimension);
- aStream.Write(Data^, Size);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//DDS/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const
- DDS_MAGIC: Cardinal = $20534444;
-
- // DDS_header.dwFlags
- DDSD_CAPS = $00000001;
- DDSD_HEIGHT = $00000002;
- DDSD_WIDTH = $00000004;
- DDSD_PIXELFORMAT = $00001000;
-
- // DDS_header.sPixelFormat.dwFlags
- DDPF_ALPHAPIXELS = $00000001;
- DDPF_ALPHA = $00000002;
- DDPF_FOURCC = $00000004;
- DDPF_RGB = $00000040;
- DDPF_LUMINANCE = $00020000;
-
- // DDS_header.sCaps.dwCaps1
- DDSCAPS_TEXTURE = $00001000;
-
- // DDS_header.sCaps.dwCaps2
- DDSCAPS2_CUBEMAP = $00000200;
-
- D3DFMT_DXT1 = $31545844;
- D3DFMT_DXT3 = $33545844;
- D3DFMT_DXT5 = $35545844;
-
-type
- TDDSPixelFormat = packed record
- dwSize: Cardinal;
- dwFlags: Cardinal;
- dwFourCC: Cardinal;
- dwRGBBitCount: Cardinal;
- dwRBitMask: Cardinal;
- dwGBitMask: Cardinal;
- dwBBitMask: Cardinal;
- dwABitMask: Cardinal;
- end;
-
- TDDSCaps = packed record
- dwCaps1: Cardinal;
- dwCaps2: Cardinal;
- dwDDSX: Cardinal;
- dwReserved: Cardinal;
- end;
-
- TDDSHeader = packed record
- dwSize: Cardinal;
- dwFlags: Cardinal;
- dwHeight: Cardinal;
- dwWidth: Cardinal;
- dwPitchOrLinearSize: Cardinal;
- dwDepth: Cardinal;
- dwMipMapCount: Cardinal;
- dwReserved: array[0..10] of Cardinal;
- PixelFormat: TDDSPixelFormat;
- Caps: TDDSCaps;
- dwReserved2: Cardinal;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.LoadDDS(const aStream: TStream): Boolean;
-var
- Header: TDDSHeader;
- Converter: TbmpBitfieldFormat;
-
- function GetDDSFormat: TglBitmapFormat;
- var
- fd: TFormatDescriptor;
- i: Integer;
- Mask: TglBitmapRec4ul;
- Range: TglBitmapRec4ui;
- match: Boolean;
- begin
- result := tfEmpty;
- with Header.PixelFormat do begin
- // Compresses
- if ((dwFlags and DDPF_FOURCC) > 0) then begin
- case Header.PixelFormat.dwFourCC of
- D3DFMT_DXT1: result := tfS3tcDtx1RGBA;
- D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
- D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
- end;
- end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin
- // prepare masks
- if ((dwFlags and DDPF_LUMINANCE) = 0) then begin
- Mask.r := dwRBitMask;
- Mask.g := dwGBitMask;
- Mask.b := dwBBitMask;
- end else begin
- Mask.r := dwRBitMask;
- Mask.g := dwRBitMask;
- Mask.b := dwRBitMask;
- end;
- if (dwFlags and DDPF_ALPHAPIXELS > 0) then
- Mask.a := dwABitMask
- else
- Mask.a := 0;;
-
- //find matching format
- fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount);
- result := fd.Format;
- if (result <> tfEmpty) then
- exit;
-
- //find format with same Range
- for i := 0 to 3 do
- Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1;
- for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
- fd := TFormatDescriptor.Get(result);
- match := true;
- for i := 0 to 3 do
- if (fd.Range.arr[i] <> Range.arr[i]) then begin
- match := false;
- break;
- end;
- if match then
- break;
- end;
-
- //no format with same range found -> use default
- if (result = tfEmpty) then begin
- if (dwABitMask > 0) then
- result := tfRGBA8ui1
- else
- result := tfRGB8ub3;
- end;
-
- Converter := TbmpBitfieldFormat.Create;
- Converter.SetCustomValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask));
- end;
- end;
- end;
-
-var
- StreamPos: Int64;
- x, y, LineSize, RowSize, Magic: Cardinal;
- NewImage, TmpData, RowData, SrcData: System.PByte;
- SourceMD, DestMD: Pointer;
- Pixel: TglBitmapPixelData;
- ddsFormat: TglBitmapFormat;
- FormatDesc: TFormatDescriptor;
-
-begin
- result := false;
- Converter := nil;
- StreamPos := aStream.Position;
-
- // Magic
- aStream.Read(Magic{%H-}, sizeof(Magic));
- if (Magic <> DDS_MAGIC) then begin
- aStream.Position := StreamPos;
- exit;
- end;
-
- //Header
- aStream.Read(Header{%H-}, sizeof(Header));
- if (Header.dwSize <> SizeOf(Header)) or
- ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <>
- (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then
- begin
- aStream.Position := StreamPos;
- exit;
- end;
-
- if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
- raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');
-
- ddsFormat := GetDDSFormat;
- try
- if (ddsFormat = tfEmpty) then
- raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
-
- FormatDesc := TFormatDescriptor.Get(ddsFormat);
- LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel);
- GetMem(NewImage, Header.dwHeight * LineSize);
- try
- TmpData := NewImage;
-
- //Converter needed
- if Assigned(Converter) then begin
- RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8);
- GetMem(RowData, RowSize);
- SourceMD := Converter.CreateMappingData;
- DestMD := FormatDesc.CreateMappingData;
- try
- for y := 0 to Header.dwHeight-1 do begin
- TmpData := NewImage;
- inc(TmpData, y * LineSize);
- SrcData := RowData;
- aStream.Read(SrcData^, RowSize);
- for x := 0 to Header.dwWidth-1 do begin
- Converter.Unmap(SrcData, Pixel, SourceMD);
- glBitmapConvertPixel(Pixel, Converter, FormatDesc);
- FormatDesc.Map(Pixel, TmpData, DestMD);
- end;
- end;
- finally
- Converter.FreeMappingData(SourceMD);
- FormatDesc.FreeMappingData(DestMD);
- FreeMem(RowData);
- end;
- end else
-
- // Compressed
- if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin
- RowSize := Header.dwPitchOrLinearSize div Header.dwWidth;
- for Y := 0 to Header.dwHeight-1 do begin
- aStream.Read(TmpData^, RowSize);
- Inc(TmpData, LineSize);
- end;
- end else
-
- // Uncompressed
- if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin
- RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3;
- for Y := 0 to Header.dwHeight-1 do begin
- aStream.Read(TmpData^, RowSize);
- Inc(TmpData, LineSize);
- end;
- end else
- raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
-
- SetData(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight);
- result := true;
- except
- if Assigned(NewImage) then
- FreeMem(NewImage);
- raise;
- end;
- finally
- FreeAndNil(Converter);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveDDS(const aStream: TStream);
-var
- Header: TDDSHeader;
- FormatDesc: TFormatDescriptor;
-begin
- if not (ftDDS in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- FormatDesc := TFormatDescriptor.Get(Format);
-
- // Generell
- FillChar(Header{%H-}, SizeOf(Header), 0);
- Header.dwSize := SizeOf(Header);
- Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT;
-
- Header.dwWidth := Max(1, Width);
- Header.dwHeight := Max(1, Height);
-
- // Caps
- Header.Caps.dwCaps1 := DDSCAPS_TEXTURE;
-
- // Pixelformat
- Header.PixelFormat.dwSize := sizeof(Header);
- if (FormatDesc.IsCompressed) then begin
- Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC;
- case Format of
- tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1;
- tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3;
- tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5;
- end;
- end else if not FormatDesc.HasColor and FormatDesc.HasAlpha then begin
- Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA;
- Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
- Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
- end else if FormatDesc.IsGrayscale then begin
- Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE;
- Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
- Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r;
- Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
- end else begin
- Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB;
- Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
- Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r;
- Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g;
- Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b;
- Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
- end;
-
- if (FormatDesc.HasAlpha) then
- Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS;
-
- aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC));
- aStream.Write(Header, SizeOf(Header));
- aStream.Write(Data^, FormatDesc.GetSize(Dimension));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.FlipHorz: Boolean;
-var
- fd: TglBitmapFormatDescriptor;
- Col, RowSize, PixelSize: Integer;
- pTempDest, pDest, pSource: PByte;
-begin
- result := false;
- fd := FormatDescriptor;
- PixelSize := Ceil(fd.BytesPerPixel);
- RowSize := fd.GetSize(Width, 1);
- if Assigned(Data) and not fd.IsCompressed then begin
- pSource := Data;
- GetMem(pDest, RowSize);
- try
- pTempDest := pDest;
- Inc(pTempDest, RowSize);
- for Col := 0 to Width-1 do begin
- dec(pTempDest, PixelSize); //dec before, because ptr is behind last byte of data
- Move(pSource^, pTempDest^, PixelSize);
- Inc(pSource, PixelSize);
- end;
- SetData(pDest, Format, Width);
- result := true;
- except
- if Assigned(pDest) then
- FreeMem(pDest);
- raise;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.FlipVert: Boolean;
-var
- fd: TglBitmapFormatDescriptor;
- Row, RowSize, PixelSize: Integer;
- TempDestData, DestData, SourceData: PByte;
-begin
- result := false;
- fd := FormatDescriptor;
- PixelSize := Ceil(fd.BytesPerPixel);
- RowSize := fd.GetSize(Width, 1);
- if Assigned(Data) then begin
- SourceData := Data;
- GetMem(DestData, Height * RowSize);
- try
- TempDestData := DestData;
- Inc(TempDestData, Width * (Height -1) * PixelSize);
- for Row := 0 to Height -1 do begin
- Move(SourceData^, TempDestData^, RowSize);
- Dec(TempDestData, RowSize);
- Inc(SourceData, RowSize);
- end;
- SetData(DestData, Format, Width, Height);
- result := true;
- except
- if Assigned(DestData) then
- FreeMem(DestData);
- raise;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.LoadFromFile(const aFilename: String);
-var
- fs: TFileStream;
-begin
- if not FileExists(aFilename) then
- raise EglBitmap.Create('file does not exist: ' + aFilename);
- fs := TFileStream.Create(aFilename, fmOpenRead);
- try
- fs.Position := 0;
- LoadFromStream(fs);
- fFilename := aFilename;
- finally
- fs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.LoadFromStream(const aStream: TStream);
-begin
- {$IFDEF GLB_SUPPORT_PNG_READ}
- if not LoadPNG(aStream) then
- {$ENDIF}
- {$IFDEF GLB_SUPPORT_JPEG_READ}
- if not LoadJPEG(aStream) then
- {$ENDIF}
- if not LoadDDS(aStream) then
- if not LoadTGA(aStream) then
- if not LoadBMP(aStream) then
- if not LoadRAW(aStream) then
- raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat;
- const aFunc: TglBitmapFunction; const aArgs: Pointer);
-var
- tmpData: PByte;
- size: Integer;
-begin
- size := TFormatDescriptor.Get(aFormat).GetSize(aSize);
- GetMem(tmpData, size);
- try
- FillChar(tmpData^, size, #$FF);
- SetData(tmpData, aFormat, aSize.X, aSize.Y);
- except
- if Assigned(tmpData) then
- FreeMem(tmpData);
- raise;
- end;
- Convert(Self, aFunc, false, aFormat, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar);
-var
- rs: TResourceStream;
-begin
- PrepareResType(aResource, aResType);
- rs := TResourceStream.Create(aInstance, aResource, aResType);
- try
- LoadFromStream(rs);
- finally
- rs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-var
- rs: TResourceStream;
-begin
- rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
- try
- LoadFromStream(rs);
- finally
- rs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
-var
- fs: TFileStream;
-begin
- fs := TFileStream.Create(aFileName, fmCreate);
- try
- fs.Position := 0;
- SaveToStream(fs, aFileType);
- finally
- fs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType);
-begin
- case aFileType of
- {$IFDEF GLB_SUPPORT_PNG_WRITE}
- ftPNG: SavePNG(aStream);
- {$ENDIF}
- {$IFDEF GLB_SUPPORT_JPEG_WRITE}
- ftJPEG: SaveJPEG(aStream);
- {$ENDIF}
- ftDDS: SaveDDS(aStream);
- ftTGA: SaveTGA(aStream);
- ftBMP: SaveBMP(aStream);
- ftRAW: SaveRAW(aStream);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean;
-begin
- result := Convert(Self, aFunc, aCreateTemp, Format, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
- const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean;
-var
- DestData, TmpData, SourceData: pByte;
- TempHeight, TempWidth: Integer;
- SourceFD, DestFD: TFormatDescriptor;
- SourceMD, DestMD: Pointer;
-
- FuncRec: TglBitmapFunctionRec;
-begin
- Assert(Assigned(Data));
- Assert(Assigned(aSource));
- Assert(Assigned(aSource.Data));
-
- result := false;
- if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin
- SourceFD := TFormatDescriptor.Get(aSource.Format);
- DestFD := TFormatDescriptor.Get(aFormat);
-
- if (SourceFD.IsCompressed) then
- raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format);
- if (DestFD.IsCompressed) then
- raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format);
-
- // inkompatible Formats so CreateTemp
- if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then
- aCreateTemp := true;
-
- // Values
- TempHeight := Max(1, aSource.Height);
- TempWidth := Max(1, aSource.Width);
-
- FuncRec.Sender := Self;
- FuncRec.Args := aArgs;
-
- TmpData := nil;
- if aCreateTemp then begin
- GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight));
- DestData := TmpData;
- end else
- DestData := Data;
-
- try
- SourceFD.PreparePixel(FuncRec.Source);
- DestFD.PreparePixel (FuncRec.Dest);
-
- SourceMD := SourceFD.CreateMappingData;
- DestMD := DestFD.CreateMappingData;
-
- FuncRec.Size := aSource.Dimension;
- FuncRec.Position.Fields := FuncRec.Size.Fields;
-
- try
- SourceData := aSource.Data;
- FuncRec.Position.Y := 0;
- while FuncRec.Position.Y < TempHeight do begin
- FuncRec.Position.X := 0;
- while FuncRec.Position.X < TempWidth do begin
- SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
- aFunc(FuncRec);
- DestFD.Map(FuncRec.Dest, DestData, DestMD);
- inc(FuncRec.Position.X);
- end;
- inc(FuncRec.Position.Y);
- end;
-
- // Updating Image or InternalFormat
- if aCreateTemp then
- SetData(TmpData, aFormat, aSource.Width, aSource.Height)
- else if (aFormat <> fFormat) then
- Format := aFormat;
-
- result := true;
- finally
- SourceFD.FreeMappingData(SourceMD);
- DestFD.FreeMappingData(DestMD);
- end;
- except
- if aCreateTemp and Assigned(TmpData) then
- FreeMem(TmpData);
- raise;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.ConvertTo(const aFormat: TglBitmapFormat): Boolean;
-var
- SourceFD, DestFD: TFormatDescriptor;
- SourcePD, DestPD: TglBitmapPixelData;
- ShiftData: TShiftData;
-
- function DataIsIdentical: Boolean;
- begin
- result := SourceFD.MaskMatch(DestFD.Mask);
- end;
-
- function CanCopyDirect: Boolean;
- begin
- result :=
- ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
- ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
- ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
- ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
- end;
-
- function CanShift: Boolean;
- begin
- result :=
- ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
- ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
- ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
- ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
- end;
-
- function GetShift(aSource, aDest: Cardinal) : ShortInt;
- begin
- result := 0;
- while (aSource > aDest) and (aSource > 0) do begin
- inc(result);
- aSource := aSource shr 1;
- end;
- end;
-
-begin
- if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin
- SourceFD := TFormatDescriptor.Get(Format);
- DestFD := TFormatDescriptor.Get(aFormat);
-
- if DataIsIdentical then begin
- result := true;
- Format := aFormat;
- exit;
- end;
-
- SourceFD.PreparePixel(SourcePD);
- DestFD.PreparePixel (DestPD);
-
- if CanCopyDirect then
- result := Convert(Self, glBitmapConvertCopyFunc, false, aFormat)
- else if CanShift then begin
- ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r);
- ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g);
- ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b);
- ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a);
- result := Convert(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData);
- end else
- result := Convert(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat);
- end else
- result := true;
-end;
-
-{$IFDEF GLB_SDL}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignToSurface(out aSurface: PSDL_Surface): Boolean;
-var
- Row, RowSize: Integer;
- SourceData, TmpData: PByte;
- TempDepth: Integer;
- FormatDesc: TFormatDescriptor;
-
- function GetRowPointer(Row: Integer): pByte;
- begin
- result := aSurface.pixels;
- Inc(result, Row * RowSize);
- end;
-
-begin
- result := false;
-
- FormatDesc := TFormatDescriptor.Get(Format);
- if FormatDesc.IsCompressed then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- if Assigned(Data) then begin
- case Trunc(FormatDesc.PixelSize) of
- 1: TempDepth := 8;
- 2: TempDepth := 16;
- 3: TempDepth := 24;
- 4: TempDepth := 32;
- else
- raise EglBitmapUnsupportedFormat.Create(Format);
- end;
-
- aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
- FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
- SourceData := Data;
- RowSize := FormatDesc.GetSize(FileWidth, 1);
-
- for Row := 0 to FileHeight-1 do begin
- TmpData := GetRowPointer(Row);
- if Assigned(TmpData) then begin
- Move(SourceData^, TmpData^, RowSize);
- inc(SourceData, RowSize);
- end;
- end;
- result := true;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
-var
- pSource, pData, pTempData: PByte;
- Row, RowSize, TempWidth, TempHeight: Integer;
- IntFormat: TglBitmapFormat;
- fd: TFormatDescriptor;
- Mask: TglBitmapMask;
-
- function GetRowPointer(Row: Integer): pByte;
- begin
- result := aSurface^.pixels;
- Inc(result, Row * RowSize);
- end;
-
-begin
- result := false;
- if (Assigned(aSurface)) then begin
- with aSurface^.format^ do begin
- Mask.r := RMask;
- Mask.g := GMask;
- Mask.b := BMask;
- Mask.a := AMask;
- IntFormat := TFormatDescriptor.GetFromMask(Mask).Format;
- if (IntFormat = tfEmpty) then
- raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.');
- end;
-
- fd := TFormatDescriptor.Get(IntFormat);
- TempWidth := aSurface^.w;
- TempHeight := aSurface^.h;
- RowSize := fd.GetSize(TempWidth, 1);
- GetMem(pData, TempHeight * RowSize);
- try
- pTempData := pData;
- for Row := 0 to TempHeight -1 do begin
- pSource := GetRowPointer(Row);
- if (Assigned(pSource)) then begin
- Move(pSource^, pTempData^, RowSize);
- Inc(pTempData, RowSize);
- end;
- end;
- SetData(pData, IntFormat, TempWidth, TempHeight);
- result := true;
- except
- if Assigned(pData) then
- FreeMem(pData);
- raise;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
-var
- Row, Col, AlphaInterleave: Integer;
- pSource, pDest: PByte;
-
- function GetRowPointer(Row: Integer): pByte;
- begin
- result := aSurface.pixels;
- Inc(result, Row * Width);
- end;
-
-begin
- result := false;
- if Assigned(Data) then begin
- if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin
- aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0);
-
- AlphaInterleave := 0;
- case Format of
- tfLuminance8Alpha8ub2:
- AlphaInterleave := 1;
- tfBGRA8ub4, tfRGBA8ub4:
- AlphaInterleave := 3;
- end;
-
- pSource := Data;
- for Row := 0 to Height -1 do begin
- pDest := GetRowPointer(Row);
- if Assigned(pDest) then begin
- for Col := 0 to Width -1 do begin
- Inc(pSource, AlphaInterleave);
- pDest^ := pSource^;
- Inc(pDest);
- Inc(pSource);
- end;
- end;
- end;
- result := true;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-var
- bmp: TglBitmap2D;
-begin
- bmp := TglBitmap2D.Create;
- try
- bmp.AssignFromSurface(aSurface);
- result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
- finally
- bmp.Free;
- end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_DELPHI}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function CreateGrayPalette: HPALETTE;
-var
- Idx: Integer;
- Pal: PLogPalette;
-begin
- GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
-
- Pal.palVersion := $300;
- Pal.palNumEntries := 256;
-
- for Idx := 0 to Pal.palNumEntries - 1 do begin
- Pal.palPalEntry[Idx].peRed := Idx;
- Pal.palPalEntry[Idx].peGreen := Idx;
- Pal.palPalEntry[Idx].peBlue := Idx;
- Pal.palPalEntry[Idx].peFlags := 0;
- end;
- Result := CreatePalette(Pal^);
- FreeMem(Pal);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignToBitmap(const aBitmap: TBitmap): Boolean;
-var
- Row, RowSize: Integer;
- pSource, pData: PByte;
-begin
- result := false;
- if Assigned(Data) then begin
- if Assigned(aBitmap) then begin
- aBitmap.Width := Width;
- aBitmap.Height := Height;
-
- case Format of
- tfAlpha8ub1, tfLuminance8ub1: begin
- aBitmap.PixelFormat := pf8bit;
- aBitmap.Palette := CreateGrayPalette;
- end;
- tfRGB5A1us1:
- aBitmap.PixelFormat := pf15bit;
- tfR5G6B5us1:
- aBitmap.PixelFormat := pf16bit;
- tfRGB8ub3, tfBGR8ub3:
- aBitmap.PixelFormat := pf24bit;
- tfRGBA8ub4, tfBGRA8ub4:
- aBitmap.PixelFormat := pf32bit;
- else
- raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.');
- end;
-
- RowSize := FormatDescriptor.GetSize(Width, 1);
- pSource := Data;
- for Row := 0 to Height-1 do begin
- pData := aBitmap.Scanline[Row];
- Move(pSource^, pData^, RowSize);
- Inc(pSource, RowSize);
- if (Format in [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A)
- SwapRGB(pData, Width, Format = tfRGBA8ub4);
- end;
- result := true;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignFromBitmap(const aBitmap: TBitmap): Boolean;
-var
- pSource, pData, pTempData: PByte;
- Row, RowSize, TempWidth, TempHeight: Integer;
- IntFormat: TglBitmapFormat;
-begin
- result := false;
-
- if (Assigned(aBitmap)) then begin
- case aBitmap.PixelFormat of
- pf8bit:
- IntFormat := tfLuminance8ub1;
- pf15bit:
- IntFormat := tfRGB5A1us1;
- pf16bit:
- IntFormat := tfR5G6B5us1;
- pf24bit:
- IntFormat := tfBGR8ub3;
- pf32bit:
- IntFormat := tfBGRA8ub4;
- else
- raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.');
- end;
-
- TempWidth := aBitmap.Width;
- TempHeight := aBitmap.Height;
- RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1);
- GetMem(pData, TempHeight * RowSize);
- try
- pTempData := pData;
- for Row := 0 to TempHeight -1 do begin
- pSource := aBitmap.Scanline[Row];
- if (Assigned(pSource)) then begin
- Move(pSource^, pTempData^, RowSize);
- Inc(pTempData, RowSize);
- end;
- end;
- SetData(pData, IntFormat, TempWidth, TempHeight);
- result := true;
- except
- if Assigned(pData) then
- FreeMem(pData);
- raise;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
-var
- Row, Col, AlphaInterleave: Integer;
- pSource, pDest: PByte;
-begin
- result := false;
-
- if Assigned(Data) then begin
- if (Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin
- if Assigned(aBitmap) then begin
- aBitmap.PixelFormat := pf8bit;
- aBitmap.Palette := CreateGrayPalette;
- aBitmap.Width := Width;
- aBitmap.Height := Height;
-
- case Format of
- tfLuminance8Alpha8ub2:
- AlphaInterleave := 1;
- tfRGBA8ub4, tfBGRA8ub4:
- AlphaInterleave := 3;
- else
- AlphaInterleave := 0;
- end;
-
- // Copy Data
- pSource := Data;
-
- for Row := 0 to Height -1 do begin
- pDest := aBitmap.Scanline[Row];
- if Assigned(pDest) then begin
- for Col := 0 to Width -1 do begin
- Inc(pSource, AlphaInterleave);
- pDest^ := pSource^;
- Inc(pDest);
- Inc(pSource);
- end;
- end;
- end;
- result := true;
- end;
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- data: TglBitmapData;
-begin
- data := TglBitmapData.Create;
- try
- data.AssignFromBitmap(aBitmap);
- result := AddAlphaFromDataObj(data, aFunc, aArgs);
- finally
- data.Free;
- end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_LAZARUS}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
- rid: TRawImageDescription;
- FormatDesc: TFormatDescriptor;
-begin
- if not Assigned(Data) then
- raise EglBitmap.Create('no pixel data assigned. load data before save');
-
- result := false;
- if not Assigned(aImage) or (Format = tfEmpty) then
- exit;
- FormatDesc := TFormatDescriptor.Get(Format);
- if FormatDesc.IsCompressed then
- exit;
-
- FillChar(rid{%H-}, SizeOf(rid), 0);
- if FormatDesc.IsGrayscale then
- rid.Format := ricfGray
- else
- rid.Format := ricfRGBA;
-
- rid.Width := Width;
- rid.Height := Height;
- rid.Depth := FormatDesc.BitsPerPixel;
- rid.BitOrder := riboBitsInOrder;
- rid.ByteOrder := riboLSBFirst;
- rid.LineOrder := riloTopToBottom;
- rid.LineEnd := rileTight;
- rid.BitsPerPixel := FormatDesc.BitsPerPixel;
- rid.RedPrec := CountSetBits(FormatDesc.Range.r);
- rid.GreenPrec := CountSetBits(FormatDesc.Range.g);
- rid.BluePrec := CountSetBits(FormatDesc.Range.b);
- rid.AlphaPrec := CountSetBits(FormatDesc.Range.a);
- rid.RedShift := FormatDesc.Shift.r;
- rid.GreenShift := FormatDesc.Shift.g;
- rid.BlueShift := FormatDesc.Shift.b;
- rid.AlphaShift := FormatDesc.Shift.a;
-
- rid.MaskBitsPerPixel := 0;
- rid.PaletteColorCount := 0;
-
- aImage.DataDescription := rid;
- aImage.CreateData;
-
- if not Assigned(aImage.PixelData) then
- raise EglBitmap.Create('error while creating LazIntfImage');
- Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension));
-
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
- f: TglBitmapFormat;
- FormatDesc: TFormatDescriptor;
- ImageData: PByte;
- ImageSize: Integer;
- CanCopy: Boolean;
- Mask: TglBitmapRec4ul;
-
- procedure CopyConvert;
- var
- bfFormat: TbmpBitfieldFormat;
- pSourceLine, pDestLine: PByte;
- pSourceMD, pDestMD: Pointer;
- Shift, Prec: TglBitmapRec4ub;
- x, y: Integer;
- pixel: TglBitmapPixelData;
- begin
- bfFormat := TbmpBitfieldFormat.Create;
- with aImage.DataDescription do begin
- Prec.r := RedPrec;
- Prec.g := GreenPrec;
- Prec.b := BluePrec;
- Prec.a := AlphaPrec;
- Shift.r := RedShift;
- Shift.g := GreenShift;
- Shift.b := BlueShift;
- Shift.a := AlphaShift;
- bfFormat.SetCustomValues(BitsPerPixel, Prec, Shift);
- end;
- pSourceMD := bfFormat.CreateMappingData;
- pDestMD := FormatDesc.CreateMappingData;
- try
- for y := 0 to aImage.Height-1 do begin
- pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine;
- pDestLine := ImageData + y * Round(FormatDesc.BytesPerPixel * aImage.Width);
- for x := 0 to aImage.Width-1 do begin
- bfFormat.Unmap(pSourceLine, pixel, pSourceMD);
- FormatDesc.Map(pixel, pDestLine, pDestMD);
- end;
- end;
- finally
- FormatDesc.FreeMappingData(pDestMD);
- bfFormat.FreeMappingData(pSourceMD);
- bfFormat.Free;
- end;
- end;
-
-begin
- result := false;
- if not Assigned(aImage) then
- exit;
-
- with aImage.DataDescription do begin
- Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift;
- Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift;
- Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift;
- Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift;
- end;
- FormatDesc := TFormatDescriptor.GetFromMask(Mask);
- f := FormatDesc.Format;
- if (f = tfEmpty) then
- exit;
-
- CanCopy :=
- (FormatDesc.BitsPerPixel = aImage.DataDescription.Depth) and
- (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth);
-
- ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height);
- ImageData := GetMem(ImageSize);
- try
- if CanCopy then
- Move(aImage.PixelData^, ImageData^, ImageSize)
- else
- CopyConvert;
- SetData(ImageData, f, aImage.Width, aImage.Height);
- except
- if Assigned(ImageData) then
- FreeMem(ImageData);
- raise;
- end;
-
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
- rid: TRawImageDescription;
- FormatDesc: TFormatDescriptor;
- Pixel: TglBitmapPixelData;
- x, y: Integer;
- srcMD: Pointer;
- src, dst: PByte;
-begin
- result := false;
- if not Assigned(aImage) or (Format = tfEmpty) then
- exit;
- FormatDesc := TFormatDescriptor.Get(Format);
- if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
- exit;
-
- FillChar(rid{%H-}, SizeOf(rid), 0);
- rid.Format := ricfGray;
- rid.Width := Width;
- rid.Height := Height;
- rid.Depth := CountSetBits(FormatDesc.Range.a);
- rid.BitOrder := riboBitsInOrder;
- rid.ByteOrder := riboLSBFirst;
- rid.LineOrder := riloTopToBottom;
- rid.LineEnd := rileTight;
- rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8);
- rid.RedPrec := CountSetBits(FormatDesc.Range.a);
- rid.GreenPrec := 0;
- rid.BluePrec := 0;
- rid.AlphaPrec := 0;
- rid.RedShift := 0;
- rid.GreenShift := 0;
- rid.BlueShift := 0;
- rid.AlphaShift := 0;
-
- rid.MaskBitsPerPixel := 0;
- rid.PaletteColorCount := 0;
-
- aImage.DataDescription := rid;
- aImage.CreateData;
-
- srcMD := FormatDesc.CreateMappingData;
- try
- FormatDesc.PreparePixel(Pixel);
- src := Data;
- dst := aImage.PixelData;
- for y := 0 to Height-1 do
- for x := 0 to Width-1 do begin
- FormatDesc.Unmap(src, Pixel, srcMD);
- case rid.BitsPerPixel of
- 8: begin
- dst^ := Pixel.Data.a;
- inc(dst);
- end;
- 16: begin
- PWord(dst)^ := Pixel.Data.a;
- inc(dst, 2);
- end;
- 24: begin
- PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0];
- PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1];
- PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2];
- inc(dst, 3);
- end;
- 32: begin
- PCardinal(dst)^ := Pixel.Data.a;
- inc(dst, 4);
- end;
- else
- raise EglBitmapUnsupportedFormat.Create(Format);
- end;
- end;
- finally
- FormatDesc.FreeMappingData(srcMD);
- end;
- result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- data: TglBitmapData;
-begin
- data := TglBitmapData.Create;
- try
- data.AssignFromLazIntfImage(aImage);
- result := AddAlphaFromDataObj(data, aFunc, aArgs);
- finally
- data.Free;
- end;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar;
- const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- rs: TResourceStream;
-begin
- PrepareResType(aResource, aResType);
- rs := TResourceStream.Create(aInstance, aResource, aResType);
- try
- result := AddAlphaFromStream(rs, aFunc, aArgs);
- finally
- rs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
- const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- rs: TResourceStream;
-begin
- rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
- try
- result := AddAlphaFromStream(rs, aFunc, aArgs);
- finally
- rs.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-begin
- if TFormatDescriptor.Get(Format).IsCompressed then
- raise EglBitmapUnsupportedFormat.Create(Format);
- result := Convert(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- FS: TFileStream;
-begin
- FS := TFileStream.Create(aFileName, fmOpenRead);
- try
- result := AddAlphaFromStream(FS, aFunc, aArgs);
- finally
- FS.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- data: TglBitmapData;
-begin
- data := TglBitmapData.Create(aStream);
- try
- result := AddAlphaFromDataObj(data, aFunc, aArgs);
- finally
- data.Free;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
- DestData, DestData2, SourceData: pByte;
- TempHeight, TempWidth: Integer;
- SourceFD, DestFD: TFormatDescriptor;
- SourceMD, DestMD, DestMD2: Pointer;
-
- FuncRec: TglBitmapFunctionRec;
-begin
- result := false;
-
- Assert(Assigned(Data));
- Assert(Assigned(aDataObj));
- Assert(Assigned(aDataObj.Data));
-
- if ((aDataObj.Width = Width) and (aDataObj.Height = Height)) then begin
- result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha);
-
- SourceFD := TFormatDescriptor.Get(aDataObj.Format);
- DestFD := TFormatDescriptor.Get(Format);
-
- if not Assigned(aFunc) then begin
- aFunc := glBitmapAlphaFunc;
- FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha);
- end else
- FuncRec.Args := aArgs;
-
- // Values
- TempWidth := aDataObj.Width;
- TempHeight := aDataObj.Height;
- if (TempWidth <= 0) or (TempHeight <= 0) then
- exit;
-
- FuncRec.Sender := Self;
- FuncRec.Size := Dimension;
- FuncRec.Position.Fields := FuncRec.Size.Fields;
-
- DestData := Data;
- DestData2 := Data;
- SourceData := aDataObj.Data;
-
- // Mapping
- SourceFD.PreparePixel(FuncRec.Source);
- DestFD.PreparePixel (FuncRec.Dest);
-
- SourceMD := SourceFD.CreateMappingData;
- DestMD := DestFD.CreateMappingData;
- DestMD2 := DestFD.CreateMappingData;
- try
- FuncRec.Position.Y := 0;
- while FuncRec.Position.Y < TempHeight do begin
- FuncRec.Position.X := 0;
- while FuncRec.Position.X < TempWidth do begin
- SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
- DestFD.Unmap (DestData, FuncRec.Dest, DestMD);
- aFunc(FuncRec);
- DestFD.Map(FuncRec.Dest, DestData2, DestMD2);
- inc(FuncRec.Position.X);
- end;
- inc(FuncRec.Position.Y);
- end;
- finally
- SourceFD.FreeMappingData(SourceMD);
- DestFD.FreeMappingData(DestMD);
- DestFD.FreeMappingData(DestMD2);
- end;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean;
-begin
- result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean;
-var
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
- result := AddAlphaFromColorKeyFloat(
- aRed / PixelData.Range.r,
- aGreen / PixelData.Range.g,
- aBlue / PixelData.Range.b,
- aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b)));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean;
-var
- values: array[0..2] of Single;
- tmp: Cardinal;
- i: Integer;
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
- with PixelData do begin
- values[0] := aRed;
- values[1] := aGreen;
- values[2] := aBlue;
-
- for i := 0 to 2 do begin
- tmp := Trunc(Range.arr[i] * aDeviation);
- Data.arr[i] := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp));
- Range.arr[i] := Max(0, Trunc(Range.arr[i] * values[i] - tmp));
- end;
- Data.a := 0;
- Range.a := 0;
- end;
- result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromValue(const aAlpha: Byte): Boolean;
-begin
- result := AddAlphaFromValueFloat(aAlpha / $FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
-var
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
- result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
-var
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
- with PixelData do
- Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
- result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.RemoveAlpha: Boolean;
-var
- FormatDesc: TFormatDescriptor;
-begin
- result := false;
- FormatDesc := TFormatDescriptor.Get(Format);
- if Assigned(Data) then begin
- if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
- raise EglBitmapUnsupportedFormat.Create(Format);
- result := ConvertTo(FormatDesc.WithoutAlpha);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.FillWithColor(const aRed, aGreen, aBlue: Byte;
- const aAlpha: Byte);
-begin
- FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal);
-var
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
- FillWithColorFloat(
- aRed / PixelData.Range.r,
- aGreen / PixelData.Range.g,
- aBlue / PixelData.Range.b,
- aAlpha / PixelData.Range.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single);
-var
- PixelData: TglBitmapPixelData;
-begin
- TFormatDescriptor.Get(Format).PreparePixel(PixelData);
- with PixelData do begin
- Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed)));
- Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen)));
- Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue)));
- Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha)));
- end;
- Convert(glBitmapFillWithColorFunc, false, @PixelData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer);
-begin
- if (Data <> aData) then begin
- if (Assigned(Data)) then
- FreeMem(Data);
- fData := aData;
- end;
-
- if Assigned(fData) then begin
- FillChar(fDimension, SizeOf(fDimension), 0);
- if aWidth <> -1 then begin
- fDimension.Fields := fDimension.Fields + [ffX];
- fDimension.X := aWidth;
- end;
-
- if aHeight <> -1 then begin
- fDimension.Fields := fDimension.Fields + [ffY];
- fDimension.Y := aHeight;
- end;
-
- fFormat := aFormat;
- end else
- fFormat := tfEmpty;
-
- UpdateScanlines;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmapData.Clone: TglBitmapData;
-var
- Temp: TglBitmapData;
- TempPtr: PByte;
- Size: Integer;
-begin
- result := nil;
- Temp := (ClassType.Create as TglBitmapData);
- try
- // copy texture data if assigned
- if Assigned(Data) then begin
- Size := TFormatDescriptor.Get(Format).GetSize(fDimension);
- GetMem(TempPtr, Size);
- try
- Move(Data^, TempPtr^, Size);
- Temp.SetData(TempPtr, Format, Width, Height);
- except
- if Assigned(TempPtr) then
- FreeMem(TempPtr);
- raise;
- end;
- end else begin
- TempPtr := nil;
- Temp.SetData(TempPtr, Format, Width, Height);
- end;
-
- // copy properties
- Temp.fFormat := Format;
- result := Temp;
- except
- FreeAndNil(Temp);
- raise;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
-var
- mask: PtrInt;
-begin
- mask :=
- (Byte(aRed) and 1) or
- ((Byte(aGreen) and 1) shl 1) or
- ((Byte(aBlue) and 1) shl 2) or
- ((Byte(aAlpha) and 1) shl 3);
- if (mask > 0) then
- Convert(glBitmapInvertFunc, false, {%H-}Pointer(mask));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
- TMatrixItem = record
- X, Y: Integer;
- W: Single;
- end;
-
- PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec;
- TglBitmapToNormalMapRec = Record
- Scale: Single;
- Heights: array of Single;
- MatrixU : array of TMatrixItem;
- MatrixV : array of TMatrixItem;
- end;
-
-const
- ONE_OVER_255 = 1 / 255;
-
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec);
-var
- Val: Single;
-begin
- with FuncRec do begin
- Val :=
- Source.Data.r * LUMINANCE_WEIGHT_R +
- Source.Data.g * LUMINANCE_WEIGHT_G +
- Source.Data.b * LUMINANCE_WEIGHT_B;
- PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255;
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-begin
- with FuncRec do
- PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec);
-type
- TVec = Array[0..2] of Single;
-var
- Idx: Integer;
- du, dv: Double;
- Len: Single;
- Vec: TVec;
-
- function GetHeight(X, Y: Integer): Single;
- begin
- with FuncRec do begin
- X := Max(0, Min(Size.X -1, X));
- Y := Max(0, Min(Size.Y -1, Y));
- result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X];
- end;
- end;
-
-begin
- with FuncRec do begin
- with PglBitmapToNormalMapRec(Args)^ do begin
- du := 0;
- for Idx := Low(MatrixU) to High(MatrixU) do
- du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W;
-
- dv := 0;
- for Idx := Low(MatrixU) to High(MatrixU) do
- dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W;
-
- Vec[0] := -du * Scale;
- Vec[1] := -dv * Scale;
- Vec[2] := 1;
- end;
-
- // Normalize
- Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
- if Len <> 0 then begin
- Vec[0] := Vec[0] * Len;
- Vec[1] := Vec[1] * Len;
- Vec[2] := Vec[2] * Len;
- end;
-
- // Farbe zuweisem
- Dest.Data.r := Trunc((Vec[0] + 1) * 127.5);
- Dest.Data.g := Trunc((Vec[1] + 1) * 127.5);
- Dest.Data.b := Trunc((Vec[2] + 1) * 127.5);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapData.GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean);
-var
- Rec: TglBitmapToNormalMapRec;
-
- procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single);
- begin
- if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin
- Matrix[Index].X := X;
- Matrix[Index].Y := Y;
- Matrix[Index].W := W;
- end;
- end;
-
-begin
- if TFormatDescriptor.Get(Format).IsCompressed then
- raise EglBitmapUnsupportedFormat.Create(Format);
-
- if aScale > 100 then
- Rec.Scale := 100
- else if aScale < -100 then
- Rec.Scale := -100
- else
- Rec.Scale := aScale;
-
- SetLength(Rec.Heights, Width * Height);
- try
- case aFunc of
- nm4Samples: begin
- SetLength(Rec.MatrixU, 2);
- SetEntry(Rec.MatrixU, 0, -1, 0, -0.5);
- SetEntry(Rec.MatrixU, 1, 1, 0, 0.5);
-
- SetLength(Rec.MatrixV, 2);
- SetEntry(Rec.MatrixV, 0, 0, 1, 0.5);
- SetEntry(Rec.MatrixV, 1, 0, -1, -0.5);
- end;
-
- nmSobel: begin
- SetLength(Rec.MatrixU, 6);
- SetEntry(Rec.MatrixU, 0, -1, 1, -1.0);
- SetEntry(Rec.MatrixU, 1, -1, 0, -2.0);
- SetEntry(Rec.MatrixU, 2, -1, -1, -1.0);
- SetEntry(Rec.MatrixU, 3, 1, 1, 1.0);
- SetEntry(Rec.MatrixU, 4, 1, 0, 2.0);
- SetEntry(Rec.MatrixU, 5, 1, -1, 1.0);
-
- SetLength(Rec.MatrixV, 6);
- SetEntry(Rec.MatrixV, 0, -1, 1, 1.0);
- SetEntry(Rec.MatrixV, 1, 0, 1, 2.0);
- SetEntry(Rec.MatrixV, 2, 1, 1, 1.0);
- SetEntry(Rec.MatrixV, 3, -1, -1, -1.0);
- SetEntry(Rec.MatrixV, 4, 0, -1, -2.0);
- SetEntry(Rec.MatrixV, 5, 1, -1, -1.0);
- end;
-
- nm3x3: begin
- SetLength(Rec.MatrixU, 6);
- SetEntry(Rec.MatrixU, 0, -1, 1, -1/6);
- SetEntry(Rec.MatrixU, 1, -1, 0, -1/6);
- SetEntry(Rec.MatrixU, 2, -1, -1, -1/6);
- SetEntry(Rec.MatrixU, 3, 1, 1, 1/6);
- SetEntry(Rec.MatrixU, 4, 1, 0, 1/6);
- SetEntry(Rec.MatrixU, 5, 1, -1, 1/6);
-
- SetLength(Rec.MatrixV, 6);
- SetEntry(Rec.MatrixV, 0, -1, 1, 1/6);
- SetEntry(Rec.MatrixV, 1, 0, 1, 1/6);
- SetEntry(Rec.MatrixV, 2, 1, 1, 1/6);
- SetEntry(Rec.MatrixV, 3, -1, -1, -1/6);
- SetEntry(Rec.MatrixV, 4, 0, -1, -1/6);
- SetEntry(Rec.MatrixV, 5, 1, -1, -1/6);
- end;
-
- nm5x5: begin
- SetLength(Rec.MatrixU, 20);
- SetEntry(Rec.MatrixU, 0, -2, 2, -1 / 16);
- SetEntry(Rec.MatrixU, 1, -1, 2, -1 / 10);
- SetEntry(Rec.MatrixU, 2, 1, 2, 1 / 10);
- SetEntry(Rec.MatrixU, 3, 2, 2, 1 / 16);
- SetEntry(Rec.MatrixU, 4, -2, 1, -1 / 10);
- SetEntry(Rec.MatrixU, 5, -1, 1, -1 / 8);
- SetEntry(Rec.MatrixU, 6, 1, 1, 1 / 8);
- SetEntry(Rec.MatrixU, 7, 2, 1, 1 / 10);
- SetEntry(Rec.MatrixU, 8, -2, 0, -1 / 2.8);
- SetEntry(Rec.MatrixU, 9, -1, 0, -0.5);
- SetEntry(Rec.MatrixU, 10, 1, 0, 0.5);
- SetEntry(Rec.MatrixU, 11, 2, 0, 1 / 2.8);
- SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10);
- SetEntry(Rec.MatrixU, 13, -1, -1, -1 / 8);
- SetEntry(Rec.MatrixU, 14, 1, -1, 1 / 8);
- SetEntry(Rec.MatrixU, 15, 2, -1, 1 / 10);
- SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16);
- SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10);
- SetEntry(Rec.MatrixU, 18, 1, -2, 1 / 10);
- SetEntry(Rec.MatrixU, 19, 2, -2, 1 / 16);
-
- SetLength(Rec.MatrixV, 20);
- SetEntry(Rec.MatrixV, 0, -2, 2, 1 / 16);
- SetEntry(Rec.MatrixV, 1, -1, 2, 1 / 10);
- SetEntry(Rec.MatrixV, 2, 0, 2, 0.25);
- SetEntry(Rec.MatrixV, 3, 1, 2, 1 / 10);
- SetEntry(Rec.MatrixV, 4, 2, 2, 1 / 16);
- SetEntry(Rec.MatrixV, 5, -2, 1, 1 / 10);
- SetEntry(Rec.MatrixV, 6, -1, 1, 1 / 8);
- SetEntry(Rec.MatrixV, 7, 0, 1, 0.5);
- SetEntry(Rec.MatrixV, 8, 1, 1, 1 / 8);
- SetEntry(Rec.MatrixV, 9, 2, 1, 1 / 16);
- SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16);
- SetEntry(Rec.MatrixV, 11, -1, -1, -1 / 8);
- SetEntry(Rec.MatrixV, 12, 0, -1, -0.5);
- SetEntry(Rec.MatrixV, 13, 1, -1, -1 / 8);
- SetEntry(Rec.MatrixV, 14, 2, -1, -1 / 10);
- SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16);
- SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10);
- SetEntry(Rec.MatrixV, 17, 0, -2, -0.25);
- SetEntry(Rec.MatrixV, 18, 1, -2, -1 / 10);
- SetEntry(Rec.MatrixV, 19, 2, -2, -1 / 16);
- end;
- end;
-
- // Daten Sammeln
- if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then
- Convert(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec)
- else
- Convert(glBitmapToNormalMapPrepareFunc, false, @Rec);
- Convert(glBitmapToNormalMapFunc, false, @Rec);
- finally
- SetLength(Rec.Heights, 0);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create;
-begin
- inherited Create;
- fFormat := glBitmapDefaultFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aFileName: String);
-begin
- Create;
- LoadFromFile(aFileName);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aStream: TStream);
-begin
- Create;
- LoadFromStream(aStream);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte);
-var
- ImageSize: Integer;
-begin
- Create;
- if not Assigned(aData) then begin
- ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize);
- GetMem(aData, ImageSize);
- try
- FillChar(aData^, ImageSize, #$FF);
- SetData(aData, aFormat, aSize.X, aSize.Y);
- except
- if Assigned(aData) then
- FreeMem(aData);
- raise;
- end;
- end else begin
- SetData(aData, aFormat, aSize.X, aSize.Y);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer);
-begin
- Create;
- LoadFromFunc(aSize, aFormat, aFunc, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar);
-begin
- Create;
- LoadFromResource(aInstance, aResource, aResType);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmapData.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-begin
- Create;
- LoadFromResourceID(aInstance, aResourceID, aResType);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-destructor TglBitmapData.Destroy;
-begin
- SetData(nil, tfEmpty);
- inherited Destroy;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - PROTECTED///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetWidth: Integer;
-begin
- if (ffX in fDimension.Fields) then
- result := fDimension.X
- else
- result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetHeight: Integer;
-begin
- if (ffY in fDimension.Fields) then
- result := fDimension.Y
- else
- result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomData(const aValue: Pointer);
-begin
- if fCustomData = aValue then
- exit;
- fCustomData := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomName(const aValue: String);
-begin
- if fCustomName = aValue then
- exit;
- fCustomName := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomNameW(const aValue: WideString);
-begin
- if fCustomNameW = aValue then
- exit;
- fCustomNameW := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
-begin
- if fDeleteTextureOnFree = aValue then
- exit;
- fDeleteTextureOnFree := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetID(const aValue: Cardinal);
-begin
- if fID = aValue then
- exit;
- fID := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
-begin
- if fMipMap = aValue then
- exit;
- fMipMap := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetTarget(const aValue: Cardinal);
-begin
- if fTarget = aValue then
- exit;
- fTarget := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetAnisotropic(const aValue: Integer);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)}
-var
- MaxAnisotropic: Integer;
-{$IFEND}
-begin
- fAnisotropic := aValue;
- if (ID > 0) then begin
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)}
- if GL_EXT_texture_filter_anisotropic then begin
- if fAnisotropic > 0 then begin
- Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
- glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic);
- if aValue > MaxAnisotropic then
- fAnisotropic := MaxAnisotropic;
- glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
- end;
- end else begin
- fAnisotropic := 0;
- end;
-{$ELSE}
- fAnisotropic := 0;
-{$IFEND}
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.CreateID;
-begin
- if (ID <> 0) then
- glDeleteTextures(1, @fID);
- glGenTextures(1, @fID);
- Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF});
-begin
- // Set Up Parameters
- SetWrap(fWrapS, fWrapT, fWrapR);
- SetFilter(fFilterMin, fFilterMag);
- SetAnisotropic(fAnisotropic);
-
-{$IFNDEF OPENGL_ES}
- SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
- if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
- SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
-{$ENDIF}
-
-{$IFNDEF OPENGL_ES}
- // Mip Maps Generation Mode
- aBuildWithGlu := false;
- if (MipMap = mmMipmap) then begin
- if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
- glTexParameteri(Target, GL_GENERATE_MIPMAP, GLint(GL_TRUE))
- else
- aBuildWithGlu := true;
- end else if (MipMap = mmMipmapGlu) then
- aBuildWithGlu := true;
-{$ELSE}
- if (MipMap = mmMipmap) then
- glGenerateMipmap(Target);
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - PUBLIC//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.AfterConstruction;
-begin
- inherited AfterConstruction;
-
- fID := 0;
- fTarget := 0;
-{$IFNDEF OPENGL_ES}
- fIsResident := false;
-{$ENDIF}
-
- fMipMap := glBitmapDefaultMipmap;
- fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree;
-
- glBitmapGetDefaultFilter (fFilterMin, fFilterMag);
- glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
-{$IFNDEF OPENGL_ES}
- glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.BeforeDestruction;
-begin
- if (fID > 0) and fDeleteTextureOnFree then
- glDeleteTextures(1, @fID);
- inherited BeforeDestruction;
-end;
-
-{$IFNDEF OPENGL_ES}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
-begin
- fBorderColor[0] := aRed;
- fBorderColor[1] := aGreen;
- fBorderColor[2] := aBlue;
- fBorderColor[3] := aAlpha;
- if (ID > 0) then begin
- Bind(false);
- glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]);
- end;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
-begin
- //check MIN filter
- case aMin of
- GL_NEAREST:
- fFilterMin := GL_NEAREST;
- GL_LINEAR:
- fFilterMin := GL_LINEAR;
- GL_NEAREST_MIPMAP_NEAREST:
- fFilterMin := GL_NEAREST_MIPMAP_NEAREST;
- GL_LINEAR_MIPMAP_NEAREST:
- fFilterMin := GL_LINEAR_MIPMAP_NEAREST;
- GL_NEAREST_MIPMAP_LINEAR:
- fFilterMin := GL_NEAREST_MIPMAP_LINEAR;
- GL_LINEAR_MIPMAP_LINEAR:
- fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
- else
- raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
- end;
-
- //check MAG filter
- case aMag of
- GL_NEAREST:
- fFilterMag := GL_NEAREST;
- GL_LINEAR:
- fFilterMag := GL_LINEAR;
- else
- raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
- end;
-
- //apply filter
- if (ID > 0) then begin
- Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
- glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag);
-
- if (MipMap = mmNone) {$IFNDEF OPENGL_ES}or (Target = GL_TEXTURE_RECTANGLE){$ENDIF} then begin
- case fFilterMin of
- GL_NEAREST, GL_LINEAR:
- glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
- GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR:
- glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR:
- glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- end;
- end else
- glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);
-
- procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
- begin
- case aValue of
-{$IFNDEF OPENGL_ES}
- GL_CLAMP:
- aTarget := GL_CLAMP;
-{$ENDIF}
-
- GL_REPEAT:
- aTarget := GL_REPEAT;
-
- GL_CLAMP_TO_EDGE: begin
-{$IFNDEF OPENGL_ES}
- if not GL_VERSION_1_2 and not GL_EXT_texture_edge_clamp then
- aTarget := GL_CLAMP
- else
-{$ENDIF}
- aTarget := GL_CLAMP_TO_EDGE;
- end;
-
-{$IFNDEF OPENGL_ES}
- GL_CLAMP_TO_BORDER: begin
- if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then
- aTarget := GL_CLAMP_TO_BORDER
- else
- aTarget := GL_CLAMP;
- end;
-{$ENDIF}
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
- GL_MIRRORED_REPEAT: begin
- {$IFNDEF OPENGL_ES}
- if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
- {$ELSE}
- if GL_VERSION_2_0 then
- {$ENDIF}
- aTarget := GL_MIRRORED_REPEAT
- else
- raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
- end;
-{$IFEND}
- else
- raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
- end;
- end;
-
-begin
- CheckAndSetWrap(S, fWrapS);
- CheckAndSetWrap(T, fWrapT);
- CheckAndSetWrap(R, fWrapR);
-
- if (ID > 0) then begin
- Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
- glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS);
- glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- {$IFDEF OPENGL_ES} if GL_VERSION_3_0 then{$ENDIF}
- glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR);
-{$IFEND}
- end;
-end;
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
-
- procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
- begin
- if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or
- (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then
- fSwizzle[aIndex] := aValue
- else
- raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
- end;
-
-begin
-{$IFNDEF OPENGL_ES}
- if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
- raise EglBitmapNotSupported.Create('texture swizzle is not supported');
-{$ELSE}
- if not GL_VERSION_3_0 then
- raise EglBitmapNotSupported.Create('texture swizzle is not supported');
-{$ENDIF}
- CheckAndSetValue(r, 0);
- CheckAndSetValue(g, 1);
- CheckAndSetValue(b, 2);
- CheckAndSetValue(a, 3);
-
- if (ID > 0) then begin
- Bind(false);
-{$IFNDEF OPENGL_ES}
- glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0]));
-{$ELSE}
- glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_R, PGLint(@fSwizzle[0]));
- glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_G, PGLint(@fSwizzle[1]));
- glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_B, PGLint(@fSwizzle[2]));
- glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_A, PGLint(@fSwizzle[3]));
-{$ENDIF}
- end;
-end;
-{$IFEND}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.Bind({$IFNDEF OPENGL_ES}const aEnableTextureUnit: Boolean{$ENDIF});
-begin
-{$IFNDEF OPENGL_ES}
- if aEnableTextureUnit then
- glEnable(Target);
-{$ENDIF}
- if (ID > 0) then
- glBindTexture(Target, ID);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.Unbind({$IFNDEF OPENGL_ES}const aDisableTextureUnit: Boolean{$ENDIF});
-begin
-{$IFNDEF OPENGL_ES}
- if aDisableTextureUnit then
- glDisable(Target);
-{$ENDIF}
- glBindTexture(Target, 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
-var
- w, h: Integer;
-begin
- w := aDataObj.Width;
- h := aDataObj.Height;
- fDimension.Fields := [];
- if (w > 0) then
- fDimension.Fields := fDimension.Fields + [ffX];
- if (h > 0) then
- fDimension.Fields := fDimension.Fields + [ffY];
- fDimension.X := w;
- fDimension.Y := h;
-end;
-
-{$IFNDEF OPENGL_ES}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.DownloadData(const aDataObj: TglBitmapData): Boolean;
-var
- Temp: PByte;
- TempWidth, TempHeight: Integer;
- TempIntFormat: GLint;
- IntFormat: TglBitmapFormat;
- FormatDesc: TFormatDescriptor;
-begin
- result := false;
- Bind;
-
- // Request Data
- glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_WIDTH, @TempWidth);
- glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT, @TempHeight);
- glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat);
-
- FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor);
- IntFormat := FormatDesc.Format;
-
- // Getting data from OpenGL
- FormatDesc := TFormatDescriptor.Get(IntFormat);
- GetMem(Temp, FormatDesc.GetSize(TempWidth, TempHeight));
- try
- if FormatDesc.IsCompressed then begin
- if not Assigned(glGetCompressedTexImage) then
- raise EglBitmap.Create('compressed formats not supported by video adapter');
- glGetCompressedTexImage(Target, 0, Temp)
- end else
- glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
- aDataObj.SetData(Temp, IntFormat, TempWidth, TempHeight);
- result := true;
- except
- if Assigned(Temp) then
- FreeMem(Temp);
- raise;
- end;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create;
-begin
- if (ClassType = TglBitmap) then
- raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
- inherited Create;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aData: TglBitmapData);
-begin
- Create;
- UploadData(aData);
-end;
-
-{$IFNDEF OPENGL_ES}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap1D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
-var
- fd: TglBitmapFormatDescriptor;
-begin
- // Upload data
- fd := aDataObj.FormatDescriptor;
- if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then
- raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data');
-
- if fd.IsCompressed then begin
- if not Assigned(glCompressedTexImage1D) then
- raise EglBitmap.Create('compressed formats not supported by video adapter');
- glCompressedTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.GetSize(aDataObj.Width, 1), aDataObj.Data)
- end else if aBuildWithGlu then
- gluBuild1DMipmaps(Target, fd.glInternalFormat, aDataObj.Width, fd.glFormat, fd.glDataFormat, aDataObj.Data)
- else
- glTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.AfterConstruction;
-begin
- inherited;
- Target := GL_TEXTURE_1D;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
-var
- BuildWithGlu, TexRec: Boolean;
- TexSize: Integer;
-begin
- if not Assigned(aDataObj) then
- exit;
-
- // Check Texture Size
- if (aCheckSize) then begin
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
-
- if (aDataObj.Width > TexSize) then
- raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
-
- TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
- (Target = GL_TEXTURE_RECTANGLE);
- if not (IsPowerOfTwo(aDataObj.Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
- end;
-
- if (fID = 0) then
- CreateID;
- SetupParameters(BuildWithGlu);
- UploadDataIntern(aDataObj, BuildWithGlu);
- glAreTexturesResident(1, @fID, @fIsResident);
-
- inherited UploadData(aDataObj, aCheckSize);
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF});
-var
- fd: TglBitmapFormatDescriptor;
-begin
- fd := aDataObj.FormatDescriptor;
- if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then
- raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data');
-
- glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
- if fd.IsCompressed then begin
- if not Assigned(glCompressedTexImage2D) then
- raise EglBitmap.Create('compressed formats not supported by video adapter');
- glCompressedTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.GetSize(fDimension), aDataObj.Data)
-{$IFNDEF OPENGL_ES}
- end else if aBuildWithGlu then begin
- gluBuild2DMipmaps(aTarget, fd.ChannelCount, aDataObj.Width, aDataObj.Height, fd.glFormat, fd.glDataFormat, aDataObj.Data)
-{$ENDIF}
- end else begin
- glTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.AfterConstruction;
-begin
- inherited;
- Target := GL_TEXTURE_2D;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
-var
- {$IFNDEF OPENGL_ES}
- BuildWithGlu, TexRec: Boolean;
- {$ENDIF}
- PotTex: Boolean;
- TexSize: Integer;
-begin
- if not Assigned(aDataObj) then
- exit;
-
- // Check Texture Size
- if (aCheckSize) then begin
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
-
- if ((aDataObj.Width > TexSize) or (aDataObj.Height > TexSize)) then
- raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
-
- PotTex := IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height);
-{$IF NOT DEFINED(OPENGL_ES)}
- TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
- if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-{$ELSEIF DEFINED(OPENGL_ES_EXT)}
- if not PotTex and not GL_OES_texture_npot then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-{$ELSE}
- if not PotTex then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-{$IFEND}
- end;
-
- if (fID = 0) then
- CreateID;
- SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF});
- UploadDataIntern(aDataObj, Target{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF});
-{$IFNDEF OPENGL_ES}
- glAreTexturesResident(1, @fID, @fIsResident);
-{$ENDIF}
-
- inherited UploadData(aDataObj, aCheckSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
-var
- Temp: pByte;
- Size, w, h: Integer;
- FormatDesc: TFormatDescriptor;
-begin
- FormatDesc := TFormatDescriptor.Get(aFormat);
- if FormatDesc.IsCompressed then
- raise EglBitmapUnsupportedFormat.Create(aFormat);
-
- w := aRight - aLeft;
- h := aBottom - aTop;
- Size := FormatDesc.GetSize(w, h);
- GetMem(Temp, Size);
- try
- glPixelStorei(GL_PACK_ALIGNMENT, 1);
- glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
- aDataObj.SetData(Temp, aFormat, w, h);
- aDataObj.FlipVert;
- except
- if Assigned(Temp) then
- FreeMem(Temp);
- raise;
- end;
-end;
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapCubeMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.AfterConstruction;
-begin
- inherited;
-
-{$IFNDEF OPENGL_ES}
- if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
- raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
-{$ELSE}
- if not (GL_VERSION_2_0) then
- raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
-{$ENDIF}
-
- SetWrap;
- Target := GL_TEXTURE_CUBE_MAP;
-{$IFNDEF OPENGL_ES}
- fGenMode := GL_REFLECTION_MAP;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
-begin
- Assert(false, 'TglBitmapCubeMap.UploadData - Don''t call UploadData directly, use UploadCubeMap instead');
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
-var
- {$IFNDEF OPENGL_ES}
- BuildWithGlu: Boolean;
- {$ENDIF}
- TexSize: Integer;
-begin
- if (aCheckSize) then begin
- glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
-
- if (aDataObj.Width > TexSize) or (aDataObj.Height > TexSize) then
- raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenerateCubeMap - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
-
-{$IF NOT DEFINED(OPENGL_ES)}
- if not ((IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
-{$ELSEIF DEFINED(OPENGL_ES_EXT)}
- if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) and not GL_OES_texture_npot then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
-{$ELSE}
- if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) then
- raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
-{$IFEND}
- end;
-
- if (fID = 0) then
- CreateID;
- SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF});
- UploadDataIntern(aDataObj, aCubeTarget{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF});
-
- inherited UploadData(aDataObj, aCheckSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean{$ENDIF});
-begin
- inherited Bind({$IFNDEF OPENGL_ES}aEnableTextureUnit{$ENDIF});
-{$IFNDEF OPENGL_ES}
- if aEnableTexCoordsGen then begin
- glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
- glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
- glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
- glEnable(GL_TEXTURE_GEN_S);
- glEnable(GL_TEXTURE_GEN_T);
- glEnable(GL_TEXTURE_GEN_R);
- end;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean{$ENDIF});
-begin
- inherited Unbind({$IFNDEF OPENGL_ES}aDisableTextureUnit{$ENDIF});
-{$IFNDEF OPENGL_ES}
- if aDisableTexCoordsGen then begin
- glDisable(GL_TEXTURE_GEN_S);
- glDisable(GL_TEXTURE_GEN_T);
- glDisable(GL_TEXTURE_GEN_R);
- end;
-{$ENDIF}
-end;
-{$IFEND}
-
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapNormalMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
- TVec = Array[0..2] of Single;
- TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-
- PglBitmapNormalMapRec = ^TglBitmapNormalMapRec;
- TglBitmapNormalMapRec = record
- HalfSize : Integer;
- Func: TglBitmapNormalMapGetVectorFunc;
- end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := aHalfSize;
- aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
- aVec[2] := - (aPosition.X + 0.5 - aHalfSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := - aHalfSize;
- aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
- aVec[2] := aPosition.X + 0.5 - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := aPosition.X + 0.5 - aHalfSize;
- aVec[1] := aHalfSize;
- aVec[2] := aPosition.Y + 0.5 - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := aPosition.X + 0.5 - aHalfSize;
- aVec[1] := - aHalfSize;
- aVec[2] := - (aPosition.Y + 0.5 - aHalfSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := aPosition.X + 0.5 - aHalfSize;
- aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
- aVec[2] := aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
- aVec[0] := - (aPosition.X + 0.5 - aHalfSize);
- aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
- aVec[2] := - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec);
-var
- i: Integer;
- Vec: TVec;
- Len: Single;
-begin
- with FuncRec do begin
- with PglBitmapNormalMapRec(Args)^ do begin
- Func(Vec, Position, HalfSize);
-
- // Normalize
- Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
- if Len <> 0 then begin
- Vec[0] := Vec[0] * Len;
- Vec[1] := Vec[1] * Len;
- Vec[2] := Vec[2] * Len;
- end;
-
- // Scale Vector and AddVectro
- Vec[0] := Vec[0] * 0.5 + 0.5;
- Vec[1] := Vec[1] * 0.5 + 0.5;
- Vec[2] := Vec[2] * 0.5 + 0.5;
- end;
-
- // Set Color
- for i := 0 to 2 do
- Dest.Data.arr[i] := Round(Vec[i] * 255);
- end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapNormalMap.AfterConstruction;
-begin
- inherited;
-{$IFNDEF OPENGL_ES}
- fGenMode := GL_NORMAL_MAP;
-{$ENDIF}
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aCheckSize: Boolean);
-var
- Rec: TglBitmapNormalMapRec;
- SizeRec: TglBitmapSize;
- DataObj: TglBitmapData;
-begin
- Rec.HalfSize := aSize div 2;
-
- SizeRec.Fields := [ffX, ffY];
- SizeRec.X := aSize;
- SizeRec.Y := aSize;
-
- DataObj := TglBitmapData.Create;
- try
- // Positive X
- Rec.Func := glBitmapNormalMapPosX;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_X, aCheckSize);
-
- // Negative X
- Rec.Func := glBitmapNormalMapNegX;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aCheckSize);
-
- // Positive Y
- Rec.Func := glBitmapNormalMapPosY;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aCheckSize);
-
- // Negative Y
- Rec.Func := glBitmapNormalMapNegY;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aCheckSize);
-
- // Positive Z
- Rec.Func := glBitmapNormalMapPosZ;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aCheckSize);
-
- // Negative Z
- Rec.Func := glBitmapNormalMapNegZ;
- DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
- UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aCheckSize);
- finally
- FreeAndNil(DataObj);
- end;
-end;
-{$IFEND}
-
-initialization
- glBitmapSetDefaultFormat (tfEmpty);
- glBitmapSetDefaultMipmap (mmMipmap);
- glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
- glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
-{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
- glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);
-{$IFEND}
-
- glBitmapSetDefaultFreeDataAfterGenTexture(true);
- glBitmapSetDefaultDeleteTextureOnFree (true);
-
- TFormatDescriptor.Init;
-
-finalization
- TFormatDescriptor.Finalize;
-
-end.
+++ /dev/null
-{ this is the default configuration file of the glBitmap.pas
- please uncomment you preferences below, rename this file to glBitmapConf.inc
- and make it available to your compilers include paths }
-
-
-// enable support for OpenGL ES 1.1
-{.$DEFINE OPENGL_ES_1_1}
-
-// enable support for OpenGL ES 2.0
-{.$DEFINE OPENGL_ES_2_0}
-
-// enable support for OpenGL ES 3.0
-{.$DEFINE OPENGL_ES_3_0}
-
-// enable support for all OpenGL ES extensions
-{.$DEFINE OPENGL_ES_EXT}
-
-
-
-// activate to enable the support for SDL_surfaces
-{.$DEFINE GLB_SDL}
-
-// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
-{.$DEFINE GLB_DELPHI}
-
-// activate to enable the support for TLazIntfImage from Lazarus
-{.$DEFINE GLB_LAZARUS}
-
-
-
-// activate to enable the support of SDL_image to load files. (READ ONLY)
-// If you enable SDL_image all other libraries will be ignored!
-{.$DEFINE GLB_SDL_IMAGE}
-
-
-
-// activate to enable Lazarus TPortableNetworkGraphic support
-// if you enable this pngImage and libPNG will be ignored
-{.$DEFINE GLB_LAZ_PNG}
-
-// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
-// if you enable pngimage the libPNG will be ignored
-{.$DEFINE GLB_PNGIMAGE}
-
-// activate to use the libPNG -> http://www.libpng.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
-{.$DEFINE GLB_LIB_PNG}
-
-
-
-// activate to enable Lazarus TJPEGImage support
-// if you enable this delphi jpegs and libJPEG will be ignored
-{.$DEFINE GLB_LAZ_JPEG}
-
-// if you enable delphi jpegs the libJPEG will be ignored
-{.$DEFINE GLB_DELPHI_JPEG}
-
-// activate to use the libJPEG -> http://www.ijg.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
-{.$DEFINE GLB_LIB_JPEG}
-
\ No newline at end of file
--- /dev/null
+{ this is the default configuration file of the glBitmap.pas
+ please uncomment you preferences below, rename this file to glBitmapConf.inc
+ and make it available to your compilers include paths }
+
+
+// enable support for OpenGL ES 1.1
+{.$DEFINE OPENGL_ES_1_1}
+
+// enable support for OpenGL ES 2.0
+{.$DEFINE OPENGL_ES_2_0}
+
+// enable support for OpenGL ES 3.0
+{.$DEFINE OPENGL_ES_3_0}
+
+// enable support for all OpenGL ES extensions
+{.$DEFINE OPENGL_ES_EXT}
+
+
+
+// activate to enable the support for SDL_surfaces
+{.$DEFINE GLB_SDL}
+
+// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
+{.$DEFINE GLB_DELPHI}
+
+// activate to enable the support for TLazIntfImage from Lazarus
+{$DEFINE GLB_LAZARUS}
+
+
+
+// activate to enable the support of SDL_image to load files. (READ ONLY)
+// If you enable SDL_image all other libraries will be ignored!
+{.$DEFINE GLB_SDL_IMAGE}
+
+
+
+// activate to enable Lazarus TPortableNetworkGraphic support
+// if you enable this pngImage and libPNG will be ignored
+{$DEFINE GLB_LAZ_PNG}
+
+// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
+// if you enable pngimage the libPNG will be ignored
+{.$DEFINE GLB_PNGIMAGE}
+
+// activate to use the libPNG -> http://www.libpng.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
+{.$DEFINE GLB_LIB_PNG}
+
+
+
+// activate to enable Lazarus TJPEGImage support
+// if you enable this delphi jpegs and libJPEG will be ignored
+{$DEFINE GLB_LAZ_JPEG}
+
+// if you enable delphi jpegs the libJPEG will be ignored
+{.$DEFINE GLB_DELPHI_JPEG}
+
+// activate to use the libJPEG -> http://www.ijg.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
+{.$DEFINE GLB_LIB_JPEG}
+
\ No newline at end of file
+++ /dev/null
-glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
-http://www.opengl24.de/index.php?cat=header&file=glbitmap
-
-modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
-
-------------------------------------------------------------
-The contents of this project are used with permission, subject to
-the Mozilla Public License Version 1.1 (the "License"); you may
-not use this file except in compliance with the License. You may
-obtain a copy of the License at
-http://www.mozilla.org/MPL/MPL-1.1.html
-------------------------------------------------------------
-The glBitmap is a Delphi/FPC unit that contains several wrapper classes
-to manage OpenGL texture objects. Below you can find a list of the main
-functionality of this classes:
-- load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
-- load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
-- save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
-- save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
-- support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...)
-- manage texture properties (e.g. Filter, Clamp, Mipmap, ...)
-- upload texture data to video card
-- download texture data from video card
-- manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)
-
-check glBitmapConf.default.inc to configure the glBitmap.pas to fit your needs
-------------------------------------------------------------
-History
-20-11-2013
-- refactoring of the complete library
-- glBitmap is managed by git, so this history is not maintenanced any longer
-21-03-2010
-- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi
- then it's your problem if that isn't true. This prevents the unit for incompatibility
- with newer versions of Delphi.
-- Problems with D2009+ resolved (Thanks noeska and all i forgot)
-- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson)
-10-08-2008
-- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson)
-- Additional Datapointer for functioninterface now has the name CustomData
-24-07-2008
-- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson)
-- If you load an texture from an file the property Filename will be set to the name of the file
-- Three new properties to attach custom data to the Texture objects
- - CustomName (free for use string)
- - CustomNameW (free for use widestring)
- - CustomDataPointer (free for use pointer to attach other objects or complex structures)
-27-05-2008
-- RLE TGAs loaded much faster
-26-05-2008
-- fixed some problem with reading RLE TGAs.
-21-05-2008
-- function clone now only copys data if it's assigned and now it also copies the ID
-- it seems that lazarus dont like comments in comments.
-01-05-2008
-- It's possible to set the id of the texture
-- define GLB_NO_NATIVE_GL deactivated by default
-27-04-2008
-- Now supports the following libraries
- - SDL and SDL_image
- - libPNG
- - libJPEG
-- Linux compatibillity via free pascal compatibility (delphi sources optional)
-- BMPs now loaded manuel
-- Large restructuring
-- Property DataPtr now has the name Data
-- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR
-- Unused Depth removed
-- Function FreeData to freeing image data added
-24-10-2007
-- ImageID flag of TGAs was ignored. (Thanks Zwoetzen)
-15-11-2006
-- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER)
-- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel
-- Function ReadOpenGLExtension is now only intern
-29-06-2006
-- pngimage now disabled by default like all other versions.
-26-06-2006
-- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi)
-22-06-2006
-- Fixed some Problem with Delphi 5
-- Now uses the newest version of pngimage. Makes saving pngs much easier.
-22-03-2006
-- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi)
-09-03-2006
-- Internal Format ifDepth8 added
-- function GrabScreen now supports all uncompressed formats
-31-01-2006
-- AddAlphaFromglBitmap implemented
-29-12-2005
-- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID)
-28-12-2005
-- Width, Height and Depth internal changed to TglBitmapPixelPosition.
- property Width, Height, Depth are still existing and new property Dimension are avail
-11-12-2005
-- Added native OpenGL Support. Breaking the dglOpenGL "barrier".
-19-10-2005
-- Added function GrabScreen to class TglBitmap2D
-18-10-2005
-- Added support to Save images
-- Added function Clone to Clone Instance
-11-10-2005
-- Functions now works with Cardinals for each channel. Up to 32 Bits per channel.
- Usefull for Future
-- Several speed optimizations
-09-10-2005
-- Internal structure change. Loading of TGA, PNG and DDS improved.
- Data, format and size will now set directly with SetDataPtr.
-- AddFunc now works with all Types of Images and Formats
-- Some Funtions moved to Baseclass TglBitmap
-06-10-2005
-- Added Support to decompress DXT3 and DXT5 compressed Images.
-- Added Mapping to convert data from one format into an other.
-05-10-2005
-- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every
- supported Input format (supported by GetPixel) into any uncompresed Format
-- Added Support to decompress DXT1 compressed Images.
-- SwapColors replaced by ConvertTo
-04-10-2005
-- Added Support for compressed DDSs
-- Added new internal formats (DXT1, DXT3, DXT5)
-29-09-2005
-- Parameter Components renamed to InternalFormat
-23-09-2005
-- Some AllocMem replaced with GetMem (little speed change)
-- better exception handling. Better protection from memory leaks.
-22-09-2005
-- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only)
-- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5)
-07-09-2005
-- Added support for Grayscale textures
-- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8)
-10-07-2005
-- Added support for GL_VERSION_2_0
-- Added support for GL_EXT_texture_filter_anisotropic
-04-07-2005
-- Function FillWithColor fills the Image with one Color
-- Function LoadNormalMap added
-30-06-2005
-- ToNormalMap allows to Create an NormalMap from the Alphachannel
-- ToNormalMap now supports Sobel (nmSobel) function.
-29-06-2005
-- support for RLE Compressed RGB TGAs added
-28-06-2005
-- Class TglBitmapNormalMap added to support Normalmap generation
-- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures.
- 3 Filters are supported. (4 Samples, 3x3 and 5x5)
-16-06-2005
-- Method LoadCubeMapClass removed
-- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures
-- virtual abstract method GenTexture in class TglBitmap now is protected
-12-06-2005
-- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal
-10-06-2005
-- little enhancement for IsPowerOfTwo
-- TglBitmap1D.GenTexture now tests NPOT Textures
-06-06-2005
-- some little name changes. All properties or function with Texture in name are
- now without texture in name. We have allways texture so we dosn't name it.
-03-06-2005
-- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or
- TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception.
-02-06-2005
-- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle
-25-04-2005
-- Function Unbind added
-- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture.
-21-04-2005
-- class TglBitmapCubeMap added (allows to Create Cubemaps)
-29-03-2005
-- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/)
- To Enable png's use the define pngimage
-22-03-2005
-- New Functioninterface added
-- Function GetPixel added
-27-11-2004
-- Property BuildMipMaps renamed to MipMap
-21-11-2004
-- property Name removed.
-- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap
-22-05-2004
-- property name added. Only used in glForms!
-26-11-2003
-- property FreeDataAfterGenTexture is now available as default (default = true)
-- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it)
-- function MoveMemory replaced with function Move (little speed change)
-- several calculations stored in variables (little speed change)
-29-09-2003
-- property BuildMipsMaps added (default = true)
- if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps
-- property FreeDataAfterGenTexture added (default = true)
- if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated.
-- parameter DisableOtherTextureUnits of Bind removed
-- parameter FreeDataAfterGeneration of GenTextures removed
-12-09-2003
-- TglBitmap dosn't delete data if class was destroyed (fixed)
-09-09-2003
-- Bind now enables TextureUnits (by params)
-- GenTextures can leave data (by param)
-- LoadTextures now optimal
-03-09-2003
-- Performance optimization in AddFunc
-- procedure Bind moved to subclasses
-- Added new Class TglBitmap1D to support real OpenGL 1D Textures
-19-08-2003
-- Texturefilter and texturewrap now also as defaults
- Minfilter = GL_LINEAR_MIPMAP_LINEAR
- Magfilter = GL_LINEAR
- Wrap(str) = GL_CLAMP_TO_EDGE
-- Added new format tfCompressed to create a compressed texture.
-- propertys IsCompressed, TextureSize and IsResident added
- IsCompressed and TextureSize only contains data from level 0
-18-08-2003
-- Added function AddFunc to add PerPixelEffects to Image
-- LoadFromFunc now based on AddFunc
-- Invert now based on AddFunc
-- SwapColors now based on AddFunc
-16-08-2003
-- Added function FlipHorz
-15-08-2003
-- Added function LaodFromFunc to create images with function
-- Added function FlipVert
-- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported
-29-07-2003
-- Added Alphafunctions to calculate alpha per function
-- Added Alpha from ColorKey using alphafunctions
-28-07-2003
-- First full functionally Version of glBitmap
-- Support for 24Bit and 32Bit TGA Pictures added
-25-07-2003
-- begin of programming
--- /dev/null
+unit uglcArrayBuffer;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Array Buffer
+ Beispiel:
+ type
+ TVertex = packed record
+ pos: TgluVector3f; // vertex position
+ tex: TgluVector2f; // texture coordinates
+ nor: TgluVector3f; // normal
+ end;
+ PVertex = ^TVertex;
+
+ var
+ vBuffer: TglcArrayBuffer;
+ iBuffer: TglcArrayBuffer;
+ p: Pointer;
+
+ vBuffer := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
+ iBuffer := TglcArrayBuffer.Create(TglcBufferTarget.btElementArrayBuffer);
+ try
+ // write vertex data to vertex buffer
+ vBuffer.Bind;
+ vBuffer.BufferData(4, SizeOf(TresMeshVertex), TglcBufferUsage.buStaticDraw, nil);
+ p := vBuffer.MapBuffer(TglcBufferAccess.baWriteOnly);
+ try
+ PVertex(p).pos := gluVertex3f(0.0, 0.0, 0.0);
+ PVertex(p).tex := gluVertex2f(0.0, 0.5);
+ PVertex(p).nor := gluVertex3f(0.0, 1.0, 0.0);
+ inc(p, SizeOf(TVertex));
+ // ...
+ finally
+ vBuffer.UnmapBuffer;
+ vBuffer.Unbind;
+ end;
+
+ // write indices to index buffer
+ iBuffer.Bind;
+ iBuffer.BufferData(4, SizeOf(GLuint), TglcBufferUsage.buStaticDraw, nil);
+ p := iBuffer.MapBuffer(TglcBufferAccess.baWriteOnly);
+ try
+ PGLuint(p) := 0;
+ // ...
+ finally
+ iBuffer.UnmapBuffer;
+ iBuffer.Unbind;
+ end;
+
+ // use array buffers to draw primitive
+ vBuffer.Bind;
+ iBuffer.Bind;
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(3, GL_FLOAT, 8, Pointer(0));
+
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, 8, Pointer(3));
+
+ glEnableClientState(GL_NORMAL_ARRAY);
+ glNormalPointer(GL_FLOAT, 8, Pointer(5));
+
+ glEnableClientState(GL_INDEX_ARRAY);
+ glIndexPointer(GL_INT, 0, nil);
+
+ glDrawElements(GL_QUADS, iBuffer.DataCount, GL_UNSIGNED_INT, nil);
+
+ glDisableClientState(GL_INDEX_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+
+ fIndexBuffer.Unbind;
+ fVertexBuffer.Unbind;
+ finally
+ FreeAndNil(vBuffer);
+ FreeAndNil(iBuffer);
+ end; }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF}, sysutils, uglcTypes;
+
+type
+ EglcArrayBuffer = class(Exception);
+ TglcArrayBuffer = class(TObject)
+ private
+ fID: GLuint;
+ fTarget: TglcBufferTarget;
+ fUsage: TglcBufferUsage;
+ protected
+ fDataCount: Integer;
+ fDataSize: Integer;
+ public
+ property ID: gluInt read fID;
+ property Target: TglcBufferTarget read fTarget;
+ property Usage: TglcBufferUsage read fUsage;
+ property DataCount: Integer read fDataCount;
+ property DataSize: Integer read fDataSize;
+
+ procedure BufferData(const aDataCount, aDataSize: Cardinal; const aUsage: TglcBufferUsage; const aData: Pointer);
+ function MapBuffer(const aAccess: TglcBufferAccess): Pointer;
+ function MapBufferRange(const aOffset: GLintptr; const aSize: GLsizeiptr; const aAccess: TglcBufferAccess): Pointer;
+ procedure UnmapBuffer;
+ procedure Bind;
+ procedure Unbind;
+ constructor Create(const aTarget: TglcBufferTarget);
+ destructor Destroy; override;
+ end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcArrayBuffer///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.BufferData(const aDataCount, aDataSize: Cardinal; const aUsage: TglcBufferUsage; const aData: Pointer);
+begin
+ glGetError(); //clear Errors
+ Bind;
+ fDataCount := aDataCount;
+ fDataSize := aDataSize;
+ fUsage := aUsage;
+ glBufferData(GLenum(fTarget), fDataCount * fDataSize, aData, GLenum(fUsage));
+ glcCheckAndRaiseError;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+function TglcArrayBuffer.MapBuffer(const aAccess: TglcBufferAccess): Pointer;
+begin
+ glGetError();
+ result := nil;
+ if (fDataCount * fDataSize) <= 0 then
+ exit;
+{$IFNDEF OPENGL_ES}
+ result := glMapBuffer(GLenum(fTarget), GLenum(aAccess));
+{$ELSE}
+ if GL_OES_mapbuffer then
+ result := glMapBufferOES(GLenum(fTarget), GLenum(aAccess))
+ else
+ raise EglcArrayBuffer.Create('map buffer is not supported by video card');
+{$ENDIF}
+ glcCheckAndRaiseError;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+function TglcArrayBuffer.MapBufferRange(const aOffset: GLintptr; const aSize: GLsizeiptr; const aAccess: TglcBufferAccess): Pointer;
+begin
+ {$IFNDEF OPENGL_ES}
+ if not (GL_ARB_map_buffer_range or GL_VERSION_3_0) then
+ raise EglcArrayBuffer.Create('map buffer range is not supported by video card');
+ result := glMapBufferRange(GLenum(fTarget), aOffset, aSize, GLenum(aAccess));
+ {$ELSE}
+ if GL_VERSION_3_0 then
+ result := glMapBufferRange(GLenum(fTarget), aOffset, aSize, GLenum(aAccess))
+ else if GL_EXT_map_buffer_range then
+ result := glMapBufferRangeEXT(GLenum(fTarget), aOffset, aSize, GLenum(aAccess))
+ else
+ raise EglcArrayBuffer.Create('map buffer range is not supported by video card');
+ {$ENDIF}
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.UnmapBuffer;
+begin
+{$IFNDEF OPENGL_ES}
+ glUnmapBuffer(GLenum(fTarget));
+{$ELSE}
+ if GL_VERSION_3_0 then
+ glUnmapBuffer(GLenum(fTarget))
+ else if GL_OES_mapbuffer then
+ glUnmapBufferOES(GLenum(fTarget))
+ else
+ raise EglcArrayBuffer.Create('unmap buffer is not supported by video card');
+{$ENDIF}
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.Bind;
+begin
+ glBindBuffer(GLenum(fTarget), fID);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.Unbind;
+begin
+ glBindBuffer(GLenum(fTarget), 0);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+constructor TglcArrayBuffer.Create(const aTarget: TglcBufferTarget);
+begin
+{$IFNDEF OPENGL_ES}
+ if not (GL_ARB_Vertex_Buffer_Object or GL_VERSION_2_0) then
+ raise EglcArrayBuffer.Create('Create - VertexBuffer: not supported');
+{$ELSE}
+ if not GL_VERSION_2_0 then
+ raise EglcArrayBuffer.Create('Create - VertexBuffer: not supported');
+{$ENDIF}
+ glGetError();
+ inherited Create;
+ glGenBuffers(1, @fID);
+ fDataCount := 0;
+ fDataSize := 0;
+ fTarget := aTarget;
+ glcCheckAndRaiseError;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+destructor TglcArrayBuffer.Destroy;
+begin
+ glDeleteBuffers(1, @fID);
+ inherited Destroy;
+end;
+
+end.
+
--- /dev/null
+{ glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
+ http://www.opengl24.de/index.php?cat=header&file=glbitmap
+
+ modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
+
+ The contents of this file are used with permission, subject to
+ the Mozilla Public License Version 1.1 (the "License"); you may
+ not use this file except in compliance with the License. You may
+ obtain a copy of the License at
+ http://www.mozilla.org/MPL/MPL-1.1.html
+
+ The glBitmap is a Delphi/FPC unit that contains several wrapper classes
+ to manage OpenGL texture objects. Below you can find a list of the main
+ functionality of this classes:
+ - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
+ - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
+ - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...)
+ - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface)
+ - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...)
+ - manage texture properties (e.g. Filter, Clamp, Mipmap, ...)
+ - upload texture data to video card
+ - download texture data from video card
+ - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...) }
+
+unit uglcBitmap;
+
+{$I glBitmapConf.inc}
+
+// Delphi Versions
+{$IFDEF fpc}
+ {$MODE Delphi}
+
+ {$IFDEF CPUI386}
+ {$DEFINE CPU386}
+ {$ASMMODE INTEL}
+ {$ENDIF}
+
+ {$IFNDEF WINDOWS}
+ {$linklib c}
+ {$ENDIF}
+{$ENDIF}
+
+// Operation System
+{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
+ {$DEFINE GLB_WIN}
+{$ELSEIF DEFINED(LINUX)}
+ {$DEFINE GLB_LINUX}
+{$IFEND}
+
+// OpenGL ES
+{$IF DEFINED(OPENGL_ES_EXT)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
+{$IF DEFINED(OPENGL_ES_3_0)} {$DEFINE OPENGL_ES_2_0} {$IFEND}
+{$IF DEFINED(OPENGL_ES_2_0)} {$DEFINE OPENGL_ES_1_1} {$IFEND}
+{$IF DEFINED(OPENGL_ES_1_1)} {$DEFINE OPENGL_ES} {$IFEND}
+
+// checking define combinations
+//SDL Image
+{$IFDEF GLB_SDL_IMAGE}
+ {$IFNDEF GLB_SDL}
+ {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'}
+ {$DEFINE GLB_SDL}
+ {$ENDIF}
+
+ {$IFDEF GLB_LAZ_PNG}
+ {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'}
+ {$undef GLB_LAZ_PNG}
+ {$ENDIF}
+
+ {$IFDEF GLB_PNGIMAGE}
+ {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'}
+ {$undef GLB_PNGIMAGE}
+ {$ENDIF}
+
+ {$IFDEF GLB_LAZ_JPEG}
+ {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'}
+ {$undef GLB_LAZ_JPEG}
+ {$ENDIF}
+
+ {$IFDEF GLB_DELPHI_JPEG}
+ {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'}
+ {$undef GLB_DELPHI_JPEG}
+ {$ENDIF}
+
+ {$IFDEF GLB_LIB_PNG}
+ {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'}
+ {$undef GLB_LIB_PNG}
+ {$ENDIF}
+
+ {$IFDEF GLB_LIB_JPEG}
+ {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'}
+ {$undef GLB_LIB_JPEG}
+ {$ENDIF}
+
+ {$DEFINE GLB_SUPPORT_PNG_READ}
+ {$DEFINE GLB_SUPPORT_JPEG_READ}
+{$ENDIF}
+
+// Lazarus TPortableNetworkGraphic
+{$IFDEF GLB_LAZ_PNG}
+ {$IFNDEF GLB_LAZARUS}
+ {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'}
+ {$DEFINE GLB_LAZARUS}
+ {$ENDIF}
+
+ {$IFDEF GLB_PNGIMAGE}
+ {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
+ {$undef GLB_PNGIMAGE}
+ {$ENDIF}
+
+ {$IFDEF GLB_LIB_PNG}
+ {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
+ {$undef GLB_LIB_PNG}
+ {$ENDIF}
+
+ {$DEFINE GLB_SUPPORT_PNG_READ}
+ {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// PNG Image
+{$IFDEF GLB_PNGIMAGE}
+ {$IFDEF GLB_LIB_PNG}
+ {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'}
+ {$undef GLB_LIB_PNG}
+ {$ENDIF}
+
+ {$DEFINE GLB_SUPPORT_PNG_READ}
+ {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// libPNG
+{$IFDEF GLB_LIB_PNG}
+ {$DEFINE GLB_SUPPORT_PNG_READ}
+ {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// Lazarus TJPEGImage
+{$IFDEF GLB_LAZ_JPEG}
+ {$IFNDEF GLB_LAZARUS}
+ {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'}
+ {$DEFINE GLB_LAZARUS}
+ {$ENDIF}
+
+ {$IFDEF GLB_DELPHI_JPEG}
+ {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'}
+ {$undef GLB_DELPHI_JPEG}
+ {$ENDIF}
+
+ {$IFDEF GLB_LIB_JPEG}
+ {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'}
+ {$undef GLB_LIB_JPEG}
+ {$ENDIF}
+
+ {$DEFINE GLB_SUPPORT_JPEG_READ}
+ {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// JPEG Image
+{$IFDEF GLB_DELPHI_JPEG}
+ {$IFDEF GLB_LIB_JPEG}
+ {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'}
+ {$undef GLB_LIB_JPEG}
+ {$ENDIF}
+
+ {$DEFINE GLB_SUPPORT_JPEG_READ}
+ {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// libJPEG
+{$IFDEF GLB_LIB_JPEG}
+ {$DEFINE GLB_SUPPORT_JPEG_READ}
+ {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// general options
+{$EXTENDEDSYNTAX ON}
+{$LONGSTRINGS ON}
+{$ALIGN ON}
+{$IFNDEF FPC}
+ {$OPTIMIZATION ON}
+{$ENDIF}
+
+interface
+
+uses
+ {$IFDEF OPENGL_ES} dglOpenGLES,
+ {$ELSE} dglOpenGL, {$ENDIF}
+
+ {$IF DEFINED(GLB_WIN) AND
+ DEFINED(GLB_DELPHI)} windows, {$IFEND}
+
+ {$IFDEF GLB_SDL} SDL, {$ENDIF}
+ {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, Graphics, {$ENDIF}
+ {$IFDEF GLB_DELPHI} Dialogs, Graphics, Types, {$ENDIF}
+
+ {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF}
+ {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF}
+ {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF}
+ {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF}
+ {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF}
+
+ Classes, SysUtils;
+
+type
+{$IFNDEF fpc}
+ QWord = System.UInt64;
+ PQWord = ^QWord;
+
+ PtrInt = Longint;
+ PtrUInt = DWord;
+{$ENDIF}
+
+
+ { type that describes the format of the data stored in a texture.
+ the name of formats is composed of the following constituents:
+ - multiple channels:
+ - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved))
+ - width of the chanel in bit (4, 8, 16, ...)
+ - data type (e.g. ub, us, ui)
+ - number of elements of data types }
+ TglBitmapFormat = (
+ tfEmpty = 0,
+
+ tfAlpha4ub1, //< 1 x unsigned byte
+ tfAlpha8ub1, //< 1 x unsigned byte
+ tfAlpha16us1, //< 1 x unsigned short
+
+ tfLuminance4ub1, //< 1 x unsigned byte
+ tfLuminance8ub1, //< 1 x unsigned byte
+ tfLuminance16us1, //< 1 x unsigned short
+
+ tfLuminance4Alpha4ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+ tfLuminance6Alpha2ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+ tfLuminance8Alpha8ub2, //< 1 x unsigned byte (lum), 1 x unsigned byte (alpha)
+ tfLuminance12Alpha4us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha)
+ tfLuminance16Alpha16us2, //< 1 x unsigned short (lum), 1 x unsigned short (alpha)
+
+ tfR3G3B2ub1, //< 1 x unsigned byte (3bit red, 3bit green, 2bit blue)
+ tfRGBX4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd)
+ tfXRGB4us1, //< 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue)
+ tfR5G6B5us1, //< 1 x unsigned short (5bit red, 6bit green, 5bit blue)
+ tfRGB5X1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved)
+ tfX1RGB5us1, //< 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue)
+ tfRGB8ub3, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue)
+ tfRGBX8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved)
+ tfXRGB8ui1, //< 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue)
+ tfRGB10X2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved)
+ tfX2RGB10ui1, //< 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue)
+ tfRGB16us3, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue)
+
+ tfRGBA4us1, //< 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha)
+ tfARGB4us1, //< 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue)
+ tfRGB5A1us1, //< 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha)
+ tfA1RGB5us1, //< 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue)
+ tfRGBA8ui1, //< 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha)
+ tfARGB8ui1, //< 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue)
+ tfRGBA8ub4, //< 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha)
+ tfRGB10A2ui1, //< 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha)
+ tfA2RGB10ui1, //< 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue)
+ tfRGBA16us4, //< 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha)
+
+ tfBGRX4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved)
+ tfXBGR4us1, //< 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red)
+ tfB5G6R5us1, //< 1 x unsigned short (5bit blue, 6bit green, 5bit red)
+ tfBGR5X1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved)
+ tfX1BGR5us1, //< 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red)
+ tfBGR8ub3, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red)
+ tfBGRX8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved)
+ tfXBGR8ui1, //< 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red)
+ tfBGR10X2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved)
+ tfX2BGR10ui1, //< 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red)
+ tfBGR16us3, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red)
+
+ tfBGRA4us1, //< 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha)
+ tfABGR4us1, //< 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red)
+ tfBGR5A1us1, //< 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha)
+ tfA1BGR5us1, //< 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red)
+ tfBGRA8ui1, //< 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha)
+ tfABGR8ui1, //< 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red)
+ tfBGRA8ub4, //< 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha)
+ tfBGR10A2ui1, //< 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha)
+ tfA2BGR10ui1, //< 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red)
+ tfBGRA16us4, //< 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha)
+
+ tfDepth16us1, //< 1 x unsigned short (depth)
+ tfDepth24ui1, //< 1 x unsigned int (depth)
+ tfDepth32ui1, //< 1 x unsigned int (depth)
+
+ tfS3tcDtx1RGBA,
+ tfS3tcDtx3RGBA,
+ tfS3tcDtx5RGBA
+ );
+
+ { type to define suitable file formats }
+ TglBitmapFileType = (
+ {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} //< Portable Network Graphic file (PNG)
+ {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} //< JPEG file
+ ftDDS, //< Direct Draw Surface file (DDS)
+ ftTGA, //< Targa Image File (TGA)
+ ftBMP, //< Windows Bitmap File (BMP)
+ ftRAW); //< glBitmap RAW file format
+ TglBitmapFileTypes = set of TglBitmapFileType;
+
+ { possible mipmap types }
+ TglBitmapMipMap = (
+ mmNone, //< no mipmaps
+ mmMipmap, //< normal mipmaps
+ mmMipmapGlu); //< mipmaps generated with glu functions
+
+ { possible normal map functions }
+ TglBitmapNormalMapFunc = (
+ nm4Samples,
+ nmSobel,
+ nm3x3,
+ nm5x5);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglBitmap = class(Exception); //< glBitmap exception
+ EglBitmapNotSupported = class(Exception); //< exception for not supported functions
+ EglBitmapSizeToLarge = class(EglBitmap); //< exception for to large textures
+ EglBitmapNonPowerOfTwo = class(EglBitmap); //< exception for non power of two textures
+ EglBitmapUnsupportedFormat = class(EglBitmap) //< exception for unsupporetd formats
+ public
+ constructor Create(const aFormat: TglBitmapFormat); overload;
+ constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ { record that stores 4 unsigned integer values }
+ TglBitmapRec4ui = packed record
+ case Integer of
+ 0: (r, g, b, a: Cardinal);
+ 1: (arr: array[0..3] of Cardinal);
+ end;
+
+ { record that stores 4 unsigned byte values }
+ TglBitmapRec4ub = packed record
+ case Integer of
+ 0: (r, g, b, a: Byte);
+ 1: (arr: array[0..3] of Byte);
+ end;
+
+ { record that stores 4 unsigned long integer values }
+ TglBitmapRec4ul = packed record
+ case Integer of
+ 0: (r, g, b, a: QWord);
+ 1: (arr: array[0..3] of QWord);
+ end;
+
+ { structure to store pixel data in }
+ TglBitmapPixelData = packed record
+ Data: TglBitmapRec4ui; //< color data for each color channel
+ Range: TglBitmapRec4ui; //< maximal color value for each channel
+ Format: TglBitmapFormat; //< format of the pixel
+ end;
+ PglBitmapPixelData = ^TglBitmapPixelData;
+
+ TglBitmapSizeFields = set of (ffX, ffY);
+ TglBitmapSize = packed record
+ Fields: TglBitmapSizeFields;
+ X: Word;
+ Y: Word;
+ end;
+ TglBitmapPixelPosition = TglBitmapSize;
+
+ { describes the properties of a given texture data format }
+ TglBitmapFormatDescriptor = class(TObject)
+ private
+ // cached properties
+ fBytesPerPixel: Single; //< number of bytes for each pixel
+ fChannelCount: Integer; //< number of color channels
+ fMask: TglBitmapRec4ul; //< bitmask for each color channel
+ fRange: TglBitmapRec4ui; //< maximal value of each color channel
+
+ { @return @true if the format has a red color channel, @false otherwise }
+ function GetHasRed: Boolean;
+
+ { @return @true if the format has a green color channel, @false otherwise }
+ function GetHasGreen: Boolean;
+
+ { @return @true if the format has a blue color channel, @false otherwise }
+ function GetHasBlue: Boolean;
+
+ { @return @true if the format has a alpha color channel, @false otherwise }
+ function GetHasAlpha: Boolean;
+
+ { @return @true if the format has any color color channel, @false otherwise }
+ function GetHasColor: Boolean;
+
+ { @return @true if the format is a grayscale format, @false otherwise }
+ function GetIsGrayscale: Boolean;
+
+ { @return @true if the format is supported by OpenGL, @false otherwise }
+ function GetHasOpenGLSupport: Boolean;
+
+ protected
+ fFormat: TglBitmapFormat; //< format this descriptor belongs to
+ fWithAlpha: TglBitmapFormat; //< suitable format with alpha channel
+ fWithoutAlpha: TglBitmapFormat; //< suitable format without alpha channel
+ fOpenGLFormat: TglBitmapFormat; //< suitable format that is supported by OpenGL
+ fRGBInverted: TglBitmapFormat; //< suitable format with inverted RGB channels
+ fUncompressed: TglBitmapFormat; //< suitable format with uncompressed data
+
+ fBitsPerPixel: Integer; //< number of bits per pixel
+ fIsCompressed: Boolean; //< @true if the format is compressed, @false otherwise
+
+ fPrecision: TglBitmapRec4ub; //< number of bits for each color channel
+ fShift: TglBitmapRec4ub; //< bit offset for each color channel
+
+ fglFormat: GLenum; //< OpenGL format enum (e.g. GL_RGB)
+ fglInternalFormat: GLenum; //< OpenGL internal format enum (e.g. GL_RGB8)
+ fglDataFormat: GLenum; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)
+
+ { set values for this format descriptor }
+ procedure SetValues; virtual;
+
+ { calculate cached values }
+ procedure CalcValues;
+ public
+ property Format: TglBitmapFormat read fFormat; //< format this descriptor belongs to
+ property ChannelCount: Integer read fChannelCount; //< number of color channels
+ property IsCompressed: Boolean read fIsCompressed; //< @true if the format is compressed, @false otherwise
+ property BitsPerPixel: Integer read fBitsPerPixel; //< number of bytes per pixel
+ property BytesPerPixel: Single read fBytesPerPixel; //< number of bits per pixel
+
+ property Precision: TglBitmapRec4ub read fPrecision; //< number of bits for each color channel
+ property Shift: TglBitmapRec4ub read fShift; //< bit offset for each color channel
+ property Range: TglBitmapRec4ui read fRange; //< maximal value of each color channel
+ property Mask: TglBitmapRec4ul read fMask; //< bitmask for each color channel
+
+ property RGBInverted: TglBitmapFormat read fRGBInverted; //< suitable format with inverted RGB channels
+ property WithAlpha: TglBitmapFormat read fWithAlpha; //< suitable format with alpha channel
+ property WithoutAlpha: TglBitmapFormat read fWithAlpha; //< suitable format without alpha channel
+ property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; //< suitable format that is supported by OpenGL
+ property Uncompressed: TglBitmapFormat read fUncompressed; //< suitable format with uncompressed data
+
+ property glFormat: GLenum read fglFormat; //< OpenGL format enum (e.g. GL_RGB)
+ property glInternalFormat: GLenum read fglInternalFormat; //< OpenGL internal format enum (e.g. GL_RGB8)
+ property glDataFormat: GLenum read fglDataFormat; //< OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)
+
+ property HasRed: Boolean read GetHasRed; //< @true if the format has a red color channel, @false otherwise
+ property HasGreen: Boolean read GetHasGreen; //< @true if the format has a green color channel, @false otherwise
+ property HasBlue: Boolean read GetHasBlue; //< @true if the format has a blue color channel, @false otherwise
+ property HasAlpha: Boolean read GetHasAlpha; //< @true if the format has a alpha color channel, @false otherwise
+ property HasColor: Boolean read GetHasColor; //< @true if the format has any color color channel, @false otherwise
+ property IsGrayscale: Boolean read GetIsGrayscale; //< @true if the format is a grayscale format, @false otherwise
+
+ property HasOpenGLSupport: Boolean read GetHasOpenGLSupport; //< @true if the format is supported by OpenGL, @false otherwise
+
+ function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual;
+ function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
+
+ { constructor }
+ constructor Create;
+ public
+ { get the format descriptor by a given OpenGL internal format
+ @param aInternalFormat OpenGL internal format to get format descriptor for
+ @returns suitable format descriptor or tfEmpty-Descriptor }
+ class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglBitmapData = class;
+
+ { structure to store data for converting in }
+ TglBitmapFunctionRec = record
+ Sender: TglBitmapData; //< texture object that stores the data to convert
+ Size: TglBitmapSize; //< size of the texture
+ Position: TglBitmapPixelPosition; //< position of the currently pixel
+ Source: TglBitmapPixelData; //< pixel data of the current pixel
+ Dest: TglBitmapPixelData; //< new data of the pixel (must be filled in)
+ Args: Pointer; //< user defined args that was passed to the convert function
+ end;
+
+ { callback to use for converting texture data }
+ TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ { class to store texture data in. used to load, save and
+ manipulate data before assigned to texture object
+ all operations on a data object can be done from a background thread }
+ TglBitmapData = class
+ private { fields }
+
+ fData: PByte; //< texture data
+ fDimension: TglBitmapSize; //< pixel size of the data
+ fFormat: TglBitmapFormat; //< format the texture data is stored in
+ fFilename: String; //< file the data was load from
+
+ fScanlines: array of PByte; //< pointer to begin of each line
+ fHasScanlines: Boolean; //< @true if scanlines are initialized, @false otherwise
+
+ private { getter / setter }
+
+ { @returns the format descriptor suitable to the texture data format }
+ function GetFormatDescriptor: TglBitmapFormatDescriptor;
+
+ { @returns the width of the texture data (in pixel) or -1 if no data is set }
+ function GetWidth: Integer;
+
+ { @returns the height of the texture data (in pixel) or -1 if no data is set }
+ function GetHeight: Integer;
+
+ { get scanline at index aIndex
+ @returns Pointer to start of line or @nil }
+ function GetScanlines(const aIndex: Integer): PByte;
+
+ { set new value for the data format. only possible if new format has the same pixel size.
+ if you want to convert the texture data, see ConvertTo function }
+ procedure SetFormat(const aValue: TglBitmapFormat);
+
+ private { internal misc }
+
+ { splits a resource identifier into the resource and it's type
+ @param aResource resource identifier to split and store name in
+ @param aResType type of the resource }
+ procedure PrepareResType(var aResource: String; var aResType: PChar);
+
+ { updates scanlines array }
+ procedure UpdateScanlines;
+
+ private { internal load and save }
+{$IFDEF GLB_SUPPORT_PNG_READ}
+ { try to load a PNG from a stream
+ @param aStream stream to load PNG from
+ @returns @true on success, @false otherwise }
+ function LoadPNG(const aStream: TStream): Boolean; virtual;
+{$ENDIF}
+
+{$ifdef GLB_SUPPORT_PNG_WRITE}
+ { save texture data as PNG to stream
+ @param aStream stream to save data to}
+ procedure SavePNG(const aStream: TStream); virtual;
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_READ}
+ { try to load a JPEG from a stream
+ @param aStream stream to load JPEG from
+ @returns @true on success, @false otherwise }
+ function LoadJPEG(const aStream: TStream): Boolean; virtual;
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_WRITE}
+ { save texture data as JPEG to stream
+ @param aStream stream to save data to}
+ procedure SaveJPEG(const aStream: TStream); virtual;
+{$ENDIF}
+
+ { try to load a RAW image from a stream
+ @param aStream stream to load RAW image from
+ @returns @true on success, @false otherwise }
+ function LoadRAW(const aStream: TStream): Boolean;
+
+ { save texture data as RAW image to stream
+ @param aStream stream to save data to}
+ procedure SaveRAW(const aStream: TStream);
+
+ { try to load a BMP from a stream
+ @param aStream stream to load BMP from
+ @returns @true on success, @false otherwise }
+ function LoadBMP(const aStream: TStream): Boolean;
+
+ { save texture data as BMP to stream
+ @param aStream stream to save data to}
+ procedure SaveBMP(const aStream: TStream);
+
+ { try to load a TGA from a stream
+ @param aStream stream to load TGA from
+ @returns @true on success, @false otherwise }
+ function LoadTGA(const aStream: TStream): Boolean;
+
+ { save texture data as TGA to stream
+ @param aStream stream to save data to}
+ procedure SaveTGA(const aStream: TStream);
+
+ { try to load a DDS from a stream
+ @param aStream stream to load DDS from
+ @returns @true on success, @false otherwise }
+ function LoadDDS(const aStream: TStream): Boolean;
+
+ { save texture data as DDS to stream
+ @param aStream stream to save data to}
+ procedure SaveDDS(const aStream: TStream);
+
+ public { properties }
+ property Data: PByte read fData; //< texture data (be carefull with this!)
+ property Dimension: TglBitmapSize read fDimension; //< size of the texture data (in pixel)
+ property Filename: String read fFilename; //< file the data was loaded from
+ property Width: Integer read GetWidth; //< width of the texture data (in pixel)
+ property Height: Integer read GetHeight; //< height of the texture data (in pixel)
+ property Format: TglBitmapFormat read fFormat write SetFormat; //< format the texture data is stored in
+ property Scanlines[const aIndex: Integer]: PByte read GetScanlines; //< pointer to begin of line at given index or @nil
+
+ property FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor; //< descriptor object that describes the format of the stored data
+
+ public { flip }
+
+ { flip texture horizontal
+ @returns @true in success, @false otherwise }
+ function FlipHorz: Boolean; virtual;
+
+ { flip texture vertical
+ @returns @true in success, @false otherwise }
+ function FlipVert: Boolean; virtual;
+
+ public { load }
+
+ { load a texture from a file
+ @param aFilename file to load texuture from }
+ procedure LoadFromFile(const aFilename: String);
+
+ { load a texture from a stream
+ @param aStream stream to load texture from }
+ procedure LoadFromStream(const aStream: TStream); virtual;
+
+ { use a function to generate texture data
+ @param aSize size of the texture
+ @param aFormat format of the texture data
+ @param aFunc callback to use for generation
+ @param aArgs user defined paramaters (use at will) }
+ procedure LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil);
+
+ { load a texture from a resource
+ @param aInstance resource handle
+ @param aResource resource indentifier
+ @param aResType resource type (if known) }
+ procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
+
+ { load a texture from a resource id
+ @param aInstance resource handle
+ @param aResource resource ID
+ @param aResType resource type }
+ procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+
+ public { save }
+
+ { save texture data to a file
+ @param aFilename filename to store texture in
+ @param aFileType file type to store data into }
+ procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
+
+ { save texture data to a stream
+ @param aFilename filename to store texture in
+ @param aFileType file type to store data into }
+ procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
+
+ public { convert }
+
+ { convert texture data using a user defined callback
+ @param aFunc callback to use for converting
+ @param aCreateTemp create a temporary buffer to use for converting
+ @param aArgs user defined paramters (use at will)
+ @returns @true if converting was successful, @false otherwise }
+ function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
+
+ { convert texture data using a user defined callback
+ @param aSource glBitmap to read data from
+ @param aFunc callback to use for converting
+ @param aCreateTemp create a temporary buffer to use for converting
+ @param aFormat format of the new data
+ @param aArgs user defined paramters (use at will)
+ @returns @true if converting was successful, @false otherwise }
+ function Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
+ const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
+
+ { convert texture data using a specific format
+ @param aFormat new format of texture data
+ @returns @true if converting was successful, @false otherwise }
+ function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
+
+{$IFDEF GLB_SDL}
+ public { SDL }
+
+ { assign texture data to SDL surface
+ @param aSurface SDL surface to write data to
+ @returns @true on success, @false otherwise }
+ function AssignToSurface(out aSurface: PSDL_Surface): Boolean;
+
+ { assign texture data from SDL surface
+ @param aSurface SDL surface to read data from
+ @returns @true on success, @false otherwise }
+ function AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
+
+ { assign alpha channel data to SDL surface
+ @param aSurface SDL surface to write alpha channel data to
+ @returns @true on success, @false otherwise }
+ function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
+
+ { assign alpha channel data from SDL surface
+ @param aSurface SDL surface to read data from
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+{$ENDIF}
+
+{$IFDEF GLB_DELPHI}
+ public { Delphi }
+
+ { assign texture data to TBitmap object
+ @param aBitmap TBitmap to write data to
+ @returns @true on success, @false otherwise }
+ function AssignToBitmap(const aBitmap: TBitmap): Boolean;
+
+ { assign texture data from TBitmap object
+ @param aBitmap TBitmap to read data from
+ @returns @true on success, @false otherwise }
+ function AssignFromBitmap(const aBitmap: TBitmap): Boolean;
+
+ { assign alpha channel data to TBitmap object
+ @param aBitmap TBitmap to write data to
+ @returns @true on success, @false otherwise }
+ function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
+
+ { assign alpha channel data from TBitmap object
+ @param aBitmap TBitmap to read data from
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+{$ENDIF}
+
+{$IFDEF GLB_LAZARUS}
+ public { Lazarus }
+
+ { assign texture data to TLazIntfImage object
+ @param aImage TLazIntfImage to write data to
+ @returns @true on success, @false otherwise }
+ function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+
+ { assign texture data from TLazIntfImage object
+ @param aImage TLazIntfImage to read data from
+ @returns @true on success, @false otherwise }
+ function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
+
+ { assign alpha channel data to TLazIntfImage object
+ @param aImage TLazIntfImage to write data to
+ @returns @true on success, @false otherwise }
+ function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+
+ { assign alpha channel data from TLazIntfImage object
+ @param aImage TLazIntfImage to read data from
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+{$ENDIF}
+
+ public { Alpha }
+ { load alpha channel data from resource
+ @param aInstance resource handle
+ @param aResource resource ID
+ @param aResType resource type
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+ { load alpha channel data from resource ID
+ @param aInstance resource handle
+ @param aResourceID resource ID
+ @param aResType resource type
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+ { add alpha channel data from function
+ @param aFunc callback to get data from
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
+
+ { add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap)
+ @param aFilename file to load alpha channel data from
+ @param aFunc callback to use for converting
+ @param aArgs SetFormat user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+ { add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap)
+ @param aStream stream to load alpha channel data from
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+ { add alpha channel data from existing glBitmap object
+ @param aBitmap TglBitmap to copy alpha channel data from
+ @param aFunc callback to use for converting
+ @param aArgs user defined parameters (use at will)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+
+ { add alpha to pixel if the pixels color is greter than the given color value
+ @param aRed red threshold (0-255)
+ @param aGreen green threshold (0-255)
+ @param aBlue blue threshold (0-255)
+ @param aDeviatation accepted deviatation (0-255)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
+
+ { add alpha to pixel if the pixels color is greter than the given color value
+ @param aRed red threshold (0-Range.r)
+ @param aGreen green threshold (0-Range.g)
+ @param aBlue blue threshold (0-Range.b)
+ @param aDeviatation accepted deviatation (0-max(Range.rgb))
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
+
+ { add alpha to pixel if the pixels color is greter than the given color value
+ @param aRed red threshold (0.0-1.0)
+ @param aGreen green threshold (0.0-1.0)
+ @param aBlue blue threshold (0.0-1.0)
+ @param aDeviatation accepted deviatation (0.0-1.0)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
+
+ { add a constand alpha value to all pixels
+ @param aAlpha alpha value to add (0-255)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromValue(const aAlpha: Byte): Boolean;
+
+ { add a constand alpha value to all pixels
+ @param aAlpha alpha value to add (0-max(Range.rgb))
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
+
+ { add a constand alpha value to all pixels
+ @param aAlpha alpha value to add (0.0-1.0)
+ @returns @true on success, @false otherwise }
+ function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
+
+ { remove alpha channel
+ @returns @true on success, @false otherwise }
+ function RemoveAlpha: Boolean; virtual;
+
+ public { fill }
+ { fill complete texture with one color
+ @param aRed red color for border (0-255)
+ @param aGreen green color for border (0-255)
+ @param aBlue blue color for border (0-255)
+ @param aAlpha alpha color for border (0-255) }
+ procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
+
+ { fill complete texture with one color
+ @param aRed red color for border (0-Range.r)
+ @param aGreen green color for border (0-Range.g)
+ @param aBlue blue color for border (0-Range.b)
+ @param aAlpha alpha color for border (0-Range.a) }
+ procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
+
+ { fill complete texture with one color
+ @param aRed red color for border (0.0-1.0)
+ @param aGreen green color for border (0.0-1.0)
+ @param aBlue blue color for border (0.0-1.0)
+ @param aAlpha alpha color for border (0.0-1.0) }
+ procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);
+
+ public { Misc }
+
+ { set data pointer of texture data
+ @param aData pointer to new texture data
+ @param aFormat format of the data stored at aData
+ @param aWidth width of the texture data
+ @param aHeight height of the texture data }
+ procedure SetData(const aData: PByte; const aFormat: TglBitmapFormat;
+ const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;
+
+ { create a clone of the current object
+ @returns clone of this object}
+ function Clone: TglBitmapData;
+
+ { invert color data (bitwise not)
+ @param aRed invert red channel
+ @param aGreen invert green channel
+ @param aBlue invert blue channel
+ @param aAlpha invert alpha channel }
+ procedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
+
+ { create normal map from texture data
+ @param aFunc normal map function to generate normalmap with
+ @param aScale scale of the normale stored in the normal map
+ @param aUseAlpha generate normalmap from alpha channel data (if present) }
+ procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3;
+ const aScale: Single = 2; const aUseAlpha: Boolean = false);
+
+ public { constructor }
+
+ { constructor - creates a texutre data object }
+ constructor Create; overload;
+
+ { constructor - creates a texture data object and loads it from a file
+ @param aFilename file to load texture from }
+ constructor Create(const aFileName: String); overload;
+
+ { constructor - creates a texture data object and loads it from a stream
+ @param aStream stream to load texture from }
+ constructor Create(const aStream: TStream); overload;
+
+ { constructor - creates a texture data object with the given size, format and data
+ @param aSize size of the texture
+ @param aFormat format of the given data
+ @param aData texture data - be carefull: the data will now be managed by the texture data object }
+ constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
+
+ { constructor - creates a texture data object with the given size and format and uses the given callback to create the data
+ @param aSize size of the texture
+ @param aFormat format of the given data
+ @param aFunc callback to use for generating the data
+ @param aArgs user defined parameters (use at will) }
+ constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
+
+ { constructor - creates a texture data object and loads it from a resource
+ @param aInstance resource handle
+ @param aResource resource indentifier
+ @param aResType resource type (if known) }
+ constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
+
+ { constructor - creates a texture data object and loads it from a resource
+ @param aInstance resource handle
+ @param aResourceID resource ID
+ @param aResType resource type (if known) }
+ constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
+
+ { destructor }
+ destructor Destroy; override;
+
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ { base class for all glBitmap classes. used to manage OpenGL texture objects
+ all operations on a bitmap object must be done from the render thread }
+ TglBitmap = class
+ protected
+ fID: GLuint; //< name of the OpenGL texture object
+ fTarget: GLuint; //< texture target (e.g. GL_TEXTURE_2D)
+ fDeleteTextureOnFree: Boolean; //< delete OpenGL texture object when this object is destroyed
+
+ // texture properties
+ fFilterMin: GLenum; //< min filter to apply to the texture
+ fFilterMag: GLenum; //< mag filter to apply to the texture
+ fWrapS: GLenum; //< texture wrapping for x axis
+ fWrapT: GLenum; //< texture wrapping for y axis
+ fWrapR: GLenum; //< texture wrapping for z axis
+ fAnisotropic: Integer; //< anisotropic level
+ fBorderColor: array[0..3] of Single; //< color of the texture border
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ //Swizzle
+ fSwizzle: array[0..3] of GLenum; //< color channel swizzle
+{$IFEND}
+{$IFNDEF OPENGL_ES}
+ fIsResident: GLboolean; //< @true if OpenGL texture object has data, @false otherwise
+{$ENDIF}
+
+ fDimension: TglBitmapSize; //< size of this texture
+ fMipMap: TglBitmapMipMap; //< mipmap type
+
+ // CustomData
+ fCustomData: Pointer; //< user defined data
+ fCustomName: String; //< user defined name
+ fCustomNameW: WideString; //< user defined name
+ protected
+ { @returns the actual width of the texture }
+ function GetWidth: Integer; virtual;
+
+ { @returns the actual height of the texture }
+ function GetHeight: Integer; virtual;
+
+ protected
+ { set a new value for fCustomData }
+ procedure SetCustomData(const aValue: Pointer);
+
+ { set a new value for fCustomName }
+ procedure SetCustomName(const aValue: String);
+
+ { set a new value for fCustomNameW }
+ procedure SetCustomNameW(const aValue: WideString);
+
+ { set new value for fDeleteTextureOnFree }
+ procedure SetDeleteTextureOnFree(const aValue: Boolean);
+
+ { set name of OpenGL texture object }
+ procedure SetID(const aValue: Cardinal);
+
+ { set new value for fMipMap }
+ procedure SetMipMap(const aValue: TglBitmapMipMap);
+
+ { set new value for target }
+ procedure SetTarget(const aValue: Cardinal);
+
+ { set new value for fAnisotrophic }
+ procedure SetAnisotropic(const aValue: Integer);
+
+ protected
+ { create OpenGL texture object (delete exisiting object if exists) }
+ procedure CreateID;
+
+ { setup texture parameters }
+ procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF});
+
+ protected
+ property Width: Integer read GetWidth; //< the actual width of the texture
+ property Height: Integer read GetHeight; //< the actual height of the texture
+
+ public
+ property ID: Cardinal read fID write SetID; //< name of the OpenGL texture object
+ property Target: Cardinal read fTarget write SetTarget; //< texture target (e.g. GL_TEXTURE_2D)
+ property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; //< delete texture object when this object is destroyed
+
+ property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; //< mipmap type
+ property Anisotropic: Integer read fAnisotropic write SetAnisotropic; //< anisotropic level
+
+ property CustomData: Pointer read fCustomData write SetCustomData; //< user defined data (use at will)
+ property CustomName: String read fCustomName write SetCustomName; //< user defined name (use at will)
+ property CustomNameW: WideString read fCustomNameW write SetCustomNameW; //< user defined name (as WideString; use at will)
+
+ property Dimension: TglBitmapSize read fDimension; //< size of the texture
+{$IFNDEF OPENGL_ES}
+ property IsResident: GLboolean read fIsResident; //< @true if OpenGL texture object has data, @false otherwise
+{$ENDIF}
+
+ { this method is called after the constructor and sets the default values of this object }
+ procedure AfterConstruction; override;
+
+ { this method is called before the destructor and does some cleanup }
+ procedure BeforeDestruction; override;
+
+ public
+{$IFNDEF OPENGL_ES}
+ { set the new value for texture border color
+ @param aRed red color for border (0.0-1.0)
+ @param aGreen green color for border (0.0-1.0)
+ @param aBlue blue color for border (0.0-1.0)
+ @param aAlpha alpha color for border (0.0-1.0) }
+ procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
+{$ENDIF}
+
+ public
+ { set new texture filer
+ @param aMin min filter
+ @param aMag mag filter }
+ procedure SetFilter(const aMin, aMag: GLenum);
+
+ { set new texture wrapping
+ @param S texture wrapping for x axis
+ @param T texture wrapping for y axis
+ @param R texture wrapping for z axis }
+ procedure SetWrap(
+ const S: GLenum = GL_CLAMP_TO_EDGE;
+ const T: GLenum = GL_CLAMP_TO_EDGE;
+ const R: GLenum = GL_CLAMP_TO_EDGE);
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ { set new swizzle
+ @param r swizzle for red channel
+ @param g swizzle for green channel
+ @param b swizzle for blue channel
+ @param a swizzle for alpha channel }
+ procedure SetSwizzle(const r, g, b, a: GLenum);
+{$IFEND}
+
+ public
+ { bind texture
+ @param aEnableTextureUnit enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) }
+ procedure Bind({$IFNDEF OPENGL_ES}const aEnableTextureUnit: Boolean = true{$ENDIF}); virtual;
+
+ { bind texture
+ @param aDisableTextureUnit disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) }
+ procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTextureUnit: Boolean = true{$ENDIF}); virtual;
+
+ { upload texture data from given data object to video card
+ @param aData texture data object that contains the actual data
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual;
+
+{$IFNDEF OPENGL_ES}
+ { download texture data from video card and store it into given data object
+ @returns @true when download was successfull, @false otherwise }
+ function DownloadData(const aDataObj: TglBitmapData): Boolean; virtual;
+{$ENDIF}
+ public
+ { constructor - creates an empty texture }
+ constructor Create; overload;
+
+ { constructor - creates an texture object and uploads the given data }
+ constructor Create(const aData: TglBitmapData); overload;
+
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IF NOT DEFINED(OPENGL_ES)}
+ { wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D
+ all operations on a bitmap object must be done from the render thread }
+ TglBitmap1D = class(TglBitmap)
+ protected
+
+ { upload the texture data to video card
+ @param aDataObj texture data object that contains the actual data
+ @param aBuildWithGlu use glu functions to build mipmaps }
+ procedure UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
+
+ public
+ property Width; //< actual with of the texture
+
+ { this method is called after constructor and initializes the object }
+ procedure AfterConstruction; override;
+
+ { upload texture data from given data object to video card
+ @param aData texture data object that contains the actual data
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
+
+ end;
+{$IFEND}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ { wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D)
+ all operations on a bitmap object must be done from the render thread }
+ TglBitmap2D = class(TglBitmap)
+ protected
+
+ { upload the texture data to video card
+ @param aDataObj texture data object that contains the actual data
+ @param aTarget target o upload data to (e.g. GL_TEXTURE_2D)
+ @param aBuildWithGlu use glu functions to build mipmaps }
+ procedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum
+ {$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF});
+
+ public
+ property Width; //< actual width of the texture
+ property Height; //< actual height of the texture
+
+ { this method is called after constructor and initializes the object }
+ procedure AfterConstruction; override;
+
+ { upload texture data from given data object to video card
+ @param aData texture data object that contains the actual data
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
+
+ public
+
+ { copy a part of the frame buffer to the texture
+ @param aTop topmost pixel to copy
+ @param aLeft leftmost pixel to copy
+ @param aRight rightmost pixel to copy
+ @param aBottom bottommost pixel to copy
+ @param aFormat format to store data in
+ @param aDataObj texture data object to store the data in }
+ class procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
+
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+ { wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP)
+ all operations on a bitmap object must be done from the render thread }
+ TglBitmapCubeMap = class(TglBitmap2D)
+ protected
+ {$IFNDEF OPENGL_ES}
+ fGenMode: Integer; //< generation mode for the cube map (e.g. GL_REFLECTION_MAP)
+ {$ENDIF}
+
+ public
+ { this method is called after constructor and initializes the object }
+ procedure AfterConstruction; override;
+
+ { upload texture data from given data object to video card
+ @param aData texture data object that contains the actual data
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
+
+ { upload texture data from given data object to video card
+ @param aData texture data object that contains the actual data
+ @param aCubeTarget cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X)
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
+
+ { bind texture
+ @param aEnableTexCoordsGen enable cube map generator
+ @param aEnableTextureUnit enable texture unit }
+ procedure Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true{$ENDIF}); reintroduce; virtual;
+
+ { unbind texture
+ @param aDisableTexCoordsGen disable cube map generator
+ @param aDisableTextureUnit disable texture unit }
+ procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true{$ENDIF}); reintroduce; virtual;
+ end;
+{$IFEND}
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ { wrapper class for cube normal maps
+ all operations on a bitmap object must be done from the render thread }
+ TglBitmapNormalMap = class(TglBitmapCubeMap)
+ public
+ { this method is called after constructor and initializes the object }
+ procedure AfterConstruction; override;
+
+ { create cube normal map from texture data and upload it to video card
+ @param aSize size of each cube map texture
+ @param aCheckSize check size before upload and throw exception if something is wrong }
+ procedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);
+ end;
+{$IFEND}
+
+ TglcBitmapFormat = TglBitmapFormat;
+ TglcBitmap2D = TglBitmap2D;
+ TglcBitmapData = TglBitmapData;
+{$IF NOT DEFINED(OPENGL_ES)}
+ TglcBitmap1D = TglBitmap1D;
+ TglcBitmapCubeMap = TglBitmapCubeMap;
+ TglcBitmapNormalMap = TglBitmapNormalMap;
+{$ELSEIF DEFINED(OPENGL_ES_2_0)}
+ TglcBitmapCubeMap = TglBitmapCubeMap;
+ TglcBitmapNormalMap = TglBitmapNormalMap;
+{$IFEND}
+
+const
+ NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0);
+
+procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
+procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
+procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
+procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
+procedure glBitmapSetDefaultWrap(
+ const S: Cardinal = GL_CLAMP_TO_EDGE;
+ const T: Cardinal = GL_CLAMP_TO_EDGE;
+ const R: Cardinal = GL_CLAMP_TO_EDGE);
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
+{$IFEND}
+
+function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
+function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
+function glBitmapGetDefaultFormat: TglBitmapFormat;
+procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
+{$IFEND}
+
+function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;
+function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
+function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
+function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
+function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
+function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
+function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
+
+function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
+
+{$IFDEF GLB_DELPHI}
+function CreateGrayPalette: HPALETTE;
+{$ENDIF}
+
+implementation
+
+uses
+ Math, syncobjs, typinfo
+ {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND};
+
+
+var
+ glBitmapDefaultDeleteTextureOnFree: Boolean;
+ glBitmapDefaultFreeDataAfterGenTextures: Boolean;
+ glBitmapDefaultFormat: TglBitmapFormat;
+ glBitmapDefaultMipmap: TglBitmapMipMap;
+ glBitmapDefaultFilterMin: Cardinal;
+ glBitmapDefaultFilterMag: Cardinal;
+ glBitmapDefaultWrapS: Cardinal;
+ glBitmapDefaultWrapT: Cardinal;
+ glBitmapDefaultWrapR: Cardinal;
+ glDefaultSwizzle: array[0..3] of GLenum;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+ TFormatDescriptor = class(TglBitmapFormatDescriptor)
+ public
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
+
+ function CreateMappingData: Pointer; virtual;
+ procedure FreeMappingData(var aMappingData: Pointer); virtual;
+
+ function IsEmpty: Boolean; virtual;
+ function MaskMatch(const aMask: TglBitmapRec4ul): Boolean; virtual;
+
+ procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
+
+ constructor Create; virtual;
+ public
+ class procedure Init;
+ class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
+ class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+ class function GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer = 0): TFormatDescriptor;
+ class function GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor;
+ class procedure Clear;
+ class procedure Finalize;
+ end;
+ TFormatDescriptorClass = class of TFormatDescriptor;
+
+ TfdEmpty = class(TFormatDescriptor);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdAlphaUB1 = class(TFormatDescriptor) //1* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdLuminanceUB1 = class(TFormatDescriptor) //1* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdUniversalUB1 = class(TFormatDescriptor) //1* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdLuminanceAlphaUB2 = class(TfdLuminanceUB1) //2* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdRGBub3 = class(TFormatDescriptor) //3* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdBGRub3 = class(TFormatDescriptor) //3* unsigned byte (inverse)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdRGBAub4 = class(TfdRGBub3) //3* unsigned byte
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdBGRAub4 = class(TfdBGRub3) //3* unsigned byte (inverse)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdAlphaUS1 = class(TFormatDescriptor) //1* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdLuminanceUS1 = class(TFormatDescriptor) //1* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdUniversalUS1 = class(TFormatDescriptor) //1* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdDepthUS1 = class(TFormatDescriptor) //1* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdLuminanceAlphaUS2 = class(TfdLuminanceUS1) //2* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdRGBus3 = class(TFormatDescriptor) //3* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdBGRus3 = class(TFormatDescriptor) //3* unsigned short (inverse)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdRGBAus4 = class(TfdRGBus3) //4* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdARGBus4 = class(TfdRGBus3) //4* unsigned short
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdBGRAus4 = class(TfdBGRus3) //4* unsigned short (inverse)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdABGRus4 = class(TfdBGRus3) //4* unsigned short (inverse)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdUniversalUI1 = class(TFormatDescriptor) //1* unsigned int
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+ TfdDepthUI1 = class(TFormatDescriptor) //1* unsigned int
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdAlpha4ub1 = class(TfdAlphaUB1)
+ procedure SetValues; override;
+ end;
+
+ TfdAlpha8ub1 = class(TfdAlphaUB1)
+ procedure SetValues; override;
+ end;
+
+ TfdAlpha16us1 = class(TfdAlphaUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance4ub1 = class(TfdLuminanceUB1)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance8ub1 = class(TfdLuminanceUB1)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance16us1 = class(TfdLuminanceUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance4Alpha4ub2 = class(TfdLuminanceAlphaUB2)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance6Alpha2ub2 = class(TfdLuminanceAlphaUB2)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance8Alpha8ub2 = class(TfdLuminanceAlphaUB2)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance12Alpha4us2 = class(TfdLuminanceAlphaUS2)
+ procedure SetValues; override;
+ end;
+
+ TfdLuminance16Alpha16us2 = class(TfdLuminanceAlphaUS2)
+ procedure SetValues; override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdR3G3B2ub1 = class(TfdUniversalUB1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBX4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdXRGB4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdR5G6B5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB5X1us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdX1RGB5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB8ub3 = class(TfdRGBub3)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBX8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdXRGB8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB10X2ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdX2RGB10ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB16us3 = class(TfdRGBus3)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBA4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdARGB4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB5A1us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdA1RGB5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBA8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdARGB8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBA8ub4 = class(TfdRGBAub4)
+ procedure SetValues; override;
+ end;
+
+ TfdRGB10A2ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdA2RGB10ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdRGBA16us4 = class(TfdRGBAus4)
+ procedure SetValues; override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdBGRX4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdXBGR4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdB5G6R5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR5X1us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdX1BGR5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR8ub3 = class(TfdBGRub3)
+ procedure SetValues; override;
+ end;
+
+ TfdBGRX8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdXBGR8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR10X2ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdX2BGR10ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR16us3 = class(TfdBGRus3)
+ procedure SetValues; override;
+ end;
+
+ TfdBGRA4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdABGR4us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR5A1us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdA1BGR5us1 = class(TfdUniversalUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGRA8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdABGR8ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGRA8ub4 = class(TfdBGRAub4)
+ procedure SetValues; override;
+ end;
+
+ TfdBGR10A2ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdA2BGR10ui1 = class(TfdUniversalUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdBGRA16us4 = class(TfdBGRAus4)
+ procedure SetValues; override;
+ end;
+
+ TfdDepth16us1 = class(TfdDepthUS1)
+ procedure SetValues; override;
+ end;
+
+ TfdDepth24ui1 = class(TfdDepthUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdDepth32ui1 = class(TfdDepthUI1)
+ procedure SetValues; override;
+ end;
+
+ TfdS3tcDtx1RGBA = class(TFormatDescriptor)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ procedure SetValues; override;
+ end;
+
+ TfdS3tcDtx3RGBA = class(TFormatDescriptor)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ procedure SetValues; override;
+ end;
+
+ TfdS3tcDtx5RGBA = class(TFormatDescriptor)
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ procedure SetValues; override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TbmpBitfieldFormat = class(TFormatDescriptor)
+ public
+ procedure SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul); overload;
+ procedure SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TbmpColorTableEnty = packed record
+ b, g, r, a: Byte;
+ end;
+ TbmpColorTable = array of TbmpColorTableEnty;
+ TbmpColorTableFormat = class(TFormatDescriptor)
+ private
+ fColorTable: TbmpColorTable;
+ protected
+ procedure SetValues; override;
+ public
+ property ColorTable: TbmpColorTable read fColorTable write fColorTable;
+
+ procedure SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload;
+ procedure CalcValues;
+ procedure CreateColorTable;
+
+ function CreateMappingData: Pointer; override;
+ procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+ procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+ destructor Destroy; override;
+ end;
+
+const
+ LUMINANCE_WEIGHT_R = 0.30;
+ LUMINANCE_WEIGHT_G = 0.59;
+ LUMINANCE_WEIGHT_B = 0.11;
+
+ ALPHA_WEIGHT_R = 0.30;
+ ALPHA_WEIGHT_G = 0.59;
+ ALPHA_WEIGHT_B = 0.11;
+
+ DEPTH_WEIGHT_R = 0.333333333;
+ DEPTH_WEIGHT_G = 0.333333333;
+ DEPTH_WEIGHT_B = 0.333333333;
+
+ FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
+ TfdEmpty,
+
+ TfdAlpha4ub1,
+ TfdAlpha8ub1,
+ TfdAlpha16us1,
+
+ TfdLuminance4ub1,
+ TfdLuminance8ub1,
+ TfdLuminance16us1,
+
+ TfdLuminance4Alpha4ub2,
+ TfdLuminance6Alpha2ub2,
+ TfdLuminance8Alpha8ub2,
+ TfdLuminance12Alpha4us2,
+ TfdLuminance16Alpha16us2,
+
+ TfdR3G3B2ub1,
+ TfdRGBX4us1,
+ TfdXRGB4us1,
+ TfdR5G6B5us1,
+ TfdRGB5X1us1,
+ TfdX1RGB5us1,
+ TfdRGB8ub3,
+ TfdRGBX8ui1,
+ TfdXRGB8ui1,
+ TfdRGB10X2ui1,
+ TfdX2RGB10ui1,
+ TfdRGB16us3,
+
+ TfdRGBA4us1,
+ TfdARGB4us1,
+ TfdRGB5A1us1,
+ TfdA1RGB5us1,
+ TfdRGBA8ui1,
+ TfdARGB8ui1,
+ TfdRGBA8ub4,
+ TfdRGB10A2ui1,
+ TfdA2RGB10ui1,
+ TfdRGBA16us4,
+
+ TfdBGRX4us1,
+ TfdXBGR4us1,
+ TfdB5G6R5us1,
+ TfdBGR5X1us1,
+ TfdX1BGR5us1,
+ TfdBGR8ub3,
+ TfdBGRX8ui1,
+ TfdXBGR8ui1,
+ TfdBGR10X2ui1,
+ TfdX2BGR10ui1,
+ TfdBGR16us3,
+
+ TfdBGRA4us1,
+ TfdABGR4us1,
+ TfdBGR5A1us1,
+ TfdA1BGR5us1,
+ TfdBGRA8ui1,
+ TfdABGR8ui1,
+ TfdBGRA8ub4,
+ TfdBGR10A2ui1,
+ TfdA2BGR10ui1,
+ TfdBGRA16us4,
+
+ TfdDepth16us1,
+ TfdDepth24ui1,
+ TfdDepth32ui1,
+
+ TfdS3tcDtx1RGBA,
+ TfdS3tcDtx3RGBA,
+ TfdS3tcDtx5RGBA
+ );
+
+var
+ FormatDescriptorCS: TCriticalSection;
+ FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
+begin
+ inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat);
+begin
+ inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapSize(X: Integer; Y: Integer): TglBitmapSize;
+begin
+ result.Fields := [];
+ if (X >= 0) then
+ result.Fields := result.Fields + [ffX];
+ if (Y >= 0) then
+ result.Fields := result.Fields + [ffY];
+ result.X := Max(0, X);
+ result.Y := Max(0, Y);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition;
+begin
+ result := glBitmapSize(X, Y);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
+begin
+ result.r := r;
+ result.g := g;
+ result.b := b;
+ result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
+begin
+ result.r := r;
+ result.g := g;
+ result.b := b;
+ result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
+begin
+ result.r := r;
+ result.g := g;
+ result.b := b;
+ result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
+var
+ i: Integer;
+begin
+ result := false;
+ for i := 0 to high(r1.arr) do
+ if (r1.arr[i] <> r2.arr[i]) then
+ exit;
+ result := true;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
+var
+ i: Integer;
+begin
+ result := false;
+ for i := 0 to high(r1.arr) do
+ if (r1.arr[i] <> r2.arr[i]) then
+ exit;
+ result := true;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
+var
+ desc: TFormatDescriptor;
+ p, tmp: PByte;
+ x, y, i: Integer;
+ md: Pointer;
+ px: TglBitmapPixelData;
+begin
+ result := nil;
+ desc := TFormatDescriptor.Get(aFormat);
+ if (desc.IsCompressed) or (desc.glFormat = 0) then
+ exit;
+
+ p := GetMemory(ceil(25 * desc.BytesPerPixel)); // 5 x 5 pixel
+ md := desc.CreateMappingData;
+ try
+ tmp := p;
+ desc.PreparePixel(px);
+ for y := 0 to 4 do
+ for x := 0 to 4 do begin
+ px.Data := glBitmapRec4ui(0, 0, 0, 0);
+ for i := 0 to 3 do begin
+ if ((y < 3) and (y = i)) or
+ ((y = 3) and (i < 3)) or
+ ((y = 4) and (i = 3))
+ then
+ px.Data.arr[i] := Trunc(px.Range.arr[i] / 4 * x)
+ else if ((y < 4) and (i = 3)) or
+ ((y = 4) and (i < 3))
+ then
+ px.Data.arr[i] := px.Range.arr[i]
+ else
+ px.Data.arr[i] := 0; //px.Range.arr[i];
+ end;
+ desc.Map(px, tmp, md);
+ end;
+ finally
+ desc.FreeMappingData(md);
+ end;
+
+ result := TglBitmapData.Create(glBitmapPosition(5, 5), aFormat, p);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapShiftRec(const r, g, b, a: Byte): TglBitmapRec4ub;
+begin
+ result.r := r;
+ result.g := g;
+ result.b := b;
+ result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
+begin
+ result := [];
+
+ if (aFormat in [
+ //8bpp
+ tfAlpha4ub1, tfAlpha8ub1,
+ tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1,
+
+ //16bpp
+ tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
+ tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1,
+ tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1,
+
+ //24bpp
+ tfBGR8ub3, tfRGB8ub3,
+
+ //32bpp
+ tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1,
+ tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1])
+ then
+ result := result + [ ftBMP ];
+
+ if (aFormat in [
+ //8bbp
+ tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1,
+
+ //16bbp
+ tfAlpha16us1, tfLuminance16us1,
+ tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
+ tfX1RGB5us1, tfARGB4us1, tfA1RGB5us1, tfDepth16us1,
+
+ //24bbp
+ tfBGR8ub3,
+
+ //32bbp
+ tfX2RGB10ui1, tfARGB8ui1, tfBGRA8ub4, tfA2RGB10ui1,
+ tfDepth24ui1, tfDepth32ui1])
+ then
+ result := result + [ftTGA];
+
+ if not (aFormat in [tfEmpty, tfRGB16us3, tfBGR16us3]) then
+ result := result + [ftDDS];
+
+{$IFDEF GLB_SUPPORT_PNG_WRITE}
+ if aFormat in [
+ tfAlpha8ub1, tfLuminance8ub1, tfLuminance8Alpha8ub2,
+ tfRGB8ub3, tfRGBA8ui1,
+ tfBGR8ub3, tfBGRA8ui1] then
+ result := result + [ftPNG];
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_WRITE}
+ if aFormat in [tfAlpha8ub1, tfLuminance8ub1, tfRGB8ub3, tfBGR8ub3] then
+ result := result + [ftJPEG];
+{$ENDIF}
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function IsPowerOfTwo(aNumber: Integer): Boolean;
+begin
+ while (aNumber and 1) = 0 do
+ aNumber := aNumber shr 1;
+ result := aNumber = 1;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function GetTopMostBit(aBitSet: QWord): Integer;
+begin
+ result := 0;
+ while aBitSet > 0 do begin
+ inc(result);
+ aBitSet := aBitSet shr 1;
+ end;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function CountSetBits(aBitSet: QWord): Integer;
+begin
+ result := 0;
+ while aBitSet > 0 do begin
+ if (aBitSet and 1) = 1 then
+ inc(result);
+ aBitSet := aBitSet shr 1;
+ end;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function LuminanceWeight(const aPixel: TglBitmapPixelData): Cardinal;
+begin
+ result := Trunc(
+ LUMINANCE_WEIGHT_R * aPixel.Data.r +
+ LUMINANCE_WEIGHT_G * aPixel.Data.g +
+ LUMINANCE_WEIGHT_B * aPixel.Data.b);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
+begin
+ result := Trunc(
+ DEPTH_WEIGHT_R * aPixel.Data.r +
+ DEPTH_WEIGHT_G * aPixel.Data.g +
+ DEPTH_WEIGHT_B * aPixel.Data.b);
+end;
+
+{$IFDEF GLB_SDL_IMAGE}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
+begin
+ result := TStream(context^.unknown.data1).Seek(offset, whence);
+end;
+
+function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
+begin
+ result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
+end;
+
+function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
+begin
+ result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
+end;
+
+function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
+begin
+ result := 0;
+end;
+
+function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
+begin
+ result := SDL_AllocRW;
+
+ if result = nil then
+ raise EglBitmap.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
+
+ result^.seek := glBitmapRWseek;
+ result^.read := glBitmapRWread;
+ result^.write := glBitmapRWwrite;
+ result^.close := glBitmapRWclose;
+ result^.unknown.data1 := Stream;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
+begin
+ glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
+begin
+ glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
+begin
+ glBitmapDefaultMipmap := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
+begin
+ glBitmapDefaultFormat := aFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
+begin
+ glBitmapDefaultFilterMin := aMin;
+ glBitmapDefaultFilterMag := aMag;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
+begin
+ glBitmapDefaultWrapS := S;
+ glBitmapDefaultWrapT := T;
+ glBitmapDefaultWrapR := R;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
+begin
+ glDefaultSwizzle[0] := r;
+ glDefaultSwizzle[1] := g;
+ glDefaultSwizzle[2] := b;
+ glDefaultSwizzle[3] := a;
+end;
+{$IFEND}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
+begin
+ result := glBitmapDefaultDeleteTextureOnFree;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
+begin
+ result := glBitmapDefaultFreeDataAfterGenTextures;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
+begin
+ result := glBitmapDefaultMipmap;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFormat: TglBitmapFormat;
+begin
+ result := glBitmapDefaultFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
+begin
+ aMin := glBitmapDefaultFilterMin;
+ aMag := glBitmapDefaultFilterMag;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
+begin
+ S := glBitmapDefaultWrapS;
+ T := glBitmapDefaultWrapT;
+ R := glBitmapDefaultWrapR;
+end;
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
+begin
+ r := glDefaultSwizzle[0];
+ g := glDefaultSwizzle[1];
+ b := glDefaultSwizzle[2];
+ a := glDefaultSwizzle[3];
+end;
+{$IFEND}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.CreateMappingData: Pointer;
+begin
+ result := nil;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer);
+begin
+ //DUMMY
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.IsEmpty: Boolean;
+begin
+ result := (fFormat = tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.MaskMatch(const aMask: TglBitmapRec4ul): Boolean;
+var
+ i: Integer;
+ m: TglBitmapRec4ul;
+begin
+ result := false;
+ if (aMask.r = 0) and (aMask.g = 0) and (aMask.b = 0) and (aMask.a = 0) then
+ raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
+ m := Mask;
+ for i := 0 to 3 do
+ if (aMask.arr[i] <> m.arr[i]) then
+ exit;
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData);
+begin
+ FillChar(aPixel{%H-}, SizeOf(aPixel), 0);
+ aPixel.Data := Range;
+ aPixel.Format := fFormat;
+ aPixel.Range := Range;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TFormatDescriptor.Create;
+begin
+ inherited Create;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlphaUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ aData^ := aPixel.Data.a;
+ inc(aData);
+end;
+
+procedure TfdAlphaUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := 0;
+ aPixel.Data.g := 0;
+ aPixel.Data.b := 0;
+ aPixel.Data.a := aData^;
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ aData^ := LuminanceWeight(aPixel);
+ inc(aData);
+end;
+
+procedure TfdLuminanceUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := aData^;
+ aPixel.Data.g := aData^;
+ aPixel.Data.b := aData^;
+ aPixel.Data.a := 0;
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversalUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ aData^ := 0;
+ for i := 0 to 3 do
+ if (Range.arr[i] > 0) then
+ aData^ := aData^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
+ inc(aData);
+end;
+
+procedure TfdUniversalUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do
+ aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and Range.arr[i];
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceAlphaUB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ aData^ := aPixel.Data.a;
+ inc(aData);
+end;
+
+procedure TfdLuminanceAlphaUB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := aData^;
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGBub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ aData^ := aPixel.Data.r;
+ inc(aData);
+ aData^ := aPixel.Data.g;
+ inc(aData);
+ aData^ := aPixel.Data.b;
+ inc(aData);
+end;
+
+procedure TfdRGBub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := aData^;
+ inc(aData);
+ aPixel.Data.g := aData^;
+ inc(aData);
+ aPixel.Data.b := aData^;
+ inc(aData);
+ aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ aData^ := aPixel.Data.b;
+ inc(aData);
+ aData^ := aPixel.Data.g;
+ inc(aData);
+ aData^ := aPixel.Data.r;
+ inc(aData);
+end;
+
+procedure TfdBGRub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.b := aData^;
+ inc(aData);
+ aPixel.Data.g := aData^;
+ inc(aData);
+ aPixel.Data.r := aData^;
+ inc(aData);
+ aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGBA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGBAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ aData^ := aPixel.Data.a;
+ inc(aData);
+end;
+
+procedure TfdRGBAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := aData^;
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGRA_UB4//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ aData^ := aPixel.Data.a;
+ inc(aData);
+end;
+
+procedure TfdBGRAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := aData^;
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlphaUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+end;
+
+procedure TfdAlphaUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := 0;
+ aPixel.Data.g := 0;
+ aPixel.Data.b := 0;
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := LuminanceWeight(aPixel);
+ inc(aData, 2);
+end;
+
+procedure TfdLuminanceUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := PWord(aData)^;
+ aPixel.Data.g := PWord(aData)^;
+ aPixel.Data.b := PWord(aData)^;
+ aPixel.Data.a := 0;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversalUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ PWord(aData)^ := 0;
+ for i := 0 to 3 do
+ if (Range.arr[i] > 0) then
+ PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
+ inc(aData, 2);
+end;
+
+procedure TfdUniversalUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do
+ aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and Range.arr[i];
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepthUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := DepthWeight(aPixel);
+ inc(aData, 2);
+end;
+
+procedure TfdDepthUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := PWord(aData)^;
+ aPixel.Data.g := PWord(aData)^;
+ aPixel.Data.b := PWord(aData)^;
+ aPixel.Data.a := PWord(aData)^;;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceAlphaUS2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+end;
+
+procedure TfdLuminanceAlphaUS2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGBus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := aPixel.Data.r;
+ inc(aData, 2);
+ PWord(aData)^ := aPixel.Data.g;
+ inc(aData, 2);
+ PWord(aData)^ := aPixel.Data.b;
+ inc(aData, 2);
+end;
+
+procedure TfdRGBus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.g := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.b := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := aPixel.Data.b;
+ inc(aData, 2);
+ PWord(aData)^ := aPixel.Data.g;
+ inc(aData, 2);
+ PWord(aData)^ := aPixel.Data.r;
+ inc(aData, 2);
+end;
+
+procedure TfdBGRus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.b := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.g := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.r := PWord(aData)^;
+ inc(aData, 2);
+ aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGBAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+end;
+
+procedure TfdRGBAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdARGBus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+ inherited Map(aPixel, aData, aMapData);
+end;
+
+procedure TfdARGBus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+ inherited Unmap(aData, aPixel, aMapData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ inherited Map(aPixel, aData, aMapData);
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+end;
+
+procedure TfdBGRAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ inherited Unmap(aData, aPixel, aMapData);
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdABGRus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PWord(aData)^ := aPixel.Data.a;
+ inc(aData, 2);
+ inherited Map(aPixel, aData, aMapData);
+end;
+
+procedure TfdABGRus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.a := PWord(aData)^;
+ inc(aData, 2);
+ inherited Unmap(aData, aPixel, aMapData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversalUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ PCardinal(aData)^ := 0;
+ for i := 0 to 3 do
+ if (Range.arr[i] > 0) then
+ PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]);
+ inc(aData, 4);
+end;
+
+procedure TfdUniversalUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do
+ aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and Range.arr[i];
+ inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepthUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ PCardinal(aData)^ := DepthWeight(aPixel);
+ inc(aData, 4);
+end;
+
+procedure TfdDepthUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ aPixel.Data.r := PCardinal(aData)^;
+ aPixel.Data.g := PCardinal(aData)^;
+ aPixel.Data.b := PCardinal(aData)^;
+ aPixel.Data.a := PCardinal(aData)^;
+ inc(aData, 4);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlpha4ub1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 8;
+ fFormat := tfAlpha4ub1;
+ fWithAlpha := tfAlpha4ub1;
+ fPrecision := glBitmapRec4ub(0, 0, 0, 8);
+ fShift := glBitmapRec4ub(0, 0, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfAlpha4ub1;
+ fglFormat := GL_ALPHA;
+ fglInternalFormat := GL_ALPHA4;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfAlpha8ub1;
+{$ENDIF}
+end;
+
+procedure TfdAlpha8ub1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 8;
+ fFormat := tfAlpha8ub1;
+ fWithAlpha := tfAlpha8ub1;
+ fPrecision := glBitmapRec4ub(0, 0, 0, 8);
+ fShift := glBitmapRec4ub(0, 0, 0, 0);
+ fOpenGLFormat := tfAlpha8ub1;
+ fglFormat := GL_ALPHA;
+ fglInternalFormat := {$IFNDEF OPENGL_ES}GL_ALPHA8{$ELSE}GL_ALPHA{$ENDIF};
+ fglDataFormat := GL_UNSIGNED_BYTE;
+end;
+
+procedure TfdAlpha16us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfAlpha16us1;
+ fWithAlpha := tfAlpha16us1;
+ fPrecision := glBitmapRec4ub(0, 0, 0, 16);
+ fShift := glBitmapRec4ub(0, 0, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfAlpha16us1;
+ fglFormat := GL_ALPHA;
+ fglInternalFormat := GL_ALPHA16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfAlpha8ub1;
+{$ENDIF}
+end;
+
+procedure TfdLuminance4ub1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 8;
+ fFormat := tfLuminance4ub1;
+ fWithAlpha := tfLuminance4Alpha4ub2;
+ fWithoutAlpha := tfLuminance4ub1;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 0);
+ fShift := glBitmapRec4ub(0, 0, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance4ub1;
+ fglFormat := GL_LUMINANCE;
+ fglInternalFormat := GL_LUMINANCE4;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8ub1;
+{$ENDIF}
+end;
+
+procedure TfdLuminance8ub1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 8;
+ fFormat := tfLuminance8ub1;
+ fWithAlpha := tfLuminance8Alpha8ub2;
+ fWithoutAlpha := tfLuminance8ub1;
+ fOpenGLFormat := tfLuminance8ub1;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 0);
+ fShift := glBitmapRec4ub(0, 0, 0, 0);
+ fglFormat := GL_LUMINANCE;
+ fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8{$ELSE}GL_LUMINANCE{$ENDIF};
+ fglDataFormat := GL_UNSIGNED_BYTE;
+end;
+
+procedure TfdLuminance16us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfLuminance16us1;
+ fWithAlpha := tfLuminance16Alpha16us2;
+ fWithoutAlpha := tfLuminance16us1;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 0);
+ fShift := glBitmapRec4ub( 0, 0, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance16us1;
+ fglFormat := GL_LUMINANCE;
+ fglInternalFormat := GL_LUMINANCE16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8ub1;
+{$ENDIF}
+end;
+
+procedure TfdLuminance4Alpha4ub2.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfLuminance4Alpha4ub2;
+ fWithAlpha := tfLuminance4Alpha4ub2;
+ fWithoutAlpha := tfLuminance4ub1;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 8);
+ fShift := glBitmapRec4ub(0, 0, 0, 8);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance4Alpha4ub2;
+ fglFormat := GL_LUMINANCE_ALPHA;
+ fglInternalFormat := GL_LUMINANCE4_ALPHA4;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8Alpha8ub2;
+{$ENDIF}
+end;
+
+procedure TfdLuminance6Alpha2ub2.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfLuminance6Alpha2ub2;
+ fWithAlpha := tfLuminance6Alpha2ub2;
+ fWithoutAlpha := tfLuminance8ub1;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 8);
+ fShift := glBitmapRec4ub(0, 0, 0, 8);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance6Alpha2ub2;
+ fglFormat := GL_LUMINANCE_ALPHA;
+ fglInternalFormat := GL_LUMINANCE6_ALPHA2;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8Alpha8ub2;
+{$ENDIF}
+end;
+
+procedure TfdLuminance8Alpha8ub2.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfLuminance8Alpha8ub2;
+ fWithAlpha := tfLuminance8Alpha8ub2;
+ fWithoutAlpha := tfLuminance8ub1;
+ fOpenGLFormat := tfLuminance8Alpha8ub2;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 8);
+ fShift := glBitmapRec4ub(0, 0, 0, 8);
+ fglFormat := GL_LUMINANCE_ALPHA;
+ fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8_ALPHA8{$ELSE}GL_LUMINANCE_ALPHA{$ENDIF};
+ fglDataFormat := GL_UNSIGNED_BYTE;
+end;
+
+procedure TfdLuminance12Alpha4us2.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfLuminance12Alpha4us2;
+ fWithAlpha := tfLuminance12Alpha4us2;
+ fWithoutAlpha := tfLuminance16us1;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 16);
+ fShift := glBitmapRec4ub( 0, 0, 0, 16);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance12Alpha4us2;
+ fglFormat := GL_LUMINANCE_ALPHA;
+ fglInternalFormat := GL_LUMINANCE12_ALPHA4;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8Alpha8ub2;
+{$ENDIF}
+end;
+
+procedure TfdLuminance16Alpha16us2.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfLuminance16Alpha16us2;
+ fWithAlpha := tfLuminance16Alpha16us2;
+ fWithoutAlpha := tfLuminance16us1;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 16);
+ fShift := glBitmapRec4ub( 0, 0, 0, 16);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfLuminance16Alpha16us2;
+ fglFormat := GL_LUMINANCE_ALPHA;
+ fglInternalFormat := GL_LUMINANCE16_ALPHA16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfLuminance8Alpha8ub2;
+{$ENDIF}
+end;
+
+procedure TfdR3G3B2ub1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 8;
+ fFormat := tfR3G3B2ub1;
+ fWithAlpha := tfRGBA4us1;
+ fWithoutAlpha := tfR3G3B2ub1;
+ fRGBInverted := tfEmpty;
+ fPrecision := glBitmapRec4ub(3, 3, 2, 0);
+ fShift := glBitmapRec4ub(5, 2, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfR3G3B2ub1;
+ fglFormat := GL_RGB;
+ fglInternalFormat := GL_R3_G3_B2;
+ fglDataFormat := GL_UNSIGNED_BYTE_3_3_2;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdRGBX4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfRGBX4us1;
+ fWithAlpha := tfRGBA4us1;
+ fWithoutAlpha := tfRGBX4us1;
+ fRGBInverted := tfBGRX4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
+ fShift := glBitmapRec4ub(12, 8, 4, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGBX4us1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdXRGB4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfXRGB4us1;
+ fWithAlpha := tfARGB4us1;
+ fWithoutAlpha := tfXRGB4us1;
+ fRGBInverted := tfXBGR4us1;
+ fPrecision := glBitmapRec4ub(4, 4, 4, 0);
+ fShift := glBitmapRec4ub(8, 4, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfXRGB4us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdR5G6B5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfR5G6B5us1;
+ fWithAlpha := tfRGB5A1us1;
+ fWithoutAlpha := tfR5G6B5us1;
+ fRGBInverted := tfB5G6R5us1;
+ fPrecision := glBitmapRec4ub( 5, 6, 5, 0);
+ fShift := glBitmapRec4ub(11, 5, 0, 0);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+ fOpenGLFormat := tfR5G6B5us1;
+ fglFormat := GL_RGB;
+ fglInternalFormat := GL_RGB565;
+ fglDataFormat := GL_UNSIGNED_SHORT_5_6_5;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$IFEND}
+end;
+
+procedure TfdRGB5X1us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfRGB5X1us1;
+ fWithAlpha := tfRGB5A1us1;
+ fWithoutAlpha := tfRGB5X1us1;
+ fRGBInverted := tfBGR5X1us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
+ fShift := glBitmapRec4ub(11, 6, 1, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGB5X1us1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB5;
+ fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdX1RGB5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfX1RGB5us1;
+ fWithAlpha := tfA1RGB5us1;
+ fWithoutAlpha := tfX1RGB5us1;
+ fRGBInverted := tfX1BGR5us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
+ fShift := glBitmapRec4ub(10, 5, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfX1RGB5us1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB5;
+ fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdRGB8ub3.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 24;
+ fFormat := tfRGB8ub3;
+ fWithAlpha := tfRGBA8ub4;
+ fWithoutAlpha := tfRGB8ub3;
+ fRGBInverted := tfBGR8ub3;
+ fPrecision := glBitmapRec4ub(8, 8, 8, 0);
+ fShift := glBitmapRec4ub(0, 8, 16, 0);
+ fOpenGLFormat := tfRGB8ub3;
+ fglFormat := GL_RGB;
+ fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGB8{$ELSE}GL_RGB{$IFEND};
+ fglDataFormat := GL_UNSIGNED_BYTE;
+end;
+
+procedure TfdRGBX8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfRGBX8ui1;
+ fWithAlpha := tfRGBA8ui1;
+ fWithoutAlpha := tfRGBX8ui1;
+ fRGBInverted := tfBGRX8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
+ fShift := glBitmapRec4ub(24, 16, 8, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGBX8ui1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$ENDIF}
+end;
+
+procedure TfdXRGB8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfXRGB8ui1;
+ fWithAlpha := tfXRGB8ui1;
+ fWithoutAlpha := tfXRGB8ui1;
+ fOpenGLFormat := tfXRGB8ui1;
+ fRGBInverted := tfXBGR8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
+ fShift := glBitmapRec4ub(16, 8, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfXRGB8ui1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$ENDIF}
+end;
+
+procedure TfdRGB10X2ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfRGB10X2ui1;
+ fWithAlpha := tfRGB10A2ui1;
+ fWithoutAlpha := tfRGB10X2ui1;
+ fRGBInverted := tfBGR10X2ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 0);
+ fShift := glBitmapRec4ub(22, 12, 2, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGB10X2ui1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB10;
+ fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
+{$ELSE}
+ fOpenGLFormat := tfRGB16us3;
+{$ENDIF}
+end;
+
+procedure TfdX2RGB10ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfX2RGB10ui1;
+ fWithAlpha := tfA2RGB10ui1;
+ fWithoutAlpha := tfX2RGB10ui1;
+ fRGBInverted := tfX2BGR10ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 0);
+ fShift := glBitmapRec4ub(20, 10, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfX2RGB10ui1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB10;
+ fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB16us3;
+{$ENDIF}
+end;
+
+procedure TfdRGB16us3.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 48;
+ fFormat := tfRGB16us3;
+ fWithAlpha := tfRGBA16us4;
+ fWithoutAlpha := tfRGB16us3;
+ fRGBInverted := tfBGR16us3;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 0);
+ fShift := glBitmapRec4ub( 0, 16, 32, 0);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ fOpenGLFormat := tfRGB16us3;
+ fglFormat := GL_RGB;
+ fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGB16{$ELSE}GL_RGB16UI{$ENDIF};
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$IFEND}
+end;
+
+procedure TfdRGBA4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfRGBA4us1;
+ fWithAlpha := tfRGBA4us1;
+ fWithoutAlpha := tfRGBX4us1;
+ fOpenGLFormat := tfRGBA4us1;
+ fRGBInverted := tfBGRA4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
+ fShift := glBitmapRec4ub(12, 8, 4, 0);
+ fglFormat := GL_RGBA;
+ fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+procedure TfdARGB4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfARGB4us1;
+ fWithAlpha := tfARGB4us1;
+ fWithoutAlpha := tfXRGB4us1;
+ fRGBInverted := tfABGR4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
+ fShift := glBitmapRec4ub( 8, 4, 0, 12);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfARGB4us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGBA4us1;
+{$ENDIF}
+end;
+
+procedure TfdRGB5A1us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfRGB5A1us1;
+ fWithAlpha := tfRGB5A1us1;
+ fWithoutAlpha := tfRGB5X1us1;
+ fOpenGLFormat := tfRGB5A1us1;
+ fRGBInverted := tfBGR5A1us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
+ fShift := glBitmapRec4ub(11, 6, 1, 0);
+ fglFormat := GL_RGBA;
+ fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}GL_RGB5_A1{$ELSE}GL_RGBA{$IFEND};
+ fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+procedure TfdA1RGB5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfA1RGB5us1;
+ fWithAlpha := tfA1RGB5us1;
+ fWithoutAlpha := tfX1RGB5us1;
+ fRGBInverted := tfA1BGR5us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
+ fShift := glBitmapRec4ub(10, 5, 0, 15);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfA1RGB5us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB5_A1;
+ fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB5A1us1;
+{$ENDIF}
+end;
+
+procedure TfdRGBA8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfRGBA8ui1;
+ fWithAlpha := tfRGBA8ui1;
+ fWithoutAlpha := tfRGBX8ui1;
+ fRGBInverted := tfBGRA8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub(24, 16, 8, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGBA8ui1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGBA8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4;
+{$ENDIF}
+end;
+
+procedure TfdARGB8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfARGB8ui1;
+ fWithAlpha := tfARGB8ui1;
+ fWithoutAlpha := tfXRGB8ui1;
+ fRGBInverted := tfABGR8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub(16, 8, 0, 24);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfARGB8ui1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4;
+{$ENDIF}
+end;
+
+procedure TfdRGBA8ub4.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfRGBA8ub4;
+ fWithAlpha := tfRGBA8ub4;
+ fWithoutAlpha := tfRGB8ub3;
+ fOpenGLFormat := tfRGBA8ub4;
+ fRGBInverted := tfBGRA8ub4;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub( 0, 8, 16, 24);
+ fglFormat := GL_RGBA;
+ fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND};
+ fglDataFormat := GL_UNSIGNED_BYTE;
+end;
+
+procedure TfdRGB10A2ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfRGB10A2ui1;
+ fWithAlpha := tfRGB10A2ui1;
+ fWithoutAlpha := tfRGB10X2ui1;
+ fRGBInverted := tfBGR10A2ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 2);
+ fShift := glBitmapRec4ub(22, 12, 2, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfRGB10A2ui1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGB10_A2;
+ fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
+{$ELSE}
+ fOpenGLFormat := tfA2RGB10ui1;
+{$ENDIF}
+end;
+
+procedure TfdA2RGB10ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfA2RGB10ui1;
+ fWithAlpha := tfA2RGB10ui1;
+ fWithoutAlpha := tfX2RGB10ui1;
+ fRGBInverted := tfA2BGR10ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 2);
+ fShift := glBitmapRec4ub(20, 10, 0, 30);
+{$IF NOT DEFINED(OPENGL_ES)}
+ fOpenGLFormat := tfA2RGB10ui1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB10_A2;
+ fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
+{$ELSEIF DEFINED(OPENGL_ES_3_0)}
+ fOpenGLFormat := tfA2RGB10ui1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGB10_A2;
+ fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ui1;
+{$IFEND}
+end;
+
+procedure TfdRGBA16us4.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 64;
+ fFormat := tfRGBA16us4;
+ fWithAlpha := tfRGBA16us4;
+ fWithoutAlpha := tfRGB16us3;
+ fRGBInverted := tfBGRA16us4;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 16);
+ fShift := glBitmapRec4ub( 0, 16, 32, 48);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ fOpenGLFormat := tfRGBA16us4;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGBA16{$ELSE}GL_RGBA16UI{$ENDIF};
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4;
+{$IFEND}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRX4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfBGRX4us1;
+ fWithAlpha := tfBGRA4us1;
+ fWithoutAlpha := tfBGRX4us1;
+ fRGBInverted := tfRGBX4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
+ fShift := glBitmapRec4ub( 4, 8, 12, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRX4us1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdXBGR4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfXBGR4us1;
+ fWithAlpha := tfABGR4us1;
+ fWithoutAlpha := tfXBGR4us1;
+ fRGBInverted := tfXRGB4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 0);
+ fShift := glBitmapRec4ub( 0, 4, 8, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfXBGR4us1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdB5G6R5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfB5G6R5us1;
+ fWithAlpha := tfBGR5A1us1;
+ fWithoutAlpha := tfB5G6R5us1;
+ fRGBInverted := tfR5G6B5us1;
+ fPrecision := glBitmapRec4ub( 5, 6, 5, 0);
+ fShift := glBitmapRec4ub( 0, 5, 11, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfB5G6R5us1;
+ fglFormat := GL_RGB;
+ fglInternalFormat := GL_RGB565;
+ fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdBGR5X1us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfBGR5X1us1;
+ fWithAlpha := tfBGR5A1us1;
+ fWithoutAlpha := tfBGR5X1us1;
+ fRGBInverted := tfRGB5X1us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
+ fShift := glBitmapRec4ub( 1, 6, 11, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR5X1us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB5;
+ fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdX1BGR5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfX1BGR5us1;
+ fWithAlpha := tfA1BGR5us1;
+ fWithoutAlpha := tfX1BGR5us1;
+ fRGBInverted := tfX1RGB5us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 0);
+ fShift := glBitmapRec4ub( 0, 5, 10, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfX1BGR5us1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB5;
+ fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+{$ELSE}
+ fOpenGLFormat := tfR5G6B5us1;
+{$ENDIF}
+end;
+
+procedure TfdBGR8ub3.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 24;
+ fFormat := tfBGR8ub3;
+ fWithAlpha := tfBGRA8ub4;
+ fWithoutAlpha := tfBGR8ub3;
+ fRGBInverted := tfRGB8ub3;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
+ fShift := glBitmapRec4ub(16, 8, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR8ub3;
+ fglFormat := GL_BGR;
+ fglInternalFormat := GL_RGB8;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$ENDIF}
+end;
+
+procedure TfdBGRX8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfBGRX8ui1;
+ fWithAlpha := tfBGRA8ui1;
+ fWithoutAlpha := tfBGRX8ui1;
+ fRGBInverted := tfRGBX8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
+ fShift := glBitmapRec4ub( 8, 16, 24, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRX8ui1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$ENDIF}
+end;
+
+procedure TfdXBGR8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfXBGR8ui1;
+ fWithAlpha := tfABGR8ui1;
+ fWithoutAlpha := tfXBGR8ui1;
+ fRGBInverted := tfXRGB8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 0);
+ fShift := glBitmapRec4ub( 0, 8, 16, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfXBGR8ui1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB8ub3;
+{$ENDIF}
+end;
+
+procedure TfdBGR10X2ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfBGR10X2ui1;
+ fWithAlpha := tfBGR10A2ui1;
+ fWithoutAlpha := tfBGR10X2ui1;
+ fRGBInverted := tfRGB10X2ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 0);
+ fShift := glBitmapRec4ub( 2, 12, 22, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR10X2ui1;
+ fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB10;
+ fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
+{$ELSE}
+ fOpenGLFormat := tfRGB16us3;
+{$ENDIF}
+end;
+
+procedure TfdX2BGR10ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfX2BGR10ui1;
+ fWithAlpha := tfA2BGR10ui1;
+ fWithoutAlpha := tfX2BGR10ui1;
+ fRGBInverted := tfX2RGB10ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 0);
+ fShift := glBitmapRec4ub( 0, 10, 20, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfX2BGR10ui1;
+ fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+ fglInternalFormat := GL_RGB10;
+ fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB16us3;
+{$ENDIF}
+end;
+
+procedure TfdBGR16us3.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 48;
+ fFormat := tfBGR16us3;
+ fWithAlpha := tfBGRA16us4;
+ fWithoutAlpha := tfBGR16us3;
+ fRGBInverted := tfRGB16us3;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 0);
+ fShift := glBitmapRec4ub(32, 16, 0, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR16us3;
+ fglFormat := GL_BGR;
+ fglInternalFormat := GL_RGB16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfRGB16us3;
+{$ENDIF}
+end;
+
+procedure TfdBGRA4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfBGRA4us1;
+ fWithAlpha := tfBGRA4us1;
+ fWithoutAlpha := tfBGRX4us1;
+ fRGBInverted := tfRGBA4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
+ fShift := glBitmapRec4ub( 4, 8, 12, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRA4us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4;
+{$ELSE}
+ fOpenGLFormat := tfRGBA4us1;
+{$ENDIF}
+end;
+
+procedure TfdABGR4us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfABGR4us1;
+ fWithAlpha := tfABGR4us1;
+ fWithoutAlpha := tfXBGR4us1;
+ fRGBInverted := tfARGB4us1;
+ fPrecision := glBitmapRec4ub( 4, 4, 4, 4);
+ fShift := glBitmapRec4ub( 0, 4, 8, 12);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfABGR4us1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGBA4;
+ fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGBA4us1;
+{$ENDIF}
+end;
+
+procedure TfdBGR5A1us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfBGR5A1us1;
+ fWithAlpha := tfBGR5A1us1;
+ fWithoutAlpha := tfBGR5X1us1;
+ fRGBInverted := tfRGB5A1us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
+ fShift := glBitmapRec4ub( 1, 6, 11, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR5A1us1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB5_A1;
+ fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1;
+{$ELSE}
+ fOpenGLFormat := tfRGB5A1us1;
+{$ENDIF}
+end;
+
+procedure TfdA1BGR5us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfA1BGR5us1;
+ fWithAlpha := tfA1BGR5us1;
+ fWithoutAlpha := tfX1BGR5us1;
+ fRGBInverted := tfA1RGB5us1;
+ fPrecision := glBitmapRec4ub( 5, 5, 5, 1);
+ fShift := glBitmapRec4ub( 0, 5, 10, 15);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfA1BGR5us1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGB5_A1;
+ fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGB5A1us1;
+{$ENDIF}
+end;
+
+procedure TfdBGRA8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfBGRA8ui1;
+ fWithAlpha := tfBGRA8ui1;
+ fWithoutAlpha := tfBGRX8ui1;
+ fRGBInverted := tfRGBA8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub( 8, 16, 24, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRA8ui1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4;
+{$ENDIF}
+end;
+
+procedure TfdABGR8ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfABGR8ui1;
+ fWithAlpha := tfABGR8ui1;
+ fWithoutAlpha := tfXBGR8ui1;
+ fRGBInverted := tfARGB8ui1;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub( 0, 8, 16, 24);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfABGR8ui1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGBA8;
+ fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4
+{$ENDIF}
+end;
+
+procedure TfdBGRA8ub4.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfBGRA8ub4;
+ fWithAlpha := tfBGRA8ub4;
+ fWithoutAlpha := tfBGR8ub3;
+ fRGBInverted := tfRGBA8ub4;
+ fPrecision := glBitmapRec4ub( 8, 8, 8, 8);
+ fShift := glBitmapRec4ub(16, 8, 0, 24);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRA8ub4;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA8;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := tfRGBA8ub4;
+{$ENDIF}
+end;
+
+procedure TfdBGR10A2ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfBGR10A2ui1;
+ fWithAlpha := tfBGR10A2ui1;
+ fWithoutAlpha := tfBGR10X2ui1;
+ fRGBInverted := tfRGB10A2ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 2);
+ fShift := glBitmapRec4ub( 2, 12, 22, 0);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGR10A2ui1;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGB10_A2;
+ fglDataFormat := GL_UNSIGNED_INT_10_10_10_2;
+{$ELSE}
+ fOpenGLFormat := tfA2RGB10ui1;
+{$ENDIF}
+end;
+
+procedure TfdA2BGR10ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfA2BGR10ui1;
+ fWithAlpha := tfA2BGR10ui1;
+ fWithoutAlpha := tfX2BGR10ui1;
+ fRGBInverted := tfA2RGB10ui1;
+ fPrecision := glBitmapRec4ub(10, 10, 10, 2);
+ fShift := glBitmapRec4ub( 0, 10, 20, 30);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfA2BGR10ui1;
+ fglFormat := GL_RGBA;
+ fglInternalFormat := GL_RGB10_A2;
+ fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV;
+{$ELSE}
+ fOpenGLFormat := tfA2RGB10ui1;
+{$ENDIF}
+end;
+
+procedure TfdBGRA16us4.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 64;
+ fFormat := tfBGRA16us4;
+ fWithAlpha := tfBGRA16us4;
+ fWithoutAlpha := tfBGR16us3;
+ fRGBInverted := tfRGBA16us4;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 16);
+ fShift := glBitmapRec4ub(32, 16, 0, 48);
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfBGRA16us4;
+ fglFormat := GL_BGRA;
+ fglInternalFormat := GL_RGBA16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$ELSE}
+ fOpenGLFormat := tfRGBA16us4;
+{$ENDIF}
+end;
+
+procedure TfdDepth16us1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 16;
+ fFormat := tfDepth16us1;
+ fWithoutAlpha := tfDepth16us1;
+ fPrecision := glBitmapRec4ub(16, 16, 16, 16);
+ fShift := glBitmapRec4ub( 0, 0, 0, 0);
+{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+ fOpenGLFormat := tfDepth16us1;
+ fglFormat := GL_DEPTH_COMPONENT;
+ fglInternalFormat := GL_DEPTH_COMPONENT16;
+ fglDataFormat := GL_UNSIGNED_SHORT;
+{$IFEND}
+end;
+
+procedure TfdDepth24ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfDepth24ui1;
+ fWithoutAlpha := tfDepth24ui1;
+ fOpenGLFormat := tfDepth24ui1;
+ fPrecision := glBitmapRec4ub(32, 32, 32, 32);
+ fShift := glBitmapRec4ub( 0, 0, 0, 0);
+{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ fOpenGLFormat := tfDepth24ui1;
+ fglFormat := GL_DEPTH_COMPONENT;
+ fglInternalFormat := GL_DEPTH_COMPONENT24;
+ fglDataFormat := GL_UNSIGNED_INT;
+{$IFEND}
+end;
+
+procedure TfdDepth32ui1.SetValues;
+begin
+ inherited SetValues;
+ fBitsPerPixel := 32;
+ fFormat := tfDepth32ui1;
+ fWithoutAlpha := tfDepth32ui1;
+ fPrecision := glBitmapRec4ub(32, 32, 32, 32);
+ fShift := glBitmapRec4ub( 0, 0, 0, 0);
+{$IF NOT DEFINED(OPENGL_ES)}
+ fOpenGLFormat := tfDepth32ui1;
+ fglFormat := GL_DEPTH_COMPONENT;
+ fglInternalFormat := GL_DEPTH_COMPONENT32;
+ fglDataFormat := GL_UNSIGNED_INT;
+{$ELSEIF DEFINED(OPENGL_ES_3_0)}
+ fOpenGLFormat := tfDepth24ui1;
+{$ELSEIF DEFINED(OPENGL_ES_2_0)}
+ fOpenGLFormat := tfDepth16us1;
+{$IFEND}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx1RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx1RGBA.SetValues;
+begin
+ inherited SetValues;
+ fFormat := tfS3tcDtx1RGBA;
+ fWithAlpha := tfS3tcDtx1RGBA;
+ fUncompressed := tfRGB5A1us1;
+ fBitsPerPixel := 4;
+ fIsCompressed := true;
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfS3tcDtx1RGBA;
+ fglFormat := GL_COMPRESSED_RGBA;
+ fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := fUncompressed;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx3RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx3RGBA.SetValues;
+begin
+ inherited SetValues;
+ fFormat := tfS3tcDtx3RGBA;
+ fWithAlpha := tfS3tcDtx3RGBA;
+ fUncompressed := tfRGBA8ub4;
+ fBitsPerPixel := 8;
+ fIsCompressed := true;
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfS3tcDtx3RGBA;
+ fglFormat := GL_COMPRESSED_RGBA;
+ fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := fUncompressed;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx5RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx5RGBA.SetValues;
+begin
+ inherited SetValues;
+ fFormat := tfS3tcDtx3RGBA;
+ fWithAlpha := tfS3tcDtx3RGBA;
+ fUncompressed := tfRGBA8ub4;
+ fBitsPerPixel := 8;
+ fIsCompressed := true;
+{$IFNDEF OPENGL_ES}
+ fOpenGLFormat := tfS3tcDtx3RGBA;
+ fglFormat := GL_COMPRESSED_RGBA;
+ fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+ fglDataFormat := GL_UNSIGNED_BYTE;
+{$ELSE}
+ fOpenGLFormat := fUncompressed;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapFormatDescriptor.GetHasRed: Boolean;
+begin
+ result := (fPrecision.r > 0);
+end;
+
+function TglBitmapFormatDescriptor.GetHasGreen: Boolean;
+begin
+ result := (fPrecision.g > 0);
+end;
+
+function TglBitmapFormatDescriptor.GetHasBlue: Boolean;
+begin
+ result := (fPrecision.b > 0);
+end;
+
+function TglBitmapFormatDescriptor.GetHasAlpha: Boolean;
+begin
+ result := (fPrecision.a > 0);
+end;
+
+function TglBitmapFormatDescriptor.GetHasColor: Boolean;
+begin
+ result := HasRed or HasGreen or HasBlue;
+end;
+
+function TglBitmapFormatDescriptor.GetIsGrayscale: Boolean;
+begin
+ result := (Mask.r = Mask.g) and (Mask.g = Mask.b) and (Mask.r > 0);
+end;
+
+function TglBitmapFormatDescriptor.GetHasOpenGLSupport: Boolean;
+begin
+ result := (OpenGLFormat = Format);
+end;
+
+procedure TglBitmapFormatDescriptor.SetValues;
+begin
+ fFormat := tfEmpty;
+ fWithAlpha := tfEmpty;
+ fWithoutAlpha := tfEmpty;
+ fOpenGLFormat := tfEmpty;
+ fRGBInverted := tfEmpty;
+ fUncompressed := tfEmpty;
+
+ fBitsPerPixel := 0;
+ fIsCompressed := false;
+
+ fglFormat := 0;
+ fglInternalFormat := 0;
+ fglDataFormat := 0;
+
+ FillChar(fPrecision, 0, SizeOf(fPrecision));
+ FillChar(fShift, 0, SizeOf(fShift));
+end;
+
+procedure TglBitmapFormatDescriptor.CalcValues;
+var
+ i: Integer;
+begin
+ fBytesPerPixel := fBitsPerPixel / 8;
+ fChannelCount := 0;
+ for i := 0 to 3 do begin
+ if (fPrecision.arr[i] > 0) then
+ inc(fChannelCount);
+ fRange.arr[i] := (1 shl fPrecision.arr[i]) - 1;
+ fMask.arr[i] := fRange.arr[i] shl fShift.arr[i];
+ end;
+end;
+
+function TglBitmapFormatDescriptor.GetSize(const aSize: TglBitmapSize): Integer;
+var
+ w, h: Integer;
+begin
+ if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin
+ w := Max(1, aSize.X);
+ h := Max(1, aSize.Y);
+ result := GetSize(w, h);
+ end else
+ result := 0;
+end;
+
+function TglBitmapFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer;
+begin
+ result := 0;
+ if (aWidth <= 0) or (aHeight <= 0) then
+ exit;
+ result := Ceil(aWidth * aHeight * BytesPerPixel);
+end;
+
+constructor TglBitmapFormatDescriptor.Create;
+begin
+ inherited Create;
+ SetValues;
+ CalcValues;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
+var
+ f: TglBitmapFormat;
+begin
+ for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin
+ result := TFormatDescriptor.Get(f);
+ if (result.glInternalFormat = aInternalFormat) then
+ exit;
+ end;
+ result := TFormatDescriptor.Get(tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Init;
+begin
+ if not Assigned(FormatDescriptorCS) then
+ FormatDescriptorCS := TCriticalSection.Create;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
+begin
+ FormatDescriptorCS.Enter;
+ try
+ result := FormatDescriptors[aFormat];
+ if not Assigned(result) then begin
+ result := FORMAT_DESCRIPTOR_CLASSES[aFormat].Create;
+ FormatDescriptors[aFormat] := result;
+ end;
+ finally
+ FormatDescriptorCS.Leave;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+begin
+ result := Get(Get(aFormat).WithAlpha);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer): TFormatDescriptor;
+var
+ ft: TglBitmapFormat;
+begin
+ // find matching format with OpenGL support
+ for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+ result := Get(ft);
+ if (result.MaskMatch(aMask)) and
+ (result.glFormat <> 0) and
+ (result.glInternalFormat <> 0) and
+ ((aBitCount = 0) or (aBitCount = result.BitsPerPixel))
+ then
+ exit;
+ end;
+
+ // find matching format without OpenGL Support
+ for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+ result := Get(ft);
+ if result.MaskMatch(aMask) and ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then
+ exit;
+ end;
+
+ result := TFormatDescriptor.Get(tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor;
+var
+ ft: TglBitmapFormat;
+begin
+ // find matching format with OpenGL support
+ for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+ result := Get(ft);
+ if glBitmapRec4ubCompare(result.Shift, aShift) and
+ glBitmapRec4ubCompare(result.Precision, aPrec) and
+ (result.glFormat <> 0) and
+ (result.glInternalFormat <> 0) and
+ ((aBitCount = 0) or (aBitCount = result.BitsPerPixel))
+ then
+ exit;
+ end;
+
+ // find matching format without OpenGL Support
+ for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+ result := Get(ft);
+ if glBitmapRec4ubCompare(result.Shift, aShift) and
+ glBitmapRec4ubCompare(result.Precision, aPrec) and
+ ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then
+ exit;
+ end;
+
+ result := TFormatDescriptor.Get(tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Clear;
+var
+ f: TglBitmapFormat;
+begin
+ FormatDescriptorCS.Enter;
+ try
+ for f := low(FormatDescriptors) to high(FormatDescriptors) do
+ FreeAndNil(FormatDescriptors[f]);
+ finally
+ FormatDescriptorCS.Leave;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Finalize;
+begin
+ Clear;
+ FreeAndNil(FormatDescriptorCS);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul);
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do begin
+ fShift.arr[i] := 0;
+ while (aMask.arr[i] > 0) and ((aMask.arr[i] and 1) = 0) do begin
+ aMask.arr[i] := aMask.arr[i] shr 1;
+ inc(fShift.arr[i]);
+ end;
+ fPrecision.arr[i] := CountSetBits(aMask.arr[i]);
+ end;
+ fBitsPerPixel := aBPP;
+ CalcValues;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub);
+begin
+ fBitsPerPixel := aBBP;
+ fPrecision := aPrec;
+ fShift := aShift;
+ CalcValues;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+ data: QWord;
+begin
+ data :=
+ ((aPixel.Data.r and Range.r) shl Shift.r) or
+ ((aPixel.Data.g and Range.g) shl Shift.g) or
+ ((aPixel.Data.b and Range.b) shl Shift.b) or
+ ((aPixel.Data.a and Range.a) shl Shift.a);
+ case BitsPerPixel of
+ 8: aData^ := data;
+ 16: PWord(aData)^ := data;
+ 32: PCardinal(aData)^ := data;
+ 64: PQWord(aData)^ := data;
+ else
+ raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]);
+ end;
+ inc(aData, Round(BytesPerPixel));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+ data: QWord;
+ i: Integer;
+begin
+ case BitsPerPixel of
+ 8: data := aData^;
+ 16: data := PWord(aData)^;
+ 32: data := PCardinal(aData)^;
+ 64: data := PQWord(aData)^;
+ else
+ raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]);
+ end;
+ for i := 0 to 3 do
+ aPixel.Data.arr[i] := (data shr fShift.arr[i]) and Range.arr[i];
+ inc(aData, Round(BytesPerPixel));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TColorTableFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.SetValues;
+begin
+ inherited SetValues;
+ fShift := glBitmapRec4ub(8, 8, 8, 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub);
+begin
+ fFormat := aFormat;
+ fBitsPerPixel := aBPP;
+ fPrecision := aPrec;
+ fShift := aShift;
+ CalcValues;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.CalcValues;
+begin
+ inherited CalcValues;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.CreateColorTable;
+var
+ i: Integer;
+begin
+ SetLength(fColorTable, 256);
+ if not HasColor then begin
+ // alpha
+ for i := 0 to High(fColorTable) do begin
+ fColorTable[i].r := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
+ fColorTable[i].g := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
+ fColorTable[i].b := Round(((i shr Shift.a) and Range.a) / Range.a * 255);
+ fColorTable[i].a := 0;
+ end;
+ end else begin
+ // normal
+ for i := 0 to High(fColorTable) do begin
+ fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255);
+ fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255);
+ fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255);
+ fColorTable[i].a := 0;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TbmpColorTableFormat.CreateMappingData: Pointer;
+begin
+ result := Pointer(0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+ if (BitsPerPixel <> 8) then
+ raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats');
+ if not HasColor then
+ // alpha
+ aData^ := aPixel.Data.a
+ else
+ // normal
+ aData^ := Round(
+ ((aPixel.Data.r shr Shift.r) and Range.r) * LUMINANCE_WEIGHT_R +
+ ((aPixel.Data.g shr Shift.g) and Range.g) * LUMINANCE_WEIGHT_G +
+ ((aPixel.Data.b shr Shift.b) and Range.b) * LUMINANCE_WEIGHT_B);
+ inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+
+ function ReadValue: Byte;
+ var
+ i: PtrUInt;
+ begin
+ if (BitsPerPixel = 8) then begin
+ result := aData^;
+ inc(aData);
+ end else begin
+ i := {%H-}PtrUInt(aMapData);
+ if (BitsPerPixel > 1) then
+ result := (aData^ shr i) and ((1 shl BitsPerPixel) - 1)
+ else
+ result := (aData^ shr (7-i)) and ((1 shl BitsPerPixel) - 1);
+ inc(i, BitsPerPixel);
+ while (i >= 8) do begin
+ inc(aData);
+ dec(i, 8);
+ end;
+ aMapData := {%H-}Pointer(i);
+ end;
+ end;
+
+begin
+ if (BitsPerPixel > 8) then
+ raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats');
+ with fColorTable[ReadValue] do begin
+ aPixel.Data.r := r;
+ aPixel.Data.g := g;
+ aPixel.Data.b := b;
+ aPixel.Data.a := a;
+ end;
+end;
+
+destructor TbmpColorTableFormat.Destroy;
+begin
+ SetLength(fColorTable, 0);
+ inherited Destroy;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - Helper//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertPixel(var aPixel: TglBitmapPixelData; const aSourceFD, aDestFD: TFormatDescriptor);
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do begin
+ if (aSourceFD.Range.arr[i] <> aDestFD.Range.arr[i]) then begin
+ if (aSourceFD.Range.arr[i] > 0) then
+ aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i])
+ else
+ aPixel.Data.arr[i] := 0;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertCopyFunc(var aFuncRec: TglBitmapFunctionRec);
+begin
+ with aFuncRec do begin
+ if (Source.Range.r > 0) then
+ Dest.Data.r := Source.Data.r;
+ if (Source.Range.g > 0) then
+ Dest.Data.g := Source.Data.g;
+ if (Source.Range.b > 0) then
+ Dest.Data.b := Source.Data.b;
+ if (Source.Range.a > 0) then
+ Dest.Data.a := Source.Data.a;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertCalculateRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+ i: Integer;
+begin
+ with aFuncRec do begin
+ for i := 0 to 3 do
+ if (Source.Range.arr[i] > 0) then
+ Dest.Data.arr[i] := Round(Dest.Range.arr[i] * Source.Data.arr[i] / Source.Range.arr[i]);
+ end;
+end;
+
+type
+ TShiftData = packed record
+ case Integer of
+ 0: (r, g, b, a: SmallInt);
+ 1: (arr: array[0..3] of SmallInt);
+ end;
+ PShiftData = ^TShiftData;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertShiftRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+ i: Integer;
+begin
+ with aFuncRec do
+ for i := 0 to 3 do
+ if (Source.Range.arr[i] > 0) then
+ Dest.Data.arr[i] := Source.Data.arr[i] shr PShiftData(Args)^.arr[i];
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+ i: Integer;
+begin
+ with aFuncRec do begin
+ Dest.Data := Source.Data;
+ for i := 0 to 3 do
+ if ({%H-}PtrUInt(Args) and (1 shl i) > 0) then
+ Dest.Data.arr[i] := Dest.Data.arr[i] xor Dest.Range.arr[i];
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapFillWithColorFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+ i: Integer;
+begin
+ with aFuncRec do begin
+ for i := 0 to 3 do
+ Dest.Data.arr[i] := PglBitmapPixelData(Args)^.Data.arr[i];
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+var
+ Temp: Single;
+begin
+ with FuncRec do begin
+ if (FuncRec.Args = nil) then begin //source has no alpha
+ Temp :=
+ Source.Data.r / Source.Range.r * ALPHA_WEIGHT_R +
+ Source.Data.g / Source.Range.g * ALPHA_WEIGHT_G +
+ Source.Data.b / Source.Range.b * ALPHA_WEIGHT_B;
+ Dest.Data.a := Round(Dest.Range.a * Temp);
+ end else
+ Dest.Data.a := Round(Source.Data.a / Source.Range.a * Dest.Range.a);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapColorKeyAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+type
+ PglBitmapPixelData = ^TglBitmapPixelData;
+begin
+ with FuncRec do begin
+ Dest.Data.r := Source.Data.r;
+ Dest.Data.g := Source.Data.g;
+ Dest.Data.b := Source.Data.b;
+
+ with PglBitmapPixelData(Args)^ do
+ if ((Dest.Data.r <= Data.r) and (Dest.Data.r >= Range.r) and
+ (Dest.Data.g <= Data.g) and (Dest.Data.g >= Range.g) and
+ (Dest.Data.b <= Data.b) and (Dest.Data.b >= Range.b)) then
+ Dest.Data.a := 0
+ else
+ Dest.Data.a := Dest.Range.a;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapValueAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+begin
+ with FuncRec do begin
+ Dest.Data.r := Source.Data.r;
+ Dest.Data.g := Source.Data.g;
+ Dest.Data.b := Source.Data.b;
+ Dest.Data.a := PCardinal(Args)^;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure SwapRGB(aData: PByte; aWidth: Integer; const aHasAlpha: Boolean);
+type
+ PRGBPix = ^TRGBPix;
+ TRGBPix = array [0..2] of byte;
+var
+ Temp: Byte;
+begin
+ while aWidth > 0 do begin
+ Temp := PRGBPix(aData)^[0];
+ PRGBPix(aData)^[0] := PRGBPix(aData)^[2];
+ PRGBPix(aData)^[2] := Temp;
+
+ if aHasAlpha then
+ Inc(aData, 4)
+ else
+ Inc(aData, 3);
+ dec(aWidth);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapData///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.GetFormatDescriptor: TglBitmapFormatDescriptor;
+begin
+ result := TFormatDescriptor.Get(fFormat);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.GetWidth: Integer;
+begin
+ if (ffX in fDimension.Fields) then
+ result := fDimension.X
+ else
+ result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.GetHeight: Integer;
+begin
+ if (ffY in fDimension.Fields) then
+ result := fDimension.Y
+ else
+ result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.GetScanlines(const aIndex: Integer): PByte;
+begin
+ if fHasScanlines and (aIndex >= Low(fScanlines)) and (aIndex <= High(fScanlines)) then
+ result := fScanlines[aIndex]
+ else
+ result := nil;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SetFormat(const aValue: TglBitmapFormat);
+begin
+ if fFormat = aValue then
+ exit;
+ if TFormatDescriptor.Get(Format).BitsPerPixel <> TFormatDescriptor.Get(aValue).BitsPerPixel then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ SetData(fData, aValue, Width, Height);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.PrepareResType(var aResource: String; var aResType: PChar);
+var
+ TempPos: Integer;
+begin
+ if not Assigned(aResType) then begin
+ TempPos := Pos('.', aResource);
+ aResType := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos)));
+ aResource := UpperCase(Copy(aResource, 0, TempPos -1));
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.UpdateScanlines;
+var
+ w, h, i, LineWidth: Integer;
+begin
+ w := Width;
+ h := Height;
+ fHasScanlines := Assigned(fData) and (w > 0) and (h > 0);
+ if fHasScanlines then begin
+ SetLength(fScanlines, h);
+ LineWidth := Trunc(w * FormatDescriptor.BytesPerPixel);
+ for i := 0 to h-1 do begin
+ fScanlines[i] := fData;
+ Inc(fScanlines[i], i * LineWidth);
+ end;
+ end else
+ SetLength(fScanlines, 0);
+end;
+
+{$IFDEF GLB_SUPPORT_PNG_READ}
+{$IF DEFINED(GLB_LAZ_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//PNG/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
+const
+ MAGIC_LEN = 8;
+ PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A;
+var
+ reader: TLazReaderPNG;
+ intf: TLazIntfImage;
+ StreamPos: Int64;
+ magic: String[MAGIC_LEN];
+begin
+ result := true;
+ StreamPos := aStream.Position;
+
+ SetLength(magic, MAGIC_LEN);
+ aStream.Read(magic[1], MAGIC_LEN);
+ aStream.Position := StreamPos;
+ if (magic <> PNG_MAGIC) then begin
+ result := false;
+ exit;
+ end;
+
+ intf := TLazIntfImage.Create(0, 0);
+ reader := TLazReaderPNG.Create;
+ try try
+ reader.UpdateDescription := true;
+ reader.ImageRead(aStream, intf);
+ AssignFromLazIntfImage(intf);
+ except
+ result := false;
+ aStream.Position := StreamPos;
+ exit;
+ end;
+ finally
+ reader.Free;
+ intf.Free;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
+var
+ Surface: PSDL_Surface;
+ RWops: PSDL_RWops;
+begin
+ result := false;
+ RWops := glBitmapCreateRWops(aStream);
+ try
+ if IMG_isPNG(RWops) > 0 then begin
+ Surface := IMG_LoadPNG_RW(RWops);
+ try
+ AssignFromSurface(Surface);
+ result := true;
+ finally
+ SDL_FreeSurface(Surface);
+ end;
+ end;
+ finally
+ SDL_FreeRW(RWops);
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
+begin
+ TStream(png_get_io_ptr(png)).Read(buffer^, size);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
+var
+ StreamPos: Int64;
+ signature: array [0..7] of byte;
+ png: png_structp;
+ png_info: png_infop;
+
+ TempHeight, TempWidth: Integer;
+ Format: TglBitmapFormat;
+
+ png_data: pByte;
+ png_rows: array of pByte;
+ Row, LineSize: Integer;
+begin
+ result := false;
+
+ if not init_libPNG then
+ raise Exception.Create('LoadPNG - unable to initialize libPNG.');
+
+ try
+ // signature
+ StreamPos := aStream.Position;
+ aStream.Read(signature{%H-}, 8);
+ aStream.Position := StreamPos;
+
+ if png_check_sig(@signature, 8) <> 0 then begin
+ // png read struct
+ png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
+ if png = nil then
+ raise EglBitmapException.Create('LoadPng - couldn''t create read struct.');
+
+ // png info
+ png_info := png_create_info_struct(png);
+ if png_info = nil then begin
+ png_destroy_read_struct(@png, nil, nil);
+ raise EglBitmapException.Create('LoadPng - couldn''t create info struct.');
+ end;
+
+ // set read callback
+ png_set_read_fn(png, aStream, glBitmap_libPNG_read_func);
+
+ // read informations
+ png_read_info(png, png_info);
+
+ // size
+ TempHeight := png_get_image_height(png, png_info);
+ TempWidth := png_get_image_width(png, png_info);
+
+ // format
+ case png_get_color_type(png, png_info) of
+ PNG_COLOR_TYPE_GRAY:
+ Format := tfLuminance8ub1;
+ PNG_COLOR_TYPE_GRAY_ALPHA:
+ Format := tfLuminance8Alpha8us1;
+ PNG_COLOR_TYPE_RGB:
+ Format := tfRGB8ub3;
+ PNG_COLOR_TYPE_RGB_ALPHA:
+ Format := tfRGBA8ub4;
+ else
+ raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+ end;
+
+ // cut upper 8 bit from 16 bit formats
+ if png_get_bit_depth(png, png_info) > 8 then
+ png_set_strip_16(png);
+
+ // expand bitdepth smaller than 8
+ if png_get_bit_depth(png, png_info) < 8 then
+ png_set_expand(png);
+
+ // allocating mem for scanlines
+ LineSize := png_get_rowbytes(png, png_info);
+ GetMem(png_data, TempHeight * LineSize);
+ try
+ SetLength(png_rows, TempHeight);
+ for Row := Low(png_rows) to High(png_rows) do begin
+ png_rows[Row] := png_data;
+ Inc(png_rows[Row], Row * LineSize);
+ end;
+
+ // read complete image into scanlines
+ png_read_image(png, @png_rows[0]);
+
+ // read end
+ png_read_end(png, png_info);
+
+ // destroy read struct
+ png_destroy_read_struct(@png, @png_info, nil);
+
+ SetLength(png_rows, 0);
+
+ // set new data
+ SetData(png_data, Format, TempWidth, TempHeight);
+
+ result := true;
+ except
+ if Assigned(png_data) then
+ FreeMem(png_data);
+ raise;
+ end;
+ end;
+ finally
+ quit_libPNG;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_PNGIMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadPNG(const aStream: TStream): Boolean;
+var
+ StreamPos: Int64;
+ Png: TPNGObject;
+ Header: String[8];
+ Row, Col, PixSize, LineSize: Integer;
+ NewImage, pSource, pDest, pAlpha: pByte;
+ PngFormat: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
+
+const
+ PngHeader: String[8] = #137#80#78#71#13#10#26#10;
+
+begin
+ result := false;
+
+ StreamPos := aStream.Position;
+ aStream.Read(Header[0], SizeOf(Header));
+ aStream.Position := StreamPos;
+
+ {Test if the header matches}
+ if Header = PngHeader then begin
+ Png := TPNGObject.Create;
+ try
+ Png.LoadFromStream(aStream);
+
+ case Png.Header.ColorType of
+ COLOR_GRAYSCALE:
+ PngFormat := tfLuminance8ub1;
+ COLOR_GRAYSCALEALPHA:
+ PngFormat := tfLuminance8Alpha8us1;
+ COLOR_RGB:
+ PngFormat := tfBGR8ub3;
+ COLOR_RGBALPHA:
+ PngFormat := tfBGRA8ub4;
+ else
+ raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+ end;
+
+ FormatDesc := TFormatDescriptor.Get(PngFormat);
+ PixSize := Round(FormatDesc.PixelSize);
+ LineSize := FormatDesc.GetSize(Png.Header.Width, 1);
+
+ GetMem(NewImage, LineSize * Integer(Png.Header.Height));
+ try
+ pDest := NewImage;
+
+ case Png.Header.ColorType of
+ COLOR_RGB, COLOR_GRAYSCALE:
+ begin
+ for Row := 0 to Png.Height -1 do begin
+ Move (Png.Scanline[Row]^, pDest^, LineSize);
+ Inc(pDest, LineSize);
+ end;
+ end;
+ COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA:
+ begin
+ PixSize := PixSize -1;
+
+ for Row := 0 to Png.Height -1 do begin
+ pSource := Png.Scanline[Row];
+ pAlpha := pByte(Png.AlphaScanline[Row]);
+
+ for Col := 0 to Png.Width -1 do begin
+ Move (pSource^, pDest^, PixSize);
+ Inc(pSource, PixSize);
+ Inc(pDest, PixSize);
+
+ pDest^ := pAlpha^;
+ inc(pAlpha);
+ Inc(pDest);
+ end;
+ end;
+ end;
+ else
+ raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+ end;
+
+ SetData(NewImage, PngFormat, Png.Header.Width, Png.Header.Height);
+
+ result := true;
+ except
+ if Assigned(NewImage) then
+ FreeMem(NewImage);
+ raise;
+ end;
+ finally
+ Png.Free;
+ end;
+ end;
+end;
+{$IFEND}
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_PNG_WRITE}
+{$IFDEF GLB_LIB_PNG}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
+begin
+ TStream(png_get_io_ptr(png)).Write(buffer^, size);
+end;
+{$ENDIF}
+
+{$IF DEFINED(GLB_LAZ_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SavePNG(const aStream: TStream);
+var
+ png: TPortableNetworkGraphic;
+ intf: TLazIntfImage;
+ raw: TRawImage;
+begin
+ png := TPortableNetworkGraphic.Create;
+ intf := TLazIntfImage.Create(0, 0);
+ try
+ if not AssignToLazIntfImage(intf) then
+ raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
+ intf.GetRawImage(raw);
+ png.LoadFromRawImage(raw, false);
+ png.SaveToStream(aStream);
+ finally
+ png.Free;
+ intf.Free;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SavePNG(const aStream: TStream);
+var
+ png: png_structp;
+ png_info: png_infop;
+ png_rows: array of pByte;
+ LineSize: Integer;
+ ColorType: Integer;
+ Row: Integer;
+ FormatDesc: TFormatDescriptor;
+begin
+ if not (ftPNG in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ if not init_libPNG then
+ raise Exception.Create('unable to initialize libPNG.');
+
+ try
+ case Format of
+ tfAlpha8ub1, tfLuminance8ub1:
+ ColorType := PNG_COLOR_TYPE_GRAY;
+ tfLuminance8Alpha8us1:
+ ColorType := PNG_COLOR_TYPE_GRAY_ALPHA;
+ tfBGR8ub3, tfRGB8ub3:
+ ColorType := PNG_COLOR_TYPE_RGB;
+ tfBGRA8ub4, tfRGBA8ub4:
+ ColorType := PNG_COLOR_TYPE_RGBA;
+ else
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ end;
+
+ FormatDesc := TFormatDescriptor.Get(Format);
+ LineSize := FormatDesc.GetSize(Width, 1);
+
+ // creating array for scanline
+ SetLength(png_rows, Height);
+ try
+ for Row := 0 to Height - 1 do begin
+ png_rows[Row] := Data;
+ Inc(png_rows[Row], Row * LineSize)
+ end;
+
+ // write struct
+ png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
+ if png = nil then
+ raise EglBitmapException.Create('SavePng - couldn''t create write struct.');
+
+ // create png info
+ png_info := png_create_info_struct(png);
+ if png_info = nil then begin
+ png_destroy_write_struct(@png, nil);
+ raise EglBitmapException.Create('SavePng - couldn''t create info struct.');
+ end;
+
+ // set read callback
+ png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil);
+
+ // set compression
+ png_set_compression_level(png, 6);
+
+ if Format in [tfBGR8ub3, tfBGRA8ub4] then
+ png_set_bgr(png);
+
+ png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ png_write_info(png, png_info);
+ png_write_image(png, @png_rows[0]);
+ png_write_end(png, png_info);
+ png_destroy_write_struct(@png, @png_info);
+ finally
+ SetLength(png_rows, 0);
+ end;
+ finally
+ quit_libPNG;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_PNGIMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SavePNG(const aStream: TStream);
+var
+ Png: TPNGObject;
+
+ pSource, pDest: pByte;
+ X, Y, PixSize: Integer;
+ ColorType: Cardinal;
+ Alpha: Boolean;
+
+ pTemp: pByte;
+ Temp: Byte;
+begin
+ if not (ftPNG in FormatGetSupportedFiles (Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ case Format of
+ tfAlpha8ub1, tfLuminance8ub1: begin
+ ColorType := COLOR_GRAYSCALE;
+ PixSize := 1;
+ Alpha := false;
+ end;
+ tfLuminance8Alpha8us1: begin
+ ColorType := COLOR_GRAYSCALEALPHA;
+ PixSize := 1;
+ Alpha := true;
+ end;
+ tfBGR8ub3, tfRGB8ub3: begin
+ ColorType := COLOR_RGB;
+ PixSize := 3;
+ Alpha := false;
+ end;
+ tfBGRA8ub4, tfRGBA8ub4: begin
+ ColorType := COLOR_RGBALPHA;
+ PixSize := 3;
+ Alpha := true
+ end;
+ else
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ end;
+
+ Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height);
+ try
+ // Copy ImageData
+ pSource := Data;
+ for Y := 0 to Height -1 do begin
+ pDest := png.ScanLine[Y];
+ for X := 0 to Width -1 do begin
+ Move(pSource^, pDest^, PixSize);
+ Inc(pDest, PixSize);
+ Inc(pSource, PixSize);
+ if Alpha then begin
+ png.AlphaScanline[Y]^[X] := pSource^;
+ Inc(pSource);
+ end;
+ end;
+
+ // convert RGB line to BGR
+ if Format in [tfRGB8ub3, tfRGBA8ub4] then begin
+ pTemp := png.ScanLine[Y];
+ for X := 0 to Width -1 do begin
+ Temp := pByteArray(pTemp)^[0];
+ pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2];
+ pByteArray(pTemp)^[2] := Temp;
+ Inc(pTemp, 3);
+ end;
+ end;
+ end;
+
+ // Save to Stream
+ Png.CompressionLevel := 6;
+ Png.SaveToStream(aStream);
+ finally
+ FreeAndNil(Png);
+ end;
+end;
+{$IFEND}
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//JPEG////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IFDEF GLB_LIB_JPEG}
+type
+ glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr;
+ glBitmap_libJPEG_source_mgr = record
+ pub: jpeg_source_mgr;
+
+ SrcStream: TStream;
+ SrcBuffer: array [1..4096] of byte;
+ end;
+
+ glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr;
+ glBitmap_libJPEG_dest_mgr = record
+ pub: jpeg_destination_mgr;
+
+ DestStream: TStream;
+ DestBuffer: array [1..4096] of byte;
+ end;
+
+procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
+var
+ src: glBitmap_libJPEG_source_mgr_ptr;
+ bytes: integer;
+begin
+ src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
+
+ bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096);
+ if (bytes <= 0) then begin
+ src^.SrcBuffer[1] := $FF;
+ src^.SrcBuffer[2] := JPEG_EOI;
+ bytes := 2;
+ end;
+
+ src^.pub.next_input_byte := @(src^.SrcBuffer[1]);
+ src^.pub.bytes_in_buffer := bytes;
+
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl;
+var
+ src: glBitmap_libJPEG_source_mgr_ptr;
+begin
+ src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
+
+ if num_bytes > 0 then begin
+ // wanted byte isn't in buffer so set stream position and read buffer
+ if num_bytes > src^.pub.bytes_in_buffer then begin
+ src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer;
+ src^.pub.fill_input_buffer(cinfo);
+ end else begin
+ // wanted byte is in buffer so only skip
+ inc(src^.pub.next_input_byte, num_bytes);
+ dec(src^.pub.bytes_in_buffer, num_bytes);
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
+var
+ dest: glBitmap_libJPEG_dest_mgr_ptr;
+begin
+ dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
+
+ if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin
+ // write complete buffer
+ dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer));
+
+ // reset buffer
+ dest^.pub.next_output_byte := @dest^.DestBuffer[1];
+ dest^.pub.free_in_buffer := Length(dest^.DestBuffer);
+ end;
+
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl;
+var
+ Idx: Integer;
+ dest: glBitmap_libJPEG_dest_mgr_ptr;
+begin
+ dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
+
+ for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin
+ // check for endblock
+ if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin
+ // write endblock
+ dest^.DestStream.Write(dest^.DestBuffer[Idx], 2);
+
+ // leave
+ break;
+ end else
+ dest^.DestStream.Write(dest^.DestBuffer[Idx], 1);
+ end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_READ}
+{$IF DEFINED(GLB_LAZ_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
+const
+ MAGIC_LEN = 2;
+ JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8;
+var
+ intf: TLazIntfImage;
+ reader: TFPReaderJPEG;
+ StreamPos: Int64;
+ magic: String[MAGIC_LEN];
+begin
+ result := true;
+ StreamPos := aStream.Position;
+
+ SetLength(magic, MAGIC_LEN);
+ aStream.Read(magic[1], MAGIC_LEN);
+ aStream.Position := StreamPos;
+ if (magic <> JPEG_MAGIC) then begin
+ result := false;
+ exit;
+ end;
+
+ reader := TFPReaderJPEG.Create;
+ intf := TLazIntfImage.Create(0, 0);
+ try try
+ intf.DataDescription := GetDescriptionFromDevice(0, 0, 0);
+ reader.ImageRead(aStream, intf);
+ AssignFromLazIntfImage(intf);
+ except
+ result := false;
+ aStream.Position := StreamPos;
+ exit;
+ end;
+ finally
+ reader.Free;
+ intf.Free;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
+var
+ Surface: PSDL_Surface;
+ RWops: PSDL_RWops;
+begin
+ result := false;
+
+ RWops := glBitmapCreateRWops(aStream);
+ try
+ if IMG_isJPG(RWops) > 0 then begin
+ Surface := IMG_LoadJPG_RW(RWops);
+ try
+ AssignFromSurface(Surface);
+ result := true;
+ finally
+ SDL_FreeSurface(Surface);
+ end;
+ end;
+ finally
+ SDL_FreeRW(RWops);
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
+var
+ StreamPos: Int64;
+ Temp: array[0..1]of Byte;
+
+ jpeg: jpeg_decompress_struct;
+ jpeg_err: jpeg_error_mgr;
+
+ IntFormat: TglBitmapFormat;
+ pImage: pByte;
+ TempHeight, TempWidth: Integer;
+
+ pTemp: pByte;
+ Row: Integer;
+
+ FormatDesc: TFormatDescriptor;
+begin
+ result := false;
+
+ if not init_libJPEG then
+ raise Exception.Create('LoadJPG - unable to initialize libJPEG.');
+
+ try
+ // reading first two bytes to test file and set cursor back to begin
+ StreamPos := aStream.Position;
+ aStream.Read({%H-}Temp[0], 2);
+ aStream.Position := StreamPos;
+
+ // if Bitmap then read file.
+ if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
+ FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00);
+ FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
+
+ // error managment
+ jpeg.err := jpeg_std_error(@jpeg_err);
+ jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
+ jpeg_err.output_message := glBitmap_libJPEG_output_message;
+
+ // decompression struct
+ jpeg_create_decompress(@jpeg);
+
+ // allocation space for streaming methods
+ jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr));
+
+ // seeting up custom functions
+ with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin
+ pub.init_source := glBitmap_libJPEG_init_source;
+ pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer;
+ pub.skip_input_data := glBitmap_libJPEG_skip_input_data;
+ pub.resync_to_restart := jpeg_resync_to_restart; // use default method
+ pub.term_source := glBitmap_libJPEG_term_source;
+
+ pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read
+ pub.next_input_byte := nil; // until buffer loaded
+
+ SrcStream := aStream;
+ end;
+
+ // set global decoding state
+ jpeg.global_state := DSTATE_START;
+
+ // read header of jpeg
+ jpeg_read_header(@jpeg, false);
+
+ // setting output parameter
+ case jpeg.jpeg_color_space of
+ JCS_GRAYSCALE:
+ begin
+ jpeg.out_color_space := JCS_GRAYSCALE;
+ IntFormat := tfLuminance8ub1;
+ end;
+ else
+ jpeg.out_color_space := JCS_RGB;
+ IntFormat := tfRGB8ub3;
+ end;
+
+ // reading image
+ jpeg_start_decompress(@jpeg);
+
+ TempHeight := jpeg.output_height;
+ TempWidth := jpeg.output_width;
+
+ FormatDesc := TFormatDescriptor.Get(IntFormat);
+
+ // creating new image
+ GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight));
+ try
+ pTemp := pImage;
+
+ for Row := 0 to TempHeight -1 do begin
+ jpeg_read_scanlines(@jpeg, @pTemp, 1);
+ Inc(pTemp, FormatDesc.GetSize(TempWidth, 1));
+ end;
+
+ // finish decompression
+ jpeg_finish_decompress(@jpeg);
+
+ // destroy decompression
+ jpeg_destroy_decompress(@jpeg);
+
+ SetData(pImage, IntFormat, TempWidth, TempHeight);
+
+ result := true;
+ except
+ if Assigned(pImage) then
+ FreeMem(pImage);
+ raise;
+ end;
+ end;
+ finally
+ quit_libJPEG;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean;
+var
+ bmp: TBitmap;
+ jpg: TJPEGImage;
+ StreamPos: Int64;
+ Temp: array[0..1]of Byte;
+begin
+ result := false;
+
+ // reading first two bytes to test file and set cursor back to begin
+ StreamPos := aStream.Position;
+ aStream.Read(Temp[0], 2);
+ aStream.Position := StreamPos;
+
+ // if Bitmap then read file.
+ if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
+ bmp := TBitmap.Create;
+ try
+ jpg := TJPEGImage.Create;
+ try
+ jpg.LoadFromStream(aStream);
+ bmp.Assign(jpg);
+ result := AssignFromBitmap(bmp);
+ finally
+ jpg.Free;
+ end;
+ finally
+ bmp.Free;
+ end;
+ end;
+end;
+{$IFEND}
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_WRITE}
+{$IF DEFINED(GLB_LAZ_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveJPEG(const aStream: TStream);
+var
+ jpeg: TJPEGImage;
+ intf: TLazIntfImage;
+ raw: TRawImage;
+begin
+ jpeg := TJPEGImage.Create;
+ intf := TLazIntfImage.Create(0, 0);
+ try
+ if not AssignToLazIntfImage(intf) then
+ raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
+ intf.GetRawImage(raw);
+ jpeg.LoadFromRawImage(raw, false);
+ jpeg.SaveToStream(aStream);
+ finally
+ intf.Free;
+ jpeg.Free;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveJPEG(const aStream: TStream);
+var
+ jpeg: jpeg_compress_struct;
+ jpeg_err: jpeg_error_mgr;
+ Row: Integer;
+ pTemp, pTemp2: pByte;
+
+ procedure CopyRow(pDest, pSource: pByte);
+ var
+ X: Integer;
+ begin
+ for X := 0 to Width - 1 do begin
+ pByteArray(pDest)^[0] := pByteArray(pSource)^[2];
+ pByteArray(pDest)^[1] := pByteArray(pSource)^[1];
+ pByteArray(pDest)^[2] := pByteArray(pSource)^[0];
+ Inc(pDest, 3);
+ Inc(pSource, 3);
+ end;
+ end;
+
+begin
+ if not (ftJPEG in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ if not init_libJPEG then
+ raise Exception.Create('SaveJPG - unable to initialize libJPEG.');
+
+ try
+ FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00);
+ FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
+
+ // error managment
+ jpeg.err := jpeg_std_error(@jpeg_err);
+ jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
+ jpeg_err.output_message := glBitmap_libJPEG_output_message;
+
+ // compression struct
+ jpeg_create_compress(@jpeg);
+
+ // allocation space for streaming methods
+ jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr));
+
+ // seeting up custom functions
+ with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin
+ pub.init_destination := glBitmap_libJPEG_init_destination;
+ pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer;
+ pub.term_destination := glBitmap_libJPEG_term_destination;
+
+ pub.next_output_byte := @DestBuffer[1];
+ pub.free_in_buffer := Length(DestBuffer);
+
+ DestStream := aStream;
+ end;
+
+ // very important state
+ jpeg.global_state := CSTATE_START;
+ jpeg.image_width := Width;
+ jpeg.image_height := Height;
+ case Format of
+ tfAlpha8ub1, tfLuminance8ub1: begin
+ jpeg.input_components := 1;
+ jpeg.in_color_space := JCS_GRAYSCALE;
+ end;
+ tfRGB8ub3, tfBGR8ub3: begin
+ jpeg.input_components := 3;
+ jpeg.in_color_space := JCS_RGB;
+ end;
+ end;
+
+ jpeg_set_defaults(@jpeg);
+ jpeg_set_quality(@jpeg, 95, true);
+ jpeg_start_compress(@jpeg, true);
+ pTemp := Data;
+
+ if Format = tfBGR8ub3 then
+ GetMem(pTemp2, fRowSize)
+ else
+ pTemp2 := pTemp;
+
+ try
+ for Row := 0 to jpeg.image_height -1 do begin
+ // prepare row
+ if Format = tfBGR8ub3 then
+ CopyRow(pTemp2, pTemp)
+ else
+ pTemp2 := pTemp;
+
+ // write row
+ jpeg_write_scanlines(@jpeg, @pTemp2, 1);
+ inc(pTemp, fRowSize);
+ end;
+ finally
+ // free memory
+ if Format = tfBGR8ub3 then
+ FreeMem(pTemp2);
+ end;
+ jpeg_finish_compress(@jpeg);
+ jpeg_destroy_compress(@jpeg);
+ finally
+ quit_libJPEG;
+ end;
+end;
+
+{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveJPEG(const aStream: TStream);
+var
+ Bmp: TBitmap;
+ Jpg: TJPEGImage;
+begin
+ if not (ftJPEG in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ Bmp := TBitmap.Create;
+ try
+ Jpg := TJPEGImage.Create;
+ try
+ AssignToBitmap(Bmp);
+ if (Format in [tfAlpha8ub1, tfLuminance8ub1]) then begin
+ Jpg.Grayscale := true;
+ Jpg.PixelFormat := jf8Bit;
+ end;
+ Jpg.Assign(Bmp);
+ Jpg.SaveToStream(aStream);
+ finally
+ FreeAndNil(Jpg);
+ end;
+ finally
+ FreeAndNil(Bmp);
+ end;
+end;
+{$IFEND}
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//RAW/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+ RawHeader = packed record
+ Magic: String[5];
+ Version: Byte;
+ Width: Integer;
+ Height: Integer;
+ DataSize: Integer;
+ BitsPerPixel: Integer;
+ Precision: TglBitmapRec4ub;
+ Shift: TglBitmapRec4ub;
+ end;
+
+function TglBitmapData.LoadRAW(const aStream: TStream): Boolean;
+var
+ header: RawHeader;
+ StartPos: Int64;
+ fd: TFormatDescriptor;
+ buf: PByte;
+begin
+ result := false;
+ StartPos := aStream.Position;
+ aStream.Read(header{%H-}, SizeOf(header));
+ if (header.Magic <> 'glBMP') then begin
+ aStream.Position := StartPos;
+ exit;
+ end;
+
+ fd := TFormatDescriptor.GetFromPrecShift(header.Precision, header.Shift, header.BitsPerPixel);
+ if (fd.Format = tfEmpty) then
+ raise EglBitmapUnsupportedFormat.Create('no supported format found');
+
+ buf := GetMemory(header.DataSize);
+ aStream.Read(buf^, header.DataSize);
+ SetData(buf, fd.Format, header.Width, header.Height);
+
+ result := true;
+end;
+
+procedure TglBitmapData.SaveRAW(const aStream: TStream);
+var
+ header: RawHeader;
+ fd: TFormatDescriptor;
+begin
+ fd := TFormatDescriptor.Get(Format);
+ header.Magic := 'glBMP';
+ header.Version := 1;
+ header.Width := Width;
+ header.Height := Height;
+ header.DataSize := fd.GetSize(fDimension);
+ header.BitsPerPixel := fd.BitsPerPixel;
+ header.Precision := fd.Precision;
+ header.Shift := fd.Shift;
+ aStream.Write(header, SizeOf(header));
+ aStream.Write(Data^, header.DataSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//BMP/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+const
+ BMP_MAGIC = $4D42;
+
+ BMP_COMP_RGB = 0;
+ BMP_COMP_RLE8 = 1;
+ BMP_COMP_RLE4 = 2;
+ BMP_COMP_BITFIELDS = 3;
+
+type
+ TBMPHeader = packed record
+ bfType: Word;
+ bfSize: Cardinal;
+ bfReserved1: Word;
+ bfReserved2: Word;
+ bfOffBits: Cardinal;
+ end;
+
+ TBMPInfo = packed record
+ biSize: Cardinal;
+ biWidth: Longint;
+ biHeight: Longint;
+ biPlanes: Word;
+ biBitCount: Word;
+ biCompression: Cardinal;
+ biSizeImage: Cardinal;
+ biXPelsPerMeter: Longint;
+ biYPelsPerMeter: Longint;
+ biClrUsed: Cardinal;
+ biClrImportant: Cardinal;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadBMP(const aStream: TStream): Boolean;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat;
+ var
+ tmp, i: Cardinal;
+ begin
+ result := tfEmpty;
+ aStream.Read(aInfo{%H-}, SizeOf(aInfo));
+ FillChar(aMask{%H-}, SizeOf(aMask), 0);
+
+ //Read Compression
+ case aInfo.biCompression of
+ BMP_COMP_RLE4,
+ BMP_COMP_RLE8: begin
+ raise EglBitmap.Create('RLE compression is not supported');
+ end;
+ BMP_COMP_BITFIELDS: begin
+ if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
+ for i := 0 to 2 do begin
+ aStream.Read(tmp{%H-}, SizeOf(tmp));
+ aMask.arr[i] := tmp;
+ end;
+ end else
+ raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
+ end;
+ end;
+
+ //get suitable format
+ case aInfo.biBitCount of
+ 8: result := tfLuminance8ub1;
+ 16: result := tfX1RGB5us1;
+ 24: result := tfBGR8ub3;
+ 32: result := tfXRGB8ui1;
+ end;
+ end;
+
+ function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat;
+ var
+ i, c: Integer;
+ fd: TFormatDescriptor;
+ ColorTable: TbmpColorTable;
+ begin
+ result := nil;
+ if (aInfo.biBitCount >= 16) then
+ exit;
+ aFormat := tfLuminance8ub1;
+ c := aInfo.biClrUsed;
+ if (c = 0) then
+ c := 1 shl aInfo.biBitCount;
+ SetLength(ColorTable, c);
+ for i := 0 to c-1 do begin
+ aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty));
+ if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then
+ aFormat := tfRGB8ub3;
+ end;
+
+ fd := TFormatDescriptor.Get(aFormat);
+ result := TbmpColorTableFormat.Create;
+ result.ColorTable := ColorTable;
+ result.SetCustomValues(aFormat, aInfo.biBitCount, fd.Precision, fd.Shift);
+ end;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat;
+ var
+ fd: TFormatDescriptor;
+ begin
+ result := nil;
+ if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin
+
+ // find suitable format ...
+ fd := TFormatDescriptor.GetFromMask(aMask);
+ if (fd.Format <> tfEmpty) then begin
+ aFormat := fd.Format;
+ exit;
+ end;
+
+ // or create custom bitfield format
+ result := TbmpBitfieldFormat.Create;
+ result.SetCustomValues(aInfo.biBitCount, aMask);
+ end;
+ end;
+
+var
+ //simple types
+ StartPos: Int64;
+ ImageSize, rbLineSize, wbLineSize, Padding, i: Integer;
+ PaddingBuff: Cardinal;
+ LineBuf, ImageData, TmpData: PByte;
+ SourceMD, DestMD: Pointer;
+ BmpFormat: TglBitmapFormat;
+
+ //records
+ Mask: TglBitmapRec4ul;
+ Header: TBMPHeader;
+ Info: TBMPInfo;
+
+ //classes
+ SpecialFormat: TFormatDescriptor;
+ FormatDesc: TFormatDescriptor;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte);
+ var
+ i: Integer;
+ Pixel: TglBitmapPixelData;
+ begin
+ aStream.Read(aLineBuf^, rbLineSize);
+ SpecialFormat.PreparePixel(Pixel);
+ for i := 0 to Info.biWidth-1 do begin
+ SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD);
+ glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc);
+ FormatDesc.Map(Pixel, aData, DestMD);
+ end;
+ end;
+
+begin
+ result := false;
+ BmpFormat := tfEmpty;
+ SpecialFormat := nil;
+ LineBuf := nil;
+ SourceMD := nil;
+ DestMD := nil;
+
+ // Header
+ StartPos := aStream.Position;
+ aStream.Read(Header{%H-}, SizeOf(Header));
+
+ if Header.bfType = BMP_MAGIC then begin
+ try try
+ BmpFormat := ReadInfo(Info, Mask);
+ SpecialFormat := ReadColorTable(BmpFormat, Info);
+ if not Assigned(SpecialFormat) then
+ SpecialFormat := CheckBitfields(BmpFormat, Mask, Info);
+ aStream.Position := StartPos + Header.bfOffBits;
+
+ if (BmpFormat <> tfEmpty) then begin
+ FormatDesc := TFormatDescriptor.Get(BmpFormat);
+ rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize
+ wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel);
+ Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize;
+
+ //get Memory
+ DestMD := FormatDesc.CreateMappingData;
+ ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight));
+ GetMem(ImageData, ImageSize);
+ if Assigned(SpecialFormat) then begin
+ GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields
+ SourceMD := SpecialFormat.CreateMappingData;
+ end;
+
+ //read Data
+ try try
+ FillChar(ImageData^, ImageSize, $FF);
+ TmpData := ImageData;
+ if (Info.biHeight > 0) then
+ Inc(TmpData, wbLineSize * (Info.biHeight-1));
+ for i := 0 to Abs(Info.biHeight)-1 do begin
+ if Assigned(SpecialFormat) then
+ SpecialFormatReadLine(TmpData, LineBuf) //if is special format read and convert data
+ else
+ aStream.Read(TmpData^, wbLineSize); //else only read data
+ if (Info.biHeight > 0) then
+ dec(TmpData, wbLineSize)
+ else
+ inc(TmpData, wbLineSize);
+ aStream.Read(PaddingBuff{%H-}, Padding);
+ end;
+ SetData(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight));
+ result := true;
+ finally
+ if Assigned(LineBuf) then
+ FreeMem(LineBuf);
+ if Assigned(SourceMD) then
+ SpecialFormat.FreeMappingData(SourceMD);
+ FormatDesc.FreeMappingData(DestMD);
+ end;
+ except
+ if Assigned(ImageData) then
+ FreeMem(ImageData);
+ raise;
+ end;
+ end else
+ raise EglBitmap.Create('LoadBMP - No suitable format found');
+ except
+ aStream.Position := StartPos;
+ raise;
+ end;
+ finally
+ FreeAndNil(SpecialFormat);
+ end;
+ end
+ else aStream.Position := StartPos;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveBMP(const aStream: TStream);
+var
+ Header: TBMPHeader;
+ Info: TBMPInfo;
+ Converter: TFormatDescriptor;
+ FormatDesc: TFormatDescriptor;
+ SourceFD, DestFD: Pointer;
+ pData, srcData, dstData, ConvertBuffer: pByte;
+
+ Pixel: TglBitmapPixelData;
+ ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer;
+ RedMask, GreenMask, BlueMask, AlphaMask: Cardinal;
+
+ PaddingBuff: Cardinal;
+
+ function GetLineWidth : Integer;
+ begin
+ result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3;
+ end;
+
+begin
+ if not (ftBMP in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ Converter := nil;
+ FormatDesc := TFormatDescriptor.Get(Format);
+ ImageSize := FormatDesc.GetSize(Dimension);
+
+ FillChar(Header{%H-}, SizeOf(Header), 0);
+ Header.bfType := BMP_MAGIC;
+ Header.bfSize := SizeOf(Header) + SizeOf(Info) + ImageSize;
+ Header.bfReserved1 := 0;
+ Header.bfReserved2 := 0;
+ Header.bfOffBits := SizeOf(Header) + SizeOf(Info);
+
+ FillChar(Info{%H-}, SizeOf(Info), 0);
+ Info.biSize := SizeOf(Info);
+ Info.biWidth := Width;
+ Info.biHeight := Height;
+ Info.biPlanes := 1;
+ Info.biCompression := BMP_COMP_RGB;
+ Info.biSizeImage := ImageSize;
+
+ try
+ case Format of
+ tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1:
+ begin
+ Info.biBitCount := 8;
+ Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal);
+ Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries
+ Converter := TbmpColorTableFormat.Create;
+ with (Converter as TbmpColorTableFormat) do begin
+ SetCustomValues(fFormat, 8, FormatDesc.Precision, FormatDesc.Shift);
+ CreateColorTable;
+ end;
+ end;
+
+ tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2,
+ tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1,
+ tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1:
+ begin
+ Info.biBitCount := 16;
+ Info.biCompression := BMP_COMP_BITFIELDS;
+ end;
+
+ tfBGR8ub3, tfRGB8ub3:
+ begin
+ Info.biBitCount := 24;
+ if (Format = tfRGB8ub3) then
+ Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values
+ end;
+
+ tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1,
+ tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1:
+ begin
+ Info.biBitCount := 32;
+ Info.biCompression := BMP_COMP_BITFIELDS;
+ end;
+ else
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ end;
+ Info.biXPelsPerMeter := 2835;
+ Info.biYPelsPerMeter := 2835;
+
+ // prepare bitmasks
+ if Info.biCompression = BMP_COMP_BITFIELDS then begin
+ Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal);
+ Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal);
+
+ RedMask := FormatDesc.Mask.r;
+ GreenMask := FormatDesc.Mask.g;
+ BlueMask := FormatDesc.Mask.b;
+ AlphaMask := FormatDesc.Mask.a;
+ end;
+
+ // headers
+ aStream.Write(Header, SizeOf(Header));
+ aStream.Write(Info, SizeOf(Info));
+
+ // colortable
+ if Assigned(Converter) and (Converter is TbmpColorTableFormat) then
+ with (Converter as TbmpColorTableFormat) do
+ aStream.Write(ColorTable[0].b,
+ SizeOf(TbmpColorTableEnty) * Length(ColorTable));
+
+ // bitmasks
+ if Info.biCompression = BMP_COMP_BITFIELDS then begin
+ aStream.Write(RedMask, SizeOf(Cardinal));
+ aStream.Write(GreenMask, SizeOf(Cardinal));
+ aStream.Write(BlueMask, SizeOf(Cardinal));
+ aStream.Write(AlphaMask, SizeOf(Cardinal));
+ end;
+
+ // image data
+ rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel);
+ wbLineSize := Round(Info.biWidth * Info.biBitCount / 8);
+ Padding := GetLineWidth - wbLineSize;
+ PaddingBuff := 0;
+
+ pData := Data;
+ inc(pData, (Height-1) * rbLineSize);
+
+ // prepare row buffer. But only for RGB because RGBA supports color masks
+ // so it's possible to change color within the image.
+ if Assigned(Converter) then begin
+ FormatDesc.PreparePixel(Pixel);
+ GetMem(ConvertBuffer, wbLineSize);
+ SourceFD := FormatDesc.CreateMappingData;
+ DestFD := Converter.CreateMappingData;
+ end else
+ ConvertBuffer := nil;
+
+ try
+ for LineIdx := 0 to Height - 1 do begin
+ // preparing row
+ if Assigned(Converter) then begin
+ srcData := pData;
+ dstData := ConvertBuffer;
+ for PixelIdx := 0 to Info.biWidth-1 do begin
+ FormatDesc.Unmap(srcData, Pixel, SourceFD);
+ glBitmapConvertPixel(Pixel, FormatDesc, Converter);
+ Converter.Map(Pixel, dstData, DestFD);
+ end;
+ aStream.Write(ConvertBuffer^, wbLineSize);
+ end else begin
+ aStream.Write(pData^, rbLineSize);
+ end;
+ dec(pData, rbLineSize);
+ if (Padding > 0) then
+ aStream.Write(PaddingBuff, Padding);
+ end;
+ finally
+ // destroy row buffer
+ if Assigned(ConvertBuffer) then begin
+ FormatDesc.FreeMappingData(SourceFD);
+ Converter.FreeMappingData(DestFD);
+ FreeMem(ConvertBuffer);
+ end;
+ end;
+ finally
+ if Assigned(Converter) then
+ Converter.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TGA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+ TTGAHeader = packed record
+ ImageID: Byte;
+ ColorMapType: Byte;
+ ImageType: Byte;
+ //ColorMapSpec: Array[0..4] of Byte;
+ ColorMapStart: Word;
+ ColorMapLength: Word;
+ ColorMapEntrySize: Byte;
+ OrigX: Word;
+ OrigY: Word;
+ Width: Word;
+ Height: Word;
+ Bpp: Byte;
+ ImageDesc: Byte;
+ end;
+
+const
+ TGA_UNCOMPRESSED_RGB = 2;
+ TGA_UNCOMPRESSED_GRAY = 3;
+ TGA_COMPRESSED_RGB = 10;
+ TGA_COMPRESSED_GRAY = 11;
+
+ TGA_NONE_COLOR_TABLE = 0;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadTGA(const aStream: TStream): Boolean;
+var
+ Header: TTGAHeader;
+ ImageData: System.PByte;
+ StartPosition: Int64;
+ PixelSize, LineSize: Integer;
+ tgaFormat: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
+ Counter: packed record
+ X, Y: packed record
+ low, high, dir: Integer;
+ end;
+ end;
+
+const
+ CACHE_SIZE = $4000;
+
+ ////////////////////////////////////////////////////////////////////////////////////////
+ procedure ReadUncompressed;
+ var
+ i, j: Integer;
+ buf, tmp1, tmp2: System.PByte;
+ begin
+ buf := nil;
+ if (Counter.X.dir < 0) then
+ GetMem(buf, LineSize);
+ try
+ while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin
+ tmp1 := ImageData;
+ inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart
+ if (Counter.X.dir < 0) then begin //flip X
+ aStream.Read(buf^, LineSize);
+ tmp2 := buf;
+ inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line
+ for i := 0 to Header.Width-1 do begin //for all pixels in line
+ for j := 0 to PixelSize-1 do begin //for all bytes in pixel
+ tmp1^ := tmp2^;
+ inc(tmp1);
+ inc(tmp2);
+ end;
+ dec(tmp2, 2*PixelSize); //move 2 backwards, because j-loop moved 1 forward
+ end;
+ end else
+ aStream.Read(tmp1^, LineSize);
+ inc(Counter.Y.low, Counter.Y.dir); //move to next line index
+ end;
+ finally
+ if Assigned(buf) then
+ FreeMem(buf);
+ end;
+ end;
+
+ ////////////////////////////////////////////////////////////////////////////////////////
+ procedure ReadCompressed;
+
+ /////////////////////////////////////////////////////////////////
+ var
+ TmpData: System.PByte;
+ LinePixelsRead: Integer;
+ procedure CheckLine;
+ begin
+ if (LinePixelsRead >= Header.Width) then begin
+ LinePixelsRead := 0;
+ inc(Counter.Y.low, Counter.Y.dir); //next line index
+ TmpData := ImageData;
+ inc(TmpData, Counter.Y.low * LineSize); //set line
+ if (Counter.X.dir < 0) then //if x flipped then
+ inc(TmpData, LineSize - PixelSize); //set last pixel
+ end;
+ end;
+
+ /////////////////////////////////////////////////////////////////
+ var
+ Cache: PByte;
+ CacheSize, CachePos: Integer;
+ procedure CachedRead(out Buffer; Count: Integer);
+ var
+ BytesRead: Integer;
+ begin
+ if (CachePos + Count > CacheSize) then begin
+ //if buffer overflow save non read bytes
+ BytesRead := 0;
+ if (CacheSize - CachePos > 0) then begin
+ BytesRead := CacheSize - CachePos;
+ Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead);
+ inc(CachePos, BytesRead);
+ end;
+
+ //load cache from file
+ CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position);
+ aStream.Read(Cache^, CacheSize);
+ CachePos := 0;
+
+ //read rest of requested bytes
+ if (Count - BytesRead > 0) then begin
+ Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead);
+ inc(CachePos, Count - BytesRead);
+ end;
+ end else begin
+ //if no buffer overflow just read the data
+ Move(PByteArray(Cache)^[CachePos], Buffer, Count);
+ inc(CachePos, Count);
+ end;
+ end;
+
+ procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte);
+ begin
+ case PixelSize of
+ 1: begin
+ aBuffer^ := aData^;
+ inc(aBuffer, Counter.X.dir);
+ end;
+ 2: begin
+ PWord(aBuffer)^ := PWord(aData)^;
+ inc(aBuffer, 2 * Counter.X.dir);
+ end;
+ 3: begin
+ PByteArray(aBuffer)^[0] := PByteArray(aData)^[0];
+ PByteArray(aBuffer)^[1] := PByteArray(aData)^[1];
+ PByteArray(aBuffer)^[2] := PByteArray(aData)^[2];
+ inc(aBuffer, 3 * Counter.X.dir);
+ end;
+ 4: begin
+ PCardinal(aBuffer)^ := PCardinal(aData)^;
+ inc(aBuffer, 4 * Counter.X.dir);
+ end;
+ end;
+ end;
+
+ var
+ TotalPixelsToRead, TotalPixelsRead: Integer;
+ Temp: Byte;
+ buf: array [0..3] of Byte; //1 pixel is max 32bit long
+ PixelRepeat: Boolean;
+ PixelsToRead, PixelCount: Integer;
+ begin
+ CacheSize := 0;
+ CachePos := 0;
+
+ TotalPixelsToRead := Header.Width * Header.Height;
+ TotalPixelsRead := 0;
+ LinePixelsRead := 0;
+
+ GetMem(Cache, CACHE_SIZE);
+ try
+ TmpData := ImageData;
+ inc(TmpData, Counter.Y.low * LineSize); //set line
+ if (Counter.X.dir < 0) then //if x flipped then
+ inc(TmpData, LineSize - PixelSize); //set last pixel
+
+ repeat
+ //read CommandByte
+ CachedRead(Temp, 1);
+ PixelRepeat := (Temp and $80) > 0;
+ PixelsToRead := (Temp and $7F) + 1;
+ inc(TotalPixelsRead, PixelsToRead);
+
+ if PixelRepeat then
+ CachedRead(buf[0], PixelSize);
+ while (PixelsToRead > 0) do begin
+ CheckLine;
+ PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF
+ while (PixelCount > 0) do begin
+ if not PixelRepeat then
+ CachedRead(buf[0], PixelSize);
+ PixelToBuffer(@buf[0], TmpData);
+ inc(LinePixelsRead);
+ dec(PixelsToRead);
+ dec(PixelCount);
+ end;
+ end;
+ until (TotalPixelsRead >= TotalPixelsToRead);
+ finally
+ FreeMem(Cache);
+ end;
+ end;
+
+ function IsGrayFormat: Boolean;
+ begin
+ result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY];
+ end;
+
+begin
+ result := false;
+
+ // reading header to test file and set cursor back to begin
+ StartPosition := aStream.Position;
+ aStream.Read(Header{%H-}, SizeOf(Header));
+
+ // no colormapped files
+ if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [
+ TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then
+ begin
+ try
+ if Header.ImageID <> 0 then // skip image ID
+ aStream.Position := aStream.Position + Header.ImageID;
+
+ tgaFormat := tfEmpty;
+ case Header.Bpp of
+ 8: if IsGrayFormat then case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfLuminance8ub1;
+ 8: tgaFormat := tfAlpha8ub1;
+ end;
+
+ 16: if IsGrayFormat then case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfLuminance16us1;
+ 8: tgaFormat := tfLuminance8Alpha8ub2;
+ end else case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfX1RGB5us1;
+ 1: tgaFormat := tfA1RGB5us1;
+ 4: tgaFormat := tfARGB4us1;
+ end;
+
+ 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfBGR8ub3;
+ end;
+
+ 32: if IsGrayFormat then case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfDepth32ui1;
+ end else case (Header.ImageDesc and $F) of
+ 0: tgaFormat := tfX2RGB10ui1;
+ 2: tgaFormat := tfA2RGB10ui1;
+ 8: tgaFormat := tfARGB8ui1;
+ end;
+ end;
+
+ if (tgaFormat = tfEmpty) then
+ raise EglBitmap.Create('LoadTga - unsupported format');
+
+ FormatDesc := TFormatDescriptor.Get(tgaFormat);
+ PixelSize := FormatDesc.GetSize(1, 1);
+ LineSize := FormatDesc.GetSize(Header.Width, 1);
+
+ GetMem(ImageData, LineSize * Header.Height);
+ try
+ //column direction
+ if ((Header.ImageDesc and (1 shl 4)) > 0) then begin
+ Counter.X.low := Header.Height-1;;
+ Counter.X.high := 0;
+ Counter.X.dir := -1;
+ end else begin
+ Counter.X.low := 0;
+ Counter.X.high := Header.Height-1;
+ Counter.X.dir := 1;
+ end;
+
+ // Row direction
+ if ((Header.ImageDesc and (1 shl 5)) > 0) then begin
+ Counter.Y.low := 0;
+ Counter.Y.high := Header.Height-1;
+ Counter.Y.dir := 1;
+ end else begin
+ Counter.Y.low := Header.Height-1;;
+ Counter.Y.high := 0;
+ Counter.Y.dir := -1;
+ end;
+
+ // Read Image
+ case Header.ImageType of
+ TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY:
+ ReadUncompressed;
+ TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY:
+ ReadCompressed;
+ end;
+
+ SetData(ImageData, tgaFormat, Header.Width, Header.Height);
+ result := true;
+ except
+ if Assigned(ImageData) then
+ FreeMem(ImageData);
+ raise;
+ end;
+ finally
+ aStream.Position := StartPosition;
+ end;
+ end
+ else aStream.Position := StartPosition;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveTGA(const aStream: TStream);
+var
+ Header: TTGAHeader;
+ Size: Integer;
+ FormatDesc: TFormatDescriptor;
+begin
+ if not (ftTGA in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ //prepare header
+ FormatDesc := TFormatDescriptor.Get(Format);
+ FillChar(Header{%H-}, SizeOf(Header), 0);
+ Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F;
+ Header.Bpp := FormatDesc.BitsPerPixel;
+ Header.Width := Width;
+ Header.Height := Height;
+ Header.ImageDesc := Header.ImageDesc or $20; //flip y
+ if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then
+ Header.ImageType := TGA_UNCOMPRESSED_GRAY
+ else
+ Header.ImageType := TGA_UNCOMPRESSED_RGB;
+ aStream.Write(Header, SizeOf(Header));
+
+ // write Data
+ Size := FormatDesc.GetSize(Dimension);
+ aStream.Write(Data^, Size);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//DDS/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+const
+ DDS_MAGIC: Cardinal = $20534444;
+
+ // DDS_header.dwFlags
+ DDSD_CAPS = $00000001;
+ DDSD_HEIGHT = $00000002;
+ DDSD_WIDTH = $00000004;
+ DDSD_PIXELFORMAT = $00001000;
+
+ // DDS_header.sPixelFormat.dwFlags
+ DDPF_ALPHAPIXELS = $00000001;
+ DDPF_ALPHA = $00000002;
+ DDPF_FOURCC = $00000004;
+ DDPF_RGB = $00000040;
+ DDPF_LUMINANCE = $00020000;
+
+ // DDS_header.sCaps.dwCaps1
+ DDSCAPS_TEXTURE = $00001000;
+
+ // DDS_header.sCaps.dwCaps2
+ DDSCAPS2_CUBEMAP = $00000200;
+
+ D3DFMT_DXT1 = $31545844;
+ D3DFMT_DXT3 = $33545844;
+ D3DFMT_DXT5 = $35545844;
+
+type
+ TDDSPixelFormat = packed record
+ dwSize: Cardinal;
+ dwFlags: Cardinal;
+ dwFourCC: Cardinal;
+ dwRGBBitCount: Cardinal;
+ dwRBitMask: Cardinal;
+ dwGBitMask: Cardinal;
+ dwBBitMask: Cardinal;
+ dwABitMask: Cardinal;
+ end;
+
+ TDDSCaps = packed record
+ dwCaps1: Cardinal;
+ dwCaps2: Cardinal;
+ dwDDSX: Cardinal;
+ dwReserved: Cardinal;
+ end;
+
+ TDDSHeader = packed record
+ dwSize: Cardinal;
+ dwFlags: Cardinal;
+ dwHeight: Cardinal;
+ dwWidth: Cardinal;
+ dwPitchOrLinearSize: Cardinal;
+ dwDepth: Cardinal;
+ dwMipMapCount: Cardinal;
+ dwReserved: array[0..10] of Cardinal;
+ PixelFormat: TDDSPixelFormat;
+ Caps: TDDSCaps;
+ dwReserved2: Cardinal;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.LoadDDS(const aStream: TStream): Boolean;
+var
+ Header: TDDSHeader;
+ Converter: TbmpBitfieldFormat;
+
+ function GetDDSFormat: TglBitmapFormat;
+ var
+ fd: TFormatDescriptor;
+ i: Integer;
+ Mask: TglBitmapRec4ul;
+ Range: TglBitmapRec4ui;
+ match: Boolean;
+ begin
+ result := tfEmpty;
+ with Header.PixelFormat do begin
+ // Compresses
+ if ((dwFlags and DDPF_FOURCC) > 0) then begin
+ case Header.PixelFormat.dwFourCC of
+ D3DFMT_DXT1: result := tfS3tcDtx1RGBA;
+ D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
+ D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
+ end;
+ end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin
+ // prepare masks
+ if ((dwFlags and DDPF_LUMINANCE) = 0) then begin
+ Mask.r := dwRBitMask;
+ Mask.g := dwGBitMask;
+ Mask.b := dwBBitMask;
+ end else begin
+ Mask.r := dwRBitMask;
+ Mask.g := dwRBitMask;
+ Mask.b := dwRBitMask;
+ end;
+ if (dwFlags and DDPF_ALPHAPIXELS > 0) then
+ Mask.a := dwABitMask
+ else
+ Mask.a := 0;;
+
+ //find matching format
+ fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount);
+ result := fd.Format;
+ if (result <> tfEmpty) then
+ exit;
+
+ //find format with same Range
+ for i := 0 to 3 do
+ Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1;
+ for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+ fd := TFormatDescriptor.Get(result);
+ match := true;
+ for i := 0 to 3 do
+ if (fd.Range.arr[i] <> Range.arr[i]) then begin
+ match := false;
+ break;
+ end;
+ if match then
+ break;
+ end;
+
+ //no format with same range found -> use default
+ if (result = tfEmpty) then begin
+ if (dwABitMask > 0) then
+ result := tfRGBA8ui1
+ else
+ result := tfRGB8ub3;
+ end;
+
+ Converter := TbmpBitfieldFormat.Create;
+ Converter.SetCustomValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask));
+ end;
+ end;
+ end;
+
+var
+ StreamPos: Int64;
+ x, y, LineSize, RowSize, Magic: Cardinal;
+ NewImage, TmpData, RowData, SrcData: System.PByte;
+ SourceMD, DestMD: Pointer;
+ Pixel: TglBitmapPixelData;
+ ddsFormat: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
+
+begin
+ result := false;
+ Converter := nil;
+ StreamPos := aStream.Position;
+
+ // Magic
+ aStream.Read(Magic{%H-}, sizeof(Magic));
+ if (Magic <> DDS_MAGIC) then begin
+ aStream.Position := StreamPos;
+ exit;
+ end;
+
+ //Header
+ aStream.Read(Header{%H-}, sizeof(Header));
+ if (Header.dwSize <> SizeOf(Header)) or
+ ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <>
+ (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then
+ begin
+ aStream.Position := StreamPos;
+ exit;
+ end;
+
+ if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
+ raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');
+
+ ddsFormat := GetDDSFormat;
+ try
+ if (ddsFormat = tfEmpty) then
+ raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
+
+ FormatDesc := TFormatDescriptor.Get(ddsFormat);
+ LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel);
+ GetMem(NewImage, Header.dwHeight * LineSize);
+ try
+ TmpData := NewImage;
+
+ //Converter needed
+ if Assigned(Converter) then begin
+ RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8);
+ GetMem(RowData, RowSize);
+ SourceMD := Converter.CreateMappingData;
+ DestMD := FormatDesc.CreateMappingData;
+ try
+ for y := 0 to Header.dwHeight-1 do begin
+ TmpData := NewImage;
+ inc(TmpData, y * LineSize);
+ SrcData := RowData;
+ aStream.Read(SrcData^, RowSize);
+ for x := 0 to Header.dwWidth-1 do begin
+ Converter.Unmap(SrcData, Pixel, SourceMD);
+ glBitmapConvertPixel(Pixel, Converter, FormatDesc);
+ FormatDesc.Map(Pixel, TmpData, DestMD);
+ end;
+ end;
+ finally
+ Converter.FreeMappingData(SourceMD);
+ FormatDesc.FreeMappingData(DestMD);
+ FreeMem(RowData);
+ end;
+ end else
+
+ // Compressed
+ if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin
+ RowSize := Header.dwPitchOrLinearSize div Header.dwWidth;
+ for Y := 0 to Header.dwHeight-1 do begin
+ aStream.Read(TmpData^, RowSize);
+ Inc(TmpData, LineSize);
+ end;
+ end else
+
+ // Uncompressed
+ if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin
+ RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3;
+ for Y := 0 to Header.dwHeight-1 do begin
+ aStream.Read(TmpData^, RowSize);
+ Inc(TmpData, LineSize);
+ end;
+ end else
+ raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
+
+ SetData(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight);
+ result := true;
+ except
+ if Assigned(NewImage) then
+ FreeMem(NewImage);
+ raise;
+ end;
+ finally
+ FreeAndNil(Converter);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveDDS(const aStream: TStream);
+var
+ Header: TDDSHeader;
+ FormatDesc: TFormatDescriptor;
+begin
+ if not (ftDDS in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ FormatDesc := TFormatDescriptor.Get(Format);
+
+ // Generell
+ FillChar(Header{%H-}, SizeOf(Header), 0);
+ Header.dwSize := SizeOf(Header);
+ Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT;
+
+ Header.dwWidth := Max(1, Width);
+ Header.dwHeight := Max(1, Height);
+
+ // Caps
+ Header.Caps.dwCaps1 := DDSCAPS_TEXTURE;
+
+ // Pixelformat
+ Header.PixelFormat.dwSize := sizeof(Header);
+ if (FormatDesc.IsCompressed) then begin
+ Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC;
+ case Format of
+ tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1;
+ tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3;
+ tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5;
+ end;
+ end else if not FormatDesc.HasColor and FormatDesc.HasAlpha then begin
+ Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA;
+ Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
+ Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
+ end else if FormatDesc.IsGrayscale then begin
+ Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE;
+ Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
+ Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r;
+ Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
+ end else begin
+ Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB;
+ Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel;
+ Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r;
+ Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g;
+ Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b;
+ Header.PixelFormat.dwABitMask := FormatDesc.Mask.a;
+ end;
+
+ if (FormatDesc.HasAlpha) then
+ Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS;
+
+ aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC));
+ aStream.Write(Header, SizeOf(Header));
+ aStream.Write(Data^, FormatDesc.GetSize(Dimension));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.FlipHorz: Boolean;
+var
+ fd: TglBitmapFormatDescriptor;
+ Col, RowSize, PixelSize: Integer;
+ pTempDest, pDest, pSource: PByte;
+begin
+ result := false;
+ fd := FormatDescriptor;
+ PixelSize := Ceil(fd.BytesPerPixel);
+ RowSize := fd.GetSize(Width, 1);
+ if Assigned(Data) and not fd.IsCompressed then begin
+ pSource := Data;
+ GetMem(pDest, RowSize);
+ try
+ pTempDest := pDest;
+ Inc(pTempDest, RowSize);
+ for Col := 0 to Width-1 do begin
+ dec(pTempDest, PixelSize); //dec before, because ptr is behind last byte of data
+ Move(pSource^, pTempDest^, PixelSize);
+ Inc(pSource, PixelSize);
+ end;
+ SetData(pDest, Format, Width);
+ result := true;
+ except
+ if Assigned(pDest) then
+ FreeMem(pDest);
+ raise;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.FlipVert: Boolean;
+var
+ fd: TglBitmapFormatDescriptor;
+ Row, RowSize, PixelSize: Integer;
+ TempDestData, DestData, SourceData: PByte;
+begin
+ result := false;
+ fd := FormatDescriptor;
+ PixelSize := Ceil(fd.BytesPerPixel);
+ RowSize := fd.GetSize(Width, 1);
+ if Assigned(Data) then begin
+ SourceData := Data;
+ GetMem(DestData, Height * RowSize);
+ try
+ TempDestData := DestData;
+ Inc(TempDestData, Width * (Height -1) * PixelSize);
+ for Row := 0 to Height -1 do begin
+ Move(SourceData^, TempDestData^, RowSize);
+ Dec(TempDestData, RowSize);
+ Inc(SourceData, RowSize);
+ end;
+ SetData(DestData, Format, Width, Height);
+ result := true;
+ except
+ if Assigned(DestData) then
+ FreeMem(DestData);
+ raise;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.LoadFromFile(const aFilename: String);
+var
+ fs: TFileStream;
+begin
+ if not FileExists(aFilename) then
+ raise EglBitmap.Create('file does not exist: ' + aFilename);
+ fs := TFileStream.Create(aFilename, fmOpenRead);
+ try
+ fs.Position := 0;
+ LoadFromStream(fs);
+ fFilename := aFilename;
+ finally
+ fs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.LoadFromStream(const aStream: TStream);
+begin
+ {$IFDEF GLB_SUPPORT_PNG_READ}
+ if not LoadPNG(aStream) then
+ {$ENDIF}
+ {$IFDEF GLB_SUPPORT_JPEG_READ}
+ if not LoadJPEG(aStream) then
+ {$ENDIF}
+ if not LoadDDS(aStream) then
+ if not LoadTGA(aStream) then
+ if not LoadBMP(aStream) then
+ if not LoadRAW(aStream) then
+ raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat;
+ const aFunc: TglBitmapFunction; const aArgs: Pointer);
+var
+ tmpData: PByte;
+ size: Integer;
+begin
+ size := TFormatDescriptor.Get(aFormat).GetSize(aSize);
+ GetMem(tmpData, size);
+ try
+ FillChar(tmpData^, size, #$FF);
+ SetData(tmpData, aFormat, aSize.X, aSize.Y);
+ except
+ if Assigned(tmpData) then
+ FreeMem(tmpData);
+ raise;
+ end;
+ Convert(Self, aFunc, false, aFormat, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar);
+var
+ rs: TResourceStream;
+begin
+ PrepareResType(aResource, aResType);
+ rs := TResourceStream.Create(aInstance, aResource, aResType);
+ try
+ LoadFromStream(rs);
+ finally
+ rs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+var
+ rs: TResourceStream;
+begin
+ rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
+ try
+ LoadFromStream(rs);
+ finally
+ rs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
+var
+ fs: TFileStream;
+begin
+ fs := TFileStream.Create(aFileName, fmCreate);
+ try
+ fs.Position := 0;
+ SaveToStream(fs, aFileType);
+ finally
+ fs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType);
+begin
+ case aFileType of
+ {$IFDEF GLB_SUPPORT_PNG_WRITE}
+ ftPNG: SavePNG(aStream);
+ {$ENDIF}
+ {$IFDEF GLB_SUPPORT_JPEG_WRITE}
+ ftJPEG: SaveJPEG(aStream);
+ {$ENDIF}
+ ftDDS: SaveDDS(aStream);
+ ftTGA: SaveTGA(aStream);
+ ftBMP: SaveBMP(aStream);
+ ftRAW: SaveRAW(aStream);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean;
+begin
+ result := Convert(Self, aFunc, aCreateTemp, Format, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
+ const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean;
+var
+ DestData, TmpData, SourceData: pByte;
+ TempHeight, TempWidth: Integer;
+ SourceFD, DestFD: TFormatDescriptor;
+ SourceMD, DestMD: Pointer;
+
+ FuncRec: TglBitmapFunctionRec;
+begin
+ Assert(Assigned(Data));
+ Assert(Assigned(aSource));
+ Assert(Assigned(aSource.Data));
+
+ result := false;
+ if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin
+ SourceFD := TFormatDescriptor.Get(aSource.Format);
+ DestFD := TFormatDescriptor.Get(aFormat);
+
+ if (SourceFD.IsCompressed) then
+ raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format);
+ if (DestFD.IsCompressed) then
+ raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format);
+
+ // inkompatible Formats so CreateTemp
+ if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then
+ aCreateTemp := true;
+
+ // Values
+ TempHeight := Max(1, aSource.Height);
+ TempWidth := Max(1, aSource.Width);
+
+ FuncRec.Sender := Self;
+ FuncRec.Args := aArgs;
+
+ TmpData := nil;
+ if aCreateTemp then begin
+ GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight));
+ DestData := TmpData;
+ end else
+ DestData := Data;
+
+ try
+ SourceFD.PreparePixel(FuncRec.Source);
+ DestFD.PreparePixel (FuncRec.Dest);
+
+ SourceMD := SourceFD.CreateMappingData;
+ DestMD := DestFD.CreateMappingData;
+
+ FuncRec.Size := aSource.Dimension;
+ FuncRec.Position.Fields := FuncRec.Size.Fields;
+
+ try
+ SourceData := aSource.Data;
+ FuncRec.Position.Y := 0;
+ while FuncRec.Position.Y < TempHeight do begin
+ FuncRec.Position.X := 0;
+ while FuncRec.Position.X < TempWidth do begin
+ SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
+ aFunc(FuncRec);
+ DestFD.Map(FuncRec.Dest, DestData, DestMD);
+ inc(FuncRec.Position.X);
+ end;
+ inc(FuncRec.Position.Y);
+ end;
+
+ // Updating Image or InternalFormat
+ if aCreateTemp then
+ SetData(TmpData, aFormat, aSource.Width, aSource.Height)
+ else if (aFormat <> fFormat) then
+ Format := aFormat;
+
+ result := true;
+ finally
+ SourceFD.FreeMappingData(SourceMD);
+ DestFD.FreeMappingData(DestMD);
+ end;
+ except
+ if aCreateTemp and Assigned(TmpData) then
+ FreeMem(TmpData);
+ raise;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.ConvertTo(const aFormat: TglBitmapFormat): Boolean;
+var
+ SourceFD, DestFD: TFormatDescriptor;
+ SourcePD, DestPD: TglBitmapPixelData;
+ ShiftData: TShiftData;
+
+ function DataIsIdentical: Boolean;
+ begin
+ result := SourceFD.MaskMatch(DestFD.Mask);
+ end;
+
+ function CanCopyDirect: Boolean;
+ begin
+ result :=
+ ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
+ ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
+ ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
+ ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
+ end;
+
+ function CanShift: Boolean;
+ begin
+ result :=
+ ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
+ ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
+ ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
+ ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
+ end;
+
+ function GetShift(aSource, aDest: Cardinal) : ShortInt;
+ begin
+ result := 0;
+ while (aSource > aDest) and (aSource > 0) do begin
+ inc(result);
+ aSource := aSource shr 1;
+ end;
+ end;
+
+begin
+ if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin
+ SourceFD := TFormatDescriptor.Get(Format);
+ DestFD := TFormatDescriptor.Get(aFormat);
+
+ if DataIsIdentical then begin
+ result := true;
+ Format := aFormat;
+ exit;
+ end;
+
+ SourceFD.PreparePixel(SourcePD);
+ DestFD.PreparePixel (DestPD);
+
+ if CanCopyDirect then
+ result := Convert(Self, glBitmapConvertCopyFunc, false, aFormat)
+ else if CanShift then begin
+ ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r);
+ ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g);
+ ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b);
+ ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a);
+ result := Convert(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData);
+ end else
+ result := Convert(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat);
+ end else
+ result := true;
+end;
+
+{$IFDEF GLB_SDL}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignToSurface(out aSurface: PSDL_Surface): Boolean;
+var
+ Row, RowSize: Integer;
+ SourceData, TmpData: PByte;
+ TempDepth: Integer;
+ FormatDesc: TFormatDescriptor;
+
+ function GetRowPointer(Row: Integer): pByte;
+ begin
+ result := aSurface.pixels;
+ Inc(result, Row * RowSize);
+ end;
+
+begin
+ result := false;
+
+ FormatDesc := TFormatDescriptor.Get(Format);
+ if FormatDesc.IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ if Assigned(Data) then begin
+ case Trunc(FormatDesc.PixelSize) of
+ 1: TempDepth := 8;
+ 2: TempDepth := 16;
+ 3: TempDepth := 24;
+ 4: TempDepth := 32;
+ else
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ end;
+
+ aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
+ FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
+ SourceData := Data;
+ RowSize := FormatDesc.GetSize(FileWidth, 1);
+
+ for Row := 0 to FileHeight-1 do begin
+ TmpData := GetRowPointer(Row);
+ if Assigned(TmpData) then begin
+ Move(SourceData^, TmpData^, RowSize);
+ inc(SourceData, RowSize);
+ end;
+ end;
+ result := true;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
+var
+ pSource, pData, pTempData: PByte;
+ Row, RowSize, TempWidth, TempHeight: Integer;
+ IntFormat: TglBitmapFormat;
+ fd: TFormatDescriptor;
+ Mask: TglBitmapMask;
+
+ function GetRowPointer(Row: Integer): pByte;
+ begin
+ result := aSurface^.pixels;
+ Inc(result, Row * RowSize);
+ end;
+
+begin
+ result := false;
+ if (Assigned(aSurface)) then begin
+ with aSurface^.format^ do begin
+ Mask.r := RMask;
+ Mask.g := GMask;
+ Mask.b := BMask;
+ Mask.a := AMask;
+ IntFormat := TFormatDescriptor.GetFromMask(Mask).Format;
+ if (IntFormat = tfEmpty) then
+ raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.');
+ end;
+
+ fd := TFormatDescriptor.Get(IntFormat);
+ TempWidth := aSurface^.w;
+ TempHeight := aSurface^.h;
+ RowSize := fd.GetSize(TempWidth, 1);
+ GetMem(pData, TempHeight * RowSize);
+ try
+ pTempData := pData;
+ for Row := 0 to TempHeight -1 do begin
+ pSource := GetRowPointer(Row);
+ if (Assigned(pSource)) then begin
+ Move(pSource^, pTempData^, RowSize);
+ Inc(pTempData, RowSize);
+ end;
+ end;
+ SetData(pData, IntFormat, TempWidth, TempHeight);
+ result := true;
+ except
+ if Assigned(pData) then
+ FreeMem(pData);
+ raise;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
+var
+ Row, Col, AlphaInterleave: Integer;
+ pSource, pDest: PByte;
+
+ function GetRowPointer(Row: Integer): pByte;
+ begin
+ result := aSurface.pixels;
+ Inc(result, Row * Width);
+ end;
+
+begin
+ result := false;
+ if Assigned(Data) then begin
+ if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin
+ aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0);
+
+ AlphaInterleave := 0;
+ case Format of
+ tfLuminance8Alpha8ub2:
+ AlphaInterleave := 1;
+ tfBGRA8ub4, tfRGBA8ub4:
+ AlphaInterleave := 3;
+ end;
+
+ pSource := Data;
+ for Row := 0 to Height -1 do begin
+ pDest := GetRowPointer(Row);
+ if Assigned(pDest) then begin
+ for Col := 0 to Width -1 do begin
+ Inc(pSource, AlphaInterleave);
+ pDest^ := pSource^;
+ Inc(pDest);
+ Inc(pSource);
+ end;
+ end;
+ end;
+ result := true;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+var
+ bmp: TglBitmap2D;
+begin
+ bmp := TglBitmap2D.Create;
+ try
+ bmp.AssignFromSurface(aSurface);
+ result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
+ finally
+ bmp.Free;
+ end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_DELPHI}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function CreateGrayPalette: HPALETTE;
+var
+ Idx: Integer;
+ Pal: PLogPalette;
+begin
+ GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
+
+ Pal.palVersion := $300;
+ Pal.palNumEntries := 256;
+
+ for Idx := 0 to Pal.palNumEntries - 1 do begin
+ Pal.palPalEntry[Idx].peRed := Idx;
+ Pal.palPalEntry[Idx].peGreen := Idx;
+ Pal.palPalEntry[Idx].peBlue := Idx;
+ Pal.palPalEntry[Idx].peFlags := 0;
+ end;
+ Result := CreatePalette(Pal^);
+ FreeMem(Pal);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignToBitmap(const aBitmap: TBitmap): Boolean;
+var
+ Row, RowSize: Integer;
+ pSource, pData: PByte;
+begin
+ result := false;
+ if Assigned(Data) then begin
+ if Assigned(aBitmap) then begin
+ aBitmap.Width := Width;
+ aBitmap.Height := Height;
+
+ case Format of
+ tfAlpha8ub1, tfLuminance8ub1: begin
+ aBitmap.PixelFormat := pf8bit;
+ aBitmap.Palette := CreateGrayPalette;
+ end;
+ tfRGB5A1us1:
+ aBitmap.PixelFormat := pf15bit;
+ tfR5G6B5us1:
+ aBitmap.PixelFormat := pf16bit;
+ tfRGB8ub3, tfBGR8ub3:
+ aBitmap.PixelFormat := pf24bit;
+ tfRGBA8ub4, tfBGRA8ub4:
+ aBitmap.PixelFormat := pf32bit;
+ else
+ raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.');
+ end;
+
+ RowSize := FormatDescriptor.GetSize(Width, 1);
+ pSource := Data;
+ for Row := 0 to Height-1 do begin
+ pData := aBitmap.Scanline[Row];
+ Move(pSource^, pData^, RowSize);
+ Inc(pSource, RowSize);
+ if (Format in [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A)
+ SwapRGB(pData, Width, Format = tfRGBA8ub4);
+ end;
+ result := true;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignFromBitmap(const aBitmap: TBitmap): Boolean;
+var
+ pSource, pData, pTempData: PByte;
+ Row, RowSize, TempWidth, TempHeight: Integer;
+ IntFormat: TglBitmapFormat;
+begin
+ result := false;
+
+ if (Assigned(aBitmap)) then begin
+ case aBitmap.PixelFormat of
+ pf8bit:
+ IntFormat := tfLuminance8ub1;
+ pf15bit:
+ IntFormat := tfRGB5A1us1;
+ pf16bit:
+ IntFormat := tfR5G6B5us1;
+ pf24bit:
+ IntFormat := tfBGR8ub3;
+ pf32bit:
+ IntFormat := tfBGRA8ub4;
+ else
+ raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.');
+ end;
+
+ TempWidth := aBitmap.Width;
+ TempHeight := aBitmap.Height;
+ RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1);
+ GetMem(pData, TempHeight * RowSize);
+ try
+ pTempData := pData;
+ for Row := 0 to TempHeight -1 do begin
+ pSource := aBitmap.Scanline[Row];
+ if (Assigned(pSource)) then begin
+ Move(pSource^, pTempData^, RowSize);
+ Inc(pTempData, RowSize);
+ end;
+ end;
+ SetData(pData, IntFormat, TempWidth, TempHeight);
+ result := true;
+ except
+ if Assigned(pData) then
+ FreeMem(pData);
+ raise;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
+var
+ Row, Col, AlphaInterleave: Integer;
+ pSource, pDest: PByte;
+begin
+ result := false;
+
+ if Assigned(Data) then begin
+ if (Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin
+ if Assigned(aBitmap) then begin
+ aBitmap.PixelFormat := pf8bit;
+ aBitmap.Palette := CreateGrayPalette;
+ aBitmap.Width := Width;
+ aBitmap.Height := Height;
+
+ case Format of
+ tfLuminance8Alpha8ub2:
+ AlphaInterleave := 1;
+ tfRGBA8ub4, tfBGRA8ub4:
+ AlphaInterleave := 3;
+ else
+ AlphaInterleave := 0;
+ end;
+
+ // Copy Data
+ pSource := Data;
+
+ for Row := 0 to Height -1 do begin
+ pDest := aBitmap.Scanline[Row];
+ if Assigned(pDest) then begin
+ for Col := 0 to Width -1 do begin
+ Inc(pSource, AlphaInterleave);
+ pDest^ := pSource^;
+ Inc(pDest);
+ Inc(pSource);
+ end;
+ end;
+ end;
+ result := true;
+ end;
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ data: TglBitmapData;
+begin
+ data := TglBitmapData.Create;
+ try
+ data.AssignFromBitmap(aBitmap);
+ result := AddAlphaFromDataObj(data, aFunc, aArgs);
+ finally
+ data.Free;
+ end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_LAZARUS}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+ rid: TRawImageDescription;
+ FormatDesc: TFormatDescriptor;
+begin
+ if not Assigned(Data) then
+ raise EglBitmap.Create('no pixel data assigned. load data before save');
+
+ result := false;
+ if not Assigned(aImage) or (Format = tfEmpty) then
+ exit;
+ FormatDesc := TFormatDescriptor.Get(Format);
+ if FormatDesc.IsCompressed then
+ exit;
+
+ FillChar(rid{%H-}, SizeOf(rid), 0);
+ if FormatDesc.IsGrayscale then
+ rid.Format := ricfGray
+ else
+ rid.Format := ricfRGBA;
+
+ rid.Width := Width;
+ rid.Height := Height;
+ rid.Depth := FormatDesc.BitsPerPixel;
+ rid.BitOrder := riboBitsInOrder;
+ rid.ByteOrder := riboLSBFirst;
+ rid.LineOrder := riloTopToBottom;
+ rid.LineEnd := rileTight;
+ rid.BitsPerPixel := FormatDesc.BitsPerPixel;
+ rid.RedPrec := CountSetBits(FormatDesc.Range.r);
+ rid.GreenPrec := CountSetBits(FormatDesc.Range.g);
+ rid.BluePrec := CountSetBits(FormatDesc.Range.b);
+ rid.AlphaPrec := CountSetBits(FormatDesc.Range.a);
+ rid.RedShift := FormatDesc.Shift.r;
+ rid.GreenShift := FormatDesc.Shift.g;
+ rid.BlueShift := FormatDesc.Shift.b;
+ rid.AlphaShift := FormatDesc.Shift.a;
+
+ rid.MaskBitsPerPixel := 0;
+ rid.PaletteColorCount := 0;
+
+ aImage.DataDescription := rid;
+ aImage.CreateData;
+
+ if not Assigned(aImage.PixelData) then
+ raise EglBitmap.Create('error while creating LazIntfImage');
+ Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension));
+
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+ f: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
+ ImageData: PByte;
+ ImageSize: Integer;
+ CanCopy: Boolean;
+ Mask: TglBitmapRec4ul;
+
+ procedure CopyConvert;
+ var
+ bfFormat: TbmpBitfieldFormat;
+ pSourceLine, pDestLine: PByte;
+ pSourceMD, pDestMD: Pointer;
+ Shift, Prec: TglBitmapRec4ub;
+ x, y: Integer;
+ pixel: TglBitmapPixelData;
+ begin
+ bfFormat := TbmpBitfieldFormat.Create;
+ with aImage.DataDescription do begin
+ Prec.r := RedPrec;
+ Prec.g := GreenPrec;
+ Prec.b := BluePrec;
+ Prec.a := AlphaPrec;
+ Shift.r := RedShift;
+ Shift.g := GreenShift;
+ Shift.b := BlueShift;
+ Shift.a := AlphaShift;
+ bfFormat.SetCustomValues(BitsPerPixel, Prec, Shift);
+ end;
+ pSourceMD := bfFormat.CreateMappingData;
+ pDestMD := FormatDesc.CreateMappingData;
+ try
+ for y := 0 to aImage.Height-1 do begin
+ pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine;
+ pDestLine := ImageData + y * Round(FormatDesc.BytesPerPixel * aImage.Width);
+ for x := 0 to aImage.Width-1 do begin
+ bfFormat.Unmap(pSourceLine, pixel, pSourceMD);
+ FormatDesc.Map(pixel, pDestLine, pDestMD);
+ end;
+ end;
+ finally
+ FormatDesc.FreeMappingData(pDestMD);
+ bfFormat.FreeMappingData(pSourceMD);
+ bfFormat.Free;
+ end;
+ end;
+
+begin
+ result := false;
+ if not Assigned(aImage) then
+ exit;
+
+ with aImage.DataDescription do begin
+ Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift;
+ Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift;
+ Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift;
+ Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift;
+ end;
+ FormatDesc := TFormatDescriptor.GetFromMask(Mask);
+ f := FormatDesc.Format;
+ if (f = tfEmpty) then
+ exit;
+
+ CanCopy :=
+ (FormatDesc.BitsPerPixel = aImage.DataDescription.Depth) and
+ (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth);
+
+ ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height);
+ ImageData := GetMem(ImageSize);
+ try
+ if CanCopy then
+ Move(aImage.PixelData^, ImageData^, ImageSize)
+ else
+ CopyConvert;
+ SetData(ImageData, f, aImage.Width, aImage.Height);
+ except
+ if Assigned(ImageData) then
+ FreeMem(ImageData);
+ raise;
+ end;
+
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+ rid: TRawImageDescription;
+ FormatDesc: TFormatDescriptor;
+ Pixel: TglBitmapPixelData;
+ x, y: Integer;
+ srcMD: Pointer;
+ src, dst: PByte;
+begin
+ result := false;
+ if not Assigned(aImage) or (Format = tfEmpty) then
+ exit;
+ FormatDesc := TFormatDescriptor.Get(Format);
+ if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
+ exit;
+
+ FillChar(rid{%H-}, SizeOf(rid), 0);
+ rid.Format := ricfGray;
+ rid.Width := Width;
+ rid.Height := Height;
+ rid.Depth := CountSetBits(FormatDesc.Range.a);
+ rid.BitOrder := riboBitsInOrder;
+ rid.ByteOrder := riboLSBFirst;
+ rid.LineOrder := riloTopToBottom;
+ rid.LineEnd := rileTight;
+ rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8);
+ rid.RedPrec := CountSetBits(FormatDesc.Range.a);
+ rid.GreenPrec := 0;
+ rid.BluePrec := 0;
+ rid.AlphaPrec := 0;
+ rid.RedShift := 0;
+ rid.GreenShift := 0;
+ rid.BlueShift := 0;
+ rid.AlphaShift := 0;
+
+ rid.MaskBitsPerPixel := 0;
+ rid.PaletteColorCount := 0;
+
+ aImage.DataDescription := rid;
+ aImage.CreateData;
+
+ srcMD := FormatDesc.CreateMappingData;
+ try
+ FormatDesc.PreparePixel(Pixel);
+ src := Data;
+ dst := aImage.PixelData;
+ for y := 0 to Height-1 do
+ for x := 0 to Width-1 do begin
+ FormatDesc.Unmap(src, Pixel, srcMD);
+ case rid.BitsPerPixel of
+ 8: begin
+ dst^ := Pixel.Data.a;
+ inc(dst);
+ end;
+ 16: begin
+ PWord(dst)^ := Pixel.Data.a;
+ inc(dst, 2);
+ end;
+ 24: begin
+ PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0];
+ PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1];
+ PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2];
+ inc(dst, 3);
+ end;
+ 32: begin
+ PCardinal(dst)^ := Pixel.Data.a;
+ inc(dst, 4);
+ end;
+ else
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ end;
+ end;
+ finally
+ FormatDesc.FreeMappingData(srcMD);
+ end;
+ result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ data: TglBitmapData;
+begin
+ data := TglBitmapData.Create;
+ try
+ data.AssignFromLazIntfImage(aImage);
+ result := AddAlphaFromDataObj(data, aFunc, aArgs);
+ finally
+ data.Free;
+ end;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar;
+ const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ rs: TResourceStream;
+begin
+ PrepareResType(aResource, aResType);
+ rs := TResourceStream.Create(aInstance, aResource, aResType);
+ try
+ result := AddAlphaFromStream(rs, aFunc, aArgs);
+ finally
+ rs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
+ const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ rs: TResourceStream;
+begin
+ rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
+ try
+ result := AddAlphaFromStream(rs, aFunc, aArgs);
+ finally
+ rs.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+begin
+ if TFormatDescriptor.Get(Format).IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ result := Convert(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ FS: TFileStream;
+begin
+ FS := TFileStream.Create(aFileName, fmOpenRead);
+ try
+ result := AddAlphaFromStream(FS, aFunc, aArgs);
+ finally
+ FS.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ data: TglBitmapData;
+begin
+ data := TglBitmapData.Create(aStream);
+ try
+ result := AddAlphaFromDataObj(data, aFunc, aArgs);
+ finally
+ data.Free;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+ DestData, DestData2, SourceData: pByte;
+ TempHeight, TempWidth: Integer;
+ SourceFD, DestFD: TFormatDescriptor;
+ SourceMD, DestMD, DestMD2: Pointer;
+
+ FuncRec: TglBitmapFunctionRec;
+begin
+ result := false;
+
+ Assert(Assigned(Data));
+ Assert(Assigned(aDataObj));
+ Assert(Assigned(aDataObj.Data));
+
+ if ((aDataObj.Width = Width) and (aDataObj.Height = Height)) then begin
+ result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha);
+
+ SourceFD := TFormatDescriptor.Get(aDataObj.Format);
+ DestFD := TFormatDescriptor.Get(Format);
+
+ if not Assigned(aFunc) then begin
+ aFunc := glBitmapAlphaFunc;
+ FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha);
+ end else
+ FuncRec.Args := aArgs;
+
+ // Values
+ TempWidth := aDataObj.Width;
+ TempHeight := aDataObj.Height;
+ if (TempWidth <= 0) or (TempHeight <= 0) then
+ exit;
+
+ FuncRec.Sender := Self;
+ FuncRec.Size := Dimension;
+ FuncRec.Position.Fields := FuncRec.Size.Fields;
+
+ DestData := Data;
+ DestData2 := Data;
+ SourceData := aDataObj.Data;
+
+ // Mapping
+ SourceFD.PreparePixel(FuncRec.Source);
+ DestFD.PreparePixel (FuncRec.Dest);
+
+ SourceMD := SourceFD.CreateMappingData;
+ DestMD := DestFD.CreateMappingData;
+ DestMD2 := DestFD.CreateMappingData;
+ try
+ FuncRec.Position.Y := 0;
+ while FuncRec.Position.Y < TempHeight do begin
+ FuncRec.Position.X := 0;
+ while FuncRec.Position.X < TempWidth do begin
+ SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
+ DestFD.Unmap (DestData, FuncRec.Dest, DestMD);
+ aFunc(FuncRec);
+ DestFD.Map(FuncRec.Dest, DestData2, DestMD2);
+ inc(FuncRec.Position.X);
+ end;
+ inc(FuncRec.Position.Y);
+ end;
+ finally
+ SourceFD.FreeMappingData(SourceMD);
+ DestFD.FreeMappingData(DestMD);
+ DestFD.FreeMappingData(DestMD2);
+ end;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean;
+begin
+ result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean;
+var
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+ result := AddAlphaFromColorKeyFloat(
+ aRed / PixelData.Range.r,
+ aGreen / PixelData.Range.g,
+ aBlue / PixelData.Range.b,
+ aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b)));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean;
+var
+ values: array[0..2] of Single;
+ tmp: Cardinal;
+ i: Integer;
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+ with PixelData do begin
+ values[0] := aRed;
+ values[1] := aGreen;
+ values[2] := aBlue;
+
+ for i := 0 to 2 do begin
+ tmp := Trunc(Range.arr[i] * aDeviation);
+ Data.arr[i] := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp));
+ Range.arr[i] := Max(0, Trunc(Range.arr[i] * values[i] - tmp));
+ end;
+ Data.a := 0;
+ Range.a := 0;
+ end;
+ result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromValue(const aAlpha: Byte): Boolean;
+begin
+ result := AddAlphaFromValueFloat(aAlpha / $FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
+var
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+ result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
+var
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+ with PixelData do
+ Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
+ result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.RemoveAlpha: Boolean;
+var
+ FormatDesc: TFormatDescriptor;
+begin
+ result := false;
+ FormatDesc := TFormatDescriptor.Get(Format);
+ if Assigned(Data) then begin
+ if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+ result := ConvertTo(FormatDesc.WithoutAlpha);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.FillWithColor(const aRed, aGreen, aBlue: Byte;
+ const aAlpha: Byte);
+begin
+ FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal);
+var
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+ FillWithColorFloat(
+ aRed / PixelData.Range.r,
+ aGreen / PixelData.Range.g,
+ aBlue / PixelData.Range.b,
+ aAlpha / PixelData.Range.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single);
+var
+ PixelData: TglBitmapPixelData;
+begin
+ TFormatDescriptor.Get(Format).PreparePixel(PixelData);
+ with PixelData do begin
+ Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed)));
+ Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen)));
+ Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue)));
+ Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha)));
+ end;
+ Convert(glBitmapFillWithColorFunc, false, @PixelData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer);
+begin
+ if (Data <> aData) then begin
+ if (Assigned(Data)) then
+ FreeMem(Data);
+ fData := aData;
+ end;
+
+ if Assigned(fData) then begin
+ FillChar(fDimension, SizeOf(fDimension), 0);
+ if aWidth <> -1 then begin
+ fDimension.Fields := fDimension.Fields + [ffX];
+ fDimension.X := aWidth;
+ end;
+
+ if aHeight <> -1 then begin
+ fDimension.Fields := fDimension.Fields + [ffY];
+ fDimension.Y := aHeight;
+ end;
+
+ fFormat := aFormat;
+ end else
+ fFormat := tfEmpty;
+
+ UpdateScanlines;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmapData.Clone: TglBitmapData;
+var
+ Temp: TglBitmapData;
+ TempPtr: PByte;
+ Size: Integer;
+begin
+ result := nil;
+ Temp := (ClassType.Create as TglBitmapData);
+ try
+ // copy texture data if assigned
+ if Assigned(Data) then begin
+ Size := TFormatDescriptor.Get(Format).GetSize(fDimension);
+ GetMem(TempPtr, Size);
+ try
+ Move(Data^, TempPtr^, Size);
+ Temp.SetData(TempPtr, Format, Width, Height);
+ except
+ if Assigned(TempPtr) then
+ FreeMem(TempPtr);
+ raise;
+ end;
+ end else begin
+ TempPtr := nil;
+ Temp.SetData(TempPtr, Format, Width, Height);
+ end;
+
+ // copy properties
+ Temp.fFormat := Format;
+ result := Temp;
+ except
+ FreeAndNil(Temp);
+ raise;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
+var
+ mask: PtrInt;
+begin
+ mask :=
+ (Byte(aRed) and 1) or
+ ((Byte(aGreen) and 1) shl 1) or
+ ((Byte(aBlue) and 1) shl 2) or
+ ((Byte(aAlpha) and 1) shl 3);
+ if (mask > 0) then
+ Convert(glBitmapInvertFunc, false, {%H-}Pointer(mask));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+ TMatrixItem = record
+ X, Y: Integer;
+ W: Single;
+ end;
+
+ PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec;
+ TglBitmapToNormalMapRec = Record
+ Scale: Single;
+ Heights: array of Single;
+ MatrixU : array of TMatrixItem;
+ MatrixV : array of TMatrixItem;
+ end;
+
+const
+ ONE_OVER_255 = 1 / 255;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec);
+var
+ Val: Single;
+begin
+ with FuncRec do begin
+ Val :=
+ Source.Data.r * LUMINANCE_WEIGHT_R +
+ Source.Data.g * LUMINANCE_WEIGHT_G +
+ Source.Data.b * LUMINANCE_WEIGHT_B;
+ PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255;
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+begin
+ with FuncRec do
+ PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec);
+type
+ TVec = Array[0..2] of Single;
+var
+ Idx: Integer;
+ du, dv: Double;
+ Len: Single;
+ Vec: TVec;
+
+ function GetHeight(X, Y: Integer): Single;
+ begin
+ with FuncRec do begin
+ X := Max(0, Min(Size.X -1, X));
+ Y := Max(0, Min(Size.Y -1, Y));
+ result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X];
+ end;
+ end;
+
+begin
+ with FuncRec do begin
+ with PglBitmapToNormalMapRec(Args)^ do begin
+ du := 0;
+ for Idx := Low(MatrixU) to High(MatrixU) do
+ du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W;
+
+ dv := 0;
+ for Idx := Low(MatrixU) to High(MatrixU) do
+ dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W;
+
+ Vec[0] := -du * Scale;
+ Vec[1] := -dv * Scale;
+ Vec[2] := 1;
+ end;
+
+ // Normalize
+ Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
+ if Len <> 0 then begin
+ Vec[0] := Vec[0] * Len;
+ Vec[1] := Vec[1] * Len;
+ Vec[2] := Vec[2] * Len;
+ end;
+
+ // Farbe zuweisem
+ Dest.Data.r := Trunc((Vec[0] + 1) * 127.5);
+ Dest.Data.g := Trunc((Vec[1] + 1) * 127.5);
+ Dest.Data.b := Trunc((Vec[2] + 1) * 127.5);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapData.GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean);
+var
+ Rec: TglBitmapToNormalMapRec;
+
+ procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single);
+ begin
+ if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin
+ Matrix[Index].X := X;
+ Matrix[Index].Y := Y;
+ Matrix[Index].W := W;
+ end;
+ end;
+
+begin
+ if TFormatDescriptor.Get(Format).IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(Format);
+
+ if aScale > 100 then
+ Rec.Scale := 100
+ else if aScale < -100 then
+ Rec.Scale := -100
+ else
+ Rec.Scale := aScale;
+
+ SetLength(Rec.Heights, Width * Height);
+ try
+ case aFunc of
+ nm4Samples: begin
+ SetLength(Rec.MatrixU, 2);
+ SetEntry(Rec.MatrixU, 0, -1, 0, -0.5);
+ SetEntry(Rec.MatrixU, 1, 1, 0, 0.5);
+
+ SetLength(Rec.MatrixV, 2);
+ SetEntry(Rec.MatrixV, 0, 0, 1, 0.5);
+ SetEntry(Rec.MatrixV, 1, 0, -1, -0.5);
+ end;
+
+ nmSobel: begin
+ SetLength(Rec.MatrixU, 6);
+ SetEntry(Rec.MatrixU, 0, -1, 1, -1.0);
+ SetEntry(Rec.MatrixU, 1, -1, 0, -2.0);
+ SetEntry(Rec.MatrixU, 2, -1, -1, -1.0);
+ SetEntry(Rec.MatrixU, 3, 1, 1, 1.0);
+ SetEntry(Rec.MatrixU, 4, 1, 0, 2.0);
+ SetEntry(Rec.MatrixU, 5, 1, -1, 1.0);
+
+ SetLength(Rec.MatrixV, 6);
+ SetEntry(Rec.MatrixV, 0, -1, 1, 1.0);
+ SetEntry(Rec.MatrixV, 1, 0, 1, 2.0);
+ SetEntry(Rec.MatrixV, 2, 1, 1, 1.0);
+ SetEntry(Rec.MatrixV, 3, -1, -1, -1.0);
+ SetEntry(Rec.MatrixV, 4, 0, -1, -2.0);
+ SetEntry(Rec.MatrixV, 5, 1, -1, -1.0);
+ end;
+
+ nm3x3: begin
+ SetLength(Rec.MatrixU, 6);
+ SetEntry(Rec.MatrixU, 0, -1, 1, -1/6);
+ SetEntry(Rec.MatrixU, 1, -1, 0, -1/6);
+ SetEntry(Rec.MatrixU, 2, -1, -1, -1/6);
+ SetEntry(Rec.MatrixU, 3, 1, 1, 1/6);
+ SetEntry(Rec.MatrixU, 4, 1, 0, 1/6);
+ SetEntry(Rec.MatrixU, 5, 1, -1, 1/6);
+
+ SetLength(Rec.MatrixV, 6);
+ SetEntry(Rec.MatrixV, 0, -1, 1, 1/6);
+ SetEntry(Rec.MatrixV, 1, 0, 1, 1/6);
+ SetEntry(Rec.MatrixV, 2, 1, 1, 1/6);
+ SetEntry(Rec.MatrixV, 3, -1, -1, -1/6);
+ SetEntry(Rec.MatrixV, 4, 0, -1, -1/6);
+ SetEntry(Rec.MatrixV, 5, 1, -1, -1/6);
+ end;
+
+ nm5x5: begin
+ SetLength(Rec.MatrixU, 20);
+ SetEntry(Rec.MatrixU, 0, -2, 2, -1 / 16);
+ SetEntry(Rec.MatrixU, 1, -1, 2, -1 / 10);
+ SetEntry(Rec.MatrixU, 2, 1, 2, 1 / 10);
+ SetEntry(Rec.MatrixU, 3, 2, 2, 1 / 16);
+ SetEntry(Rec.MatrixU, 4, -2, 1, -1 / 10);
+ SetEntry(Rec.MatrixU, 5, -1, 1, -1 / 8);
+ SetEntry(Rec.MatrixU, 6, 1, 1, 1 / 8);
+ SetEntry(Rec.MatrixU, 7, 2, 1, 1 / 10);
+ SetEntry(Rec.MatrixU, 8, -2, 0, -1 / 2.8);
+ SetEntry(Rec.MatrixU, 9, -1, 0, -0.5);
+ SetEntry(Rec.MatrixU, 10, 1, 0, 0.5);
+ SetEntry(Rec.MatrixU, 11, 2, 0, 1 / 2.8);
+ SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10);
+ SetEntry(Rec.MatrixU, 13, -1, -1, -1 / 8);
+ SetEntry(Rec.MatrixU, 14, 1, -1, 1 / 8);
+ SetEntry(Rec.MatrixU, 15, 2, -1, 1 / 10);
+ SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16);
+ SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10);
+ SetEntry(Rec.MatrixU, 18, 1, -2, 1 / 10);
+ SetEntry(Rec.MatrixU, 19, 2, -2, 1 / 16);
+
+ SetLength(Rec.MatrixV, 20);
+ SetEntry(Rec.MatrixV, 0, -2, 2, 1 / 16);
+ SetEntry(Rec.MatrixV, 1, -1, 2, 1 / 10);
+ SetEntry(Rec.MatrixV, 2, 0, 2, 0.25);
+ SetEntry(Rec.MatrixV, 3, 1, 2, 1 / 10);
+ SetEntry(Rec.MatrixV, 4, 2, 2, 1 / 16);
+ SetEntry(Rec.MatrixV, 5, -2, 1, 1 / 10);
+ SetEntry(Rec.MatrixV, 6, -1, 1, 1 / 8);
+ SetEntry(Rec.MatrixV, 7, 0, 1, 0.5);
+ SetEntry(Rec.MatrixV, 8, 1, 1, 1 / 8);
+ SetEntry(Rec.MatrixV, 9, 2, 1, 1 / 16);
+ SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16);
+ SetEntry(Rec.MatrixV, 11, -1, -1, -1 / 8);
+ SetEntry(Rec.MatrixV, 12, 0, -1, -0.5);
+ SetEntry(Rec.MatrixV, 13, 1, -1, -1 / 8);
+ SetEntry(Rec.MatrixV, 14, 2, -1, -1 / 10);
+ SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16);
+ SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10);
+ SetEntry(Rec.MatrixV, 17, 0, -2, -0.25);
+ SetEntry(Rec.MatrixV, 18, 1, -2, -1 / 10);
+ SetEntry(Rec.MatrixV, 19, 2, -2, -1 / 16);
+ end;
+ end;
+
+ // Daten Sammeln
+ if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then
+ Convert(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec)
+ else
+ Convert(glBitmapToNormalMapPrepareFunc, false, @Rec);
+ Convert(glBitmapToNormalMapFunc, false, @Rec);
+ finally
+ SetLength(Rec.Heights, 0);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create;
+begin
+ inherited Create;
+ fFormat := glBitmapDefaultFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aFileName: String);
+begin
+ Create;
+ LoadFromFile(aFileName);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aStream: TStream);
+begin
+ Create;
+ LoadFromStream(aStream);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte);
+var
+ ImageSize: Integer;
+begin
+ Create;
+ if not Assigned(aData) then begin
+ ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize);
+ GetMem(aData, ImageSize);
+ try
+ FillChar(aData^, ImageSize, #$FF);
+ SetData(aData, aFormat, aSize.X, aSize.Y);
+ except
+ if Assigned(aData) then
+ FreeMem(aData);
+ raise;
+ end;
+ end else begin
+ SetData(aData, aFormat, aSize.X, aSize.Y);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer);
+begin
+ Create;
+ LoadFromFunc(aSize, aFormat, aFunc, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar);
+begin
+ Create;
+ LoadFromResource(aInstance, aResource, aResType);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmapData.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+begin
+ Create;
+ LoadFromResourceID(aInstance, aResourceID, aResType);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglBitmapData.Destroy;
+begin
+ SetData(nil, tfEmpty);
+ inherited Destroy;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - PROTECTED///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetWidth: Integer;
+begin
+ if (ffX in fDimension.Fields) then
+ result := fDimension.X
+ else
+ result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetHeight: Integer;
+begin
+ if (ffY in fDimension.Fields) then
+ result := fDimension.Y
+ else
+ result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomData(const aValue: Pointer);
+begin
+ if fCustomData = aValue then
+ exit;
+ fCustomData := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomName(const aValue: String);
+begin
+ if fCustomName = aValue then
+ exit;
+ fCustomName := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomNameW(const aValue: WideString);
+begin
+ if fCustomNameW = aValue then
+ exit;
+ fCustomNameW := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
+begin
+ if fDeleteTextureOnFree = aValue then
+ exit;
+ fDeleteTextureOnFree := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetID(const aValue: Cardinal);
+begin
+ if fID = aValue then
+ exit;
+ fID := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
+begin
+ if fMipMap = aValue then
+ exit;
+ fMipMap := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetTarget(const aValue: Cardinal);
+begin
+ if fTarget = aValue then
+ exit;
+ fTarget := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetAnisotropic(const aValue: Integer);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)}
+var
+ MaxAnisotropic: Integer;
+{$IFEND}
+begin
+ fAnisotropic := aValue;
+ if (ID > 0) then begin
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)}
+ if GL_EXT_texture_filter_anisotropic then begin
+ if fAnisotropic > 0 then begin
+ Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
+ glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic);
+ if aValue > MaxAnisotropic then
+ fAnisotropic := MaxAnisotropic;
+ glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
+ end;
+ end else begin
+ fAnisotropic := 0;
+ end;
+{$ELSE}
+ fAnisotropic := 0;
+{$IFEND}
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.CreateID;
+begin
+ if (ID <> 0) then
+ glDeleteTextures(1, @fID);
+ glGenTextures(1, @fID);
+ Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF});
+begin
+ // Set Up Parameters
+ SetWrap(fWrapS, fWrapT, fWrapR);
+ SetFilter(fFilterMin, fFilterMag);
+ SetAnisotropic(fAnisotropic);
+
+{$IFNDEF OPENGL_ES}
+ SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
+ if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+ SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
+{$ENDIF}
+
+{$IFNDEF OPENGL_ES}
+ // Mip Maps Generation Mode
+ aBuildWithGlu := false;
+ if (MipMap = mmMipmap) then begin
+ if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
+ glTexParameteri(Target, GL_GENERATE_MIPMAP, GLint(GL_TRUE))
+ else
+ aBuildWithGlu := true;
+ end else if (MipMap = mmMipmapGlu) then
+ aBuildWithGlu := true;
+{$ELSE}
+ if (MipMap = mmMipmap) then
+ glGenerateMipmap(Target);
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - PUBLIC//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.AfterConstruction;
+begin
+ inherited AfterConstruction;
+
+ fID := 0;
+ fTarget := 0;
+{$IFNDEF OPENGL_ES}
+ fIsResident := false;
+{$ENDIF}
+
+ fMipMap := glBitmapDefaultMipmap;
+ fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree;
+
+ glBitmapGetDefaultFilter (fFilterMin, fFilterMag);
+ glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
+{$IFNDEF OPENGL_ES}
+ glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.BeforeDestruction;
+begin
+ if (fID > 0) and fDeleteTextureOnFree then
+ glDeleteTextures(1, @fID);
+ inherited BeforeDestruction;
+end;
+
+{$IFNDEF OPENGL_ES}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
+begin
+ fBorderColor[0] := aRed;
+ fBorderColor[1] := aGreen;
+ fBorderColor[2] := aBlue;
+ fBorderColor[3] := aAlpha;
+ if (ID > 0) then begin
+ Bind(false);
+ glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]);
+ end;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
+begin
+ //check MIN filter
+ case aMin of
+ GL_NEAREST:
+ fFilterMin := GL_NEAREST;
+ GL_LINEAR:
+ fFilterMin := GL_LINEAR;
+ GL_NEAREST_MIPMAP_NEAREST:
+ fFilterMin := GL_NEAREST_MIPMAP_NEAREST;
+ GL_LINEAR_MIPMAP_NEAREST:
+ fFilterMin := GL_LINEAR_MIPMAP_NEAREST;
+ GL_NEAREST_MIPMAP_LINEAR:
+ fFilterMin := GL_NEAREST_MIPMAP_LINEAR;
+ GL_LINEAR_MIPMAP_LINEAR:
+ fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
+ else
+ raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
+ end;
+
+ //check MAG filter
+ case aMag of
+ GL_NEAREST:
+ fFilterMag := GL_NEAREST;
+ GL_LINEAR:
+ fFilterMag := GL_LINEAR;
+ else
+ raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
+ end;
+
+ //apply filter
+ if (ID > 0) then begin
+ Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
+ glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag);
+
+ if (MipMap = mmNone) {$IFNDEF OPENGL_ES}or (Target = GL_TEXTURE_RECTANGLE){$ENDIF} then begin
+ case fFilterMin of
+ GL_NEAREST, GL_LINEAR:
+ glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
+ GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR:
+ glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR:
+ glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ end;
+ end else
+ glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);
+
+ procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
+ begin
+ case aValue of
+{$IFNDEF OPENGL_ES}
+ GL_CLAMP:
+ aTarget := GL_CLAMP;
+{$ENDIF}
+
+ GL_REPEAT:
+ aTarget := GL_REPEAT;
+
+ GL_CLAMP_TO_EDGE: begin
+{$IFNDEF OPENGL_ES}
+ if not GL_VERSION_1_2 and not GL_EXT_texture_edge_clamp then
+ aTarget := GL_CLAMP
+ else
+{$ENDIF}
+ aTarget := GL_CLAMP_TO_EDGE;
+ end;
+
+{$IFNDEF OPENGL_ES}
+ GL_CLAMP_TO_BORDER: begin
+ if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then
+ aTarget := GL_CLAMP_TO_BORDER
+ else
+ aTarget := GL_CLAMP;
+ end;
+{$ENDIF}
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+ GL_MIRRORED_REPEAT: begin
+ {$IFNDEF OPENGL_ES}
+ if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
+ {$ELSE}
+ if GL_VERSION_2_0 then
+ {$ENDIF}
+ aTarget := GL_MIRRORED_REPEAT
+ else
+ raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
+ end;
+{$IFEND}
+ else
+ raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
+ end;
+ end;
+
+begin
+ CheckAndSetWrap(S, fWrapS);
+ CheckAndSetWrap(T, fWrapT);
+ CheckAndSetWrap(R, fWrapR);
+
+ if (ID > 0) then begin
+ Bind({$IFNDEF OPENGL_ES}false{$ENDIF});
+ glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS);
+ glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ {$IFDEF OPENGL_ES} if GL_VERSION_3_0 then{$ENDIF}
+ glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR);
+{$IFEND}
+ end;
+end;
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
+
+ procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
+ begin
+ if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or
+ (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then
+ fSwizzle[aIndex] := aValue
+ else
+ raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
+ end;
+
+begin
+{$IFNDEF OPENGL_ES}
+ if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+ raise EglBitmapNotSupported.Create('texture swizzle is not supported');
+{$ELSE}
+ if not GL_VERSION_3_0 then
+ raise EglBitmapNotSupported.Create('texture swizzle is not supported');
+{$ENDIF}
+ CheckAndSetValue(r, 0);
+ CheckAndSetValue(g, 1);
+ CheckAndSetValue(b, 2);
+ CheckAndSetValue(a, 3);
+
+ if (ID > 0) then begin
+ Bind(false);
+{$IFNDEF OPENGL_ES}
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0]));
+{$ELSE}
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_R, PGLint(@fSwizzle[0]));
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_G, PGLint(@fSwizzle[1]));
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_B, PGLint(@fSwizzle[2]));
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_A, PGLint(@fSwizzle[3]));
+{$ENDIF}
+ end;
+end;
+{$IFEND}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.Bind({$IFNDEF OPENGL_ES}const aEnableTextureUnit: Boolean{$ENDIF});
+begin
+{$IFNDEF OPENGL_ES}
+ if aEnableTextureUnit then
+ glEnable(Target);
+{$ENDIF}
+ if (ID > 0) then
+ glBindTexture(Target, ID);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.Unbind({$IFNDEF OPENGL_ES}const aDisableTextureUnit: Boolean{$ENDIF});
+begin
+{$IFNDEF OPENGL_ES}
+ if aDisableTextureUnit then
+ glDisable(Target);
+{$ENDIF}
+ glBindTexture(Target, 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
+var
+ w, h: Integer;
+begin
+ w := aDataObj.Width;
+ h := aDataObj.Height;
+ fDimension.Fields := [];
+ if (w > 0) then
+ fDimension.Fields := fDimension.Fields + [ffX];
+ if (h > 0) then
+ fDimension.Fields := fDimension.Fields + [ffY];
+ fDimension.X := w;
+ fDimension.Y := h;
+end;
+
+{$IFNDEF OPENGL_ES}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.DownloadData(const aDataObj: TglBitmapData): Boolean;
+var
+ Temp: PByte;
+ TempWidth, TempHeight: Integer;
+ TempIntFormat: GLint;
+ IntFormat: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
+begin
+ result := false;
+ Bind;
+
+ // Request Data
+ glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_WIDTH, @TempWidth);
+ glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT, @TempHeight);
+ glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat);
+
+ FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor);
+ IntFormat := FormatDesc.Format;
+
+ // Getting data from OpenGL
+ FormatDesc := TFormatDescriptor.Get(IntFormat);
+ GetMem(Temp, FormatDesc.GetSize(TempWidth, TempHeight));
+ try
+ if FormatDesc.IsCompressed then begin
+ if not Assigned(glGetCompressedTexImage) then
+ raise EglBitmap.Create('compressed formats not supported by video adapter');
+ glGetCompressedTexImage(Target, 0, Temp)
+ end else
+ glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
+ aDataObj.SetData(Temp, IntFormat, TempWidth, TempHeight);
+ result := true;
+ except
+ if Assigned(Temp) then
+ FreeMem(Temp);
+ raise;
+ end;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create;
+begin
+ if (ClassType = TglBitmap) then
+ raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
+ inherited Create;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aData: TglBitmapData);
+begin
+ Create;
+ UploadData(aData);
+end;
+
+{$IFNDEF OPENGL_ES}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap1D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
+var
+ fd: TglBitmapFormatDescriptor;
+begin
+ // Upload data
+ fd := aDataObj.FormatDescriptor;
+ if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then
+ raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data');
+
+ if fd.IsCompressed then begin
+ if not Assigned(glCompressedTexImage1D) then
+ raise EglBitmap.Create('compressed formats not supported by video adapter');
+ glCompressedTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.GetSize(aDataObj.Width, 1), aDataObj.Data)
+ end else if aBuildWithGlu then
+ gluBuild1DMipmaps(Target, fd.glInternalFormat, aDataObj.Width, fd.glFormat, fd.glDataFormat, aDataObj.Data)
+ else
+ glTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.AfterConstruction;
+begin
+ inherited;
+ Target := GL_TEXTURE_1D;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
+var
+ BuildWithGlu, TexRec: Boolean;
+ TexSize: Integer;
+begin
+ if not Assigned(aDataObj) then
+ exit;
+
+ // Check Texture Size
+ if (aCheckSize) then begin
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
+
+ if (aDataObj.Width > TexSize) then
+ raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+
+ TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
+ (Target = GL_TEXTURE_RECTANGLE);
+ if not (IsPowerOfTwo(aDataObj.Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+ end;
+
+ if (fID = 0) then
+ CreateID;
+ SetupParameters(BuildWithGlu);
+ UploadDataIntern(aDataObj, BuildWithGlu);
+ glAreTexturesResident(1, @fID, @fIsResident);
+
+ inherited UploadData(aDataObj, aCheckSize);
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF});
+var
+ fd: TglBitmapFormatDescriptor;
+begin
+ fd := aDataObj.FormatDescriptor;
+ if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then
+ raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data');
+
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+ if fd.IsCompressed then begin
+ if not Assigned(glCompressedTexImage2D) then
+ raise EglBitmap.Create('compressed formats not supported by video adapter');
+ glCompressedTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.GetSize(fDimension), aDataObj.Data)
+{$IFNDEF OPENGL_ES}
+ end else if aBuildWithGlu then begin
+ gluBuild2DMipmaps(aTarget, fd.ChannelCount, aDataObj.Width, aDataObj.Height, fd.glFormat, fd.glDataFormat, aDataObj.Data)
+{$ENDIF}
+ end else begin
+ glTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.AfterConstruction;
+begin
+ inherited;
+ Target := GL_TEXTURE_2D;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
+var
+ {$IFNDEF OPENGL_ES}
+ BuildWithGlu, TexRec: Boolean;
+ {$ENDIF}
+ PotTex: Boolean;
+ TexSize: Integer;
+begin
+ if not Assigned(aDataObj) then
+ exit;
+
+ // Check Texture Size
+ if (aCheckSize) then begin
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
+
+ if ((aDataObj.Width > TexSize) or (aDataObj.Height > TexSize)) then
+ raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+
+ PotTex := IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height);
+{$IF NOT DEFINED(OPENGL_ES)}
+ TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
+ if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+{$ELSEIF DEFINED(OPENGL_ES_EXT)}
+ if not PotTex and not GL_OES_texture_npot then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+{$ELSE}
+ if not PotTex then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+{$IFEND}
+ end;
+
+ if (fID = 0) then
+ CreateID;
+ SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF});
+ UploadDataIntern(aDataObj, Target{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF});
+{$IFNDEF OPENGL_ES}
+ glAreTexturesResident(1, @fID, @fIsResident);
+{$ENDIF}
+
+ inherited UploadData(aDataObj, aCheckSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
+var
+ Temp: pByte;
+ Size, w, h: Integer;
+ FormatDesc: TFormatDescriptor;
+begin
+ FormatDesc := TFormatDescriptor.Get(aFormat);
+ if FormatDesc.IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(aFormat);
+
+ w := aRight - aLeft;
+ h := aBottom - aTop;
+ Size := FormatDesc.GetSize(w, h);
+ GetMem(Temp, Size);
+ try
+ glPixelStorei(GL_PACK_ALIGNMENT, 1);
+ glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
+ aDataObj.SetData(Temp, aFormat, w, h);
+ aDataObj.FlipVert;
+ except
+ if Assigned(Temp) then
+ FreeMem(Temp);
+ raise;
+ end;
+end;
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapCubeMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.AfterConstruction;
+begin
+ inherited;
+
+{$IFNDEF OPENGL_ES}
+ if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
+ raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
+{$ELSE}
+ if not (GL_VERSION_2_0) then
+ raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
+{$ENDIF}
+
+ SetWrap;
+ Target := GL_TEXTURE_CUBE_MAP;
+{$IFNDEF OPENGL_ES}
+ fGenMode := GL_REFLECTION_MAP;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean);
+begin
+ Assert(false, 'TglBitmapCubeMap.UploadData - Don''t call UploadData directly, use UploadCubeMap instead');
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
+var
+ {$IFNDEF OPENGL_ES}
+ BuildWithGlu: Boolean;
+ {$ENDIF}
+ TexSize: Integer;
+begin
+ if (aCheckSize) then begin
+ glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
+
+ if (aDataObj.Width > TexSize) or (aDataObj.Height > TexSize) then
+ raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenerateCubeMap - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
+
+{$IF NOT DEFINED(OPENGL_ES)}
+ if not ((IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
+{$ELSEIF DEFINED(OPENGL_ES_EXT)}
+ if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) and not GL_OES_texture_npot then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
+{$ELSE}
+ if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) then
+ raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.');
+{$IFEND}
+ end;
+
+ if (fID = 0) then
+ CreateID;
+ SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF});
+ UploadDataIntern(aDataObj, aCubeTarget{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF});
+
+ inherited UploadData(aDataObj, aCheckSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean{$ENDIF});
+begin
+ inherited Bind({$IFNDEF OPENGL_ES}aEnableTextureUnit{$ENDIF});
+{$IFNDEF OPENGL_ES}
+ if aEnableTexCoordsGen then begin
+ glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
+ glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
+ glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
+ glEnable(GL_TEXTURE_GEN_S);
+ glEnable(GL_TEXTURE_GEN_T);
+ glEnable(GL_TEXTURE_GEN_R);
+ end;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean{$ENDIF});
+begin
+ inherited Unbind({$IFNDEF OPENGL_ES}aDisableTextureUnit{$ENDIF});
+{$IFNDEF OPENGL_ES}
+ if aDisableTexCoordsGen then begin
+ glDisable(GL_TEXTURE_GEN_S);
+ glDisable(GL_TEXTURE_GEN_T);
+ glDisable(GL_TEXTURE_GEN_R);
+ end;
+{$ENDIF}
+end;
+{$IFEND}
+
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapNormalMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+ TVec = Array[0..2] of Single;
+ TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+
+ PglBitmapNormalMapRec = ^TglBitmapNormalMapRec;
+ TglBitmapNormalMapRec = record
+ HalfSize : Integer;
+ Func: TglBitmapNormalMapGetVectorFunc;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := aHalfSize;
+ aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+ aVec[2] := - (aPosition.X + 0.5 - aHalfSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := - aHalfSize;
+ aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+ aVec[2] := aPosition.X + 0.5 - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := aPosition.X + 0.5 - aHalfSize;
+ aVec[1] := aHalfSize;
+ aVec[2] := aPosition.Y + 0.5 - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := aPosition.X + 0.5 - aHalfSize;
+ aVec[1] := - aHalfSize;
+ aVec[2] := - (aPosition.Y + 0.5 - aHalfSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := aPosition.X + 0.5 - aHalfSize;
+ aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+ aVec[2] := aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+ aVec[0] := - (aPosition.X + 0.5 - aHalfSize);
+ aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+ aVec[2] := - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec);
+var
+ i: Integer;
+ Vec: TVec;
+ Len: Single;
+begin
+ with FuncRec do begin
+ with PglBitmapNormalMapRec(Args)^ do begin
+ Func(Vec, Position, HalfSize);
+
+ // Normalize
+ Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
+ if Len <> 0 then begin
+ Vec[0] := Vec[0] * Len;
+ Vec[1] := Vec[1] * Len;
+ Vec[2] := Vec[2] * Len;
+ end;
+
+ // Scale Vector and AddVectro
+ Vec[0] := Vec[0] * 0.5 + 0.5;
+ Vec[1] := Vec[1] * 0.5 + 0.5;
+ Vec[2] := Vec[2] * 0.5 + 0.5;
+ end;
+
+ // Set Color
+ for i := 0 to 2 do
+ Dest.Data.arr[i] := Round(Vec[i] * 255);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapNormalMap.AfterConstruction;
+begin
+ inherited;
+{$IFNDEF OPENGL_ES}
+ fGenMode := GL_NORMAL_MAP;
+{$ENDIF}
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aCheckSize: Boolean);
+var
+ Rec: TglBitmapNormalMapRec;
+ SizeRec: TglBitmapSize;
+ DataObj: TglBitmapData;
+begin
+ Rec.HalfSize := aSize div 2;
+
+ SizeRec.Fields := [ffX, ffY];
+ SizeRec.X := aSize;
+ SizeRec.Y := aSize;
+
+ DataObj := TglBitmapData.Create;
+ try
+ // Positive X
+ Rec.Func := glBitmapNormalMapPosX;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_X, aCheckSize);
+
+ // Negative X
+ Rec.Func := glBitmapNormalMapNegX;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aCheckSize);
+
+ // Positive Y
+ Rec.Func := glBitmapNormalMapPosY;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aCheckSize);
+
+ // Negative Y
+ Rec.Func := glBitmapNormalMapNegY;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aCheckSize);
+
+ // Positive Z
+ Rec.Func := glBitmapNormalMapPosZ;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aCheckSize);
+
+ // Negative Z
+ Rec.Func := glBitmapNormalMapNegZ;
+ DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec);
+ UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aCheckSize);
+ finally
+ FreeAndNil(DataObj);
+ end;
+end;
+{$IFEND}
+
+initialization
+ glBitmapSetDefaultFormat (tfEmpty);
+ glBitmapSetDefaultMipmap (mmMipmap);
+ glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
+ glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}
+ glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);
+{$IFEND}
+
+ glBitmapSetDefaultFreeDataAfterGenTexture(true);
+ glBitmapSetDefaultDeleteTextureOnFree (true);
+
+ TFormatDescriptor.Init;
+
+finalization
+ TFormatDescriptor.Finalize;
+
+end.
--- /dev/null
+unit uglcCamera;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Frustum und Kamera
+ Beispiel:
+ var
+ camera: TglcCamera;
+
+ camera := TglcCamera.Create;
+ try
+ camera.Perspective(45, 0.01, 100, 800/600); // define perspective view
+ camera.Move(gluVector(2, 3, -5)); // move 2 right, 3 up and 5 back
+ camera.Tilt(-25); // turn 25 degrees down
+ camera.Turn(-10); // turn 10 degrees left
+ camera.Activate; // activate camera
+
+ // do normal rendering
+
+ finally
+ FreeAndNil(camera);
+ end; }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils,
+ ugluVector, ugluMatrix;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcFrustum = class(TObject)
+ private
+ fProjMatrix: TgluMatrix4f;
+ function GetProjMatrixPtr: Pointer;
+ function GetWidth: Single;
+ function GetHeight: Single;
+ function GetFOVAngle: Single;
+ function GetAspectRatio: Single;
+ procedure UpdateProjMatrix;
+ protected
+ fIsOrthogonal: Boolean;
+ fTop, fBottom, fLeft, fRight, fNear, fFar: Single;
+ public
+ property Top: Single read fTop;
+ property Bottom: Single read fBottom;
+ property Left: Single read fLeft;
+ property Right: Single read fRight;
+ property Near: Single read fNear;
+ property Far: Single read fFar;
+ property Width: Single read GetWidth;
+ property Height: Single read GetHeight;
+ property FOVAngle: Single read GetFOVAngle;
+ property AspectRatio: Single read GetAspectRatio;
+ property IsOrthogonal: Boolean read fIsOrthogonal;
+ property ProjMatrix: TgluMatrix4f read fProjMatrix;
+ property ProjMatrixPtr: Pointer read GetProjMatrixPtr;
+
+ procedure Frustum(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+ procedure Perspective(const aFOVAngle, aAspectRatio, aNear, aFar: Single);
+ procedure Ortho(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+ procedure Activate;
+{$IFNDEF OPENGL_ES}
+ procedure Render;
+{$ENDIF}
+
+ constructor Create;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcCamera = class(TglcFrustum)
+ private
+ fPosition: TgluMatrix4f;
+ function GetPositionPtr: Pointer;
+ public
+ property Position: TgluMatrix4f read fPosition write fPosition;
+ property PositionPtr: Pointer read GetPositionPtr;
+
+ procedure Move(const aVec: TgluVector3f);
+ procedure Tilt(const aAngle: Single);
+ procedure Turn(const aAngle: Single);
+ procedure Roll(const aAngle: Single);
+ procedure Activate;
+ function GetRay(const aPos: TgluVector2f): TgluRayf;
+
+ constructor Create;
+ end;
+
+implementation
+
+uses
+ Math, {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF};
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcFrustum///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.UpdateProjMatrix;
+begin
+ if fIsOrthogonal then begin
+ fProjMatrix[maAxisX] := gluVector4f(
+ 2 / (fRight - fLeft),
+ 0,
+ 0,
+ 0);
+ fProjMatrix[maAxisY] := gluVector4f(
+ 0,
+ 2 / (fTop - fBottom),
+ 0,
+ 0);
+ fProjMatrix[maAxisZ] := gluVector4f(
+ 0,
+ 0,
+ -2 / (fFar - fNear),
+ 0);
+ fProjMatrix[maPos] := gluVector4f(
+ -(fRight + fLeft) / (fRight - fLeft),
+ -(fTop + fBottom) / (fTop - fBottom),
+ -(fFar + fNear) / (fFar - fNear),
+ 1);
+ end else begin
+ fProjMatrix[maAxisX] := gluVector4f(
+ 2 * fNear / (fRight - fLeft),
+ 0,
+ 0,
+ 0);
+ fProjMatrix[maAxisY] := gluVector4f(
+ 0,
+ 2 * fNear / (fTop - fBottom),
+ 0,
+ 0);
+ fProjMatrix[maAxisZ] := gluVector4f(
+ (fRight + fLeft) / (fRight - fLeft),
+ (fTop + fBottom) / (fTop - fBottom),
+ -(fFar + fNear) / (fFar - fNear),
+ -1);
+ fProjMatrix[maPos] := gluVector4f(
+ 0,
+ 0,
+ -2 * fFar * fNear / (fFar - fNear),
+ 0);
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetWidth: Single;
+begin
+ result := (fRight - fLeft);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetProjMatrixPtr: Pointer;
+begin
+ result := @fProjMatrix[0, 0];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetHeight: Single;
+begin
+ result := (fTop - fBottom);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetFOVAngle: Single;
+begin
+ result := arctan2(Height/2, fNear)/Pi*360;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetAspectRatio: Single;
+begin
+ result := Height / Width;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Frustum(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+begin
+ fIsOrthogonal := false;
+ fTop := aRight;
+ fBottom := aLeft;
+ fLeft := aBottom;
+ fRight := aTop;
+ fNear := aNear;
+ fFar := aFar;
+ UpdateProjMatrix;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Perspective(const aFOVAngle, aAspectRatio, aNear, aFar: Single);
+begin
+ fIsOrthogonal := false;
+ fNear := aNear;
+ fFar := aFar;
+ fTop := fNear * tan(aFOVAngle / 360 * Pi);
+ fBottom := -fTop;
+ fRight := aAspectRatio * fTop;
+ fLeft := -fRight;
+ UpdateProjMatrix;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Ortho(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+begin
+ fIsOrthogonal := true;
+ fLeft := aLeft;
+ fRight := aRight;
+ fTop := aTop;
+ fBottom := aBottom;
+ fNear := aNear;
+ fFar := aFar;
+ UpdateProjMatrix;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Activate;
+begin
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity;
+ if fIsOrthogonal then
+ {$IFNDEF OPENGL_ES}glOrtho{$ELSE}glOrthof{$ENDIF}(fLeft, fRight, fBottom, fTop, fNear, fFar)
+ else
+ {$IFNDEF OPENGL_ES}glFrustum{$ELSE}glFrustumf{$ENDIF}(fLeft, fRight, fBottom, fTop, fNear, fFar);
+ glMatrixMode(GL_MODELVIEW);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IFNDEF OPENGL_ES}
+procedure TglcFrustum.Render;
+var
+ min, max: TgluVector2f;
+begin
+ min[0] := fLeft / fNear * fFar;
+ min[1] := fBottom / fNear * fFar;
+ max[0] := fRight / fNear * fFar;
+ max[1] := fTop / fNear * fFar;
+
+ glBegin(GL_LINE_LOOP);
+ glVertex3f(fLeft, fTop, -fNear);
+ glVertex3f(fLeft, fBottom, -fNear);
+ glVertex3f(fRight, fBottom, -fNear);
+ glVertex3f(fRight, fTop, -fNear);
+ glEnd;
+
+ glBegin(GL_LINE_LOOP);
+ glVertex3f(min[0], min[0], -fFar);
+ glVertex3f(min[0], max[0], -fFar);
+ glVertex3f(max[0], max[0], -fFar);
+ glVertex3f(max[0], min[0], -fFar);
+ glEnd;
+
+ glBegin(GL_LINES);
+ glVertex3f(0, 0, 0); glVertex3f(min[0], min[0], -fFar);
+ glVertex3f(0, 0, 0); glVertex3f(min[0], max[0], -fFar);
+ glVertex3f(0, 0, 0); glVertex3f(max[0], max[0], -fFar);
+ glVertex3f(0, 0, 0); glVertex3f(max[0], min[0], -fFar);
+ glEnd;
+end;
+{$ENDIF}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcFrustum.Create;
+begin
+ inherited Create;
+ fTop := 0;
+ fBottom := 0;
+ fLeft := 0;
+ fRight := 0;
+ fNear := 0;
+ fFar := 0;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcCamera////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcCamera.GetPositionPtr: Pointer;
+begin
+ result := @fPosition[0, 0];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Move(const aVec: TgluVector3f);
+begin
+ fPosition := gluMatrixMult(gluMatrixTranslate(aVec), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Tilt(const aAngle: Single);
+begin
+ fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(1,0,0), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Turn(const aAngle: Single);
+begin
+ fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(0,1,0), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Roll(const aAngle: Single);
+begin
+ fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(0,0,1), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Activate;
+begin
+ inherited Activate;
+ glLoadMatrixf(@fPosition[0, 0]);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcCamera.GetRay(const aPos: TgluVector2f): TgluRayf;
+var
+ p: TgluVector3f;
+begin
+ if (aPos[0] < 0) then
+ p[0] := -aPos[0] * fLeft
+ else
+ p[0] := aPos[0] * fRight;
+ if (aPos[1] < 0) then
+ p[1] := -aPos[1] * fBottom
+ else
+ p[1] := aPos[1] * fTop;
+ if (fIsOrthogonal) then begin
+ p[2] := 0;
+ result.p := fPosition * p;
+ result.v := fPosition * gluVector3f(0, 0, -1);
+ end else begin
+ p[2] := -fNear;
+ result.p := gluVector3f(0, 0, 0);
+ result.v := fPosition * p;
+ end;
+ result := gluRayNormalize(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcCamera.Create;
+begin
+ inherited Create;
+ fPosition := gluMatrixIdentity;
+end;
+
+end.
+
--- /dev/null
+unit uglcContext;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine abstrakte Klassen-Kapselung für OpenGL Kontexte
+
+
+Abstrakte Contextklasse zum Erstellen von Renderkontexten auf Windows & Linux(bzw X11/Gtk2)
+Für aktuelle Plattform passende Klasse kann per GetPlatformClass gefunden werden.
+
+Bsp.:
+ //muss im GUI/Main-Thread aufgerufen werden:
+ pf := TglcContext.GetPlatformClass().MakePF();
+ fContext := TglcContext.GetPlatformClass().Create(MyTWinControl, PF);
+
+ //_kann_ in Background Thread abgerufen werden:
+ fContext.BuildContext();
+ [Arbeit mit dem Context]
+ fContext.CloseContext();
+
+ //im MainThread
+ FreeAndNil(fContext)
+
+
+weitere Funktionen:
+ MakePF() erzeugt PixelFormatDescriptor mit Defaults
+ BuildContext() baut Kontext (kann in BackgrounThread aufgerufen werden)
+ CloseContext() gibt den Kontext frei (muss im selben Thread aufgerufen werden wie BuildContext;
+ wird der Kontext nur im MainThread genutzt, muss CloseContext nicht explizit aufgerufen
+ werden und wird beim zerstören des Kontext-Objekts ausgeführt)
+ Activate/Deactiveate Kontext aktiv schalten oder nicht
+ SwapBuffers DoubleBuffering
+ SetSwapInterval VSync
+ Share ShareLists
+ EnableDebugOutput GL-Debug via ARB_debug_output oder AMD_debug_output de/aktivieren
+}
+
+interface
+
+uses
+ SysUtils, Controls, dglOpenGL;
+
+const
+ GLC_CONTEXT_VERSION_UNKNOWN = -1;
+
+type
+{$IFNDEF fpc}
+ TThreadID = Cardinal;
+{$ENDIF}
+
+ TMultiSample = 1..high(byte);
+ TglcContextPixelFormatSettings = packed record
+ DoubleBuffered: boolean;
+ Stereo: boolean;
+ MultiSampling: TMultiSample;
+ ColorBits: Integer;
+ DepthBits: Integer;
+ StencilBits: Integer;
+ AccumBits: Integer;
+ AuxBuffers: Integer;
+ Layer: Integer;
+ end;
+ TglcContextVersionSettings = packed record
+ Major: Integer;
+ Minor: Integer;
+ ForwardCompatible: Boolean;
+ end;
+ TSeverity = (svLow, svMedium, svHigh);
+ TLogEvent = procedure(const aSender: TObject; const aSeverity: TSeverity; const aMsg: String) of Object;
+
+ TglcDisplayFlag = (
+ dfFullscreen);
+ TglcDisplayFlags = set of TglcDisplayFlag;
+
+ EGLError = class(Exception);
+
+ { TglcContext }
+ TglcContextClass = class of TglcContext;
+ TglcContext = class
+ private
+ fControl: TWinControl;
+ fThreadID: TThreadID;
+ fEnableVsync: Boolean;
+ fLogEvent: TLogEvent;
+
+ function GetEnableVSync: Boolean;
+ procedure SetEnableVSync(aValue: Boolean);
+ procedure LogMsg(const aSeverity: TSeverity; const aMsg: String);
+ procedure SetDebugMode(const aEnable: Boolean);
+ protected
+ fUseVersion: Boolean;
+ fPixelFormatSettings: TglcContextPixelFormatSettings;
+ fVersionSettings: TglcContextVersionSettings;
+ procedure OpenContext; virtual;
+
+ public
+ property PixelFormatSettings: TglcContextPixelFormatSettings read fPixelFormatSettings;
+ property VersionSettings: TglcContextVersionSettings read fVersionSettings;
+
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); overload; virtual;
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); overload; virtual;
+ destructor Destroy; override;
+
+ property ThreadID: TThreadID read fThreadID;
+ property EnableVSync: Boolean read GetEnableVSync write SetEnableVSync;
+
+ procedure BuildContext;
+ procedure EnableDebugOutput(const aLogEvent: TLogEvent);
+ procedure DisableDebugOutput;
+ procedure CloseContext; virtual;
+ procedure Activate; virtual; abstract;
+ procedure Deactivate; virtual; abstract;
+ function IsActive: boolean; virtual; abstract;
+ procedure SwapBuffers; virtual; abstract;
+ procedure SetSwapInterval(const aInterval: GLint); virtual; abstract;
+ function GetSwapInterval: GLint; virtual; abstract;
+ procedure Share(const aContext: TglcContext); virtual; abstract;
+{$IFDEF fpc}
+ private class var
+ fMainContextThreadID: TThreadID;
+ public
+ class property MainContextThreadID: TThreadID read fMainContextThreadID;
+{$ENDIF}
+ public
+ class function MakePF(DoubleBuffered: boolean = true;
+ Stereo: boolean=false;
+ MultiSampling: TMultiSample=1;
+ ColorBits: Integer=32;
+ DepthBits: Integer=24;
+ StencilBits: Integer=0;
+ AccumBits: Integer=0;
+ AuxBuffers: Integer=0;
+ Layer: Integer=0): TglcContextPixelFormatSettings;
+ class function MakeVersion(const aMajor, aMinor: Integer; const aForwardCompatible: Boolean): TglcContextVersionSettings;
+ class function GetPlatformClass: TglcContextClass;
+ class function ChangeDisplaySettings(const aWidth, aHeight,
+ aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean; virtual; abstract;
+ class function IsAnyContextActive: boolean; virtual;
+ end;
+
+implementation
+
+uses
+ {$IFDEF WINDOWS}
+ uglcContextWGL
+ {$ELSE}{$IFDEF WIN32}
+ uglcContextWGL{$IFNDEF fpc}, Windows{$ENDIF}
+ {$ENDIF}{$ENDIF}
+
+ {$IFDEF LINUX}
+ uglcContextGtk2GLX
+ {$ENDIF}
+ ;
+
+{$IFNDEF fpc}
+var
+ fMainContextThreadID: TThreadID;
+{$ENDIF}
+
+procedure GlDebugCallbackARB(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; {%H-}length: GLsizei; const message_: PGLchar; {%H-}userParam: PGLvoid); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}
+var
+ src, typ: String;
+ sv: TSeverity;
+begin
+ case source of
+ GL_DEBUG_SOURCE_API_ARB : src:= 'API';
+ GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB : src:= 'WINDOW';
+ GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: src:= 'SHADER';
+ GL_DEBUG_SOURCE_THIRD_PARTY_ARB : src:= '3RDPARTY';
+ GL_DEBUG_SOURCE_APPLICATION_ARB : src:= 'APPLICATION';
+ GL_DEBUG_SOURCE_OTHER_ARB : src:= 'OTHER';
+ end;
+ src:= 'GL_' + src;
+
+ case type_ of
+ GL_DEBUG_TYPE_ERROR_ARB : typ:= 'ERROR';
+ GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB : typ:= 'DEPRECATED';
+ GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB : typ:= 'UNDEF BEHAV';
+ GL_DEBUG_TYPE_PORTABILITY_ARB : typ:= 'PORTABILITY';
+ GL_DEBUG_TYPE_PERFORMANCE_ARB : typ:= 'PERFORMANCE';
+ GL_DEBUG_TYPE_OTHER_ARB : typ:= 'OTHER';
+ end;
+
+ case severity of
+ GL_DEBUG_SEVERITY_LOW_ARB: sv := svLow;
+ GL_DEBUG_SEVERITY_MEDIUM_ARB: sv := svMedium;
+ GL_DEBUG_SEVERITY_HIGH_ARB: sv := svHigh;
+ end;
+
+ TglcContext(userParam).LogMsg(sv, format('%s [%d] %s',[typ, id, message_]));
+end;
+
+procedure GlDebugCallbackAMD(id: GLuint; category: GLenum; severity: GLenum; {%H-}length: GLsizei; const message_: PGLchar; {%H-}userParam: PGLvoid); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}
+var
+ src: String;
+ sv: TSeverity;
+begin
+ case category of
+ GL_DEBUG_CATEGORY_API_ERROR_AMD : src:= 'API';
+ GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD : src:= 'WINDOW';
+ GL_DEBUG_CATEGORY_DEPRECATION_AMD : src:= 'SHADER';
+ GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD : src:= 'UNDEF BEHAV';
+ GL_DEBUG_CATEGORY_PERFORMANCE_AMD : src:= 'PERFORMANCE';
+ GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD : src:= 'SHADER';
+ GL_DEBUG_CATEGORY_APPLICATION_AMD : src:= 'APPLICATION';
+ GL_DEBUG_CATEGORY_OTHER_AMD : src:= 'OTHER';
+ end;
+ src:= 'GL_' + src;
+
+ case severity of
+ GL_DEBUG_SEVERITY_LOW_AMD: sv := svLow;
+ GL_DEBUG_SEVERITY_MEDIUM_AMD: sv := svMedium;
+ GL_DEBUG_SEVERITY_HIGH_AMD: sv := svHigh;
+ end;
+
+ TglcContext(userParam).LogMsg(sv, format('[%d] %s',[id, message_]));
+end;
+
+function TglcContext.GetEnableVSync: Boolean;
+begin
+ result := fEnableVsync;
+end;
+
+procedure TglcContext.SetEnableVSync(aValue: Boolean);
+begin
+ fEnableVsync := aValue;
+ if IsActive then begin
+ if fEnableVsync then
+ SetSwapInterval(1)
+ else
+ SetSwapInterval(0);
+ end;
+end;
+
+procedure TglcContext.LogMsg(const aSeverity: TSeverity; const aMsg: String);
+begin
+ if Assigned(fLogEvent) then
+ fLogEvent(self, aSeverity, aMsg);
+end;
+
+procedure TglcContext.SetDebugMode(const aEnable: Boolean);
+begin
+ // ARB Debug Output
+ if GL_ARB_debug_output then begin
+ glDebugMessageCallbackARB(@GlDebugCallbackARB, self);
+ glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nil, aEnable);
+ if aEnable then begin
+ glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+ glDebugMessageInsertARB(GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_OTHER_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, -1, PGLchar('Attached ARB_debug_output'));
+ end;
+
+ // AMD Debug Output
+ end else if GL_AMD_debug_output then begin
+ glDebugMessageCallbackAMD(@GlDebugCallbackAMD, self);
+ glDebugMessageEnableAMD(GL_DONT_CARE, GL_DONT_CARE, 0, nil, aEnable);
+ if aEnable then
+ glDebugMessageInsertAMD(GL_DEBUG_CATEGORY_OTHER_AMD, GL_DEBUG_SEVERITY_LOW_ARB, 0, -1, PGLchar('Attached ARB_debug_output'));
+ end;
+end;
+
+procedure TglcContext.OpenContext;
+begin
+ fThreadID := GetCurrentThreadId;
+ if fMainContextThreadID = 0 then
+ fMainContextThreadID := fThreadID;
+end;
+
+class function TglcContext.MakePF(DoubleBuffered: boolean; Stereo: boolean; MultiSampling: TMultiSample; ColorBits: Integer;
+ DepthBits: Integer; StencilBits: Integer; AccumBits: Integer; AuxBuffers: Integer; Layer: Integer): TglcContextPixelFormatSettings;
+begin
+ Result.DoubleBuffered:= DoubleBuffered;
+ Result.Stereo:= Stereo;
+ Result.MultiSampling:= MultiSampling;
+ Result.ColorBits:= ColorBits;
+ Result.DepthBits:= DepthBits;
+ Result.StencilBits:= StencilBits;
+ Result.AccumBits:= AccumBits;
+ Result.AuxBuffers:= AuxBuffers;
+ Result.Layer:= Layer;
+end;
+
+class function TglcContext.MakeVersion(const aMajor, aMinor: Integer; const aForwardCompatible: Boolean): TglcContextVersionSettings;
+begin
+ result.Major := aMajor;
+ result.Minor := aMinor;
+ result.ForwardCompatible := aForwardCompatible;
+end;
+
+class function TglcContext.GetPlatformClass: TglcContextClass;
+begin
+ Result := nil;
+ {$IFDEF WINDOWS}
+ Result:= TglcContextWGL;
+ {$ELSE}{$IFDEF WIN32}
+ Result:= TglcContextWGL;
+ {$ENDIF}{$ENDIF}
+ {$IFDEF LINUX}
+ Result:= TglcContextGtk2GLX;
+ {$ENDIF}
+ if not Assigned(result) then
+ raise EGLError.Create('unable to find suitabe context class');
+end;
+
+class function TglcContext.IsAnyContextActive: boolean;
+begin
+ Result:= GetPlatformClass.IsAnyContextActive;
+end;
+
+constructor TglcContext.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings);
+begin
+ inherited Create;
+ fPixelFormatSettings := aPixelFormatSettings;
+ FControl := aControl;
+ fThreadID := 0;
+ fEnableVsync := false;
+ fUseVersion := false;
+ InitOpenGL();
+end;
+
+constructor TglcContext.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings);
+begin
+ Create(aControl, aPixelFormatSettings);
+ fVersionSettings := aVersionSettings;
+ fUseVersion := true;
+end;
+
+destructor TglcContext.Destroy;
+begin
+ if (GetCurrentThreadId = fMainContextThreadID) then
+ fMainContextThreadID := 0;
+ CloseContext;
+ inherited Destroy;
+end;
+
+procedure TglcContext.BuildContext;
+begin
+ OpenContext;
+ Activate;
+ ReadImplementationProperties;
+ ReadExtensions;
+ SetEnableVSync(fEnableVsync);
+end;
+
+procedure TglcContext.EnableDebugOutput(const aLogEvent: TLogEvent);
+begin
+ fLogEvent := aLogEvent;
+ SetDebugMode(true);
+end;
+
+procedure TglcContext.DisableDebugOutput;
+begin
+ SetDebugMode(false);
+end;
+
+procedure TglcContext.CloseContext;
+begin
+ if fMainContextThreadID = fThreadID then
+ fMainContextThreadID := 0;
+end;
+
+initialization
+ {$IFDEF fpc}TglcContext.{$ENDIF}fMainContextThreadID := 0;
+
+end.
+
--- /dev/null
+unit uglcContextGtk2GLX;\r
+\r
+{ Package: OpenGLCore\r
+ Prefix: glc - OpenGL Core\r
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Kontexte für Linux\r
+ Hint: diese Unit sollte niemals direkt genutzt werden (siehe uglcContext) }\r
+\r
+interface\r
+\r
+uses\r
+ SysUtils, Controls, uglcContext, LCLType, XUtil, XLib, gdk2x, gtk2, gdk2, dglOpenGL,\r
+ LMessages, uglcContextGtkCustomVisual;\r
+\r
+type\r
+ EGLXError = class(EGLError);\r
+\r
+ TRenderControl = class(TCustomVisualControl)\r
+ private\r
+ fTarget: TWinControl;\r
+ protected\r
+ procedure WndProc(var Message: TLMessage); override;\r
+ public\r
+ property Target: TWinControl read fTarget write fTarget;\r
+ end;\r
+\r
+ { TglcContextGtk2GLX }\r
+\r
+ TglcContextGtk2GLX = class(TglcContext)\r
+ private\r
+ FVisual: PXVisualInfo;\r
+ FDisplay: PDisplay;\r
+ FWidget: PGtkWidget;\r
+ FContext: GLXContext;\r
+ FRenderControl: TRenderControl;\r
+ procedure UpdateVisual(const aControl: TWinControl);\r
+ protected\r
+ procedure OpenContext; override;\r
+ public\r
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); override; overload;\r
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); override; overload;\r
+ destructor Destroy; override;\r
+\r
+ procedure CloseContext; override;\r
+ procedure Activate; override;\r
+ procedure Deactivate; override;\r
+ function IsActive: boolean; override;\r
+ procedure SwapBuffers; override;\r
+ procedure SetSwapInterval(const aInterval: GLint); override;\r
+ procedure Share(const aContext: TglcContext); override;\r
+\r
+ class function ChangeDisplaySettings(const aWidth, aHeight,\r
+ aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean; override;\r
+ class function IsAnyContextActive: boolean; override;\r
+ end;\r
+\r
+implementation\r
+\r
+type\r
+ TGLIntArray = packed array of GLInt;\r
+\r
+{$region messages -fold}\r
+procedure TRenderControl.WndProc(var Message: TLMessage);\r
+begin\r
+ case Message.msg of\r
+ //LM_ACTIVATEITEM,\r
+ //LM_CHANGED,\r
+ //LM_FOCUS,\r
+ LM_CLICKED,\r
+ //LM_RELEASED,\r
+ LM_ENTER,\r
+ LM_LEAVE,\r
+ //LM_CHECKRESIZE,\r
+ //LM_SETEDITABLE,\r
+ //LM_MOVEWORD,\r
+ //LM_MOVEPAGE,\r
+ //LM_MOVETOROW,\r
+ //LM_MOVETOCOLUMN,\r
+ //LM_KILLCHAR,\r
+ //LM_KILLWORD,\r
+ //LM_KILLLINE,\r
+ //LM_CLOSEQUERY,\r
+ //LM_DRAGSTART,\r
+ //LM_MONTHCHANGED,\r
+ //LM_YEARCHANGED,\r
+ //LM_DAYCHANGED,\r
+ LM_LBUTTONTRIPLECLK,\r
+ LM_LBUTTONQUADCLK,\r
+ LM_MBUTTONTRIPLECLK,\r
+ LM_MBUTTONQUADCLK,\r
+ LM_RBUTTONTRIPLECLK,\r
+ LM_RBUTTONQUADCLK,\r
+ LM_MOUSEENTER,\r
+ LM_MOUSELEAVE,\r
+ LM_XBUTTONTRIPLECLK,\r
+ LM_XBUTTONQUADCLK,\r
+\r
+ //SC_SIZE,\r
+ //SC_MOVE,\r
+ //SC_MINIMIZE,\r
+ //SC_MAXIMIZE,\r
+ //SC_NEXTWINDOW,\r
+ //SC_PREVWINDOW,\r
+ //SC_CLOSE,\r
+ SC_VSCROLL,\r
+ SC_HSCROLL,\r
+ SC_MOUSEMENU,\r
+ SC_KEYMENU,\r
+ //SC_ARRANGE,\r
+ //SC_RESTORE,\r
+ //SC_TASKLIST,\r
+ //SC_SCREENSAVE,\r
+ //SC_HOTKEY,\r
+ //SC_DEFAULT,\r
+ //SC_MONITORPOWER,\r
+ //SC_CONTEXTHELP,\r
+ //SC_SEPARATOR,\r
+\r
+ //LM_MOVE,\r
+ //LM_SIZE,\r
+ LM_ACTIVATE,\r
+ LM_SETFOCUS,\r
+ LM_KILLFOCUS,\r
+ //LM_ENABLE,\r
+ //LM_GETTEXTLENGTH,\r
+ //LM_SHOWWINDOW,\r
+ //LM_CANCELMODE,\r
+ //LM_DRAWITEM,\r
+ //LM_MEASUREITEM,\r
+ //LM_DELETEITEM,\r
+ //LM_VKEYTOITEM,\r
+ //LM_CHARTOITEM,\r
+ //LM_COMPAREITEM,\r
+ //LM_WINDOWPOSCHANGING,\r
+ //LM_WINDOWPOSCHANGED,\r
+ //LM_NOTIFY,\r
+ //LM_HELP,\r
+ //LM_NOTIFYFORMAT,\r
+ //LM_CONTEXTMENU,\r
+ //LM_NCCALCSIZE,\r
+ //LM_NCHITTEST,\r
+ //LM_NCPAINT,\r
+ //LM_NCACTIVATE,\r
+ //LM_GETDLGCODE,\r
+ LM_NCMOUSEMOVE,\r
+ LM_NCLBUTTONDOWN,\r
+ LM_NCLBUTTONUP,\r
+ LM_NCLBUTTONDBLCLK,\r
+ LM_KEYDOWN,\r
+ LM_KEYUP,\r
+ LM_CHAR,\r
+ LM_SYSKEYDOWN,\r
+ LM_SYSKEYUP,\r
+ LM_SYSCHAR,\r
+ LM_COMMAND,\r
+ LM_SYSCOMMAND,\r
+ LM_TIMER,\r
+ LM_HSCROLL,\r
+ LM_VSCROLL,\r
+ //LM_CTLCOLORMSGBOX,\r
+ //LM_CTLCOLOREDIT,\r
+ //LM_CTLCOLORLISTBOX,\r
+ //LM_CTLCOLORBTN,\r
+ //LM_CTLCOLORDLG,\r
+ //LM_CTLCOLORSCROLLBAR,\r
+ //LM_CTLCOLORSTATIC,\r
+ LM_MOUSEMOVE,\r
+ LM_LBUTTONDOWN,\r
+ LM_LBUTTONUP,\r
+ LM_LBUTTONDBLCLK,\r
+ LM_RBUTTONDOWN,\r
+ LM_RBUTTONUP,\r
+ LM_RBUTTONDBLCLK,\r
+ LM_MBUTTONDOWN,\r
+ LM_MBUTTONUP,\r
+ LM_MBUTTONDBLCLK,\r
+ LM_MOUSEWHEEL,\r
+ LM_XBUTTONDOWN,\r
+ LM_XBUTTONUP,\r
+ LM_XBUTTONDBLCLK,\r
+ //LM_PARENTNOTIFY,\r
+ //LM_CAPTURECHANGED,\r
+ //LM_DROPFILES,\r
+ //LM_SELCHANGE,\r
+ LM_CUT,\r
+ LM_COPY,\r
+ LM_PASTE,\r
+ //LM_CLEAR,\r
+ //LM_CONFIGUREEVENT,\r
+ //LM_EXIT,\r
+ //LM_QUIT,\r
+ //LM_NULL,\r
+ //LM_PAINT,\r
+ //LM_ERASEBKGND,\r
+ //LM_SETCURSOR,\r
+ //LM_SETFONT:\r
+\r
+ //CM_ACTIVATE,\r
+ //CM_DEACTIVATE,\r
+ //CM_FOCUSCHANGED,\r
+ //CM_PARENTFONTCHANGED,\r
+ //CM_PARENTCOLORCHANGED,\r
+ //CM_HITTEST,\r
+ //CM_VISIBLECHANGED,\r
+ //CM_ENABLEDCHANGED,\r
+ //CM_COLORCHANGED,\r
+ //CM_FONTCHANGED,\r
+ //CM_CURSORCHANGED,\r
+ //CM_TEXTCHANGED,\r
+ CM_MOUSEENTER,\r
+ CM_MOUSELEAVE,\r
+ //CM_MENUCHANGED,\r
+ //CM_APPSYSCOMMAND,\r
+ //CM_BUTTONPRESSED,\r
+ //CM_SHOWINGCHANGED,\r
+ //CM_ENTER,\r
+ //CM_EXIT,\r
+ //CM_DESIGNHITTEST,\r
+ //CM_ICONCHANGED,\r
+ //CM_WANTSPECIALKEY,\r
+ //CM_RELEASE,\r
+ //CM_FONTCHANGE,\r
+ //CM_TABSTOPCHANGED,\r
+ //CM_UIACTIVATE,\r
+ //CM_CONTROLLISTCHANGE,\r
+ //CM_GETDATALINK,\r
+ //CM_CHILDKEY,\r
+ //CM_HINTSHOW,\r
+ //CM_SYSFONTCHANGED,\r
+ //CM_CONTROLCHANGE,\r
+ //CM_CHANGED,\r
+ //CM_BORDERCHANGED,\r
+ //CM_BIDIMODECHANGED,\r
+ //CM_PARENTBIDIMODECHANGED,\r
+ //CM_ALLCHILDRENFLIPPED,\r
+ //CM_ACTIONUPDATE,\r
+ //CM_ACTIONEXECUTE,\r
+ //CM_HINTSHOWPAUSE,\r
+ //CM_DOCKNOTIFICATION,\r
+ CM_MOUSEWHEEL,\r
+ //CM_APPSHOWBTNGLYPHCHANGED,\r
+ //CM_APPSHOWMENUGLYPHCHANGED,\r
+\r
+ //CN_BASE,\r
+ //CN_CHARTOITEM,\r
+ //CN_COMMAND,\r
+ //CN_COMPAREITEM,\r
+ //CN_CTLCOLORBTN,\r
+ //CN_CTLCOLORDLG,\r
+ //CN_CTLCOLOREDIT,\r
+ //CN_CTLCOLORLISTBOX,\r
+ //CN_CTLCOLORMSGBOX,\r
+ //CN_CTLCOLORSCROLLBAR,\r
+ //CN_CTLCOLORSTATIC,\r
+ //CN_DELETEITEM,\r
+ //CN_DRAWITEM,\r
+ CN_HSCROLL,\r
+ //CN_MEASUREITEM,\r
+ //CN_PARENTNOTIFY,\r
+ //CN_VKEYTOITEM,\r
+ CN_VSCROLL,\r
+ CN_KEYDOWN,\r
+ CN_KEYUP,\r
+ CN_CHAR,\r
+ CN_SYSKEYUP,\r
+ CN_SYSKEYDOWN,\r
+ CN_SYSCHAR,\r
+ CN_NOTIFY:\r
+ begin\r
+ if Assigned(fTarget) then\r
+ Message.Result := fTarget.Perform(Message.msg, Message.wParam, Message.lParam);\r
+ end;\r
+ end;\r
+ inherited WndProc(Message);\r
+end;\r
+\r
+{$endregion}\r
+\r
+function CreateOpenGLContextAttrList(UseFB: boolean; pf: TglcContextPixelFormatSettings): TGLIntArray;\r
+var\r
+ p: integer;\r
+\r
+ procedure Add(i: integer);\r
+ begin\r
+ SetLength(Result, p+1);\r
+ Result[p]:=i;\r
+ inc(p);\r
+ end;\r
+\r
+ procedure CreateList;\r
+ begin\r
+ if UseFB then begin Add(GLX_X_RENDERABLE); Add(1); end;\r
+ if pf.DoubleBuffered then begin\r
+ if UseFB then begin\r
+ Add(GLX_DOUBLEBUFFER); Add(1);\r
+ end else\r
+ Add(GLX_DOUBLEBUFFER);\r
+ end;\r
+ if not UseFB and (pf.ColorBits>24) then Add(GLX_RGBA);\r
+ if UseFB then begin\r
+ Add(GLX_DRAWABLE_TYPE);\r
+ Add(GLX_WINDOW_BIT);\r
+ end;\r
+ Add(GLX_RED_SIZE); Add(8);\r
+ Add(GLX_GREEN_SIZE); Add(8);\r
+ Add(GLX_BLUE_SIZE); Add(8);\r
+ if pf.ColorBits>24 then\r
+ Add(GLX_ALPHA_SIZE); Add(8);\r
+ Add(GLX_DEPTH_SIZE); Add(pf.DepthBits);\r
+ Add(GLX_STENCIL_SIZE); Add(pf.StencilBits);\r
+ Add(GLX_AUX_BUFFERS); Add(pf.AUXBuffers);\r
+\r
+ if pf.MultiSampling > 1 then begin\r
+ Add(GLX_SAMPLE_BUFFERS_ARB); Add(1);\r
+ Add(GLX_SAMPLES_ARB); Add(pf.MultiSampling);\r
+ end;\r
+\r
+ Add(0); { 0 = X.None (be careful: GLX_NONE is something different) }\r
+ end;\r
+\r
+begin\r
+ SetLength(Result, 0);\r
+ p:=0;\r
+ CreateList;\r
+end;\r
+\r
+function FBglXChooseVisual(dpy:PDisplay; screen:longint; attrib_list:Plongint):PXVisualInfo;\r
+type\r
+ PGLXFBConfig = ^GLXFBConfig;\r
+var\r
+ FBConfigsCount: integer;\r
+ FBConfigs: PGLXFBConfig;\r
+ FBConfig: GLXFBConfig;\r
+begin\r
+ Result:= nil;\r
+ FBConfigsCount:=0;\r
+ FBConfigs:= glXChooseFBConfig(dpy, screen, attrib_list, @FBConfigsCount);\r
+ if FBConfigsCount = 0 then\r
+ exit;\r
+\r
+ { just choose the first FB config from the FBConfigs list.\r
+ More involved selection possible. }\r
+ FBConfig := FBConfigs^;\r
+ Result:=glXGetVisualFromFBConfig(dpy, FBConfig);\r
+end;\r
+\r
+\r
+{ TglcContextGtk2GLX }\r
+\r
+procedure TglcContextGtk2GLX.UpdateVisual(const aControl: TWinControl);\r
+var\r
+ attrList: TGLIntArray;\r
+ drawable: PGdkDrawable;\r
+begin\r
+ if not Assigned(aControl) then\r
+ raise EArgumentException.Create('aControl is not assigned');\r
+\r
+ {\r
+ Temporary (realized) widget to get to display\r
+ }\r
+ FWidget:= {%H-}PGtkWidget(PtrUInt(aControl.Handle));\r
+ gtk_widget_realize(FWidget);\r
+ drawable:= GTK_WIDGET(FWidget)^.window;\r
+\r
+ FDisplay:= GDK_WINDOW_XDISPLAY(drawable);\r
+\r
+ {\r
+ Find a suitable visual from PixelFormat using GLX 1.3 FBConfigs or\r
+ old-style Visuals\r
+ }\r
+ if Assigned(glXChooseFBConfig) then begin\r
+ attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings);\r
+ FVisual := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+ if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin\r
+ fPixelFormatSettings.MultiSampling := 1;\r
+ attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings);\r
+ FVisual := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+ end;\r
+ end;\r
+ if not Assigned(FVisual) then begin\r
+ attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings);\r
+ FVisual := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+ if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin\r
+ fPixelFormatSettings.MultiSampling := 1;\r
+ attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings);\r
+ FVisual := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+ end;\r
+ end;\r
+ if not Assigned(FVisual) then\r
+ raise EGLXError.Create('choose visual failed');\r
+\r
+ {\r
+ Most widgets inherit the drawable of their parent. In contrast to Windows, descending from\r
+ TWinControl does not mean it's actually always a window of its own.\r
+ Famous example: TPanel is just a frame painted on a canvas.\r
+ Also, the LCL does somethin weird to colormaps in window creation, so we have\r
+ to use a custom widget here to have full control about visual selection.\r
+ }\r
+ FRenderControl:= TRenderControl.Create(aControl, FVisual^.visual^.visualid);\r
+ try\r
+ FRenderControl.Parent := aControl;\r
+ FRenderControl.HandleNeeded;\r
+ FRenderControl.Target := aControl;\r
+ except\r
+ FreeAndNil(FRenderControl);\r
+ raise;\r
+ end;\r
+\r
+ {\r
+ Real Widget handle, unrealized!!!\r
+ }\r
+ FWidget:= FRenderControl.Widget;\r
+ gtk_widget_realize(FWidget);\r
+ drawable:= GTK_WIDGET(FWidget)^.window;\r
+ FDisplay:= GDK_WINDOW_XDISPLAY(drawable);\r
+\r
+ // FRenderControl.Align:= alClient breaks the context or something\r
+ FRenderControl.BoundsRect := aControl.ClientRect;\r
+ FRenderControl.Anchors := [akLeft, akTop, akRight, akBottom];\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.OpenContext;\r
+var\r
+ Attribs: array of GLint;\r
+ tmpContext: GLXContext;\r
+ glxID: GLXDrawable;\r
+begin\r
+ inherited OpenContext;\r
+\r
+ if not Assigned(FVisual) then\r
+ raise EGLXError.Create('Failed to find Visual');\r
+\r
+ tmpContext := glXCreateContext(FDisplay, FVisual, nil, true);\r
+ if fUseVersion and\r
+ (fVersionSettings.Major <> GLC_CONTEXT_VERSION_UNKNOWN) and\r
+ (fVersionSettings.Minor <> GLC_CONTEXT_VERSION_UNKNOWN) then\r
+ begin\r
+ // Set attributes to describe our requested context\r
+ SetLength(Attribs, 5);\r
+ Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;\r
+ Attribs[1] := fVersionSettings.Major;\r
+ Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;\r
+ Attribs[3] := fVersionSettings.Minor;\r
+\r
+ // Add context flag for forward compatible context\r
+ // Forward compatible means no more support for legacy functions like\r
+ // immediate mode (glvertex, glrotate, gltranslate, etc.)\r
+ if fVersionSettings.ForwardCompatible then begin\r
+ SetLength(Attribs, Length(Attribs)+2);\r
+ Attribs[4] := WGL_CONTEXT_FLAGS_ARB;\r
+ Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;\r
+ end;\r
+\r
+ // Attribute flags must be finalized with a zero\r
+ SetLength(Attribs, 1);\r
+ Attribs[High(Attribs)] := 0;\r
+\r
+ glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+ glXMakeCurrent(FDisplay, glxID, tmpContext);\r
+ ReadImplementationProperties;\r
+ if not Assigned(glXCreateContextAttribsARB) or not GLX_ARB_create_context then begin\r
+ glXDestroyContext(FDisplay, tmpContext);\r
+ raise Exception.Create('GLX_ARB_create_context not supported');\r
+ end;\r
+ FContext := glXCreateContextAttribsARB(FDisplay, FVisual, nil, true, @Attribs[0]);\r
+\r
+ glXDestroyContext(FDisplay, tmpContext);\r
+ end else\r
+ FContext := tmpContext;\r
+\r
+ if (FContext = nil) then\r
+ raise EGLXError.Create('Failed to create Context');\r
+end;\r
+\r
+constructor TglcContextGtk2GLX.Create(const aControl: TWinControl;\r
+ const aPixelFormatSettings: TglcContextPixelFormatSettings);\r
+begin\r
+ inherited Create(aControl, aPixelFormatSettings);\r
+ UpdateVisual(aControl);\r
+end;\r
+\r
+constructor TglcContextGtk2GLX.Create(const aControl: TWinControl;\r
+ const aPixelFormatSettings: TglcContextPixelFormatSettings;\r
+ const aVersionSettings: TglcContextVersionSettings);\r
+begin\r
+ inherited Create(aControl, aPixelFormatSettings, aVersionSettings);\r
+ UpdateVisual(aControl);\r
+end;\r
+\r
+destructor TglcContextGtk2GLX.Destroy;\r
+begin\r
+ FreeAndNil(FRenderControl);\r
+ XFree(FVisual);\r
+ inherited Destroy;\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.CloseContext;\r
+begin\r
+ if not Assigned(FWidget) then exit;\r
+ if Assigned(FContext) then\r
+ glXDestroyContext(FDisplay, FContext);\r
+ FreeAndNil(FRenderControl);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Activate;\r
+var\r
+ glxID: GLXDrawable;\r
+begin\r
+ if not Assigned(FWidget) then exit;\r
+ // make sure the widget is realized\r
+ gtk_widget_realize(FWidget);\r
+ if not GTK_WIDGET_REALIZED(FWidget) then exit;\r
+\r
+ // make current\r
+ glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+ glXMakeCurrent(FDisplay, glxID, FContext);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Deactivate;\r
+var\r
+ glxID: GLXDrawable;\r
+begin\r
+ if not Assigned(FWidget) then exit;\r
+ glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+ glXMakeCurrent(FDisplay, glxID, nil);\r
+end;\r
+\r
+function TglcContextGtk2GLX.IsActive: boolean;\r
+var\r
+ glxID: GLXDrawable;\r
+begin\r
+ glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+ Result:= (FContext = glXGetCurrentContext()) and\r
+ Assigned(FWidget) and\r
+ (glxID = glXGetCurrentDrawable());\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.SwapBuffers;\r
+var\r
+ glxID: GLXDrawable;\r
+begin\r
+ if not Assigned(FWidget) then exit;\r
+ glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+ glXSwapBuffers(FDisplay, glxID);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.SetSwapInterval(const aInterval: GLint);\r
+var\r
+ drawable: PGdkDrawable;\r
+begin\r
+ drawable:= GTK_WIDGET(FWidget)^.window;\r
+ if GLX_EXT_swap_control then\r
+ glXSwapIntervalEXT(FDisplay, GDK_WINDOW_XWINDOW(drawable), aInterval);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Share(const aContext: TglcContext);\r
+begin\r
+ raise Exception.Create('not yet implemented');\r
+end;\r
+\r
+class function TglcContextGtk2GLX.{%H-}ChangeDisplaySettings(const aWidth, aHeight,\r
+ aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean;\r
+begin\r
+ raise Exception.Create('not yet implemented');\r
+end;\r
+\r
+class function TglcContextGtk2GLX.IsAnyContextActive: boolean;\r
+begin\r
+ Result:= (glXGetCurrentContext()<>nil) and (glXGetCurrentDrawable()<>0);\r
+end;\r
+\r
+end.\r
+\r
--- /dev/null
+unit uglcContextGtkCustomVisual;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält Klassen zum Erzeugen von Visuals (unter Linux),
+ auf denen ein OpenGL Kontext erstellt werden kann }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, Controls, LCLType, InterfaceBase, LMessages, WSLCLClasses, WSControls,
+ X, XLib, glib2, gdk2, gdk2x, gtk2, Gtk2Def, Gtk2Int;
+
+type
+ TCustomVisualControl = class(TWinControl)
+ private
+ FIntWidget: PGtkWidget;
+ FVisualID: TVisualID;
+ protected
+ function WSCreateHandle({%H-}const WSPrivate: TWSPrivateClass; const AParams: TCreateParams): TLCLIntfHandle;
+ procedure WSBeforeDestroyHandle;
+ public
+ constructor Create(TheOwner: TComponent; const aVisualID: TVisualID); overload;
+ property Widget: PGtkWidget read FIntWidget;
+ end;
+
+
+ TWSCustomVisualControl = class(TWSWinControl)
+ published
+ class function CreateHandle(const AWinControl: TWinControl;
+ const AParams: TCreateParams): TLCLIntfHandle; override;
+ class procedure DestroyHandle(const AWinControl: TWinControl); override;
+ end;
+
+
+implementation
+
+type
+ PGtkCustomWidget = ^TGtkCustomWidget;
+ TGtkCustomWidget = record
+ darea: TGtkDrawingArea;
+ end;
+
+ PGtkCustomWidgetClass = ^TGtkCustomWidgetClass;
+ TGtkCustomWidgetClass = record
+ parent_class: TGtkDrawingAreaClass;
+ end;
+
+var
+ custom_widget_type: TGtkType = 0;
+ custom_widget_parent_class: Pointer = nil;
+
+function GTK_TYPE_CUSTOM_WIDGET: TGtkType; forward;
+
+
+procedure g_return_if_fail(b: boolean; const Msg: string);
+begin
+ if not b then raise Exception.Create(Msg);
+end;
+
+procedure g_return_if_fail(b: boolean);
+begin
+ g_return_if_fail(b,'');
+end;
+
+function GTK_IS_CUSTOM_WIDGET(obj: Pointer): Boolean;
+begin
+ GTK_IS_CUSTOM_WIDGET:=GTK_CHECK_TYPE(obj,GTK_TYPE_CUSTOM_WIDGET);
+end;
+
+function GTK_CUSTOM_WIDGET(obj: Pointer): PGtkCustomWidget;
+begin
+ g_return_if_fail(GTK_IS_CUSTOM_WIDGET(obj),'');
+ Result:=PGtkCustomWidget(obj);
+end;
+
+procedure gtk_custom_widget_init(custom_widget: PGTypeInstance; theClass: gpointer); cdecl;
+begin
+ if theClass=nil then ;
+ //DebugLn(['gtk_custom_widget_init START']);
+ gtk_widget_set_double_buffered(PGtkWidget(custom_widget),gdkFALSE);
+ GTK_WIDGET_UNSET_FLAGS(PGtkWidget(custom_widget),GTK_NO_WINDOW);
+ //DebugLn(['gtk_custom_widget_init END']);
+end;
+
+procedure gtk_custom_widget_destroy(obj: PGtkObject); cdecl;
+begin
+ g_return_if_fail (obj <>nil,'');
+ g_return_if_fail (GTK_IS_CUSTOM_WIDGET(obj),'');
+
+ if Assigned(GTK_OBJECT_CLASS(custom_widget_parent_class)^.destroy) then
+ GTK_OBJECT_CLASS(custom_widget_parent_class)^.destroy(obj);
+end;
+
+procedure gtk_custom_widget_class_init(klass: Pointer); cdecl;
+var
+ object_class: PGtkObjectClass;
+begin
+ custom_widget_parent_class := gtk_type_class(gtk_drawing_area_get_type());
+ g_return_if_fail(custom_widget_parent_class<>nil,'gtk_custom_widget_class_init parent_class=nil');
+ object_class := PGtkObjectClass(klass);
+ g_return_if_fail(object_class<>nil,'gtk_custom_widget_class_init object_class=nil');
+
+ object_class^.destroy := @gtk_custom_widget_destroy;
+end;
+
+function custom_widget_size_allocateCB(Widget: PGtkWidget; Size: pGtkAllocation;
+ Data: gPointer): GBoolean; cdecl;
+const
+ CallBackDefaultReturn = {$IFDEF GTK2}false{$ELSE}true{$ENDIF};
+var
+ SizeMsg: TLMSize;
+ GtkWidth, GtkHeight: integer;
+ LCLControl: TWinControl;
+begin
+ Result := CallBackDefaultReturn;
+ if not GTK_WIDGET_REALIZED(Widget) then begin
+ // the widget is not yet realized, so this GTK resize was not a user change.
+ // => ignore
+ exit;
+ end;
+ if Size=nil then ;
+ LCLControl:=TWinControl(Data);
+ if LCLControl=nil then exit;
+ //DebugLn(['gtkglarea_size_allocateCB ',DbgSName(LCLControl)]);
+
+ gtk_widget_get_size_request(Widget, @GtkWidth, @GtkHeight);
+
+ SizeMsg.Msg:=0;
+ FillChar(SizeMsg,SizeOf(SizeMsg),0);
+ with SizeMsg do
+ begin
+ Result := 0;
+ Msg := LM_SIZE;
+ SizeType := Size_SourceIsInterface;
+ Width := SmallInt(GtkWidth);
+ Height := SmallInt(GtkHeight);
+ end;
+ //DebugLn(['gtkglarea_size_allocateCB ',GtkWidth,',',GtkHeight]);
+ LCLControl.WindowProc(TLMessage(SizeMsg));
+end;
+
+function GTK_TYPE_CUSTOM_WIDGET: TGtkType;
+const
+ custom_widget_type_name = 'GtkGLArea';
+ custom_widget_info: TGtkTypeInfo = (
+ type_name: custom_widget_type_name;
+ object_size: SizeOf(TGtkCustomWidget);
+ class_size: SizeOf(TGtkCustomWidgetClass);
+ class_init_func: @gtk_custom_widget_class_init;
+ object_init_func: @gtk_custom_widget_init;
+ reserved_1: nil;
+ reserved_2: nil;
+ base_class_init_func: nil;
+ );
+begin
+ if (custom_widget_type=0) then begin
+ custom_widget_type:=gtk_type_unique(gtk_drawing_area_get_type(),@custom_widget_info);
+ end;
+ Result:=custom_widget_type;
+end;
+
+{ TCustomVisualControl }
+
+constructor TCustomVisualControl.Create(TheOwner: TComponent; const aVisualID: TVisualID);
+begin
+ inherited Create(TheOwner);
+ FIntWidget:= nil;
+ fVisualID:= aVisualID;
+ SetBounds(0, 0, 200, 200);
+end;
+
+function TCustomVisualControl.WSCreateHandle(const WSPrivate: TWSPrivateClass; const AParams: TCreateParams): TLCLIntfHandle;
+var
+ cmap: PGdkColormap;
+ gdkvis: PGdkVisual;
+begin
+ // is the requested VisualID different from what the widget would get?
+ cmap := gdk_colormap_get_system;
+ gdkvis:= gdk_colormap_get_visual(cmap);
+ if XVisualIDFromVisual(gdk_x11_visual_get_xvisual(gdkvis)) <> FVisualID then begin
+ gdkvis:= gdkx_visual_get(FVisualID);
+ cmap := gdk_colormap_new(gdkvis, false);
+ end;
+
+ FIntWidget:= gtk_type_new(GTK_TYPE_CUSTOM_WIDGET);
+ gtk_widget_set_colormap(FIntWidget, cmap);
+
+ Result:= TLCLIntfHandle({%H-}PtrUInt(FIntWidget));
+ PGtkobject(FIntWidget)^.flags:= PGtkobject(FIntWidget)^.flags or GTK_CAN_FOCUS;
+ TGTK2WidgetSet(WidgetSet).FinishCreateHandle(Self,FIntWidget,AParams);
+ g_signal_connect_after(FIntWidget, 'size-allocate', TGTKSignalFunc(@custom_widget_size_allocateCB), Self);
+end;
+
+procedure TCustomVisualControl.WSBeforeDestroyHandle;
+begin
+ if not HandleAllocated then exit;
+end;
+
+
+{ TWSCustomVisualControl }
+
+class function TWSCustomVisualControl.CreateHandle(const AWinControl: TWinControl; const AParams: TCreateParams): TLCLIntfHandle;
+begin
+ if csDesigning in AWinControl.ComponentState then begin
+ // do not use "inherited CreateHandle", because the LCL changes the hierarchy at run time
+ Result:= TWSWinControlClass(ClassParent).CreateHandle(AWinControl,AParams);
+ end else
+ Result:= (AWinControl as TCustomVisualControl).WSCreateHandle(WSPrivate, AParams);
+end;
+
+class procedure TWSCustomVisualControl.DestroyHandle(const AWinControl: TWinControl);
+begin
+ (AWinControl as TCustomVisualControl).WSBeforeDestroyHandle;
+ // do not use "inherited DestroyHandle", because the LCL changes the hierarchy at run time
+ TWSWinControlClass(ClassParent).DestroyHandle(AWinControl);
+end;
+
+initialization
+ RegisterWSComponent(TCustomVisualControl,TWSCustomVisualControl);
+
+end.
+
--- /dev/null
+unit uglcContextWGL;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Kontexte für Windows
+ Hint: diese Unit sollte niemals direkt genutzt werden (siehe uglcContext) }
+
+interface
+
+uses
+ Classes, SysUtils, Forms, Windows, uglcContext, dglOpenGL, Controls;
+
+type
+ EWGLError = class(EGLError);
+
+ { TglcContextWGL }
+
+ TglcContextWGL = class(TglcContext)
+ private
+ FDC: HDC;
+ FRC: HGLRC;
+ fHandle: THandle;
+ fPixelFormat: Integer;
+ {%H-}constructor Create(const aControl: TWinControl); overload;
+ protected
+ procedure UpdatePixelFormat;
+ procedure OpenContext; override;
+ function FindPixelFormat: Integer;
+ function FindPixelFormatNoAA: Integer;
+ procedure OpenFromPF(PixelFormat: Integer);
+ public
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); overload; override;
+ constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); overload; override;
+
+ procedure CloseContext; override;
+ procedure Activate; override;
+ procedure Deactivate; override;
+ function IsActive: boolean; override;
+ procedure SwapBuffers; override;
+ procedure SetSwapInterval(const aInterval: GLint); override;
+ function GetSwapInterval: GLint; override;
+ procedure Share(const aContext: TglcContext); override;
+
+ class function ChangeDisplaySettings(const aWidth, aHeight, aBitPerPixel, aFreq: Integer;
+ const aFlags: TglcDisplayFlags): Boolean; override;
+ class function IsAnyContextActive: boolean; override;
+ end;
+
+implementation
+
+{ TglcContextWGL }
+
+constructor TglcContextWGL.Create(const aControl: TWinControl);
+begin
+ inherited Create(aControl, MakePF());
+ fHandle := aControl.Handle;
+end;
+
+procedure TglcContextWGL.UpdatePixelFormat;
+begin
+ fPixelFormat := FindPixelFormat;
+ if (fPixelFormat = 0) then begin
+ // try without MS
+ fPixelFormatSettings.MultiSampling := 1;
+ fPixelFormat := FindPixelFormat;
+ end;
+end;
+
+procedure TglcContextWGL.OpenContext;
+begin
+ inherited OpenContext;
+ OpenFromPF(fPixelFormat);
+end;
+
+function TglcContextWGL.FindPixelFormat: Integer;
+var
+ OldRC: HGLRC; OldDC: HDC;
+ tmpWnd: TForm;
+ tmpContext: TglcContextWGL;
+ pf, i, max: integer;
+ Count: GLuint;
+ PFList, SampleList: array[0..31] of GLint;
+
+ procedure ChoosePF(pPFList, pSampleList: PGLint; MaxCount: integer);
+ var
+ //ARB_Erweiterung vorhanden
+ //| EXT_Erweiterung vorhanden
+ MultiARBSup, MultiEXTSup: Boolean;
+ //Liste der Integer Attribute
+ IAttrib: array[0..22] of GLint;
+ //Liste der Float Attribute (nur 0, da kein Wert)
+ FAttrib: GLFloat;
+ QueryAtrib, i: Integer;
+ PPosiblePF, PSample: PglInt;
+ begin
+ //Pixelformate mit AA auslesen
+ MultiARBSup := false;
+ MultiEXTSup := false;
+ if WGL_ARB_extensions_string and
+ WGL_ARB_pixel_format and
+ (WGL_ARB_MULTISAMPLE or GL_ARB_MULTISAMPLE) then
+ multiARBSup := true;
+ if WGL_EXT_extensions_string and
+ WGL_EXT_pixel_format and
+ (WGL_EXT_MULTISAMPLE or GL_EXT_MULTISAMPLE) then
+ multiEXTSup := true;
+
+ if multiARBSup then
+ Read_WGL_ARB_pixel_format
+ else if multiEXTSup then
+ Read_WGL_EXT_pixel_format;
+
+ if not (MultiARBSup or MultiEXTSup) then
+ exit;
+
+ IAttrib[00] := WGL_DRAW_TO_WINDOW_ARB;
+ IAttrib[01] := 1;
+
+ IAttrib[02] := WGL_SUPPORT_OPENGL_ARB;
+ IAttrib[03] := 1;
+
+ IAttrib[04] := WGL_DOUBLE_BUFFER_ARB;
+ if (fPixelFormatSettings.DoubleBuffered) then
+ IAttrib[05] := 1
+ else
+ IAttrib[05] := 0;
+
+ IAttrib[06] := WGL_PIXEL_TYPE_ARB;
+ IAttrib[07] := WGL_TYPE_RGBA_ARB;
+
+ IAttrib[08] := WGL_COLOR_BITS_ARB;
+ IAttrib[09] := fPixelFormatSettings.ColorBits;
+
+ IAttrib[10] := WGL_ALPHA_BITS_ARB;
+ IAttrib[11] := 0; //TODO: fPixelFormatSettings.AlphaBits;
+
+ IAttrib[12] := WGL_DEPTH_BITS_ARB;
+ IAttrib[13] := fPixelFormatSettings.DepthBits;
+
+ IAttrib[14] := WGL_STENCIL_BITS_ARB;
+ IAttrib[15] := fPixelFormatSettings.StencilBits;
+
+ IAttrib[16] := WGL_ACCUM_BITS_ARB;
+ IAttrib[17] := fPixelFormatSettings.AccumBits;
+
+ IAttrib[18] := WGL_AUX_BUFFERS_ARB;
+ IAttrib[19] := fPixelFormatSettings.AuxBuffers;
+
+ IAttrib[20] := WGL_SAMPLE_BUFFERS_ARB;
+ IAttrib[21] := 1;
+
+ IAttrib[22] := 0;
+ FAttrib := 0;
+
+ if multiARBSup then
+ wglChoosePixelFormatARB(tmpContext.FDC, @IAttrib[0], @FAttrib, MaxCount, pPFList, @Count)
+ else if multiEXTSup then
+ wglChoosePixelFormatEXT(tmpContext.FDC, @IAttrib[0], @FAttrib, MaxCount, pPFList, @Count);
+
+ if Count > length(PFList) then
+ Count := length(PFList);
+
+ QueryAtrib := WGL_SAMPLES_ARB;
+ PSample := pSampleList;
+ PPosiblePF := @PFList[0];
+ for i := 0 to Count-1 do begin
+ if multiARBSup then
+ wglGetPixelFormatAttribivARB(tmpContext.FDC, PPosiblePF^, 0, 1, @QueryAtrib, PSample)
+ else if multiEXTSup then
+ wglGetPixelFormatAttribivEXT(tmpContext.FDC, PPosiblePF^, 0, 1, @QueryAtrib, PSample);
+ inc(PSample);
+ inc(PPosiblePF);
+ end;
+ end;
+begin
+ if (fPixelFormatSettings.MultiSampling = 1) then begin
+ Result := FindPixelFormatNoAA;
+ exit;
+ end;
+ Result := 0;
+ OldDC := wglGetCurrentDC();
+ OldRC := wglGetCurrentContext();
+ try
+ tmpWnd := TForm.Create(nil);
+ tmpContext := TglcContextWGL.Create(tmpWnd);
+ try
+ pf := tmpContext.FindPixelFormatNoAA;
+ tmpContext.OpenFromPF(pf);
+ tmpContext.Activate;
+
+ FillChar({%H-}PFList[0], Length(PFList), 0);
+ FillChar({%H-}SampleList[0], Length(SampleList), 0);
+ ChoosePF(@PFList[0], @SampleList[0], length(SampleList));
+ max := 0;
+ for i := 0 to Count-1 do begin
+ if (max < SampleList[i]) and (SampleList[i] <= fPixelFormatSettings.MultiSampling) and (PFList[i] <> 0) then begin
+ max := SampleList[i];
+ result := PFList[i];
+ if (max = fPixelFormatSettings.MultiSampling) then
+ break;
+ end;
+ end;
+ tmpContext.Deactivate;
+ finally
+ FreeAndNil(tmpContext);
+ FreeAndNil(tmpWnd);
+ end;
+ finally
+ if (OldDC <> 0) and (OldRC <> 0) then
+ ActivateRenderingContext(OldDC, OldRC);
+ end;
+end;
+
+function TglcContextWGL.FindPixelFormatNoAA: Integer;
+const
+ MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
+var
+ //DeviceContext
+ DC: HDC;
+ //Objekttyp des DCs
+ AType: DWord;
+ //Beschreibung zum passenden Pixelformat
+ PFDescriptor: TPixelFormatDescriptor;
+begin
+ result := 0;
+ DC := GetDC(fHandle);
+ if DC = 0 then begin
+ exit;
+ end;
+ FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), #0);
+ with PFDescriptor do begin
+ nSize := SizeOf(PFDescriptor);
+ nVersion := 1;
+ dwFlags := PFD_SUPPORT_OPENGL;
+ AType := GetObjectType(DC);
+ if AType = 0 then begin
+ exit;
+ end;
+ if fPixelFormatSettings.DoubleBuffered then
+ dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+ if fPixelFormatSettings.Stereo then
+ dwFlags := dwFlags or PFD_STEREO;
+ if AType in MemoryDCs then
+ dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+ else
+ dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+ iPixelType := PFD_TYPE_RGBA;
+ cColorBits := fPixelFormatSettings.ColorBits;
+//TODO: cAlphaBits := fPixelFormatSettings.AlphaBits;
+ cDepthBits := fPixelFormatSettings.DepthBits;
+ cStencilBits := fPixelFormatSettings.StencilBits;
+ cAccumBits := fPixelFormatSettings.AccumBits;
+ cAuxBuffers := fPixelFormatSettings.AuxBuffers;
+
+ if fPixelFormatSettings.Layer = 0 then
+ iLayerType := PFD_MAIN_PLANE
+ else if fPixelFormatSettings.Layer > 0 then
+ iLayerType := PFD_OVERLAY_PLANE
+ else
+ iLayerType := Byte(PFD_UNDERLAY_PLANE);
+ end;
+ result := ChoosePixelFormat(DC, @PFDescriptor);
+end;
+
+procedure TglcContextWGL.OpenFromPF(PixelFormat: Integer);
+var
+ tmpRC: HGLRC;
+ Attribs: array of GLint;
+ CreateContextAttribs: TwglCreateContextAttribsARB;
+begin
+ if PixelFormat = 0 then begin
+ raise EWGLError.Create('Invalid PixelFormat');
+ end;
+
+ FDC := GetDC(fHandle);
+ if FDC = 0 then begin
+ raise EWGLError.CreateFmt('Cannot create DC on %x',[fHandle]);
+ end;
+
+ if not SetPixelFormat(FDC, PixelFormat, nil) then begin
+ ReleaseDC(fHandle, FDC);
+ raise EWGLError.CreateFmt('Cannot set PF %d on Control %x DC %d',[PixelFormat, fHandle, FDC]);
+ end;
+
+ tmpRC := wglCreateContext(FDC);
+ if tmpRC = 0 then begin
+ ReleaseDC(fHandle, FDC);
+ raise EWGLError.CreateFmt('Cannot create context on Control %x DC %d',[PixelFormat, fHandle, FDC]);
+ end;
+
+ if fUseVersion and
+ (fVersionSettings.Major <> GLC_CONTEXT_VERSION_UNKNOWN) and
+ (fVersionSettings.Minor <> GLC_CONTEXT_VERSION_UNKNOWN) then
+ begin
+ { Code from dglOpenGL.pas (modified) }
+ wglMakeCurrent(FDC, tmpRC);
+
+ // Set attributes to describe our requested context
+ SetLength(Attribs, 5);
+ Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;
+ Attribs[1] := fVersionSettings.Major;
+ Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;
+ Attribs[3] := fVersionSettings.Minor;
+
+ // Add context flag for forward compatible context
+ // Forward compatible means no more support for legacy functions like
+ // immediate mode (glvertex, glrotate, gltranslate, etc.)
+ if fVersionSettings.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
+ CreateContextAttribs := TwglCreateContextAttribsARB(wglGetProcAddress('wglCreateContextAttribsARB'));
+ if not Assigned(CreateContextAttribs) then begin
+ wglMakeCurrent(0, 0);
+ wglDeleteContext(tmpRC);
+ ReleaseDC(fHandle, FDC);
+ raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!');
+ end;
+
+ // Create context
+ FRC := CreateContextAttribs(FDC, 0, @Attribs[0]);
+ if (FRC = 0) then begin
+ wglMakeCurrent(0, 0);
+ wglDeleteContext(tmpRC);
+ ReleaseDC(fHandle, FDC);
+ raise Exception.Create('Could not create the desired OpenGL rendering context!');
+ end;
+
+ wglMakeCurrent(0, 0);
+ wglDeleteContext(tmpRC);
+ end else
+ FRC := tmpRC;
+end;
+
+constructor TglcContextWGL.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings);
+begin
+ inherited Create(aControl, aPixelFormatSettings);
+ fHandle := aControl.Handle;
+ UpdatePixelFormat;
+end;
+
+constructor TglcContextWGL.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings);
+begin
+ inherited Create(aControl, aPixelFormatSettings, aVersionSettings);
+ fHandle := aControl.Handle;
+ UpdatePixelFormat;
+end;
+
+procedure TglcContextWGL.CloseContext;
+begin
+ if (FRC <> 0) then begin
+ Deactivate;
+ DestroyRenderingContext(FRC);
+ ReleaseDC(fHandle, FDC);
+ FRC := 0;
+ FDC := 0;
+ end;
+end;
+
+procedure TglcContextWGL.Activate;
+begin
+ ActivateRenderingContext(FDC, FRC);
+end;
+
+procedure TglcContextWGL.Deactivate;
+begin
+ if wglGetCurrentContext()=FRC then
+ DeactivateRenderingContext;
+end;
+
+function TglcContextWGL.IsActive: boolean;
+begin
+ Result:= (FRC <> 0) and
+ (FRC = wglGetCurrentContext()) and
+ (FDC = wglGetCurrentDC());
+end;
+
+procedure TglcContextWGL.SwapBuffers;
+begin
+ Windows.SwapBuffers(FDC);
+end;
+
+procedure TglcContextWGL.SetSwapInterval(const aInterval: GLint);
+begin
+ wglSwapIntervalEXT(aInterval);
+end;
+
+function TglcContextWGL.GetSwapInterval: GLint;
+begin
+ result := wglGetSwapIntervalEXT();
+end;
+
+procedure TglcContextWGL.Share(const aContext: TglcContext);
+begin
+ wglShareLists(FRC, (aContext as TglcContextWGL).FRC);
+end;
+
+class function TglcContextWGL.ChangeDisplaySettings(const aWidth, aHeight,
+ aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean;
+var
+ dm: TDeviceMode;
+ flags: Cardinal;
+begin
+ FillChar(dm{%H-}, SizeOf(dm), 0);
+ with dm do begin
+ dmSize := SizeOf(dm);
+ dmPelsWidth := aWidth;
+ dmPelsHeight := aHeight;
+ dmDisplayFrequency := aFreq;
+ dmBitsPerPel := aBitPerPixel;
+ dmFields := DM_PELSWIDTH or DM_PELSHEIGHT or DM_BITSPERPEL or DM_DISPLAYFREQUENCY;
+ end;
+ flags := 0; //CDS_TEST;
+ if (dfFullscreen in aFlags) then
+ flags := flags or CDS_FULLSCREEN;
+ result := (Windows.ChangeDisplaySettings(dm, flags) = DISP_CHANGE_SUCCESSFUL);
+end;
+
+class function TglcContextWGL.IsAnyContextActive: boolean;
+begin
+ Result:= (wglGetCurrentContext()<>0) and (wglGetCurrentDC()<>0);
+end;
+
+end.
+
--- /dev/null
+unit uglcFrameBufferObject;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL FrameBufferObjekte
+ Beispiel:
+ var
+ fbo: TglcFrameBufferObject;
+ tex: TglcTextureBuffer;
+ buf: TglcRenderBuffer;
+
+ fbo := TglcFrameBufferObject.Create;
+ try
+ ffbo.SetSize(800, 600);
+
+ // creating texture buffer as color buffer
+ tex := TglcTextureBuffer.Create(TglcFormat.fmRGBA, TglcInternalFormat.ifRGBA16F);
+ fbo.AddBuffer(tex, TglcAttachment.atColor0, true);
+
+ // creating render buffer as depth buffer
+ buf := TglcRenderBuffer.Create(TglcInternalFormat.ifDepthComponent);
+ fbo.AddBuffer(buf, TglcAttachment.atDepth, true);
+
+ // render to frame buffer object
+ fbo.Bind;
+ // do normal rendering
+ fbo.Unbind;
+
+ // use texture buffer
+ tex.Bind;
+ // do normal rendering
+ tex.Unbind;
+ finally
+ FreeAndNil(fbo);
+ end; }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, fgl, {$IFNDEF OPENGL_ES}dglOpenGl{$ELSE}dglOpenGLES{$ENDIF}, uglcTypes;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcBufferType = (btRenderBuffer, btTextureBuffer);
+ TglcBuffer = class(TObject)
+ private
+ fBufferType: TglcBufferType;
+ fWidth: Integer;
+ fHeight: Integer;
+
+ procedure SetWidth(const aValue: Integer);
+ procedure SetHeight(const aValue: Integer);
+ public
+ property Width : Integer read fWidth write SetWidth;
+ property Height: Integer read fHeight write SetHeight;
+ property BufferType: TglcBufferType read fBufferType;
+
+ procedure SetSize(const aWidth, aHeight: Integer); virtual;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglcRenderBuffer = class(Exception);
+ TglcRenderBuffer = class(TglcBuffer)
+ private
+ fID: gluInt;
+ fFormat: TglcInternalFormat;
+
+ procedure UpdateRenderBufferStorage;
+ procedure SetFormat(const aValue: TglcInternalFormat);
+ public
+ property ID: gluInt read fID;
+ property Format: TglcInternalFormat read fFormat write SetFormat;
+
+ procedure SetSize(const aWidth, aHeight: Integer); override;
+ procedure Bind;
+ procedure Unbind;
+
+ constructor Create(const aFormat: TglcInternalFormat);
+ destructor Destroy; override;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglcTextureBuffer = class(exception);
+ TglcTextureBuffer = class(TglcBuffer)
+ private
+ fID: GLuint;
+ fFormat: TglcFormat;
+ fInternalFormat: TglcInternalFormat;
+ fBorder: Boolean;
+
+ procedure UpdateTexImage;
+ procedure SetFormat(const aValue: TglcFormat);
+ procedure SetInternalFormat(const aValue: TglcInternalFormat);
+ procedure SetBorder(const aValue: Boolean);
+ public
+ property ID : GLuint read fID;
+ property Border : Boolean read fBorder write SetBorder;
+ property Format : TglcFormat read fFormat write SetFormat;
+ property InternalFormat: TglcInternalFormat read fInternalFormat write SetInternalFormat;
+
+ procedure SetSize(const aWidth, aHeight: Integer); override;
+ procedure Bind(const aEnableTextureUnit: Boolean = true);
+ procedure Unbind(const aDisableTextureUnit: Boolean = true);
+
+ constructor Create(const aFormat: TglcFormat; const aInternalFormat: TglcInternalFormat);
+ destructor Destroy; override;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglcFrameBufferObject = class(Exception);
+ TglcFrameBufferObject = class(TObject)
+ private type
+ TglcAttachmentContainer = class(TObject)
+ Buffer: TglcBuffer;
+ Attachment: TglcAttachment;
+ OwnsObject: Boolean;
+ constructor Create(const aBuffer: TglcBuffer; const aAttachment: TglcAttachment; const aOwnsObject: Boolean = true);
+ destructor Destroy; override;
+ end;
+ TglcAttachmentContainerList = specialize TFPGObjectList<TglcAttachmentContainer>;
+ private
+ fID: GLuint;
+ fOwnsObjects: Boolean;
+ fWidth: Integer;
+ fHeight: Integer;
+ fBuffers: TglcAttachmentContainerList;
+{$IFDEF OPENGL_ES}
+ fOldViewport: array[0..3] of GLint;
+{$ENDIF}
+
+ function GetBuffer(const aIndex: Integer): TglcBuffer;
+ procedure SetBuffer(const aIndex: Integer; const aValue: TglcBuffer);
+
+ function GetAttachment(const aIndex: Integer): TglcAttachment;
+ procedure SetAttachment(const aIndex: Integer; const aValue: TglcAttachment);
+
+ function GetBufferCount: Integer;
+
+ procedure Attach(const aIndex: Integer);
+ procedure Detach(const aIndex: Integer);
+
+ procedure SetWidth(const aValue: Integer);
+ procedure SetHeight(const aValue: Integer);
+ procedure CheckFrameBufferStatus;
+ procedure UpdateAndCheckFBO;
+ public
+ property ID : GLuint read fID;
+ property Count : Integer read GetBufferCount;
+ property OwnsObjects: Boolean read fOwnsObjects;
+ property Width : Integer read fWidth write SetWidth;
+ property Height : Integer read fHeight write SetHeight;
+ property Attachments[const aIndex: Integer]: TglcAttachment read GetAttachment write SetAttachment;
+ property Buffers [const aIndex: Integer]: TglcBuffer read GetBuffer write SetBuffer;
+
+ procedure AddBuffer(const aBuffer: TglcBuffer; const aAttachment: TglcAttachment; const aOwnsBuffer: Boolean = true);
+ procedure DelBuffer(const aIndex: Integer);
+ function RemBuffer(const aBuffer: TglcBuffer): Integer;
+ function IndexOfBuffer(const aBuffer: TglcBuffer): Integer;
+
+ procedure SetSize(const aWidth, aHeight: Integer);
+ function CheckAttachment(const aAttachment: TglcAttachment): Boolean;
+
+ procedure Bind(const aSetViewport: Boolean = true);
+ procedure Unbind(const aResetViewport: Boolean = true);
+
+ constructor Create(const aOwnBuffers: Boolean = true);
+ destructor Destroy; override;
+ end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcBuffer////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetWidth(const aValue: Integer);
+begin
+ SetSize(aValue, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetHeight(const aValue: Integer);
+begin
+ SetSize(fWidth, aValue);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+ fWidth := aWidth;
+ fHeight := aHeight;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcRenderBuffer//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.UpdateRenderBufferStorage;
+begin
+ glGetError; //clear Erroros
+ Bind;
+ glRenderbufferStorage(GL_RENDERBUFFER, GLenum(fFormat), fWidth, fHeight);
+ Unbind;
+ glcCheckAndRaiseError;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.SetFormat(const aValue: TglcInternalFormat);
+begin
+ fFormat := aValue;
+ UpdateRenderBufferStorage;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+ if (aWidth <= 0) or (aHeight <= 0) then
+ raise EglcRenderBuffer.Create('invalid width or height');
+ if (aWidth <> fWidth) or (aHeight <> fHeight) then begin
+ inherited SetSize(aWidth, aHeight);
+ UpdateRenderBufferStorage;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.Bind;
+begin
+ glBindRenderbuffer(GL_RENDERBUFFER, fID);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.Unbind;
+begin
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcRenderBuffer.Create(const aFormat: TglcInternalFormat);
+begin
+ inherited Create;
+ fBufferType := btRenderBuffer;
+ glGenRenderbuffers(1, @fID);
+ fFormat := aFormat;
+ SetSize(64, 64);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcRenderBuffer.Destroy;
+begin
+ glDeleteRenderbuffers(1, @fID);
+ inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcTextureBuffer/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.UpdateTexImage;
+begin
+ glGetError; //clear errors
+ Bind(false);
+ glTexImage2D(GL_TEXTURE_2D, 0, GLenum(fInternalFormat), fWidth, fHeight, GLint(Byte(fBorder) and Byte(1)), GLenum(fFormat), GL_UNSIGNED_BYTE, nil);
+ Unbind(false);
+ glcCheckAndRaiseError;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetFormat(const aValue: TglcFormat);
+begin
+ if (fFormat <> aValue) then begin
+ fFormat := aValue;
+ UpdateTexImage;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetInternalFormat(const aValue: TglcInternalFormat);
+begin
+ if (fInternalFormat <> aValue) then begin
+ fInternalFormat := aValue;
+ UpdateTexImage;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetBorder(const aValue: Boolean);
+begin
+ if (fBorder <> aValue) then begin
+ fBorder := aValue;
+ UpdateTexImage;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+ if (aWidth <= 0) or (aHeight <= 0) then
+ raise EglcTextureBuffer.Create('invalid width or height');
+ if (aWidth <> fWidth) or (aHeight <> fHeight) then begin
+ inherited SetSize(aWidth, aHeight);
+ UpdateTexImage;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.Bind(const aEnableTextureUnit: Boolean = true);
+begin
+ if aEnableTextureUnit then
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, fID);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.Unbind(const aDisableTextureUnit: Boolean = true);
+begin
+ if aDisableTextureUnit then
+ glDisable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcTextureBuffer.Create(const aFormat: TglcFormat; const aInternalFormat: TglcInternalFormat);
+begin
+ inherited Create;
+ fBufferType := btTextureBuffer;
+
+ glGenTextures(1, @fID);
+ Bind(false);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, {$IFNDEF OPENGL_ES}GL_CLAMP{$ELSE}GL_CLAMP_TO_EDGE{$ENDIF});
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, {$IFNDEF OPENGL_ES}GL_CLAMP{$ELSE}GL_CLAMP_TO_EDGE{$ENDIF});
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ Unbind(false);
+
+ fFormat := aFormat;
+ fInternalFormat := aInternalFormat;
+ SetSize(64, 64);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcTextureBuffer.Destroy;
+begin
+ glDeleteTextures(1, @fID);
+ inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcAttachment////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcFrameBufferObject.TglcAttachmentContainer.Create(const aBuffer: TglcBuffer;
+ const aAttachment: TglcAttachment; const aOwnsObject: Boolean);
+begin
+ inherited Create;
+ Buffer := aBuffer;
+ Attachment := aAttachment;
+ OwnsObject := aOwnsObject;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcFrameBufferObject.TglcAttachmentContainer.Destroy;
+begin
+ if OwnsObject then
+ Buffer.Free;
+ inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcFrameBufferObject/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetBuffer(const aIndex: Integer): TglcBuffer;
+begin
+ if (aIndex >= 0) and (aIndex < fBuffers.Count) then
+ result := fBuffers[aIndex].Buffer
+ else
+ raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.SetBuffer(const aIndex: Integer; const aValue: TglcBuffer);
+begin
+ if (aIndex < 0) or (aIndex >= fBuffers.Count) then
+ raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+
+ if not Assigned(aValue) then
+ raise EglcFrameBufferObject.Create('invalid buffer');
+
+ Detach(aIndex);
+ fBuffers[aIndex].Buffer := aValue;
+ Attach(aIndex);
+ UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetAttachment(const aIndex: Integer): TglcAttachment;
+begin
+ if (aIndex >= 0) and (aIndex < fBuffers.Count) then
+ result := fBuffers[aIndex].Attachment
+ else
+ raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.SetAttachment(const aIndex: Integer; const aValue: TglcAttachment);
+begin
+ if (aIndex < 0) or (aIndex >= fBuffers.Count) then
+ raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+
+ if not CheckAttachment(aValue) then
+ raise EglcFrameBufferObject.Create('Attachment already assigned');
+
+ Detach(aIndex);
+ fBuffers[aIndex].Attachment := aValue;
+ Attach(aIndex);
+ UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.Attach(const aIndex: Integer);
+var
+ a: TglcAttachment;
+ b: TglcBuffer;
+begin
+ a := Attachments[aIndex];
+ b := Buffers[aIndex];
+ Bind(false);
+ if (b.BufferType = btRenderBuffer) then
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GLenum(a), GL_RENDERBUFFER, (b as TglcRenderBuffer).ID)
+ else
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GLenum(a), GL_TEXTURE_2D, (b as TglcTextureBuffer).ID, 0);
+ Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.Detach(const aIndex: Integer);
+var
+ a: TglcAttachment;
+ b: TglcBuffer;
+begin
+ a := Attachments[aIndex];
+ b := Buffers[aIndex];
+ Bind(false);
+ if (b.BufferType = btRenderBuffer) then
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GLenum(a), GL_RENDERBUFFER, 0)
+ else
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GLenum(a), GL_TEXTURE_2D, 0, 0);
+ Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die neue Breite fest
+//@Value: Breite;
+procedure TglcFrameBufferObject.SetWidth(const aValue: Integer);
+begin
+ SetSize(aValue, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die neue Höhe fest
+//@Value: neue Höhe;
+procedure TglcFrameBufferObject.SetHeight(const aValue: Integer);
+begin
+ SetSize(fWidth, aValue);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.CheckFrameBufferStatus;
+begin
+ case glCheckFramebufferStatus(GL_FRAMEBUFFER) of
+ GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+ raise EglcFrameBufferObject.Create('Incomplete attachment');
+ GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+ raise EglcFrameBufferObject.Create('Missing attachment');
+{$IFNDEF OPENGL_ES}
+ GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
+ raise EglcFrameBufferObject.Create('Incomplete dimensions');
+ GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
+ raise EglcFrameBufferObject.Create('Incomplete formats');
+ GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+ raise EglcFrameBufferObject.Create('Incomplete draw buffer');
+ GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+ raise EglcFrameBufferObject.Create('Incomplete read buffer');
+{$ENDIF}
+ GL_FRAMEBUFFER_UNSUPPORTED:
+ raise EglcFrameBufferObject.Create('Framebufferobjects unsupported');
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//prüft das FrameBufferObjekt auf Fehler
+procedure TglcFrameBufferObject.UpdateAndCheckFBO;
+
+ function IsColorAttachment(const a: TglcAttachment): Boolean;
+ begin
+ result := (GLenum(a) >= GL_COLOR_ATTACHMENT0) and (GLenum(a) <= GL_COLOR_ATTACHMENT15);
+ end;
+
+var
+ buff: array of GLenum;
+{$IFNDEF OPENGL_ES}
+ b: GLboolean;
+{$ENDIF}
+ i: Integer;
+begin
+ if (fBuffers.Count = 0) then
+ exit;
+ Bind(false);
+
+ //find ColorBuffers
+ SetLength(buff, 0);
+ for i := 0 to fBuffers.Count-1 do
+ if IsColorAttachment(fBuffers[i].Attachment) then begin
+ SetLength(buff, Length(buff) + 1);
+ buff[High(buff)] := GLenum(fBuffers[i].Attachment);
+ end;
+
+ //set Read and Draw Buffer
+ if (Length(buff) = 0) then begin
+ glReadBuffer(GL_NONE);
+{$IFNDEF OPENGL_ES}
+ glDrawBuffer(GL_NONE);
+{$ELSE}
+ SetLength(buff, 1);
+ buff[0] := GL_NONE;
+ glDrawBuffers(1, @buff[0]);
+{$ENDIF}
+ end else begin
+ glDrawBuffers(Length(buff), @buff[0]);
+{$IFNDEF OPENGL_ES}
+ glGetBooleanv(GL_DOUBLEBUFFER, @b);
+ if b then
+ glReadBuffer(GL_BACK)
+ else
+ glReadBuffer(GL_FRONT);
+{$ELSE}
+ glReadBuffer(GL_FRONT);
+{$ENDIF}
+ end;
+ Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetBufferCount: Integer;
+begin
+ result := fBuffers.Count;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.AddBuffer(const aBuffer: TglcBuffer;
+ const aAttachment: TglcAttachment; const aOwnsBuffer: Boolean);
+begin
+ if not Assigned(aBuffer) then
+ raise EglcFrameBufferObject.Create('invalid buffer');
+ if not CheckAttachment(aAttachment) then
+ raise EglcFrameBufferObject.Create('attachment already assigned');
+
+ fBuffers.Add(TglcAttachmentContainer.Create(aBuffer, aAttachment, fOwnsObjects and aOwnsBuffer));
+ if OwnsObjects then
+ aBuffer.SetSize(fWidth, fHeight);
+ Attach(fBuffers.Count-1);
+
+ UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.DelBuffer(const aIndex: Integer);
+begin
+ if (aIndex >= 0) and (aIndex < fBuffers.Count) then begin
+ Detach(aIndex);
+ fBuffers.Delete(aIndex);
+ UpdateAndCheckFBO;
+ end else
+ raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.RemBuffer(const aBuffer: TglcBuffer): Integer;
+begin
+ result := IndexOfBuffer(aBuffer);
+ if (result >= 0) then
+ DelBuffer(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.IndexOfBuffer(const aBuffer: TglcBuffer): Integer;
+var
+ i: Integer;
+begin
+ for i := 0 to fBuffers.Count-1 do
+ if (fBuffers[i].Buffer = aBuffer) then begin
+ result := i;
+ exit;
+ end;
+ result := -1;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die Größe neu fest
+//@Width: neue Breite;
+//@Height: neue Höhe;
+procedure TglcFrameBufferObject.SetSize(const aWidth, aHeight: Integer);
+var
+ c: TglcAttachmentContainer;
+begin
+ if (aWidth <= 0) or (aHeight <= 0) then
+ raise EglcFrameBufferObject.Create('invalid width or height');
+
+ fWidth := aWidth;
+ fHeight := aHeight;
+ if OwnsObjects then
+ for c in fBuffers do
+ if c.OwnsObject then
+ c.Buffer.SetSize(fWidth, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.CheckAttachment(const aAttachment: TglcAttachment): Boolean;
+var
+ i: Integer;
+begin
+ result := false;
+ for i := 0 to fBuffers.Count-1 do
+ if (fBuffers[i].Attachment = aAttachment) then
+ exit;
+ result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Bindet das FrameBufferObjekt
+procedure TglcFrameBufferObject.Bind(const aSetViewport: Boolean = true);
+begin
+ glBindFramebuffer(GL_FRAMEBUFFER, fID);
+ if aSetViewport then begin
+{$IFNDEF OPENGL_ES}
+ glPushAttrib(GL_VIEWPORT_BIT);
+{$ELSE}
+ glGetIntegerv(GL_VIEWPORT, @fOldViewport[0]);
+{$ENDIF}
+ glViewPort(0, 0, fWidth, fHeight);
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Entbindet das FrameBufferObjekt
+procedure TglcFrameBufferObject.Unbind(const aResetViewport: Boolean = true);
+begin
+ if aResetViewport then
+{$IFNDEF OPENGL_ES}
+ glPopAttrib;
+{$ELSE}
+ glViewport(fOldViewport[0], fOldViewport[1], fOldViewport[2], fOldViewport[3]);
+{$ENDIF}
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erzeugt das Objekt
+constructor TglcFrameBufferObject.Create(const aOwnBuffers: Boolean = true);
+begin
+ inherited Create;
+
+ glGenFramebuffers(1, @fID);
+ fWidth := 64;
+ fHeight := 64;
+ fOwnsObjects := aOwnBuffers;
+ fBuffers := TglcAttachmentContainerList.Create(true); //containers are always owned by this object!
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//gibt das Objekt frei
+destructor TglcFrameBufferObject.Destroy;
+begin
+ fBuffers.Free;
+ glDeleteFramebuffers(1, @fID);
+ inherited Destroy;
+end;
+
+end.
+
--- /dev/null
+unit uglcLight;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL Licht- und Material-Objekte }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, {$IFNDEF OPENGL_ES}dglOpenGl{$ELSE}dglOpenGLES{$ENDIF}, ugluVector, uglcTypes;
+
+type
+ TglcMaterialRec = packed record
+ Ambient: TgluVector4f;
+ Diffuse: TgluVector4f;
+ Specular: TgluVector4f;
+ Emission: TgluVector4f;
+ Shininess: GLfloat;
+ end;
+ PglcMaterialRec = ^TglcMaterialRec;
+
+ TglcLightType = (
+ ltGlobal = 0,
+ ltPoint = 1,
+ ltSpot = 2);
+ TglcLightRec = packed record
+ Ambient: TgluVector4f;
+ Diffuse: TgluVector4f;
+ Specular: TgluVector4f;
+ Position: TgluVector4f;
+ SpotDirection: TgluVector3f;
+ SpotExponent: GLfloat;
+ SpotCutoff: GLfloat;
+ ConstantAtt: GLfloat;
+ LinearAtt: GLfloat;
+ QuadraticAtt: GLfloat;
+ end;
+ PglcLightRec = ^TglcLightRec;
+
+const
+ MAT_DEFAULT_AMBIENT: TgluVector4f = (0.2, 0.2, 0.2, 1.0);
+ MAT_DEFAULT_DIFFUSE: TgluVector4f = (0.8, 0.8, 0.8, 1.0);
+ MAT_DEFAULT_SPECULAR: TgluVector4f = (0.5, 0.5, 0.5, 1.0);
+ MAT_DEFAULT_EMISSION: TgluVector4f = (0.0, 0.0, 0.0, 1.0);
+ MAT_DEFAULT_SHININESS: GLfloat = 50.0;
+
+ LIGHT_DEFAULT_AMBIENT: TgluVector4f = (0.4, 0.4, 0.4, 1.0);
+ LIGHT_DEFAULT_DIFFUSE: TgluVector4f = (0.7, 0.7, 0.7, 1.0);
+ LIGHT_DEFAULT_SPECULAR: TgluVector4f = (0.9, 0.9, 0.9, 1.0);
+ LIGHT_DEFAULT_POSITION: TgluVector4f = (0.0, 0.0, 1.0, 0.0);
+ LIGHT_DEFAULT_SPOT_DIRECTION: TgluVector3f = (0.0, 0.0, -1.0);
+ LIGHT_DEFAULT_SPOT_EXPONENT: GLfloat = 0.0;
+ LIGHT_DEFAULT_SPOT_CUTOFF: GLfloat = 180.0;
+ LIGHT_DEFAULT_CONSTANT_ATT: GLfloat = 1.0;
+ LIGHT_DEFAULT_LINEAR_ATT: GLfloat = 0.0;
+ LIGHT_DEFAULT_QUADRATIC_ATT: GLfloat = 0.0;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcMaterial = class(TObject)
+ private
+ fData: TglcMaterialRec;
+ public
+ property Diffuse: TgluVector4f read fData.Diffuse write fData.Diffuse;
+ property Ambient: TgluVector4f read fData.Ambient write fData.Ambient;
+ property Specular: TgluVector4f read fData.Specular write fData.Specular;
+ property Emission: TgluVector4f read fData.Emission write fData.Emission;
+ property Shininess: GLfloat read fData.Shininess write fData.Shininess;
+ property Data: TglcMaterialRec read fData write fData;
+
+ procedure Bind(const aFace: TglcFace);
+
+ class procedure Bind(const aFace: TglcFace; const aMaterial: TglcMaterialRec);
+ class function DefaultValues: TglcMaterialRec;
+
+ constructor Create;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglcLight = class(Exception);
+ TglcLight = class(TObject)
+ private
+ function GetDataPtr: PglcLightRec;
+ protected
+ fData: TglcLightRec;
+
+ procedure SetAmbient (const aValue: TgluVector4f); virtual;
+ procedure SetDiffuse (const aValue: TgluVector4f); virtual;
+ procedure SetSpecular (const aValue: TgluVector4f); virtual;
+ procedure SetPosition4f (const aValue: TgluVector4f); virtual;
+ procedure SetSpotDirection(const aValue: TgluVector3f); virtual;
+ procedure SetSpotExponent (const aValue: GLfloat); virtual;
+ procedure SetSpotCutoff (const aValue: GLfloat); virtual;
+ procedure SetConstantAtt (const aValue: GLfloat); virtual;
+ procedure SetLinearAtt (const aValue: GLfloat); virtual;
+ procedure SetQuadraticAtt (const aValue: GLfloat); virtual;
+ procedure SetData (const aValue: TglcLightRec); virtual;
+
+ property Ambient: TgluVector4f read fData.Ambient write SetAmbient;
+ property Diffuse: TgluVector4f read fData.Diffuse write SetDiffuse;
+ property Specular: TgluVector4f read fData.Specular write SetSpecular;
+ property Position4f: TgluVector4f read fData.Position write SetPosition4f;
+ property SpotDirection: TgluVector3f read fData.SpotDirection write SetSpotDirection;
+ property SpotExponent: GLfloat read fData.SpotExponent write SetSpotExponent;
+ property SpotCutoff: GLfloat read fData.SpotCutoff write SetSpotCutoff;
+ property ConstantAtt: GLfloat read fData.ConstantAtt write SetConstantAtt;
+ property LinearAtt: GLfloat read fData.LinearAtt write SetLinearAtt;
+ property QuadraticAtt: GLfloat read fData.QuadraticAtt write SetQuadraticAtt;
+ public
+ property Data: TglcLightRec read fData write SetData;
+ property DataPtr: PglcLightRec read GetDataPtr;
+
+ procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); virtual; abstract;
+
+ class procedure Bind(const aLightID: GLenum; const aLight: TglcLightRec;
+ const aEnableLighting: Boolean; const aLightType: TglcLightType);
+ class procedure Unbind(const aLightID: GLenum; const aDisableLighting: Boolean = true);
+ class function DefaultValues: TglcLightRec; virtual;
+
+ constructor Create;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcLightGlobal = class(TglcLight)
+ private
+ function GetDirection: TgluVector3f;
+ procedure SetDirection(aValue: TgluVector3f);
+ public
+ property Ambient;
+ property Diffuse;
+ property Specular;
+ property Direction: TgluVector3f read GetDirection write SetDirection;
+
+ procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcLightPoint = class(TglcLight)
+ private
+ fMaxSize: Single;
+ fSizeFactor: Single;
+ function GetPosition: TgluVector3f;
+ procedure SetPosition(const aValue: TgluVector3f);
+ protected
+ procedure SetMaxSize (const aValue: Single); virtual;
+ procedure SetSizeFactor(const aValue: Single); virtual;
+ public
+ property Ambient;
+ property Diffuse;
+ property Specular;
+ property ConstantAtt;
+ property LinearAtt;
+ property QuadraticAtt;
+ property MaxSize: Single read fMaxSize write SetMaxSize;
+ property SizeFactor: Single read fSizeFactor write SetSizeFactor;
+ property Position: TgluVector3f read GetPosition write SetPosition;
+
+ procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+
+ constructor Create;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglcLightSpot = class(TglcLightPoint)
+ public
+ property SpotCutoff;
+ property SpotDirection;
+ property SpotExponent;
+
+ procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+ end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcMaterial//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcMaterial.Bind(const aFace: TglcFace);
+begin
+ Bind(aFace, fData);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcMaterial.Bind(const aFace: TglcFace; const aMaterial: TglcMaterialRec);
+begin
+ glMaterialfv(GLenum(aFace), GL_AMBIENT, @aMaterial.Ambient[0]);
+ glMaterialfv(GLenum(aFace), GL_DIFFUSE, @aMaterial.Diffuse[0]);
+ glMaterialfv(GLenum(aFace), GL_EMISSION, @aMaterial.Emission[0]);
+ glMaterialfv(GLenum(aFace), GL_SPECULAR, @aMaterial.Specular[0]);
+ glMaterialfv(GLenum(aFace), GL_SHININESS, @aMaterial.Shininess);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglcMaterial.DefaultValues: TglcMaterialRec;
+begin
+ result.Ambient := MAT_DEFAULT_AMBIENT;
+ result.Diffuse := MAT_DEFAULT_DIFFUSE;
+ result.Specular := MAT_DEFAULT_SPECULAR;
+ result.Emission := MAT_DEFAULT_EMISSION;
+ result.Shininess := MAT_DEFAULT_SHININESS;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcMaterial.Create;
+begin
+ inherited Create;
+ fData := DefaultValues;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLight/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLight.GetDataPtr: PglcLightRec;
+begin
+ result := @fData;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetAmbient(const aValue: TgluVector4f);
+begin
+ fData.Ambient := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetDiffuse(const aValue: TgluVector4f);
+begin
+ fData.Diffuse := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpecular(const aValue: TgluVector4f);
+begin
+ fData.Specular := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetPosition4f(const aValue: TgluVector4f);
+begin
+ fData.Position := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetConstantAtt(const aValue: GLfloat);
+begin
+ fData.ConstantAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetLinearAtt(const aValue: GLfloat);
+begin
+ fData.LinearAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetQuadraticAtt(const aValue: GLfloat);
+begin
+ fData.QuadraticAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotDirection(const aValue: TgluVector3f);
+begin
+ fData.SpotDirection := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotExponent(const aValue: GLfloat);
+begin
+ fData.SpotExponent := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotCutoff(const aValue: GLfloat);
+begin
+ fData.SpotCutoff := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetData(const aValue: TglcLightRec);
+begin
+ fData := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcLight.Bind(const aLightID: GLenum; const aLight: TglcLightRec;
+ const aEnableLighting: Boolean; const aLightType: TglcLightType);
+begin
+ glEnable(aLightID);
+ if (aEnableLighting) then
+ glEnable(GL_LIGHTING);
+
+ if (aLightType in [ltGlobal, ltPoint, ltSpot]) then begin
+ glLightfv(aLightID, GL_AMBIENT, @aLight.Ambient[0]);
+ glLightfv(aLightID, GL_DIFFUSE, @aLight.Diffuse[0]);
+ glLightfv(aLightID, GL_SPECULAR, @aLight.Specular[0]);
+ glLightfv(aLightID, GL_POSITION, @aLight.Position[0]);
+ end else begin
+ glLightfv(aLightID, GL_AMBIENT, @LIGHT_DEFAULT_AMBIENT[0]);
+ glLightfv(aLightID, GL_DIFFUSE, @LIGHT_DEFAULT_DIFFUSE[0]);
+ glLightfv(aLightID, GL_SPECULAR, @LIGHT_DEFAULT_SPECULAR[0]);
+ glLightfv(aLightID, GL_POSITION, @LIGHT_DEFAULT_POSITION[0]);
+ end;
+
+ if (aLightType in [ltPoint, ltSpot]) then begin
+ glLightfv(aLightID, GL_CONSTANT_ATTENUATION, @aLight.ConstantAtt);
+ glLightfv(aLightID, GL_LINEAR_ATTENUATION, @aLight.LinearAtt);
+ glLightfv(aLightID, GL_QUADRATIC_ATTENUATION, @aLight.QuadraticAtt);
+ end else begin
+ glLightfv(aLightID, GL_CONSTANT_ATTENUATION, @LIGHT_DEFAULT_CONSTANT_ATT);
+ glLightfv(aLightID, GL_LINEAR_ATTENUATION, @LIGHT_DEFAULT_LINEAR_ATT);
+ glLightfv(aLightID, GL_QUADRATIC_ATTENUATION, @LIGHT_DEFAULT_QUADRATIC_ATT);
+ end;
+
+ if (aLightType in [ltSpot]) then begin
+ glLightfv(aLightID, GL_SPOT_DIRECTION, @aLight.SpotDirection[0]);
+ glLightfv(aLightID, GL_SPOT_EXPONENT, @aLight.SpotExponent);
+ glLightfv(aLightID, GL_SPOT_CUTOFF, @aLight.SpotCutoff);
+ end else begin
+ glLightfv(aLightID, GL_SPOT_DIRECTION, @LIGHT_DEFAULT_SPOT_DIRECTION[0]);
+ glLightfv(aLightID, GL_SPOT_EXPONENT, @LIGHT_DEFAULT_SPOT_EXPONENT);
+ glLightfv(aLightID, GL_SPOT_CUTOFF, @LIGHT_DEFAULT_SPOT_CUTOFF);
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcLight.Unbind(const aLightID: GLenum; const aDisableLighting: Boolean);
+begin
+ glDisable(aLightID);
+ if aDisableLighting then
+ glDisable(GL_LIGHTING);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglcLight.DefaultValues: TglcLightRec;
+begin
+ result.Ambient := LIGHT_DEFAULT_AMBIENT;
+ result.Diffuse := LIGHT_DEFAULT_DIFFUSE;
+ result.Specular := LIGHT_DEFAULT_SPECULAR;
+ result.Position := LIGHT_DEFAULT_POSITION;
+ result.SpotDirection := LIGHT_DEFAULT_SPOT_DIRECTION;
+ result.SpotExponent := LIGHT_DEFAULT_SPOT_EXPONENT;
+ result.SpotCutoff := LIGHT_DEFAULT_SPOT_CUTOFF;
+ result.ConstantAtt := LIGHT_DEFAULT_CONSTANT_ATT;
+ result.LinearAtt := LIGHT_DEFAULT_LINEAR_ATT;
+ result.QuadraticAtt := LIGHT_DEFAULT_QUADRATIC_ATT;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcLight.Create;
+begin
+ inherited Create;
+ fData := DefaultValues;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightGlobal///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLightGlobal.GetDirection: TgluVector3f;
+begin
+ result := gluVector3f(Position4f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightGlobal.SetDirection(aValue: TgluVector3f);
+begin
+ Position4f := gluVector4f(aValue, 0.0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightGlobal.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+ TglcLight.Bind(aLightID, fData, aEnableLighting, ltGlobal);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightPoint////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLightPoint.GetPosition: TgluVector3f;
+begin
+ result := gluVector3f(fData.Position);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetPosition(const aValue: TgluVector3f);
+begin
+ SetPosition4f(gluVector4f(aValue, 1.0));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetMaxSize(const aValue: Single);
+begin
+ fMaxSize := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetSizeFactor(const aValue: Single);
+begin
+ fSizeFactor := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+ TglcLight.Bind(aLightID, fData, aEnableLighting, ltPoint);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcLightPoint.Create;
+begin
+ inherited Create;
+ Position := gluVector3f(0.0, 0.0, 0.0);
+ fMaxSize := 0;
+ fSizeFactor := 1.0;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightSpot/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightSpot.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+ TglcLight.Bind(aLightID, fData, aEnableLighting, ltSpot);
+end;
+
+end.
+
--- /dev/null
+unit uglcShader;\r
+\r
+{ Package: OpenGLCore\r
+ Prefix: glc - OpenGL Core\r
+ Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL Shader Objekte\r
+ Beispiel:\r
+ var\r
+ shader: TglcShaderProgram;\r
+\r
+ //write log message to console\r
+ // @param aSender: object that send the message\r
+ // @param aMsg: message to write to console\r
+ procedure LogMessage(aSender: TObject; const aMsg: String);\r
+ begin\r
+ writeln(Format('[%p]: %s', [aSender, aMsg]);\r
+ end;\r
+\r
+ //load shader object from file and add it to 'shader'\r
+ // @param aFilename: name of file to load shader code from\r
+ // @param aType: type of shader object to create\r
+ procedure LoadShaderObject(const aFilename: String; const aType: TglcShaderType);\r
+ var\r
+ sl: TStringList;\r
+ so: TglcShaderObject;\r
+ begin\r
+ sl := TStringList.Create;\r
+ try\r
+ sl.LoadFromFile(aFileName);\r
+ so := TglcShaderObject.Create(aType);\r
+ shader.add(so);\r
+ finally\r
+ FreeAndNil(sl, @LogMessage);\r
+ end;\r
+ end;\r
+\r
+ shader := TglcShaderProgram.Create(@LogMessage);\r
+ try\r
+ // load shader objects\r
+ LoadShaderObject('./test_shader.vert', TglcShaderType.stVertex);\r
+ LoadShaderObject('./test_shader.frag', TglcShaderType.stFragment);\r
+\r
+ // compile shader\r
+ shader.Compile;\r
+\r
+ // use shader\r
+ shader.Enable;\r
+ shader.Uniform1f('uTest', 0.1234);\r
+ // do normal rendering\r
+ shader.Disable;\r
+\r
+ finally\r
+ FreeAndNil(shader);\r
+ end; }\r
+\r
+{$mode objfpc}{$H+}\r
+\r
+interface\r
+\r
+uses\r
+ Classes, SysUtils, fgl, {$IFNDEF OPENGL_ES}dglOpenGl{$ELSE}dglOpenGLES{$ENDIF}, uglcTypes, ugluMatrix;\r
+\r
+type\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+ EglcShader = class(Exception);\r
+ TglcShaderProgram = class;\r
+ TglcShaderLogEvent = procedure(aSender: TObject; const aMsg: String) of Object;\r
+ TglcShaderObject = class(TObject)\r
+ private\r
+ fAtachedTo: TglcShaderProgram;\r
+ fShaderObj: GLuint;\r
+ fShaderType: TglcShaderType;\r
+ fCode: String;\r
+ fOnLog: TglcShaderLogEvent;\r
+ fAttachedTo: TglcShaderProgram;\r
+\r
+ function GetInfoLog(aObj: GLuint): String;\r
+ function GetCompiled: Boolean;\r
+ procedure Log(const aMsg: String);\r
+ procedure CreateShaderObj;\r
+ procedure AttachTo(const aProgram: TglcShaderProgram);\r
+ public\r
+ property ShaderObj: GLuint read fShaderObj;\r
+ property ShaderType: TglcShaderType read fShaderType;\r
+ property Compiled: Boolean read GetCompiled;\r
+ property AtachedTo: TglcShaderProgram read fAtachedTo;\r
+ property Code: String read fCode write fCode;\r
+ property OnLog: TglcShaderLogEvent read fOnLog write fOnLog;\r
+\r
+ procedure Compile;\r
+\r
+ constructor Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent = nil);\r
+ destructor Destroy; override;\r
+ end;\r
+ TglcShaderObjectList = specialize TFPGObjectList<TglcShaderObject>;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+ TglcShaderProgram = class(TglcShaderObjectList)\r
+ private\r
+ fProgramObj: GLuint;\r
+ fOnLog: TglcShaderLogEvent;\r
+ fFilename: String;\r
+\r
+ function GetUniformLocation(const aName: String; out aPos: glInt): Boolean;\r
+ function GetInfoLog(Obj: GLuint): String;\r
+ function GetCompiled: Boolean;\r
+ function GetLinked: Boolean;\r
+\r
+ procedure CreateProgramObj;\r
+ procedure Log(const msg: String);\r
+ procedure AttachShaderObj(const aShaderObj: TglcShaderObject);\r
+ public\r
+ property ProgramObj: GLuint read fProgramObj;\r
+ property Filename: String read fFilename;\r
+ property Compiled: Boolean read GetCompiled;\r
+ property Linked: Boolean read GetLinked;\r
+ property OnLog: TglcShaderLogEvent read fOnLog write fOnLog;\r
+\r
+ procedure Compile;\r
+ procedure Enable;\r
+ procedure Disable;\r
+\r
+ procedure Add(aShaderObj: TglcShaderObject);\r
+ procedure Delete(aID: Integer; aFreeOwnedObj: Boolean = True);\r
+ procedure Clear;\r
+\r
+ function Uniform1f(const aName: String; aP1: GLFloat): Boolean;\r
+ function Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean;\r
+ function Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean;\r
+ function Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean;\r
+ function Uniform1i(const aName: String; aP1: GLint): Boolean;\r
+ function Uniform2i(const aName: String; aP1, aP2: GLint): Boolean;\r
+ function Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean;\r
+ function Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean;\r
+ function Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+ function Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+ function Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+ function Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+ function Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+ function Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+ function Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+ function Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+ function UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean;\r
+ function UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean;\r
+ function UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean;\r
+\r
+ function GetUniformfv(const aName: String; aP: PGLfloat): Boolean;\r
+ function GetUniformfi(const aName: String; aP: PGLint): Boolean;\r
+ procedure BindAttribLocation(const aName: String; const aAttribIndex: GLint);\r
+ function GetAttribLocation(const aName: String): Integer;\r
+ function HasUniform(const aName: String): Boolean;\r
+\r
+ procedure LoadFromFile(const aFilename: String);\r
+ procedure LoadFromStream(const aStream: TStream);\r
+ procedure SaveToFile(const aFilename: String);\r
+ procedure SaveToStream(const aStream: TStream);\r
+\r
+ constructor Create(const aLogEvent: TglcShaderLogEvent = nil);\r
+ destructor Destroy; override;\r
+ end;\r
+\r
+implementation\r
+\r
+uses\r
+ RegExpr;\r
+\r
+const\r
+ ERROR_STR_VAR_NAME: String = 'can''t find the variable ''%s'' in the program';\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//glShaderObject////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt das Log eines OpenGL-Objekts aus\r
+//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll;\r
+//@result: Log des Objekts;\r
+function TglcShaderObject.GetInfoLog(aObj: GLuint): String;\r
+var\r
+ Msg: PChar;\r
+ bLen: GLint;\r
+ sLen: GLsizei;\r
+begin\r
+ bLen := 0;\r
+ glGetShaderiv(aObj, GL_INFO_LOG_LENGTH, @bLen);\r
+ if bLen > 1 then begin\r
+ GetMem(Msg, bLen * SizeOf(Char));\r
+ glGetShaderInfoLog(aObj, bLen, @sLen, Msg);\r
+ result := PChar(Msg);\r
+ Dispose(Msg);\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt aus, ob der Shader ohne Fehler kompiliert wurde\r
+//@result: TRUE wenn ohne Fehler kompiliert, sonst FALSE;\r
+function TglcShaderObject.GetCompiled: Boolean;\r
+var\r
+ value: GLint;\r
+begin\r
+ glGetShaderiv(fShaderObj, GL_COMPILE_STATUS, @value);\r
+ result := (value = GLint(GL_TRUE));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ruft das Log-Event auf, wenn es gesetzt ist\r
+//@msg: Nachricht die geloggt werden soll;\r
+procedure TglcShaderObject.Log(const aMsg: String);\r
+begin\r
+ if Assigned(fOnLog) then begin\r
+ fOnLog(self, aMsg);\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderObject.CreateShaderObj;\r
+begin\r
+ if (fShaderObj <> 0) then\r
+ exit;\r
+ fShaderObj := glCreateShader(GLenum(fShaderType));\r
+ if fShaderObj = 0 then\r
+ raise EglcShader.Create('can''t create ShaderObject');\r
+ Log('shader object created: #'+IntToHex(fShaderObj, 4));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderObject.AttachTo(const aProgram: TglcShaderProgram);\r
+begin\r
+ if (aProgram <> fAtachedTo) then begin\r
+ CreateShaderObj;\r
+ glAttachShader(aProgram.ProgramObj, fShaderObj);\r
+ fAttachedTo := aProgram;\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//kompiliert das Shader-Objekt\r
+procedure TglcShaderObject.Compile;\r
+var\r
+ len, i: GLint;\r
+ List: TStringList;\r
+ c: PAnsiChar;\r
+begin\r
+ CreateShaderObj;\r
+ len := Length(fCode);\r
+ if len > 0 then begin\r
+ c := PAnsiChar(fCode);\r
+ glShaderSource(fShaderObj, 1, @c, @len);\r
+ glCompileShader(fShaderObj);\r
+ List := TStringList.Create;\r
+ List.Text := GetInfoLog(fShaderObj);\r
+ for i := 0 to List.Count-1 do\r
+ Log(List[i]);\r
+ List.Free;\r
+ end else Log('error while compiling: no bound shader code');\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//erzeugt das Objekt\r
+//@ShaderType: Typ des Shader-Objekts;\r
+//@LogEvent: Event zum loggen von Fehlern und Ereignissen;\r
+//@raise: EglcShader wenn der Shadertyp unbekannt oder ungültig ist;\r
+constructor TglcShaderObject.Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent);\r
+begin\r
+ inherited Create;\r
+ fCode := '';\r
+ fOnLog := aLogEvent;\r
+ fShaderType := aShaderType;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//gibt das Objekt frei\r
+destructor TglcShaderObject.Destroy;\r
+begin\r
+ if (fShaderObj <> 0) then\r
+ glDeleteShader(fShaderObj);\r
+ inherited Destroy;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//glShaderProgram///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+function TglcShaderProgram.GetUniformLocation(const aName: String; out aPos: glInt): Boolean;\r
+begin\r
+ aPos := glGetUniformLocation(fProgramObj, PChar(aName));\r
+ result := (aPos <> -1);\r
+ if not result then\r
+ Log(StringReplace(ERROR_STR_VAR_NAME, '%s', aName, [rfIgnoreCase, rfReplaceAll]));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt das Log eines OpenGL-Objekts aus\r
+//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll;\r
+//@result: Log des Objekts;\r
+function TglcShaderProgram.GetInfoLog(Obj: GLuint): String;\r
+var\r
+ Msg: PChar;\r
+ bLen: GLint;\r
+ sLen: GLsizei;\r
+begin\r
+ bLen := 0;\r
+ glGetProgramiv(Obj, GL_INFO_LOG_LENGTH, @bLen);\r
+ if bLen > 1 then begin\r
+ GetMem(Msg, bLen * SizeOf(Char));\r
+ glGetProgramInfoLog(Obj, bLen, @sLen, Msg);\r
+ result := PChar(Msg);\r
+ Dispose(Msg);\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//prüft ob alle Shader ohne Fehler compiliert wurden\r
+//@result: TRUE wenn alle erfolgreich compiliert, sonst FALSE;\r
+function TglcShaderProgram.GetCompiled: Boolean;\r
+var\r
+ i: Integer;\r
+begin\r
+ result := (Count > 0);\r
+ for i := 0 to Count-1 do\r
+ result := result and Items[i].Compiled;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//prüft ob das Programm ohne Fehler gelinkt wurde\r
+//@result: TRUE wenn linken erfolgreich, sonst FASLE;\r
+function TglcShaderProgram.GetLinked: Boolean;\r
+var\r
+ value: glInt;\r
+begin\r
+ glGetProgramiv(fProgramObj, GL_LINK_STATUS, @value);\r
+ result := (value = GLint(GL_TRUE));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.CreateProgramObj;\r
+begin\r
+ if (fProgramObj = 0) then begin\r
+ fProgramObj := glCreateProgram();\r
+ Log('shader program created: #'+IntToHex(fProgramObj, 4));\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ruft das Log-Event auf, wenn es gesetzt ist\r
+//@msg: Nachricht die geloggt werden soll;\r
+procedure TglcShaderProgram.Log(const msg: String);\r
+begin\r
+ if Assigned(fOnLog) then begin\r
+ fOnLog(self, msg);\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.AttachShaderObj(const aShaderObj: TglcShaderObject);\r
+begin\r
+ CreateProgramObj;\r
+ aShaderObj.AttachTo(self);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//Kompiliert den Shader-Code\r
+procedure TglcShaderProgram.Compile;\r
+var\r
+ i: Integer;\r
+ l: TStringList;\r
+begin\r
+ CreateProgramObj;\r
+ for i := 0 to Count-1 do begin\r
+ AttachShaderObj(Items[i]);\r
+ Items[i].Compile;\r
+ end;\r
+ glLinkProgram(fProgramObj);\r
+ l := TStringList.Create;\r
+ l.Text := GetInfoLog(fProgramObj);\r
+ for i := 0 to l.Count-1 do\r
+ Log(l[i]);\r
+ l.Free;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//aktiviert den Shader\r
+procedure TglcShaderProgram.Enable;\r
+begin\r
+ glUseProgram(fProgramObj);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//deaktiviert den Shader\r
+procedure TglcShaderProgram.Disable;\r
+begin\r
+ glUseProgram(0);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//fügt der Liste einen Shader hinzu\r
+//@ShaderObj: Objekt, das hinzugefügt werden soll;\r
+procedure TglcShaderProgram.Add(aShaderObj: TglcShaderObject);\r
+begin\r
+ inherited Add(aShaderObj);\r
+ if (fProgramObj <> 0) then\r
+ AttachShaderObj(aShaderObj);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//löscht ein ShaderObjekt aus der Liste\r
+//@ID: Index des Objekts, das gelöscht werden soll;\r
+//@FreeOwnedObj: wenn TRUE wird das gelöschte Objekt freigegeben;\r
+procedure TglcShaderProgram.Delete(aID: Integer; aFreeOwnedObj: Boolean);\r
+var\r
+ b: Boolean;\r
+begin\r
+ if (aID >= 0) and (aID < Count) and (fProgramObj <> 0) then begin\r
+ glDetachShader(fProgramObj, Items[aID].fShaderObj);\r
+ Items[aID].fAttachedTo := nil;\r
+ end;\r
+ b := FreeObjects;\r
+ FreeObjects := aFreeOwnedObj;\r
+ inherited Delete(aID);\r
+ FreeObjects := b;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.Clear;\r
+begin\r
+ while (Count > 0) do\r
+ Delete(0);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 1-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1f(const aName: String; aP1: GLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform1f(pos, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 2-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform2f(pos, aP1, aP2);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 3-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform3f(pos, aP1, aP2, aP3);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 4-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@p4: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform4f(pos, aP1, aP2, aP3, aP4);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 1-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1i(const aName: String; aP1: GLint): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform1i(pos, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 2-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2i(const aName: String; aP1, aP2: GLint): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform2i(pos, aP1, aP2);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 3-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform3i(pos, aP1, aP2, aP3);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 4-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@p4: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform4i(pos, aP1, aP2, aP3, aP4);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 1-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform1fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 2-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform2fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 3-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform3fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 4-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform4fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 1-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform1iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 2-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform2iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 3-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform3iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 4-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniform4iv(pos, aCount, aP1) ;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 2x2-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniformMatrix2fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 3x3-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniformMatrix3fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 4x4-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glUniformMatrix4fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//holt den Wert einer Float-Uniform-Variable aus dem Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gelesen werden soll;\r
+//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.GetUniformfv(const aName: String; aP: PGLfloat): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glGetUniformfv(fProgramObj, pos, aP);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//holt den Wert einer Integer-Uniform-Variable aus dem Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gelesen werden soll;\r
+//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.GetUniformfi(const aName: String; aP: PGLint): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+ if result then\r
+ glGetUniformiv(fProgramObj, pos, aP);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.BindAttribLocation(const aName: String; const aAttribIndex: GLint);\r
+begin\r
+ CreateProgramObj;\r
+ glBindAttribLocation(fProgramObj, aAttribIndex, PGLchar(aName));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+function TglcShaderProgram.GetAttribLocation(const aName: String): Integer;\r
+begin\r
+ result := glGetAttribLocation(fProgramObj, PGLchar(aName));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+function TglcShaderProgram.HasUniform(const aName: String): Boolean;\r
+var\r
+ pos: GLint;\r
+begin\r
+ result := GetUniformLocation(aName, pos);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//läd den Shader aus einer Datei\r
+//@Filename: Datei aus der gelesen werden soll;\r
+//@raise: EglcShader, wenn Datei nicht vorhanden ist;\r
+procedure TglcShaderProgram.LoadFromFile(const aFilename: String);\r
+var\r
+ Stream: TFileStream;\r
+begin\r
+ if FileExists(aFilename) then begin\r
+ Stream := TFileStream.Create(aFilename, fmOpenRead);\r
+ try\r
+ LoadFromStream(Stream);\r
+ fFilename := aFilename;\r
+ finally\r
+ Stream.Free;\r
+ end;\r
+ end else raise EglcShader.Create('TglShaderProgram.LoadFromFile - file not found: '+Filename);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//läd den Shader aus einem Stream\r
+//@Stream: Stream aus dem gelesen werden soll;\r
+//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde;\r
+procedure TglcShaderProgram.LoadFromStream(const aStream: TStream);\r
+\r
+ function GetShaderType(const aStr: String): TglcShaderType;\r
+ begin\r
+ if (aStr = 'GL_VERTEX_SHADER') then\r
+ result := TglcShaderType.stVertex\r
+ else if (aStr = 'GL_FRAGMENT_SHADER') then\r
+ result := TglcShaderType.stFragment\r
+{$IFNDEF OPENGL_ES}\r
+ else if (aStr = 'GL_GEOMETRY_SHADER') then\r
+ result := TglcShaderType.stGeometry\r
+ else if (aStr = 'GL_TESS_CONTROL_SHADER') then\r
+ result := TglcShaderType.stTessControl\r
+ else if (aStr = 'GL_TESS_EVALUATION_SHADER') then\r
+ result := TglcShaderType.stTessEvaluation\r
+{$ENDIF}\r
+ else\r
+ raise Exception.Create('invalid shader type: ' + aStr);\r
+ end;\r
+\r
+var\r
+ sl: TStringList;\r
+ s: String;\r
+ rx: TRegExpr;\r
+ LastMatchPos: PtrInt;\r
+ st: TglcShaderType;\r
+ o: TglcShaderObject;\r
+\r
+ procedure AddObj(const aPos: Integer);\r
+ begin\r
+ if (LastMatchPos > 0) then begin\r
+ o := TglcShaderObject.Create(st, fOnLog);\r
+ o.Code := Trim(Copy(s, LastMatchPos, aPos - LastMatchPos));\r
+ Add(o);\r
+ end;\r
+ end;\r
+\r
+begin\r
+ if not Assigned(aStream) then\r
+ raise EglcShader.Create('TglShaderProgram.SaveToStream - stream is nil');\r
+\r
+ Clear;\r
+ sl := TStringList.Create;\r
+ rx := TRegExpr.Create;\r
+ try\r
+ sl.LoadFromStream(aStream);\r
+ s := sl.Text;\r
+ LastMatchPos := 0;\r
+ rx.Expression := '/\*\s*ShaderObject\s*:\s*(GL_[A-Z_]+)\s*\*/\s*$?';\r
+ rx.InputString := s;\r
+\r
+ while rx.Exec(LastMatchPos+1) do begin\r
+ AddObj(rx.MatchPos[0]);\r
+ LastMatchPos := rx.MatchPos[0] + rx.MatchLen[0];\r
+ st := GetShaderType(rx.Match[1]);\r
+ end;\r
+ AddObj(Length(s));\r
+ finally\r
+ rx.Free;\r
+ sl.Free;\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//speichert den Shader in einer Datei\r
+//@Filename: Datei in die geschrieben werden soll;\r
+procedure TglcShaderProgram.SaveToFile(const aFilename: String);\r
+var\r
+ Stream: TFileStream;\r
+begin\r
+ Stream := TFileStream.Create(aFilename, fmCreate);\r
+ try\r
+ SaveToStream(Stream);\r
+ fFilename := aFilename;\r
+ finally\r
+ Stream.Free;\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//speichert den Shader in einen Stream\r
+//@Stream: Stream in den geschrieben werden soll;\r
+//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde;\r
+//@raise: EglcShader wenn ungültige Datei;\r
+procedure TglcShaderProgram.SaveToStream(const aStream: TStream);\r
+var\r
+ i: Integer;\r
+ sl: TStringList;\r
+ sObj: TglcShaderObject;\r
+\r
+ function GetShaderTypeStr(const aShaderType: TglcShaderType): String;\r
+ begin\r
+ case aShaderType of\r
+ TglcShaderType.stVertex: result := 'GL_VERTEX_SHADER';\r
+ TglcShaderType.stFragment: result := 'GL_FRAGMENT_SHADER';\r
+{$IFNDEF OPENGL_ES}\r
+ TglcShaderType.stGeometry: result := 'GL_GEOMETRY_SHADER';\r
+ TglcShaderType.stTessControl: result := 'GL_TESS_CONTROL_SHADER';\r
+ TglcShaderType.stTessEvaluation: result := 'GL_TESS_EVALUATION_SHADER';\r
+{$ENDIF}\r
+ else\r
+ result := 'UNKNOWN';\r
+ end;\r
+ end;\r
+\r
+begin\r
+ if not Assigned(aStream) then\r
+ raise EglcShader.Create('TglShaderProgram.LoadFromStream - stream is nil');\r
+ fFilename := '';\r
+ sl := TStringList.Create;\r
+ try\r
+ for i := 0 to Count-1 do begin\r
+ sObj := Items[i];\r
+ sl.Add('/* ShaderObject: ' + GetShaderTypeStr(sObj.ShaderType) + ' */');\r
+ sl.Add(sObj.Code);\r
+ end;\r
+ sl.SaveToStream(aStream);\r
+ finally\r
+ sl.Free;\r
+ end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//erzeugt das Objekt\r
+//@LogEvent: Event zum loggen von Fehlern und Ereignissen;\r
+//@raise: EglcShader wenn OpenGL nicht initialisiert werden konnte;\r
+//@raise:\r
+constructor TglcShaderProgram.Create(const aLogEvent: TglcShaderLogEvent);\r
+begin\r
+ inherited Create;\r
+ fOnLog := aLogEvent;\r
+ fFilename := '';\r
+ fProgramObj := 0;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//gibt das Objekt frei\r
+destructor TglcShaderProgram.Destroy;\r
+begin\r
+ if (fProgramObj <> 0) then\r
+ glDeleteProgram(fProgramObj);\r
+ inherited Destroy;\r
+end;\r
+\r
+end.\r
+\r
--- /dev/null
+unit uglcTypes;
+
+{ Package: OpenGLCore
+ Prefix: glc - OpenGL Core
+ Beschreibung: diese Unit definiert Enum-Typen die OpenGL Konstanten wrappen und stellt zusätzlich
+ Funktions-Wrapper zur verfügung die diese Enum-Typen als Parameter entgegen nehmen }
+
+{$mode objfpc}{$H+}
+{$MACRO ON}
+{$SCOPEDENUMS ON}
+
+interface
+
+uses
+ {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF}, sysutils;
+
+type
+ TglcFace = (
+ faFront = GL_FRONT,
+ faBack = GL_BACK,
+ faBoth = GL_FRONT_AND_BACK);
+
+{$IFNDEF OPENGL_ES}
+ TglcPolygonMode = (
+ pmPoint = GL_POINT,
+ pmLine = GL_LINE,
+ pmFill = GL_FILL);
+{$ENDIF}
+
+ TglcDepthFunc = (
+ dfNever = GL_NEVER,
+ dfLess = GL_LESS,
+ dfEqual = GL_EQUAL,
+ dfLessEqual = GL_LEQUAL,
+ dfGreater = GL_GREATER,
+ dfNotEqual = GL_NOTEQUAL,
+ dfGreaterEqual = GL_GEQUAL,
+ dfAlways = GL_ALWAYS);
+
+ TglcClearBuffer = (
+ cbDepthBuffer = GL_DEPTH_BUFFER_BIT,
+{$IFNDEF OPENGL_ES}
+ cbAccumBuffer = GL_ACCUM_BUFFER_BIT,
+{$ENDIF}
+ cbStencilBuffer = GL_STENCIL_BUFFER_BIT,
+ cbColorBuffer = GL_COLOR_BUFFER_BIT);
+
+ TglcTextureMinFilter = (
+ mfNearest = GL_NEAREST,
+ mfLinear = GL_LINEAR,
+ mfNearestMipmapNearest = GL_NEAREST_MIPMAP_NEAREST,
+ mfLinearMipmapNearest = GL_LINEAR_MIPMAP_NEAREST,
+ mfNearestMipmapLinear = GL_NEAREST_MIPMAP_LINEAR,
+ mfLinearMipmapLinear = GL_LINEAR_MIPMAP_LINEAR);
+
+ TglcTextureMagFilter = (
+ mfNearest = GL_NEAREST,
+ mfLinear = GL_LINEAR);
+
+ TglcTextureWrap = (
+{$IFNDEF OPENGL_ES}
+ twClamp = GL_CLAMP,
+{$ENDIF}
+ twRepeat = GL_REPEAT,
+{$IFNDEF OPENGL_ES}
+ twClampToBorder = GL_CLAMP_TO_BORDER,
+{$ENDIF}
+ twClampToEdge = GL_CLAMP_TO_EDGE,
+ twMirroredRepeat = GL_MIRRORED_REPEAT);
+
+ TglcBlendFactor = (
+ bfZero = GL_ZERO,
+ bfOne = GL_ONE,
+ bfSrcColor = GL_SRC_COLOR,
+ bfOneMinusSrcColor = GL_ONE_MINUS_SRC_COLOR,
+ bfSrcAlpha = GL_SRC_ALPHA,
+ bfOneMinusSrcAlpha = GL_ONE_MINUS_SRC_ALPHA,
+ bfDstAlpha = GL_DST_ALPHA,
+ bfOneMinusDstAlpha = GL_ONE_MINUS_DST_ALPHA,
+ bfDstColor = GL_DST_COLOR,
+ bfOneMinusDstColor = GL_ONE_MINUS_DST_COLOR,
+ bfSrcAlphaSaturate = GL_SRC_ALPHA_SATURATE,
+ bgConstColor = GL_CONSTANT_COLOR,
+ bfOneMinusConstColor = GL_ONE_MINUS_CONSTANT_COLOR,
+ bfConstAlpha = GL_CONSTANT_ALPHA,
+ bfOneMinusConstAlpha = GL_ONE_MINUS_CONSTANT_ALPHA);
+
+ TglcBlendMode = (
+ bmNone,
+ bmAlphaBlend,
+ bmAdditiveAlphaBlend,
+ bmAdditiveBlend);
+
+ TglcFormat = (
+ fmUnknown = 0,
+{$IFNDEF OPENGL_ES}
+ fmColorIndex = GL_COLOR_INDEX,
+{$ENDIF}
+ fmDepthComponent = GL_DEPTH_COMPONENT,
+ fmRed = GL_RED,
+ fmGreen = GL_GREEN,
+ fmBlue = GL_BLUE,
+ fmAlpha = GL_ALPHA,
+ fmRGB = GL_RGB,
+ fmRGBA = GL_RGBA,
+ fmLuminance = GL_LUMINANCE,
+ fmLuminanceAlpha = GL_LUMINANCE_ALPHA,
+{$IFNDEF OPENGL_ES}
+ fmBGR = GL_BGR,
+ fmBGRA = GL_BGRA,
+{$ENDIF}
+ fmDepthStencil = GL_DEPTH_STENCIL);
+
+ TglcInternalFormat = (
+ ifUnknown = 0,
+ ifDepthComponent = GL_DEPTH_COMPONENT,
+ ifAlpha = GL_ALPHA,
+ ifRGB = GL_RGB,
+ ifRGBA = GL_RGBA,
+ ifLuminance = GL_LUMINANCE,
+ ifLuminanceAlpha = GL_LUMINANCE_ALPHA,
+{$IFNDEF OPENGL_ES}
+ ifR3G3B2 = GL_R3_G3_B2,
+ ifAlpha4 = GL_ALPHA4,
+ ifAlpha8 = GL_ALPHA8,
+ ifAlpha12 = GL_ALPHA12,
+ ifAlpha16 = GL_ALPHA16,
+ ifLuminance4 = GL_LUMINANCE4,
+ ifLuminance8 = GL_LUMINANCE8,
+ ifLuminance12 = GL_LUMINANCE12,
+ ifLuminance16 = GL_LUMINANCE16,
+ ifLuminance4Alpha4 = GL_LUMINANCE4_ALPHA4,
+ ifLuminance6Alpha2 = GL_LUMINANCE6_ALPHA2,
+ ifLuminance8Alpha8 = GL_LUMINANCE8_ALPHA8,
+ ifLuminance12Alpha4 = GL_LUMINANCE12_ALPHA4,
+ ifLuminance12Alpha12 = GL_LUMINANCE12_ALPHA12,
+ ifLuminance16Alpha16 = GL_LUMINANCE16_ALPHA16,
+ ifIntensity = GL_INTENSITY,
+ ifIntensity4 = GL_INTENSITY4,
+ ifIntensity8 = GL_INTENSITY8,
+ ifIntensity12 = GL_INTENSITY12,
+ ifIntensity16 = GL_INTENSITY16,
+ ifRGB4 = GL_RGB4,
+ ifRGB5 = GL_RGB5,
+{$ENDIF}
+ ifRGB8 = GL_RGB8,
+{$IFNDEF OPENGL_ES}
+ ifRGB10 = GL_RGB10,
+ ifRGB12 = GL_RGB12,
+ ifRGB16 = GL_RGB16,
+ ifRGBA2 = GL_RGBA2,
+{$ENDIF}
+ ifRGBA4 = GL_RGBA4,
+ ifRGB5A1 = GL_RGB5_A1,
+ ifRGBA8 = GL_RGBA8,
+ ifRGB10A2 = GL_RGB10_A2,
+{$IFNDEF OPENGL_ES}
+ ifRGBA12 = GL_RGBA12,
+ ifRGBA16 = GL_RGBA16,
+{$ENDIF}
+ ifDepthComponent16 = GL_DEPTH_COMPONENT16,
+ ifDepthComponent24 = GL_DEPTH_COMPONENT24,
+{$IFNDEF OPENGL_ES}
+ ifDepthComponent32 = GL_DEPTH_COMPONENT32,
+ ifCompressedAlpha = GL_COMPRESSED_ALPHA,
+ ifCompressedLuminance = GL_COMPRESSED_LUMINANCE,
+ ifCompressedLuminanceAlpha = GL_COMPRESSED_LUMINANCE_ALPHA,
+ ifCompressedIntensity = GL_COMPRESSED_INTENSITY,
+ ifCompressedRGB = GL_COMPRESSED_RGB,
+ ifCompressedRGBA = GL_COMPRESSED_RGBA,
+{$ENDIF}
+ ifRGBA32f = GL_RGBA32F,
+ ifRGB32f = GL_RGB32F,
+ ifRGBA16F = GL_RGBA16F,
+ ifRGB16F = GL_RGB16F,
+ ifDepth24Stencil8 = GL_DEPTH24_STENCIL8,
+ ifSRGB = GL_SRGB,
+ ifSRGB8 = GL_SRGB8,
+{$IFNDEF OPENGL_ES}
+ ifSRGBA = GL_SRGB_ALPHA,
+{$ENDIF}
+ ifSRGBA8 = GL_SRGB8_ALPHA8,
+{$IFNDEF OPENGL_ES}
+ ifSLuminanceAlpha = GL_SLUMINANCE_ALPHA,
+ ifSLuminance8Alpha8 = GL_SLUMINANCE8_ALPHA8,
+ ifSLuminance = GL_SLUMINANCE,
+ ifSLuminance8 = GL_SLUMINANCE8,
+{$ENDIF}
+ ifDepth32fStencil8 = GL_DEPTH32F_STENCIL8,
+{$IFNDEF OPENGL_ES}
+ ifStencil1 = GL_STENCIL_INDEX1,
+ ifStencil4 = GL_STENCIL_INDEX4,
+{$ENDIF}
+ ifStencil8 = GL_STENCIL_INDEX8
+{$IFNDEF OPENGL_ES}
+ , ifStencil16 = GL_STENCIL_INDEX16
+{$ENDIF}
+ );
+
+ TglcAttachment = (
+ atDepthStencil = GL_DEPTH_STENCIL_ATTACHMENT,
+ atColor0 = GL_COLOR_ATTACHMENT0,
+ atColor1 = GL_COLOR_ATTACHMENT1,
+ atColor2 = GL_COLOR_ATTACHMENT2,
+ atColor3 = GL_COLOR_ATTACHMENT3,
+ atColor4 = GL_COLOR_ATTACHMENT4,
+ atColor5 = GL_COLOR_ATTACHMENT5,
+ atColor6 = GL_COLOR_ATTACHMENT6,
+ atColor7 = GL_COLOR_ATTACHMENT7,
+ atColor8 = GL_COLOR_ATTACHMENT8,
+ atColor9 = GL_COLOR_ATTACHMENT9,
+ atColor10 = GL_COLOR_ATTACHMENT10,
+ atColor11 = GL_COLOR_ATTACHMENT11,
+ atColor12 = GL_COLOR_ATTACHMENT12,
+ atColor13 = GL_COLOR_ATTACHMENT13,
+ atColor14 = GL_COLOR_ATTACHMENT14,
+ atColor15 = GL_COLOR_ATTACHMENT15,
+ atDepth = GL_DEPTH_ATTACHMENT,
+ atStencil = GL_STENCIL_ATTACHMENT);
+
+ TglcShaderType = (
+ stFragment = GL_FRAGMENT_SHADER,
+ stVertex = GL_VERTEX_SHADER
+{$IFNDEF OPENGL_ES}
+ , stGeometry = GL_GEOMETRY_SHADER
+ , stTessEvaluation = GL_TESS_EVALUATION_SHADER
+ , stTessControl = GL_TESS_CONTROL_SHADER
+{$ENDIF}
+ );
+
+ TglcBufferTarget = (
+ btArrayBuffer = GL_ARRAY_BUFFER,
+ btElementArrayBuffer = GL_ELEMENT_ARRAY_BUFFER);
+
+ TglcBufferUsage = (
+ buStreamDraw = GL_STREAM_DRAW,
+ buStreamRead = GL_STREAM_READ,
+ buStreamCopy = GL_STREAM_COPY,
+ buStaticDraw = GL_STATIC_DRAW,
+ buStaticRead = GL_STATIC_READ,
+ buStaticCopy = GL_STATIC_COPY,
+ buDynamicDraw = GL_DYNAMIC_DRAW,
+ buDynamicRead = GL_DYNAMIC_READ,
+ buDynamicCopy = GL_DYNAMIC_COPY);
+
+ TglcBufferAccess = (
+ baReadOnly = GL_READ_ONLY,
+ baWriteOnly = GL_WRITE_ONLY,
+ baReadWrite = GL_READ_WRITE);
+
+ EOpenGL = class(Exception)
+ private
+ fErrorCode: GLenum;
+ public
+ property ErrorCode: GLenum read fErrorCode;
+ constructor Create(const aErrorCode: GLenum);
+ constructor Create(const aMsg: String; const aErrorCode: GLenum);
+ end;
+
+procedure glcRenderFace(const aValue: TglcFace); inline;
+procedure glcDepthFunc(const aValue: TglcDepthFunc); inline;
+procedure glcBlendFunc(const aSource, aDest: TglcBlendFactor); inline; overload;
+procedure glcBlendFunc(const aMode: TglcBlendMode); inline; overload;
+procedure glcCheckAndRaiseError;
+{$IFNDEF OPENGL_ES}
+procedure glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode); inline;
+{$ENDIF}
+
+implementation
+
+type
+ TglcBlendModeValue = packed record
+ src, dst: TglcBlendFactor;
+ end;
+
+const
+ BLEND_MODE_VALUES: array[TglcBlendMode] of TglcBlendModeValue = (
+ (src: TglcBlendFactor.bfOne; dst: TglcBlendFactor.bfZero), //bmNone
+ (src: TglcBlendFactor.bfSrcAlpha; dst: TglcBlendFactor.bfOneMinusSrcAlpha), //bmAlphaBlend
+ (src: TglcBlendFactor.bfSrcAlpha; dst: TglcBlendFactor.bfOne), //bmAdditiveAlphaBlend
+ (src: TglcBlendFactor.bfOne; dst: TglcBlendFactor.bfOne)); //bmAdditiveBlend
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcRenderFace(const aValue: TglcFace);
+begin
+ case aValue of
+ TglcFace.faBoth: begin
+ glDisable(GL_CULL_FACE);
+ end;
+ TglcFace.faFront: begin
+ glEnable(GL_CULL_FACE);
+ glCullFace(GL_BACK);
+ end;
+ TglcFace.faBack: begin
+ glEnable(GL_CULL_FACE);
+ glCullFace(GL_FRONT);
+ end;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcDepthFunc(const aValue: TglcDepthFunc);
+begin
+ glDepthFunc(GLenum(aValue));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcBlendFunc(const aSource, aDest: TglcBlendFactor);
+begin
+ glBlendFunc(GLenum(aSource), GLenum(aDest));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcBlendFunc(const aMode: TglcBlendMode); overload;
+begin
+ glBlendFunc(GLenum(BLEND_MODE_VALUES[aMode].src), GLenum(BLEND_MODE_VALUES[aMode].dst));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcCheckAndRaiseError;
+var
+ e: GLenum;
+begin
+ e := glGetError();
+ if (e <> GL_NO_ERROR) then
+ raise EOpenGL.Create(e);
+end;
+
+{$IFNDEF OPENGL_ES}
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode);
+begin
+ glPolygonMode(GLenum(aFace), GLenum(aValue));
+end;
+{$ENDIF}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EOpenGL///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EOpenGL.Create(const aErrorCode: GLenum);
+begin
+ fErrorCode := aErrorCode;
+{$IFNDEF OPENGL_ES}
+ inherited Create(gluErrorString(fErrorCode));
+{$ELSE}
+ inherited Create('OpenGL Error: ' + IntToHex(fErrorCode, 8));
+{$ENDIF}
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EOpenGL.Create(const aMsg: String; const aErrorCode: GLenum);
+begin
+ fErrorCode := aErrorCode;
+{$IFNDEF OPENGL_ES}
+ inherited Create(aMsg + ': ' + gluErrorString(fErrorCode))
+{$ELSE}
+ inherited Create(aMsg + ': ' + IntToHex(fErrorCode, 8));
+{$ENDIF}
+end;
+
+end.
+
--- /dev/null
+unit uglcVertexArrayObject;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, contnrs, dglOpenGL, uglcArrayBuffer;
+
+type
+ EglcVertexArrayObject = class(Exception);
+ TglcVertexArrayObject = class(TObject)
+ private
+ fID: GLuint;
+ fArrayBuffers: TObjectList;
+ public
+ property ID: GLuint read fID;
+
+ procedure BindArrayBuffer(const aBuffer: TglcArrayBuffer; const aOwnsObject: Boolean);
+ procedure VertexAttribPointer(const aIndex: GLuint; const aSize: GLint; const aType: GLenum;
+ const aNormalized: GLboolean; const aStride: GLsizei; const aOffset: GLint);
+
+ procedure Bind;
+ procedure Unbind;
+
+ constructor Create;
+ destructor Destroy; override;
+ end;
+
+implementation
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcVertexArrayObject//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcVertexArrayObject.BindArrayBuffer(const aBuffer: TglcArrayBuffer; const aOwnsObject: Boolean);
+begin
+ Bind;
+ aBuffer.Bind;
+ if aOwnsObject and (fArrayBuffers.IndexOf(aBuffer) < 0) then
+ fArrayBuffers.Add(aBuffer);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcVertexArrayObject.VertexAttribPointer(const aIndex: GLuint; const aSize: GLint; const aType: GLenum;
+ const aNormalized: GLboolean; const aStride: GLsizei; const aOffset: GLint);
+begin
+ Bind;
+ glEnableVertexAttribArray(aIndex);
+ glVertexAttribPointer(aIndex, aSize, aType, aNormalized, aStride, Pointer(aOffset));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcVertexArrayObject.Bind;
+begin
+ glBindVertexArray(fID);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcVertexArrayObject.Unbind;
+begin
+ glBindVertexArray(0);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcVertexArrayObject.Create;
+begin
+ inherited Create;
+ if not GL_VERSION_3_0 and
+ not GL_ARB_vertex_array_object then
+ raise EglcVertexArrayObject.Create('vertex array objects are not supported by video vard');
+ glGenVertexArrays(1, @fID);
+ fArrayBuffers := TObjectList.Create(true);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcVertexArrayObject.Destroy;
+begin
+ glDeleteVertexArrays(1, @fID);
+ FreeAndNil(fArrayBuffers);
+ inherited Destroy;
+end;
+
+end.
+
--- /dev/null
+unit ugluMatrix;
+
+{ Package: OpenGLCore
+ Prefix: glu - OpenGL Utils
+ Beschreibung: diese Unit enthält Matrix-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, ugluVector;
+
+type
+ //Matrixtypen
+ TgluMatrix2ub = array[0..1] of TgluVector2ub;
+ TgluMatrix2i = array[0..1] of TgluVector2i;
+ TgluMatrix2f = array[0..1] of TgluVector2f;
+ TgluMatrix2d = array[0..1] of TgluVector2d;
+
+ TgluMatrix3ub = array[0..2] of TgluVector3ub;
+ TgluMatrix3i = array[0..2] of TgluVector3i;
+ TgluMatrix3f = array[0..2] of TgluVector3f;
+ TgluMatrix3d = array[0..2] of TgluVector3d;
+
+ TgluMatrix4ub = array[0..3] of TgluVector4ub;
+ TgluMatrix4i = array[0..3] of TgluVector4i;
+ TgluMatrix4f = array[0..3] of TgluVector4f;
+ TgluMatrix4d = array[0..3] of TgluVector4d;
+
+ //MatrixPointer
+ PgluMatrix2ub = ^TgluMatrix2ub;
+ PgluMatrix2i = ^TgluMatrix2i;
+ PgluMatrix2f = ^TgluMatrix2f;
+ PgluMatrix2d = ^TgluMatrix2d;
+
+ PgluMatrix3ub = ^TgluMatrix3ub;
+ PgluMatrix3i = ^TgluMatrix3i;
+ PgluMatrix3f = ^TgluMatrix3f;
+ PgluMatrix3d = ^TgluMatrix3d;
+
+ PgluMatrix4ub = ^TgluMatrix4ub;
+ PgluMatrix4i = ^TgluMatrix4i;
+ PgluMatrix4f = ^TgluMatrix4f;
+ PgluMatrix4d = ^TgluMatrix4d;
+
+ //Konstructoren
+ function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
+
+ //Matrixfunktionen
+ function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
+ function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f; overload;
+ function gluMatrixScale(const s: Single): TgluMatrix4f; overload;
+ function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
+ function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
+ function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+ function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f; overload;
+ function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f; overload;
+ function gluMatrixSubMatrix(const m:TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
+ function gluMatrixDeterminant(const m: TgluMatrix3f): Single; overload;
+ function gluMatrixDeterminant(const m: TgluMatrix4f): Single; overload;
+ function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
+ function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
+
+ operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
+ operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+ operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
+
+const
+ maAxisX = 0;
+ maAxisY = 1;
+ maAxisZ = 2;
+ maPos = 3;
+ gluMatrixIdentity: TgluMatrix4f = ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1));
+
+implementation
+
+uses
+ Math;
+
+operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
+begin
+ result := gluMatrixMult(m1, m2);
+end;
+
+operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+begin
+ result := gluMatrixMultVec(m, v);
+end;
+
+operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
+begin
+ result := gluVector3f(gluMatrixMultVec(m, gluVEctor4f(v, 1.0)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
+var
+ i, j: Integer;
+begin
+ for i := 0 to 3 do
+ for j := 0 to 3 do
+ result[i, j] := m[i, j];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Translationsmatrix
+//@v: Vektor der Translationsmatrix;
+function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
+var
+ i: Integer;
+begin
+ result := gluMatrixIdentity;
+ for i := 0 to 2 do
+ result[3, i] := v[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Skalierungsmatrix
+//@v: Vektor der Skalierungsmatrix;
+function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f;
+var
+ i: Integer;
+begin
+ result := gluMatrixIdentity;
+ for i := 0 to 2 do
+ result[i, i] := v[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluMatrixScale(const s: Single): TgluMatrix4f;
+var
+ i: Integer;
+begin
+ result := gluMatrixIdentity;
+ for i := 0 to 2 do
+ result[i, i] := s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Rotationsmatrix;
+//@axis: Achse um die gedreht werden soll;
+//@angle: Winkel mit dem gedreht werden soll;
+function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
+var
+ X, Y, Z, a, s, c: Single;
+begin
+ axis := gluVectorNormalize(axis);
+ X := axis[0];
+ Y := axis[1];
+ Z := axis[2];
+ a := angle/180*Pi;
+ s := sin(a);
+ c := cos(a);
+ result := gluMatrixIdentity;
+ result[maAxisX] := gluVector4f(
+ SQR(X) + (1-SQR(X))*c,
+ X*Y*(1-c) + Z*s,
+ X*Z*(1-c) - Y*s,
+ 0);
+ result[maAxisY] := gluVector4f(
+ X*Y*(1-c) - Z*s,
+ SQR(Y) + (1-SQR(Y))*c,
+ Y*Z*(1-c) + X*s,
+ 0);
+ result[maAxisZ] := gluVector4f(
+ X*Z*(1-c) + Y*s,
+ Y*Z*(1-c) - X*s,
+ SQR(Z) + (1-SQR(Z))*c,
+ 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Mutlipliziert Matrix1 mit Matrix2
+//@Matrix1: 1. Multiplikator;
+//@Matrix2: 2. Multiplikator;
+//@result: Matrix1 * Matrix2
+function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
+var
+ x, y, i: Integer;
+ sum: Single;
+begin
+ for x := 0 to 3 do begin
+ for y := 0 to 3 do begin
+ sum := 0;
+ for i := 0 to 3 do
+ sum := sum + m1[i, y] * m2[x, i];
+ result[x, y] := sum;
+ end;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Multiplizerit eine Matrix mit einem Vektor
+//@m: Matrix mit der multipliziert werden soll;
+//@v: Vektor mit dem multipliziert werden soll;
+//@result: Ergebnis der Multiplikation
+function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+var
+ i, j: Integer;
+ sum: Single;
+begin
+ for i := 0 to 3 do begin
+ sum := 0;
+ for j := 0 to 3 do
+ sum := sum + m[j,i] * v[j];
+ result[i] := sum;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Transponierte Matrix
+//@m: Matrix die Transponiert werden soll;
+//@result: Transponierte Matrix;
+function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f;
+var
+ i, j: Integer;
+begin
+ for i := 0 to 2 do
+ for j := 0 to 2 do
+ result[i, j] := m[j, i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Transponierte Matrix
+//@m: Matrix die Transponiert werden soll;
+//@result: Transponierte Matrix;
+function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f;
+var
+ i, j: Integer;
+begin
+ for i := 0 to 3 do
+ for j := 0 to 3 do
+ result[i, j] := m[j, i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ermittelt die Untermatrix einer Matrix
+//@m: Matrix derren Untermatrix berechnet werden soll;
+//@s: Spalte die gelöscht werden soll;
+//@z: Zeile die gelöscht werden soll;
+//@result: Untermatrix von m
+function gluMatrixSubMatrix(const m: TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
+var
+ x, y, i, j: Integer;
+begin
+ for i := 0 to 2 do
+ for j := 0 to 2 do begin
+ x := i;
+ y := j;
+ if (i >= s) then
+ inc(x);
+ if (j >= z) then
+ inc(y);
+ result[i, j] := m[x, y];
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Determinante einer Matrix
+//@m: Matrix derren Determinaten berechnet werden soll;
+//@result: Determinante von m
+function gluMatrixDeterminant(const m: TgluMatrix3f): Single;
+begin
+ result :=
+ m[0,0] * m[1,1] * m[2,2] +
+ m[1,0] * m[2,1] * m[0,2] +
+ m[2,0] * m[0,1] * m[1,2] -
+ m[2,0] * m[1,1] * m[0,2] -
+ m[1,0] * m[0,1] * m[2,2] -
+ m[0,0] * m[2,1] * m[1,2];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Determinante einer Matrix
+//@m: Matrix derren Determinaten berechnet werden soll;
+//@result: Determinante von m
+function gluMatrixDeterminant(const m: TgluMatrix4f): Single;
+var
+ i: Integer;
+begin
+ result := 0;
+ for i := 0 to 3 do
+ result := result + power(-1, i) * m[i, 0] * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, 0));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Adjunkte einer Matrix
+//@m: Matrix derren Adjunkte berechnet werden soll;
+//@result: Adjunkte von m
+function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
+var
+ i, j: Integer;
+begin
+ for i := 0 to 3 do
+ for j := 0 to 3 do
+ result[i, j] := power(-1, i+j) * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, j));
+ result := gluMatrixTranspose(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die inverse Matrix einer Matrix
+//@m: Matrix derren Inverse berechnet werden soll;
+//@result: Inverse Matrix von m;
+function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
+var
+ d: Single;
+ i, j: Integer;
+begin
+ d := gluMatrixDeterminant(m);
+ result := gluMatrixAdjoint(m);
+ for i := 0 to 3 do
+ for j := 0 to 3 do
+ result[i,j] := result[i,j] / d;
+end;
+
+end.
+
--- /dev/null
+unit ugluQuaternion;
+
+{ Package: OpenGLCore
+ Prefix: glu - OpenGL Utils
+ Beschreibung: diese Unit enthält Quaternion-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, ugluVector, ugluMatrix;
+
+type
+ TgluQuaternion = type TgluVector4f; // w,x,y,z
+
+{
+ Winkel : rad, außer glRotate-Komponenten
+ Absolute Werte : Orientation
+ Relative Werte/"Drehanweisungen" : Rotation
+ To/FromVector : Position im R^4
+
+ Alle Funktionen nehmen an, dass die Quaternion nur zur Rotation verwendet wird (kein Scale),
+ mathematisch also normalisiert ist. Es findet keine Überprüfung statt.
+}
+
+ //Quaternion Konstruktoren
+ function gluQuaternion(const W, X, Y, Z: Single): TgluQuaternion;
+ function gluQuaternionNormalize(const q: TgluQuaternion): TgluQuaternion;
+ procedure gluQuaternionNormalizeInplace(var q: TgluQuaternion);
+ function gluQuaternionToVector(const q: TgluQuaternion): TgluVector3f;
+ function gluVectorToQuaternion(const v: TgluVector3f): TgluQuaternion;
+
+ //Arithmetic
+ function gluQuaternionConjugate(const q: TgluQuaternion): TgluQuaternion;
+ function gluQuaternionMultiply(const l,r: TgluQuaternion): TgluQuaternion;
+ function gluQuaternionAdd(const a,b: TgluQuaternion): TgluQuaternion;
+ function gluQuaternionSubtract(const l,r: TgluQuaternion): TgluQuaternion;
+ function gluQuaternionScale(const q: TgluQuaternion; const f: Single): TgluQuaternion;
+
+
+ //To/From RotationMatrix
+ function gluQuaternionToMatrix(const q: TgluQuaternion): TgluMatrix4f;
+ function gluMatrixToQuaternion(const m: TgluMatrix4f): TgluQuaternion;
+
+ //To/From Axis/Angle {WINKEL IN °DEG}
+ function gluQuaternionToRotation(const q: TgluQuaternion; out angle: Single): TgluVector3f;
+ function gluRotationToQuaternion(const angle: Single; const axis: TgluVector3f): TgluQuaternion;
+
+ //Transforms
+ function gluQuaternionTransformVec(const q: TgluQuaternion; const v: TgluVector3f): TgluVector3f;
+
+ function gluQuaternionLookAt(const Location, Target, UpVector: TgluVector3f): TgluQuaternion;
+ //Rotation zw. Richtungen: Wie muss a modifiziert werden um b zu bekommen?
+ function gluVectorRotationTo(const a, b: TgluVector3f): TgluQuaternion;
+
+ //Modifying Quaternions
+ function gluQuaternionHalfAngle(const q: TgluQuaternion): TgluQuaternion;
+ function gluQuaternionAngleBetween(const a, b: TgluQuaternion): double;
+ function gluQuaternionSlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+ function gluQuaternionNlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+
+ operator +(const a, b: TgluQuaternion): TgluQuaternion;
+ operator -(const l, r: TgluQuaternion): TgluQuaternion;
+ operator *(const l, r: TgluQuaternion): TgluQuaternion;
+ operator *(const q: TgluQuaternion; const s: Single): TgluQuaternion;
+
+const
+ quW = 0;
+ quX = 1;
+ quY = 2;
+ quZ = 3;
+ gluQuaternionIdentity: TgluQuaternion = (1,0,0,0);
+
+implementation
+
+uses
+ Math;
+
+operator +(const a, b: TgluQuaternion): TgluQuaternion;
+begin
+ result := gluQuaternionAdd(a, b);
+end;
+
+operator -(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+ result := gluQuaternionSubtract(l, r);
+end;
+
+operator *(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+ result := gluQuaternionMultiply(l, r);
+end;
+
+operator *(const q: TgluQuaternion; const s: Single): TgluQuaternion;
+begin
+ result := gluQuaternionScale(q, s);
+end;
+
+function gluQuaternion(const W, X, Y, Z: Single): TgluQuaternion;
+begin
+ Result:= gluVector4f(W,X,Y,Z);
+end;
+
+function gluQuaternionNormalize(const q: TgluQuaternion): TgluQuaternion;
+begin
+ Result:= q;
+ gluQuaternionNormalizeInplace(Result);
+end;
+
+procedure gluQuaternionNormalizeInplace(var q: TgluQuaternion);
+var
+ s: Double;
+begin
+ s:= sqr(q[quX])+sqr(q[quY])+sqr(q[quZ])+sqr(q[quW]);
+ // already normalized?
+ if IsZero(s - 1) then
+ exit;
+ s:= 1/sqrt(s);
+ q[quX]:= q[quX] * s;
+ q[quY]:= q[quY] * s;
+ q[quZ]:= q[quZ] * s;
+ q[quW]:= q[quW] * s;
+end;
+
+function gluQuaternionToVector(const q: TgluQuaternion): TgluVector3f;
+begin
+ Result:= gluVector3f(q[quX], q[quY], q[quZ]);
+end;
+
+function gluVectorToQuaternion(const v: TgluVector3f): TgluQuaternion;
+begin
+ Result:= gluQuaternion(0, v[0], v[1], v[2]);
+end;
+
+
+function gluQuaternionConjugate(const q: TgluQuaternion): TgluQuaternion;
+begin
+ Result[quW] := q[quW];
+ Result[quX] := -q[quX];
+ Result[quY] := -q[quY];
+ Result[quZ] := -q[quZ];
+end;
+
+function gluQuaternionMultiply(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+ Result[quW] := -l[qux] * r[qux] - l[quy] * r[quy] - l[quz] * r[quz] + l[quw] * r[quw];
+ Result[quX] := l[qux] * r[quw] + l[quy] * r[quz] - l[quz] * r[quy] + l[quw] * r[qux];
+ Result[quY] := -l[qux] * r[quz] + l[quy] * r[quw] + l[quz] * r[qux] + l[quw] * r[quy];
+ Result[quZ] := l[qux] * r[quy] - l[quy] * r[qux] + l[quz] * r[quw] + l[quw] * r[quz];
+end;
+
+function gluQuaternionAdd(const a, b: TgluQuaternion): TgluQuaternion;
+begin
+ Result[quW] := a[quW] + b[quW];
+ Result[quX] := a[quX] + b[quX];
+ Result[quY] := a[quY] + b[quY];
+ Result[quZ] := a[quZ] + b[quZ];
+end;
+
+function gluQuaternionSubtract(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+ Result[quW] := l[quW] - r[quW];
+ Result[quX] := l[quX] - r[quX];
+ Result[quY] := l[quY] - r[quY];
+ Result[quZ] := l[quZ] - r[quZ];
+end;
+
+function gluQuaternionScale(const q: TgluQuaternion; const f: Single): TgluQuaternion;
+begin
+ Result[quW] := q[quW] * f;
+ Result[quX] := q[quX] * f;
+ Result[quY] := q[quY] * f;
+ Result[quZ] := q[quZ] * f;
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/index.htm
+function gluQuaternionToMatrix(const q: TgluQuaternion): TgluMatrix4f;
+var
+ qx,qy,qz,qw: Single;
+begin
+ qw:= q[quW];
+ qx:= q[quX];
+ qy:= q[quY];
+ qz:= q[quZ];
+ Result:= gluMatrixIdentity;
+ Result[maAxisX] := gluVector4f(
+ 1 - 2*SQR(qy) - 2*SQR(qz),
+ 2*qx*qy + 2*qz*qw,
+ 2*qx*qz - 2*qy*qw,
+ 0);
+ Result[maAxisY] := gluVector4f(
+ 2*qx*qy - 2*qz*qw,
+ 1 - 2*SQR(qx) - 2*SQR(qz),
+ 2*qy*qz + 2*qx*qw,
+ 0);
+ Result[maAxisZ] := gluVector4f(
+ 2*qx*qz + 2*qy*qw,
+ 2*qy*qz - 2*qx*qw,
+ 1 - 2*SQR(qx) - 2*SQR(qy),
+ 0);
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+function gluMatrixToQuaternion(const m: TgluMatrix4f): TgluQuaternion;
+var
+ trace, s: double;
+ q: TgluQuaternion;
+
+begin
+ trace := m[0][0] + m[1][1] + m[2][2]; // I removed + 1.0f; see discussion with Ethan
+ if( trace > 0 ) then begin// I changed M_EPSILON to 0
+ s := 0.5 / SQRT(trace+ 1.0);
+ q[quW] := 0.25 / s;
+ q[quX] := ( m[2][1] - m[1][2] ) * s;
+ q[quY] := ( m[0][2] - m[2][0] ) * s;
+ q[quZ] := ( m[1][0] - m[0][1] ) * s;
+ end else begin
+ if ( m[0][0] > m[1][1]) and (m[0][0] > m[2][2] ) then begin
+ s := 2.0 * SQRT( 1.0 + m[0][0] - m[1][1] - m[2][2]);
+ q[quW] := (m[2][1] - m[1][2] ) / s;
+ q[quX] := 0.25 * s;
+ q[quY] := (m[0][1] + m[1][0] ) / s;
+ q[quZ] := (m[0][2] + m[2][0] ) / s;
+ end else if (m[1][1] > m[2][2]) then begin
+ s := 2.0 * SQRT( 1.0 + m[1][1] - m[0][0] - m[2][2]);
+ q[quW] := (m[0][2] - m[2][0] ) / s;
+ q[quX] := (m[0][1] + m[1][0] ) / s;
+ q[quY] := 0.25 * s;
+ q[quZ] := (m[1][2] + m[2][1] ) / s;
+ end else begin
+ s := 2.0 * SQRT( 1.0 + m[2][2] - m[0][0] - m[1][1] );
+ q[quW] := (m[1][0] - m[0][1] ) / s;
+ q[quX] := (m[0][2] + m[2][0] ) / s;
+ q[quY] := (m[1][2] + m[2][1] ) / s;
+ q[quZ] := 0.25 * s;
+ end;
+ end;
+ Result:= q;
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
+function gluQuaternionToRotation(const q: TgluQuaternion; out angle: Single): TgluVector3f;
+var
+ s: double;
+begin
+ angle := radtodeg(2 * arccos(q[quW]));
+ s := sqrt(1-q[quW]*q[quW]); // assuming quaternion normalised then w is less than 1, so term always positive.
+ if (s < 0.001) then begin // test to avoid divide by zero, s is always positive due to sqrt
+ // if s close to zero then direction of axis not important
+ Result[0] := q[quX]; // if it is important that axis is normalised then replace with x=1; y=z=0;
+ Result[1] := q[quY];
+ Result[2] := q[quZ];
+ end else begin
+ Result[0] := q[quX] / s; // normalise axis
+ Result[1] := q[quY] / s;
+ Result[2] := q[quZ] / s;
+ end;
+end;
+
+function gluRotationToQuaternion(const angle: Single; const axis: TgluVector3f): TgluQuaternion;
+var
+ a: single;
+begin
+ a:= degtorad(angle) / 2;
+ Result:= gluQuaternion(
+ cos(a),
+ sin(a) * axis[0],
+ sin(a) * axis[1],
+ sin(a) * axis[2]);
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/index.htm
+function gluQuaternionTransformVec(const q: TgluQuaternion; const v: TgluVector3f): TgluVector3f;
+var
+ p: TgluQuaternion;
+begin
+ //Pout = q * Pin * q'
+ p:= gluQuaternionMultiply(q, gluVectorToQuaternion(v));
+ p:= gluQuaternionMultiply(p, gluQuaternionConjugate(q));
+ Result:= gluQuaternionToVector(p);
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/halfAngle.htm
+function gluQuaternionHalfAngle(const q: TgluQuaternion): TgluQuaternion;
+begin
+ Result:= q;
+ Result[quW]:= Result[quW] + 1;
+ gluQuaternionNormalizeInplace(Result);
+end;
+
+function gluQuaternionAngleBetween(const a, b: TgluQuaternion): double;
+var
+ cosHalfTheta: double;
+begin
+ cosHalfTheta:= a[quW] * b[quW] + a[quX] * b[quX] + a[quY] * b[quY] + a[quZ] * b[quZ];
+ Result:= arccos(cosHalfTheta) * 2;
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/index.htm
+function gluQuaternionSlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+var
+ qa,qb: TgluQuaternion;
+ cosHalfTheta, sinHalfTheta,
+ halfTheta,
+ ratioA, ratioB: double;
+begin
+ qa:= a;
+ qb:= b;
+ // Calculate angle between them.
+ cosHalfTheta:= a[quW] * b[quW] + a[quX] * b[quX] + a[quY] * b[quY] + a[quZ] * b[quZ];
+ if (cosHalfTheta < 0) then begin
+ qb:= gluQuaternion(
+ -b[quW],
+ -b[quX],
+ -b[quY],
+ b[quZ]
+ );
+ cosHalfTheta:= -cosHalfTheta;
+ end;
+
+ // if qa=qb or qa=-qb then theta = 0 and we can return qa
+ if abs(cosHalfTheta) >= 1.0 then begin
+ Result:= qa;
+ Exit;
+ end;
+
+ // Calculate temporary values.
+ halfTheta := arccos(cosHalfTheta);
+ sinHalfTheta := sqrt(1.0 - sqr(cosHalfTheta));
+ // if theta = 180 degrees then result is not fully defined
+ // we could rotate around any axis normal to qa or qb
+ if (abs(sinHalfTheta) < 0.001) then begin
+ Result:= gluQuaternionAdd(gluQuaternionScale(qa, 0.5), gluQuaternionScale(qb, 0.5));
+ exit
+ end;
+ ratioA := sin((1 - t) * halfTheta) / sinHalfTheta;
+ ratioB := sin(t * halfTheta) / sinHalfTheta;
+ //calculate Quaternion.
+ Result:= gluQuaternionAdd(gluQuaternionScale(qa, ratioA), gluQuaternionScale(qb, ratioB));
+end;
+
+function gluQuaternionNlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+begin
+ Result:= gluQuaternionAdd(a, gluQuaternionScale(gluQuaternionSubtract(b,a), t));
+ gluQuaternionNormalizeInplace(Result);
+end;
+
+function gluQuaternionLookAt(const Location, Target, UpVector: TgluVector3f): TgluQuaternion;
+var
+ front, up, right: TgluVector3f;
+ w4_recip: Single;
+begin
+ front:= gluVectorSubtract(Location, Target); // eigentlich falschrum. don't ask.
+ up:= UpVector;
+ gluVectorOrthoNormalize(front, up);
+ right:= gluVectorProduct(up, front);
+
+ Result[quW]:= SQRT(1 + right[0] + up[1] + front[2]) * 0.5;
+ w4_recip:= 1 / (4 * Result[quW]);
+
+ Result[quX]:= (front[1] - up[2]) * w4_recip;
+ Result[quY]:= (right[2] - front[0]) * w4_recip;
+ Result[quZ]:= (up[0] - right[1]) * w4_recip;
+end;
+
+function gluVectorRotationTo(const a, b: TgluVector3f): TgluQuaternion;
+var
+ d, qw: single;
+ ax: TgluVector3f;
+begin
+ d:=gluVectorScalar(a, b);
+ ax:= gluVectorProduct(a, b);
+ qw:= gluVectorLength(a) * gluVectorLength(b) + d;
+ if (qw < 0.0001) then begin // vectors are 180 degrees apart
+ Result:= gluQuaternion(0, -a[2],a[1],a[0]);
+ end else begin
+ Result:= gluQuaternion(qw, ax[0],ax[1],ax[2]);
+ end;
+ gluQuaternionNormalizeInplace(Result);
+end;
+
+end.
+
--- /dev/null
+unit ugluVector;
+
+{ Package: OpenGLCore
+ Prefix: glu - OpenGL Utils
+ Beschreibung: diese Unit enthält Vektor-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+ Classes, SysUtils, {$IFNDEF OPENGL_ES}dglOpenGL{$ELSE}dglOpenGLES{$ENDIF};
+
+type
+ //Vektortypen
+ TgluVector2ub = TGLVectorub2;
+ TgluVector3ub = TGLVectorub3;
+ TgluVector4ub = TGLVectorub4;
+
+ TgluVector2i = TGLVectori2;
+ TgluVector3i = TGLVectori3;
+ TgluVector4i = TGLVectori4;
+
+ TgluVector2e = array[0..1] of GLenum;
+ TgluVector3e = array[0..2] of GLenum;
+ TgluVector4e = array[0..3] of GLenum;
+
+ TgluVector2f = TGLVectorf2;
+ TgluVector3f = TGLVectorf3;
+ TgluVector4f = TGLVectorf4;
+
+ TgluVector2d = TGLVectord2;
+ TgluVector3d = TGLVectord3;
+ TgluVector4d = TGLVectord4;
+
+ TgluVector2p = TGLVectorp2;
+ TgluVector3p = TGLVectorp3;
+ TgluVector4p = TGLVectorp4;
+
+ TgluPlanef = TgluVector4f;
+
+ TgluVector3fArr8 = array[0..7] of TgluVector4f;
+ TgluRayf = packed record
+ p, v: TgluVector3f;
+ end;
+
+ TgluRecord2ub = packed record
+ case Integer of
+ 0: (x, y: gluByte);
+ 1: (s, t: gluByte);
+ 2: (u, v: gluByte);
+ 3: (vec: TgluVector2ub);
+ end;
+ TgluRecord3ub = packed record
+ case Integer of
+ 0: (x, y, z: gluByte);
+ 1: (r, g, b: gluByte);
+ 2: (u, v, w: gluByte);
+ 3: (vec: TgluVector3ub);
+ end;
+ TgluRecord4ub = packed record
+ case Integer of
+ 0: (x, y, z, w: gluByte);
+ 1: (r, g, b, a: gluByte);
+ 2: (vec: TgluVector4ub);
+ end;
+
+ TgluRecord2i = packed record
+ case Integer of
+ 0: (x, y: glInt);
+ 1: (s, t: glInt);
+ 2: (u, v: glInt);
+ 3: (vec: TgluVector2i);
+ end;
+ TgluRecord3i = packed record
+ case Integer of
+ 0: (x, y, z: glInt);
+ 1: (r, g, b: glInt);
+ 2: (u, v, w: glInt);
+ 3: (vec: TgluVector3i);
+ end;
+ TgluRecord4i = packed record
+ case Integer of
+ 0: (x, y, z, w: glInt);
+ 1: (r, g, b, a: glInt);
+ 2: (vec: TgluVector4i);
+ end;
+
+ TgluRecord2f = packed record
+ case Integer of
+ 0: (x, y: glFloat);
+ 1: (s, t: glFloat);
+ 2: (u, v: glFloat);
+ 3: (vec: TgluVector2f);
+ end;
+ TgluRecord3f = packed record
+ case Integer of
+ 0: (x, y, z: glFloat);
+ 1: (r, g, b: glFloat);
+ 2: (u, v, w: glFloat);
+ 3: (vec: TgluVector3f);
+ end;
+ TgluRecord4f = packed record
+ case Integer of
+ 0: (x, y, z, w: glFloat);
+ 1: (r, g, b, a: glFloat);
+ 2: (vec4: TgluVector4f);
+ 3: (vec3: TgluVector3f);
+ end;
+
+ TgluRecord2d = packed record
+ case Integer of
+ 0: (x, y: glDouble);
+ 1: (s, t: glDouble);
+ 2: (u, v: glDouble);
+ 3: (vec: TgluVector2d);
+ end;
+ TgluRecord3d = packed record
+ case Integer of
+ 0: (x, y, z: glDouble);
+ 1: (r, g, b: glDouble);
+ 2: (u, v, w: glDouble);
+ 3: (vec: TgluVector3d);
+ end;
+ TgluRecord4d = packed record
+ case Integer of
+ 0: (x, y, z, w: glDouble);
+ 1: (r, g, b, a: glDouble);
+ 2: (vec: TgluVector4d);
+ end;
+
+ //VectorPointer
+ PgluVector2i = ^TgluVector2i;
+ PgluVector3i = ^TgluVector3i;
+ PgluVector4i = ^TgluVector4i;
+
+ PgluVector2e = ^TgluVector2e;
+ PgluVector3e = ^TgluVector3e;
+ PgluVector4e = ^TgluVector4e;
+
+ PgluVector2ub = ^TgluVector2ub;
+ PgluVector3ub = ^TgluVector3ub;
+ PgluVector4ub = ^TgluVector4ub;
+
+ PgluVector2f = ^TgluVector2f;
+ PgluVector3f = ^TgluVector3f;
+ PgluVector4f = ^TgluVector4f;
+
+ PgluVector2d = ^TgluVector2d;
+ PgluVector3d = ^TgluVector3d;
+ PgluVector4d = ^TgluVector4d;
+
+ PgluVector2p = ^TgluVector2p;
+ PgluVector3p = ^TgluVector3p;
+ PgluVector4p = ^TgluVector4p;
+
+ TVectorColor = -$7FFFFFFF-1..$7FFFFFFF;
+
+ //Stream: Lese- und Schreibfunktionen
+ procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
+ procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
+ procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
+ function gluVector2fRead(const aStream: TStream): TgluVector2f;
+ function gluVector3fRead(const aStream: TStream): TgluVector3f;
+ function gluVector4fRead(const aStream: TStream): TgluVector4f;
+
+ //Vektor Konstruktoren
+ function gluVector4f(const X, Y, Z, W: Single): TgluVector4f;
+ function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
+ function gluVector4d(const X, Y, Z, W: Single): TgluVector4d;
+ function gluVector3f(const X, Y, Z: Single): TgluVector3f; overload;
+ function gluVector3f(const v: TgluVector4f): TgluVector3f; overload;
+ function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f; overload;
+ function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f; overload;
+ function gluVector2f(const X, Y: Single): TgluVector2f;
+ function gluVector2f(const v3: TgluVector3f): TgluVector2f;
+ function gluVector2f(const v4: TgluVector4f): TgluVector2f;
+ function gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
+ function gluVector2i(const X, Y: Integer): TgluVector2i;
+ function gluVector2e(const X, Y: GLenum): TgluVector2e;
+ function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
+ function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
+
+ //Vektorfunktionen
+ function gluVectorNormalize(const v: TgluVector4f): TgluVector4f; overload;
+ function gluVectorNormalize(const v: TgluVector3f): TgluVector3f; overload;
+ function gluVectorNormalize(const v: TgluVector2f): TgluVector2f; overload;
+ function gluVectorLength(const v: TgluVector3f): Single; overload;
+ function gluVectorLength(const v: TgluVector2f): Single; overload;
+ function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
+ function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
+ function gluVectorScalar(const v1, v2: TgluVector3f): Single; overload;
+ function gluVectorScalar(const v1, v2: TgluVector2f): Single; overload;
+ function gluVectorAngle(const v1, v2: TgluVector3f): Single; overload;
+ function gluVectorAngle(const v1, v2: TgluVector2f): Single; overload;
+ function gluVectorEquals(const v1, v2: TgluVector2f): Boolean; overload;
+ function gluVectorEquals(const v1, v2: TgluVector3f): Boolean; overload;
+ function gluVectorEquals(const v1, v2: TgluVector4f): Boolean; overload;
+ function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
+ function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
+ function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
+ function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
+ function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f; overload;
+ function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f; overload;
+ function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
+ function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
+ procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
+ function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
+
+ //Ebnenfunktionen
+ function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
+ function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
+ function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
+ function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
+
+ //Rayfunktionen
+ function gluRayf(const p, v: TgluVector3f): TgluRayf;
+ function gluRayNormalize(const r: TgluRayf): TgluRayf;
+ function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
+
+ //Vektor Aus- und Eingaben
+ function gluVector4fToStr(const v: TgluVector4f; const round: Integer = 3): String;
+ function gluVector3fToStr(const v: TgluVector3f; const round: Integer = 3): String;
+ function gluVector2fToStr(const v: TgluVector2f; const round: Integer = 3): String;
+ function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
+ function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
+ function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
+ function gluStrToVector4f(str: String): TgluVector4f;
+ function gluStrToVector3f(str: String): TgluVector3f;
+ function gluStrToVector2f(str: String): TgluVector2f;
+ function gluVector4iToStr(const v: TgluVector4i): String;
+ function gluVector3iToStr(const v: TgluVector3i): String;
+ function gluVector2iToStr(const v: TgluVector2i): String;
+ function gluStrToVector4i(const str: String): TgluVector4i;
+ function gluStrToVector3i(const str: String): TgluVector3i;
+ function gluStrToVector2i(const str: String): TgluVector2i;
+ function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
+ function gluVectorToColor(const v: TgluVector3f): TVectorColor; overload;
+ function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
+ function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
+ function gluVectorHSVColor(v: TgluVector3f): TgluVector3f; overload;
+ function gluVectorHSVColor(v: TgluVector4f): TgluVector4f; overload;
+
+ operator >< (const v1, v2: TgluVector3f): TgluVector3f; inline;
+
+ operator * (const v1, v2: TgluVector4f): Single; inline; overload;
+ operator * (const v1, v2: TgluVector3f): Single; inline; overload;
+ operator * (const v1, v2: TgluVector2f): Single; inline; overload;
+
+ operator * (const v: TgluVector2f; const s: Single): TgluVector2f; inline; overload;
+ operator * (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
+ operator * (const v: TgluVector4f; const s: Single): TgluVector4f; inline; overload;
+
+ operator * (const s: Single; const v: TgluVector2f): TgluVector2f; inline; overload;
+ operator * (const s: Single; const v: TgluVector3f): TgluVector3f; inline; overload;
+ operator * (const s: Single; const v: TgluVector4f): TgluVector4f; inline; overload;
+
+ operator / (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
+
+ operator = (const v1, v2: TgluVector2f): Boolean; inline; overload;
+ operator = (const v1, v2: TgluVector3f): Boolean; inline; overload;
+ operator = (const v1, v2: TgluVector4f): Boolean; inline; overload;
+
+ operator + (const v1, v2: TgluVector3f): TgluVector3f; inline;
+ operator - (const v1, v2: TgluVector3f): TgluVector3f; inline;
+
+const
+ gluVectorNull : TgluVector3f = (0,0,0);
+ gluVectorUnitX: TgluVector3f = (1,0,0);
+ gluVectorUnitY: TgluVector3f = (0,1,0);
+ gluVectorUnitZ: TgluVector3f = (0,0,1);
+
+implementation
+
+uses
+ Math;
+
+operator >< (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+ result := gluVectorProduct(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector4f): Single;
+begin
+ result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector3f): Single;
+begin
+ result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector2f): Single;
+begin
+ result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v: TgluVector2f; const s: Single): TgluVector2f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator * (const v: TgluVector3f; const s: Single): TgluVector3f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator * (const v: TgluVector4f; const s: Single): TgluVector4f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector2f): TgluVector2f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector3f): TgluVector3f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector4f): TgluVector4f;
+begin
+ result := gluVectorMult(v, s);
+end;
+
+operator / (const v: TgluVector3f; const s: Single): TgluVector3f;
+begin
+ result := gluVectorDivide(v, s);
+end;
+
+operator = (const v1, v2: TgluVector2f): Boolean;
+begin
+ result := gluVectorEquals(v1, v2);
+end;
+
+operator = (const v1, v2: TgluVector3f): Boolean;
+begin
+ result := gluVectorEquals(v1, v2);
+end;
+
+operator = (const v1, v2: TgluVector4f): Boolean;
+begin
+ result := gluVectorEquals(v1, v2);
+end;
+
+operator + (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+ result := gluVectorAdd(v1, v2);
+end;
+
+operator - (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+ result := gluVectorSubtract(v1, v2);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
+begin
+ aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
+begin
+ aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
+begin
+ aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function gluVector2fRead(const aStream: TStream): TgluVector2f;
+begin
+ if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+ raise Exception.Create('gluVector2fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function gluVector3fRead(const aStream: TStream): TgluVector3f;
+begin
+ if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+ raise Exception.Create('gluVector3fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function gluVector4fRead(const aStream: TStream): TgluVector4f;
+begin
+ if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+ raise Exception.Create('gluVector4fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector4f(const X,Y,Z,W: Single): TgluVector4f;
+begin
+ result[0] := X;
+ result[1] := Y;
+ result[2] := Z;
+ result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
+begin
+ PgluVector3f(@result[0])^ := aVec;
+ result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector4d(const X,Y,Z,W: Single): TgluVector4d;
+begin
+ result[0] := X;
+ result[1] := Y;
+ result[2] := Z;
+ result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@X: 1. Wert im Vector;
+//@Y: 2. Wert im Vector;
+//@Z: 3. Wert im Vector;
+function gluVector3f(const X,Y,Z: Single): TgluVector3f;
+begin
+ result[0] := X;
+ result[1] := Y;
+ result[2] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@v: 4-Komponenten Vektor aus dem der Vektor erstellt werden soll;
+function gluVector3f(const v: TgluVector4f): TgluVector3f;
+begin
+ result := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f;
+begin
+ result[0] := v[0];
+ result[1] := v[1];
+ result[2] := z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erzeugt einen Vektor aus 2 Punkten
+//@p1: Punkt 1;
+//@p2: Punkt 2;
+//@result: Vektor zwischen den Punkten
+function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f;
+var
+ i: Integer;
+begin
+ for i := 0 to 2 do
+ result[i] := p2[i] - p1[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@X: 1. Wert im Vector;
+//@Y: 2. Wert im Vector;
+function gluVector2f(const X,Y: Single): TgluVector2f;
+begin
+ result[0] := X;
+ result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2f(const v3: TgluVector3f): TgluVector2f;
+begin
+ result[0] := v3[0];
+ result[1] := v3[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2f(const v4: TgluVector4f): TgluVector2f;
+begin
+ result[0] := v4[0];
+ result[1] := v4[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
+begin
+ result[0] := W;
+ result[1] := X;
+ result[2] := Y;
+ result[3] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector2i(const X, Y: Integer): TgluVector2i;
+begin
+ result[0] := X;
+ result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2e(const X, Y: GLenum): TgluVector2e;
+begin
+ result[0] := X;
+ result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
+begin
+ result[0] := X;
+ result[1] := Y;
+ result[2] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
+begin
+ result[0] := X;
+ result[1] := Y;
+ result[2] := Z;
+ result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorNormalize(const v: TgluVector4f): TgluVector4f;
+begin
+ result := v;
+ if (result[3] <> 0) then
+ result := gluVectorMult(result, result[3]);
+ PgluVector3f(@result[0])^ := gluVectorNormalize(PgluVector3f(@result[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Normalisiert einen Vector
+//@v: Vector der normalisiert werden soll;
+//@result: normalisierter Vector;
+function gluVectorNormalize(const v: TgluVector3f): TgluVector3f;
+var len: Single;
+begin
+ len := gluVectorLength(v);
+ if (len > 0) then begin
+ result[0] := v[0]/len;
+ result[1] := v[1]/len;
+ result[2] := v[2]/len;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Normalisiert einen Vector
+//@v: Vector der normalisiert werden soll;
+//@result: normalisierter Vector;
+function gluVectorNormalize(const v: TgluVector2f): TgluVector2f;
+var len: Single;
+begin
+ len := gluVectorLength(v);
+ result[0] := v[0]/len;
+ result[1] := v[1]/len;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Länge eines Vectors
+//@v: Vector dessen Länge berechnet werden soll;
+//@result: Lange des Vectors;
+function gluVectorLength(const v: TgluVector3f): Single;
+begin
+ result := SQRT(SQR(v[0])+SQR(v[1])+SQR(v[2]));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Länge eines Vectors
+//@v: Vector dessen Länge berechnet werden soll;
+//@result: Lange des Vectors;
+function gluVectorLength(const v: TgluVector2f): Single;
+begin
+ result := SQRT(SQR(v[0])+SQR(v[1]));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das VektorProdukt aus den Übergebenen Vektoren
+//@v1: 1. Vektor;
+//@v2: 2. Vektor;
+//@result: Vektor des Vektorprodukts aus v1 und v2;
+function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
+begin
+ result[0] := v1[1]*v2[2] - v1[2]*v2[1];
+ result[1] := v1[2]*v2[0] - v1[0]*v2[2];
+ result[2] := v1[0]*v2[1] - v1[1]*v2[0];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
+begin
+ result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector3f): Single;
+begin
+ result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector2f): Single;
+begin
+ result := v1[0]*v2[0] + v1[1]*v2[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet den Winkel zwischen den übergebenen Vectoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Winkel zwischen v1 und v2;
+function gluVectorAngle(const v1, v2: TgluVector3f): Single;
+begin
+ result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet den Winkel zwischen den übergebenen Vectoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Winkel zwischen v1 und v2;
+function gluVectorAngle(const v1, v2: TgluVector2f): Single;
+begin
+ result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector2f): Boolean;
+begin
+ result := (v1[0] = v2[0]) and (v1[1] = v2[1]);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector3f): Boolean;
+begin
+ result := (v1[2] = v2[2]) and gluVectorEquals(PgluVector2f(@v1[0])^, PgluVector2f(@v2[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector4f): Boolean;
+begin
+ result := (v1[3] = v2[3]) and gluVectorEquals(PgluVector3f(@v1[0])^, PgluVector3f(@v2[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
+begin
+ result[0] := v[0] * s;
+ result[1] := v[1] * s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//multipliziert den Vektor mit einem Skalar
+//@v: Vektor der multipliziert werden soll;
+//@s: Skalar;
+//@result: Elementweise multiplizierter Vektor;
+function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
+var
+ i: Integer;
+begin
+ for i := 0 to 2 do
+ result[i] := v[i] * s;
+end;
+
+function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do
+ result[i] := v[i] * s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
+var
+ i: Integer;
+begin
+ for i := 0 to 3 do
+ result[i] := v[i] / s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f;
+var i: Integer;
+begin
+ for i := 0 to High(v) do
+ result[i] := Min(Max(v[i], aMin), aMax);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f;
+var i: Integer;
+begin
+ for i := 0 to High(v) do
+ result[i] := Min(Max(v[i], aMin), aMax);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//addiert zwei Vektoren
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+//@result: elementweise Summe der beiden Vektoren;
+function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
+var
+ i: Integer;
+begin
+ for i := 0 to 2 do
+ result[i] := v1[i] + v2[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//subtrahiert zwei Vektoren
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+//@result: elementweise Differenz der beiden Vektoren;
+function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
+var
+ i: Integer;
+begin
+ for i := 0 to 2 do
+ result[i] := v1[i] - v2[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Verändert die Vektoren so, dass sie orthogonal und normalisiert sind, bleibt dabei in der gleichen Ebene
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
+var
+ proj: TgluVector3f;
+begin
+ reference:= gluVectorNormalize(reference);
+
+ proj:= gluVectorMult(reference, gluVectorScalar(tangent, reference));
+ tangent:= gluVectorSubtract(tangent, proj);
+ tangent:= gluVectorNormalize(tangent);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet den übergebenen Vector in absolute (matrixunabhängige) Raumkoordinaten um
+//@v: Vector dessen absolute Koordinaten bestimmt werden sollen;
+//@result: absolute Raumkoordianten des Vectors v;
+function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
+var
+ v4: TgluVector4f;
+ sum: Single;
+ i, j: Integer;
+ m: array[0..3, 0..3] of GLfloat;
+begin
+ for i := 0 to 2 do
+ v4[i] := v[i];
+ v4[3] := 1;
+ glGetFloatv(GL_MODELVIEW_MATRIX, @m[0, 0]);
+ for i := 0 to 2 do begin
+ sum := 0;
+ for j := 0 to 3 do begin
+ sum := sum + m[j, i]*v4[j];
+ end;
+ result[i] := sum;
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet eine Ebene die durch 3 Punkte bestimmt wird
+//@p1: Punkt 1;
+//@p2: Punkt 2, Punkt auf dem der Normalenvekrtor steht;
+//@p3: Punkt 3;
+//@result: Parameter der Ebene (0, 1, 2: Normalvektor; 3: Abstand);
+function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
+var
+ n, v1, v2: TgluVector3f;
+begin
+ v1 := gluVector3f(p2, p1);
+ v2 := gluVector3f(p2, p3);
+ n := gluVectorProduct(v1, v2);
+ result := gluPlanef(n, p2);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
+var
+ d: Single;
+begin
+ d := gluVectorScalar(n, p);
+ PgluVector3f(@result)^ := n;
+ result[3] := -d;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//normalisiert die Parameter einer Ebene
+//@p: Parameter der Ebene;
+//@result: normalisierte Prameter der Ebene;
+function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
+var
+ m: Single;
+ i: Integer;
+begin
+ m := Sqrt(Sqr(p[0]) + Sqr(p[1]) + Sqr(p[2]));
+ for i := 0 to 3 do
+ result[i] := p[i] / m;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
+var
+ lambda, real: Double;
+ i: Integer;
+begin
+ result := false;
+ lambda := 0;
+ real := 0;
+ for i := 0 to 2 do begin
+ lambda := lambda + aRay.v[i] * aPlane[i];
+ real := real + aRay.p[i] * aPlane[i];
+ end;
+ if (lambda = 0) then begin
+ aPoint := gluVector3f(0, 0, 0);
+ exit;
+ end;
+ lambda := (aPlane[3] - real) / lambda;
+ aPoint := gluRayPoint(aRay, -lambda);
+ result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayf(const p, v: TgluVector3f): TgluRayf;
+begin
+ result.p := p;
+ result.v := v;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayNormalize(const r: TgluRayf): TgluRayf;
+begin
+ result.p := r.p;
+ result.v := gluVectorNormalize(r.v);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
+begin
+ result := gluVectorAdd(r.p, gluVectorMult(r.v, lambda));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector4fToStr(const v: TgluVector4f; const round: Integer): String;
+var
+ f: TFormatSettings;
+begin
+ f.DecimalSeparator := '.';
+ if (round >= 0) then
+ result := Format('%.*f; %.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2], round, v[3]], f)
+ else
+ result := Format('%f; %f; %f; %f;', [v[0], v[1], v[2], v[3]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector3fToStr(const v: TgluVector3f; const round: Integer): String;
+var
+ f: TFormatSettings;
+begin
+ f.DecimalSeparator := '.';
+ if (round >= 0) then
+ result := Format('%.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2]], f)
+ else
+ result := Format('%f; %f; %f;', [v[0], v[1], v[2]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector2fToStr(const v: TgluVector2f; const round: Integer): String;
+var
+ f: TFormatSettings;
+begin
+ f.DecimalSeparator := '.';
+ if (round >= 0) then
+ result := Format('%.*f; %.*f;', [round, v[0], round, v[1]], f)
+ else
+ result := Format('%f; %f;', [v[0], v[1]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluStrToVectorIntern(str: String; const aAbortOnFailure: Boolean; out aVec: TgluVector4f): Boolean;
+var
+ i, j, p, l: Integer;
+ s: String;
+ format: TFormatSettings;
+ v: Single;
+begin
+ result := false;
+ FillChar(aVec{%H-}, SizeOf(aVec), 0);
+ FillChar(format{%H-}, SizeOf(format), 0);
+ format.DecimalSeparator := '.';
+ if (Length(str) > 0) and (str[Length(str)] <> ';') then
+ str := str + ';';
+ j := 0;
+ i := 1;
+ p := 1;
+ l := Length(str);
+ while (i <= l) do begin
+ if str[i] = ';' then begin
+ s := Trim(copy(str, p, i-p));
+ if not TryStrToFloat(s, v, format) then begin
+ if aAbortOnFailure then
+ exit;
+ v := 0;
+ end;
+ aVec[j] := v;
+ inc(j);
+ p := i+1;
+ end;
+ inc(i);
+ end;
+ result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
+begin
+ result := gluStrToVectorIntern(str, true, aVec);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
+var
+ v: TgluVector4f;
+begin
+ if (Length(str) > 0) and (str[Length(str)] <> ';') then
+ str := str + ';';
+ result := gluTryStrToVector4f(str+'0;', v);
+ aVec := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
+var
+ v: TgluVector4f;
+begin
+ if (Length(str) > 0) and (str[Length(str)] <> ';') then
+ str := str + ';';
+ result := gluTryStrToVector4f(str+'0;0;', v);
+ aVec := PgluVector2f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector4f(str: String): TgluVector4f;
+begin
+ gluStrToVectorIntern(str, false, result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector3f(str: String): TgluVector3f;
+var
+ v: TgluVector4f;
+begin
+ if (Length(str) > 0) and (str[Length(str)] <> ';') then
+ str := str + ';';
+ v := gluStrToVector4f(str+'0;');
+ result := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector2f(str: String): TgluVector2f;
+var
+ v: TgluVector3f;
+begin
+ if (Length(str) > 0) and (str[Length(str)] <> ';') then
+ str := str + ';';
+ v := gluStrToVector3f(str+'0;');
+ result := PgluVector2f(@v[0])^;
+end;
+
+function gluVector4iToStr(const v: TgluVector4i): String;
+begin
+ Result:= Format('%d;%d;%d;%d;',[v[0],v[1],v[2],v[3]]);
+end;
+
+function gluVector3iToStr(const v: TgluVector3i): String;
+begin
+ Result:= Format('%d;%d;%d;',[v[0],v[1],v[2]]);
+end;
+
+function gluVector2iToStr(const v: TgluVector2i): String;
+begin
+ Result:= Format('%d;%d;',[v[0],v[1]]);
+end;
+
+function gluStrToVector4i(const str: String): TgluVector4i;
+var
+ i, j, p, l: Integer;
+ v: integer;
+begin
+ FillChar(result{%H-}, SizeOf(result), 0);
+ j := 0;
+ i := 1;
+ p := 1;
+ l := Length(str);
+ while (i <= l) do begin
+ if str[i] = ';' then begin
+ if not TryStrToInt(copy(str, p, i-p), v) then
+ v := 0;
+ result[j] := v;
+ inc(j);
+ p := i+1;
+ end;
+ inc(i);
+ end;
+end;
+
+function gluStrToVector3i(const str: String): TgluVector3i;
+var
+ v: TgluVector4i;
+begin
+ v := gluStrToVector4i(str+'0;');
+ result := PgluVector3i(@v[0])^;
+end;
+
+function gluStrToVector2i(const str: String): TgluVector2i;
+var
+ v: TgluVector3i;
+begin
+ v := gluStrToVector3i(str+'0;');
+ result := PgluVector2i(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen Vektor in eine Farbe um
+//@v: Vektor der umgewandelt werden soll;
+//@result: Farbe;
+function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
+begin
+ result := gluVectorToColor(PgluVector3f(@v[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen Vektor in eine Farbe um
+//@v: Vektor der umgewandelt werden soll;
+//@result: Farbe;
+function gluVectorToColor(const v: TgluVector3f): TVectorColor;
+var
+ r, g, b: Byte;
+begin
+ r := round(255*v[0]);
+ g := round(255*v[1]);
+ b := round(255*v[2]);
+ result := r + (g shl 8) + (b shl 16);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
+begin
+ result[0] := ( c and $FF) / 255;
+ result[1] := ((c shr 8) and $FF) / 255;
+ result[2] := ((c shr 16) and $FF) / 255;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
+begin
+ PgluVector3f(@result[0])^ := gluColorToVector3f(c);
+ result[3] := a;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
+//@v: Farbe im HSV-Farbraum;
+//@result: Farbe im RGB-Farbraum;
+function gluVectorHSVColor(v: TgluVector3f): TgluVector3f;
+const
+ _H = 0;
+ _S = 1;
+ _V = 2;
+var
+ h: Integer;
+ f, p, q, t: Single;
+begin
+ v[_H] := 360*v[_H];
+//H normieren
+ while (v[_H] < 0) do
+ v[_H] := v[_H] + 360;
+ while (v[_H] > 360) do
+ v[_H] := v[_H] - 360;
+//V normieren
+ if (v[_V] < 0) then
+ v[_V] := 0;
+ if (v[_V] > 1) then
+ v[_V] := 1;
+
+ h := Floor(v[_H] / 60);
+ f := v[_H]/60 - h;
+ p := v[_V] * (1 - v[_S]);
+ q := v[_V] * (1 - v[_S] * f);
+ t := v[_V] * (1 - v[_S] * (1 - f));
+ case h of
+ 1: result := gluVector3f(q, v[_V], p);
+ 2: result := gluVector3f(p, v[_V], t);
+ 3: result := gluVector3f(p, q, v[_V]);
+ 4: result := gluVector3f(t, p, v[_V]);
+ 5: result := gluVector3f(v[_V], p, q);
+ else
+ result := gluVector3f(v[_V], t, p);
+ end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
+//@v: Farbe im HSV-Farbraum;
+//@result: Farbe im RGB-Farbraum;
+function gluVectorHSVColor(v: TgluVector4f): TgluVector4f;
+begin
+ PgluVector3f(@result)^ := gluVectorHSVColor(PgluVector3f(@v)^);
+ result[3] := v[3];
+end;
+
+end.
+
projects / LazOpenGLCore.git / commitdiff
