From: Bergmann89 Date: Sat, 7 Mar 2015 12:32:09 +0000 (+0100) Subject: Merge remote-tracking branch 'glBitmap@DGL/master' X-Git-Url: https://git.delphigl.com/?p=LazOpenGLCore.git;a=commitdiff_plain;h=HEAD;hp=821046d4db90afd95fbbd2c0e1335f58fed38c31 Merge remote-tracking branch 'glBitmap@DGL/master' Conflicts: uglcBitmap.pas --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f1ff06d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +lib/ \ No newline at end of file diff --git a/dglOpenGL.pas b/dglOpenGL.pas new file mode 100644 index 0000000..5d2a5ed --- /dev/null +++ b/dglOpenGL.pas @@ -0,0 +1,20340 @@ +{ ============================================================================ + + 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. + diff --git a/doc/AllClasses.html b/doc/AllClasses.html deleted file mode 100644 index 2e3ad84..0000000 --- a/doc/AllClasses.html +++ /dev/null @@ -1,112 +0,0 @@ - - - -All Classes, Interfaces, Objects and Records - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Classes, Interfaces, Objects and Records

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameUnitDescription
EglBitmapglBitmap

glBitmap exception

EglBitmapNonPowerOfTwoglBitmap

exception for non power of two textures

EglBitmapNotSupportedglBitmap

exception for not supported functions

EglBitmapSizeToLargeglBitmap

exception for to large textures

EglBitmapUnsupportedFormatglBitmap

exception for unsupporetd formats

TglBitmapglBitmap

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

TglBitmap1DglBitmap

wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread

TglBitmap2DglBitmap

wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread

TglBitmapCubeMapglBitmap

wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread

TglBitmapDataglBitmap

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

TglBitmapFormatDescriptorglBitmap

describes the properties of a given texture data format

TglBitmapFunctionRecglBitmap

structure to store data for converting in

TglBitmapNormalMapglBitmap

wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread

TglBitmapPixelDataglBitmap

structure to store pixel data in

TglBitmapRec4ubglBitmap

record that stores 4 unsigned byte values

TglBitmapRec4uiglBitmap

record that stores 4 unsigned integer values

TglBitmapRec4ulglBitmap

record that stores 4 unsigned long integer values

TglBitmapSizeglBitmap

 

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllConstants.html b/doc/AllConstants.html deleted file mode 100644 index 441bc1d..0000000 --- a/doc/AllConstants.html +++ /dev/null @@ -1,27 +0,0 @@ - - - -All Constants - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Constants

- - - - - - - - - - - -
NameUnitDescription
NULL_SIZEglBitmap

 

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllFunctions.html b/doc/AllFunctions.html deleted file mode 100644 index f0d37eb..0000000 --- a/doc/AllFunctions.html +++ /dev/null @@ -1,132 +0,0 @@ - - - -All Functions and Procedures - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Functions and Procedures

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameUnitDescription
glBitmapCreateTestDataglBitmap

 

glBitmapGetDefaultDeleteTextureOnFreeglBitmap

 

glBitmapGetDefaultFilterglBitmap

 

glBitmapGetDefaultFormatglBitmap

 

glBitmapGetDefaultFreeDataAfterGenTextureglBitmap

 

glBitmapGetDefaultMipmapglBitmap

 

glBitmapGetDefaultSwizzleglBitmap

 

glBitmapGetDefaultTextureWrapglBitmap

 

glBitmapPositionglBitmap

 

glBitmapRec4ubglBitmap

 

glBitmapRec4ubCompareglBitmap

 

glBitmapRec4uiglBitmap

 

glBitmapRec4uiCompareglBitmap

 

glBitmapRec4ulglBitmap

 

glBitmapSetDefaultDeleteTextureOnFreeglBitmap

 

glBitmapSetDefaultFilterglBitmap

 

glBitmapSetDefaultFormatglBitmap

 

glBitmapSetDefaultFreeDataAfterGenTextureglBitmap

 

glBitmapSetDefaultMipmapglBitmap

 

glBitmapSetDefaultSwizzleglBitmap

 

glBitmapSetDefaultWrapglBitmap

 

glBitmapSizeglBitmap

 

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllIdentifiers.html b/doc/AllIdentifiers.html deleted file mode 100644 index e5ed18c..0000000 --- a/doc/AllIdentifiers.html +++ /dev/null @@ -1,272 +0,0 @@ - - - -All Identifiers - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Identifiers

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameUnitDescription
EglBitmapglBitmap

glBitmap exception

EglBitmapNonPowerOfTwoglBitmap

exception for non power of two textures

EglBitmapNotSupportedglBitmap

exception for not supported functions

EglBitmapSizeToLargeglBitmap

exception for to large textures

EglBitmapUnsupportedFormatglBitmap

exception for unsupporetd formats

glBitmapCreateTestDataglBitmap

 

glBitmapGetDefaultDeleteTextureOnFreeglBitmap

 

glBitmapGetDefaultFilterglBitmap

 

glBitmapGetDefaultFormatglBitmap

 

glBitmapGetDefaultFreeDataAfterGenTextureglBitmap

 

glBitmapGetDefaultMipmapglBitmap

 

glBitmapGetDefaultSwizzleglBitmap

 

glBitmapGetDefaultTextureWrapglBitmap

 

glBitmapPositionglBitmap

 

glBitmapRec4ubglBitmap

 

glBitmapRec4ubCompareglBitmap

 

glBitmapRec4uiglBitmap

 

glBitmapRec4uiCompareglBitmap

 

glBitmapRec4ulglBitmap

 

glBitmapSetDefaultDeleteTextureOnFreeglBitmap

 

glBitmapSetDefaultFilterglBitmap

 

glBitmapSetDefaultFormatglBitmap

 

glBitmapSetDefaultFreeDataAfterGenTextureglBitmap

 

glBitmapSetDefaultMipmapglBitmap

 

glBitmapSetDefaultSwizzleglBitmap

 

glBitmapSetDefaultWrapglBitmap

 

glBitmapSizeglBitmap

 

NULL_SIZEglBitmap

 

PglBitmapPixelDataglBitmap

 

TglBitmapglBitmap

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

TglBitmap1DglBitmap

wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread

TglBitmap2DglBitmap

wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread

TglBitmapCubeMapglBitmap

wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread

TglBitmapDataglBitmap

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

TglBitmapFileTypeglBitmap

type to define suitable file formats

TglBitmapFileTypesglBitmap

 

TglBitmapFormatglBitmap

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

TglBitmapFormatDescriptorglBitmap

describes the properties of a given texture data format

TglBitmapFunctionglBitmap

callback to use for converting texture data

TglBitmapFunctionRecglBitmap

structure to store data for converting in

TglBitmapMipMapglBitmap

possible mipmap types

TglBitmapNormalMapglBitmap

wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread

TglBitmapNormalMapFuncglBitmap

possible normal map functions

TglBitmapPixelDataglBitmap

structure to store pixel data in

TglBitmapPixelPositionglBitmap

 

TglBitmapRec4ubglBitmap

record that stores 4 unsigned byte values

TglBitmapRec4uiglBitmap

record that stores 4 unsigned integer values

TglBitmapRec4ulglBitmap

record that stores 4 unsigned long integer values

TglBitmapSizeglBitmap

 

TglBitmapSizeFieldsglBitmap

 

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllTypes.html b/doc/AllTypes.html deleted file mode 100644 index 77dd4d1..0000000 --- a/doc/AllTypes.html +++ /dev/null @@ -1,67 +0,0 @@ - - - -All Types - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Types

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameUnitDescription
PglBitmapPixelDataglBitmap

 

TglBitmapFileTypeglBitmap

type to define suitable file formats

TglBitmapFileTypesglBitmap

 

TglBitmapFormatglBitmap

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

TglBitmapFunctionglBitmap

callback to use for converting texture data

TglBitmapMipMapglBitmap

possible mipmap types

TglBitmapNormalMapFuncglBitmap

possible normal map functions

TglBitmapPixelPositionglBitmap

 

TglBitmapSizeFieldsglBitmap

 

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllUnits.html b/doc/AllUnits.html deleted file mode 100644 index 063a13d..0000000 --- a/doc/AllUnits.html +++ /dev/null @@ -1,31 +0,0 @@ - - - -All Units - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Units

- - - - - - - - - -
NameDescription
glBitmap

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

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

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

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

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/AllVariables.html b/doc/AllVariables.html deleted file mode 100644 index 5729fdf..0000000 --- a/doc/AllVariables.html +++ /dev/null @@ -1,17 +0,0 @@ - - - -All Variables - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Variables

-

-The units do not contain any variables.

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/ClassHierarchy.html b/doc/ClassHierarchy.html deleted file mode 100644 index 35c6c33..0000000 --- a/doc/ClassHierarchy.html +++ /dev/null @@ -1,35 +0,0 @@ - - - -Class Hierarchy - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class Hierarchy

- -
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/PasDocSettings.pds b/doc/PasDocSettings.pds deleted file mode 100644 index 4d1d158..0000000 --- a/doc/PasDocSettings.pds +++ /dev/null @@ -1,72 +0,0 @@ -[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 diff --git a/doc/automated.gif b/doc/automated.gif deleted file mode 100644 index 7c271d8..0000000 Binary files a/doc/automated.gif and /dev/null differ diff --git a/doc/glBitmap.EglBitmap.html b/doc/glBitmap.EglBitmap.html deleted file mode 100644 index b1ab820..0000000 --- a/doc/glBitmap.EglBitmap.html +++ /dev/null @@ -1,29 +0,0 @@ - - - -glBitmap: Class EglBitmap - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class EglBitmap

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type EglBitmap = class(Exception)

-

Description

-

-glBitmap exception

-

Hierarchy

-
  • Exception
    • -
  • EglBitmap
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.EglBitmapNonPowerOfTwo.html b/doc/glBitmap.EglBitmapNonPowerOfTwo.html deleted file mode 100644 index a08a7ea..0000000 --- a/doc/glBitmap.EglBitmapNonPowerOfTwo.html +++ /dev/null @@ -1,30 +0,0 @@ - - - -glBitmap: Class EglBitmapNonPowerOfTwo - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class EglBitmapNonPowerOfTwo

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type EglBitmapNonPowerOfTwo = class(EglBitmap)

-

Description

-

-exception for non power of two textures

-

Hierarchy

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.EglBitmapNotSupported.html b/doc/glBitmap.EglBitmapNotSupported.html deleted file mode 100644 index eaec1e6..0000000 --- a/doc/glBitmap.EglBitmapNotSupported.html +++ /dev/null @@ -1,29 +0,0 @@ - - - -glBitmap: Class EglBitmapNotSupported - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class EglBitmapNotSupported

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type EglBitmapNotSupported = class(Exception)

-

Description

-

-exception for not supported functions

-

Hierarchy

-
  • Exception
    • -
  • EglBitmapNotSupported
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.EglBitmapSizeToLarge.html b/doc/glBitmap.EglBitmapSizeToLarge.html deleted file mode 100644 index b9a71cf..0000000 --- a/doc/glBitmap.EglBitmapSizeToLarge.html +++ /dev/null @@ -1,30 +0,0 @@ - - - -glBitmap: Class EglBitmapSizeToLarge - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class EglBitmapSizeToLarge

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type EglBitmapSizeToLarge = class(EglBitmap)

-

Description

-

-exception for to large textures

-

Hierarchy

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.EglBitmapUnsupportedFormat.html b/doc/glBitmap.EglBitmapUnsupportedFormat.html deleted file mode 100644 index 6b7bfb0..0000000 --- a/doc/glBitmap.EglBitmapUnsupportedFormat.html +++ /dev/null @@ -1,60 +0,0 @@ - - - -glBitmap: Class EglBitmapUnsupportedFormat - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class EglBitmapUnsupportedFormat

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type EglBitmapUnsupportedFormat = class(EglBitmap)

-

Description

-

-exception for unsupporetd formats

-

Hierarchy

-
  • Exception
    • -
  • EglBitmap
    • -
  • EglBitmapUnsupportedFormat

Overview

-

Methods

- - - - - - - - - -
Publicconstructor Create(const aFormat: TglBitmapFormat); overload;
Publicconstructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
-

Description

-

Methods

- - - - - - -
Publicconstructor Create(const aFormat: TglBitmapFormat); overload;
- 
- - - - - - -
Publicconstructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmap.html b/doc/glBitmap.TglBitmap.html deleted file mode 100644 index cf098b3..0000000 --- a/doc/glBitmap.TglBitmap.html +++ /dev/null @@ -1,771 +0,0 @@ - - - -glBitmap: Class TglBitmap - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmap

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmap = class(TObject)

-

Description

-

-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

-

Hierarchy

-
  • TObject
    • -
  • TglBitmap

Overview

-

Fields

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProtectedfID: GLuint;
ProtectedfTarget: GLuint;
ProtectedfDeleteTextureOnFree: Boolean;
ProtectedfFilterMin: GLenum;
ProtectedfFilterMag: GLenum;
ProtectedfWrapS: GLenum;
ProtectedfWrapT: GLenum;
ProtectedfWrapR: GLenum;
ProtectedfAnisotropic: Integer;
ProtectedfBorderColor: array[0..3] of Single;
ProtectedfSwizzle: array[0..3] of GLenum;
ProtectedfDimension: TglBitmapSize;
ProtectedfMipMap: TglBitmapMipMap;
ProtectedfCustomData: Pointer;
ProtectedfCustomName: String;
ProtectedfCustomNameW: WideString;
-

Methods

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Protectedfunction GetWidth: Integer; virtual;
Protectedfunction GetHeight: Integer; virtual;
Protectedprocedure SetCustomData(const aValue: Pointer);
Protectedprocedure SetCustomName(const aValue: String);
Protectedprocedure SetCustomNameW(const aValue: WideString);
Protectedprocedure SetDeleteTextureOnFree(const aValue: Boolean);
Protectedprocedure SetID(const aValue: Cardinal);
Protectedprocedure SetMipMap(const aValue: TglBitmapMipMap);
Protectedprocedure SetTarget(const aValue: Cardinal);
Protectedprocedure SetAnisotropic(const aValue: Integer);
Protectedprocedure CreateID;
Protectedprocedure SetupParameters();
Publicprocedure AfterConstruction; override;
Publicprocedure BeforeDestruction; override;
Publicprocedure SetFilter(const aMin, aMag: GLenum);
Publicprocedure SetWrap( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);
Publicprocedure SetSwizzle(const r, g, b, a: GLenum);
Publicprocedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
Publicprocedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual;
Publicconstructor Create; overload;
Publicconstructor Create(const aData: TglBitmapData); overload;
-

Properties

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Protectedproperty Width: Integer read GetWidth;
Protectedproperty Height: Integer read GetHeight;
Publicproperty ID: Cardinal read fID write SetID;
Publicproperty Target: Cardinal read fTarget write SetTarget;
Publicproperty DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree;
Publicproperty MipMap: TglBitmapMipMap read fMipMap write SetMipMap;
Publicproperty Anisotropic: Integer read fAnisotropic write SetAnisotropic;
Publicproperty CustomData: Pointer read fCustomData write SetCustomData;
Publicproperty CustomName: String read fCustomName write SetCustomName;
Publicproperty CustomNameW: WideString read fCustomNameW write SetCustomNameW;
Publicproperty Dimension: TglBitmapSize read fDimension;
-

Description

-

Fields

- - - - - - -
ProtectedfID: GLuint;
-

-name of the OpenGL texture object

-
- - - - - - -
ProtectedfTarget: GLuint;
-

-texture target (e.g. GL_TEXTURE_2D)

-
- - - - - - -
ProtectedfDeleteTextureOnFree: Boolean;
-

-delete OpenGL texture object when this object is destroyed

-
- - - - - - -
ProtectedfFilterMin: GLenum;
-

-min filter to apply to the texture

-
- - - - - - -
ProtectedfFilterMag: GLenum;
-

-mag filter to apply to the texture

-
- - - - - - -
ProtectedfWrapS: GLenum;
-

-texture wrapping for x axis

-
- - - - - - -
ProtectedfWrapT: GLenum;
-

-texture wrapping for y axis

-
- - - - - - -
ProtectedfWrapR: GLenum;
-

-texture wrapping for z axis

-
- - - - - - -
ProtectedfAnisotropic: Integer;
-

-anisotropic level

-
- - - - - - -
ProtectedfBorderColor: array[0..3] of Single;
-

-color of the texture border

-
- - - - - - -
ProtectedfSwizzle: array[0..3] of GLenum;
-

-color channel swizzle

-
- - - - - - -
ProtectedfDimension: TglBitmapSize;
-

-size of this texture

-
- - - - - - -
ProtectedfMipMap: TglBitmapMipMap;
-

-mipmap type

-
- - - - - - -
ProtectedfCustomData: Pointer;
-

-user defined data

-
- - - - - - -
ProtectedfCustomName: String;
-

-user defined name

-
- - - - - - -
ProtectedfCustomNameW: WideString;
-

-user defined name

-
-

Methods

- - - - - - -
Protectedfunction GetWidth: Integer; virtual;
- 
Returns
-

the actual width of the texture

- - - - - - -
Protectedfunction GetHeight: Integer; virtual;
- 
Returns
-

the actual height of the texture

- - - - - - -
Protectedprocedure SetCustomData(const aValue: Pointer);
-

-set a new value for fCustomData

-
- - - - - - -
Protectedprocedure SetCustomName(const aValue: String);
-

-set a new value for fCustomName

-
- - - - - - -
Protectedprocedure SetCustomNameW(const aValue: WideString);
-

-set a new value for fCustomNameW

-
- - - - - - -
Protectedprocedure SetDeleteTextureOnFree(const aValue: Boolean);
-

-set new value for fDeleteTextureOnFree

-
- - - - - - -
Protectedprocedure SetID(const aValue: Cardinal);
-

-set name of OpenGL texture object

-
- - - - - - -
Protectedprocedure SetMipMap(const aValue: TglBitmapMipMap);
-

-set new value for fMipMap

-
- - - - - - -
Protectedprocedure SetTarget(const aValue: Cardinal);
-

-set new value for target

-
- - - - - - -
Protectedprocedure SetAnisotropic(const aValue: Integer);
-

-set new value for fAnisotrophic

-
- - - - - - -
Protectedprocedure CreateID;
-

-create OpenGL texture object (delete exisiting object if exists)

-
- - - - - - -
Protectedprocedure SetupParameters();
-

-setup texture parameters

-
- - - - - - -
Publicprocedure AfterConstruction; override;
-

-this method is called after the constructor and sets the default values of this object

-
- - - - - - -
Publicprocedure BeforeDestruction; override;
-

-this method is called before the destructor and does some cleanup

-
- - - - - - -
Publicprocedure SetFilter(const aMin, aMag: GLenum);
-

-set new texture filer

-
Parameters
-
-
aMin
-
min filter
-
aMag
-
mag filter
-
-
- - - - - - -
Publicprocedure SetWrap( const S: GLenum = GL_CLAMP_TO_EDGE; const T: GLenum = GL_CLAMP_TO_EDGE; const R: GLenum = GL_CLAMP_TO_EDGE);
-

-set new texture wrapping

-
Parameters
-
-
S
-
texture wrapping for x axis
-
T
-
texture wrapping for y axis
-
R
-
texture wrapping for z axis
-
-
- - - - - - -
Publicprocedure SetSwizzle(const r, g, b, a: GLenum);
-

-set new swizzle

-
Parameters
-
-
r
-
swizzle for red channel
-
g
-
swizzle for green channel
-
b
-
swizzle for blue channel
-
a
-
swizzle for alpha channel
-
-
- - - - - - -
Publicprocedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
-

-bind texture

-
Parameters
-
-
aEnableTextureUnit
-
enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))
-
-
- - - - - - -
Publicprocedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
-

-bind texture

-
Parameters
-
-
aDisableTextureUnit
-
disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D))
-
-
- - - - - - -
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual;
-

-upload texture data from given data object to video card

-
Parameters
-
-
aData
-
texture data object that contains the actual data
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
- - - - - - -
Publicconstructor Create; overload;
-

-constructor - creates an empty texture

-
- - - - - - -
Publicconstructor Create(const aData: TglBitmapData); overload;
-

-constructor - creates an texture object and uploads the given data

-
-

Properties

- - - - - - -
Protectedproperty Width: Integer read GetWidth;
-

-the actual width of the texture

-
- - - - - - -
Protectedproperty Height: Integer read GetHeight;
-

-the actual height of the texture

-
- - - - - - -
Publicproperty ID: Cardinal read fID write SetID;
-

-name of the OpenGL texture object

-
- - - - - - -
Publicproperty Target: Cardinal read fTarget write SetTarget;
-

-texture target (e.g. GL_TEXTURE_2D)

-
- - - - - - -
Publicproperty DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree;
-

-delete texture object when this object is destroyed

-
- - - - - - -
Publicproperty MipMap: TglBitmapMipMap read fMipMap write SetMipMap;
-

-mipmap type

-
- - - - - - -
Publicproperty Anisotropic: Integer read fAnisotropic write SetAnisotropic;
-

-anisotropic level

-
- - - - - - -
Publicproperty CustomData: Pointer read fCustomData write SetCustomData;
-

-user defined data (use at will)

-
- - - - - - -
Publicproperty CustomName: String read fCustomName write SetCustomName;
-

-user defined name (use at will)

-
- - - - - - -
Publicproperty CustomNameW: WideString read fCustomNameW write SetCustomNameW;
-

-user defined name (as WideString; use at will)

-
- - - - - - -
Publicproperty Dimension: TglBitmapSize read fDimension;
-

-size of the texture

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmap1D.html b/doc/glBitmap.TglBitmap1D.html deleted file mode 100644 index 1ab6fba..0000000 --- a/doc/glBitmap.TglBitmap1D.html +++ /dev/null @@ -1,110 +0,0 @@ - - - -glBitmap: Class TglBitmap1D - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmap1D

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmap1D = class(TglBitmap)

-

Description

-

-wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D all operations on a bitmap object must be done from the render thread

-

Hierarchy

-

Overview

-

Methods

- - - - - - - - - - - - - -
Protectedprocedure UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
Publicprocedure AfterConstruction; override;
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-

Properties

- - - - - -
Publicproperty Width;
-

Description

-

Methods

- - - - - - -
Protectedprocedure UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean);
-

-upload the texture data to video card

-
Parameters
-
-
aDataObj
-
texture data object that contains the actual data
-
aBuildWithGlu
-
use glu functions to build mipmaps
-
-
- - - - - - -
Publicprocedure AfterConstruction; override;
-

-this method is called after constructor and initializes the object

-
- - - - - - -
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-

-upload texture data from given data object to video card

-
Parameters
-
-
aData
-
texture data object that contains the actual data
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
-

Properties

- - - - - - -
Publicproperty Width;
-

-actual with of the texture

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmap2D.html b/doc/glBitmap.TglBitmap2D.html deleted file mode 100644 index 3e74fbc..0000000 --- a/doc/glBitmap.TglBitmap2D.html +++ /dev/null @@ -1,155 +0,0 @@ - - - -glBitmap: Class TglBitmap2D - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmap2D

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmap2D = class(TglBitmap)

-

Description

-

-wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) all operations on a bitmap object must be done from the render thread

-

Hierarchy

-

Overview

-

Methods

- - - - - - - - - - - - - - - - - -
Protectedprocedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum );
Publicprocedure AfterConstruction; override;
Publicprocedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-

Properties

- - - - - - - - - -
Publicproperty Width;
Publicproperty Height;
-

Description

-

Methods

- - - - - - -
Protectedprocedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum );
-

-upload the texture data to video card

-
Parameters
-
-
aDataObj
-
texture data object that contains the actual data
-
aTarget
-
target o upload data to (e.g. GL_TEXTURE_2D)
-
aBuildWithGlu
-
use glu functions to build mipmaps
-
-
- - - - - - -
Publicprocedure AfterConstruction; override;
-

-this method is called after constructor and initializes the object

-
- - - - - - -
Publicprocedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);
-

-copy a part of the frame buffer to the texture

-
Parameters
-
-
aTop
-
topmost pixel to copy
-
aLeft
-
leftmost pixel to copy
-
aRight
-
rightmost pixel to copy
-
aBottom
-
bottommost pixel to copy
-
aFormat
-
format to store data in
-
aDataObj
-
texture data object to store the data in
-
-
- - - - - - -
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-

-upload texture data from given data object to video card

-
Parameters
-
-
aData
-
texture data object that contains the actual data
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
-

Properties

- - - - - - -
Publicproperty Width;
-

-actual width of the texture

-
- - - - - - -
Publicproperty Height;
-

-actual height of the texture

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapCubeMap.html b/doc/glBitmap.TglBitmapCubeMap.html deleted file mode 100644 index c893bb5..0000000 --- a/doc/glBitmap.TglBitmapCubeMap.html +++ /dev/null @@ -1,137 +0,0 @@ - - - -glBitmap: Class TglBitmapCubeMap - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmapCubeMap

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapCubeMap = class(TglBitmap2D)

-

Description

-

-wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) all operations on a bitmap object must be done from the render thread

-

Hierarchy

-

Overview

-

Methods

- - - - - - - - - - - - - - - - - - - - - -
Publicprocedure AfterConstruction; override;
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
Publicprocedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
Publicprocedure Bind( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
Publicprocedure Unbind( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
-

Description

-

Methods

- - - - - - -
Publicprocedure AfterConstruction; override;
-

-this method is called after constructor and initializes the object

-
- - - - - - -
Publicprocedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;
-

-upload texture data from given data object to video card

-
Parameters
-
-
aData
-
texture data object that contains the actual data
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
- - - - - - -
Publicprocedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);
-

-upload texture data from given data object to video card

-
Parameters
-
-
aData
-
texture data object that contains the actual data
-
aCubeTarget
-
cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X)
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
- - - - - - -
Publicprocedure Bind( const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
-

-bind texture

-
Parameters
-
-
aEnableTexCoordsGen
-
enable cube map generator
-
aEnableTextureUnit
-
enable texture unit
-
-
- - - - - - -
Publicprocedure Unbind( const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
-

-unbind texture

-
Parameters
-
-
aDisableTexCoordsGen
-
disable cube map generator
-
aDisableTextureUnit
-
disable texture unit
-
-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapData.html b/doc/glBitmap.TglBitmapData.html deleted file mode 100644 index 1e23065..0000000 --- a/doc/glBitmap.TglBitmapData.html +++ /dev/null @@ -1,1539 +0,0 @@ - - - -glBitmap: Class TglBitmapData - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmapData

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapData = class(TObject)

-

Description

-

-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

-

Hierarchy

-
  • TObject
    • -
  • TglBitmapData

Overview

-

Fields

- - - - - - - - - - - - - - - - - - - - - - - - - -
PrivatefData: PByte;
PrivatefDimension: TglBitmapSize;
PrivatefFormat: TglBitmapFormat;
PrivatefFilename: String;
PrivatefScanlines: array of PByte;
PrivatefHasScanlines: Boolean;
-

Methods

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Privatefunction GetFormatDescriptor: TglBitmapFormatDescriptor;
Privatefunction GetWidth: Integer;
Privatefunction GetHeight: Integer;
Privatefunction GetScanlines(const aIndex: Integer): PByte;
Privateprocedure SetFormat(const aValue: TglBitmapFormat);
Privateprocedure PrepareResType(var aResource: String; var aResType: PChar);
Privateprocedure UpdateScanlines;
Privatefunction LoadPNG(const aStream: TStream): Boolean; virtual;
Privateprocedure SavePNG(const aStream: TStream); virtual;
Privatefunction LoadJPEG(const aStream: TStream): Boolean; virtual;
Privateprocedure SaveJPEG(const aStream: TStream); virtual;
Privatefunction LoadRAW(const aStream: TStream): Boolean;
Privateprocedure SaveRAW(const aStream: TStream);
Privatefunction LoadBMP(const aStream: TStream): Boolean;
Privateprocedure SaveBMP(const aStream: TStream);
Privatefunction LoadTGA(const aStream: TStream): Boolean;
Privateprocedure SaveTGA(const aStream: TStream);
Privatefunction LoadDDS(const aStream: TStream): Boolean;
Privateprocedure SaveDDS(const aStream: TStream);
Publicfunction FlipHorz: Boolean; virtual;
Publicfunction FlipVert: Boolean; virtual;
Publicprocedure LoadFromFile(const aFilename: String);
Publicprocedure LoadFromStream(const aStream: TStream); virtual;
Publicprocedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);
Publicprocedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
Publicprocedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
Publicprocedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
Publicprocedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
Publicfunction Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
Publicfunction Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
Publicfunction ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
Publicfunction AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
Publicfunction AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
Publicfunction AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
Publicfunction AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
Publicfunction AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
Publicfunction AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
Publicfunction AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
Publicfunction AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
Publicfunction AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
Publicfunction AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
Publicfunction AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
Publicfunction AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
Publicfunction AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
Publicfunction AddAlphaFromValue(const aAlpha: Byte): Boolean;
Publicfunction AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
Publicfunction AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
Publicfunction RemoveAlpha: Boolean; virtual;
Publicprocedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
Publicprocedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
Publicprocedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);
Publicprocedure SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;
Publicfunction Clone: TglBitmapData;
Publicprocedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
Publicprocedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);
Publicconstructor Create; overload;
Publicconstructor Create(const aFileName: String); overload;
Publicconstructor Create(const aStream: TStream); overload;
Publicconstructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
Publicconstructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
Publicconstructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
Publicconstructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
Publicdestructor Destroy; override;
-

Properties

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Publicproperty Data: PByte read fData;
Publicproperty Dimension: TglBitmapSize read fDimension;
Publicproperty Filename: String read fFilename;
Publicproperty Width: Integer read GetWidth;
Publicproperty Height: Integer read GetHeight;
Publicproperty Format: TglBitmapFormat read fFormat write SetFormat;
Publicproperty Scanlines[constaIndex:Integer]: PByte read GetScanlines;
Publicproperty FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor;
-

Description

-

Fields

- - - - - - -
PrivatefData: PByte;
-

-texture data

-
- - - - - - -
PrivatefDimension: TglBitmapSize;
-

-pixel size of the data

-
- - - - - - -
PrivatefFormat: TglBitmapFormat;
-

-format the texture data is stored in

-
- - - - - - -
PrivatefFilename: String;
-

-file the data was load from

-
- - - - - - -
PrivatefScanlines: array of PByte;
-

-pointer to begin of each line

-
- - - - - - -
PrivatefHasScanlines: Boolean;
-

-True if scanlines are initialized, False otherwise

-
-

Methods

- - - - - - -
Privatefunction GetFormatDescriptor: TglBitmapFormatDescriptor;
- 
Returns
-

the format descriptor suitable to the texture data format

- - - - - - -
Privatefunction GetWidth: Integer;
- 
Returns
-

the width of the texture data (in pixel) or -1 if no data is set

- - - - - - -
Privatefunction GetHeight: Integer;
- 
Returns
-

the height of the texture data (in pixel) or -1 if no data is set

- - - - - - -
Privatefunction GetScanlines(const aIndex: Integer): PByte;
-

-get scanline at index aIndex

-
Returns
-

Pointer to start of line or Nil

- - - - - - -
Privateprocedure SetFormat(const aValue: TglBitmapFormat);
-

-set new value for the data format. only possible if new format has the same pixel size. if you want to convert the texture data, see ConvertTo function

-
- - - - - - -
Privateprocedure PrepareResType(var aResource: String; var aResType: PChar);
-

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

-
Parameters
-
-
aResource
-
resource identifier to split and store name in
-
aResType
-
type of the resource
-
-
- - - - - - -
Privateprocedure UpdateScanlines;
-

-updates scanlines array

-
- - - - - - -
Privatefunction LoadPNG(const aStream: TStream): Boolean; virtual;
-

-try to load a PNG from a stream

-
Parameters
-
-
aStream
-
stream to load PNG from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SavePNG(const aStream: TStream); virtual;
-

-save texture data as PNG to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Privatefunction LoadJPEG(const aStream: TStream): Boolean; virtual;
-

-try to load a JPEG from a stream

-
Parameters
-
-
aStream
-
stream to load JPEG from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SaveJPEG(const aStream: TStream); virtual;
-

-save texture data as JPEG to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Privatefunction LoadRAW(const aStream: TStream): Boolean;
-

-try to load a RAW image from a stream

-
Parameters
-
-
aStream
-
stream to load RAW image from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SaveRAW(const aStream: TStream);
-

-save texture data as RAW image to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Privatefunction LoadBMP(const aStream: TStream): Boolean;
-

-try to load a BMP from a stream

-
Parameters
-
-
aStream
-
stream to load BMP from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SaveBMP(const aStream: TStream);
-

-save texture data as BMP to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Privatefunction LoadTGA(const aStream: TStream): Boolean;
-

-try to load a TGA from a stream

-
Parameters
-
-
aStream
-
stream to load TGA from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SaveTGA(const aStream: TStream);
-

-save texture data as TGA to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Privatefunction LoadDDS(const aStream: TStream): Boolean;
-

-try to load a DDS from a stream

-
Parameters
-
-
aStream
-
stream to load DDS from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Privateprocedure SaveDDS(const aStream: TStream);
-

-save texture data as DDS to stream

-
Parameters
-
-
aStream
-
stream to save data to
-
-
- - - - - - -
Publicfunction FlipHorz: Boolean; virtual;
-

-flip texture horizontal

-
Returns
-

True in success, False otherwise

- - - - - - -
Publicfunction FlipVert: Boolean; virtual;
-

-flip texture vertical

-
Returns
-

True in success, False otherwise

- - - - - - -
Publicprocedure LoadFromFile(const aFilename: String);
-

-load a texture from a file

-
Parameters
-
-
aFilename
-
file to load texuture from
-
-
- - - - - - -
Publicprocedure LoadFromStream(const aStream: TStream); virtual;
-

-load a texture from a stream

-
Parameters
-
-
aStream
-
stream to load texture from
-
-
- - - - - - -
Publicprocedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);
-

-use a function to generate texture data

-
Parameters
-
-
aSize
-
size of the texture
-
aFunc
-
callback to use for generation
-
aFormat
-
format of the texture data
-
aArgs
-
user defined paramaters (use at will)
-
-
- - - - - - -
Publicprocedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
-

-load a texture from a resource

-
Parameters
-
-
aInstance
-
resource handle
-
aResource
-
resource indentifier
-
aResType
-
resource type (if known)
-
-
- - - - - - -
Publicprocedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-

-load a texture from a resource id

-
Parameters
-
-
aInstance
-
resource handle
-
aResource
-
resource ID
-
aResType
-
resource type
-
-
- - - - - - -
Publicprocedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);
-

-save texture data to a file

-
Parameters
-
-
aFilename
-
filename to store texture in
-
aFileType
-
file type to store data into
-
-
- - - - - - -
Publicprocedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
-

-save texture data to a stream

-
Parameters
-
-
aFilename
-
filename to store texture in
-
aFileType
-
file type to store data into
-
-
- - - - - - -
Publicfunction Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
-

-convert texture data using a user defined callback

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

True if converting was successful, False otherwise

- - - - - - -
Publicfunction Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
-

-convert texture data using a user defined callback

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

True if converting was successful, False otherwise

- - - - - - -
Publicfunction ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
-

-convert texture data using a specific format

-
Parameters
-
-
aFormat
-
new format of texture data
-
-
Returns
-

True if converting was successful, False otherwise

- - - - - - -
Publicfunction AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-

-assign texture data to TLazIntfImage object

-
Parameters
-
-
aImage
-
TLazIntfImage to write data to
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Publicfunction AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
-

-assign texture data from TLazIntfImage object

-
Parameters
-
-
aImage
-
TLazIntfImage to read data from
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Publicfunction AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-

-assign alpha channel data to TLazIntfImage object

-
Parameters
-
-
aImage
-
TLazIntfImage to write data to
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Publicfunction AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-

-assign alpha channel data from TLazIntfImage object

-
Parameters
-
-
aImage
-
TLazIntfImage to read data from
-
aFunc
-
callback to use for converting
-
aArgs
-
user defined parameters (use at will)
-
-
Returns
-

True on success, False otherwise

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

-load alpha channel data from resource

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

True on success, False otherwise

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

-load alpha channel data from resource ID

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

True on success, False otherwise

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

-add alpha channel data from function

-
Parameters
-
-
aFunc
-
callback to get data from
-
aArgs
-
user defined parameters (use at will)
-
-
Returns
-

True on success, False otherwise

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

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

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

True on success, False otherwise

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

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

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

True on success, False otherwise

- - - - - - -
Publicfunction AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-

-add alpha channel data from existing glBitmap object

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

True on success, False otherwise

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

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

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

True on success, False otherwise

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

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

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

True on success, False otherwise

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

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

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

True on success, False otherwise

- - - - - - -
Publicfunction AddAlphaFromValue(const aAlpha: Byte): Boolean;
-

-add a constand alpha value to all pixels

-
Parameters
-
-
aAlpha
-
alpha value to add (0-255)
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Publicfunction AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
-

-add a constand alpha value to all pixels

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

True on success, False otherwise

- - - - - - -
Publicfunction AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
-

-add a constand alpha value to all pixels

-
Parameters
-
-
aAlpha
-
alpha value to add (0.0-1.0)
-
-
Returns
-

True on success, False otherwise

- - - - - - -
Publicfunction RemoveAlpha: Boolean; virtual;
-

-remove alpha channel

-
Returns
-

True on success, False otherwise

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

-fill complete texture with one color

-
Parameters
-
-
aRed
-
red color for border (0-255)
-
aGreen
-
green color for border (0-255)
-
aBlue
-
blue color for border (0-255)
-
aAlpha
-
alpha color for border (0-255)
-
-
- - - - - - -
Publicprocedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
-

-fill complete texture with one color

-
Parameters
-
-
aRed
-
red color for border (0-Range.r)
-
aGreen
-
green color for border (0-Range.g)
-
aBlue
-
blue color for border (0-Range.b)
-
aAlpha
-
alpha color for border (0-Range.a)
-
-
- - - - - - -
Publicprocedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);
-

-fill complete texture with one color

-
Parameters
-
-
aRed
-
red color for border (0.0-1.0)
-
aGreen
-
green color for border (0.0-1.0)
-
aBlue
-
blue color for border (0.0-1.0)
-
aAlpha
-
alpha color for border (0.0-1.0)
-
-
- - - - - - -
Publicprocedure SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;
-

-set data pointer of texture data

-
Parameters
-
-
aData
-
pointer to new texture data
-
aFormat
-
format of the data stored at aData
-
aWidth
-
width of the texture data
-
aHeight
-
height of the texture data
-
-
- - - - - - -
Publicfunction Clone: TglBitmapData;
-

-create a clone of the current object

-
Returns
-

clone of this object

- - - - - - -
Publicprocedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);
-

-invert color data (bitwise not)

-
Parameters
-
-
aRed
-
invert red channel
-
aGreen
-
invert green channel
-
aBlue
-
invert blue channel
-
aAlpha
-
invert alpha channel
-
-
- - - - - - -
Publicprocedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);
-

-create normal map from texture data

-
Parameters
-
-
aFunc
-
normal map function to generate normalmap with
-
aScale
-
scale of the normale stored in the normal map
-
aUseAlpha
-
generate normalmap from alpha channel data (if present)
-
-
- - - - - - -
Publicconstructor Create; overload;
-

-constructor - creates a texutre data object

-
- - - - - - -
Publicconstructor Create(const aFileName: String); overload;
-

-constructor - creates a texture data object and loads it from a file

-
Parameters
-
-
aFilename
-
file to load texture from
-
-
- - - - - - -
Publicconstructor Create(const aStream: TStream); overload;
-

-constructor - creates a texture data object and loads it from a stream

-
Parameters
-
-
aStream
-
stream to load texture from
-
-
- - - - - - -
Publicconstructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
-

-constructor - creates a texture data object with the given size, format and data

-
Parameters
-
-
aSize
-
size of the texture
-
aFormat
-
format of the given data
-
aData
-
texture data - be carefull: the data will now be managed by the texture data object
-
-
- - - - - - -
Publicconstructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
-

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

-
Parameters
-
-
aSize
-
size of the texture
-
aFormat
-
format of the given data
-
aFunc
-
callback to use for generating the data
-
aArgs
-
user defined parameters (use at will)
-
-
- - - - - - -
Publicconstructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
-

-constructor - creates a texture data object and loads it from a resource

-
Parameters
-
-
aInstance
-
resource handle
-
aResource
-
resource indentifier
-
aResType
-
resource type (if known)
-
-
- - - - - - -
Publicconstructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
-

-constructor - creates a texture data object and loads it from a resource

-
Parameters
-
-
aInstance
-
resource handle
-
aResourceID
-
resource ID
-
aResType
-
resource type (if known)
-
-
- - - - - - -
Publicdestructor Destroy; override;
-

-destructor

-
-

Properties

- - - - - - -
Publicproperty Data: PByte read fData;
-

-texture data (be carefull with this!)

-
- - - - - - -
Publicproperty Dimension: TglBitmapSize read fDimension;
-

-size of the texture data (in pixel)

-
- - - - - - -
Publicproperty Filename: String read fFilename;
-

-file the data was loaded from

-
- - - - - - -
Publicproperty Width: Integer read GetWidth;
-

-width of the texture data (in pixel)

-
- - - - - - -
Publicproperty Height: Integer read GetHeight;
-

-height of the texture data (in pixel)

-
- - - - - - -
Publicproperty Format: TglBitmapFormat read fFormat write SetFormat;
-

-format the texture data is stored in

-
- - - - - - -
Publicproperty Scanlines[constaIndex:Integer]: PByte read GetScanlines;
-

-pointer to begin of line at given index or Nil

-
- - - - - - -
Publicproperty FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor;
-

-descriptor object that describes the format of the stored data

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapFormatDescriptor.html b/doc/glBitmap.TglBitmapFormatDescriptor.html deleted file mode 100644 index 5e899f1..0000000 --- a/doc/glBitmap.TglBitmapFormatDescriptor.html +++ /dev/null @@ -1,767 +0,0 @@ - - - -glBitmap: Class TglBitmapFormatDescriptor - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmapFormatDescriptor

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapFormatDescriptor = class(TObject)

-

Description

-

-describes the properties of a given texture data format

-

Hierarchy

-
  • TObject
    • -
  • TglBitmapFormatDescriptor

Overview

-

Fields

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PrivatefBytesPerPixel: Single;
PrivatefChannelCount: Integer;
PrivatefMask: TglBitmapRec4ul;
PrivatefRange: TglBitmapRec4ui;
ProtectedfFormat: TglBitmapFormat;
ProtectedfWithAlpha: TglBitmapFormat;
ProtectedfWithoutAlpha: TglBitmapFormat;
ProtectedfOpenGLFormat: TglBitmapFormat;
ProtectedfRGBInverted: TglBitmapFormat;
ProtectedfUncompressed: TglBitmapFormat;
ProtectedfBitsPerPixel: Integer;
ProtectedfIsCompressed: Boolean;
ProtectedfPrecision: TglBitmapRec4ub;
ProtectedfShift: TglBitmapRec4ub;
ProtectedfglFormat: GLenum;
ProtectedfglInternalFormat: GLenum;
ProtectedfglDataFormat: GLenum;
-

Methods

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Privatefunction GetHasRed: Boolean;
Privatefunction GetHasGreen: Boolean;
Privatefunction GetHasBlue: Boolean;
Privatefunction GetHasAlpha: Boolean;
Privatefunction GetHasColor: Boolean;
Privatefunction GetIsGrayscale: Boolean;
Protectedprocedure SetValues; virtual;
Protectedprocedure CalcValues;
Publicfunction GetSize(const aSize: TglBitmapSize): Integer; overload; virtual;
Publicfunction GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
Publicconstructor Create;
Publicclass function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
-

Properties

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

Description

-

Fields

- - - - - - -
PrivatefBytesPerPixel: Single;
-

-number of bytes for each pixel

-
- - - - - - -
PrivatefChannelCount: Integer;
-

-number of color channels

-
- - - - - - -
PrivatefMask: TglBitmapRec4ul;
-

-bitmask for each color channel

-
- - - - - - -
PrivatefRange: TglBitmapRec4ui;
-

-maximal value of each color channel

-
- - - - - - -
ProtectedfFormat: TglBitmapFormat;
-

-format this descriptor belongs to

-
- - - - - - -
ProtectedfWithAlpha: TglBitmapFormat;
-

-suitable format with alpha channel

-
- - - - - - -
ProtectedfWithoutAlpha: TglBitmapFormat;
-

-suitable format without alpha channel

-
- - - - - - -
ProtectedfOpenGLFormat: TglBitmapFormat;
-

-suitable format that is supported by OpenGL

-
- - - - - - -
ProtectedfRGBInverted: TglBitmapFormat;
-

-suitable format with inverted RGB channels

-
- - - - - - -
ProtectedfUncompressed: TglBitmapFormat;
-

-suitable format with uncompressed data

-
- - - - - - -
ProtectedfBitsPerPixel: Integer;
-

-number of bits per pixel

-
- - - - - - -
ProtectedfIsCompressed: Boolean;
-

-True if the format is compressed, False otherwise

-
- - - - - - -
ProtectedfPrecision: TglBitmapRec4ub;
-

-number of bits for each color channel

-
- - - - - - -
ProtectedfShift: TglBitmapRec4ub;
-

-bit offset for each color channel

-
- - - - - - -
ProtectedfglFormat: GLenum;
-

-OpenGL format enum (e.g. GL_RGB)

-
- - - - - - -
ProtectedfglInternalFormat: GLenum;
-

-OpenGL internal format enum (e.g. GL_RGB8)

-
- - - - - - -
ProtectedfglDataFormat: GLenum;
-

-OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)

-
-

Methods

- - - - - - -
Privatefunction GetHasRed: Boolean;
- 
Returns
-

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

- - - - - - -
Privatefunction GetHasGreen: Boolean;
- 
Returns
-

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

- - - - - - -
Privatefunction GetHasBlue: Boolean;
- 
Returns
-

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

- - - - - - -
Privatefunction GetHasAlpha: Boolean;
- 
Returns
-

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

- - - - - - -
Privatefunction GetHasColor: Boolean;
- 
Returns
-

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

- - - - - - -
Privatefunction GetIsGrayscale: Boolean;
- 
Returns
-

True if the format is a grayscale format, False otherwise

- - - - - - -
Protectedprocedure SetValues; virtual;
-

-set values for this format descriptor

-
- - - - - - -
Protectedprocedure CalcValues;
-

-calculate cached values

-
- - - - - - -
Publicfunction GetSize(const aSize: TglBitmapSize): Integer; overload; virtual;
- 
- - - - - - -
Publicfunction GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
- 
- - - - - - -
Publicconstructor Create;
-

-constructor

-
- - - - - - -
Publicclass function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
-

-get the format descriptor by a given OpenGL internal format

-
Parameters
-
-
aInternalFormat
-
OpenGL internal format to get format descriptor for
-
-
Returns
-

suitable format descriptor or tfEmpty-Descriptor

-

Properties

- - - - - - -
Publicproperty Format: TglBitmapFormat read fFormat;
-

-format this descriptor belongs to

-
- - - - - - -
Publicproperty ChannelCount: Integer read fChannelCount;
-

-number of color channels

-
- - - - - - -
Publicproperty IsCompressed: Boolean read fIsCompressed;
-

-True if the format is compressed, False otherwise

-
- - - - - - -
Publicproperty BitsPerPixel: Integer read fBitsPerPixel;
-

-number of bytes per pixel

-
- - - - - - -
Publicproperty BytesPerPixel: Single read fBytesPerPixel;
-

-number of bits per pixel

-
- - - - - - -
Publicproperty Precision: TglBitmapRec4ub read fPrecision;
-

-number of bits for each color channel

-
- - - - - - -
Publicproperty Shift: TglBitmapRec4ub read fShift;
-

-bit offset for each color channel

-
- - - - - - -
Publicproperty Range: TglBitmapRec4ui read fRange;
-

-maximal value of each color channel

-
- - - - - - -
Publicproperty Mask: TglBitmapRec4ul read fMask;
-

-bitmask for each color channel

-
- - - - - - -
Publicproperty RGBInverted: TglBitmapFormat read fRGBInverted;
-

-suitable format with inverted RGB channels

-
- - - - - - -
Publicproperty WithAlpha: TglBitmapFormat read fWithAlpha;
-

-suitable format with alpha channel

-
- - - - - - -
Publicproperty WithoutAlpha: TglBitmapFormat read fWithAlpha;
-

-suitable format without alpha channel

-
- - - - - - -
Publicproperty OpenGLFormat: TglBitmapFormat read fOpenGLFormat;
-

-suitable format that is supported by OpenGL

-
- - - - - - -
Publicproperty Uncompressed: TglBitmapFormat read fUncompressed;
-

-suitable format with uncompressed data

-
- - - - - - -
Publicproperty glFormat: GLenum read fglFormat;
-

-OpenGL format enum (e.g. GL_RGB)

-
- - - - - - -
Publicproperty glInternalFormat: GLenum read fglInternalFormat;
-

-OpenGL internal format enum (e.g. GL_RGB8)

-
- - - - - - -
Publicproperty glDataFormat: GLenum read fglDataFormat;
-

-OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)

-
- - - - - - -
Publicproperty HasRed: Boolean read GetHasRed;
-

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

-
- - - - - - -
Publicproperty HasGreen: Boolean read GetHasGreen;
-

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

-
- - - - - - -
Publicproperty HasBlue: Boolean read GetHasBlue;
-

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

-
- - - - - - -
Publicproperty HasAlpha: Boolean read GetHasAlpha;
-

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

-
- - - - - - -
Publicproperty HasColor: Boolean read GetHasColor;
-

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

-
- - - - - - -
Publicproperty IsGrayscale: Boolean read GetIsGrayscale;
-

-True if the format is a grayscale format, False otherwise

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapFunctionRec.html b/doc/glBitmap.TglBitmapFunctionRec.html deleted file mode 100644 index f8833da..0000000 --- a/doc/glBitmap.TglBitmapFunctionRec.html +++ /dev/null @@ -1,105 +0,0 @@ - - - -glBitmap: record TglBitmapFunctionRec - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

record TglBitmapFunctionRec

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapFunctionRec = record

-

Description

-

-structure to store data for converting in

-

Overview

-

Fields

- - - - - - - - - - - - - - - - - - - -
Sender: TglBitmapData;
Size: TglBitmapSize;
Position: TglBitmapPixelPosition;
Source: TglBitmapPixelData;
Dest: TglBitmapPixelData;
Args: Pointer;
-

Description

-

Fields

- - - - - -
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

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapNormalMap.html b/doc/glBitmap.TglBitmapNormalMap.html deleted file mode 100644 index daf09c0..0000000 --- a/doc/glBitmap.TglBitmapNormalMap.html +++ /dev/null @@ -1,73 +0,0 @@ - - - -glBitmap: Class TglBitmapNormalMap - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Class TglBitmapNormalMap

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapNormalMap = class(TglBitmapCubeMap)

-

Description

-

-wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread

-

Hierarchy

-

Overview

-

Methods

- - - - - - - - - -
Publicprocedure AfterConstruction; override;
Publicprocedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);
-

Description

-

Methods

- - - - - - -
Publicprocedure AfterConstruction; override;
-

-this method is called after constructor and initializes the object

-
- - - - - - -
Publicprocedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);
-

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

-
Parameters
-
-
aSize
-
size of each cube map texture
-
aCheckSize
-
check size before upload and throw exception if something is wrong
-
-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapPixelData.html b/doc/glBitmap.TglBitmapPixelData.html deleted file mode 100644 index e468b17..0000000 --- a/doc/glBitmap.TglBitmapPixelData.html +++ /dev/null @@ -1,69 +0,0 @@ - - - -glBitmap: packed record TglBitmapPixelData - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

packed record TglBitmapPixelData

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapPixelData = packed record

-

Description

-

-structure to store pixel data in

-

Overview

-

Fields

- - - - - - - - - - -
Data: TglBitmapRec4ui;
Range: TglBitmapRec4ui;
Format: TglBitmapFormat;
-

Description

-

Fields

- - - - - -
Data: TglBitmapRec4ui;
-

-color data for each color channel

-
- - - - - -
Range: TglBitmapRec4ui;
-

-maximal color value for each channel

-
- - - - - -
Format: TglBitmapFormat;
-

-format of the pixel

-
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapRec4ub.html b/doc/glBitmap.TglBitmapRec4ub.html deleted file mode 100644 index f7dec9a..0000000 --- a/doc/glBitmap.TglBitmapRec4ub.html +++ /dev/null @@ -1,83 +0,0 @@ - - - -glBitmap: packed record TglBitmapRec4ub - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

packed record TglBitmapRec4ub

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapRec4ub = packed record

-

Description

-

-record that stores 4 unsigned byte values

-

Overview

-

Fields

- - - - - - - - - - - - - - - - -
r: Byte
g: Byte
b: Byte
a: Byte
arr: array[0..3] of Byte
-

Description

-

Fields

- - - - - -
r: Byte
- 
- - - - - -
g: Byte
- 
- - - - - -
b: Byte
- 
- - - - - -
a: Byte
- 
- - - - - -
arr: array[0..3] of Byte
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapRec4ui.html b/doc/glBitmap.TglBitmapRec4ui.html deleted file mode 100644 index 6365e17..0000000 --- a/doc/glBitmap.TglBitmapRec4ui.html +++ /dev/null @@ -1,83 +0,0 @@ - - - -glBitmap: packed record TglBitmapRec4ui - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

packed record TglBitmapRec4ui

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapRec4ui = packed record

-

Description

-

-record that stores 4 unsigned integer values

-

Overview

-

Fields

- - - - - - - - - - - - - - - - -
r: Cardinal
g: Cardinal
b: Cardinal
a: Cardinal
arr: array[0..3] of Cardinal
-

Description

-

Fields

- - - - - -
r: Cardinal
- 
- - - - - -
g: Cardinal
- 
- - - - - -
b: Cardinal
- 
- - - - - -
a: Cardinal
- 
- - - - - -
arr: array[0..3] of Cardinal
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapRec4ul.html b/doc/glBitmap.TglBitmapRec4ul.html deleted file mode 100644 index 9d5f10f..0000000 --- a/doc/glBitmap.TglBitmapRec4ul.html +++ /dev/null @@ -1,83 +0,0 @@ - - - -glBitmap: packed record TglBitmapRec4ul - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

packed record TglBitmapRec4ul

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapRec4ul = packed record

-

Description

-

-record that stores 4 unsigned long integer values

-

Overview

-

Fields

- - - - - - - - - - - - - - - - -
r: QWord
g: QWord
b: QWord
a: QWord
arr: array[0..3] of QWord
-

Description

-

Fields

- - - - - -
r: QWord
- 
- - - - - -
g: QWord
- 
- - - - - -
b: QWord
- 
- - - - - -
a: QWord
- 
- - - - - -
arr: array[0..3] of QWord
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.TglBitmapSize.html b/doc/glBitmap.TglBitmapSize.html deleted file mode 100644 index 78f6f1f..0000000 --- a/doc/glBitmap.TglBitmapSize.html +++ /dev/null @@ -1,61 +0,0 @@ - - - -glBitmap: packed record TglBitmapSize - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

packed record TglBitmapSize

- - -
DescriptionHierarchyFieldsMethodsProperties
-

Unit

-

-glBitmap

-

Declaration

-

-type TglBitmapSize = packed record

-

Description

- 

Overview

-

Fields

- - - - - - - - - - -
Fields: TglBitmapSizeFields;
X: Word;
Y: Word;
-

Description

-

Fields

- - - - - -
Fields: TglBitmapSizeFields;
- 
- - - - - -
X: Word;
- 
- - - - - -
Y: Word;
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/glBitmap.html b/doc/glBitmap.html deleted file mode 100644 index 9f34b78..0000000 --- a/doc/glBitmap.html +++ /dev/null @@ -1,610 +0,0 @@ - - - -glBitmap - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Unit glBitmap

- - -
DescriptionUsesClasses, Interfaces, Objects and RecordsFunctions and ProceduresTypesConstantsVariables
-

Description

-

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

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

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, ...)

-

Overview

-

Classes, Interfaces, Objects and Records

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameDescription
Class EglBitmap 
Class EglBitmapNotSupported 
Class EglBitmapSizeToLarge 
Class EglBitmapNonPowerOfTwo 
Class EglBitmapUnsupportedFormat 
packed record TglBitmapRec4ui 
packed record TglBitmapRec4ub 
packed record TglBitmapRec4ul 
packed record TglBitmapPixelData 
packed record TglBitmapSize 
Class TglBitmapFormatDescriptor 
record TglBitmapFunctionRec 
Class TglBitmapData 
Class TglBitmap 
Class TglBitmap1D 
Class TglBitmap2D 
Class TglBitmapCubeMap 
Class TglBitmapNormalMap 
-

Functions and Procedures

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
procedure glBitmapSetDefaultWrap( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
function glBitmapGetDefaultMipmap: TglBitmapMipMap;
function glBitmapGetDefaultFormat: TglBitmapFormat;
procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;
function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
-

Types

- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
TglBitmapFormat = (...);
TglBitmapFileType = (...);
TglBitmapFileTypes = set of TglBitmapFileType;
TglBitmapMipMap = (...);
TglBitmapNormalMapFunc = (...);
PglBitmapPixelData = ˆTglBitmapPixelData;
TglBitmapSizeFields = set of (ffX, ffY);
TglBitmapPixelPosition = TglBitmapSize;
TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
-

Constants

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

Description

-

Functions and Procedures

- - - - - -
procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
- 
- - - - - -
procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
- 
- - - - - -
procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
- 
- - - - - -
procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
- 
- - - - - -
procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
- 
- - - - - -
procedure glBitmapSetDefaultWrap( const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
- 
- - - - - -
procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
- 
- - - - - -
function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
- 
- - - - - -
function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
- 
- - - - - -
function glBitmapGetDefaultMipmap: TglBitmapMipMap;
- 
- - - - - -
function glBitmapGetDefaultFormat: TglBitmapFormat;
- 
- - - - - -
procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
- 
- - - - - -
procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
- 
- - - - - -
procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
- 
- - - - - -
function glBitmapSize(X: Integer = -1; Y: Integer = -1): TglBitmapSize;
- 
- - - - - -
function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
- 
- - - - - -
function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub;
- 
- - - - - -
function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui;
- 
- - - - - -
function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul;
- 
- - - - - -
function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean;
- 
- - - - - -
function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean;
- 
- - - - - -
function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;
- 
-

Types

- - - - - -
TglBitmapFormat = (...);
-

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

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

-type to define suitable file formats

-
Values
-
    -
  • -ftPNG: Portable Network Graphic file (PNG)
    • -
  • -ftJPEG: JPEG file
    • -
  • -ftDDS: Direct Draw Surface file (DDS)
    • -
  • -ftTGA: Targa Image File (TGA)
    • -
  • -ftBMP: Windows Bitmap File (BMP)
    • -
  • -ftRAW: glBitmap RAW file format
    • -
-
- - - - - -
TglBitmapFileTypes = set of TglBitmapFileType;
- 
- - - - - -
TglBitmapMipMap = (...);
-

-possible mipmap types

-
Values
-
    -
  • -mmNone: no mipmaps
    • -
  • -mmMipmap: normal mipmaps
    • -
  • -mmMipmapGlu: mipmaps generated with glu functions
    • -
-
- - - - - -
TglBitmapNormalMapFunc = (...);
-

-possible normal map functions

-
Values
-
    -
  • -nm4Samples:  
    • -
  • -nmSobel:  
    • -
  • -nm3x3:  
    • -
  • -nm5x5:  
    • -
-
- - - - - -
PglBitmapPixelData = ˆTglBitmapPixelData;
- 
- - - - - -
TglBitmapSizeFields = set of (ffX, ffY);
- 
- - - - - -
TglBitmapPixelPosition = TglBitmapSize;
- 
- - - - - -
TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
-

-callback to use for converting texture data

-
-

Constants

- - - - - -
NULL_SIZE: TglBitmapSize = (Fields: []; X: 0; Y: 0);
- 
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/index.html b/doc/index.html deleted file mode 100644 index 063a13d..0000000 --- a/doc/index.html +++ /dev/null @@ -1,31 +0,0 @@ - - - -All Units - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

All Units

- - - - - - - - - -
NameDescription
glBitmap

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

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

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

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

-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/legend.html b/doc/legend.html deleted file mode 100644 index e908f2e..0000000 --- a/doc/legend.html +++ /dev/null @@ -1,53 +0,0 @@ - - - -Legend - - - - - -
-

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

 -

Legend

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
MarkerVisibility
Strict PrivateStrict Private
PrivatePrivate
Strict ProtectedStrict Protected
ProtectedProtected
PublicPublic
PublishedPublished
AutomatedAutomated
ImplicitImplicit
-
Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 - -
diff --git a/doc/pasdoc.css b/doc/pasdoc.css deleted file mode 100644 index 81e3138..0000000 --- a/doc/pasdoc.css +++ /dev/null @@ -1,171 +0,0 @@ -body, html, table.container { - margin: 0; - padding: 0; -} - -body { - font-family: Verdana,Arial; - color: black; - background-color: white; - font-size: 12px; -} - -table.container { - width: 100%; - border-spacing: 0; -} -table.container td { - vertical-align: top; -} - -td.navigation { - width: 200px; - color: white; - background-color: #787878; - margin: 0; - /* padding-bottom is a little larger, to make navigation column have some - nice height even when td.content column is very small. */ - padding: 1em 1em 100px 1em; -} -td.navigation p { padding: 0; } -td.navigation h2 { margin-top: 0; } - -td.content { padding: 1em; } -td.content h1 { margin-top: 0; } - -img { border:0px; } - -a:link {color:#C91E0C; text-decoration: none; } -a:visited {color:#7E5C31; text-decoration: none; } -a:hover {text-decoration: underline; } -a:active {text-decoration: underline; } - -a.navigation:link { color: white; text-decoration: none; } -a.navigation:visited { color: white; text-decoration: none; } -a.navigation:hover { color: white; font-weight: bold; text-decoration: none; } -a.navigation:active { color: white; text-decoration: none; } - -a.bold:link {color:#C91E0C; text-decoration: none; font-weight:bold; } -a.bold:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } -a.bold:hover {text-decoration: underline; font-weight:bold; } -a.bold:active {text-decoration: underline; font-weight:bold; } - -a.section {color: green; text-decoration: none; font-weight: bold; } -a.section:hover {color: green; text-decoration: underline; font-weight: bold; } - -ul.useslist a:link {color:#C91E0C; text-decoration: none; font-weight:bold; } -ul.useslist a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } -ul.useslist a:hover {text-decoration: underline; font-weight:bold; } -ul.useslist a:active {text-decoration: underline; font-weight:bold; } - -ul.hierarchy { list-style-type:none; } -ul.hierarchylevel { list-style-type:none; } - -p.unitlink a:link {color:#C91E0C; text-decoration: none; font-weight:bold; } -p.unitlink a:visited {color:#7E5C31; text-decoration: none; font-weight:bold; } -p.unitlink a:hover {text-decoration: underline; font-weight:bold; } -p.unitlink a:active {text-decoration: underline; font-weight:bold; } - -tr.list { background: #FFBF44; } -tr.list2 { background: #FFC982; } -tr.listheader { background: #C91E0C; color: white; } - -table.wide_list { border-spacing:2px; width:100%; } -table.wide_list td { vertical-align:top; padding:4px; } - -table.markerlegend { width:auto; } -table.markerlegend td.legendmarker { text-align:center; } - -table.sections { background:white; } -table.sections td {background:lightgray; } - -table.summary td.itemcode { width:100%; } -table.detail td.itemcode { width:100%; } - -td.itemname {white-space:nowrap; } -td.itemunit {white-space:nowrap; } -td.itemdesc { width:100%; } - -div.nodescription { color:red; } -dl.parameters dt { color:blue; } - -/* Various browsers have various default styles for
, - sometimes ugly for our purposes, so it's best to set things - like font-size and font-weight in out pasdoc.css explicitly. */ -h6.description_section { - /* font-size 100% means that it has the same font size as the - parent element, i.e. normal description text */ - font-size: 100%; - font-weight: bold; - /* By default browsers usually have some large margin-bottom and - margin-top for tags. In our case, margin-bottom is - unnecessary, we want to visually show that description_section - is closely related to content below. In this situation - (where the font size is just as a normal text), smaller bottom - margin seems to look good. */ - margin-bottom: 0em; -} - -/* Style applied to Pascal code in documentation - (e.g. produced by @longcode tag) } */ -span.pascal_string { color: #000080; } -span.pascal_keyword { font-weight: bolder; } -span.pascal_comment { color: #000080; font-style: italic; } -span.pascal_compiler_comment { color: #008000; } -span.pascal_numeric { } -span.pascal_hex { } - -p.hint_directive { color: red; } - -input#search_text { } -input#search_submit_button { } - -acronym.mispelling { background-color: #ffa; } - -/* Actually this reduces vertical space between *every* paragraph - inside list with @itemSpacing(compact). - While we would like to reduce this space only for the - top of 1st and bottom of last paragraph within each list item. - But, well, user probably will not do any paragraph breaks - within a list with @itemSpacing(compact) anyway, so it's - acceptable solution. */ -ul.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } -ol.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } -dl.compact_spacing p { margin-top: 0em; margin-bottom: 0em; } - -/* Style for table created by @table tags: - just some thin border. - - This way we have some borders around the cells - (so cells are visibly separated), but the border - "blends with the background" so it doesn't look too ugly. - Hopefully it looks satisfactory in most cases and for most - people. - - We add padding for cells, otherwise they look too close. - This is normal thing to do when border-collapse is set to - collapse (because this eliminates spacing between cells). -*/ -table.table_tag { border-collapse: collapse; } -table.table_tag td { border: 1pt solid gray; padding: 0.3em; } -table.table_tag th { border: 1pt solid gray; padding: 0.3em; } - -table.detail { - border: 1pt solid gray; - margin-top: 0.3em; - margin-bottom: 0.3em; -} - -.search-form { white-space: nowrap; } -.search-input, .search-button { display: inline-block; vertical-align: middle; } - -/* Do not make extra vertical space at the beginning/end of table cells. - We need ">" selector, to not change paragraphs inside lists inside - table cells. */ -table.table_tag td > p:first-child, -table.table_tag th > p:first-child, - td.itemdesc > p:first-child { margin-top: 0em; } - -table.table_tag td > p:last-child, -table.table_tag th > p:last-child, - td.itemdesc > p:last-child { margin-bottom: 0em; } diff --git a/doc/private.gif b/doc/private.gif deleted file mode 100644 index dca4ce2..0000000 Binary files a/doc/private.gif and /dev/null differ diff --git a/doc/protected.gif b/doc/protected.gif deleted file mode 100644 index 96cc382..0000000 Binary files a/doc/protected.gif and /dev/null differ diff --git a/doc/public.gif b/doc/public.gif deleted file mode 100644 index 89f1197..0000000 Binary files a/doc/public.gif and /dev/null differ diff --git a/doc/published.gif b/doc/published.gif deleted file mode 100644 index 6ed9af6..0000000 Binary files a/doc/published.gif and /dev/null differ diff --git a/examples/GrabScreen/GrabScreen.lpi b/examples/GrabScreen/GrabScreen.lpi deleted file mode 100644 index 12f6c24..0000000 --- a/examples/GrabScreen/GrabScreen.lpi +++ /dev/null @@ -1,80 +0,0 @@ - - - - - - - - - - - - - - <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> diff --git a/examples/GrabScreen/GrabScreen.lpr b/examples/GrabScreen/GrabScreen.lpr deleted file mode 100644 index 97acff5..0000000 --- a/examples/GrabScreen/GrabScreen.lpr +++ /dev/null @@ -1,60 +0,0 @@ -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. - - diff --git a/examples/GrabScreen/GrabScreen.lps b/examples/GrabScreen/GrabScreen.lps deleted file mode 100644 index 92e04b8..0000000 --- a/examples/GrabScreen/GrabScreen.lps +++ /dev/null @@ -1,166 +0,0 @@ -<?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> diff --git a/examples/Helper.pas b/examples/Helper.pas deleted file mode 100644 index 5311e5c..0000000 --- a/examples/Helper.pas +++ /dev/null @@ -1,91 +0,0 @@ -unit Helper; - -{$mode objfpc}{$H+} - -interface - -uses - Classes, SysUtils, Windows, dglOpenGL; - -type - TOpenGLWindow = packed record - LWndClass: TWndClass; - hMainHandle: HWND; - DC: HDC; - RC: HGLRC; - end; - -function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow; -function ProgressMesages: Boolean; -procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow); - -implementation - -function CreateOpenGLWindow(const aCaption: String; const aWidth, aHeight: Integer; const aWndProc: WNDPROC): TOpenGLWindow; -begin - //create the window - result.LWndClass.hInstance := hInstance; - with result.LWndClass do begin - lpszClassName := 'MyWinApiWnd'; - Style := CS_PARENTDC or CS_BYTEALIGNCLIENT; - hIcon := LoadIcon(hInstance,'MAINICON'); - lpfnWndProc := aWndProc; - hbrBackground := COLOR_BTNFACE+1; - hCursor := LoadCursor(0,IDC_ARROW); - end; - RegisterClass(result.LWndClass); - result.hMainHandle := CreateWindow( - result.LWndClass.lpszClassName, - PAnsiChar(aCaption), - WS_CAPTION or WS_MINIMIZEBOX or WS_SYSMENU or WS_VISIBLE, - (GetSystemMetrics(SM_CXSCREEN) - aWidth) div 2, - (GetSystemMetrics(SM_CYSCREEN) - aHeight) div 2, - aWidth, aHeight, 0, 0, hInstance, nil); - - // create and activate rendering context - result.DC := GetDC(result.hMainHandle); - if (result.DC = 0) then begin - WriteLn('unable to get DeviceContext'); - halt; - end; - result.RC := CreateRenderingContext(result.DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0); - if (result.RC = 0) then begin - WriteLn('unable to create RenderingContext'); - halt; - end; - ActivateRenderingContext(result.DC, result.RC); - - // init OpenGL - glViewport(0, 0, aWidth, aHeight); - glClearColor(0, 0, 0, 0); - glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); - - glDisable(GL_DEPTH_TEST); - glDisable(GL_CULL_FACE); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity; - glOrtho(0, aWidth, aHeight, 0, -10, 10); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity; -end; - -function ProgressMesages: Boolean; -var - Msg: TMSG; -begin - result := GetMessage(Msg, 0, 0, 0); - if result then begin - TranslateMessage(Msg); - DispatchMessage(Msg); - end; -end; - -procedure DestroyOpenGLWindow(const aWindow: TOpenGLWindow); -begin - DestroyRenderingContext(aWindow.RC); - ReleaseDC(aWindow.hMainHandle, aWindow.DC); -end; - -end. - diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi deleted file mode 100644 index 50332a3..0000000 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi +++ /dev/null @@ -1,79 +0,0 @@ -<?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> diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr deleted file mode 100644 index 64d2db7..0000000 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr +++ /dev/null @@ -1,65 +0,0 @@ -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. - diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps deleted file mode 100644 index 5c03634..0000000 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps +++ /dev/null @@ -1,145 +0,0 @@ -<?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> diff --git a/examples/TextureFromFunction/TextureFromFunction.lpi b/examples/TextureFromFunction/TextureFromFunction.lpi deleted file mode 100644 index 897ab96..0000000 --- a/examples/TextureFromFunction/TextureFromFunction.lpi +++ /dev/null @@ -1,81 +0,0 @@ -<?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> diff --git a/examples/TextureFromFunction/TextureFromFunction.lpr b/examples/TextureFromFunction/TextureFromFunction.lpr deleted file mode 100644 index 7c60833..0000000 --- a/examples/TextureFromFunction/TextureFromFunction.lpr +++ /dev/null @@ -1,101 +0,0 @@ -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. - diff --git a/examples/TextureFromFunction/TextureFromFunction.lps b/examples/TextureFromFunction/TextureFromFunction.lps deleted file mode 100644 index aa8b9d4..0000000 --- a/examples/TextureFromFunction/TextureFromFunction.lps +++ /dev/null @@ -1,116 +0,0 @@ -<?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> diff --git a/examples/dglOpenGL.pas b/examples/dglOpenGL.pas deleted file mode 100644 index 7772eee..0000000 --- a/examples/dglOpenGL.pas +++ /dev/null @@ -1,20081 +0,0 @@ -{ ============================================================================ - - OpenGL 4.4 - Headertranslation - Version 4.4 - Date : 2013/07/22 - - Supported environments and targets : - - (Win32) Delphi 4 and up - - (Win32, Win64) Delphi XE2 - - (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up) - -============================================================================== - - Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h. - It also contains some helperfunctions that were inspired by those - found in Mike Lischke's OpenGL12.pas. - - Copyright (C) DGL-OpenGL2-Portteam - All Rights Reserved - - Obtained through: - Delphi OpenGL Community(DGL) - www.delphigl.com - - Converted and maintained by DGL's GL2.0-Team : - - Sascha Willems - http://www.saschawillems.de - - Steffen Xonna (Lossy eX) - http://www.dev-center.de - Additional input : - - Andrey Gruzdev (Mac OS X patch for XE2 / FPC) - - Lars Middendorf - - Martin Waldegger (Mars) - - Benjamin Rosseaux (BeRo) - http://www.0ok.de - Additional thanks: - sigsegv (libdl.so) - -============================================================================== - You may retrieve the latest version of this file at the Delphi OpenGL - Community home page, located at http://www.delphigl.com/ - - The contents of this file are used with permission, subject to - the Mozilla Public License Version 1.1 (the "License"); you may - not use this file except in compliance with the License. You may - obtain a copy of the License at - http://www.mozilla.org/MPL/MPL-1.1.html - - Software distributed under the License is distributed on an - "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - implied. See the License for the specific language governing - rights and limitations under the License. - -============================================================================== - History : - Version 1.0 Initial Release - Version 1.1 Added PPointer in Tpyessection for compatiblity with Delphi - versions lower than 7 (SW) - Added a function named RaiseLastOSError including a comment - on how to make it run under Delphi versions lower than 7 (SW) - Added some data types according to the GL-Syntax (SW) - Version 1.2 Fixed some problems with getting the addresses of some - Extensions (e.g. glTexImage3D) where the EXT/ARB did work - but not the core-functions (SW) - Version 1.3 A second call to ReadimplementationProperties won't - revert to the default libs anymore (MW) - Libraries now will be released if necessary (MW) - Version 1.3a Small fixes for glSlang-functions (SW) - Version 1.3b Fixed a small bug with GL_ARB_shader_objects, that lead - lead to that extension not loaded correctly (SW) - Version 1.3c more GL 1.5 compliance by FOG_COORD_xx and - ARB less VBO and occlusion query routines (MW) - Version 1.3d Fixed linebreaks (should now be corrected under D5) (SW) - Version 1.4 Changed header to correspond to the OpenGL-Shading - Language specification 1.10 : - - Added new GL_SAMPLER_*-Constants - - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB - - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB - - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW) - Version 1.4a Fixed a missing stdcall for glBindAttribLocationARB (SW) - Version 1.4b Fixed declaration for glUniform*(f/i)vARB (added count) (MW) - glCompileShaderARB changed from function to procedure (MW) - Version 1.5 Added support for FreePascal (BR) - Added type TGLVectorf3/TGLVector3f (SW) - Version 1.6 Added Extension GL_EXT_framebuffer_object (SX) - Version 1.7 Added Extension GL_ARB_fragment_program_shadow (SX) - Added Extension GL_ARB_draw_buffers (SX) - Added Extension GL_ARB_texture_rectangle (SX) - Added Extension GL_ARB_color_buffer_float (SX) - Added Extension GL_ARB_half_float_pixel (SX) - Added Extension GL_ARB_texture_float (SX) - Added Extension GL_ARB_pixel_buffer_object (SX) - Added Extension GL_EXT_depth_bounds_test (SX) - Added Extension GL_EXT_texture_mirror_clamp (SX) - Added Extension GL_EXT_blend_equation_separate (SX) - Added Extension GL_EXT_pixel_buffer_object (SX) - Added Extension GL_EXT_texture_compression_dxt1 (SX) - Added Extension GL_NV_fragment_program_option (SX) - Added Extension GL_NV_fragment_program2 (SX) - Added Extension GL_NV_vertex_program2_option (SX) - Added Extension GL_NV_vertex_program3 (SX) - Version 1.8 Added explicit delegate type definitions (LM) - Added .Net 1.1 Support (LM) - Added .Net overloaded functions (LM) - Added delayed extension loading and stubs (LM) - Added automatic InitOpenGL call in CreateRenderingContext(LM) - Added extra Read_* function (LM) - Version 2.0 fixed some Problem with version string and damn drivers. - String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX) - Removed unexisting extension GL_ARB_texture_mirror_repeat(SX) - Added Extension WGL_ARB_pixel_format_float (SX) - Added Extension GL_EXT_stencil_clear_tag (SX) - Added Extension GL_EXT_texture_rectangle (SX) - Added Extension GL_EXT_texture_edge_clamp (SX) - Some 1.5 Core Consts added (now completed) (SX) - gluProject need pointer for not .net (SX) - gluUnProject need pointer for not .net (SX) - wglUseFontOutlines* need pointer for not .net (SX) - wglSwapMultipleBuffers need pointer for not .net (SX) - Bug with wglGetExtensionsStringEXT removed - different type for .net (SX) - Added OpenGL 2.0 Core (SX) - Version 2.0.1 fixed some problems with glGetActiveAttrib in 2.0 Core (SX) - fixes some problems with gluProject (SX) - fixes some problems with gluUnProject (SX) - fixes some problems with gluTessVertex (SX) - fixes some problems with gluLoadSamplingMatrices (SX) - Version 2.1 Removed .NET Support (SX) - Better support for Linux (SX) - Better Codeformation (SX) - Added some more Vector/Matrix types (SX) - Added OpenGL 2.1 Core (SX) - Added Extension GL_EXT_packed_depth_stencil (SX) - Added Extension GL_EXT_texture_sRGB (SX) - Added Extension GL_EXT_framebuffer_blit (SX) - Added Extension GL_EXT_framebuffer_multisample (SX) - Added Extension GL_EXT_timer_query (SX) - Added Extension GL_EXT_gpu_program_parameters (SX) - Added Extension GL_EXT_bindable_uniform (SX) - Added Extension GL_EXT_draw_buffers2 (SX) - Added Extension GL_EXT_draw_instanced (SX) - Added Extension GL_EXT_framebuffer_sRGB (SX) - Added Extension GL_EXT_geometry_shader4 (SX) - Added Extension GL_EXT_gpu_shader4 (SX) - Added Extension GL_EXT_packed_float (SX) - Added Extension GL_EXT_texture_array (SX) - Added Extension GL_EXT_texture_buffer_object (SX) - Added Extension GL_EXT_texture_compression_latc (SX) - Added Extension GL_EXT_texture_compression_rgtc (SX) - Added Extension GL_EXT_texture_integer (SX) - Added Extension GL_EXT_texture_shared_exponent (SX) - Added Extension GL_NV_depth_buffer_float (SX) - Added Extension GL_NV_fragment_program4 (SX) - Added Extension GL_NV_framebuffer_multisample_coverage (SX) - Added Extension GL_NV_geometry_program4 (SX) - Added Extension GL_NV_gpu_program4 (SX) - Added Extension GL_NV_parameter_buffer_object (SX) - Added Extension GL_NV_transform_feedback (SX) - Added Extension GL_NV_vertex_program4 (SX) - Version 3.0 fixed some const of GL_EXT_texture_shared_exponent (SX) - possible better support for mac (SX) - Added OpenGL 3.0 Core (SX) - Added Extension GL_ARB_depth_buffer_float (SX) - Added Extension GL_ARB_draw_instanced (SX) - Added Extension GL_ARB_framebuffer_object (SX) - Added Extension GL_ARB_framebuffer_sRGB (SX) - Added Extension GL_ARB_geometry_shader4 (SX) - Added Extension GL_ARB_half_float_vertex (SX) - Added Extension GL_ARB_instanced_arrays (SX) - Added Extension GL_ARB_map_buffer_range (SX) - Added Extension GL_ARB_texture_buffer_object (SX) - Added Extension GL_ARB_texture_compression_rgtc (SX) - Added Extension GL_ARB_texture_rg (SX) - Added Extension GL_ARB_vertex_array_object (SX) - Added Extension GL_NV_conditional_render (SX) - Added Extension GL_NV_present_video (SX) - Added Extension GL_EXT_transform_feedback (SX) - Added Extension GL_EXT_direct_state_access (SX) - Added Extension GL_EXT_vertex_array_bgra (SX) - Added Extension GL_EXT_texture_swizzle (SX) - Added Extension GL_NV_explicit_multisample (SX) - Added Extension GL_NV_transform_feedback2 (SX) - Added Extension WGL_ARB_create_context (SX) - Added Extension WGL_NV_present_video (SX) - Added Extension WGL_NV_video_out (SX) - Added Extension WGL_NV_swap_group (SX) - Added Extension WGL_NV_gpu_affinity (SX) - Added define DGL_TINY_HEADER to suppress automatic - function loading (SX) - glProcedure renamed to dglGetProcAddress and now it's - visible from outside the unit to custom load functions (SX) - dglCheckExtension added to check if an extension exists (SX) - Read_GL_ARB_buffer_object renamed to - Read_GL_ARB_vertex_buffer_object (SX) - Version 3.0.1 fixed an problem with fpc (SX) - Version 3.0.2 fixed an problem with WGL_ARB_create_context (SX) - Version 3.2 Functions from GL_VERSION_3_0 where updated (SX) - Functions from GL_ARB_map_buffer_range where updated (SX) - Functions from GL_NV_present_video where added (SX) - Added consts of GL_ARB_instanced_arrays (SX) - Defines to identify Delphi was changed (prevent for - feature maintenance) (SX) - Added Extension GL_ATI_meminfo (SX) - Added Extension GL_AMD_performance_monitor (SX) - Added Extension GL_AMD_texture_texture4 (SX) - Added Extension GL_AMD_vertex_shader_tesselator (SX) - Added Extension GL_EXT_provoking_vertex (SX) - Added Extension WGL_AMD_gpu_association (SX) - Added OpenGL 3.1 Core (SX) - All deprecated stuff can be disabled if you undef the - define DGL_DEPRECATED (SX) - Added Extension GL_ARB_uniform_buffer_object (SX) - Added Extension GL_ARB_compatibility (SX) - Added Extension GL_ARB_copy_buffer (SX) - Added Extension GL_ARB_shader_texture_lod (SX) - Remove function from GL_NV_present_video (SX) - Added Extension WGL_3DL_stereo_control (SX) - Added Extension GL_EXT_texture_snorm (SX) - Added Extension GL_AMD_draw_buffers_blend (SX) - Added Extension GL_APPLE_texture_range (SX) - Added Extension GL_APPLE_float_pixels (SX) - Added Extension GL_APPLE_vertex_program_evaluators (SX) - Added Extension GL_APPLE_aux_depth_stencil (SX) - Added Extension GL_APPLE_object_purgeable (SX) - Added Extension GL_APPLE_row_bytes (SX) - Added OpenGL 3.2 Core (SX) - Added Extension GL_ARB_depth_clamp (SX) - Added Extension GL_ARB_draw_elements_base_vertex (SX) - Added Extension GL_ARB_fragment_coord_conventions (SX) - Added Extension GL_ARB_provoking_vertex (SX) - Added Extension GL_ARB_seamless_cube_map (SX) - Added Extension GL_ARB_sync (SX) - Added Extension GL_ARB_texture_multisample (SX) - Added Extension GL_ARB_vertex_array_bgra (SX) - Added Extension GL_ARB_draw_buffers_blend (SX) - Added Extension GL_ARB_sample_shading (SX) - Added Extension GL_ARB_texture_cube_map_array (SX) - Added Extension GL_ARB_texture_gather (SX) - Added Extension GL_ARB_texture_query_lod (SX) - Added Extension WGL_ARB_create_context_profile (SX) - Added GLX Core up to Version 1.4 (SX) - Added Extension GLX_ARB_multisample (SX) - Added Extension GLX_ARB_fbconfig_float (SX) - Added Extension GLX_ARB_get_proc_address (SX) - Added Extension GLX_ARB_create_context (SX) - Added Extension GLX_ARB_create_context_profile (SX) - Added Extension GLX_EXT_visual_info (SX) - Added Extension GLX_EXT_visual_rating (SX) - Added Extension GLX_EXT_import_context (SX) - Added Extension GLX_EXT_fbconfig_packed_float (SX) - Added Extension GLX_EXT_framebuffer_sRGB (SX) - Added Extension GLX_EXT_texture_from_pixmap (SX) - Version 3.2.1 Fixed some problems with Delphi < 6 (SX) - Version 3.2.2 Added Extension GL_APPLE_rgb_422 (SX) - Added Extension GL_EXT_separate_shader_objects (SX) - Added Extension GL_NV_video_capture (SX) - Added Extension GL_NV_copy_image (SX) - Added Extension GL_NV_parameter_buffer_object2 (SX) - Added Extension GL_NV_shader_buffer_load (SX) - Added Extension GL_NV_vertex_buffer_unified_memory (SX) - Added Extension GL_NV_texture_barrier (SX) - Variable GL_EXT_texture_snorm will be filled (SX) - Variable GL_APPLE_row_bytes will be filled (SX) - Added Extension WGL_NV_video_capture (SX) - Added Extension WGL_NV_copy_image (SX) - WGL_NV_video_out now named WGL_NV_video_output (SX) - Added Extension GLX_EXT_swap_control (SX) - Version 3.2.3 Fixed an Problem with glGetAttribLocation (SX) - Added const GL_UNIFORM_BUFFER_EXT (SX) - Functions of GL_NV_texture_barrier now will be loaded (SX) - Version 4.0 Changes on Extension GL_ARB_texture_gather (SX) - Changes on Extension GL_NV_shader_buffer_load (SX) - Added OpenGL 3.3 Core (SX) - Added OpenGL 4.0 Core (SX) - Added Extension GL_AMD_shader_stencil_export (SX) - Added Extension GL_AMD_seamless_cubemap_per_texture (SX) - Added Extension GL_ARB_shading_language_include (SX) - Added Extension GL_ARB_texture_compression_bptc (SX) - Added Extension GL_ARB_blend_func_extended (SX) - Added Extension GL_ARB_explicit_attrib_location (SX) - Added Extension GL_ARB_occlusion_query2 (SX) - Added Extension GL_ARB_sampler_objects (SX) - Added Extension GL_ARB_shader_bit_encoding (SX) - Added Extension GL_ARB_texture_rgb10_a2ui (SX) - Added Extension GL_ARB_texture_swizzle (SX) - Added Extension GL_ARB_timer_query (SX) - Added Extension GL_ARB_vertex_type_2_10_10_10_rev (SX) - Added Extension GL_ARB_draw_indirect (SX) - Added Extension GL_ARB_gpu_shader5 (SX) - Added Extension GL_ARB_gpu_shader_fp64 (SX) - Added Extension GL_ARB_shader_subroutine (SX) - Added Extension GL_ARB_tessellation_shader (SX) - Added Extension GL_ARB_texture_buffer_object_rgb32 (SX) - Added Extension GL_ARB_transform_feedback2 (SX) - Added Extension GL_ARB_transform_feedback3 (SX) - Version 4.1 Possible fix some strange linux behavior (SX) - All function uses GL instead of TGL types (SX) - GL_AMD_vertex_shader_tesselator will be read now (SX) - GL_AMD_draw_buffers_blend will be read now (SX) - Changes on glStencilFuncSeparate (GL_2_0) (SX) - Changes on GL_VERSION_3_2 (SX) - Changes on GL_VERSION_3_3 (SX) - Changes on GL_VERSION_4_0 (SX) - Changes on GL_ARB_sample_shading (SX) - Changes on GL_ARB_texture_cube_map_array (SX) - Changes on GL_ARB_gpu_shader5 (SX) - Changes on GL_ARB_transform_feedback3 (SX) - Changes on GL_ARB_sampler_objects (SX) - Changes on GL_ARB_gpu_shader_fp64 (SX) - Changes on GL_APPLE_element_array (SX) - Changes on GL_APPLE_vertex_array_range (SX) - Changes on GL_NV_transform_feedback (SX) - Changes on GL_NV_vertex_buffer_unified_memory (SX) - Changes on GL_EXT_multi_draw_arrays (SX) - Changes on GL_EXT_direct_state_access (SX) - Changes on GL_AMD_performance_monitor (SX) - Changes on GL_AMD_seamless_cubemap_per_texture (SX) - Changes on GL_EXT_geometry_shader4 (SX) - Added OpenGL 4.1 Core (SX) - Added Extension GL_ARB_ES2_compatibility (SX) - Added Extension GL_ARB_get_program_binary (SX) - Added Extension GL_ARB_separate_shader_objects (SX) - Added Extension GL_ARB_shader_precision (SX) - Added Extension GL_ARB_vertex_attrib_64bit (SX) - Added Extension GL_ARB_viewport_array (SX) - Added Extension GL_ARB_cl_event (SX) - Added Extension GL_ARB_debug_output (SX) - Added Extension GL_ARB_robustness (SX) - Added Extension GL_ARB_shader_stencil_export (SX) - Added Extension GL_AMD_conservative_depth (SX) - Added Extension GL_EXT_shader_image_load_store (SX) - Added Extension GL_EXT_vertex_attrib_64bit (SX) - Added Extension GL_NV_gpu_program5 (SX) - Added Extension GL_NV_gpu_shader5 (SX) - Added Extension GL_NV_shader_buffer_store (SX) - Added Extension GL_NV_tessellation_program5 (SX) - Added Extension GL_NV_vertex_attrib_integer_64bit (SX) - Added Extension GL_NV_multisample_coverage (SX) - Added Extension GL_AMD_name_gen_delete (SX) - Added Extension GL_AMD_debug_output (SX) - Added Extension GL_NV_vdpau_interop (SX) - Added Extension GL_AMD_transform_feedback3_lines_triangles (SX) - Added Extension GL_AMD_depth_clamp_separate (SX) - Added Extension GL_EXT_texture_sRGB_decode (SX) - Added Extension WGL_ARB_framebuffer_sRGB (SX) - Added Extension WGL_ARB_create_context_robustness (SX) - Added Extension WGL_EXT_create_context_es2_profile (SX) - Added Extension WGL_NV_multisample_coverage (SX) - Added Extension GLX_ARB_vertex_buffer_object (SX) - Added Extension GLX_ARB_framebuffer_sRGB (SX) - Added Extension GLX_ARB_create_context_robustness (SX) - Added Extension GLX_EXT_create_context_es2_profile (SX) - Version 4.1a Fix for dglGetProcAddress with FPC and linux (def param) (SW) - Version 4.2 Added OpenGL 4.2 Core (SW) - Added Extension GL_ARB_base_instance (SW) - Added Extension GL_ARB_shading_language_420pack (SW) - Added Extension GL_ARB_transform_feedback_instanced (SW) - Added Extension GL_ARB_compressed_texture_pixel_storage (SW) - Added Extension GL_ARB_conservative_depth (SW) - Added Extension GL_ARB_internalformat_query (SW) - Added Extension GL_ARB_map_buffer_alignment (SW) - Added Extension GL_ARB_shader_atomic_counters (SW) - Added Extension GL_ARB_shader_image_load_store (SW) - Added Extension GL_ARB_shading_language_packing (SW) - Added Extension GL_ARB_texture_storage (SW) - Added Extension WGL_NV_DX_interop (SW) - Added Define for WGL_EXT_create_context_es2_profile (SW) - Version 4.2a Added Mac OS X patch by Andrey Gruzdev (SW) - Version 4.3 Added OpenGL 4.3 Core (SW) - Added GL_ARB_arrays_of_arrays (SW) - Added GL_ARB_fragment_layer_viewport (SW) - Added GL_ARB_shader_image_size (SW) - Added GL_ARB_ES3_compatibility (SW) - Added GL_ARB_clear_buffer_object (SW) - Added GL_ARB_compute_shader (SW) - Added GL_ARB_copy_image (SW) - Added GL_KHR_debug (SW) - Added GL_ARB_explicit_uniform_location, (SW) - Added GL_ARB_framebuffer_no_attachments (SW) - Added GL_ARB_internalformat_query2 (SW) - Added GL_ARB_invalidate_subdata (SW) - Added GL_ARB_multi_draw_indirect (SW) - Added GL_ARB_program_interface_query (SW) - Added GL_ARB_robust_buffer_access_behavior (SW) - Added GL_ARB_shader_storage_buffer_object (SW) - Added GL_ARB_stencil_texturing (SW) - Added GL_ARB_texture_buffer_range (SW) - Added GL_ARB_texture_query_levels (SW) - Added GL_ARB_texture_storage_multisample (SW) - Added GL_ARB_texture_view (SW) - Added GL_ARB_vertex_attrib_binding (SW) - Added new vendor-specific extensions (SW) - Added GL_NV_path_rendering (SW) - Added GL_AMD_pinned_memory (SW) - Added GL_AMD_stencil_operation_extended (SW) - Added GL_AMD_vertex_shader_viewport_index (SW) - Added GL_AMD_vertex_shader_layer (SW) - Added GL_NV_bindless_texture (SW) - Added GL_NV_shader_atomic_float (SW) - Added GL_AMD_query_buffer_object (SW) - Added CreateRenderingContextVersion (SW) - Version 4.4 Added ARB_buffer_storage (SW) - Added ARB_clear_texture extension (SW) - Added ARB_enhanced_layouts extension (SW) - Added ARB_multi_bind extension (SW) - Added ARB_query_buffer_object extension (SW) - Added ARB_texture_mirror_clamp_to_edge extension (SW) - Added ARB_texture_stencil8 extension (SW) - Added ARB_vertex_type_10f_11f_11f_rev extension (SW) - Added MAX_VERTEX_ATTRIB_STRIDE stat (SW) - Added missing functions for GL_EXT_direct_state_access (SW) - GL3.0+ uses non-deprecated way of getting extensions - (thanks to frenK) (SW) - Added missing cdecl for TglXGetVisualFromFBConfig (SW) - - -============================================================================== - Header based on glext.h rev 87 (2012-08-06) - Header based on wglext.h rev 24 (2012/01/04) - Header based on glxext.h rev 33 (2012/02/29) (only Core/ARB/EXT) - - This is an important notice for maintaining. Dont remove it. And make sure - to keep it up to date -============================================================================== } - -{$define DGL_DEPRECATED} -{ - This define defines if the header should use deprecated ARB stuff or not. - per Default the Header use deprecated Stuff. -} - - -{.$define DGL_TINY_HEADER} -{ - If you enable the define DGL_TINY_HEADER no function automatically will be loaded if you - call ActivateRenderingContext. This may some bit faster and the smart linker can delete - all non used functions. This will reduce the filesize of your binary file. But in this - case you have to load the functions by yourself. There are two ways to do this. - - 1. You can load whole extension by calling the func Read_Extensionname. But if you do - this it's possible to load functions you dont use. So you have the same "problem" - like before. But it's only an bit smaler. - > Read_GL_ARB_multitexture; - - 2. You are able to load only the functions you exactly need. In this case you are able - to use the variables of the dglOpenGL.pas. So you only need to load the functions - and you can use the header like before. - To do this you have to created and activated an opengl context and than you can load - the needed functions. - > ActivateRenderingContext(fDC, fRC); - > glActiveTextureARB := dglGetProcAddress('glActiveTextureARB'); - > glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB'); - - So only the function "glActiveTextureARB" and "glMultiTexCoord2fARB" will be loaded. - - - Please notice that the extension variables won't be loaded if this define is active. But - you can call dglCheckExtension to check if any extension exists. You can assign them to - the variables of the dglOpenGL.pas so all code they use this will find them. - - > GL_ARB_shading_language_100 := dglCheckExtension('GL_ARB_shading_language_100'); -} - - -unit dglOpenGL; - -interface - -// defines to configure freepascal -{$IFDEF FPC} - {$MODE Delphi} - - {$IFNDEF WINDOWS} - {$LINKLIB c} - {$ENDIF} -{$ENDIF} - -// known delphi versions -{$IFNDEF FPC} // if freepascal isnt defined - {$IFDEF VER140} // Delphi 6 - {$DEFINE DELPHI6_AND_DOWN} - {$ENDIF} - - {$IFDEF VER130} // Delphi 5 - {$DEFINE DELPHI6_AND_DOWN} - {$ENDIF} - - {$IFDEF VER120} // Delphi 4 - {$DEFINE DELPHI6_AND_DOWN} - {$ENDIF} - - {$IFDEF VER110} // C++ Builder 3 - {$DEFINE DELPHI6_AND_DOWN} - {$ENDIF} - - {$IFDEF VER100} // Delphi 3 - {$DEFINE DELPHI6_AND_DOWN} - {$ENDIF} -{$ENDIF} - -// Options for Delphi < 5 -{$IFDEF DELPHI6_AND_DOWN} - {$A+} -{$ELSE} - {$A4} -{$ENDIF} - -// generell options -{$H+,O+,X+} - -// detecting Windows -{$IFDEF Win32} // Delphi and fpc of 32 Bit Windows - {$DEFINE DGL_WIN} -{$ENDIF} - -{$IFDEF Win64} // Delphi and fpc of 32 Bit Windows - {$DEFINE DGL_WIN} -{$ENDIF} - -// detecting Linux -{$IFDEF linux} // Linux - {$DEFINE DGL_LINUX} -{$ENDIF} - -{$IFDEF DARWIN} // Mac OS X and FPC - {$DEFINE DGL_MAC} -{$ENDIF} - -{$IFDEF DELPHI} // Mac OS X add Delphi -{$IFDEF MACOS} - {$DEFINE DGL_MAC} -{$ENDIF} -{$ENDIF} - - -// detecting 64 Bit CPU -{$IFDEF CPU64} // fpc on 64 bit cpus - {$DEFINE DGL_64BIT} // dgl define for 64 bit -{$ENDIF} - - - -uses - {$IFDEF FPC}{$IFDEF DARWIN}dynlibs,{$ENDIF}{$ENDIF} // LoadLibrary functions - SysUtils - {$IFDEF DGL_WIN}, Windows{$ENDIF} - {$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF} - ; - -type - // Needed for Delphi 6 and less (defined in system.pas for Delphi 7) - PPointer = ^Pointer; - PCardinal = ^Cardinal; - - GLenum = Cardinal; - GLboolean = BYTEBOOL; - GLbitfield = Cardinal; - GLbyte = Shortint; - GLshort = SmallInt; - GLint = Integer; - GLsizei = Integer; - GLubyte = Byte; - GLushort = Word; - GLuint = Cardinal; - GLfloat = Single; - GLclampf = Single; - GLdouble = Double; - GLclampd = Double; - GLvoid = Pointer; - GLint64 = Int64; - GLuint64 = {$IFDEF DELPHI6_AND_DOWN} Int64 {$ELSE} UInt64 {$ENDIF}; - - TGLenum = GLenum; - TGLboolean = GLboolean; - TGLbitfield = GLbitfield; - TGLbyte = GLbyte; - TGLshort = GLshort; - TGLint = GLint; - TGLsizei = GLsizei; - TGLubyte = GLubyte; - TGLushort = GLushort; - TGLuint = GLuint; - TGLfloat = GLfloat; - TGLclampf = GLclampf; - TGLdouble = GLdouble; - TGLclampd = GLclampd; - TGLvoid = GLvoid; - TGLint64 = GLint64; - TGLuint64 = GLuint64; - - PGLboolean = ^GLboolean; - PGLbyte = ^GLbyte; - PGLshort = ^GLshort; - PGLint = ^GLint; - PGLsizei = ^GLsizei; - PGLubyte = ^GLubyte; - PGLushort = ^GLushort; - PGLuint = ^GLuint; - PGLclampf = ^GLclampf; - PGLfloat = ^GLfloat; - PGLdouble = ^GLdouble; - PGLclampd = ^GLclampd; - PGLenum = ^GLenum; - PGLvoid = Pointer; - PPGLvoid = ^PGLvoid; - PGLint64 = ^GLint64; - PGLuint64 = ^GLuint64; - - // GL_NV_half_float - GLhalfNV = WORD; - TGLhalfNV = GLhalfNV; - PGLhalfNV = ^GLhalfNV; - - // GL_ARB_shader_objects - PGLHandleARB = ^GLHandleARB; - GLHandleARB = Integer; - GLcharARB = AnsiChar; - PGLcharARB = PAnsiChar; - PPGLcharARB = ^PGLcharARB; - - // GL_VERSION_1_5 - GLintptr = GLint; - GLsizeiptr = GLsizei; - - // GL_ARB_vertex_buffer_object - GLintptrARB = GLint; - GLsizeiptrARB = GLsizei; - - // GL_VERSION_2_0 - GLHandle = Integer; - PGLchar = PAnsiChar; - PPGLchar = ^PGLChar; - - // GL_EXT_timer_query - GLint64EXT = Int64; - TGLint64EXT = GLint64EXT; - PGLint64EXT = ^GLint64EXT; - - GLuint64EXT = GLuint64; - TGLuint64EXT = GLuint64EXT; - PGLuint64EXT = ^GLuint64EXT; - - // WGL_ARB_pbuffer - HPBUFFERARB = THandle; - - // WGL_EXT_pbuffer - HPBUFFEREXT = THandle; - - // WGL_NV_present_video - PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV; - HVIDEOOUTPUTDEVICENV = THandle; - - // WGL_NV_video_output - PHPVIDEODEV = ^HPVIDEODEV; - HPVIDEODEV = THandle; - - // WGL_NV_gpu_affinity - PHPGPUNV = ^HPGPUNV; - PHGPUNV = ^HGPUNV; - - // WGL_NV_video_capture - HVIDEOINPUTDEVICENV = THandle; - PHVIDEOINPUTDEVICENV = ^HVIDEOINPUTDEVICENV; - - HPGPUNV = THandle; - HGPUNV = THandle; - - // GL_ARB_sync - GLsync = Pointer; - - // GL_ARB_cl_event - { These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event } - _cl_context = record end; - _cl_event = record end; - p_cl_context = ^_cl_context; - p_cl_event = ^_cl_event; - - // GL_ARB_debug_output - TglDebugProcARB = procedure (source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_debug_output - TglDebugProcAMD = procedure (id: GLuint; category: GLenum; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // (4.3) GL_KHR_debug - TglDebugProc = procedure(source : GLEnum; type_ : GLEnum; id : GLUInt; severity : GLUInt; length : GLsizei; const message_ : PGLCHar; userParam : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vdpau_interop - GLvdpauSurfaceNV = GLintptr; - PGLvdpauSurfaceNV = ^GLvdpauSurfaceNV; - - - // GLX - {$IFDEF DGL_LINUX} - GLXContext = Pointer; - GLXContextID = TXID; - GLXDrawable = TXID; - GLXFBConfig = Pointer; - GLXPbuffer = TXID; - GLXPixmap = TXID; - GLXWindow = TXID; - - Window = TXID; - Colormap = TXID; - Pixmap = TXID; - Font = TXID; - {$ENDIF} - - // Datatypes corresponding to GL's types TGL(name)(type)(count) - TGLVectorub2 = array[0..1] of GLubyte; - TGLVectori2 = array[0..1] of GLint; - TGLVectorf2 = array[0..1] of GLfloat; - TGLVectord2 = array[0..1] of GLdouble; - TGLVectorp2 = array[0..1] of Pointer; - - TGLVectorub3 = array[0..2] of GLubyte; - TGLVectori3 = array[0..2] of GLint; - TGLVectorf3 = array[0..2] of GLfloat; - TGLVectord3 = array[0..2] of GLdouble; - TGLVectorp3 = array[0..2] of Pointer; - - TGLVectorub4 = array[0..3] of GLubyte; - TGLVectori4 = array[0..3] of GLint; - TGLVectorf4 = array[0..3] of GLfloat; - TGLVectord4 = array[0..3] of GLdouble; - TGLVectorp4 = array[0..3] of Pointer; - - TGLArrayf4 = TGLVectorf4; - TGLArrayf3 = TGLVectorf3; - TGLArrayd3 = TGLVectord3; - TGLArrayi4 = TGLVectori4; - TGLArrayp4 = TGLVectorp4; - - TGlMatrixub3 = array[0..2, 0..2] of GLubyte; - TGlMatrixi3 = array[0..2, 0..2] of GLint; - TGLMatrixf3 = array[0..2, 0..2] of GLfloat; - TGLMatrixd3 = array[0..2, 0..2] of GLdouble; - - TGlMatrixub4 = array[0..3, 0..3] of GLubyte; - TGlMatrixi4 = array[0..3, 0..3] of GLint; - TGLMatrixf4 = array[0..3, 0..3] of GLfloat; - TGLMatrixd4 = array[0..3, 0..3] of GLdouble; - - TGLVector3f = TGLVectorf3; - - // Datatypes corresponding to OpenGL12.pas for easy porting - TVector3d = TGLVectord3; - - TVector4i = TGLVectori4; - TVector4f = TGLVectorf4; - TVector4p = TGLVectorp4; - - TMatrix4f = TGLMatrixf4; - TMatrix4d = TGLMatrixd4; - - PGLMatrixd4 = ^TGLMatrixd4; - PVector4i = ^TVector4i; - - - -{$IFDEF FPC} - TRect = packed record - Left, Top, Right, Bottom: Longint; - end; -{$ENDIF} - - - PGPU_DEVICE = ^GPU_DEVICE; - GPU_DEVICE = record - cb: DWORD; - DeviceName: array [0..31] of AnsiChar; - DeviceString: array [0..127] of AnsiChar; - Flags: DWORD; - rcVirtualScreen: TRect; - end; - - -type -{$IFDEF FPC} - {$IFDEF DGL_WIN} - PWGLSwap = ^TWGLSwap; - {$EXTERNALSYM _WGLSWAP} - _WGLSWAP = packed record - hdc: HDC; - uiFlags: UINT; - end; - - TWGLSwap = _WGLSWAP; - {$EXTERNALSYM WGLSWAP} - WGLSWAP = _WGLSWAP; - - {$ENDIF} -{$ENDIF} - - // GLU types - TGLUNurbs = record - end; - TGLUQuadric = record - end; - TGLUTesselator = record - end; - PGLUNurbs = ^TGLUNurbs; - PGLUQuadric = ^TGLUQuadric; - PGLUTesselator = ^TGLUTesselator; - // backwards compatibility - TGLUNurbsObj = TGLUNurbs; - TGLUQuadricObj = TGLUQuadric; - TGLUTesselatorObj = TGLUTesselator; - TGLUTriangulatorObj = TGLUTesselator; - PGLUNurbsObj = PGLUNurbs; - PGLUQuadricObj = PGLUQuadric; - PGLUTesselatorObj = PGLUTesselator; - PGLUTriangulatorObj = PGLUTesselator; - - // GLUQuadricCallback - TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - // GLUTessCallback - TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - // GLUNurbsCallback - TGLUNurbsErrorProc = procedure(ErrorCode: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - -var - GL_VERSION_1_0, - GL_VERSION_1_1, - GL_VERSION_1_2, - GL_VERSION_1_3, - GL_VERSION_1_4, - GL_VERSION_1_5, - GL_VERSION_2_0, - GL_VERSION_2_1, - GL_VERSION_3_0, - GL_VERSION_3_1, - GL_VERSION_3_2, - GL_VERSION_3_3, - GL_VERSION_4_0, - GL_VERSION_4_1, - GL_VERSION_4_2, - GL_VERSION_4_3, - GL_VERSION_4_4, - GLU_VERSION_1_1, - GLU_VERSION_1_2, - GLU_VERSION_1_3, - GL_3DFX_multisample, - GL_3DFX_tbuffer, - GL_3DFX_texture_compression_FXT1, - GL_APPLE_client_storage, - GL_APPLE_element_array, - GL_APPLE_fence, - GL_APPLE_specular_vector, - GL_APPLE_transform_hint, - GL_APPLE_vertex_array_object, - GL_APPLE_vertex_array_range, - GL_APPLE_ycbcr_422, - GL_APPLE_texture_range, - GL_APPLE_float_pixels, - GL_APPLE_vertex_program_evaluators, - GL_APPLE_aux_depth_stencil, - GL_APPLE_object_purgeable, - GL_APPLE_row_bytes, - GL_APPLE_rgb_422, - GL_ARB_depth_texture, - GL_ARB_fragment_program, - GL_ARB_imaging, - GL_ARB_matrix_palette, - GL_ARB_multisample, - GL_ARB_multitexture, - GL_ARB_point_parameters, - GL_ARB_shadow, - GL_ARB_shadow_ambient, - GL_ARB_texture_border_clamp, - GL_ARB_texture_compression, - GL_ARB_texture_cube_map, - GL_ARB_texture_env_add, - GL_ARB_texture_env_combine, - GL_ARB_texture_env_crossbar, - GL_ARB_texture_env_dot3, - GL_ARB_texture_mirrored_repeat, - GL_ARB_transpose_matrix, - GL_ARB_vertex_blend, - GL_ARB_vertex_buffer_object, - GL_ARB_vertex_program, - GL_ARB_window_pos, - GL_ARB_shader_objects, - GL_ARB_vertex_shader, - GL_ARB_fragment_shader, - GL_ARB_shading_language_100, - GL_ARB_occlusion_query, - GL_ARB_texture_non_power_of_two, - GL_ARB_point_sprite, - GL_ARB_fragment_program_shadow, - GL_ARB_draw_buffers, - GL_ARB_texture_rectangle, - GL_ARB_color_buffer_float, - GL_ARB_half_float_pixel, - GL_ARB_texture_float, - GL_ARB_pixel_buffer_object, - GL_ARB_depth_buffer_float, - GL_ARB_draw_instanced, - GL_ARB_framebuffer_object, - GL_ARB_framebuffer_sRGB, - GL_ARB_geometry_shader4, - GL_ARB_half_float_vertex, - GL_ARB_instanced_arrays, - GL_ARB_map_buffer_range, - GL_ARB_texture_buffer_object, - GL_ARB_texture_compression_rgtc, - GL_ARB_texture_rg, - GL_ARB_vertex_array_object, - GL_ARB_uniform_buffer_object, - GL_ARB_compatibility, - GL_ARB_copy_buffer, - GL_ARB_shader_texture_lod, - GL_ARB_depth_clamp, - GL_ARB_draw_elements_base_vertex, - GL_ARB_fragment_coord_conventions, - GL_ARB_provoking_vertex, - GL_ARB_seamless_cube_map, - GL_ARB_sync, - GL_ARB_texture_multisample, - GL_ARB_vertex_array_bgra, - GL_ARB_draw_buffers_blend, - GL_ARB_sample_shading, - GL_ARB_texture_cube_map_array, - GL_ARB_texture_gather, - GL_ARB_texture_query_lod, - GL_ARB_shading_language_include, - GL_ARB_texture_compression_bptc, - GL_ARB_blend_func_extended, - GL_ARB_explicit_attrib_location, - GL_ARB_occlusion_query2, - GL_ARB_sampler_objects, - GL_ARB_shader_bit_encoding, - GL_ARB_texture_rgb10_a2ui, - GL_ARB_texture_swizzle, - GL_ARB_timer_query, - GL_ARB_vertex_type_2_10_10_10_rev, - GL_ARB_draw_indirect, - GL_ARB_gpu_shader5, - GL_ARB_gpu_shader_fp64, - GL_ARB_shader_subroutine, - GL_ARB_tessellation_shader, - GL_ARB_texture_buffer_object_rgb32, - GL_ARB_transform_feedback2, - GL_ARB_transform_feedback3, - GL_ARB_ES2_compatibility, - GL_ARB_get_program_binary, - GL_ARB_separate_shader_objects, - GL_ARB_shader_precision, - GL_ARB_vertex_attrib_64bit, - GL_ARB_viewport_array, - - // GL 4.2 - GL_ARB_base_instance, - GL_ARB_shading_language_420pack, - GL_ARB_transform_feedback_instanced, - GL_ARB_compressed_texture_pixel_storage, - GL_ARB_conservative_depth, - GL_ARB_internalformat_query, - GL_ARB_map_buffer_alignment, - GL_ARB_shader_atomic_counters, - GL_ARB_shader_image_load_store, - GL_ARB_shading_language_packing, - GL_ARB_texture_storage, - // END GL 4.2 - - // GL 4.3 - GL_ARB_arrays_of_arrays, - GL_ARB_fragment_layer_viewport, - GL_ARB_shader_image_size, - GL_ARB_ES3_compatibility, - GL_ARB_clear_buffer_object, - GL_ARB_compute_shader, - GL_ARB_copy_image, - GL_KHR_debug, - GL_ARB_explicit_uniform_location, - GL_ARB_framebuffer_no_attachments, - GL_ARB_internalformat_query2, - GL_ARB_invalidate_subdata, - GL_ARB_multi_draw_indirect, - GL_ARB_program_interface_query, - GL_ARB_robust_buffer_access_behavior, - GL_ARB_shader_storage_buffer_object, - GL_ARB_stencil_texturing, - GL_ARB_texture_buffer_range, - GL_ARB_texture_query_levels, - GL_ARB_texture_storage_multisample, - GL_ARB_texture_view, - GL_ARB_vertex_attrib_binding, - GL_NV_path_rendering, - GL_AMD_pinned_memory, - GL_AMD_stencil_operation_extended, - GL_AMD_vertex_shader_viewport_index, - GL_AMD_vertex_shader_layer, - GL_NV_bindless_texture, - GL_NV_shader_atomic_float, - GL_AMD_query_buffer_object, - // END GL 4.3 - - // GL 4.4 - GL_ARB_buffer_storage, - GL_ARB_clear_texture, - GL_ARB_enhanced_layouts, - GL_ARB_multi_bind, - GL_ARB_query_buffer_object, - GL_ARB_texture_mirror_clamp_to_edge, - GL_ARB_texture_stencil8, - GL_ARB_vertex_type_10f_11f_11f_rev, - // END 4.4 - - GL_ARB_cl_event, - GL_ARB_debug_output, - GL_ARB_robustness, - GL_ARB_shader_stencil_export, - GL_ATI_draw_buffers, - GL_ATI_element_array, - GL_ATI_envmap_bumpmap, - GL_ATI_fragment_shader, - GL_ATI_map_object_buffer, - GL_ATI_pn_triangles, - GL_ATI_separate_stencil, - GL_ATI_text_fragment_shader, - GL_ATI_texture_env_combine3, - GL_ATI_texture_float, - GL_ATI_texture_mirror_once, - GL_ATI_vertex_array_object, - GL_ATI_vertex_attrib_array_object, - GL_ATI_vertex_streams, - GL_ATI_meminfo, - GL_AMD_performance_monitor, - GL_AMD_texture_texture4, - GL_AMD_vertex_shader_tesselator, - GL_AMD_draw_buffers_blend, - GL_AMD_shader_stencil_export, - GL_AMD_seamless_cubemap_per_texture, - GL_AMD_conservative_depth, - GL_AMD_name_gen_delete, - GL_AMD_debug_output, - GL_AMD_transform_feedback3_lines_triangles, - GL_AMD_depth_clamp_separate, - GL_EXT_422_pixels, - GL_EXT_abgr, - GL_EXT_bgra, - GL_EXT_blend_color, - GL_EXT_blend_func_separate, - GL_EXT_blend_logic_op, - GL_EXT_blend_minmax, - GL_EXT_blend_subtract, - GL_EXT_clip_volume_hint, - GL_EXT_cmyka, - GL_EXT_color_matrix, - GL_EXT_color_subtable, - GL_EXT_compiled_vertex_array, - GL_EXT_convolution, - GL_EXT_coordinate_frame, - GL_EXT_copy_texture, - GL_EXT_cull_vertex, - GL_EXT_draw_range_elements, - GL_EXT_fog_coord, - GL_EXT_framebuffer_object, - GL_EXT_histogram, - GL_EXT_index_array_formats, - GL_EXT_index_func, - GL_EXT_index_material, - GL_EXT_index_texture, - GL_EXT_light_texture, - GL_EXT_misc_attribute, - GL_EXT_multi_draw_arrays, - GL_EXT_multisample, - GL_EXT_packed_pixels, - GL_EXT_paletted_texture, - GL_EXT_pixel_transform, - GL_EXT_pixel_transform_color_table, - GL_EXT_point_parameters, - GL_EXT_polygon_offset, - GL_EXT_rescale_normal, - GL_EXT_secondary_color, - GL_EXT_separate_specular_color, - GL_EXT_shadow_funcs, - GL_EXT_shared_texture_palette, - GL_EXT_stencil_two_side, - GL_EXT_stencil_wrap, - GL_EXT_subtexture, - GL_EXT_texture, - GL_EXT_texture3D, - GL_EXT_texture_compression_s3tc, - GL_EXT_texture_cube_map, - GL_EXT_texture_edge_clamp, - GL_EXT_texture_env_add, - GL_EXT_texture_env_combine, - GL_EXT_texture_env_dot3, - GL_EXT_texture_filter_anisotropic, - GL_EXT_texture_lod_bias, - GL_EXT_texture_object, - GL_EXT_texture_perturb_normal, - GL_EXT_texture_rectangle, - GL_EXT_vertex_array, - GL_EXT_vertex_shader, - GL_EXT_vertex_weighting, - GL_EXT_depth_bounds_test, - GL_EXT_texture_mirror_clamp, - GL_EXT_blend_equation_separate, - GL_EXT_pixel_buffer_object, - GL_EXT_texture_compression_dxt1, - GL_EXT_stencil_clear_tag, - GL_EXT_packed_depth_stencil, - GL_EXT_texture_sRGB, - GL_EXT_framebuffer_blit, - GL_EXT_framebuffer_multisample, - GL_EXT_timer_query, - GL_EXT_gpu_program_parameters, - GL_EXT_bindable_uniform, - GL_EXT_draw_buffers2, - GL_EXT_draw_instanced, - GL_EXT_framebuffer_sRGB, - GL_EXT_geometry_shader4, - GL_EXT_gpu_shader4, - GL_EXT_packed_float, - GL_EXT_texture_array, - GL_EXT_texture_buffer_object, - GL_EXT_texture_compression_latc, - GL_EXT_texture_compression_rgtc, - GL_EXT_texture_integer, - GL_EXT_texture_shared_exponent, - GL_EXT_transform_feedback, - GL_EXT_direct_state_access, - GL_EXT_vertex_array_bgra, - GL_EXT_texture_swizzle, - GL_EXT_provoking_vertex, - GL_EXT_texture_snorm, - GL_EXT_separate_shader_objects, - GL_EXT_shader_image_load_store, - GL_EXT_vertex_attrib_64bit, - GL_EXT_texture_sRGB_decode, - GL_FfdMaskSGIX, - GL_HP_convolution_border_modes, - GL_HP_image_transform, - GL_HP_occlusion_test, - GL_HP_texture_lighting, - GL_IBM_cull_vertex, - GL_IBM_multimode_draw_arrays, - GL_IBM_rasterpos_clip, - GL_IBM_texture_mirrored_repeat, - GL_IBM_vertex_array_lists, - GL_INGR_blend_func_separate, - GL_INGR_color_clamp, - GL_INGR_interlace_read, - GL_INGR_palette_buffer, - GL_INTEL_parallel_arrays, - GL_INTEL_texture_scissor, - GL_MESA_resize_buffers, - GL_MESA_window_pos, - GL_NV_blend_square, - GL_NV_copy_depth_to_color, - GL_NV_depth_clamp, - GL_NV_evaluators, - GL_NV_fence, - GL_NV_float_buffer, - GL_NV_fog_distance, - GL_NV_fragment_program, - GL_NV_half_float, - GL_NV_light_max_exponent, - GL_NV_multisample_filter_hint, - GL_NV_occlusion_query, - GL_NV_packed_depth_stencil, - GL_NV_pixel_data_range, - GL_NV_point_sprite, - GL_NV_primitive_restart, - GL_NV_register_combiners, - GL_NV_register_combiners2, - GL_NV_texgen_emboss, - GL_NV_texgen_reflection, - GL_NV_texture_compression_vtc, - GL_NV_texture_env_combine4, - GL_NV_texture_expand_normal, - GL_NV_texture_rectangle, - GL_NV_texture_shader, - GL_NV_texture_shader2, - GL_NV_texture_shader3, - GL_NV_vertex_array_range, - GL_NV_vertex_array_range2, - GL_NV_vertex_program, - GL_NV_vertex_program1_1, - GL_NV_vertex_program2, - GL_NV_fragment_program_option, - GL_NV_fragment_program2, - GL_NV_vertex_program2_option, - GL_NV_vertex_program3, - GL_NV_depth_buffer_float, - GL_NV_fragment_program4, - GL_NV_framebuffer_multisample_coverage, - GL_NV_geometry_program4, - GL_NV_gpu_program4, - GL_NV_parameter_buffer_object, - GL_NV_transform_feedback, - GL_NV_vertex_program4, - GL_NV_conditional_render, - GL_NV_present_video, - GL_NV_explicit_multisample, - GL_NV_transform_feedback2, - GL_NV_video_capture, - GL_NV_copy_image, - GL_NV_parameter_buffer_object2, - GL_NV_shader_buffer_load, - GL_NV_vertex_buffer_unified_memory, - GL_NV_gpu_program5, - GL_NV_gpu_shader5, - GL_NV_shader_buffer_store, - GL_NV_tessellation_program5, - GL_NV_vertex_attrib_integer_64bit, - GL_NV_multisample_coverage, - GL_NV_vdpau_interop, - GL_NV_texture_barrier, - GL_OML_interlace, - GL_OML_resample, - GL_OML_subsample, - GL_PGI_misc_hints, - GL_PGI_vertex_hints, - GL_REND_screen_coordinates, - GL_S3_s3tc, - GL_SGIS_detail_texture, - GL_SGIS_fog_function, - GL_SGIS_generate_mipmap, - GL_SGIS_multisample, - GL_SGIS_pixel_texture, - GL_SGIS_point_line_texgen, - GL_SGIS_point_parameters, - GL_SGIS_sharpen_texture, - GL_SGIS_texture4D, - GL_SGIS_texture_border_clamp, - GL_SGIS_texture_color_mask, - GL_SGIS_texture_edge_clamp, - GL_SGIS_texture_filter4, - GL_SGIS_texture_lod, - GL_SGIS_texture_select, - GL_SGIX_async, - GL_SGIX_async_histogram, - GL_SGIX_async_pixel, - GL_SGIX_blend_alpha_minmax, - GL_SGIX_calligraphic_fragment, - GL_SGIX_clipmap, - GL_SGIX_convolution_accuracy, - GL_SGIX_depth_pass_instrument, - GL_SGIX_depth_texture, - GL_SGIX_flush_raster, - GL_SGIX_fog_offset, - GL_SGIX_fog_scale, - GL_SGIX_fragment_lighting, - GL_SGIX_framezoom, - GL_SGIX_igloo_interface, - GL_SGIX_impact_pixel_texture, - GL_SGIX_instruments, - GL_SGIX_interlace, - GL_SGIX_ir_instrument1, - GL_SGIX_list_priority, - GL_SGIX_pixel_texture, - GL_SGIX_pixel_tiles, - GL_SGIX_polynomial_ffd, - GL_SGIX_reference_plane, - GL_SGIX_resample, - GL_SGIX_scalebias_hint, - GL_SGIX_shadow, - GL_SGIX_shadow_ambient, - GL_SGIX_sprite, - GL_SGIX_subsample, - GL_SGIX_tag_sample_buffer, - GL_SGIX_texture_add_env, - GL_SGIX_texture_coordinate_clamp, - GL_SGIX_texture_lod_bias, - GL_SGIX_texture_multi_buffer, - GL_SGIX_texture_scale_bias, - GL_SGIX_texture_select, - GL_SGIX_vertex_preclip, - GL_SGIX_ycrcb, - GL_SGIX_ycrcb_subsample, - GL_SGIX_ycrcba, - GL_SGI_color_matrix, - GL_SGI_color_table, - GL_SGI_depth_pass_instrument, - GL_SGI_texture_color_table, - GL_SUNX_constant_data, - GL_SUN_convolution_border_modes, - GL_SUN_global_alpha, - GL_SUN_mesh_array, - GL_SUN_slice_accum, - GL_SUN_triangle_list, - GL_SUN_vertex, - - GL_WIN_phong_shading, - GL_WIN_specular_fog, - WGL_3DFX_multisample, - WGL_ARB_buffer_region, - WGL_ARB_extensions_string, - WGL_ARB_make_current_read, - WGL_ARB_multisample, - WGL_ARB_pbuffer, - WGL_ARB_pixel_format, - WGL_ARB_pixel_format_float, - WGL_ARB_render_texture, - WGL_ARB_create_context, - WGL_ARB_create_context_profile, - WGL_ARB_framebuffer_sRGB, - WGL_ARB_create_context_robustness, - WGL_ATI_pixel_format_float, - WGL_AMD_gpu_association, - WGL_EXT_depth_float, - WGL_EXT_display_color_table, - WGL_EXT_extensions_string, - WGL_EXT_make_current_read, - WGL_EXT_multisample, - WGL_EXT_pbuffer, - WGL_EXT_pixel_format, - WGL_EXT_swap_control, - WGL_EXT_create_context_es2_profile, - WGL_I3D_digital_video_control, - WGL_I3D_gamma, - WGL_I3D_genlock, - WGL_I3D_image_buffer, - WGL_I3D_swap_frame_lock, - WGL_I3D_swap_frame_usage, - WGL_NV_float_buffer, - WGL_NV_render_depth_texture, - WGL_NV_render_texture_rectangle, - WGL_NV_vertex_array_range, - WGL_NV_present_video, - WGL_NV_video_output, - WGL_NV_swap_group, - WGL_NV_gpu_affinity, - WGL_NV_video_capture, - WGL_NV_copy_image, - WGL_NV_multisample_coverage, - WGL_NV_DX_interop, - WGL_OML_sync_control, - WGL_3DL_stereo_control, - WIN_draw_range_elements, - WIN_swap_hint, - -// GLX_VERSION_1_0, - GLX_VERSION_1_3, - GLX_VERSION_1_4, - GLX_ARB_multisample, - GLX_ARB_fbconfig_float, - GLX_ARB_get_proc_address, - GLX_ARB_create_context, - GLX_ARB_create_context_profile, - GLX_ARB_vertex_buffer_object, - GLX_ARB_framebuffer_sRGB, - GLX_ARB_create_context_robustness, - GLX_EXT_visual_info, - GLX_EXT_visual_rating, - GLX_EXT_import_context, - GLX_EXT_fbconfig_packed_float, - GLX_EXT_framebuffer_sRGB, - GLX_EXT_texture_from_pixmap, - GLX_EXT_swap_control, - GLX_EXT_create_context_es2_profile : Boolean; - -const - // GL_VERSION_1_1 - { AttribMask } - GL_DEPTH_BUFFER_BIT = $00000100; - GL_STENCIL_BUFFER_BIT = $00000400; - GL_COLOR_BUFFER_BIT = $00004000; - { Boolean } - GL_TRUE = 1; - GL_FALSE = 0; - { BeginMode } - GL_POINTS = $0000; - GL_LINES = $0001; - GL_LINE_LOOP = $0002; - GL_LINE_STRIP = $0003; - GL_TRIANGLES = $0004; - GL_TRIANGLE_STRIP = $0005; - GL_TRIANGLE_FAN = $0006; - { AlphaFunction } - GL_NEVER = $0200; - GL_LESS = $0201; - GL_EQUAL = $0202; - GL_LEQUAL = $0203; - GL_GREATER = $0204; - GL_NOTEQUAL = $0205; - GL_GEQUAL = $0206; - GL_ALWAYS = $0207; - { BlendingFactorDest } - GL_ZERO = 0; - GL_ONE = 1; - GL_SRC_COLOR = $0300; - GL_ONE_MINUS_SRC_COLOR = $0301; - GL_SRC_ALPHA = $0302; - GL_ONE_MINUS_SRC_ALPHA = $0303; - GL_DST_ALPHA = $0304; - GL_ONE_MINUS_DST_ALPHA = $0305; - { BlendingFactorSrc } - GL_DST_COLOR = $0306; - GL_ONE_MINUS_DST_COLOR = $0307; - GL_SRC_ALPHA_SATURATE = $0308; - { DrawBufferMode } - GL_NONE = 0; - GL_FRONT_LEFT = $0400; - GL_FRONT_RIGHT = $0401; - GL_BACK_LEFT = $0402; - GL_BACK_RIGHT = $0403; - GL_FRONT = $0404; - GL_BACK = $0405; - GL_LEFT = $0406; - GL_RIGHT = $0407; - GL_FRONT_AND_BACK = $0408; - { ErrorCode } - GL_NO_ERROR = 0; - GL_INVALID_ENUM = $0500; - GL_INVALID_VALUE = $0501; - GL_INVALID_OPERATION = $0502; - GL_OUT_OF_MEMORY = $0505; - { FrontFaceDirection } - GL_CW = $0900; - GL_CCW = $0901; - { GetPName } - GL_POINT_SIZE = $0B11; - GL_POINT_SIZE_RANGE = $0B12; - GL_POINT_SIZE_GRANULARITY = $0B13; - GL_LINE_SMOOTH = $0B20; - GL_LINE_WIDTH = $0B21; - GL_LINE_WIDTH_RANGE = $0B22; - GL_LINE_WIDTH_GRANULARITY = $0B23; - GL_POLYGON_SMOOTH = $0B41; - GL_CULL_FACE = $0B44; - GL_CULL_FACE_MODE = $0B45; - GL_FRONT_FACE = $0B46; - GL_DEPTH_RANGE = $0B70; - GL_DEPTH_TEST = $0B71; - GL_DEPTH_WRITEMASK = $0B72; - GL_DEPTH_CLEAR_VALUE = $0B73; - GL_DEPTH_FUNC = $0B74; - GL_STENCIL_TEST = $0B90; - GL_STENCIL_CLEAR_VALUE = $0B91; - GL_STENCIL_FUNC = $0B92; - GL_STENCIL_VALUE_MASK = $0B93; - GL_STENCIL_FAIL = $0B94; - GL_STENCIL_PASS_DEPTH_FAIL = $0B95; - GL_STENCIL_PASS_DEPTH_PASS = $0B96; - GL_STENCIL_REF = $0B97; - GL_STENCIL_WRITEMASK = $0B98; - GL_VIEWPORT = $0BA2; - GL_DITHER = $0BD0; - GL_BLEND_DST = $0BE0; - GL_BLEND_SRC = $0BE1; - GL_BLEND = $0BE2; - GL_LOGIC_OP_MODE = $0BF0; - GL_COLOR_LOGIC_OP = $0BF2; - GL_DRAW_BUFFER = $0C01; - GL_READ_BUFFER = $0C02; - GL_SCISSOR_BOX = $0C10; - GL_SCISSOR_TEST = $0C11; - GL_COLOR_CLEAR_VALUE = $0C22; - GL_COLOR_WRITEMASK = $0C23; - GL_DOUBLEBUFFER = $0C32; - GL_STEREO = $0C33; - GL_LINE_SMOOTH_HINT = $0C52; - GL_POLYGON_SMOOTH_HINT = $0C53; - GL_UNPACK_SWAP_BYTES = $0CF0; - GL_UNPACK_LSB_FIRST = $0CF1; - GL_UNPACK_ROW_LENGTH = $0CF2; - GL_UNPACK_SKIP_ROWS = $0CF3; - GL_UNPACK_SKIP_PIXELS = $0CF4; - GL_UNPACK_ALIGNMENT = $0CF5; - GL_PACK_SWAP_BYTES = $0D00; - GL_PACK_LSB_FIRST = $0D01; - GL_PACK_ROW_LENGTH = $0D02; - GL_PACK_SKIP_ROWS = $0D03; - GL_PACK_SKIP_PIXELS = $0D04; - GL_PACK_ALIGNMENT = $0D05; - GL_MAX_TEXTURE_SIZE = $0D33; - GL_MAX_VIEWPORT_DIMS = $0D3A; - GL_SUBPIXEL_BITS = $0D50; - GL_TEXTURE_1D = $0DE0; - GL_TEXTURE_2D = $0DE1; - GL_POLYGON_OFFSET_UNITS = $2A00; - GL_POLYGON_OFFSET_POINT = $2A01; - GL_POLYGON_OFFSET_LINE = $2A02; - GL_POLYGON_OFFSET_FILL = $8037; - GL_POLYGON_OFFSET_FACTOR = $8038; - GL_TEXTURE_BINDING_1D = $8068; - GL_TEXTURE_BINDING_2D = $8069; - { GetTextureParameter } - GL_TEXTURE_WIDTH = $1000; - GL_TEXTURE_HEIGHT = $1001; - GL_TEXTURE_INTERNAL_FORMAT = $1003; - GL_TEXTURE_BORDER_COLOR = $1004; - GL_TEXTURE_BORDER = $1005; - GL_TEXTURE_RED_SIZE = $805C; - GL_TEXTURE_GREEN_SIZE = $805D; - GL_TEXTURE_BLUE_SIZE = $805E; - GL_TEXTURE_ALPHA_SIZE = $805F; - { HintMode } - GL_DONT_CARE = $1100; - GL_FASTEST = $1101; - GL_NICEST = $1102; - { DataType } - GL_BYTE = $1400; - GL_UNSIGNED_BYTE = $1401; - GL_SHORT = $1402; - GL_UNSIGNED_SHORT = $1403; - GL_INT = $1404; - GL_UNSIGNED_INT = $1405; - GL_FLOAT = $1406; - GL_DOUBLE = $140A; - { LogicOp } - GL_CLEAR = $1500; - GL_AND = $1501; - GL_AND_REVERSE = $1502; - GL_COPY = $1503; - GL_AND_INVERTED = $1504; - GL_NOOP = $1505; - GL_XOR = $1506; - GL_OR = $1507; - GL_NOR = $1508; - GL_EQUIV = $1509; - GL_INVERT = $150A; - GL_OR_REVERSE = $150B; - GL_COPY_INVERTED = $150C; - GL_OR_INVERTED = $150D; - GL_NAND = $150E; - GL_SET = $150F; - { MatrixMode (for gl3.h, FBO attachment type) } - GL_TEXTURE = $1702; - { PixelCopyType } - GL_COLOR = $1800; - GL_DEPTH = $1801; - GL_STENCIL = $1802; - { PixelFormat } - GL_STENCIL_INDEX = $1901; - GL_DEPTH_COMPONENT = $1902; - GL_RED = $1903; - GL_GREEN = $1904; - GL_BLUE = $1905; - GL_ALPHA = $1906; - GL_RGB = $1907; - GL_RGBA = $1908; - { PolygonMode } - GL_POINT = $1B00; - GL_LINE = $1B01; - GL_FILL = $1B02; - { StencilOp } - GL_KEEP = $1E00; - GL_REPLACE = $1E01; - GL_INCR = $1E02; - GL_DECR = $1E03; - { StringName } - GL_VENDOR = $1F00; - GL_RENDERER = $1F01; - GL_VERSION = $1F02; - GL_EXTENSIONS = $1F03; - { TextureMagFilter } - GL_NEAREST = $2600; - GL_LINEAR = $2601; - { TextureMinFilter } - GL_NEAREST_MIPMAP_NEAREST = $2700; - GL_LINEAR_MIPMAP_NEAREST = $2701; - GL_NEAREST_MIPMAP_LINEAR = $2702; - GL_LINEAR_MIPMAP_LINEAR = $2703; - { TextureParameterName } - GL_TEXTURE_MAG_FILTER = $2800; - GL_TEXTURE_MIN_FILTER = $2801; - GL_TEXTURE_WRAP_S = $2802; - GL_TEXTURE_WRAP_T = $2803; - { TextureTarget } - GL_PROXY_TEXTURE_1D = $8063; - GL_PROXY_TEXTURE_2D = $8064; - { TextureWrapMode } - GL_REPEAT = $2901; - { PixelInternalFormat } - GL_R3_G3_B2 = $2A10; - GL_RGB4 = $804F; - GL_RGB5 = $8050; - GL_RGB8 = $8051; - GL_RGB10 = $8052; - GL_RGB12 = $8053; - GL_RGB16 = $8054; - GL_RGBA2 = $8055; - GL_RGBA4 = $8056; - GL_RGB5_A1 = $8057; - GL_RGBA8 = $8058; - GL_RGB10_A2 = $8059; - GL_RGBA12 = $805A; - GL_RGBA16 = $805B; -{$ifdef DGL_DEPRECATED} - GL_ACCUM = $0100; - GL_LOAD = $0101; - GL_RETURN = $0102; - GL_MULT = $0103; - GL_ADD = $0104; - GL_CURRENT_BIT = $00000001; - GL_POINT_BIT = $00000002; - GL_LINE_BIT = $00000004; - GL_POLYGON_BIT = $00000008; - GL_POLYGON_STIPPLE_BIT = $00000010; - GL_PIXEL_MODE_BIT = $00000020; - GL_LIGHTING_BIT = $00000040; - GL_FOG_BIT = $00000080; - GL_ACCUM_BUFFER_BIT = $00000200; - GL_VIEWPORT_BIT = $00000800; - GL_TRANSFORM_BIT = $00001000; - GL_ENABLE_BIT = $00002000; - GL_HINT_BIT = $00008000; - GL_EVAL_BIT = $00010000; - GL_LIST_BIT = $00020000; - GL_TEXTURE_BIT = $00040000; - GL_SCISSOR_BIT = $00080000; - GL_ALL_ATTRIB_BITS = $000FFFFF; - GL_QUADS = $0007; - GL_QUAD_STRIP = $0008; - GL_POLYGON = $0009; - GL_CLIP_PLANE0 = $3000; - GL_CLIP_PLANE1 = $3001; - GL_CLIP_PLANE2 = $3002; - GL_CLIP_PLANE3 = $3003; - GL_CLIP_PLANE4 = $3004; - GL_CLIP_PLANE5 = $3005; - GL_2_BYTES = $1407; - GL_3_BYTES = $1408; - GL_4_BYTES = $1409; - GL_AUX0 = $0409; - GL_AUX1 = $040A; - GL_AUX2 = $040B; - GL_AUX3 = $040C; - GL_STACK_OVERFLOW = $0503; - GL_STACK_UNDERFLOW = $0504; - GL_2D = $0600; - GL_3D = $0601; - GL_3D_COLOR = $0602; - GL_3D_COLOR_TEXTURE = $0603; - GL_4D_COLOR_TEXTURE = $0604; - GL_PASS_THROUGH_TOKEN = $0700; - GL_POINT_TOKEN = $0701; - GL_LINE_TOKEN = $0702; - GL_POLYGON_TOKEN = $0703; - GL_BITMAP_TOKEN = $0704; - GL_DRAW_PIXEL_TOKEN = $0705; - GL_COPY_PIXEL_TOKEN = $0706; - GL_LINE_RESET_TOKEN = $0707; - GL_EXP = $0800; - GL_EXP2 = $0801; - GL_COEFF = $0A00; - GL_ORDER = $0A01; - GL_DOMAIN = $0A02; - GL_CURRENT_COLOR = $0B00; - GL_CURRENT_INDEX = $0B01; - GL_CURRENT_NORMAL = $0B02; - GL_CURRENT_TEXTURE_COORDS = $0B03; - GL_CURRENT_RASTER_COLOR = $0B04; - GL_CURRENT_RASTER_INDEX = $0B05; - GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06; - GL_CURRENT_RASTER_POSITION = $0B07; - GL_CURRENT_RASTER_POSITION_VALID = $0B08; - GL_CURRENT_RASTER_DISTANCE = $0B09; - GL_POINT_SMOOTH = $0B10; - GL_LINE_STIPPLE = $0B24; - GL_LINE_STIPPLE_PATTERN = $0B25; - GL_LINE_STIPPLE_REPEAT = $0B26; - GL_LIST_MODE = $0B30; - GL_MAX_LIST_NESTING = $0B31; - GL_LIST_BASE = $0B32; - GL_LIST_INDEX = $0B33; - GL_POLYGON_MODE = $0B40; - GL_POLYGON_STIPPLE = $0B42; - GL_EDGE_FLAG = $0B43; - GL_LIGHTING = $0B50; - GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51; - GL_LIGHT_MODEL_TWO_SIDE = $0B52; - GL_LIGHT_MODEL_AMBIENT = $0B53; - GL_SHADE_MODEL = $0B54; - GL_COLOR_MATERIAL_FACE = $0B55; - GL_COLOR_MATERIAL_PARAMETER = $0B56; - GL_COLOR_MATERIAL = $0B57; - GL_FOG = $0B60; - GL_FOG_INDEX = $0B61; - GL_FOG_DENSITY = $0B62; - GL_FOG_START = $0B63; - GL_FOG_END = $0B64; - GL_FOG_MODE = $0B65; - GL_FOG_COLOR = $0B66; - GL_ACCUM_CLEAR_VALUE = $0B80; - GL_MATRIX_MODE = $0BA0; - GL_NORMALIZE = $0BA1; - GL_MODELVIEW_STACK_DEPTH = $0BA3; - GL_PROJECTION_STACK_DEPTH = $0BA4; - GL_TEXTURE_STACK_DEPTH = $0BA5; - GL_MODELVIEW_MATRIX = $0BA6; - GL_PROJECTION_MATRIX = $0BA7; - GL_TEXTURE_MATRIX = $0BA8; - GL_ATTRIB_STACK_DEPTH = $0BB0; - GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1; - GL_ALPHA_TEST = $0BC0; - GL_ALPHA_TEST_FUNC = $0BC1; - GL_ALPHA_TEST_REF = $0BC2; - GL_INDEX_LOGIC_OP = $0BF1; - GL_AUX_BUFFERS = $0C00; - GL_INDEX_CLEAR_VALUE = $0C20; - GL_INDEX_WRITEMASK = $0C21; - GL_INDEX_MODE = $0C30; - GL_RGBA_MODE = $0C31; - GL_RENDER_MODE = $0C40; - GL_PERSPECTIVE_CORRECTION_HINT = $0C50; - GL_POINT_SMOOTH_HINT = $0C51; - GL_FOG_HINT = $0C54; - GL_TEXTURE_GEN_S = $0C60; - GL_TEXTURE_GEN_T = $0C61; - GL_TEXTURE_GEN_R = $0C62; - GL_TEXTURE_GEN_Q = $0C63; - GL_PIXEL_MAP_I_TO_I = $0C70; - GL_PIXEL_MAP_S_TO_S = $0C71; - GL_PIXEL_MAP_I_TO_R = $0C72; - GL_PIXEL_MAP_I_TO_G = $0C73; - GL_PIXEL_MAP_I_TO_B = $0C74; - GL_PIXEL_MAP_I_TO_A = $0C75; - GL_PIXEL_MAP_R_TO_R = $0C76; - GL_PIXEL_MAP_G_TO_G = $0C77; - GL_PIXEL_MAP_B_TO_B = $0C78; - GL_PIXEL_MAP_A_TO_A = $0C79; - GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0; - GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1; - GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2; - GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3; - GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4; - GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5; - GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6; - GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7; - GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8; - GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9; - GL_MAP_COLOR = $0D10; - GL_MAP_STENCIL = $0D11; - GL_INDEX_SHIFT = $0D12; - GL_INDEX_OFFSET = $0D13; - GL_RED_SCALE = $0D14; - GL_RED_BIAS = $0D15; - GL_ZOOM_X = $0D16; - GL_ZOOM_Y = $0D17; - GL_GREEN_SCALE = $0D18; - GL_GREEN_BIAS = $0D19; - GL_BLUE_SCALE = $0D1A; - GL_BLUE_BIAS = $0D1B; - GL_ALPHA_SCALE = $0D1C; - GL_ALPHA_BIAS = $0D1D; - GL_DEPTH_SCALE = $0D1E; - GL_DEPTH_BIAS = $0D1F; - GL_MAX_EVAL_ORDER = $0D30; - GL_MAX_LIGHTS = $0D31; - GL_MAX_CLIP_PLANES = $0D32; - GL_MAX_PIXEL_MAP_TABLE = $0D34; - GL_MAX_ATTRIB_STACK_DEPTH = $0D35; - GL_MAX_MODELVIEW_STACK_DEPTH = $0D36; - GL_MAX_NAME_STACK_DEPTH = $0D37; - GL_MAX_PROJECTION_STACK_DEPTH = $0D38; - GL_MAX_TEXTURE_STACK_DEPTH = $0D39; - GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B; - GL_INDEX_BITS = $0D51; - GL_RED_BITS = $0D52; - GL_GREEN_BITS = $0D53; - GL_BLUE_BITS = $0D54; - GL_ALPHA_BITS = $0D55; - GL_DEPTH_BITS = $0D56; - GL_STENCIL_BITS = $0D57; - GL_ACCUM_RED_BITS = $0D58; - GL_ACCUM_GREEN_BITS = $0D59; - GL_ACCUM_BLUE_BITS = $0D5A; - GL_ACCUM_ALPHA_BITS = $0D5B; - GL_NAME_STACK_DEPTH = $0D70; - GL_AUTO_NORMAL = $0D80; - GL_MAP1_COLOR_4 = $0D90; - GL_MAP1_INDEX = $0D91; - GL_MAP1_NORMAL = $0D92; - GL_MAP1_TEXTURE_COORD_1 = $0D93; - GL_MAP1_TEXTURE_COORD_2 = $0D94; - GL_MAP1_TEXTURE_COORD_3 = $0D95; - GL_MAP1_TEXTURE_COORD_4 = $0D96; - GL_MAP1_VERTEX_3 = $0D97; - GL_MAP1_VERTEX_4 = $0D98; - GL_MAP2_COLOR_4 = $0DB0; - GL_MAP2_INDEX = $0DB1; - GL_MAP2_NORMAL = $0DB2; - GL_MAP2_TEXTURE_COORD_1 = $0DB3; - GL_MAP2_TEXTURE_COORD_2 = $0DB4; - GL_MAP2_TEXTURE_COORD_3 = $0DB5; - GL_MAP2_TEXTURE_COORD_4 = $0DB6; - GL_MAP2_VERTEX_3 = $0DB7; - GL_MAP2_VERTEX_4 = $0DB8; - GL_MAP1_GRID_DOMAIN = $0DD0; - GL_MAP1_GRID_SEGMENTS = $0DD1; - GL_MAP2_GRID_DOMAIN = $0DD2; - GL_MAP2_GRID_SEGMENTS = $0DD3; - GL_FEEDBACK_BUFFER_POINTER = $0DF0; - GL_FEEDBACK_BUFFER_SIZE = $0DF1; - GL_FEEDBACK_BUFFER_TYPE = $0DF2; - GL_SELECTION_BUFFER_POINTER = $0DF3; - GL_SELECTION_BUFFER_SIZE = $0DF4; - GL_LIGHT0 = $4000; - GL_LIGHT1 = $4001; - GL_LIGHT2 = $4002; - GL_LIGHT3 = $4003; - GL_LIGHT4 = $4004; - GL_LIGHT5 = $4005; - GL_LIGHT6 = $4006; - GL_LIGHT7 = $4007; - GL_AMBIENT = $1200; - GL_DIFFUSE = $1201; - GL_SPECULAR = $1202; - GL_POSITION = $1203; - GL_SPOT_DIRECTION = $1204; - GL_SPOT_EXPONENT = $1205; - GL_SPOT_CUTOFF = $1206; - GL_CONSTANT_ATTENUATION = $1207; - GL_LINEAR_ATTENUATION = $1208; - GL_QUADRATIC_ATTENUATION = $1209; - GL_COMPILE = $1300; - GL_COMPILE_AND_EXECUTE = $1301; - GL_EMISSION = $1600; - GL_SHININESS = $1601; - GL_AMBIENT_AND_DIFFUSE = $1602; - GL_COLOR_INDEXES = $1603; - GL_MODELVIEW = $1700; - GL_PROJECTION = $1701; - GL_COLOR_INDEX = $1900; - GL_LUMINANCE = $1909; - GL_LUMINANCE_ALPHA = $190A; - GL_BITMAP = $1A00; - GL_RENDER = $1C00; - GL_FEEDBACK = $1C01; - GL_SELECT = $1C02; - GL_FLAT = $1D00; - GL_SMOOTH = $1D01; - GL_S = $2000; - GL_T = $2001; - GL_R = $2002; - GL_Q = $2003; - GL_MODULATE = $2100; - GL_DECAL = $2101; - GL_TEXTURE_ENV_MODE = $2200; - GL_TEXTURE_ENV_COLOR = $2201; - GL_TEXTURE_ENV = $2300; - GL_EYE_LINEAR = $2400; - GL_OBJECT_LINEAR = $2401; - GL_SPHERE_MAP = $2402; - GL_TEXTURE_GEN_MODE = $2500; - GL_OBJECT_PLANE = $2501; - GL_EYE_PLANE = $2502; - GL_CLAMP = $2900; - GL_CLIENT_PIXEL_STORE_BIT = $00000001; - GL_CLIENT_VERTEX_ARRAY_BIT = $00000002; - GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF; - GL_ALPHA4 = $803B; - GL_ALPHA8 = $803C; - GL_ALPHA12 = $803D; - GL_ALPHA16 = $803E; - GL_LUMINANCE4 = $803F; - GL_LUMINANCE8 = $8040; - GL_LUMINANCE12 = $8041; - GL_LUMINANCE16 = $8042; - GL_LUMINANCE4_ALPHA4 = $8043; - GL_LUMINANCE6_ALPHA2 = $8044; - GL_LUMINANCE8_ALPHA8 = $8045; - GL_LUMINANCE12_ALPHA4 = $8046; - GL_LUMINANCE12_ALPHA12 = $8047; - GL_LUMINANCE16_ALPHA16 = $8048; - GL_INTENSITY = $8049; - GL_INTENSITY4 = $804A; - GL_INTENSITY8 = $804B; - GL_INTENSITY12 = $804C; - GL_INTENSITY16 = $804D; - GL_TEXTURE_LUMINANCE_SIZE = $8060; - GL_TEXTURE_INTENSITY_SIZE = $8061; - GL_TEXTURE_PRIORITY = $8066; - GL_TEXTURE_RESIDENT = $8067; - GL_VERTEX_ARRAY = $8074; - GL_NORMAL_ARRAY = $8075; - GL_COLOR_ARRAY = $8076; - GL_INDEX_ARRAY = $8077; - GL_TEXTURE_COORD_ARRAY = $8078; - GL_EDGE_FLAG_ARRAY = $8079; - GL_VERTEX_ARRAY_SIZE = $807A; - GL_VERTEX_ARRAY_TYPE = $807B; - GL_VERTEX_ARRAY_STRIDE = $807C; - GL_NORMAL_ARRAY_TYPE = $807E; - GL_NORMAL_ARRAY_STRIDE = $807F; - GL_COLOR_ARRAY_SIZE = $8081; - GL_COLOR_ARRAY_TYPE = $8082; - GL_COLOR_ARRAY_STRIDE = $8083; - GL_INDEX_ARRAY_TYPE = $8085; - GL_INDEX_ARRAY_STRIDE = $8086; - GL_TEXTURE_COORD_ARRAY_SIZE = $8088; - GL_TEXTURE_COORD_ARRAY_TYPE = $8089; - GL_TEXTURE_COORD_ARRAY_STRIDE = $808A; - GL_EDGE_FLAG_ARRAY_STRIDE = $808C; - GL_VERTEX_ARRAY_POINTER = $808E; - GL_NORMAL_ARRAY_POINTER = $808F; - GL_COLOR_ARRAY_POINTER = $8090; - GL_INDEX_ARRAY_POINTER = $8091; - GL_TEXTURE_COORD_ARRAY_POINTER = $8092; - GL_EDGE_FLAG_ARRAY_POINTER = $8093; - GL_V2F = $2A20; - GL_V3F = $2A21; - GL_C4UB_V2F = $2A22; - GL_C4UB_V3F = $2A23; - GL_C3F_V3F = $2A24; - GL_N3F_V3F = $2A25; - GL_C4F_N3F_V3F = $2A26; - GL_T2F_V3F = $2A27; - GL_T4F_V4F = $2A28; - GL_T2F_C4UB_V3F = $2A29; - GL_T2F_C3F_V3F = $2A2A; - GL_T2F_N3F_V3F = $2A2B; - GL_T2F_C4F_N3F_V3F = $2A2C; - GL_T4F_C4F_N3F_V4F = $2A2D; - GL_COLOR_TABLE_FORMAT_EXT = $80D8; - GL_COLOR_TABLE_WIDTH_EXT = $80D9; - GL_COLOR_TABLE_RED_SIZE_EXT = $80DA; - GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB; - GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC; - GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD; - GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE; - GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF; - GL_LOGIC_OP = GL_INDEX_LOGIC_OP; - GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT; -{$endif} - - // GL_VERSION_1_2 - GL_UNSIGNED_BYTE_3_3_2 = $8032; - GL_UNSIGNED_SHORT_4_4_4_4 = $8033; - GL_UNSIGNED_SHORT_5_5_5_1 = $8034; - GL_UNSIGNED_INT_8_8_8_8 = $8035; - GL_UNSIGNED_INT_10_10_10_2 = $8036; - GL_TEXTURE_BINDING_3D = $806A; - GL_PACK_SKIP_IMAGES = $806B; - GL_PACK_IMAGE_HEIGHT = $806C; - GL_UNPACK_SKIP_IMAGES = $806D; - GL_UNPACK_IMAGE_HEIGHT = $806E; - GL_TEXTURE_3D = $806F; - GL_PROXY_TEXTURE_3D = $8070; - GL_TEXTURE_DEPTH = $8071; - GL_TEXTURE_WRAP_R = $8072; - GL_MAX_3D_TEXTURE_SIZE = $8073; - GL_UNSIGNED_BYTE_2_3_3_REV = $8362; - GL_UNSIGNED_SHORT_5_6_5 = $8363; - GL_UNSIGNED_SHORT_5_6_5_REV = $8364; - GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365; - GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366; - GL_UNSIGNED_INT_8_8_8_8_REV = $8367; - GL_UNSIGNED_INT_2_10_10_10_REV = $8368; - GL_BGR = $80E0; - GL_BGRA = $80E1; - GL_MAX_ELEMENTS_VERTICES = $80E8; - GL_MAX_ELEMENTS_INDICES = $80E9; - GL_CLAMP_TO_EDGE = $812F; - GL_TEXTURE_MIN_LOD = $813A; - GL_TEXTURE_MAX_LOD = $813B; - GL_TEXTURE_BASE_LEVEL = $813C; - GL_TEXTURE_MAX_LEVEL = $813D; - GL_SMOOTH_POINT_SIZE_RANGE = $0B12; - GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13; - GL_SMOOTH_LINE_WIDTH_RANGE = $0B22; - GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23; - GL_ALIASED_LINE_WIDTH_RANGE = $846E; -{$ifdef DGL_DEPRECATED} - GL_RESCALE_NORMAL = $803A; - GL_LIGHT_MODEL_COLOR_CONTROL = $81F8; - GL_SINGLE_COLOR = $81F9; - GL_SEPARATE_SPECULAR_COLOR = $81FA; - GL_ALIASED_POINT_SIZE_RANGE = $846D; -{$endif} - - // GL_VERSION_1_3 - GL_TEXTURE0 = $84C0; - GL_TEXTURE1 = $84C1; - GL_TEXTURE2 = $84C2; - GL_TEXTURE3 = $84C3; - GL_TEXTURE4 = $84C4; - GL_TEXTURE5 = $84C5; - GL_TEXTURE6 = $84C6; - GL_TEXTURE7 = $84C7; - GL_TEXTURE8 = $84C8; - GL_TEXTURE9 = $84C9; - GL_TEXTURE10 = $84CA; - GL_TEXTURE11 = $84CB; - GL_TEXTURE12 = $84CC; - GL_TEXTURE13 = $84CD; - GL_TEXTURE14 = $84CE; - GL_TEXTURE15 = $84CF; - GL_TEXTURE16 = $84D0; - GL_TEXTURE17 = $84D1; - GL_TEXTURE18 = $84D2; - GL_TEXTURE19 = $84D3; - GL_TEXTURE20 = $84D4; - GL_TEXTURE21 = $84D5; - GL_TEXTURE22 = $84D6; - GL_TEXTURE23 = $84D7; - GL_TEXTURE24 = $84D8; - GL_TEXTURE25 = $84D9; - GL_TEXTURE26 = $84DA; - GL_TEXTURE27 = $84DB; - GL_TEXTURE28 = $84DC; - GL_TEXTURE29 = $84DD; - GL_TEXTURE30 = $84DE; - GL_TEXTURE31 = $84DF; - GL_ACTIVE_TEXTURE = $84E0; - GL_MULTISAMPLE = $809D; - GL_SAMPLE_ALPHA_TO_COVERAGE = $809E; - GL_SAMPLE_ALPHA_TO_ONE = $809F; - GL_SAMPLE_COVERAGE = $80A0; - GL_SAMPLE_BUFFERS = $80A8; - GL_SAMPLES = $80A9; - GL_SAMPLE_COVERAGE_VALUE = $80AA; - GL_SAMPLE_COVERAGE_INVERT = $80AB; - GL_TEXTURE_CUBE_MAP = $8513; - GL_TEXTURE_BINDING_CUBE_MAP = $8514; - GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515; - GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516; - GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518; - GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A; - GL_PROXY_TEXTURE_CUBE_MAP = $851B; - GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; - GL_COMPRESSED_RGB = $84ED; - GL_COMPRESSED_RGBA = $84EE; - GL_TEXTURE_COMPRESSION_HINT = $84EF; - GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0; - GL_TEXTURE_COMPRESSED = $86A1; - GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2; - GL_COMPRESSED_TEXTURE_FORMATS = $86A3; - GL_CLAMP_TO_BORDER = $812D; -{$ifdef DGL_DEPRECATED} - GL_CLIENT_ACTIVE_TEXTURE = $84E1; - GL_MAX_TEXTURE_UNITS = $84E2; - GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3; - GL_TRANSPOSE_PROJECTION_MATRIX = $84E4; - GL_TRANSPOSE_TEXTURE_MATRIX = $84E5; - GL_TRANSPOSE_COLOR_MATRIX = $84E6; - GL_MULTISAMPLE_BIT = $20000000; - GL_NORMAL_MAP = $8511; - GL_REFLECTION_MAP = $8512; - GL_COMPRESSED_ALPHA = $84E9; - GL_COMPRESSED_LUMINANCE = $84EA; - GL_COMPRESSED_LUMINANCE_ALPHA = $84EB; - GL_COMPRESSED_INTENSITY = $84EC; - GL_COMBINE = $8570; - GL_COMBINE_RGB = $8571; - GL_COMBINE_ALPHA = $8572; - GL_SOURCE0_RGB = $8580; - GL_SOURCE1_RGB = $8581; - GL_SOURCE2_RGB = $8582; - GL_SOURCE0_ALPHA = $8588; - GL_SOURCE1_ALPHA = $8589; - GL_SOURCE2_ALPHA = $858A; - GL_OPERAND0_RGB = $8590; - GL_OPERAND1_RGB = $8591; - GL_OPERAND2_RGB = $8592; - GL_OPERAND0_ALPHA = $8598; - GL_OPERAND1_ALPHA = $8599; - GL_OPERAND2_ALPHA = $859A; - GL_RGB_SCALE = $8573; - GL_ADD_SIGNED = $8574; - GL_INTERPOLATE = $8575; - GL_SUBTRACT = $84E7; - GL_CONSTANT = $8576; - GL_PRIMARY_COLOR = $8577; - GL_PREVIOUS = $8578; - GL_DOT3_RGB = $86AE; - GL_DOT3_RGBA = $86AF; -{$endif} - - // GL_VERSION_1_4 - GL_BLEND_DST_RGB = $80C8; - GL_BLEND_SRC_RGB = $80C9; - GL_BLEND_DST_ALPHA = $80CA; - GL_BLEND_SRC_ALPHA = $80CB; - GL_POINT_FADE_THRESHOLD_SIZE = $8128; - GL_DEPTH_COMPONENT16 = $81A5; - GL_DEPTH_COMPONENT24 = $81A6; - GL_DEPTH_COMPONENT32 = $81A7; - GL_MIRRORED_REPEAT = $8370; - GL_MAX_TEXTURE_LOD_BIAS = $84FD; - GL_TEXTURE_LOD_BIAS = $8501; - GL_INCR_WRAP = $8507; - GL_DECR_WRAP = $8508; - GL_TEXTURE_DEPTH_SIZE = $884A; - GL_TEXTURE_COMPARE_MODE = $884C; - GL_TEXTURE_COMPARE_FUNC = $884D; -{$ifdef DGL_DEPRECATED} - GL_POINT_SIZE_MIN = $8126; - GL_POINT_SIZE_MAX = $8127; - GL_POINT_DISTANCE_ATTENUATION = $8129; - GL_GENERATE_MIPMAP = $8191; - GL_GENERATE_MIPMAP_HINT = $8192; - GL_FOG_COORDINATE_SOURCE = $8450; - GL_FOG_COORDINATE = $8451; - GL_FRAGMENT_DEPTH = $8452; - GL_CURRENT_FOG_COORDINATE = $8453; - GL_FOG_COORDINATE_ARRAY_TYPE = $8454; - GL_FOG_COORDINATE_ARRAY_STRIDE = $8455; - GL_FOG_COORDINATE_ARRAY_POINTER = $8456; - GL_FOG_COORDINATE_ARRAY = $8457; - GL_COLOR_SUM = $8458; - GL_CURRENT_SECONDARY_COLOR = $8459; - GL_SECONDARY_COLOR_ARRAY_SIZE = $845A; - GL_SECONDARY_COLOR_ARRAY_TYPE = $845B; - GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C; - GL_SECONDARY_COLOR_ARRAY_POINTER = $845D; - GL_SECONDARY_COLOR_ARRAY = $845E; - GL_TEXTURE_FILTER_CONTROL = $8500; - GL_DEPTH_TEXTURE_MODE = $884B; - GL_COMPARE_R_TO_TEXTURE = $884E; -{$endif} - - // GL_VERSION_1_5 - GL_BUFFER_SIZE = $8764; - GL_BUFFER_USAGE = $8765; - GL_QUERY_COUNTER_BITS = $8864; - GL_CURRENT_QUERY = $8865; - GL_QUERY_RESULT = $8866; - GL_QUERY_RESULT_AVAILABLE = $8867; - GL_ARRAY_BUFFER = $8892; - GL_ELEMENT_ARRAY_BUFFER = $8893; - GL_ARRAY_BUFFER_BINDING = $8894; - GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895; - GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F; - GL_READ_ONLY = $88B8; - GL_WRITE_ONLY = $88B9; - GL_READ_WRITE = $88BA; - GL_BUFFER_ACCESS = $88BB; - GL_BUFFER_MAPPED = $88BC; - GL_BUFFER_MAP_POINTER = $88BD; - GL_STREAM_DRAW = $88E0; - GL_STREAM_READ = $88E1; - GL_STREAM_COPY = $88E2; - GL_STATIC_DRAW = $88E4; - GL_STATIC_READ = $88E5; - GL_STATIC_COPY = $88E6; - GL_DYNAMIC_DRAW = $88E8; - GL_DYNAMIC_READ = $88E9; - GL_DYNAMIC_COPY = $88EA; - GL_SAMPLES_PASSED = $8914; -{$ifdef DGL_DEPRECATED} - GL_VERTEX_ARRAY_BUFFER_BINDING = $8896; - GL_NORMAL_ARRAY_BUFFER_BINDING = $8897; - GL_COLOR_ARRAY_BUFFER_BINDING = $8898; - GL_INDEX_ARRAY_BUFFER_BINDING = $8899; - GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A; - GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B; - GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C; - GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D; - GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E; - GL_FOG_COORD_SRC = $8450; - GL_FOG_COORD = $8451; - GL_CURRENT_FOG_COORD = $8453; - GL_FOG_COORD_ARRAY_TYPE = $8454; - GL_FOG_COORD_ARRAY_STRIDE = $8455; - GL_FOG_COORD_ARRAY_POINTER = $8456; - GL_FOG_COORD_ARRAY = $8457; - GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D; - GL_SRC0_RGB = $8580; - GL_SRC1_RGB = $8581; - GL_SRC2_RGB = $8582; - GL_SRC0_ALPHA = $8588; - GL_SRC1_ALPHA = $8589; - GL_SRC2_ALPHA = $858A; -{$endif} - - // GL_VERSION_2_0 - GL_BLEND_EQUATION_RGB = $8009; - GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622; - GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623; - GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624; - GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625; - GL_CURRENT_VERTEX_ATTRIB = $8626; - GL_VERTEX_PROGRAM_POINT_SIZE = $8642; - GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645; - GL_STENCIL_BACK_FUNC = $8800; - GL_STENCIL_BACK_FAIL = $8801; - GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802; - GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803; - GL_MAX_DRAW_BUFFERS = $8824; - GL_DRAW_BUFFER0 = $8825; - GL_DRAW_BUFFER1 = $8826; - GL_DRAW_BUFFER2 = $8827; - GL_DRAW_BUFFER3 = $8828; - GL_DRAW_BUFFER4 = $8829; - GL_DRAW_BUFFER5 = $882A; - GL_DRAW_BUFFER6 = $882B; - GL_DRAW_BUFFER7 = $882C; - GL_DRAW_BUFFER8 = $882D; - GL_DRAW_BUFFER9 = $882E; - GL_DRAW_BUFFER10 = $882F; - GL_DRAW_BUFFER11 = $8830; - GL_DRAW_BUFFER12 = $8831; - GL_DRAW_BUFFER13 = $8832; - GL_DRAW_BUFFER14 = $8833; - GL_DRAW_BUFFER15 = $8834; - GL_BLEND_EQUATION_ALPHA = $883D; - GL_MAX_VERTEX_ATTRIBS = $8869; - GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A; - GL_MAX_TEXTURE_IMAGE_UNITS = $8872; - GL_FRAGMENT_SHADER = $8B30; - GL_VERTEX_SHADER = $8B31; - GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49; - GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A; - GL_MAX_VARYING_FLOATS = $8B4B; - GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C; - GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D; - GL_SHADER_TYPE = $8B4F; - GL_FLOAT_VEC2 = $8B50; - GL_FLOAT_VEC3 = $8B51; - GL_FLOAT_VEC4 = $8B52; - GL_INT_VEC2 = $8B53; - GL_INT_VEC3 = $8B54; - GL_INT_VEC4 = $8B55; - GL_BOOL = $8B56; - GL_BOOL_VEC2 = $8B57; - GL_BOOL_VEC3 = $8B58; - GL_BOOL_VEC4 = $8B59; - GL_FLOAT_MAT2 = $8B5A; - GL_FLOAT_MAT3 = $8B5B; - GL_FLOAT_MAT4 = $8B5C; - GL_SAMPLER_1D = $8B5D; - GL_SAMPLER_2D = $8B5E; - GL_SAMPLER_3D = $8B5F; - GL_SAMPLER_CUBE = $8B60; - GL_SAMPLER_1D_SHADOW = $8B61; - GL_SAMPLER_2D_SHADOW = $8B62; - GL_DELETE_STATUS = $8B80; - GL_COMPILE_STATUS = $8B81; - GL_LINK_STATUS = $8B82; - GL_VALIDATE_STATUS = $8B83; - GL_INFO_LOG_LENGTH = $8B84; - GL_ATTACHED_SHADERS = $8B85; - GL_ACTIVE_UNIFORMS = $8B86; - GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87; - GL_SHADER_SOURCE_LENGTH = $8B88; - GL_ACTIVE_ATTRIBUTES = $8B89; - GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A; - GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B; - GL_SHADING_LANGUAGE_VERSION = $8B8C; - GL_CURRENT_PROGRAM = $8B8D; - GL_POINT_SPRITE_COORD_ORIGIN = $8CA0; - GL_LOWER_LEFT = $8CA1; - GL_UPPER_LEFT = $8CA2; - GL_STENCIL_BACK_REF = $8CA3; - GL_STENCIL_BACK_VALUE_MASK = $8CA4; - GL_STENCIL_BACK_WRITEMASK = $8CA5; -{$ifdef DGL_DEPRECATED} - GL_VERTEX_PROGRAM_TWO_SIDE = $8643; - GL_POINT_SPRITE = $8861; - GL_COORD_REPLACE = $8862; - GL_MAX_TEXTURE_COORDS = $8871; -{$endif} - - // GL_VERSION_2_1 - GL_PIXEL_PACK_BUFFER = $88EB; - GL_PIXEL_UNPACK_BUFFER = $88EC; - GL_PIXEL_PACK_BUFFER_BINDING = $88ED; - GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF; - GL_FLOAT_MAT2x3 = $8B65; - GL_FLOAT_MAT2x4 = $8B66; - GL_FLOAT_MAT3x2 = $8B67; - GL_FLOAT_MAT3x4 = $8B68; - GL_FLOAT_MAT4x2 = $8B69; - GL_FLOAT_MAT4x3 = $8B6A; - GL_SRGB = $8C40; - GL_SRGB8 = $8C41; - GL_SRGB_ALPHA = $8C42; - GL_SRGB8_ALPHA8 = $8C43; - GL_COMPRESSED_SRGB = $8C48; - GL_COMPRESSED_SRGB_ALPHA = $8C49; -{$ifdef DGL_DEPRECATED} - GL_CURRENT_RASTER_SECONDARY_COLOR = $845F; - GL_SLUMINANCE_ALPHA = $8C44; - GL_SLUMINANCE8_ALPHA8 = $8C45; - GL_SLUMINANCE = $8C46; - GL_SLUMINANCE8 = $8C47; - GL_COMPRESSED_SLUMINANCE = $8C4A; - GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B; -{$endif} - - // GL_VERSION_3_0 - GL_COMPARE_REF_TO_TEXTURE = $884E; - GL_CLIP_DISTANCE0 = $3000; - GL_CLIP_DISTANCE1 = $3001; - GL_CLIP_DISTANCE2 = $3002; - GL_CLIP_DISTANCE3 = $3003; - GL_CLIP_DISTANCE4 = $3004; - GL_CLIP_DISTANCE5 = $3005; - GL_CLIP_DISTANCE6 = $3006; - GL_CLIP_DISTANCE7 = $3007; - GL_MAX_CLIP_DISTANCES = $0D32; - GL_MAJOR_VERSION = $821B; - GL_MINOR_VERSION = $821C; - GL_NUM_EXTENSIONS = $821D; - GL_CONTEXT_FLAGS = $821E; - GL_DEPTH_BUFFER = $8223; - GL_STENCIL_BUFFER = $8224; - GL_COMPRESSED_RED = $8225; - GL_COMPRESSED_RG = $8226; - GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001; - GL_RGBA32F = $8814; - GL_RGB32F = $8815; - GL_RGBA16F = $881A; - GL_RGB16F = $881B; - GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD; - GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF; - GL_MIN_PROGRAM_TEXEL_OFFSET = $8904; - GL_MAX_PROGRAM_TEXEL_OFFSET = $8905; - GL_CLAMP_READ_COLOR = $891C; - GL_FIXED_ONLY = $891D; - GL_MAX_VARYING_COMPONENTS = $8B4B; - GL_TEXTURE_1D_ARRAY = $8C18; - GL_PROXY_TEXTURE_1D_ARRAY = $8C19; - GL_TEXTURE_2D_ARRAY = $8C1A; - GL_PROXY_TEXTURE_2D_ARRAY = $8C1B; - GL_TEXTURE_BINDING_1D_ARRAY = $8C1C; - GL_TEXTURE_BINDING_2D_ARRAY = $8C1D; - GL_R11F_G11F_B10F = $8C3A; - GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B; - GL_RGB9_E5 = $8C3D; - GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E; - GL_TEXTURE_SHARED_SIZE = $8C3F; - GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76; - GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80; - GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83; - GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84; - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85; - GL_PRIMITIVES_GENERATED = $8C87; - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88; - GL_RASTERIZER_DISCARD = $8C89; - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B; - GL_INTERLEAVED_ATTRIBS = $8C8C; - GL_SEPARATE_ATTRIBS = $8C8D; - GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E; - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F; - GL_RGBA32UI = $8D70; - GL_RGB32UI = $8D71; - GL_RGBA16UI = $8D76; - GL_RGB16UI = $8D77; - GL_RGBA8UI = $8D7C; - GL_RGB8UI = $8D7D; - GL_RGBA32I = $8D82; - GL_RGB32I = $8D83; - GL_RGBA16I = $8D88; - GL_RGB16I = $8D89; - GL_RGBA8I = $8D8E; - GL_RGB8I = $8D8F; - GL_RED_INTEGER = $8D94; - GL_GREEN_INTEGER = $8D95; - GL_BLUE_INTEGER = $8D96; - GL_RGB_INTEGER = $8D98; - GL_RGBA_INTEGER = $8D99; - GL_BGR_INTEGER = $8D9A; - GL_BGRA_INTEGER = $8D9B; - GL_SAMPLER_1D_ARRAY = $8DC0; - GL_SAMPLER_2D_ARRAY = $8DC1; - GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3; - GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4; - GL_SAMPLER_CUBE_SHADOW = $8DC5; - GL_UNSIGNED_INT_VEC2 = $8DC6; - GL_UNSIGNED_INT_VEC3 = $8DC7; - GL_UNSIGNED_INT_VEC4 = $8DC8; - GL_INT_SAMPLER_1D = $8DC9; - GL_INT_SAMPLER_2D = $8DCA; - GL_INT_SAMPLER_3D = $8DCB; - GL_INT_SAMPLER_CUBE = $8DCC; - GL_INT_SAMPLER_1D_ARRAY = $8DCE; - GL_INT_SAMPLER_2D_ARRAY = $8DCF; - GL_UNSIGNED_INT_SAMPLER_1D = $8DD1; - GL_UNSIGNED_INT_SAMPLER_2D = $8DD2; - GL_UNSIGNED_INT_SAMPLER_3D = $8DD3; - GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4; - GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6; - GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7; - GL_QUERY_WAIT = $8E13; - GL_QUERY_NO_WAIT = $8E14; - GL_QUERY_BY_REGION_WAIT = $8E15; - GL_QUERY_BY_REGION_NO_WAIT = $8E16; - GL_BUFFER_ACCESS_FLAGS = $911F; - GL_BUFFER_MAP_LENGTH = $9120; - GL_BUFFER_MAP_OFFSET = $9121; - { Reuse tokens from ARB_depth_buffer_float } - { reuse GL_DEPTH_COMPONENT32F } - { reuse GL_DEPTH32F_STENCIL8 } - { reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV } - { Reuse tokens from ARB_framebuffer_object } - { reuse GL_INVALID_FRAMEBUFFER_OPERATION } - { reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING } - { reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE } - { reuse GL_FRAMEBUFFER_DEFAULT } - { reuse GL_FRAMEBUFFER_UNDEFINED } - { reuse GL_DEPTH_STENCIL_ATTACHMENT } - { reuse GL_INDEX } - { reuse GL_MAX_RENDERBUFFER_SIZE } - { reuse GL_DEPTH_STENCIL } - { reuse GL_UNSIGNED_INT_24_8 } - { reuse GL_DEPTH24_STENCIL8 } - { reuse GL_TEXTURE_STENCIL_SIZE } - { reuse GL_TEXTURE_RED_TYPE } - { reuse GL_TEXTURE_GREEN_TYPE } - { reuse GL_TEXTURE_BLUE_TYPE } - { reuse GL_TEXTURE_ALPHA_TYPE } - { reuse GL_TEXTURE_DEPTH_TYPE } - { reuse GL_UNSIGNED_NORMALIZED } - { reuse GL_FRAMEBUFFER_BINDING } - { reuse GL_DRAW_FRAMEBUFFER_BINDING } - { reuse GL_RENDERBUFFER_BINDING } - { reuse GL_READ_FRAMEBUFFER } - { reuse GL_DRAW_FRAMEBUFFER } - { reuse GL_READ_FRAMEBUFFER_BINDING } - { reuse GL_RENDERBUFFER_SAMPLES } - { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME } - { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL } - { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE } - { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } - { reuse GL_FRAMEBUFFER_COMPLETE } - { reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT } - { reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT } - { reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER } - { reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER } - { reuse GL_FRAMEBUFFER_UNSUPPORTED } - { reuse GL_MAX_COLOR_ATTACHMENTS } - { reuse GL_COLOR_ATTACHMENT0 } - { reuse GL_COLOR_ATTACHMENT1 } - { reuse GL_COLOR_ATTACHMENT2 } - { reuse GL_COLOR_ATTACHMENT3 } - { reuse GL_COLOR_ATTACHMENT4 } - { reuse GL_COLOR_ATTACHMENT5 } - { reuse GL_COLOR_ATTACHMENT6 } - { reuse GL_COLOR_ATTACHMENT7 } - { reuse GL_COLOR_ATTACHMENT8 } - { reuse GL_COLOR_ATTACHMENT9 } - { reuse GL_COLOR_ATTACHMENT10 } - { reuse GL_COLOR_ATTACHMENT11 } - { reuse GL_COLOR_ATTACHMENT12 } - { reuse GL_COLOR_ATTACHMENT13 } - { reuse GL_COLOR_ATTACHMENT14 } - { reuse GL_COLOR_ATTACHMENT15 } - { reuse GL_DEPTH_ATTACHMENT } - { reuse GL_STENCIL_ATTACHMENT } - { reuse GL_FRAMEBUFFER } - { reuse GL_RENDERBUFFER } - { reuse GL_RENDERBUFFER_WIDTH } - { reuse GL_RENDERBUFFER_HEIGHT } - { reuse GL_RENDERBUFFER_INTERNAL_FORMAT } - { reuse GL_STENCIL_INDEX1 } - { reuse GL_STENCIL_INDEX4 } - { reuse GL_STENCIL_INDEX8 } - { reuse GL_STENCIL_INDEX16 } - { reuse GL_RENDERBUFFER_RED_SIZE } - { reuse GL_RENDERBUFFER_GREEN_SIZE } - { reuse GL_RENDERBUFFER_BLUE_SIZE } - { reuse GL_RENDERBUFFER_ALPHA_SIZE } - { reuse GL_RENDERBUFFER_DEPTH_SIZE } - { reuse GL_RENDERBUFFER_STENCIL_SIZE } - { reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE } - { reuse GL_MAX_SAMPLES } - { Reuse tokens from ARB_framebuffer_sRGB } - { reuse GL_FRAMEBUFFER_SRGB } - { Reuse tokens from ARB_half_float_vertex } - { reuse GL_HALF_FLOAT } - { Reuse tokens from ARB_map_buffer_range } - { reuse GL_MAP_READ_BIT } - { reuse GL_MAP_WRITE_BIT } - { reuse GL_MAP_INVALIDATE_RANGE_BIT } - { reuse GL_MAP_INVALIDATE_BUFFER_BIT } - { reuse GL_MAP_FLUSH_EXPLICIT_BIT } - { reuse GL_MAP_UNSYNCHRONIZED_BIT } - { Reuse tokens from ARB_texture_compression_rgtc } - { reuse GL_COMPRESSED_RED_RGTC1 } - { reuse GL_COMPRESSED_SIGNED_RED_RGTC1 } - { reuse GL_COMPRESSED_RG_RGTC2 } - { reuse GL_COMPRESSED_SIGNED_RG_RGTC2 } - { Reuse tokens from ARB_texture_rg } - { reuse GL_RG } - { reuse GL_RG_INTEGER } - { reuse GL_R8 } - { reuse GL_R16 } - { reuse GL_RG8 } - { reuse GL_RG16 } - { reuse GL_R16F } - { reuse GL_R32F } - { reuse GL_RG16F } - { reuse GL_RG32F } - { reuse GL_R8I } - { reuse GL_R8UI } - { reuse GL_R16I } - { reuse GL_R16UI } - { reuse GL_R32I } - { reuse GL_R32UI } - { reuse GL_RG8I } - { reuse GL_RG8UI } - { reuse GL_RG16I } - { reuse GL_RG16UI } - { reuse GL_RG32I } - { reuse GL_RG32UI } - { Reuse tokens from ARB_vertex_array_object } - { reuse GL_VERTEX_ARRAY_BINDING } -{$ifdef DGL_DEPRECATED} - GL_CLAMP_VERTEX_COLOR = $891A; - GL_CLAMP_FRAGMENT_COLOR = $891B; - GL_ALPHA_INTEGER = $8D97; - { Reuse tokens from ARB_framebuffer_object } - { reuse GL_TEXTURE_LUMINANCE_TYPE } - { reuse GL_TEXTURE_INTENSITY_TYPE } -{$endif} - - // GL_VERSION_3_1 - GL_SAMPLER_2D_RECT = $8B63; - GL_SAMPLER_2D_RECT_SHADOW = $8B64; - GL_SAMPLER_BUFFER = $8DC2; - GL_INT_SAMPLER_2D_RECT = $8DCD; - GL_INT_SAMPLER_BUFFER = $8DD0; - GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5; - GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8; - GL_TEXTURE_BUFFER = $8C2A; - GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B; - GL_TEXTURE_BINDING_BUFFER = $8C2C; - GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D; - GL_TEXTURE_BUFFER_FORMAT = $8C2E; - GL_TEXTURE_RECTANGLE = $84F5; - GL_TEXTURE_BINDING_RECTANGLE = $84F6; - GL_PROXY_TEXTURE_RECTANGLE = $84F7; - GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8; - GL_RED_SNORM = $8F90; - GL_RG_SNORM = $8F91; - GL_RGB_SNORM = $8F92; - GL_RGBA_SNORM = $8F93; - GL_R8_SNORM = $8F94; - GL_RG8_SNORM = $8F95; - GL_RGB8_SNORM = $8F96; - GL_RGBA8_SNORM = $8F97; - GL_R16_SNORM = $8F98; - GL_RG16_SNORM = $8F99; - GL_RGB16_SNORM = $8F9A; - GL_RGBA16_SNORM = $8F9B; - GL_SIGNED_NORMALIZED = $8F9C; - GL_PRIMITIVE_RESTART = $8F9D; - GL_PRIMITIVE_RESTART_INDEX = $8F9E; - { Reuse tokens from ARB_copy_buffer } - { reuse GL_COPY_READ_BUFFER } - { reuse GL_COPY_WRITE_BUFFER } - { Reuse tokens from ARB_draw_instanced (none) } - { Reuse tokens from ARB_uniform_buffer_object } - { reuse GL_UNIFORM_BUFFER } - { reuse GL_UNIFORM_BUFFER_BINDING } - { reuse GL_UNIFORM_BUFFER_START } - { reuse GL_UNIFORM_BUFFER_SIZE } - { reuse GL_MAX_VERTEX_UNIFORM_BLOCKS } - { reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS } - { reuse GL_MAX_COMBINED_UNIFORM_BLOCKS } - { reuse GL_MAX_UNIFORM_BUFFER_BINDINGS } - { reuse GL_MAX_UNIFORM_BLOCK_SIZE } - { reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS } - { reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS } - { reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT } - { reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH } - { reuse GL_ACTIVE_UNIFORM_BLOCKS } - { reuse GL_UNIFORM_TYPE } - { reuse GL_UNIFORM_SIZE } - { reuse GL_UNIFORM_NAME_LENGTH } - { reuse GL_UNIFORM_BLOCK_INDEX } - { reuse GL_UNIFORM_OFFSET } - { reuse GL_UNIFORM_ARRAY_STRIDE } - { reuse GL_UNIFORM_MATRIX_STRIDE } - { reuse GL_UNIFORM_IS_ROW_MAJOR } - { reuse GL_UNIFORM_BLOCK_BINDING } - { reuse GL_UNIFORM_BLOCK_DATA_SIZE } - { reuse GL_UNIFORM_BLOCK_NAME_LENGTH } - { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS } - { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES } - { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER } - { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER } - { reuse GL_INVALID_INDEX } - - // GL_VERSION_3_2 - GL_CONTEXT_CORE_PROFILE_BIT = $00000001; - GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002; - GL_LINES_ADJACENCY = $000A; - GL_LINE_STRIP_ADJACENCY = $000B; - GL_TRIANGLES_ADJACENCY = $000C; - GL_TRIANGLE_STRIP_ADJACENCY = $000D; - GL_PROGRAM_POINT_SIZE = $8642; - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29; - GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7; - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8; - GL_GEOMETRY_SHADER = $8DD9; - GL_GEOMETRY_VERTICES_OUT = $8916; - GL_GEOMETRY_INPUT_TYPE = $8917; - GL_GEOMETRY_OUTPUT_TYPE = $8918; - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF; - GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0; - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1; - GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122; - GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123; - GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124; - GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125; - GL_CONTEXT_PROFILE_MASK = $9126; - { reuse GL_MAX_VARYING_COMPONENTS } - { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } - { Reuse tokens from ARB_depth_clamp } - { reuse GL_DEPTH_CLAMP } - { Reuse tokens from ARB_draw_elements_base_vertex (none) } - { Reuse tokens from ARB_fragment_coord_conventions (none) } - { Reuse tokens from ARB_provoking_vertex } - { reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION } - { reuse GL_FIRST_VERTEX_CONVENTION } - { reuse GL_LAST_VERTEX_CONVENTION } - { reuse GL_PROVOKING_VERTEX } - { Reuse tokens from ARB_seamless_cube_map } - { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS } - { Reuse tokens from ARB_sync } - { reuse GL_MAX_SERVER_WAIT_TIMEOUT } - { reuse GL_OBJECT_TYPE } - { reuse GL_SYNC_CONDITION } - { reuse GL_SYNC_STATUS } - { reuse GL_SYNC_FLAGS } - { reuse GL_SYNC_FENCE } - { reuse GL_SYNC_GPU_COMMANDS_COMPLETE } - { reuse GL_UNSIGNALED } - { reuse GL_SIGNALED } - { reuse GL_ALREADY_SIGNALED } - { reuse GL_TIMEOUT_EXPIRED } - { reuse GL_CONDITION_SATISFIED } - { reuse GL_WAIT_FAILED } - { reuse GL_TIMEOUT_IGNORED } - { reuse GL_SYNC_FLUSH_COMMANDS_BIT } - { reuse GL_TIMEOUT_IGNORED } - { Reuse tokens from ARB_texture_multisample } - { reuse GL_SAMPLE_POSITION } - { reuse GL_SAMPLE_MASK } - { reuse GL_SAMPLE_MASK_VALUE } - { reuse GL_MAX_SAMPLE_MASK_WORDS } - { reuse GL_TEXTURE_2D_MULTISAMPLE } - { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE } - { reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY } - { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY } - { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE } - { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY } - { reuse GL_TEXTURE_SAMPLES } - { reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS } - { reuse GL_SAMPLER_2D_MULTISAMPLE } - { reuse GL_INT_SAMPLER_2D_MULTISAMPLE } - { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE } - { reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY } - { reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY } - { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY } - { reuse GL_MAX_COLOR_TEXTURE_SAMPLES } - { reuse GL_MAX_DEPTH_TEXTURE_SAMPLES } - { reuse GL_MAX_INTEGER_SAMPLES } - { Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core } - - // GL_VERSION_3_3 - GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE; - { Reuse tokens from ARB_blend_func_extended } - { reuse GL_SRC1_COLOR } - { reuse GL_ONE_MINUS_SRC1_COLOR } - { reuse GL_ONE_MINUS_SRC1_ALPHA } - { reuse GL_MAX_DUAL_SOURCE_DRAW_BUFFERS } - { Reuse tokens from ARB_explicit_attrib_location (none) } - { Reuse tokens from ARB_occlusion_query2 } - { reuse GL_ANY_SAMPLES_PASSED } - { Reuse tokens from ARB_sampler_objects } - { reuse GL_SAMPLER_BINDING } - { Reuse tokens from ARB_shader_bit_encoding (none) } - { Reuse tokens from ARB_texture_rgb10_a2ui } - { reuse GL_RGB10_A2UI } - { Reuse tokens from ARB_texture_swizzle } - { reuse GL_TEXTURE_SWIZZLE_R } - { reuse GL_TEXTURE_SWIZZLE_G } - { reuse GL_TEXTURE_SWIZZLE_B } - { reuse GL_TEXTURE_SWIZZLE_A } - { reuse GL_TEXTURE_SWIZZLE_RGBA } - { Reuse tokens from ARB_timer_query } - { reuse GL_TIME_ELAPSED } - { reuse GL_TIMESTAMP } - { Reuse tokens from ARB_vertex_type_2_10_10_10_rev } - { reuse GL_INT_2_10_10_10_REV } - - // GL_VERSION_4_0 - GL_SAMPLE_SHADING = $8C36; - GL_MIN_SAMPLE_SHADING_VALUE = $8C37; - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E; - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F; - GL_TEXTURE_CUBE_MAP_ARRAY = $9009; - GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A; - GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B; - GL_SAMPLER_CUBE_MAP_ARRAY = $900C; - GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D; - GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E; - GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F; - { Reuse tokens from ARB_texture_query_lod (none) } - { Reuse tokens from ARB_draw_buffers_blend (none) } - { Reuse tokens from ARB_draw_indirect } - { reuse GL_DRAW_INDIRECT_BUFFER } - { reuse GL_DRAW_INDIRECT_BUFFER_BINDING } - { Reuse tokens from ARB_gpu_shader5 } - { reuse GL_GEOMETRY_SHADER_INVOCATIONS } - { reuse GL_MAX_GEOMETRY_SHADER_INVOCATIONS } - { reuse GL_MIN_FRAGMENT_INTERPOLATION_OFFSET } - { reuse GL_MAX_FRAGMENT_INTERPOLATION_OFFSET } - { reuse GL_FRAGMENT_INTERPOLATION_OFFSET_BITS } - { reuse GL_MAX_VERTEX_STREAMS } - { Reuse tokens from ARB_gpu_shader_fp64 } - { reuse GL_DOUBLE_VEC2 } - { reuse GL_DOUBLE_VEC3 } - { reuse GL_DOUBLE_VEC4 } - { reuse GL_DOUBLE_MAT2 } - { reuse GL_DOUBLE_MAT3 } - { reuse GL_DOUBLE_MAT4 } - { reuse GL_DOUBLE_MAT2x3 } - { reuse GL_DOUBLE_MAT2x4 } - { reuse GL_DOUBLE_MAT3x2 } - { reuse GL_DOUBLE_MAT3x4 } - { reuse GL_DOUBLE_MAT4x2 } - { reuse GL_DOUBLE_MAT4x3 } - { Reuse tokens from ARB_shader_subroutine } - { reuse GL_ACTIVE_SUBROUTINES } - { reuse GL_ACTIVE_SUBROUTINE_UNIFORMS } - { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS } - { reuse GL_ACTIVE_SUBROUTINE_MAX_LENGTH } - { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH } - { reuse GL_MAX_SUBROUTINES } - { reuse GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS } - { reuse GL_NUM_COMPATIBLE_SUBROUTINES } - { reuse GL_COMPATIBLE_SUBROUTINES } - { Reuse tokens from ARB_tessellation_shader } - { reuse GL_PATCHES } - { reuse GL_PATCH_VERTICES } - { reuse GL_PATCH_DEFAULT_INNER_LEVEL } - { reuse GL_PATCH_DEFAULT_OUTER_LEVEL } - { reuse GL_TESS_CONTROL_OUTPUT_VERTICES } - { reuse GL_TESS_GEN_MODE } - { reuse GL_TESS_GEN_SPACING } - { reuse GL_TESS_GEN_VERTEX_ORDER } - { reuse GL_TESS_GEN_POINT_MODE } - { reuse GL_ISOLINES } - { reuse GL_FRACTIONAL_ODD } - { reuse GL_FRACTIONAL_EVEN } - { reuse GL_MAX_PATCH_VERTICES } - { reuse GL_MAX_TESS_GEN_LEVEL } - { reuse GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS } - { reuse GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS } - { reuse GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS } - { reuse GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS } - { reuse GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS } - { reuse GL_MAX_TESS_PATCH_COMPONENTS } - { reuse GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS } - { reuse GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS } - { reuse GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS } - { reuse GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS } - { reuse GL_MAX_TESS_CONTROL_INPUT_COMPONENTS } - { reuse GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS } - { reuse GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS } - { reuse GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS } - { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER } - { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER } - { reuse GL_TESS_EVALUATION_SHADER } - { reuse GL_TESS_CONTROL_SHADER } - { Reuse tokens from ARB_texture_buffer_object_rgb32 (none) } - { Reuse tokens from ARB_transform_feedback2 } - { reuse GL_TRANSFORM_FEEDBACK } - { reuse GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED } - { reuse GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE } - { reuse GL_TRANSFORM_FEEDBACK_BINDING } - { Reuse tokens from ARB_transform_feedback3 } - { reuse GL_MAX_TRANSFORM_FEEDBACK_BUFFERS } - { reuse GL_MAX_VERTEX_STREAMS } - - // GL_VERSION_4_1 - { Reuse tokens from ARB_ES2_compatibility } - { reuse GL_FIXED } - { reuse GL_IMPLEMENTATION_COLOR_READ_TYPE } - { reuse GL_IMPLEMENTATION_COLOR_READ_FORMAT } - { reuse GL_LOW_FLOAT } - { reuse GL_MEDIUM_FLOAT } - { reuse GL_HIGH_FLOAT } - { reuse GL_LOW_INT } - { reuse GL_MEDIUM_INT } - { reuse GL_HIGH_INT } - { reuse GL_SHADER_COMPILER } - { reuse GL_NUM_SHADER_BINARY_FORMATS } - { reuse GL_MAX_VERTEX_UNIFORM_VECTORS } - { reuse GL_MAX_VARYING_VECTORS } - { reuse GL_MAX_FRAGMENT_UNIFORM_VECTORS } - { reuse GL_RGB565 } - { Reuse tokens from ARB_get_program_binary } - { reuse GL_PROGRAM_BINARY_RETRIEVABLE_HINT } - { reuse GL_PROGRAM_BINARY_LENGTH } - { reuse GL_NUM_PROGRAM_BINARY_FORMATS } - { reuse GL_PROGRAM_BINARY_FORMATS } - { Reuse tokens from ARB_separate_shader_objects } - { reuse GL_VERTEX_SHADER_BIT } - { reuse GL_FRAGMENT_SHADER_BIT } - { reuse GL_GEOMETRY_SHADER_BIT } - { reuse GL_TESS_CONTROL_SHADER_BIT } - { reuse GL_TESS_EVALUATION_SHADER_BIT } - { reuse GL_ALL_SHADER_BITS } - { reuse GL_PROGRAM_SEPARABLE } - { reuse GL_ACTIVE_PROGRAM } - { reuse GL_PROGRAM_PIPELINE_BINDING } - { Reuse tokens from ARB_shader_precision (none) } - { Reuse tokens from ARB_vertex_attrib_64bit - all are in GL 3.0 and 4.0 already } - { Reuse tokens from ARB_viewport_array - some are in GL 1.1 and ARB_provoking_vertex already } - { reuse GL_MAX_VIEWPORTS } - { reuse GL_VIEWPORT_SUBPIXEL_BITS } - { reuse GL_VIEWPORT_BOUNDS_RANGE } - { reuse GL_LAYER_PROVOKING_VERTEX } - { reuse GL_VIEWPORT_INDEX_PROVOKING_VERTEX } - { reuse GL_UNDEFINED_VERTEX } - - // GL_VERSION_4_2 - { Reuse tokens from ARB_base_instance (none) } - { Reuse tokens from ARB_shading_language_420pack (none) } - { Reuse tokens from ARB_transform_feedback_instanced (none) } - { Reuse tokens from ARB_compressed_texture_pixel_storage } - { reuse GL_UNPACK_COMPRESSED_BLOCK_WIDTH } - { reuse GL_UNPACK_COMPRESSED_BLOCK_HEIGHT } - { reuse GL_UNPACK_COMPRESSED_BLOCK_DEPTH } - { reuse GL_UNPACK_COMPRESSED_BLOCK_SIZE } - { reuse GL_PACK_COMPRESSED_BLOCK_WIDTH } - { reuse GL_PACK_COMPRESSED_BLOCK_HEIGHT } - { reuse GL_PACK_COMPRESSED_BLOCK_DEPTH } - { reuse GL_PACK_COMPRESSED_BLOCK_SIZE } - { Reuse tokens from ARB_conservative_depth (none) } - { Reuse tokens from ARB_internalformat_query } - { reuse GL_NUM_SAMPLE_COUNTS } - { Reuse tokens from ARB_map_buffer_alignment } - { reuse GL_MIN_MAP_BUFFER_ALIGNMENT } - { Reuse tokens from ARB_shader_atomic_counters } - { reuse GL_ATOMIC_COUNTER_BUFFER } - { reuse GL_ATOMIC_COUNTER_BUFFER_BINDING } - { reuse GL_ATOMIC_COUNTER_BUFFER_START } - { reuse GL_ATOMIC_COUNTER_BUFFER_SIZE } - { reuse GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE } - { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS } - { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER } - { reuse GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_VERTEX_ATOMIC_COUNTERS } - { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS } - { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS } - { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTERS } - { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTERS } - { reuse GL_MAX_COMBINED_ATOMIC_COUNTERS } - { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE } - { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS } - { reuse GL_ACTIVE_ATOMIC_COUNTER_BUFFERS } - { reuse GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX } - { reuse GL_UNSIGNED_INT_ATOMIC_COUNTER } - { Reuse tokens from ARB_shader_image_load_store } - { reuse GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT } - { reuse GL_ELEMENT_ARRAY_BARRIER_BIT } - { reuse GL_UNIFORM_BARRIER_BIT } - { reuse GL_TEXTURE_FETCH_BARRIER_BIT } - { reuse GL_SHADER_IMAGE_ACCESS_BARRIER_BIT } - { reuse GL_COMMAND_BARRIER_BIT } - { reuse GL_PIXEL_BUFFER_BARRIER_BIT } - { reuse GL_TEXTURE_UPDATE_BARRIER_BIT } - { reuse GL_BUFFER_UPDATE_BARRIER_BIT } - { reuse GL_FRAMEBUFFER_BARRIER_BIT } - { reuse GL_TRANSFORM_FEEDBACK_BARRIER_BIT } - { reuse GL_ATOMIC_COUNTER_BARRIER_BIT } - { reuse GL_ALL_BARRIER_BITS } - { reuse GL_MAX_IMAGE_UNITS } - { reuse GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS } - { reuse GL_IMAGE_BINDING_NAME } - { reuse GL_IMAGE_BINDING_LEVEL } - { reuse GL_IMAGE_BINDING_LAYERED } - { reuse GL_IMAGE_BINDING_LAYER } - { reuse GL_IMAGE_BINDING_ACCESS } - { reuse GL_IMAGE_1D } - { reuse GL_IMAGE_2D } - { reuse GL_IMAGE_3D } - { reuse GL_IMAGE_2D_RECT } - { reuse GL_IMAGE_CUBE } - { reuse GL_IMAGE_BUFFER } - { reuse GL_IMAGE_1D_ARRAY } - { reuse GL_IMAGE_2D_ARRAY } - { reuse GL_IMAGE_CUBE_MAP_ARRAY } - { reuse GL_IMAGE_2D_MULTISAMPLE } - { reuse GL_IMAGE_2D_MULTISAMPLE_ARRAY } - { reuse GL_INT_IMAGE_1D } - { reuse GL_INT_IMAGE_2D } - { reuse GL_INT_IMAGE_3D } - { reuse GL_INT_IMAGE_2D_RECT } - { reuse GL_INT_IMAGE_CUBE } - { reuse GL_INT_IMAGE_BUFFER } - { reuse GL_INT_IMAGE_1D_ARRAY } - { reuse GL_INT_IMAGE_2D_ARRAY } - { reuse GL_INT_IMAGE_CUBE_MAP_ARRAY } - { reuse GL_INT_IMAGE_2D_MULTISAMPLE } - { reuse GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY } - { reuse GL_UNSIGNED_INT_IMAGE_1D } - { reuse GL_UNSIGNED_INT_IMAGE_2D } - { reuse GL_UNSIGNED_INT_IMAGE_3D } - { reuse GL_UNSIGNED_INT_IMAGE_2D_RECT } - { reuse GL_UNSIGNED_INT_IMAGE_CUBE } - { reuse GL_UNSIGNED_INT_IMAGE_BUFFER } - { reuse GL_UNSIGNED_INT_IMAGE_1D_ARRAY } - { reuse GL_UNSIGNED_INT_IMAGE_2D_ARRAY } - { reuse GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY } - { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE } - { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY } - { reuse GL_MAX_IMAGE_SAMPLES } - { reuse GL_IMAGE_BINDING_FORMAT } - { reuse GL_IMAGE_FORMAT_COMPATIBILITY_TYPE } - { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE } - { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS } - { reuse GL_MAX_VERTEX_IMAGE_UNIFORMS } - { reuse GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS } - { reuse GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS } - { reuse GL_MAX_GEOMETRY_IMAGE_UNIFORMS } - { reuse GL_MAX_FRAGMENT_IMAGE_UNIFORMS } - { reuse GL_MAX_COMBINED_IMAGE_UNIFORMS } - { Reuse tokens from ARB_shading_language_packing (none) } - { Reuse tokens from ARB_texture_storage } - { reuse GL_TEXTURE_IMMUTABLE_FORMAT } - - // GL_VERSION_4_3 - GL_NUM_SHADING_LANGUAGE_VERSIONS = $82E9; - GL_VERTEX_ATTRIB_ARRAY_LONG = $874E; - { Reuse tokens from ARB_arrays_of_arrays (none, GLSL only) } - { Reuse tokens from ARB_fragment_layer_viewport (none, GLSL only) } - { Reuse tokens from ARB_shader_image_size (none, GLSL only) } - { Reuse tokens from ARB_ES3_compatibility } - { reuse GL_COMPRESSED_RGB8_ETC2 } - { reuse GL_COMPRESSED_SRGB8_ETC2 } - { reuse GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 } - { reuse GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 } - { reuse GL_COMPRESSED_RGBA8_ETC2_EAC } - { reuse GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC } - { reuse GL_COMPRESSED_R11_EAC } - { reuse GL_COMPRESSED_SIGNED_R11_EAC } - { reuse GL_COMPRESSED_RG11_EAC } - { reuse GL_COMPRESSED_SIGNED_RG11_EAC } - { reuse GL_PRIMITIVE_RESTART_FIXED_INDEX } - { reuse GL_ANY_SAMPLES_PASSED_CONSERVATIVE } - { reuse GL_MAX_ELEMENT_INDEX } - { Reuse tokens from ARB_clear_buffer_object (none) } - { Reuse tokens from ARB_compute_shader } - { reuse GL_COMPUTE_SHADER } - { reuse GL_MAX_COMPUTE_UNIFORM_BLOCKS } - { reuse GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS } - { reuse GL_MAX_COMPUTE_IMAGE_UNIFORMS } - { reuse GL_MAX_COMPUTE_SHARED_MEMORY_SIZE } - { reuse GL_MAX_COMPUTE_UNIFORM_COMPONENTS } - { reuse GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS } - { reuse GL_MAX_COMPUTE_ATOMIC_COUNTERS } - { reuse GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS } - { reuse GL_MAX_COMPUTE_LOCAL_INVOCATIONS } - { reuse GL_MAX_COMPUTE_WORK_GROUP_COUNT } - { reuse GL_MAX_COMPUTE_WORK_GROUP_SIZE } - { reuse GL_COMPUTE_LOCAL_WORK_SIZE } - { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER } - { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER } - { reuse GL_DISPATCH_INDIRECT_BUFFER } - { reuse GL_DISPATCH_INDIRECT_BUFFER_BINDING } - { Reuse tokens from ARB_copy_image (none) } - { Reuse tokens from KHR_debug } - { reuse GL_DEBUG_OUTPUT_SYNCHRONOUS } - { reuse GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH } - { reuse GL_DEBUG_CALLBACK_FUNCTION } - { reuse GL_DEBUG_CALLBACK_USER_PARAM } - { reuse GL_DEBUG_SOURCE_API } - { reuse GL_DEBUG_SOURCE_WINDOW_SYSTEM } - { reuse GL_DEBUG_SOURCE_SHADER_COMPILER } - { reuse GL_DEBUG_SOURCE_THIRD_PARTY } - { reuse GL_DEBUG_SOURCE_APPLICATION } - { reuse GL_DEBUG_SOURCE_OTHER } - { reuse GL_DEBUG_TYPE_ERROR } - { reuse GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR } - { reuse GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR } - { reuse GL_DEBUG_TYPE_PORTABILITY } - { reuse GL_DEBUG_TYPE_PERFORMANCE } - { reuse GL_DEBUG_TYPE_OTHER } - { reuse GL_MAX_DEBUG_MESSAGE_LENGTH } - { reuse GL_MAX_DEBUG_LOGGED_MESSAGES } - { reuse GL_DEBUG_LOGGED_MESSAGES } - { reuse GL_DEBUG_SEVERITY_HIGH } - { reuse GL_DEBUG_SEVERITY_MEDIUM } - { reuse GL_DEBUG_SEVERITY_LOW } - { reuse GL_DEBUG_TYPE_MARKER } - { reuse GL_DEBUG_TYPE_PUSH_GROUP } - { reuse GL_DEBUG_TYPE_POP_GROUP } - { reuse GL_DEBUG_SEVERITY_NOTIFICATION } - { reuse GL_MAX_DEBUG_GROUP_STACK_DEPTH } - { reuse GL_DEBUG_GROUP_STACK_DEPTH } - { reuse GL_BUFFER } - { reuse GL_SHADER } - { reuse GL_PROGRAM } - { reuse GL_QUERY } - { reuse GL_PROGRAM_PIPELINE } - { reuse GL_SAMPLER } - { reuse GL_DISPLAY_LIST } - { reuse GL_MAX_LABEL_LENGTH } - { reuse GL_DEBUG_OUTPUT } - { reuse GL_CONTEXT_FLAG_DEBUG_BIT } - { reuse GL_STACK_UNDERFLOW } - { reuse GL_STACK_OVERFLOW } - { Reuse tokens from ARB_explicit_uniform_location } - { reuse GL_MAX_UNIFORM_LOCATIONS } - { Reuse tokens from ARB_framebuffer_no_attachments } - { reuse GL_FRAMEBUFFER_DEFAULT_WIDTH } - { reuse GL_FRAMEBUFFER_DEFAULT_HEIGHT } - { reuse GL_FRAMEBUFFER_DEFAULT_LAYERS } - { reuse GL_FRAMEBUFFER_DEFAULT_SAMPLES } - { reuse GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS } - { reuse GL_MAX_FRAMEBUFFER_WIDTH } - { reuse GL_MAX_FRAMEBUFFER_HEIGHT } - { reuse GL_MAX_FRAMEBUFFER_LAYERS } - { reuse GL_MAX_FRAMEBUFFER_SAMPLES } - { Reuse tokens from ARB_internalformat_query2 } - { reuse GL_INTERNALFORMAT_SUPPORTED } - { reuse GL_INTERNALFORMAT_PREFERRED } - { reuse GL_INTERNALFORMAT_RED_SIZE } - { reuse GL_INTERNALFORMAT_GREEN_SIZE } - { reuse GL_INTERNALFORMAT_BLUE_SIZE } - { reuse GL_INTERNALFORMAT_ALPHA_SIZE } - { reuse GL_INTERNALFORMAT_DEPTH_SIZE } - { reuse GL_INTERNALFORMAT_STENCIL_SIZE } - { reuse GL_INTERNALFORMAT_SHARED_SIZE } - { reuse GL_INTERNALFORMAT_RED_TYPE } - { reuse GL_INTERNALFORMAT_GREEN_TYPE } - { reuse GL_INTERNALFORMAT_BLUE_TYPE } - { reuse GL_INTERNALFORMAT_ALPHA_TYPE } - { reuse GL_INTERNALFORMAT_DEPTH_TYPE } - { reuse GL_INTERNALFORMAT_STENCIL_TYPE } - { reuse GL_MAX_WIDTH } - { reuse GL_MAX_HEIGHT } - { reuse GL_MAX_DEPTH } - { reuse GL_MAX_LAYERS } - { reuse GL_MAX_COMBINED_DIMENSIONS } - { reuse GL_COLOR_COMPONENTS } - { reuse GL_DEPTH_COMPONENTS } - { reuse GL_STENCIL_COMPONENTS } - { reuse GL_COLOR_RENDERABLE } - { reuse GL_DEPTH_RENDERABLE } - { reuse GL_STENCIL_RENDERABLE } - { reuse GL_FRAMEBUFFER_RENDERABLE } - { reuse GL_FRAMEBUFFER_RENDERABLE_LAYERED } - { reuse GL_FRAMEBUFFER_BLEND } - { reuse GL_READ_PIXELS } - { reuse GL_READ_PIXELS_FORMAT } - { reuse GL_READ_PIXELS_TYPE } - { reuse GL_TEXTURE_IMAGE_FORMAT } - { reuse GL_TEXTURE_IMAGE_TYPE } - { reuse GL_GET_TEXTURE_IMAGE_FORMAT } - { reuse GL_GET_TEXTURE_IMAGE_TYPE } - { reuse GL_MIPMAP } - { reuse GL_MANUAL_GENERATE_MIPMAP } - { reuse GL_AUTO_GENERATE_MIPMAP } - { reuse GL_COLOR_ENCODING } - { reuse GL_SRGB_READ } - { reuse GL_SRGB_WRITE } - { reuse GL_FILTER } - { reuse GL_VERTEX_TEXTURE } - { reuse GL_TESS_CONTROL_TEXTURE } - { reuse GL_TESS_EVALUATION_TEXTURE } - { reuse GL_GEOMETRY_TEXTURE } - { reuse GL_FRAGMENT_TEXTURE } - { reuse GL_COMPUTE_TEXTURE } - { reuse GL_TEXTURE_SHADOW } - { reuse GL_TEXTURE_GATHER } - { reuse GL_TEXTURE_GATHER_SHADOW } - { reuse GL_SHADER_IMAGE_LOAD } - { reuse GL_SHADER_IMAGE_STORE } - { reuse GL_SHADER_IMAGE_ATOMIC } - { reuse GL_IMAGE_TEXEL_SIZE } - { reuse GL_IMAGE_COMPATIBILITY_CLASS } - { reuse GL_IMAGE_PIXEL_FORMAT } - { reuse GL_IMAGE_PIXEL_TYPE } - { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST } - { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST } - { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE } - { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE } - { reuse GL_TEXTURE_COMPRESSED_BLOCK_WIDTH } - { reuse GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT } - { reuse GL_TEXTURE_COMPRESSED_BLOCK_SIZE } - { reuse GL_CLEAR_BUFFER } - { reuse GL_TEXTURE_VIEW } - { reuse GL_VIEW_COMPATIBILITY_CLASS } - { reuse GL_FULL_SUPPORT } - { reuse GL_CAVEAT_SUPPORT } - { reuse GL_IMAGE_CLASS_4_X_32 } - { reuse GL_IMAGE_CLASS_2_X_32 } - { reuse GL_IMAGE_CLASS_1_X_32 } - { reuse GL_IMAGE_CLASS_4_X_16 } - { reuse GL_IMAGE_CLASS_2_X_16 } - { reuse GL_IMAGE_CLASS_1_X_16 } - { reuse GL_IMAGE_CLASS_4_X_8 } - { reuse GL_IMAGE_CLASS_2_X_8 } - { reuse GL_IMAGE_CLASS_1_X_8 } - { reuse GL_IMAGE_CLASS_11_11_10 } - { reuse GL_IMAGE_CLASS_10_10_10_2 } - { reuse GL_VIEW_CLASS_128_BITS } - { reuse GL_VIEW_CLASS_96_BITS } - { reuse GL_VIEW_CLASS_64_BITS } - { reuse GL_VIEW_CLASS_48_BITS } - { reuse GL_VIEW_CLASS_32_BITS } - { reuse GL_VIEW_CLASS_24_BITS } - { reuse GL_VIEW_CLASS_16_BITS } - { reuse GL_VIEW_CLASS_8_BITS } - { reuse GL_VIEW_CLASS_S3TC_DXT1_RGB } - { reuse GL_VIEW_CLASS_S3TC_DXT1_RGBA } - { reuse GL_VIEW_CLASS_S3TC_DXT3_RGBA } - { reuse GL_VIEW_CLASS_S3TC_DXT5_RGBA } - { reuse GL_VIEW_CLASS_RGTC1_RED } - { reuse GL_VIEW_CLASS_RGTC2_RG } - { reuse GL_VIEW_CLASS_BPTC_UNORM } - { reuse GL_VIEW_CLASS_BPTC_FLOAT } - { Reuse tokens from ARB_invalidate_subdata (none) } - { Reuse tokens from ARB_multi_draw_indirect (none) } - { Reuse tokens from ARB_program_interface_query } - { reuse GL_UNIFORM } - { reuse GL_UNIFORM_BLOCK } - { reuse GL_PROGRAM_INPUT } - { reuse GL_PROGRAM_OUTPUT } - { reuse GL_BUFFER_VARIABLE } - { reuse GL_SHADER_STORAGE_BLOCK } - { reuse GL_VERTEX_SUBROUTINE } - { reuse GL_TESS_CONTROL_SUBROUTINE } - { reuse GL_TESS_EVALUATION_SUBROUTINE } - { reuse GL_GEOMETRY_SUBROUTINE } - { reuse GL_FRAGMENT_SUBROUTINE } - { reuse GL_COMPUTE_SUBROUTINE } - { reuse GL_VERTEX_SUBROUTINE_UNIFORM } - { reuse GL_TESS_CONTROL_SUBROUTINE_UNIFORM } - { reuse GL_TESS_EVALUATION_SUBROUTINE_UNIFORM } - { reuse GL_GEOMETRY_SUBROUTINE_UNIFORM } - { reuse GL_FRAGMENT_SUBROUTINE_UNIFORM } - { reuse GL_COMPUTE_SUBROUTINE_UNIFORM } - { reuse GL_TRANSFORM_FEEDBACK_VARYING } - { reuse GL_ACTIVE_RESOURCES } - { reuse GL_MAX_NAME_LENGTH } - { reuse GL_MAX_NUM_ACTIVE_VARIABLES } - { reuse GL_MAX_NUM_COMPATIBLE_SUBROUTINES } - { reuse GL_NAME_LENGTH } - { reuse GL_TYPE } - { reuse GL_ARRAY_SIZE } - { reuse GL_OFFSET } - { reuse GL_BLOCK_INDEX } - { reuse GL_ARRAY_STRIDE } - { reuse GL_MATRIX_STRIDE } - { reuse GL_IS_ROW_MAJOR } - { reuse GL_ATOMIC_COUNTER_BUFFER_INDEX } - { reuse GL_BUFFER_BINDING } - { reuse GL_BUFFER_DATA_SIZE } - { reuse GL_NUM_ACTIVE_VARIABLES } - { reuse GL_ACTIVE_VARIABLES } - { reuse GL_REFERENCED_BY_VERTEX_SHADER } - { reuse GL_REFERENCED_BY_TESS_CONTROL_SHADER } - { reuse GL_REFERENCED_BY_TESS_EVALUATION_SHADER } - { reuse GL_REFERENCED_BY_GEOMETRY_SHADER } - { reuse GL_REFERENCED_BY_FRAGMENT_SHADER } - { reuse GL_REFERENCED_BY_COMPUTE_SHADER } - { reuse GL_TOP_LEVEL_ARRAY_SIZE } - { reuse GL_TOP_LEVEL_ARRAY_STRIDE } - { reuse GL_LOCATION } - { reuse GL_LOCATION_INDEX } - { reuse GL_IS_PER_PATCH } - { Reuse tokens from ARB_robust_buffer_access_behavior (none) } - { Reuse tokens from ARB_shader_storage_buffer_object } - { reuse GL_SHADER_STORAGE_BUFFER } - { reuse GL_SHADER_STORAGE_BUFFER_BINDING } - { reuse GL_SHADER_STORAGE_BUFFER_START } - { reuse GL_SHADER_STORAGE_BUFFER_SIZE } - { reuse GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS } - { reuse GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS } - { reuse GL_MAX_SHADER_STORAGE_BLOCK_SIZE } - { reuse GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT } - { reuse GL_SHADER_STORAGE_BARRIER_BIT } - { reuse GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES } - { Reuse tokens from ARB_stencil_texturing } - { reuse GL_DEPTH_STENCIL_TEXTURE_MODE } - { Reuse tokens from ARB_texture_buffer_range } - { reuse GL_TEXTURE_BUFFER_OFFSET } - { reuse GL_TEXTURE_BUFFER_SIZE } - { reuse GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT } - { Reuse tokens from ARB_texture_query_levels (none) } - { Reuse tokens from ARB_texture_storage_multisample (none) } - { Reuse tokens from ARB_texture_view } - { reuse GL_TEXTURE_VIEW_MIN_LEVEL } - { reuse GL_TEXTURE_VIEW_NUM_LEVELS } - { reuse GL_TEXTURE_VIEW_MIN_LAYER } - { reuse GL_TEXTURE_VIEW_NUM_LAYERS } - { reuse GL_TEXTURE_IMMUTABLE_LEVELS } - { Reuse tokens from ARB_vertex_attrib_binding } - { reuse GL_VERTEX_ATTRIB_BINDING } - { reuse GL_VERTEX_ATTRIB_RELATIVE_OFFSET } - { reuse GL_VERTEX_BINDING_DIVISOR } - { reuse GL_VERTEX_BINDING_OFFSET } - { reuse GL_VERTEX_BINDING_STRIDE } - { reuse GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET } - { reuse GL_MAX_VERTEX_ATTRIB_BINDINGS } - - - // GL_3DFX_multisample - GL_MULTISAMPLE_3DFX = $86B2; - GL_SAMPLE_BUFFERS_3DFX = $86B3; - GL_SAMPLES_3DFX = $86B4; - GL_MULTISAMPLE_BIT_3DFX = $20000000; - - // GL_3DFX_texture_compression_FXT1 - GL_COMPRESSED_RGB_FXT1_3DFX = $86B0; - GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1; - - // GL_APPLE_client_storage - GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2; - - // GL_APPLE_element_array - GL_ELEMENT_ARRAY_APPLE = $8A0C; - GL_ELEMENT_ARRAY_TYPE_APPLE = $8A0D; - GL_ELEMENT_ARRAY_POINTER_APPLE = $8A0E; - - // GL_APPLE_fence - GL_DRAW_PIXELS_APPLE = $8A0A; - GL_FENCE_APPLE = $8A0B; - - // GL_APPLE_specular_vector - GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0; - - // GL_APPLE_transform_hint - GL_TRANSFORM_HINT_APPLE = $85B1; - - // GL_APPLE_vertex_array_object - GL_VERTEX_ARRAY_BINDING_APPLE = $85B5; - - // GL_APPLE_vertex_array_range - GL_VERTEX_ARRAY_RANGE_APPLE = $851D; - GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E; - GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F; - GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521; - GL_STORAGE_CLIENT_APPLE = $85B4; - GL_STORAGE_CACHED_APPLE = $85BE; - GL_STORAGE_SHARED_APPLE = $85BF; - - // GL_APPLE_ycbcr_422 - GL_YCBCR_422_APPLE = $85B9; - GL_UNSIGNED_SHORT_8_8_APPLE = $85BA; - GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB; - - // GL_APPLE_texture_range - GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7; - GL_TEXTURE_RANGE_POINTER_APPLE = $85B8; - GL_TEXTURE_STORAGE_HINT_APPLE = $85BC; - GL_STORAGE_PRIVATE_APPLE = $85BD; - { reuse GL_STORAGE_CACHED_APPLE } - { reuse GL_STORAGE_SHARED_APPLE } - - // GL_APPLE_float_pixels - GL_HALF_APPLE = $140B; - GL_RGBA_FLOAT32_APPLE = $8814; - GL_RGB_FLOAT32_APPLE = $8815; - GL_ALPHA_FLOAT32_APPLE = $8816; - GL_INTENSITY_FLOAT32_APPLE = $8817; - GL_LUMINANCE_FLOAT32_APPLE = $8818; - GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819; - GL_RGBA_FLOAT16_APPLE = $881A; - GL_RGB_FLOAT16_APPLE = $881B; - GL_ALPHA_FLOAT16_APPLE = $881C; - GL_INTENSITY_FLOAT16_APPLE = $881D; - GL_LUMINANCE_FLOAT16_APPLE = $881E; - GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F; - GL_COLOR_FLOAT_APPLE = $8A0F; - - // GL_APPLE_vertex_program_evaluators - GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00; - GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01; - GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02; - GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03; - GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04; - GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05; - GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06; - GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07; - GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08; - GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09; - - // GL_APPLE_aux_depth_stencil - GL_AUX_DEPTH_STENCIL_APPLE = $8A14; - - // GL_APPLE_object_purgeable - GL_BUFFER_OBJECT_APPLE = $85B3; - GL_RELEASED_APPLE = $8A19; - GL_VOLATILE_APPLE = $8A1A; - GL_RETAINED_APPLE = $8A1B; - GL_UNDEFINED_APPLE = $8A1C; - GL_PURGEABLE_APPLE = $8A1D; - - // GL_APPLE_row_bytes - GL_PACK_ROW_BYTES_APPLE = $8A15; - GL_UNPACK_ROW_BYTES_APPLE = $8A16; - - // GL_APPLE_rgb_422 - { reuse GL_UNSIGNED_SHORT_8_8_APPLE } - { reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE } - - // GL_ARB_depth_texture - GL_DEPTH_COMPONENT16_ARB = $81A5; - GL_DEPTH_COMPONENT24_ARB = $81A6; - GL_DEPTH_COMPONENT32_ARB = $81A7; - GL_TEXTURE_DEPTH_SIZE_ARB = $884A; - GL_DEPTH_TEXTURE_MODE_ARB = $884B; - - // GL_ARB_fragment_program - GL_FRAGMENT_PROGRAM_ARB = $8804; - GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805; - GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806; - GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807; - GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808; - GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809; - GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A; - GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B; - GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C; - GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D; - GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E; - GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F; - GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810; - GL_MAX_TEXTURE_COORDS_ARB = $8871; - GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872; - - // GL_ARB_imaging - GL_CONSTANT_COLOR_ARB = $8001; - GL_CONSTANT_COLOR = $8001; - GL_ONE_MINUS_CONSTANT_COLOR = $8002; - GL_CONSTANT_ALPHA = $8003; - GL_ONE_MINUS_CONSTANT_ALPHA = $8004; - GL_BLEND_COLOR = $8005; - GL_FUNC_ADD = $8006; - GL_MIN = $8007; - GL_MAX = $8008; - GL_BLEND_EQUATION = $8009; - GL_FUNC_SUBTRACT = $800A; - GL_FUNC_REVERSE_SUBTRACT = $800B; -{$ifdef DGL_DEPRECATED} - GL_CONVOLUTION_1D = $8010; - GL_CONVOLUTION_2D = $8011; - GL_SEPARABLE_2D = $8012; - GL_CONVOLUTION_BORDER_MODE = $8013; - GL_CONVOLUTION_FILTER_SCALE = $8014; - GL_CONVOLUTION_FILTER_BIAS = $8015; - GL_REDUCE = $8016; - GL_CONVOLUTION_FORMAT = $8017; - GL_CONVOLUTION_WIDTH = $8018; - GL_CONVOLUTION_HEIGHT = $8019; - GL_MAX_CONVOLUTION_WIDTH = $801A; - GL_MAX_CONVOLUTION_HEIGHT = $801B; - GL_POST_CONVOLUTION_RED_SCALE = $801C; - GL_POST_CONVOLUTION_GREEN_SCALE = $801D; - GL_POST_CONVOLUTION_BLUE_SCALE = $801E; - GL_POST_CONVOLUTION_ALPHA_SCALE = $801F; - GL_POST_CONVOLUTION_RED_BIAS = $8020; - GL_POST_CONVOLUTION_GREEN_BIAS = $8021; - GL_POST_CONVOLUTION_BLUE_BIAS = $8022; - GL_POST_CONVOLUTION_ALPHA_BIAS = $8023; - GL_HISTOGRAM = $8024; - GL_PROXY_HISTOGRAM = $8025; - GL_HISTOGRAM_WIDTH = $8026; - GL_HISTOGRAM_FORMAT = $8027; - GL_HISTOGRAM_RED_SIZE = $8028; - GL_HISTOGRAM_GREEN_SIZE = $8029; - GL_HISTOGRAM_BLUE_SIZE = $802A; - GL_HISTOGRAM_ALPHA_SIZE = $802B; - GL_HISTOGRAM_LUMINANCE_SIZE = $802C; - GL_HISTOGRAM_SINK = $802D; - GL_MINMAX = $802E; - GL_MINMAX_FORMAT = $802F; - GL_MINMAX_SINK = $8030; - GL_TABLE_TOO_LARGE = $8031; - GL_COLOR_MATRIX = $80B1; - GL_COLOR_MATRIX_STACK_DEPTH = $80B2; - GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3; - GL_POST_COLOR_MATRIX_RED_SCALE = $80B4; - GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5; - GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6; - GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7; - GL_POST_COLOR_MATRIX_RED_BIAS = $80B8; - GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9; - GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA; - GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB; - GL_COLOR_TABLE = $80D0; - GL_POST_CONVOLUTION_COLOR_TABLE = $80D1; - GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2; - GL_PROXY_COLOR_TABLE = $80D3; - GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4; - GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5; - GL_COLOR_TABLE_SCALE = $80D6; - GL_COLOR_TABLE_BIAS = $80D7; - GL_COLOR_TABLE_FORMAT = $80D8; - GL_COLOR_TABLE_WIDTH = $80D9; - GL_COLOR_TABLE_RED_SIZE = $80DA; - GL_COLOR_TABLE_GREEN_SIZE = $80DB; - GL_COLOR_TABLE_BLUE_SIZE = $80DC; - GL_COLOR_TABLE_ALPHA_SIZE = $80DD; - GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE; - GL_COLOR_TABLE_INTENSITY_SIZE = $80DF; - GL_CONSTANT_BORDER = $8151; - GL_REPLICATE_BORDER = $8153; - GL_CONVOLUTION_BORDER_COLOR = $8154; -{$endif} - - // GL_ARB_matrix_palette - GL_MATRIX_PALETTE_ARB = $8840; - GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841; - GL_MAX_PALETTE_MATRICES_ARB = $8842; - GL_CURRENT_PALETTE_MATRIX_ARB = $8843; - GL_MATRIX_INDEX_ARRAY_ARB = $8844; - GL_CURRENT_MATRIX_INDEX_ARB = $8845; - GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846; - GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847; - GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848; - GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849; - - // GL_ARB_multisample - GL_MULTISAMPLE_ARB = $809D; - GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E; - GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F; - GL_SAMPLE_COVERAGE_ARB = $80A0; - GL_SAMPLE_BUFFERS_ARB = $80A8; - GL_SAMPLES_ARB = $80A9; - GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA; - GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB; - GL_MULTISAMPLE_BIT_ARB = $20000000; - - // GL_ARB_multitexture - GL_TEXTURE0_ARB = $84C0; - GL_TEXTURE1_ARB = $84C1; - GL_TEXTURE2_ARB = $84C2; - GL_TEXTURE3_ARB = $84C3; - GL_TEXTURE4_ARB = $84C4; - GL_TEXTURE5_ARB = $84C5; - GL_TEXTURE6_ARB = $84C6; - GL_TEXTURE7_ARB = $84C7; - GL_TEXTURE8_ARB = $84C8; - GL_TEXTURE9_ARB = $84C9; - GL_TEXTURE10_ARB = $84CA; - GL_TEXTURE11_ARB = $84CB; - GL_TEXTURE12_ARB = $84CC; - GL_TEXTURE13_ARB = $84CD; - GL_TEXTURE14_ARB = $84CE; - GL_TEXTURE15_ARB = $84CF; - GL_TEXTURE16_ARB = $84D0; - GL_TEXTURE17_ARB = $84D1; - GL_TEXTURE18_ARB = $84D2; - GL_TEXTURE19_ARB = $84D3; - GL_TEXTURE20_ARB = $84D4; - GL_TEXTURE21_ARB = $84D5; - GL_TEXTURE22_ARB = $84D6; - GL_TEXTURE23_ARB = $84D7; - GL_TEXTURE24_ARB = $84D8; - GL_TEXTURE25_ARB = $84D9; - GL_TEXTURE26_ARB = $84DA; - GL_TEXTURE27_ARB = $84DB; - GL_TEXTURE28_ARB = $84DC; - GL_TEXTURE29_ARB = $84DD; - GL_TEXTURE30_ARB = $84DE; - GL_TEXTURE31_ARB = $84DF; - GL_ACTIVE_TEXTURE_ARB = $84E0; - GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1; - GL_MAX_TEXTURE_UNITS_ARB = $84E2; - - // GL_ARB_point_parameters - GL_POINT_SIZE_MIN_ARB = $8126; - GL_POINT_SIZE_MAX_ARB = $8127; - GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128; - GL_POINT_DISTANCE_ATTENUATION_ARB = $8129; - - // GL_ARB_shadow - GL_TEXTURE_COMPARE_MODE_ARB = $884C; - GL_TEXTURE_COMPARE_FUNC_ARB = $884D; - GL_COMPARE_R_TO_TEXTURE_ARB = $884E; - - // GL_ARB_shadow_ambient - GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF; - - // GL_ARB_texture_border_clamp - GL_CLAMP_TO_BORDER_ARB = $812D; - - // GL_ARB_texture_compression - GL_COMPRESSED_ALPHA_ARB = $84E9; - GL_COMPRESSED_LUMINANCE_ARB = $84EA; - GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB; - GL_COMPRESSED_INTENSITY_ARB = $84EC; - GL_COMPRESSED_RGB_ARB = $84ED; - GL_COMPRESSED_RGBA_ARB = $84EE; - GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF; - GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0; - GL_TEXTURE_COMPRESSED_ARB = $86A1; - GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2; - GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3; - - // GL_ARB_texture_cube_map - GL_NORMAL_MAP_ARB = $8511; - GL_REFLECTION_MAP_ARB = $8512; - GL_TEXTURE_CUBE_MAP_ARB = $8513; - GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514; - GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515; - GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516; - GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518; - GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A; - GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B; - GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C; - - // GL_ARB_texture_env_combine - GL_COMBINE_ARB = $8570; - GL_COMBINE_RGB_ARB = $8571; - GL_COMBINE_ALPHA_ARB = $8572; - GL_SOURCE0_RGB_ARB = $8580; - GL_SOURCE1_RGB_ARB = $8581; - GL_SOURCE2_RGB_ARB = $8582; - GL_SOURCE0_ALPHA_ARB = $8588; - GL_SOURCE1_ALPHA_ARB = $8589; - GL_SOURCE2_ALPHA_ARB = $858A; - GL_OPERAND0_RGB_ARB = $8590; - GL_OPERAND1_RGB_ARB = $8591; - GL_OPERAND2_RGB_ARB = $8592; - GL_OPERAND0_ALPHA_ARB = $8598; - GL_OPERAND1_ALPHA_ARB = $8599; - GL_OPERAND2_ALPHA_ARB = $859A; - GL_RGB_SCALE_ARB = $8573; - GL_ADD_SIGNED_ARB = $8574; - GL_INTERPOLATE_ARB = $8575; - GL_SUBTRACT_ARB = $84E7; - GL_CONSTANT_ARB = $8576; - GL_PRIMARY_COLOR_ARB = $8577; - GL_PREVIOUS_ARB = $8578; - - // GL_ARB_texture_env_dot3 - GL_DOT3_RGB_ARB = $86AE; - GL_DOT3_RGBA_ARB = $86AF; - - // GL_ARB_texture_mirrored_repeat - GL_MIRRORED_REPEAT_ARB = $8370; - - // GL_ARB_transpose_matrix - GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3; - GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4; - GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5; - GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6; - - // GL_ARB_vertex_blend - GL_MAX_VERTEX_UNITS_ARB = $86A4; - GL_ACTIVE_VERTEX_UNITS_ARB = $86A5; - GL_WEIGHT_SUM_UNITY_ARB = $86A6; - GL_VERTEX_BLEND_ARB = $86A7; - GL_CURRENT_WEIGHT_ARB = $86A8; - GL_WEIGHT_ARRAY_TYPE_ARB = $86A9; - GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA; - GL_WEIGHT_ARRAY_SIZE_ARB = $86AB; - GL_WEIGHT_ARRAY_POINTER_ARB = $86AC; - GL_WEIGHT_ARRAY_ARB = $86AD; - GL_MODELVIEW0_ARB = $1700; - GL_MODELVIEW1_ARB = $850A; - GL_MODELVIEW2_ARB = $8722; - GL_MODELVIEW3_ARB = $8723; - GL_MODELVIEW4_ARB = $8724; - GL_MODELVIEW5_ARB = $8725; - GL_MODELVIEW6_ARB = $8726; - GL_MODELVIEW7_ARB = $8727; - GL_MODELVIEW8_ARB = $8728; - GL_MODELVIEW9_ARB = $8729; - GL_MODELVIEW10_ARB = $872A; - GL_MODELVIEW11_ARB = $872B; - GL_MODELVIEW12_ARB = $872C; - GL_MODELVIEW13_ARB = $872D; - GL_MODELVIEW14_ARB = $872E; - GL_MODELVIEW15_ARB = $872F; - GL_MODELVIEW16_ARB = $8730; - GL_MODELVIEW17_ARB = $8731; - GL_MODELVIEW18_ARB = $8732; - GL_MODELVIEW19_ARB = $8733; - GL_MODELVIEW20_ARB = $8734; - GL_MODELVIEW21_ARB = $8735; - GL_MODELVIEW22_ARB = $8736; - GL_MODELVIEW23_ARB = $8737; - GL_MODELVIEW24_ARB = $8738; - GL_MODELVIEW25_ARB = $8739; - GL_MODELVIEW26_ARB = $873A; - GL_MODELVIEW27_ARB = $873B; - GL_MODELVIEW28_ARB = $873C; - GL_MODELVIEW29_ARB = $873D; - GL_MODELVIEW30_ARB = $873E; - GL_MODELVIEW31_ARB = $873F; - - // GL_ARB_vertex_buffer_object - GL_BUFFER_SIZE_ARB = $8764; - GL_BUFFER_USAGE_ARB = $8765; - GL_ARRAY_BUFFER_ARB = $8892; - GL_ELEMENT_ARRAY_BUFFER_ARB = $8893; - GL_ARRAY_BUFFER_BINDING_ARB = $8894; - GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895; - GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896; - GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897; - GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898; - GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899; - GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A; - GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B; - GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C; - GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D; - GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E; - GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F; - GL_READ_ONLY_ARB = $88B8; - GL_WRITE_ONLY_ARB = $88B9; - GL_READ_WRITE_ARB = $88BA; - GL_BUFFER_ACCESS_ARB = $88BB; - GL_BUFFER_MAPPED_ARB = $88BC; - GL_BUFFER_MAP_POINTER_ARB = $88BD; - GL_STREAM_DRAW_ARB = $88E0; - GL_STREAM_READ_ARB = $88E1; - GL_STREAM_COPY_ARB = $88E2; - GL_STATIC_DRAW_ARB = $88E4; - GL_STATIC_READ_ARB = $88E5; - GL_STATIC_COPY_ARB = $88E6; - GL_DYNAMIC_DRAW_ARB = $88E8; - GL_DYNAMIC_READ_ARB = $88E9; - GL_DYNAMIC_COPY_ARB = $88EA; - - // GL_ARB_vertex_program - GL_COLOR_SUM_ARB = $8458; - GL_VERTEX_PROGRAM_ARB = $8620; - GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622; - GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623; - GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624; - GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625; - GL_CURRENT_VERTEX_ATTRIB_ARB = $8626; - GL_PROGRAM_LENGTH_ARB = $8627; - GL_PROGRAM_STRING_ARB = $8628; - GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E; - GL_MAX_PROGRAM_MATRICES_ARB = $862F; - GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640; - GL_CURRENT_MATRIX_ARB = $8641; - GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642; - GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643; - GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645; - GL_PROGRAM_ERROR_POSITION_ARB = $864B; - GL_PROGRAM_BINDING_ARB = $8677; - GL_MAX_VERTEX_ATTRIBS_ARB = $8869; - GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A; - GL_PROGRAM_ERROR_STRING_ARB = $8874; - GL_PROGRAM_FORMAT_ASCII_ARB = $8875; - GL_PROGRAM_FORMAT_ARB = $8876; - GL_PROGRAM_INSTRUCTIONS_ARB = $88A0; - GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1; - GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2; - GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3; - GL_PROGRAM_TEMPORARIES_ARB = $88A4; - GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5; - GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6; - GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7; - GL_PROGRAM_PARAMETERS_ARB = $88A8; - GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9; - GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA; - GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB; - GL_PROGRAM_ATTRIBS_ARB = $88AC; - GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD; - GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE; - GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF; - GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0; - GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1; - GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2; - GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3; - GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4; - GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5; - GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6; - GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7; - GL_MATRIX0_ARB = $88C0; - GL_MATRIX1_ARB = $88C1; - GL_MATRIX2_ARB = $88C2; - GL_MATRIX3_ARB = $88C3; - GL_MATRIX4_ARB = $88C4; - GL_MATRIX5_ARB = $88C5; - GL_MATRIX6_ARB = $88C6; - GL_MATRIX7_ARB = $88C7; - GL_MATRIX8_ARB = $88C8; - GL_MATRIX9_ARB = $88C9; - GL_MATRIX10_ARB = $88CA; - GL_MATRIX11_ARB = $88CB; - GL_MATRIX12_ARB = $88CC; - GL_MATRIX13_ARB = $88CD; - GL_MATRIX14_ARB = $88CE; - GL_MATRIX15_ARB = $88CF; - GL_MATRIX16_ARB = $88D0; - GL_MATRIX17_ARB = $88D1; - GL_MATRIX18_ARB = $88D2; - GL_MATRIX19_ARB = $88D3; - GL_MATRIX20_ARB = $88D4; - GL_MATRIX21_ARB = $88D5; - GL_MATRIX22_ARB = $88D6; - GL_MATRIX23_ARB = $88D7; - GL_MATRIX24_ARB = $88D8; - GL_MATRIX25_ARB = $88D9; - GL_MATRIX26_ARB = $88DA; - GL_MATRIX27_ARB = $88DB; - GL_MATRIX28_ARB = $88DC; - GL_MATRIX29_ARB = $88DD; - GL_MATRIX30_ARB = $88DE; - GL_MATRIX31_ARB = $88DF; - - // GL_ARB_draw_buffers - GL_MAX_DRAW_BUFFERS_ARB = $8824; - GL_DRAW_BUFFER0_ARB = $8825; - GL_DRAW_BUFFER1_ARB = $8826; - GL_DRAW_BUFFER2_ARB = $8827; - GL_DRAW_BUFFER3_ARB = $8828; - GL_DRAW_BUFFER4_ARB = $8829; - GL_DRAW_BUFFER5_ARB = $882A; - GL_DRAW_BUFFER6_ARB = $882B; - GL_DRAW_BUFFER7_ARB = $882C; - GL_DRAW_BUFFER8_ARB = $882D; - GL_DRAW_BUFFER9_ARB = $882E; - GL_DRAW_BUFFER10_ARB = $882F; - GL_DRAW_BUFFER11_ARB = $8830; - GL_DRAW_BUFFER12_ARB = $8831; - GL_DRAW_BUFFER13_ARB = $8832; - GL_DRAW_BUFFER14_ARB = $8833; - GL_DRAW_BUFFER15_ARB = $8834; - - // GL_ARB_texture_rectangle - GL_TEXTURE_RECTANGLE_ARB = $84F5; - GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6; - GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7; - GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8; - - // GL_ARB_color_buffer_float - GL_RGBA_FLOAT_MODE_ARB = $8820; - GL_CLAMP_VERTEX_COLOR_ARB = $891A; - GL_CLAMP_FRAGMENT_COLOR_ARB = $891B; - GL_CLAMP_READ_COLOR_ARB = $891C; - GL_FIXED_ONLY_ARB = $891D; - WGL_TYPE_RGBA_FLOAT_ARB = $21A0; - GLX_RGBA_FLOAT_TYPE = $20B9; - GLX_RGBA_FLOAT_BIT = $00000004; - - // GL_ARB_half_float_pixel - GL_HALF_FLOAT_ARB = $140B; - - // GL_ARB_texture_float - GL_TEXTURE_RED_TYPE_ARB = $8C10; - GL_TEXTURE_GREEN_TYPE_ARB = $8C11; - GL_TEXTURE_BLUE_TYPE_ARB = $8C12; - GL_TEXTURE_ALPHA_TYPE_ARB = $8C13; - GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14; - GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15; - GL_TEXTURE_DEPTH_TYPE_ARB = $8C16; - GL_UNSIGNED_NORMALIZED_ARB = $8C17; - GL_RGBA32F_ARB = $8814; - GL_RGB32F_ARB = $8815; - GL_ALPHA32F_ARB = $8816; - GL_INTENSITY32F_ARB = $8817; - GL_LUMINANCE32F_ARB = $8818; - GL_LUMINANCE_ALPHA32F_ARB = $8819; - GL_RGBA16F_ARB = $881A; - GL_RGB16F_ARB = $881B; - GL_ALPHA16F_ARB = $881C; - GL_INTENSITY16F_ARB = $881D; - GL_LUMINANCE16F_ARB = $881E; - GL_LUMINANCE_ALPHA16F_ARB = $881F; - - // GL_ARB_pixel_buffer_object - GL_PIXEL_PACK_BUFFER_ARB = $88EB; - GL_PIXEL_UNPACK_BUFFER_ARB = $88EC; - GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED; - GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF; - - // GL_ARB_depth_buffer_float - GL_DEPTH_COMPONENT32F = $8CAC; - GL_DEPTH32F_STENCIL8 = $8CAD; - GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD; - - // GL_ARB_framebuffer_object - GL_INVALID_FRAMEBUFFER_OPERATION = $0506; - GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210; - GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211; - GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212; - GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213; - GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214; - GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215; - GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216; - GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217; - GL_FRAMEBUFFER_DEFAULT = $8218; - GL_FRAMEBUFFER_UNDEFINED = $8219; - GL_DEPTH_STENCIL_ATTACHMENT = $821A; - GL_MAX_RENDERBUFFER_SIZE = $84E8; - GL_DEPTH_STENCIL = $84F9; - GL_UNSIGNED_INT_24_8 = $84FA; - GL_DEPTH24_STENCIL8 = $88F0; - GL_TEXTURE_STENCIL_SIZE = $88F1; - GL_TEXTURE_RED_TYPE = $8C10; - GL_TEXTURE_GREEN_TYPE = $8C11; - GL_TEXTURE_BLUE_TYPE = $8C12; - GL_TEXTURE_ALPHA_TYPE = $8C13; - GL_TEXTURE_DEPTH_TYPE = $8C16; - GL_UNSIGNED_NORMALIZED = $8C17; - GL_FRAMEBUFFER_BINDING = $8CA6; - GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING; - GL_RENDERBUFFER_BINDING = $8CA7; - GL_READ_FRAMEBUFFER = $8CA8; - GL_DRAW_FRAMEBUFFER = $8CA9; - GL_READ_FRAMEBUFFER_BINDING = $8CAA; - GL_RENDERBUFFER_SAMPLES = $8CAB; - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0; - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4; - GL_FRAMEBUFFER_COMPLETE = $8CD5; - GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6; - GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7; - GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB; - GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC; - GL_FRAMEBUFFER_UNSUPPORTED = $8CDD; - GL_MAX_COLOR_ATTACHMENTS = $8CDF; - GL_COLOR_ATTACHMENT0 = $8CE0; - GL_COLOR_ATTACHMENT1 = $8CE1; - GL_COLOR_ATTACHMENT2 = $8CE2; - GL_COLOR_ATTACHMENT3 = $8CE3; - GL_COLOR_ATTACHMENT4 = $8CE4; - GL_COLOR_ATTACHMENT5 = $8CE5; - GL_COLOR_ATTACHMENT6 = $8CE6; - GL_COLOR_ATTACHMENT7 = $8CE7; - GL_COLOR_ATTACHMENT8 = $8CE8; - GL_COLOR_ATTACHMENT9 = $8CE9; - GL_COLOR_ATTACHMENT10 = $8CEA; - GL_COLOR_ATTACHMENT11 = $8CEB; - GL_COLOR_ATTACHMENT12 = $8CEC; - GL_COLOR_ATTACHMENT13 = $8CED; - GL_COLOR_ATTACHMENT14 = $8CEE; - GL_COLOR_ATTACHMENT15 = $8CEF; - GL_DEPTH_ATTACHMENT = $8D00; - GL_STENCIL_ATTACHMENT = $8D20; - GL_FRAMEBUFFER = $8D40; - GL_RENDERBUFFER = $8D41; - GL_RENDERBUFFER_WIDTH = $8D42; - GL_RENDERBUFFER_HEIGHT = $8D43; - GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44; - GL_STENCIL_INDEX1 = $8D46; - GL_STENCIL_INDEX4 = $8D47; - GL_STENCIL_INDEX8 = $8D48; - GL_STENCIL_INDEX16 = $8D49; - GL_RENDERBUFFER_RED_SIZE = $8D50; - GL_RENDERBUFFER_GREEN_SIZE = $8D51; - GL_RENDERBUFFER_BLUE_SIZE = $8D52; - GL_RENDERBUFFER_ALPHA_SIZE = $8D53; - GL_RENDERBUFFER_DEPTH_SIZE = $8D54; - GL_RENDERBUFFER_STENCIL_SIZE = $8D55; - GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56; - GL_MAX_SAMPLES = $8D57; -{$ifdef DGL_DEPRECATED} - GL_INDEX = $8222; - GL_TEXTURE_LUMINANCE_TYPE = $8C14; - GL_TEXTURE_INTENSITY_TYPE = $8C15; -{$endif} - - // GL_ARB_framebuffer_sRGB - GL_FRAMEBUFFER_SRGB = $8DB9; - - // GL_ARB_geometry_shader4 - GL_LINES_ADJACENCY_ARB = $000A; - GL_LINE_STRIP_ADJACENCY_ARB = $000B; - GL_TRIANGLES_ADJACENCY_ARB = $000C; - GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D; - GL_PROGRAM_POINT_SIZE_ARB = $8642; - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29; - GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7; - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8; - GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9; - GL_GEOMETRY_SHADER_ARB = $8DD9; - GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA; - GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB; - GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC; - GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD; - GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE; - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF; - GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0; - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1; - { reuse GL_MAX_VARYING_COMPONENTS } - { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER } - - // GL_ARB_half_float_vertex - GL_HALF_FLOAT = $140B; - - // GL_ARB_instanced_arrays - GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE; - - // GL_ARB_map_buffer_range - GL_MAP_READ_BIT = $0001; - GL_MAP_WRITE_BIT = $0002; - GL_MAP_INVALIDATE_RANGE_BIT = $0004; - GL_MAP_INVALIDATE_BUFFER_BIT = $0008; - GL_MAP_FLUSH_EXPLICIT_BIT = $0010; - GL_MAP_UNSYNCHRONIZED_BIT = $0020; - - // GL_ARB_texture_buffer_object - GL_TEXTURE_BUFFER_ARB = $8C2A; - GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B; - GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C; - GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D; - GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E; - - // GL_ARB_texture_compression_rgtc - GL_COMPRESSED_RED_RGTC1 = $8DBB; - GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC; - GL_COMPRESSED_RG_RGTC2 = $8DBD; - GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE; - - // GL_ARB_texture_rg - GL_RG = $8227; - GL_RG_INTEGER = $8228; - GL_R8 = $8229; - GL_R16 = $822A; - GL_RG8 = $822B; - GL_RG16 = $822C; - GL_R16F = $822D; - GL_R32F = $822E; - GL_RG16F = $822F; - GL_RG32F = $8230; - GL_R8I = $8231; - GL_R8UI = $8232; - GL_R16I = $8233; - GL_R16UI = $8234; - GL_R32I = $8235; - GL_R32UI = $8236; - GL_RG8I = $8237; - GL_RG8UI = $8238; - GL_RG16I = $8239; - GL_RG16UI = $823A; - GL_RG32I = $823B; - GL_RG32UI = $823C; - - // GL_ARB_vertex_array_object - GL_VERTEX_ARRAY_BINDING = $85B5; - - // GL_ARB_uniform_buffer_object - GL_UNIFORM_BUFFER = $8A11; - GL_UNIFORM_BUFFER_BINDING = $8A28; - GL_UNIFORM_BUFFER_START = $8A29; - GL_UNIFORM_BUFFER_SIZE = $8A2A; - GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B; - GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C; - GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D; - GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E; - GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F; - GL_MAX_UNIFORM_BLOCK_SIZE = $8A30; - GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31; - GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32; - GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33; - GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34; - GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35; - GL_ACTIVE_UNIFORM_BLOCKS = $8A36; - GL_UNIFORM_TYPE = $8A37; - GL_UNIFORM_SIZE = $8A38; - GL_UNIFORM_NAME_LENGTH = $8A39; - GL_UNIFORM_BLOCK_INDEX = $8A3A; - GL_UNIFORM_OFFSET = $8A3B; - GL_UNIFORM_ARRAY_STRIDE = $8A3C; - GL_UNIFORM_MATRIX_STRIDE = $8A3D; - GL_UNIFORM_IS_ROW_MAJOR = $8A3E; - GL_UNIFORM_BLOCK_BINDING = $8A3F; - GL_UNIFORM_BLOCK_DATA_SIZE = $8A40; - GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41; - GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42; - GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43; - GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44; - GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = $8A45; - GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46; - GL_INVALID_INDEX = $FFFFFFFF; - - // GL_ARB_compatibility - { ARB_compatibility just defines tokens from core 3.0 } - - // GL_ARB_copy_buffer - GL_COPY_READ_BUFFER_BINDING = $8F36; - GL_COPY_READ_BUFFER = GL_COPY_READ_BUFFER_BINDING; - GL_COPY_WRITE_BUFFER_BINDING = $8F37; - GL_COPY_WRITE_BUFFER = GL_COPY_WRITE_BUFFER_BINDING; - - // GL_ARB_depth_clamp - GL_DEPTH_CLAMP = $864F; - - // GL_ARB_provoking_vertex - GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C; - GL_FIRST_VERTEX_CONVENTION = $8E4D; - GL_LAST_VERTEX_CONVENTION = $8E4E; - GL_PROVOKING_VERTEX = $8E4F; - - // GL_ARB_seamless_cube_map - GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F; - - // GL_ARB_sync - GL_MAX_SERVER_WAIT_TIMEOUT = $9111; - GL_OBJECT_TYPE = $9112; - GL_SYNC_CONDITION = $9113; - GL_SYNC_STATUS = $9114; - GL_SYNC_FLAGS = $9115; - GL_SYNC_FENCE = $9116; - GL_SYNC_GPU_COMMANDS_COMPLETE = $9117; - GL_UNSIGNALED = $9118; - GL_SIGNALED = $9119; - GL_ALREADY_SIGNALED = $911A; - GL_TIMEOUT_EXPIRED = $911B; - GL_CONDITION_SATISFIED = $911C; - GL_WAIT_FAILED = $911D; - GL_SYNC_FLUSH_COMMANDS_BIT = $00000001; - GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF; - - // GL_ARB_texture_multisample - GL_SAMPLE_POSITION = $8E50; - GL_SAMPLE_MASK = $8E51; - GL_SAMPLE_MASK_VALUE = $8E52; - GL_MAX_SAMPLE_MASK_WORDS = $8E59; - GL_TEXTURE_2D_MULTISAMPLE = $9100; - GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101; - GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102; - GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103; - GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104; - GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105; - GL_TEXTURE_SAMPLES = $9106; - GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107; - GL_SAMPLER_2D_MULTISAMPLE = $9108; - GL_INT_SAMPLER_2D_MULTISAMPLE = $9109; - GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A; - GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B; - GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C; - GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D; - GL_MAX_COLOR_TEXTURE_SAMPLES = $910E; - GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F; - GL_MAX_INTEGER_SAMPLES = $9110; - - // GL_ARB_vertex_array_bgra - { reuse GL_BGRA } - - // GL_ARB_sample_shading - GL_SAMPLE_SHADING_ARB = $8C36; - GL_MIN_SAMPLE_SHADING_VALUE_ARB = $8C37; - - // GL_ARB_texture_cube_map_array - GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009; - GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A; - GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B; - GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C; - GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D; - GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E; - GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F; - - // GL_ARB_texture_gather - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E; - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F; - - // GL_ARB_shading_language_include - GL_SHADER_INCLUDE_ARB = $8DAE; - GL_NAMED_STRING_LENGTH_ARB = $8DE9; - GL_NAMED_STRING_TYPE_ARB = $8DEA; - - // GL_ARB_texture_compression_bptc - GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C; - GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D; - GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E; - GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F; - - // GL_ARB_blend_func_extended - GL_SRC1_COLOR = $88F9; - { reuse GL_SRC1_ALPHA } - GL_ONE_MINUS_SRC1_COLOR = $88FA; - GL_ONE_MINUS_SRC1_ALPHA = $88FB; - GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC; - - // GL_ARB_occlusion_query2 - GL_ANY_SAMPLES_PASSED = $8C2F; - - // GL_ARB_sampler_objects - GL_SAMPLER_BINDING = $8919; - - // GL_ARB_texture_rgb10_a2ui - GL_RGB10_A2UI = $906F; - - // GL_ARB_texture_swizzle - GL_TEXTURE_SWIZZLE_R = $8E42; - GL_TEXTURE_SWIZZLE_G = $8E43; - GL_TEXTURE_SWIZZLE_B = $8E44; - GL_TEXTURE_SWIZZLE_A = $8E45; - GL_TEXTURE_SWIZZLE_RGBA = $8E46; - - // GL_ARB_timer_query - GL_TIME_ELAPSED = $88BF; - GL_TIMESTAMP = $8E28; - - // GL_ARB_vertex_type_2_10_10_10_rev - { reuse GL_UNSIGNED_INT_2_10_10_10_REV } - GL_INT_2_10_10_10_REV = $8D9F; - - // GL_ARB_draw_indirect - GL_DRAW_INDIRECT_BUFFER = $8F3F; - GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43; - - // GL_ARB_gpu_shader5 - GL_GEOMETRY_SHADER_INVOCATIONS = $887F; - GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A; - GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B; - GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C; - GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D; - { reuse GL_MAX_VERTEX_STREAMS } - - // GL_ARB_gpu_shader_fp64 - { reuse GL_DOUBLE } - GL_DOUBLE_VEC2 = $8FFC; - GL_DOUBLE_VEC3 = $8FFD; - GL_DOUBLE_VEC4 = $8FFE; - GL_DOUBLE_MAT2 = $8F46; - GL_DOUBLE_MAT3 = $8F47; - GL_DOUBLE_MAT4 = $8F48; - GL_DOUBLE_MAT2x3 = $8F49; - GL_DOUBLE_MAT2x4 = $8F4A; - GL_DOUBLE_MAT3x2 = $8F4B; - GL_DOUBLE_MAT3x4 = $8F4C; - GL_DOUBLE_MAT4x2 = $8F4D; - GL_DOUBLE_MAT4x3 = $8F4E; - - // GL_ARB_shader_subroutine - GL_ACTIVE_SUBROUTINES = $8DE5; - GL_ACTIVE_SUBROUTINE_UNIFORMS = $8DE6; - GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = $8E47; - GL_ACTIVE_SUBROUTINE_MAX_LENGTH = $8E48; - GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = $8E49; - GL_MAX_SUBROUTINES = $8DE7; - GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = $8DE8; - GL_NUM_COMPATIBLE_SUBROUTINES = $8E4A; - GL_COMPATIBLE_SUBROUTINES = $8E4B; - { reuse GL_UNIFORM_SIZE } - { reuse GL_UNIFORM_NAME_LENGTH } - - // GL_ARB_tessellation_shader - GL_PATCHES = $000E; - GL_PATCH_VERTICES = $8E72; - GL_PATCH_DEFAULT_INNER_LEVEL = $8E73; - GL_PATCH_DEFAULT_OUTER_LEVEL = $8E74; - GL_TESS_CONTROL_OUTPUT_VERTICES = $8E75; - GL_TESS_GEN_MODE = $8E76; - GL_TESS_GEN_SPACING = $8E77; - GL_TESS_GEN_VERTEX_ORDER = $8E78; - GL_TESS_GEN_POINT_MODE = $8E79; - { reuse GL_TRIANGLES } - { reuse GL_QUADS } - GL_ISOLINES = $8E7A; - { reuse GL_EQUAL } - GL_FRACTIONAL_ODD = $8E7B; - GL_FRACTIONAL_EVEN = $8E7C; - { reuse GL_CCW } - { reuse GL_CW } - GL_MAX_PATCH_VERTICES = $8E7D; - GL_MAX_TESS_GEN_LEVEL = $8E7E; - GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = $8E7F; - GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E80; - GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = $8E81; - GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = $8E82; - GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = $8E83; - GL_MAX_TESS_PATCH_COMPONENTS = $8E84; - GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = $8E85; - GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = $8E86; - GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = $8E89; - GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = $8E8A; - GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = $886C; - GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = $886D; - GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = $8E1E; - GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E1F; - GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = $84F0; - GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = $84F1; - GL_TESS_EVALUATION_SHADER = $8E87; - GL_TESS_CONTROL_SHADER = $8E88; - - // GL_ARB_texture_buffer_object_rgb32 - { reuse GL_RGB32F } - { reuse GL_RGB32UI } - { reuse GL_RGB32I } - - // GL_ARB_transform_feedback2 - GL_TRANSFORM_FEEDBACK = $8E22; - GL_TRANSFORM_FEEDBACK_PAUSED = $8E23; - GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = GL_TRANSFORM_FEEDBACK_PAUSED; - GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24; - GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = GL_TRANSFORM_FEEDBACK_ACTIVE; - GL_TRANSFORM_FEEDBACK_BINDING = $8E25; - - // GL_ARB_transform_feedback3 - GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = $8E70; - GL_MAX_VERTEX_STREAMS = $8E71; - - // GL_ARB_ES2_compatibility - GL_FIXED = $140C; - GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A; - GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B; - GL_LOW_FLOAT = $8DF0; - GL_MEDIUM_FLOAT = $8DF1; - GL_HIGH_FLOAT = $8DF2; - GL_LOW_INT = $8DF3; - GL_MEDIUM_INT = $8DF4; - GL_HIGH_INT = $8DF5; - GL_SHADER_COMPILER = $8DFA; - GL_NUM_SHADER_BINARY_FORMATS = $8DF9; - GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB; - GL_MAX_VARYING_VECTORS = $8DFC; - GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD; - GL_RGB565 = $8D62; - - // GL_ARB_get_program_binary - GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257; - GL_PROGRAM_BINARY_LENGTH = $8741; - GL_NUM_PROGRAM_BINARY_FORMATS = $87FE; - GL_PROGRAM_BINARY_FORMATS = $87FF; - - // GL_ARB_separate_shader_objects - GL_VERTEX_SHADER_BIT = $00000001; - GL_FRAGMENT_SHADER_BIT = $00000002; - GL_GEOMETRY_SHADER_BIT = $00000004; - GL_TESS_CONTROL_SHADER_BIT = $00000008; - GL_TESS_EVALUATION_SHADER_BIT = $00000010; - GL_ALL_SHADER_BITS = $FFFFFFFF; - GL_PROGRAM_SEPARABLE = $8258; - GL_ACTIVE_PROGRAM = $8259; - GL_PROGRAM_PIPELINE_BINDING = $825A; - - // GL_ARB_vertex_attrib_64bit - { reuse GL_RGB32I } - { reuse GL_DOUBLE_VEC2 } - { reuse GL_DOUBLE_VEC3 } - { reuse GL_DOUBLE_VEC4 } - { reuse GL_DOUBLE_MAT2 } - { reuse GL_DOUBLE_MAT3 } - { reuse GL_DOUBLE_MAT4 } - { reuse GL_DOUBLE_MAT2x3 } - { reuse GL_DOUBLE_MAT2x4 } - { reuse GL_DOUBLE_MAT3x2 } - { reuse GL_DOUBLE_MAT3x4 } - { reuse GL_DOUBLE_MAT4x2 } - { reuse GL_DOUBLE_MAT4x3 } - - // GL_ARB_viewport_array - { reuse GL_SCISSOR_BOX } - { reuse GL_VIEWPORT } - { reuse GL_DEPTH_RANGE } - { reuse GL_SCISSOR_TEST } - GL_MAX_VIEWPORTS = $825B; - GL_VIEWPORT_SUBPIXEL_BITS = $825C; - GL_VIEWPORT_BOUNDS_RANGE = $825D; - GL_LAYER_PROVOKING_VERTEX = $825E; - GL_VIEWPORT_INDEX_PROVOKING_VERTEX = $825F; - GL_UNDEFINED_VERTEX = $8260; - { reuse GL_FIRST_VERTEX_CONVENTION } - { reuse GL_LAST_VERTEX_CONVENTION } - { reuse GL_PROVOKING_VERTEX } - - // GL_ARB_cl_event - GL_SYNC_CL_EVENT_ARB = $8240; - GL_SYNC_CL_EVENT_COMPLETE_ARB = $8241; - - // GL_ARB_debug_output - GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = $8242; - GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = $8243; - GL_DEBUG_CALLBACK_FUNCTION_ARB = $8244; - GL_DEBUG_CALLBACK_USER_PARAM_ARB = $8245; - GL_DEBUG_SOURCE_API_ARB = $8246; - GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = $8247; - GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = $8248; - GL_DEBUG_SOURCE_THIRD_PARTY_ARB = $8249; - GL_DEBUG_SOURCE_APPLICATION_ARB = $824A; - GL_DEBUG_SOURCE_OTHER_ARB = $824B; - GL_DEBUG_TYPE_ERROR_ARB = $824C; - GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = $824D; - GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = $824E; - GL_DEBUG_TYPE_PORTABILITY_ARB = $824F; - GL_DEBUG_TYPE_PERFORMANCE_ARB = $8250; - GL_DEBUG_TYPE_OTHER_ARB = $8251; - GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = $9143; - GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = $9144; - GL_DEBUG_LOGGED_MESSAGES_ARB = $9145; - GL_DEBUG_SEVERITY_HIGH_ARB = $9146; - GL_DEBUG_SEVERITY_MEDIUM_ARB = $9147; - GL_DEBUG_SEVERITY_LOW_ARB = $9148; - - // GL_ARB_robustness - { reuse GL_NO_ERROR } - GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = $00000004; - GL_LOSE_CONTEXT_ON_RESET_ARB = $8252; - GL_GUILTY_CONTEXT_RESET_ARB = $8253; - GL_INNOCENT_CONTEXT_RESET_ARB = $8254; - GL_UNKNOWN_CONTEXT_RESET_ARB = $8255; - GL_RESET_NOTIFICATION_STRATEGY_ARB = $8256; - GL_NO_RESET_NOTIFICATION_ARB = $8261; - - // GL_ARB_compressed_texture_pixel_storage - GL_UNPACK_COMPRESSED_BLOCK_WIDTH = $09127; - GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = $09128; - GL_UNPACK_COMPRESSED_BLOCK_DEPTH = $09129; - GL_UNPACK_COMPRESSED_BLOCK_SIZE = $0912A; - GL_PACK_COMPRESSED_BLOCK_WIDTH = $0912B; - GL_PACK_COMPRESSED_BLOCK_HEIGHT = $0912C; - GL_PACK_COMPRESSED_BLOCK_DEPTH = $0912D; - GL_PACK_COMPRESSED_BLOCK_SIZE = $0912E; - - // GL_ARB_internalformat_query - GL_NUM_SAMPLE_COUNTS = $09380; - - // GL_ARB_map_buffer_alignment - GL_MIN_MAP_BUFFER_ALIGNMENT = $090BC; - - // GL_ARB_shader_atomic_counters - GL_ATOMIC_COUNTER_BUFFER = $92C0; - GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1; - GL_ATOMIC_COUNTER_BUFFER_START = $92C2; - GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3; - GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = $92C4; - GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = $92C5; - GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = $92C6; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = $92C7; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = $92C8; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = $92C9; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = $92CA; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = $92CB; - GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC; - GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD; - GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE; - GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF; - GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0; - GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1; - GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2; - GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3; - GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4; - GL_MAX_GEOMETRY_ATOMIC_COUNTERS = $92D5; - GL_MAX_FRAGMENT_ATOMIC_COUNTERS = $92D6; - GL_MAX_COMBINED_ATOMIC_COUNTERS = $92D7; - GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8; - GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC; - GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = $92D9; - GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = $92DA; - GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB; - - // GL_ARB_shader_image_load_store - GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001; - GL_ELEMENT_ARRAY_BARRIER_BIT = $00000002; - GL_UNIFORM_BARRIER_BIT = $00000004; - GL_TEXTURE_FETCH_BARRIER_BIT = $00000008; - GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020; - GL_COMMAND_BARRIER_BIT = $00000040; - GL_PIXEL_BUFFER_BARRIER_BIT = $00000080; - GL_TEXTURE_UPDATE_BARRIER_BIT = $00000100; - GL_BUFFER_UPDATE_BARRIER_BIT = $00000200; - GL_FRAMEBUFFER_BARRIER_BIT = $00000400; - GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800; - GL_ATOMIC_COUNTER_BARRIER_BIT = $00001000; - GL_ALL_BARRIER_BITS = $FFFFFFFF; - GL_MAX_IMAGE_UNITS = $8F38; - GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = $8F39; - GL_IMAGE_BINDING_NAME = $8F3A; - GL_IMAGE_BINDING_LEVEL = $8F3B; - GL_IMAGE_BINDING_LAYERED = $8F3C; - GL_IMAGE_BINDING_LAYER = $8F3D; - GL_IMAGE_BINDING_ACCESS = $8F3E; - GL_IMAGE_1D = $904C; - GL_IMAGE_2D = $904D; - GL_IMAGE_3D = $904E; - GL_IMAGE_2D_RECT = $904F; - GL_IMAGE_CUBE = $9050; - GL_IMAGE_BUFFER = $9051; - GL_IMAGE_1D_ARRAY = $9052; - GL_IMAGE_2D_ARRAY = $9053; - GL_IMAGE_CUBE_MAP_ARRAY = $9054; - GL_IMAGE_2D_MULTISAMPLE = $9055; - GL_IMAGE_2D_MULTISAMPLE_ARRAY = $9056; - GL_INT_IMAGE_1D = $9057; - GL_INT_IMAGE_2D = $9058; - GL_INT_IMAGE_3D = $9059; - GL_INT_IMAGE_2D_RECT = $905A; - GL_INT_IMAGE_CUBE = $905B; - GL_INT_IMAGE_BUFFER = $905C; - GL_INT_IMAGE_1D_ARRAY = $905D; - GL_INT_IMAGE_2D_ARRAY = $905E; - GL_INT_IMAGE_CUBE_MAP_ARRAY = $905F; - GL_INT_IMAGE_2D_MULTISAMPLE = $9060; - GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $9061; - GL_UNSIGNED_INT_IMAGE_1D = $9062; - GL_UNSIGNED_INT_IMAGE_2D = $9063; - GL_UNSIGNED_INT_IMAGE_3D = $9064; - GL_UNSIGNED_INT_IMAGE_2D_RECT = $9065; - GL_UNSIGNED_INT_IMAGE_CUBE = $9066; - GL_UNSIGNED_INT_IMAGE_BUFFER = $9067; - GL_UNSIGNED_INT_IMAGE_1D_ARRAY = $9068; - GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069; - GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A; - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = $906B; - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $906C; - GL_MAX_IMAGE_SAMPLES = $906D; - GL_IMAGE_BINDING_FORMAT = $906E; - GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7; - GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8; - GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9; - GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA; - GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB; - GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC; - GL_MAX_GEOMETRY_IMAGE_UNIFORMS = $90CD; - GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE; - GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF; - - // GL_ARB_texture_storage - GL_TEXTURE_IMMUTABLE_FORMAT = $912F; - - // 4.3 - GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0; - GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1; - GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2; - GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3; - GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4; - GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5; - GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6; - GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7; - GL_COMPRESSED_RGBA_ASTC_105_KHR = $93B8; - GL_COMPRESSED_RGBA_ASTC_106_KHR = $93B9; - GL_COMPRESSED_RGBA_ASTC_108_KHR = $93BA; - GL_COMPRESSED_RGBA_ASTC_110_KHR = $93BB; - GL_COMPRESSED_RGBA_ASTC_12x10_KHR = $93BC; - GL_COMPRESSED_RGBA_ASTC_12x12_KHR = $93BD; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = $93D0; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = $93D1; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = $93D2; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = $93D3; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = $93D4; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = $93D5; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = $93D6; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = $93D7; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = $93D8; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = $93D9; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = $93DA; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = $93DB; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = $93DC; - GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = $93DD; - // (4.3) GL_KHR_debug - GL_DEBUG_OUTPUT_SYNCHRONOUS = $8242; - GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = $8243; - GL_DEBUG_CALLBACK_FUNCTION = $8244; - GL_DEBUG_CALLBACK_USER_PARAM = $8245; - GL_DEBUG_SOURCE_API = $8246; - GL_DEBUG_SOURCE_WINDOW_SYSTEM = $8247; - GL_DEBUG_SOURCE_SHADER_COMPILER = $8248; - GL_DEBUG_SOURCE_THIRD_PARTY = $8249; - GL_DEBUG_SOURCE_APPLICATION = $824A; - GL_DEBUG_SOURCE_OTHER = $824B; - GL_DEBUG_TYPE_ERROR = $824C; - GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = $824D; - GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = $824E; - GL_DEBUG_TYPE_PORTABILITY = $824F; - GL_DEBUG_TYPE_PERFORMANCE = $8250; - GL_DEBUG_TYPE_OTHER = $8251; - GL_DEBUG_TYPE_MARKER = $8268; - GL_DEBUG_TYPE_PUSH_GROUP = $8269; - GL_DEBUG_TYPE_POP_GROUP = $826A; - GL_DEBUG_SEVERITY_NOTIFICATION = $826B; - GL_MAX_DEBUG_GROUP_STACK_DEPTH = $826C; - GL_DEBUG_GROUP_STACK_DEPTH = $826D; - GL_BUFFER = $82E0; - GL_SHADER = $82E1; - GL_PROGRAM = $82E2; - GL_QUERY = $82E3; - GL_PROGRAM_PIPELINE = $82E4; - GL_SAMPLER = $82E6; - GL_DISPLAY_LIST = $82E7; - GL_MAX_LABEL_LENGTH = $82E8; - GL_MAX_DEBUG_MESSAGE_LENGTH = $9143; - GL_MAX_DEBUG_LOGGED_MESSAGES = $9144; - GL_DEBUG_LOGGED_MESSAGES = $9145; - GL_DEBUG_SEVERITY_HIGH = $9146; - GL_DEBUG_SEVERITY_MEDIUM = $9147; - GL_DEBUG_SEVERITY_LOW = $9148; - GL_DEBUG_OUTPUT = $92E0; - GL_CONTEXT_FLAG_DEBUG_BIT = $00000002; - GL_COMPUTE_SHADER = $91B9; - GL_MAX_COMPUTE_UNIFORM_BLOCKS = $91BB; - GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC; - GL_MAX_COMPUTE_IMAGE_UNIFORMS = $91BD; - GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262; - GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263; - GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264; - GL_MAX_COMPUTE_ATOMIC_COUNTERS = $8265; - GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266; - GL_MAX_COMPUTE_LOCAL_INVOCATIONS = $90EB; - GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE; - GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF; - GL_COMPUTE_LOCAL_WORK_SIZE = $8267; - GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = $90EC; - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = $90ED; - GL_DISPATCH_INDIRECT_BUFFER = $90EE; - GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF; - GL_COMPUTE_SHADER_BIT = $00000020; - GL_COMPRESSED_RGB8_ETC2 = $9274; - GL_COMPRESSED_SRGB8_ETC2 = $9275; - GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276; - GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277; - GL_COMPRESSED_RGBA8_ETC2_EAC = $9278; - GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279; - GL_COMPRESSED_R11_EAC = $9270; - GL_COMPRESSED_SIGNED_R11_EAC = $9271; - GL_COMPRESSED_RG11_EAC = $9272; - GL_COMPRESSED_SIGNED_RG11_EAC = $9273; - GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69; - GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A; - GL_MAX_ELEMENT_INDEX = $8D6B; - GL_MAX_UNIFORM_LOCATIONS = $826E; - GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310; - GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311; - GL_FRAMEBUFFER_DEFAULT_LAYERS = $9312; - GL_FRAMEBUFFER_DEFAULT_SAMPLES = $9313; - GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314; - GL_MAX_FRAMEBUFFER_WIDTH = $9315; - GL_MAX_FRAMEBUFFER_HEIGHT = $9316; - GL_MAX_FRAMEBUFFER_LAYERS = $9317; - GL_MAX_FRAMEBUFFER_SAMPLES = $9318; - GL_INTERNALFORMAT_SUPPORTED = $826F; - GL_INTERNALFORMAT_PREFERRED = $8270; - GL_INTERNALFORMAT_RED_SIZE = $8271; - GL_INTERNALFORMAT_GREEN_SIZE = $8272; - GL_INTERNALFORMAT_BLUE_SIZE = $8273; - GL_INTERNALFORMAT_ALPHA_SIZE = $8274; - GL_INTERNALFORMAT_DEPTH_SIZE = $8275; - GL_INTERNALFORMAT_STENCIL_SIZE = $8276; - GL_INTERNALFORMAT_SHARED_SIZE = $8277; - GL_INTERNALFORMAT_RED_TYPE = $8278; - GL_INTERNALFORMAT_GREEN_TYPE = $8279; - GL_INTERNALFORMAT_BLUE_TYPE = $827A; - GL_INTERNALFORMAT_ALPHA_TYPE = $827B; - GL_INTERNALFORMAT_DEPTH_TYPE = $827C; - GL_INTERNALFORMAT_STENCIL_TYPE = $827D; - GL_MAX_WIDTH = $827E; - GL_MAX_HEIGHT = $827F; - GL_MAX_DEPTH = $8280; - GL_MAX_LAYERS = $8281; - GL_MAX_COMBINED_DIMENSIONS = $8282; - GL_COLOR_COMPONENTS = $8283; - GL_DEPTH_COMPONENTS = $8284; - GL_STENCIL_COMPONENTS = $8285; - GL_COLOR_RENDERABLE = $8286; - GL_DEPTH_RENDERABLE = $8287; - GL_STENCIL_RENDERABLE = $8288; - GL_FRAMEBUFFER_RENDERABLE = $8289; - GL_FRAMEBUFFER_RENDERABLE_LAYERED = $828A; - GL_FRAMEBUFFER_BLEND = $828B; - GL_READ_PIXELS = $828C; - GL_READ_PIXELS_FORMAT = $828D; - GL_READ_PIXELS_TYPE = $828E; - GL_TEXTURE_IMAGE_FORMAT = $828F; - GL_TEXTURE_IMAGE_TYPE = $8290; - GL_GET_TEXTURE_IMAGE_FORMAT = $8291; - GL_GET_TEXTURE_IMAGE_TYPE = $8292; - GL_MIPMAP = $8293; - GL_MANUAL_GENERATE_MIPMAP = $8294; - GL_AUTO_GENERATE_MIPMAP = $8295; - GL_COLOR_ENCODING = $8296; - GL_SRGB_READ = $8297; - GL_SRGB_WRITE = $8298; - GL_SRGB_DECODE_ARB = $8299; - GL_FILTER = $829A; - GL_VERTEX_TEXTURE = $829B; - GL_TESS_CONTROL_TEXTURE = $829C; - GL_TESS_EVALUATION_TEXTURE = $829D; - GL_GEOMETRY_TEXTURE = $829E; - GL_FRAGMENT_TEXTURE = $829F; - GL_COMPUTE_TEXTURE = $82A0; - GL_TEXTURE_SHADOW = $82A1; - GL_TEXTURE_GATHER = $82A2; - GL_TEXTURE_GATHER_SHADOW = $82A3; - GL_SHADER_IMAGE_LOAD = $82A4; - GL_SHADER_IMAGE_STORE = $82A5; - GL_SHADER_IMAGE_ATOMIC = $82A6; - GL_IMAGE_TEXEL_SIZE = $82A7; - GL_IMAGE_COMPATIBILITY_CLASS = $82A8; - GL_IMAGE_PIXEL_FORMAT = $82A9; - GL_IMAGE_PIXEL_TYPE = $82AA; - GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = $82AC; - GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = $82AD; - GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = $82AE; - GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = $82AF; - GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = $82B1; - GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = $82B2; - GL_TEXTURE_COMPRESSED_BLOCK_SIZE = $82B3; - GL_CLEAR_BUFFER = $82B4; - GL_TEXTURE_VIEW = $82B5; - GL_VIEW_COMPATIBILITY_CLASS = $82B6; - GL_FULL_SUPPORT = $82B7; - GL_CAVEAT_SUPPORT = $82B8; - GL_IMAGE_CLASS_4_X_32 = $82B9; - GL_IMAGE_CLASS_2_X_32 = $82BA; - GL_IMAGE_CLASS_1_X_32 = $82BB; - GL_IMAGE_CLASS_4_X_16 = $82BC; - GL_IMAGE_CLASS_2_X_16 = $82BD; - GL_IMAGE_CLASS_1_X_16 = $82BE; - GL_IMAGE_CLASS_4_X_8 = $82BF; - GL_IMAGE_CLASS_2_X_8 = $82C0; - GL_IMAGE_CLASS_1_X_8 = $82C1; - GL_IMAGE_CLASS_11_11_10 = $82C2; - GL_IMAGE_CLASS_10_10_10_2 = $82C3; - GL_VIEW_CLASS_128_BITS = $82C4; - GL_VIEW_CLASS_96_BITS = $82C5; - GL_VIEW_CLASS_64_BITS = $82C6; - GL_VIEW_CLASS_48_BITS = $82C7; - GL_VIEW_CLASS_32_BITS = $82C8; - GL_VIEW_CLASS_24_BITS = $82C9; - GL_VIEW_CLASS_16_BITS = $82CA; - GL_VIEW_CLASS_8_BITS = $82CB; - GL_VIEW_CLASS_S3TC_DXT1_RGB = $82CC; - GL_VIEW_CLASS_S3TC_DXT1_RGBA = $82CD; - GL_VIEW_CLASS_S3TC_DXT3_RGBA = $82CE; - GL_VIEW_CLASS_S3TC_DXT5_RGBA = $82CF; - GL_VIEW_CLASS_RGTC1_RED = $82D0; - GL_VIEW_CLASS_RGTC2_RG = $82D1; - GL_VIEW_CLASS_BPTC_UNORM = $82D2; - GL_VIEW_CLASS_BPTC_FLOAT = $82D3; - GL_UNIFORM = $92E1; - GL_UNIFORM_BLOCK = $92E2; - GL_PROGRAM_INPUT = $92E3; - GL_PROGRAM_OUTPUT = $92E4; - GL_BUFFER_VARIABLE = $92E5; - GL_SHADER_STORAGE_BLOCK = $92E6; - GL_VERTEX_SUBROUTINE = $92E8; - GL_TESS_CONTROL_SUBROUTINE = $92E9; - GL_TESS_EVALUATION_SUBROUTINE = $92EA; - GL_GEOMETRY_SUBROUTINE = $92EB; - GL_FRAGMENT_SUBROUTINE = $92EC; - GL_COMPUTE_SUBROUTINE = $92ED; - GL_VERTEX_SUBROUTINE_UNIFORM = $92EE; - GL_TESS_CONTROL_SUBROUTINE_UNIFORM = $92EF; - GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = $92F0; - GL_GEOMETRY_SUBROUTINE_UNIFORM = $92F1; - GL_FRAGMENT_SUBROUTINE_UNIFORM = $92F2; - GL_COMPUTE_SUBROUTINE_UNIFORM = $92F3; - GL_TRANSFORM_FEEDBACK_VARYING = $92F4; - GL_ACTIVE_RESOURCES = $92F5; - GL_MAX_NAME_LENGTH = $92F6; - GL_MAX_NUM_ACTIVE_VARIABLES = $92F7; - GL_MAX_NUM_COMPATIBLE_SUBROUTINES = $92F8; - GL_NAME_LENGTH = $92F9; - GL_TYPE = $92FA; - GL_ARRAY_SIZE = $92FB; - GL_OFFSET = $92FC; - GL_BLOCK_INDEX = $92FD; - GL_ARRAY_STRIDE = $92FE; - GL_MATRIX_STRIDE = $92FF; - GL_IS_ROW_MAJOR = $9300; - GL_ATOMIC_COUNTER_BUFFER_INDEX = $9301; - GL_BUFFER_BINDING = $9302; - GL_BUFFER_DATA_SIZE = $9303; - GL_NUM_ACTIVE_VARIABLES = $9304; - GL_ACTIVE_VARIABLES = $9305; - GL_REFERENCED_BY_VERTEX_SHADER = $9306; - GL_REFERENCED_BY_TESS_CONTROL_SHADER = $9307; - GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308; - GL_REFERENCED_BY_GEOMETRY_SHADER = $9309; - GL_REFERENCED_BY_FRAGMENT_SHADER = $930A; - GL_REFERENCED_BY_COMPUTE_SHADER = $930B; - GL_TOP_LEVEL_ARRAY_SIZE = $930C; - GL_TOP_LEVEL_ARRAY_STRIDE = $930D; - GL_LOCATION = $930E; - GL_LOCATION_INDEX = $930F; - GL_IS_PER_PATCH = $92E7; - GL_SHADER_STORAGE_BUFFER = $90D2; - GL_SHADER_STORAGE_BUFFER_BINDING = $90D3; - GL_SHADER_STORAGE_BUFFER_START = $90D4; - GL_SHADER_STORAGE_BUFFER_SIZE = $90D5; - GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6; - GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7; - GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8; - GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9; - GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA; - GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB; - GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC; - GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD; - GL_MAX_SHADER_STORAGE_BLOCK_SIZE = $90DE; - GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF; - GL_SHADER_STORAGE_BARRIER_BIT = $2000; - GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS; - GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA; - GL_TEXTURE_BUFFER_OFFSET = $919D; - GL_TEXTURE_BUFFER_SIZE = $919E; - GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F; - GL_TEXTURE_VIEW_MIN_LEVEL = $82DB; - GL_TEXTURE_VIEW_NUM_LEVELS = $82DC; - GL_TEXTURE_VIEW_MIN_LAYER = $82DD; - GL_TEXTURE_VIEW_NUM_LAYERS = $82DE; - GL_TEXTURE_IMMUTABLE_LEVELS = $82DF; - GL_VERTEX_ATTRIB_BINDING = $82D4; - GL_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D5; - GL_VERTEX_BINDING_DIVISOR = $82D6; - GL_VERTEX_BINDING_OFFSET = $82D7; - GL_VERTEX_BINDING_STRIDE = $82D8; - GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9; - GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA; - // END 4.3 - - // GL 4.4 - GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5; - GL_MAP_PERSISTENT_BIT = $0040; - GL_MAP_COHERENT_BIT = $0080; - GL_DYNAMIC_STORAGE_BIT = $0100; - GL_CLIENT_STORAGE_BIT = $0200; - GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = $00004000; - GL_BUFFER_IMMUTABLE_STORAGE = $821F; - GL_BUFFER_STORAGE_FLAGS = $8220; - GL_CLEAR_TEXTURE = $9365; - GL_LOCATION_COMPONENT = $934A; - GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = $934B; - GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = $934C; - GL_QUERY_BUFFER = $9192; - GL_QUERY_BUFFER_BARRIER_BIT = $00008000; - GL_QUERY_BUFFER_BINDING = $9193; - GL_QUERY_RESULT_NO_WAIT = $9194; - GL_MIRROR_CLAMP_TO_EDGE = $8743; - // END GL 4.4 - - // GL_ATI_draw_buffers - GL_MAX_DRAW_BUFFERS_ATI = $8824; - GL_DRAW_BUFFER0_ATI = $8825; - GL_DRAW_BUFFER1_ATI = $8826; - GL_DRAW_BUFFER2_ATI = $8827; - GL_DRAW_BUFFER3_ATI = $8828; - GL_DRAW_BUFFER4_ATI = $8829; - GL_DRAW_BUFFER5_ATI = $882A; - GL_DRAW_BUFFER6_ATI = $882B; - GL_DRAW_BUFFER7_ATI = $882C; - GL_DRAW_BUFFER8_ATI = $882D; - GL_DRAW_BUFFER9_ATI = $882E; - GL_DRAW_BUFFER10_ATI = $882F; - GL_DRAW_BUFFER11_ATI = $8830; - GL_DRAW_BUFFER12_ATI = $8831; - GL_DRAW_BUFFER13_ATI = $8832; - GL_DRAW_BUFFER14_ATI = $8833; - GL_DRAW_BUFFER15_ATI = $8834; - - // GL_ATI_element_array - GL_ELEMENT_ARRAY_ATI = $8768; - GL_ELEMENT_ARRAY_TYPE_ATI = $8769; - GL_ELEMENT_ARRAY_POINTER_ATI = $876A; - - // GL_ATI_envmap_bumpmap - GL_BUMP_ROT_MATRIX_ATI = $8775; - GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776; - GL_BUMP_NUM_TEX_UNITS_ATI = $8777; - GL_BUMP_TEX_UNITS_ATI = $8778; - GL_DUDV_ATI = $8779; - GL_DU8DV8_ATI = $877A; - GL_BUMP_ENVMAP_ATI = $877B; - GL_BUMP_TARGET_ATI = $877C; - - // GL_ATI_fragment_shader - GL_FRAGMENT_SHADER_ATI = $8920; - GL_REG_0_ATI = $8921; - GL_REG_1_ATI = $8922; - GL_REG_2_ATI = $8923; - GL_REG_3_ATI = $8924; - GL_REG_4_ATI = $8925; - GL_REG_5_ATI = $8926; - GL_REG_6_ATI = $8927; - GL_REG_7_ATI = $8928; - GL_REG_8_ATI = $8929; - GL_REG_9_ATI = $892A; - GL_REG_10_ATI = $892B; - GL_REG_11_ATI = $892C; - GL_REG_12_ATI = $892D; - GL_REG_13_ATI = $892E; - GL_REG_14_ATI = $892F; - GL_REG_15_ATI = $8930; - GL_REG_16_ATI = $8931; - GL_REG_17_ATI = $8932; - GL_REG_18_ATI = $8933; - GL_REG_19_ATI = $8934; - GL_REG_20_ATI = $8935; - GL_REG_21_ATI = $8936; - GL_REG_22_ATI = $8937; - GL_REG_23_ATI = $8938; - GL_REG_24_ATI = $8939; - GL_REG_25_ATI = $893A; - GL_REG_26_ATI = $893B; - GL_REG_27_ATI = $893C; - GL_REG_28_ATI = $893D; - GL_REG_29_ATI = $893E; - GL_REG_30_ATI = $893F; - GL_REG_31_ATI = $8940; - GL_CON_0_ATI = $8941; - GL_CON_1_ATI = $8942; - GL_CON_2_ATI = $8943; - GL_CON_3_ATI = $8944; - GL_CON_4_ATI = $8945; - GL_CON_5_ATI = $8946; - GL_CON_6_ATI = $8947; - GL_CON_7_ATI = $8948; - GL_CON_8_ATI = $8949; - GL_CON_9_ATI = $894A; - GL_CON_10_ATI = $894B; - GL_CON_11_ATI = $894C; - GL_CON_12_ATI = $894D; - GL_CON_13_ATI = $894E; - GL_CON_14_ATI = $894F; - GL_CON_15_ATI = $8950; - GL_CON_16_ATI = $8951; - GL_CON_17_ATI = $8952; - GL_CON_18_ATI = $8953; - GL_CON_19_ATI = $8954; - GL_CON_20_ATI = $8955; - GL_CON_21_ATI = $8956; - GL_CON_22_ATI = $8957; - GL_CON_23_ATI = $8958; - GL_CON_24_ATI = $8959; - GL_CON_25_ATI = $895A; - GL_CON_26_ATI = $895B; - GL_CON_27_ATI = $895C; - GL_CON_28_ATI = $895D; - GL_CON_29_ATI = $895E; - GL_CON_30_ATI = $895F; - GL_CON_31_ATI = $8960; - GL_MOV_ATI = $8961; - GL_ADD_ATI = $8963; - GL_MUL_ATI = $8964; - GL_SUB_ATI = $8965; - GL_DOT3_ATI = $8966; - GL_DOT4_ATI = $8967; - GL_MAD_ATI = $8968; - GL_LERP_ATI = $8969; - GL_CND_ATI = $896A; - GL_CND0_ATI = $896B; - GL_DOT2_ADD_ATI = $896C; - GL_SECONDARY_INTERPOLATOR_ATI = $896D; - GL_NUM_FRAGMENT_REGISTERS_ATI = $896E; - GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F; - GL_NUM_PASSES_ATI = $8970; - GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971; - GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972; - GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973; - GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974; - GL_COLOR_ALPHA_PAIRING_ATI = $8975; - GL_SWIZZLE_STR_ATI = $8976; - GL_SWIZZLE_STQ_ATI = $8977; - GL_SWIZZLE_STR_DR_ATI = $8978; - GL_SWIZZLE_STQ_DQ_ATI = $8979; - GL_SWIZZLE_STRQ_ATI = $897A; - GL_SWIZZLE_STRQ_DQ_ATI = $897B; - GL_RED_BIT_ATI = $00000001; - GL_GREEN_BIT_ATI = $00000002; - GL_BLUE_BIT_ATI = $00000004; - GL_2X_BIT_ATI = $00000001; - GL_4X_BIT_ATI = $00000002; - GL_8X_BIT_ATI = $00000004; - GL_HALF_BIT_ATI = $00000008; - GL_QUARTER_BIT_ATI = $00000010; - GL_EIGHTH_BIT_ATI = $00000020; - GL_SATURATE_BIT_ATI = $00000040; - GL_COMP_BIT_ATI = $00000002; - GL_NEGATE_BIT_ATI = $00000004; - GL_BIAS_BIT_ATI = $00000008; - - // GL_ATI_pn_triangles - GL_PN_TRIANGLES_ATI = $87F0; - GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1; - GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2; - GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3; - GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4; - GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5; - GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6; - GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7; - GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8; - - // GL_ATI_separate_stencil - GL_STENCIL_BACK_FUNC_ATI = $8800; - GL_STENCIL_BACK_FAIL_ATI = $8801; - GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802; - GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803; - - // GL_ATI_text_fragment_shader - GL_TEXT_FRAGMENT_SHADER_ATI = $8200; - - // GL_ATI_texture_env_combine3 - GL_MODULATE_ADD_ATI = $8744; - GL_MODULATE_SIGNED_ADD_ATI = $8745; - GL_MODULATE_SUBTRACT_ATI = $8746; - - // GL_ATI_texture_float - GL_RGBA_FLOAT32_ATI = $8814; - GL_RGB_FLOAT32_ATI = $8815; - GL_ALPHA_FLOAT32_ATI = $8816; - GL_INTENSITY_FLOAT32_ATI = $8817; - GL_LUMINANCE_FLOAT32_ATI = $8818; - GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819; - GL_RGBA_FLOAT16_ATI = $881A; - GL_RGB_FLOAT16_ATI = $881B; - GL_ALPHA_FLOAT16_ATI = $881C; - GL_INTENSITY_FLOAT16_ATI = $881D; - GL_LUMINANCE_FLOAT16_ATI = $881E; - GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F; - - // GL_ATI_texture_mirror_once - GL_MIRROR_CLAMP_ATI = $8742; - GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743; - - // GL_ATI_vertex_array_object - GL_STATIC_ATI = $8760; - GL_DYNAMIC_ATI = $8761; - GL_PRESERVE_ATI = $8762; - GL_DISCARD_ATI = $8763; - GL_OBJECT_BUFFER_SIZE_ATI = $8764; - GL_OBJECT_BUFFER_USAGE_ATI = $8765; - GL_ARRAY_OBJECT_BUFFER_ATI = $8766; - GL_ARRAY_OBJECT_OFFSET_ATI = $8767; - - // GL_ATI_vertex_streams - GL_MAX_VERTEX_STREAMS_ATI = $876B; - GL_VERTEX_STREAM0_ATI = $876C; - GL_VERTEX_STREAM1_ATI = $876D; - GL_VERTEX_STREAM2_ATI = $876E; - GL_VERTEX_STREAM3_ATI = $876F; - GL_VERTEX_STREAM4_ATI = $8770; - GL_VERTEX_STREAM5_ATI = $8771; - GL_VERTEX_STREAM6_ATI = $8772; - GL_VERTEX_STREAM7_ATI = $8773; - GL_VERTEX_SOURCE_ATI = $8774; - - // GL_ATI_meminfo - GL_VBO_FREE_MEMORY_ATI = $87FB; - GL_TEXTURE_FREE_MEMORY_ATI = $87FC; - GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD; - - // GL_AMD_performance_monitor - GL_COUNTER_TYPE_AMD = $8BC0; - GL_COUNTER_RANGE_AMD = $8BC1; - GL_UNSIGNED_INT64_AMD = $8BC2; - GL_PERCENTAGE_AMD = $8BC3; - GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4; - GL_PERFMON_RESULT_SIZE_AMD = $8BC5; - GL_PERFMON_RESULT_AMD = $8BC6; - - // GL_AMD_vertex_shader_tesselator - GL_SAMPLER_BUFFER_AMD = $9001; - GL_INT_SAMPLER_BUFFER_AMD = $9002; - GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003; - GL_TESSELLATION_MODE_AMD = $9004; - GL_TESSELLATION_FACTOR_AMD = $9005; - GL_DISCRETE_AMD = $9006; - GL_CONTINUOUS_AMD = $9007; - - // GL_AMD_seamless_cubemap_per_texture - { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS } - - // GL_AMD_name_gen_delete - GL_DATA_BUFFER_AMD = $9151; - GL_PERFORMANCE_MONITOR_AMD = $9152; - GL_QUERY_OBJECT_AMD = $9153; - GL_VERTEX_ARRAY_OBJECT_AMD = $9154; - GL_SAMPLER_OBJECT_AMD = $9155; - - // GL_AMD_debug_output - GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = $9144; - GL_DEBUG_LOGGED_MESSAGES_AMD = $9145; - GL_DEBUG_SEVERITY_HIGH_AMD = $9146; - GL_DEBUG_SEVERITY_MEDIUM_AMD = $9147; - GL_DEBUG_SEVERITY_LOW_AMD = $9148; - GL_DEBUG_CATEGORY_API_ERROR_AMD = $9149; - GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = $914A; - GL_DEBUG_CATEGORY_DEPRECATION_AMD = $914B; - GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = $914C; - GL_DEBUG_CATEGORY_PERFORMANCE_AMD = $914D; - GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = $914E; - GL_DEBUG_CATEGORY_APPLICATION_AMD = $914F; - GL_DEBUG_CATEGORY_OTHER_AMD = $9150; - - // GL_AMD_depth_clamp_separate - GL_DEPTH_CLAMP_NEAR_AMD = $901E; - GL_DEPTH_CLAMP_FAR_AMD = $901F; - - // GL_EXT_422_pixels - GL_422_EXT = $80CC; - GL_422_REV_EXT = $80CD; - GL_422_AVERAGE_EXT = $80CE; - GL_422_REV_AVERAGE_EXT = $80CF; - - // GL_EXT_abgr - GL_ABGR_EXT = $8000; - - // GL_EXT_bgra - GL_BGR_EXT = $80E0; - GL_BGRA_EXT = $80E1; - - // GL_EXT_blend_color - GL_CONSTANT_COLOR_EXT = $8001; - GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002; - GL_CONSTANT_ALPHA_EXT = $8003; - GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004; - GL_BLEND_COLOR_EXT = $8005; - - // GL_EXT_blend_func_separate - GL_BLEND_DST_RGB_EXT = $80C8; - GL_BLEND_SRC_RGB_EXT = $80C9; - GL_BLEND_DST_ALPHA_EXT = $80CA; - GL_BLEND_SRC_ALPHA_EXT = $80CB; - - // GL_EXT_blend_minmax - GL_FUNC_ADD_EXT = $8006; - GL_MIN_EXT = $8007; - GL_MAX_EXT = $8008; - GL_BLEND_EQUATION_EXT = $8009; - - // GL_EXT_blend_subtract - GL_FUNC_SUBTRACT_EXT = $800A; - GL_FUNC_REVERSE_SUBTRACT_EXT = $800B; - - // GL_EXT_clip_volume_hint - GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0; - - // GL_EXT_cmyka - GL_CMYK_EXT = $800C; - GL_CMYKA_EXT = $800D; - GL_PACK_CMYK_HINT_EXT = $800E; - GL_UNPACK_CMYK_HINT_EXT = $800F; - - // GL_EXT_compiled_vertex_array - GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8; - GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9; - - // GL_EXT_convolution - GL_CONVOLUTION_1D_EXT = $8010; - GL_CONVOLUTION_2D_EXT = $8011; - GL_SEPARABLE_2D_EXT = $8012; - GL_CONVOLUTION_BORDER_MODE_EXT = $8013; - GL_CONVOLUTION_FILTER_SCALE_EXT = $8014; - GL_CONVOLUTION_FILTER_BIAS_EXT = $8015; - GL_REDUCE_EXT = $8016; - GL_CONVOLUTION_FORMAT_EXT = $8017; - GL_CONVOLUTION_WIDTH_EXT = $8018; - GL_CONVOLUTION_HEIGHT_EXT = $8019; - GL_MAX_CONVOLUTION_WIDTH_EXT = $801A; - GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B; - GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C; - GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D; - GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E; - GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F; - GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020; - GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021; - GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022; - GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023; - - // GL_EXT_coordinate_frame - GL_TANGENT_ARRAY_EXT = $8439; - GL_BINORMAL_ARRAY_EXT = $843A; - GL_CURRENT_TANGENT_EXT = $843B; - GL_CURRENT_BINORMAL_EXT = $843C; - GL_TANGENT_ARRAY_TYPE_EXT = $843E; - GL_TANGENT_ARRAY_STRIDE_EXT = $843F; - GL_BINORMAL_ARRAY_TYPE_EXT = $8440; - GL_BINORMAL_ARRAY_STRIDE_EXT = $8441; - GL_TANGENT_ARRAY_POINTER_EXT = $8442; - GL_BINORMAL_ARRAY_POINTER_EXT = $8443; - GL_MAP1_TANGENT_EXT = $8444; - GL_MAP2_TANGENT_EXT = $8445; - GL_MAP1_BINORMAL_EXT = $8446; - GL_MAP2_BINORMAL_EXT = $8447; - - // GL_EXT_cull_vertex - GL_CULL_VERTEX_EXT = $81AA; - GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB; - GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC; - - // GL_EXT_draw_range_elements - GL_MAX_ELEMENTS_VERTICES_EXT = $80E8; - GL_MAX_ELEMENTS_INDICES_EXT = $80E9; - - // GL_EXT_fog_coord - GL_FOG_COORDINATE_SOURCE_EXT = $8450; - GL_FOG_COORDINATE_EXT = $8451; - GL_FRAGMENT_DEPTH_EXT = $8452; - GL_CURRENT_FOG_COORDINATE_EXT = $8453; - GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454; - GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455; - GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456; - GL_FOG_COORDINATE_ARRAY_EXT = $8457; - - // GL_EXT_framebuffer_object - GL_FRAMEBUFFER_EXT = $8D40; - GL_RENDERBUFFER_EXT = $8D41; - GL_STENCIL_INDEX_EXT = $8D45; - GL_STENCIL_INDEX1_EXT = $8D46; - GL_STENCIL_INDEX4_EXT = $8D47; - GL_STENCIL_INDEX8_EXT = $8D48; - GL_STENCIL_INDEX16_EXT = $8D49; - GL_RENDERBUFFER_WIDTH_EXT = $8D42; - GL_RENDERBUFFER_HEIGHT_EXT = $8D43; - GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44; - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0; - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4; - GL_COLOR_ATTACHMENT0_EXT = $8CE0; - GL_COLOR_ATTACHMENT1_EXT = $8CE1; - GL_COLOR_ATTACHMENT2_EXT = $8CE2; - GL_COLOR_ATTACHMENT3_EXT = $8CE3; - GL_COLOR_ATTACHMENT4_EXT = $8CE4; - GL_COLOR_ATTACHMENT5_EXT = $8CE5; - GL_COLOR_ATTACHMENT6_EXT = $8CE6; - GL_COLOR_ATTACHMENT7_EXT = $8CE7; - GL_COLOR_ATTACHMENT8_EXT = $8CE8; - GL_COLOR_ATTACHMENT9_EXT = $8CE9; - GL_COLOR_ATTACHMENT10_EXT = $8CEA; - GL_COLOR_ATTACHMENT11_EXT = $8CEB; - GL_COLOR_ATTACHMENT12_EXT = $8CEC; - GL_COLOR_ATTACHMENT13_EXT = $8CED; - GL_COLOR_ATTACHMENT14_EXT = $8CEE; - GL_COLOR_ATTACHMENT15_EXT = $8CEF; - GL_DEPTH_ATTACHMENT_EXT = $8D00; - GL_STENCIL_ATTACHMENT_EXT = $8D20; - GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5; - GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6; - GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7; - GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8; - GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9; - GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA; - GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB; - GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC; - GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD; - GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE; - GL_FRAMEBUFFER_BINDING_EXT = $8CA6; - GL_RENDERBUFFER_BINDING_EXT = $8CA7; - GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF; - GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8; - GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506; - - // GL_EXT_histogram - GL_HISTOGRAM_EXT = $8024; - GL_PROXY_HISTOGRAM_EXT = $8025; - GL_HISTOGRAM_WIDTH_EXT = $8026; - GL_HISTOGRAM_FORMAT_EXT = $8027; - GL_HISTOGRAM_RED_SIZE_EXT = $8028; - GL_HISTOGRAM_GREEN_SIZE_EXT = $8029; - GL_HISTOGRAM_BLUE_SIZE_EXT = $802A; - GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B; - GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C; - GL_HISTOGRAM_SINK_EXT = $802D; - GL_MINMAX_EXT = $802E; - GL_MINMAX_FORMAT_EXT = $802F; - GL_MINMAX_SINK_EXT = $8030; - GL_TABLE_TOO_LARGE_EXT = $8031; - - // GL_EXT_index_array_formats - GL_IUI_V2F_EXT = $81AD; - GL_IUI_V3F_EXT = $81AE; - GL_IUI_N3F_V2F_EXT = $81AF; - GL_IUI_N3F_V3F_EXT = $81B0; - GL_T2F_IUI_V2F_EXT = $81B1; - GL_T2F_IUI_V3F_EXT = $81B2; - GL_T2F_IUI_N3F_V2F_EXT = $81B3; - GL_T2F_IUI_N3F_V3F_EXT = $81B4; - - // GL_EXT_index_func - GL_INDEX_TEST_EXT = $81B5; - GL_INDEX_TEST_FUNC_EXT = $81B6; - GL_INDEX_TEST_REF_EXT = $81B7; - - // GL_EXT_index_material - GL_INDEX_MATERIAL_EXT = $81B8; - GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9; - GL_INDEX_MATERIAL_FACE_EXT = $81BA; - - // GL_EXT_light_texture - GL_FRAGMENT_MATERIAL_EXT = $8349; - GL_FRAGMENT_NORMAL_EXT = $834A; - GL_FRAGMENT_COLOR_EXT = $834C; - GL_ATTENUATION_EXT = $834D; - GL_SHADOW_ATTENUATION_EXT = $834E; - GL_TEXTURE_APPLICATION_MODE_EXT = $834F; - GL_TEXTURE_LIGHT_EXT = $8350; - GL_TEXTURE_MATERIAL_FACE_EXT = $8351; - GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352; - - // GL_EXT_multisample - GL_MULTISAMPLE_EXT = $809D; - GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E; - GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F; - GL_SAMPLE_MASK_EXT = $80A0; - GL_1PASS_EXT = $80A1; - GL_2PASS_0_EXT = $80A2; - GL_2PASS_1_EXT = $80A3; - GL_4PASS_0_EXT = $80A4; - GL_4PASS_1_EXT = $80A5; - GL_4PASS_2_EXT = $80A6; - GL_4PASS_3_EXT = $80A7; - GL_SAMPLE_BUFFERS_EXT = $80A8; - GL_SAMPLES_EXT = $80A9; - GL_SAMPLE_MASK_VALUE_EXT = $80AA; - GL_SAMPLE_MASK_INVERT_EXT = $80AB; - GL_SAMPLE_PATTERN_EXT = $80AC; - GL_MULTISAMPLE_BIT_EXT = $20000000; - - // GL_EXT_packed_pixels - GL_UNSIGNED_BYTE_3_3_2_EXT = $8032; - GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033; - GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034; - GL_UNSIGNED_INT_8_8_8_8_EXT = $8035; - GL_UNSIGNED_INT_10_10_10_2_EXT = $8036; - - // GL_EXT_paletted_texture - GL_COLOR_INDEX1_EXT = $80E2; - GL_COLOR_INDEX2_EXT = $80E3; - GL_COLOR_INDEX4_EXT = $80E4; - GL_COLOR_INDEX8_EXT = $80E5; - GL_COLOR_INDEX12_EXT = $80E6; - GL_COLOR_INDEX16_EXT = $80E7; - GL_TEXTURE_INDEX_SIZE_EXT = $80ED; - - // GL_EXT_pixel_transform - GL_PIXEL_TRANSFORM_2D_EXT = $8330; - GL_PIXEL_MAG_FILTER_EXT = $8331; - GL_PIXEL_MIN_FILTER_EXT = $8332; - GL_PIXEL_CUBIC_WEIGHT_EXT = $8333; - GL_CUBIC_EXT = $8334; - GL_AVERAGE_EXT = $8335; - GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336; - GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337; - GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338; - - // GL_EXT_point_parameters - GL_POINT_SIZE_MIN_EXT = $8126; - GL_POINT_SIZE_MAX_EXT = $8127; - GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128; - GL_DISTANCE_ATTENUATION_EXT = $8129; - - // GL_EXT_polygon_offset - GL_POLYGON_OFFSET_EXT = $8037; - GL_POLYGON_OFFSET_FACTOR_EXT = $8038; - GL_POLYGON_OFFSET_BIAS_EXT = $8039; - - // GL_EXT_rescale_normal - GL_RESCALE_NORMAL_EXT = $803A; - - // GL_EXT_secondary_color - GL_COLOR_SUM_EXT = $8458; - GL_CURRENT_SECONDARY_COLOR_EXT = $8459; - GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A; - GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B; - GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C; - GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D; - GL_SECONDARY_COLOR_ARRAY_EXT = $845E; - - // GL_EXT_separate_specular_color - GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8; - GL_SINGLE_COLOR_EXT = $81F9; - GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA; - - // GL_EXT_shared_texture_palette - GL_SHARED_TEXTURE_PALETTE_EXT = $81FB; - - // GL_EXT_stencil_two_side - GL_STENCIL_TEST_TWO_SIDE_EXT = $8910; - GL_ACTIVE_STENCIL_FACE_EXT = $8911; - - // GL_EXT_stencil_wrap - GL_INCR_WRAP_EXT = $8507; - GL_DECR_WRAP_EXT = $8508; - - // GL_EXT_texture - GL_ALPHA4_EXT = $803B; - GL_ALPHA8_EXT = $803C; - GL_ALPHA12_EXT = $803D; - GL_ALPHA16_EXT = $803E; - GL_LUMINANCE4_EXT = $803F; - GL_LUMINANCE8_EXT = $8040; - GL_LUMINANCE12_EXT = $8041; - GL_LUMINANCE16_EXT = $8042; - GL_LUMINANCE4_ALPHA4_EXT = $8043; - GL_LUMINANCE6_ALPHA2_EXT = $8044; - GL_LUMINANCE8_ALPHA8_EXT = $8045; - GL_LUMINANCE12_ALPHA4_EXT = $8046; - GL_LUMINANCE12_ALPHA12_EXT = $8047; - GL_LUMINANCE16_ALPHA16_EXT = $8048; - GL_INTENSITY_EXT = $8049; - GL_INTENSITY4_EXT = $804A; - GL_INTENSITY8_EXT = $804B; - GL_INTENSITY12_EXT = $804C; - GL_INTENSITY16_EXT = $804D; - GL_RGB2_EXT = $804E; - GL_RGB4_EXT = $804F; - GL_RGB5_EXT = $8050; - GL_RGB8_EXT = $8051; - GL_RGB10_EXT = $8052; - GL_RGB12_EXT = $8053; - GL_RGB16_EXT = $8054; - GL_RGBA2_EXT = $8055; - GL_RGBA4_EXT = $8056; - GL_RGB5_A1_EXT = $8057; - GL_RGBA8_EXT = $8058; - GL_RGB10_A2_EXT = $8059; - GL_RGBA12_EXT = $805A; - GL_RGBA16_EXT = $805B; - GL_TEXTURE_RED_SIZE_EXT = $805C; - GL_TEXTURE_GREEN_SIZE_EXT = $805D; - GL_TEXTURE_BLUE_SIZE_EXT = $805E; - GL_TEXTURE_ALPHA_SIZE_EXT = $805F; - GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060; - GL_TEXTURE_INTENSITY_SIZE_EXT = $8061; - GL_REPLACE_EXT = $8062; - GL_PROXY_TEXTURE_1D_EXT = $8063; - GL_PROXY_TEXTURE_2D_EXT = $8064; - GL_TEXTURE_TOO_LARGE_EXT = $8065; - - // GL_EXT_texture3D - GL_PACK_SKIP_IMAGES_EXT = $806B; - GL_PACK_IMAGE_HEIGHT_EXT = $806C; - GL_UNPACK_SKIP_IMAGES_EXT = $806D; - GL_UNPACK_IMAGE_HEIGHT_EXT = $806E; - GL_TEXTURE_3D_EXT = $806F; - GL_PROXY_TEXTURE_3D_EXT = $8070; - GL_TEXTURE_DEPTH_EXT = $8071; - GL_TEXTURE_WRAP_R_EXT = $8072; - GL_MAX_3D_TEXTURE_SIZE_EXT = $8073; - - // GL_EXT_texture_compression_s3tc - GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0; - GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1; - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2; - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3; - - // GL_EXT_texture_cube_map - GL_NORMAL_MAP_EXT = $8511; - GL_REFLECTION_MAP_EXT = $8512; - GL_TEXTURE_CUBE_MAP_EXT = $8513; - GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514; - GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515; - GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516; - GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518; - GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519; - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A; - GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B; - GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C; - - // GL_EXT_texture_edge_clamp - GL_CLAMP_TO_EDGE_EXT = $812F; - - // GL_EXT_texture_env_combine - GL_COMBINE_EXT = $8570; - GL_COMBINE_RGB_EXT = $8571; - GL_COMBINE_ALPHA_EXT = $8572; - GL_RGB_SCALE_EXT = $8573; - GL_ADD_SIGNED_EXT = $8574; - GL_INTERPOLATE_EXT = $8575; - GL_CONSTANT_EXT = $8576; - GL_PRIMARY_COLOR_EXT = $8577; - GL_PREVIOUS_EXT = $8578; - GL_SOURCE0_RGB_EXT = $8580; - GL_SOURCE1_RGB_EXT = $8581; - GL_SOURCE2_RGB_EXT = $8582; - GL_SOURCE0_ALPHA_EXT = $8588; - GL_SOURCE1_ALPHA_EXT = $8589; - GL_SOURCE2_ALPHA_EXT = $858A; - GL_OPERAND0_RGB_EXT = $8590; - GL_OPERAND1_RGB_EXT = $8591; - GL_OPERAND2_RGB_EXT = $8592; - GL_OPERAND0_ALPHA_EXT = $8598; - GL_OPERAND1_ALPHA_EXT = $8599; - GL_OPERAND2_ALPHA_EXT = $859A; - - // GL_EXT_texture_env_dot3 - GL_DOT3_RGB_EXT = $8740; - GL_DOT3_RGBA_EXT = $8741; - - // GL_EXT_texture_filter_anisotropic - GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; - GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; - - // GL_EXT_texture_lod_bias - GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD; - GL_TEXTURE_FILTER_CONTROL_EXT = $8500; - GL_TEXTURE_LOD_BIAS_EXT = $8501; - - // GL_EXT_texture_object - GL_TEXTURE_PRIORITY_EXT = $8066; - GL_TEXTURE_RESIDENT_EXT = $8067; - GL_TEXTURE_1D_BINDING_EXT = $8068; - GL_TEXTURE_2D_BINDING_EXT = $8069; - GL_TEXTURE_3D_BINDING_EXT = $806A; - - // GL_EXT_texture_perturb_normal - GL_PERTURB_EXT = $85AE; - GL_TEXTURE_NORMAL_EXT = $85AF; - - // GL_EXT_texture_rectangle - GL_TEXTURE_RECTANGLE_EXT = $84F5; - GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6; - GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7; - GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8; - - // GL_EXT_vertex_array - GL_VERTEX_ARRAY_EXT = $8074; - GL_NORMAL_ARRAY_EXT = $8075; - GL_COLOR_ARRAY_EXT = $8076; - GL_INDEX_ARRAY_EXT = $8077; - GL_TEXTURE_COORD_ARRAY_EXT = $8078; - GL_EDGE_FLAG_ARRAY_EXT = $8079; - GL_VERTEX_ARRAY_SIZE_EXT = $807A; - GL_VERTEX_ARRAY_TYPE_EXT = $807B; - GL_VERTEX_ARRAY_STRIDE_EXT = $807C; - GL_VERTEX_ARRAY_COUNT_EXT = $807D; - GL_NORMAL_ARRAY_TYPE_EXT = $807E; - GL_NORMAL_ARRAY_STRIDE_EXT = $807F; - GL_NORMAL_ARRAY_COUNT_EXT = $8080; - GL_COLOR_ARRAY_SIZE_EXT = $8081; - GL_COLOR_ARRAY_TYPE_EXT = $8082; - GL_COLOR_ARRAY_STRIDE_EXT = $8083; - GL_COLOR_ARRAY_COUNT_EXT = $8084; - GL_INDEX_ARRAY_TYPE_EXT = $8085; - GL_INDEX_ARRAY_STRIDE_EXT = $8086; - GL_INDEX_ARRAY_COUNT_EXT = $8087; - GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088; - GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089; - GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A; - GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B; - GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C; - GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D; - GL_VERTEX_ARRAY_POINTER_EXT = $808E; - GL_NORMAL_ARRAY_POINTER_EXT = $808F; - GL_COLOR_ARRAY_POINTER_EXT = $8090; - GL_INDEX_ARRAY_POINTER_EXT = $8091; - GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092; - GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093; - - // GL_EXT_vertex_shader - GL_VERTEX_SHADER_EXT = $8780; - GL_VERTEX_SHADER_BINDING_EXT = $8781; - GL_OP_INDEX_EXT = $8782; - GL_OP_NEGATE_EXT = $8783; - GL_OP_DOT3_EXT = $8784; - GL_OP_DOT4_EXT = $8785; - GL_OP_MUL_EXT = $8786; - GL_OP_ADD_EXT = $8787; - GL_OP_MADD_EXT = $8788; - GL_OP_FRAC_EXT = $8789; - GL_OP_MAX_EXT = $878A; - GL_OP_MIN_EXT = $878B; - GL_OP_SET_GE_EXT = $878C; - GL_OP_SET_LT_EXT = $878D; - GL_OP_CLAMP_EXT = $878E; - GL_OP_FLOOR_EXT = $878F; - GL_OP_ROUND_EXT = $8790; - GL_OP_EXP_BASE_2_EXT = $8791; - GL_OP_LOG_BASE_2_EXT = $8792; - GL_OP_POWER_EXT = $8793; - GL_OP_RECIP_EXT = $8794; - GL_OP_RECIP_SQRT_EXT = $8795; - GL_OP_SUB_EXT = $8796; - GL_OP_CROSS_PRODUCT_EXT = $8797; - GL_OP_MULTIPLY_MATRIX_EXT = $8798; - GL_OP_MOV_EXT = $8799; - GL_OUTPUT_VERTEX_EXT = $879A; - GL_OUTPUT_COLOR0_EXT = $879B; - GL_OUTPUT_COLOR1_EXT = $879C; - GL_OUTPUT_TEXTURE_COORD0_EXT = $879D; - GL_OUTPUT_TEXTURE_COORD1_EXT = $879E; - GL_OUTPUT_TEXTURE_COORD2_EXT = $879F; - GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0; - GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1; - GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2; - GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3; - GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4; - GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5; - GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6; - GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7; - GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8; - GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9; - GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA; - GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB; - GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC; - GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD; - GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE; - GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF; - GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0; - GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1; - GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2; - GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3; - GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4; - GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5; - GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6; - GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7; - GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8; - GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9; - GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA; - GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB; - GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC; - GL_OUTPUT_FOG_EXT = $87BD; - GL_SCALAR_EXT = $87BE; - GL_VECTOR_EXT = $87BF; - GL_MATRIX_EXT = $87C0; - GL_VARIANT_EXT = $87C1; - GL_INVARIANT_EXT = $87C2; - GL_LOCAL_CONSTANT_EXT = $87C3; - GL_LOCAL_EXT = $87C4; - GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5; - GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6; - GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7; - GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8; - GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9; - GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA; - GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB; - GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC; - GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD; - GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE; - GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF; - GL_VERTEX_SHADER_VARIANTS_EXT = $87D0; - GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1; - GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2; - GL_VERTEX_SHADER_LOCALS_EXT = $87D3; - GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4; - GL_X_EXT = $87D5; - GL_Y_EXT = $87D6; - GL_Z_EXT = $87D7; - GL_W_EXT = $87D8; - GL_NEGATIVE_X_EXT = $87D9; - GL_NEGATIVE_Y_EXT = $87DA; - GL_NEGATIVE_Z_EXT = $87DB; - GL_NEGATIVE_W_EXT = $87DC; - GL_ZERO_EXT = $87DD; - GL_ONE_EXT = $87DE; - GL_NEGATIVE_ONE_EXT = $87DF; - GL_NORMALIZED_RANGE_EXT = $87E0; - GL_FULL_RANGE_EXT = $87E1; - GL_CURRENT_VERTEX_EXT = $87E2; - GL_MVP_MATRIX_EXT = $87E3; - GL_VARIANT_VALUE_EXT = $87E4; - GL_VARIANT_DATATYPE_EXT = $87E5; - GL_VARIANT_ARRAY_STRIDE_EXT = $87E6; - GL_VARIANT_ARRAY_TYPE_EXT = $87E7; - GL_VARIANT_ARRAY_EXT = $87E8; - GL_VARIANT_ARRAY_POINTER_EXT = $87E9; - GL_INVARIANT_VALUE_EXT = $87EA; - GL_INVARIANT_DATATYPE_EXT = $87EB; - GL_LOCAL_CONSTANT_VALUE_EXT = $87EC; - GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED; - - // GL_EXT_vertex_weighting - GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3; - GL_MODELVIEW1_STACK_DEPTH_EXT = $8502; - GL_MODELVIEW0_MATRIX_EXT = $0BA6; - GL_MODELVIEW1_MATRIX_EXT = $8506; - GL_VERTEX_WEIGHTING_EXT = $8509; - GL_MODELVIEW0_EXT = $1700; - GL_MODELVIEW1_EXT = $850A; - GL_CURRENT_VERTEX_WEIGHT_EXT = $850B; - GL_VERTEX_WEIGHT_ARRAY_EXT = $850C; - GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D; - GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E; - GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F; - GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510; - - // GL_EXT_depth_bounds_test - GL_DEPTH_BOUNDS_TEST_EXT = $8890; - GL_DEPTH_BOUNDS_EXT = $8891; - - // GL_EXT_texture_mirror_clamp - GL_MIRROR_CLAMP_EXT = $8742; - GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743; - GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912; - - // GL_EXT_blend_equation_separate - GL_BLEND_EQUATION_RGB_EXT = $8009; - GL_BLEND_EQUATION_ALPHA_EXT = $883D; - - // GL_EXT_pixel_buffer_object - GL_PIXEL_PACK_BUFFER_EXT = $88EB; - GL_PIXEL_UNPACK_BUFFER_EXT = $88EC; - GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED; - GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF; - - // GL_EXT_stencil_clear_tag - GL_STENCIL_TAG_BITS_EXT = $88F2; - GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3; - - // GL_EXT_packed_depth_stencil - GL_DEPTH_STENCIL_EXT = $84F9; - GL_UNSIGNED_INT_24_8_EXT = $84FA; - GL_DEPTH24_STENCIL8_EXT = $88F0; - GL_TEXTURE_STENCIL_SIZE_EXT = $88F1; - - // GL_EXT_texture_sRGB - GL_SRGB_EXT = $8C40; - GL_SRGB8_EXT = $8C41; - GL_SRGB_ALPHA_EXT = $8C42; - GL_SRGB8_ALPHA8_EXT = $8C43; - GL_SLUMINANCE_ALPHA_EXT = $8C44; - GL_SLUMINANCE8_ALPHA8_EXT = $8C45; - GL_SLUMINANCE_EXT = $8C46; - GL_SLUMINANCE8_EXT = $8C47; - GL_COMPRESSED_SRGB_EXT = $8C48; - GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49; - GL_COMPRESSED_SLUMINANCE_EXT = $8C4A; - GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B; - GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C; - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D; - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E; - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F; - - // GL_EXT_framebuffer_blit - GL_READ_FRAMEBUFFER_EXT = $8CA8; - GL_DRAW_FRAMEBUFFER_EXT = $8CA9; - GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT; - GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA; - - // GL_EXT_framebuffer_multisample - GL_RENDERBUFFER_SAMPLES_EXT = $8CAB; - GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56; - GL_MAX_SAMPLES_EXT = $8D57; - - // GL_EXT_timer_query - GL_TIME_ELAPSED_EXT = $88BF; - - // GL_EXT_bindable_uniform - GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2; - GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3; - GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4; - GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED; - GL_UNIFORM_BUFFER_EXT = $8DEE; - GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF; - - // GL_EXT_framebuffer_sRGB - GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; - WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9; - GL_FRAMEBUFFER_SRGB_EXT = $8DB9; - GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA; - - // GL_EXT_geometry_shader4 - GL_GEOMETRY_SHADER_EXT = $8DD9; - GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA; - GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB; - GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC; - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29; - GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD; - GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE; - GL_MAX_VARYING_COMPONENTS_EXT = $8B4B; - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF; - GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0; - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1; - GL_LINES_ADJACENCY_EXT = $A; - GL_LINE_STRIP_ADJACENCY_EXT = $B; - GL_TRIANGLES_ADJACENCY_EXT = $C; - GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D; - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8; - GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9; - GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7; - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4; - GL_PROGRAM_POINT_SIZE_EXT = $8642; - - // GL_EXT_gpu_shader4 - GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD; - GL_SAMPLER_1D_ARRAY_EXT = $8DC0; - GL_SAMPLER_2D_ARRAY_EXT = $8DC1; - GL_SAMPLER_BUFFER_EXT = $8DC2; - GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3; - GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4; - GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5; - GL_UNSIGNED_INT_VEC2_EXT = $8DC6; - GL_UNSIGNED_INT_VEC3_EXT = $8DC7; - GL_UNSIGNED_INT_VEC4_EXT = $8DC8; - GL_INT_SAMPLER_1D_EXT = $8DC9; - GL_INT_SAMPLER_2D_EXT = $8DCA; - GL_INT_SAMPLER_3D_EXT = $8DCB; - GL_INT_SAMPLER_CUBE_EXT = $8DCC; - GL_INT_SAMPLER_2D_RECT_EXT = $8DCD; - GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE; - GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF; - GL_INT_SAMPLER_BUFFER_EXT = $8DD0; - GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1; - GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2; - GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3; - GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4; - GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5; - GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6; - GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7; - GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8; - GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904; - GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905; - - // GL_EXT_packed_float - GL_R11F_G11F_B10F_EXT = $8C3A; - GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B; - RGBA_SIGNED_COMPONENTS_EXT = $8C3C; - WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8; - GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; - GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; - - // GL_EXT_texture_array - GL_TEXTURE_1D_ARRAY_EXT = $8C18; - GL_TEXTURE_2D_ARRAY_EXT = $8C1A; - GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B; - GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19; - GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C; - GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D; - GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF; - GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E; - - // GL_EXT_texture_buffer_object - GL_TEXTURE_BUFFER_EXT = $8C2A; - GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B; - GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C; - GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D; - GL_TEXTURE_BUFFER_FORMAT_EXT = $8C2E; - - // GL_EXT_texture_compression_latc - GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70; - GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71; - GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72; - GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73; - - // GL_EXT_texture_compression_rgtc - GL_COMPRESSED_RED_RGTC1_EXT = $8DBB; - GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC; - GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD; - GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE; - - // GL_EXT_texture_integer - GL_RGBA_INTEGER_MODE_EXT = $8D9E; - GL_RGBA32UI_EXT = $8D70; - GL_RGB32UI_EXT = $8D71; - GL_ALPHA32UI_EXT = $8D72; - GL_INTENSITY32UI_EXT = $8D73; - GL_LUMINANCE32UI_EXT = $8D74; - GL_LUMINANCE_ALPHA32UI_EXT = $8D75; - GL_RGBA16UI_EXT = $8D76; - GL_RGB16UI_EXT = $8D77; - GL_ALPHA16UI_EXT = $8D78; - GL_INTENSITY16UI_EXT = $8D79; - GL_LUMINANCE16UI_EXT = $8D7A; - GL_LUMINANCE_ALPHA16UI_EXT = $8D7B; - GL_RGBA8UI_EXT = $8D7C; - GL_RGB8UI_EXT = $8D7D; - GL_ALPHA8UI_EXT = $8D7E; - GL_INTENSITY8UI_EXT = $8D7F; - GL_LUMINANCE8UI_EXT = $8D80; - GL_LUMINANCE_ALPHA8UI_EXT = $8D81; - GL_RGBA32I_EXT = $8D82; - GL_RGB32I_EXT = $8D83; - GL_ALPHA32I_EXT = $8D84; - GL_INTENSITY32I_EXT = $8D85; - GL_LUMINANCE32I_EXT = $8D86; - GL_LUMINANCE_ALPHA32I_EXT = $8D87; - GL_RGBA16I_EXT = $8D88; - GL_RGB16I_EXT = $8D89; - GL_ALPHA16I_EXT = $8D8A; - GL_INTENSITY16I_EXT = $8D8B; - GL_LUMINANCE16I_EXT = $8D8C; - GL_LUMINANCE_ALPHA16I_EXT = $8D8D; - GL_RGBA8I_EXT = $8D8E; - GL_RGB8I_EXT = $8D8F; - GL_ALPHA8I_EXT = $8D90; - GL_INTENSITY8I_EXT = $8D91; - GL_LUMINANCE8I_EXT = $8D92; - GL_LUMINANCE_ALPHA8I_EXT = $8D93; - GL_RED_INTEGER_EXT = $8D94; - GL_GREEN_INTEGER_EXT = $8D95; - GL_BLUE_INTEGER_EXT = $8D96; - GL_ALPHA_INTEGER_EXT = $8D97; - GL_RGB_INTEGER_EXT = $8D98; - GL_RGBA_INTEGER_EXT = $8D99; - GL_BGR_INTEGER_EXT = $8D9A; - GL_BGRA_INTEGER_EXT = $8D9B; - GL_LUMINANCE_INTEGER_EXT = $8D9C; - GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D; - - // GL_EXT_texture_shared_exponent - GL_RGB9_E5_EXT = $8C3D; - GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E; - GL_TEXTURE_SHARED_SIZE_EXT = $8C3F; - - // GL_EXT_transform_feedback - GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E; - GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84; - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85; - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F; - GL_INTERLEAVED_ATTRIBS_EXT = $8C8C; - GL_SEPARATE_ATTRIBS_EXT = $8C8D; - GL_PRIMITIVES_GENERATED_EXT = $8C87; - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88; - GL_RASTERIZER_DISCARD_EXT = $8C89; - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80; - GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83; - GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F; - GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76; - - // GL_EXT_direct_state_access - GL_PROGRAM_MATRIX_EXT = $8E2D; - GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E; - GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F; - - // GL_EXT_texture_swizzle - GL_TEXTURE_SWIZZLE_R_EXT = $8E42; - GL_TEXTURE_SWIZZLE_G_EXT = $8E43; - GL_TEXTURE_SWIZZLE_B_EXT = $8E44; - GL_TEXTURE_SWIZZLE_A_EXT = $8E45; - GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46; - - // GL_EXT_provoking_vertex - GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C; - GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D; - GL_LAST_VERTEX_CONVENTION_EXT = $8E4E; - GL_PROVOKING_VERTEX_EXT = $8E4F; - - // GL_EXT_texture_snorm - GL_ALPHA_SNORM = $9010; - GL_LUMINANCE_SNORM = $9011; - GL_LUMINANCE_ALPHA_SNORM = $9012; - GL_INTENSITY_SNORM = $9013; - GL_ALPHA8_SNORM = $9014; - GL_LUMINANCE8_SNORM = $9015; - GL_LUMINANCE8_ALPHA8_SNORM = $9016; - GL_INTENSITY8_SNORM = $9017; - GL_ALPHA16_SNORM = $9018; - GL_LUMINANCE16_SNORM = $9019; - GL_LUMINANCE16_ALPHA16_SNORM = $901A; - GL_INTENSITY16_SNORM = $901B; - { reuse GL_RED_SNORM } - { reuse GL_RG_SNORM } - { reuse GL_RGB_SNORM } - { reuse GL_RGBA_SNORM } - { reuse GL_R8_SNORM } - { reuse GL_RG8_SNORM } - { reuse GL_RGB8_SNORM } - { reuse GL_RGBA8_SNORM } - { reuse GL_R16_SNORM } - { reuse GL_RG16_SNORM } - { reuse GL_RGB16_SNORM } - { reuse GL_RGBA16_SNORM } - { reuse GL_SIGNED_NORMALIZED } - - // GL_EXT_separate_shader_objects - GL_ACTIVE_PROGRAM_EXT = $8B8D; - - // GL_EXT_shader_image_load_store - GL_MAX_IMAGE_UNITS_EXT = $8F38; - GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = $8F39; - GL_IMAGE_BINDING_NAME_EXT = $8F3A; - GL_IMAGE_BINDING_LEVEL_EXT = $8F3B; - GL_IMAGE_BINDING_LAYERED_EXT = $8F3C; - GL_IMAGE_BINDING_LAYER_EXT = $8F3D; - GL_IMAGE_BINDING_ACCESS_EXT = $8F3E; - GL_IMAGE_1D_EXT = $904C; - GL_IMAGE_2D_EXT = $904D; - GL_IMAGE_3D_EXT = $904E; - GL_IMAGE_2D_RECT_EXT = $904F; - GL_IMAGE_CUBE_EXT = $9050; - GL_IMAGE_BUFFER_EXT = $9051; - GL_IMAGE_1D_ARRAY_EXT = $9052; - GL_IMAGE_2D_ARRAY_EXT = $9053; - GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054; - GL_IMAGE_2D_MULTISAMPLE_EXT = $9055; - GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9056; - GL_INT_IMAGE_1D_EXT = $9057; - GL_INT_IMAGE_2D_EXT = $9058; - GL_INT_IMAGE_3D_EXT = $9059; - GL_INT_IMAGE_2D_RECT_EXT = $905A; - GL_INT_IMAGE_CUBE_EXT = $905B; - GL_INT_IMAGE_BUFFER_EXT = $905C; - GL_INT_IMAGE_1D_ARRAY_EXT = $905D; - GL_INT_IMAGE_2D_ARRAY_EXT = $905E; - GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F; - GL_INT_IMAGE_2D_MULTISAMPLE_EXT = $9060; - GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9061; - GL_UNSIGNED_INT_IMAGE_1D_EXT = $9062; - GL_UNSIGNED_INT_IMAGE_2D_EXT = $9063; - GL_UNSIGNED_INT_IMAGE_3D_EXT = $9064; - GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = $9065; - GL_UNSIGNED_INT_IMAGE_CUBE_EXT = $9066; - GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067; - GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = $9068; - GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = $9069; - GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A; - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = $906B; - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $906C; - GL_MAX_IMAGE_SAMPLES_EXT = $906D; - GL_IMAGE_BINDING_FORMAT_EXT = $906E; - GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = $00000001; - GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = $00000002; - GL_UNIFORM_BARRIER_BIT_EXT = $00000004; - GL_TEXTURE_FETCH_BARRIER_BIT_EXT = $00000008; - GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = $00000020; - GL_COMMAND_BARRIER_BIT_EXT = $00000040; - GL_PIXEL_BUFFER_BARRIER_BIT_EXT = $00000080; - GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = $00000100; - GL_BUFFER_UPDATE_BARRIER_BIT_EXT = $00000200; - GL_FRAMEBUFFER_BARRIER_BIT_EXT = $00000400; - GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = $00000800; - GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = $00001000; - GL_ALL_BARRIER_BITS_EXT = $FFFFFFFF; - - // GL_EXT_vertex_attrib_64bit - { reuse GL_DOUBLE } - GL_DOUBLE_VEC2_EXT = $8FFC; - GL_DOUBLE_VEC3_EXT = $8FFD; - GL_DOUBLE_VEC4_EXT = $8FFE; - GL_DOUBLE_MAT2_EXT = $8F46; - GL_DOUBLE_MAT3_EXT = $8F47; - GL_DOUBLE_MAT4_EXT = $8F48; - GL_DOUBLE_MAT2x3_EXT = $8F49; - GL_DOUBLE_MAT2x4_EXT = $8F4A; - GL_DOUBLE_MAT3x2_EXT = $8F4B; - GL_DOUBLE_MAT3x4_EXT = $8F4C; - GL_DOUBLE_MAT4x2_EXT = $8F4D; - GL_DOUBLE_MAT4x3_EXT = $8F4E; - - // GL_EXT_texture_sRGB_decode - GL_TEXTURE_SRGB_DECODE_EXT = $8A48; - GL_DECODE_EXT = $8A49; - GL_SKIP_DECODE_EXT = $8A4A; - - // GL_NV_texture_multisample - GL_TEXTURE_COVERAGE_SAMPLES_NV = $9045; - GL_TEXTURE_COLOR_SAMPLES_NV = $9046; - - // GL_AMD_blend_minmax_factor - GL_FACTOR_MIN_AMD = $901C; - GL_FACTOR_MAX_AMD = $901D; - - // GL_AMD_sample_positions - GL_SUBSAMPLE_DISTANCE_AMD = $883F; - - // GL_EXT_x11_sync_object - GL_SYNC_X11_FENCE_EXT = $90E1; - - // GL_EXT_framebuffer_multisample_blit_scaled - GL_SCALED_RESOLVE_FASTEST_EXT = $90BA; - GL_SCALED_RESOLVE_NICEST_EXT = $90BB; - - // (4.3) GL_NV_path_rendering - GL_PATH_FORMAT_SVG_NV = $9070; - GL_PATH_FORMAT_PS_NV = $9071; - GL_STANDARD_FONT_NAME_NV = $9072; - GL_SYSTEM_FONT_NAME_NV = $9073; - GL_FILE_NAME_NV = $9074; - GL_PATH_STROKE_WIDTH_NV = $9075; - GL_PATH_END_CAPS_NV = $9076; - GL_PATH_INITIAL_END_CAP_NV = $9077; - GL_PATH_TERMINAL_END_CAP_NV = $9078; - GL_PATH_JOIN_STYLE_NV = $9079; - GL_PATH_MITER_LIMIT_NV = $907A; - GL_PATH_DASH_CAPS_NV = $907B; - GL_PATH_INITIAL_DASH_CAP_NV = $907C; - GL_PATH_TERMINAL_DASH_CAP_NV = $907D; - GL_PATH_DASH_OFFSET_NV = $907E; - GL_PATH_CLIENT_LENGTH_NV = $907F; - GL_PATH_FILL_MODE_NV = $9080; - GL_PATH_FILL_MASK_NV = $9081; - GL_PATH_FILL_COVER_MODE_NV = $9082; - GL_PATH_STROKE_COVER_MODE_NV = $9083; - GL_PATH_STROKE_MASK_NV = $9084; - GL_PATH_SAMPLE_QUALITY_NV = $9085; - GL_PATH_STROKE_BOUND_NV = $9086; - GL_PATH_STROKE_OVERSAMPLE_COUNT_NV= $9087; - GL_COUNT_UP_NV = $9088; - GL_COUNT_DOWN_NV = $9089; - GL_PATH_OBJECT_BOUNDING_BOX_NV = $908A; - GL_CONVEX_HULL_NV = $908B; - GL_MULTI_HULLS_NV = $908C; - GL_BOUNDING_BOX_NV = $908D; - GL_TRANSLATE_X_NV = $908E; - GL_TRANSLATE_Y_NV = $908F; - GL_TRANSLATE_2D_NV = $9090; - GL_TRANSLATE_3D_NV = $9091; - GL_AFFINE_2D_NV = $9092; - GL_PROJECTIVE_2D_NV = $9093; - GL_AFFINE_3D_NV = $9094; - GL_PROJECTIVE_3D_NV = $9095; - GL_TRANSPOSE_AFFINE_2D_NV = $9096; - GL_TRANSPOSE_PROJECTIVE_2D_NV = $9097; - GL_TRANSPOSE_AFFINE_3D_NV = $9098; - GL_TRANSPOSE_PROJECTIVE_3D_NV = $9099; - GL_UTF8_NV = $909A; - GL_UTF16_NV = $909B; - GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV= $909C; - GL_PATH_COMMAND_COUNT_NV = $909D; - GL_PATH_COORD_COUNT_NV = $909E; - GL_PATH_DASH_ARRAY_COUNT_NV = $909F; - GL_PATH_COMPUTED_LENGTH_NV = $90A0; - GL_PATH_FILL_BOUNDING_BOX_NV = $90A1; - GL_PATH_STROKE_BOUNDING_BOX_NV = $90A2; - GL_SQUARE_NV = $90A3; - GL_ROUND_NV = $90A4; - GL_TRIANGULAR_NV = $90A5; - GL_BEVEL_NV = $90A6; - GL_MITER_REVERT_NV = $90A7; - GL_MITER_TRUNCATE_NV = $90A8; - GL_SKIP_MISSING_GLYPH_NV = $90A9; - GL_USE_MISSING_GLYPH_NV = $90AA; - GL_PATH_ERROR_POSITION_NV = $90AB; - GL_PATH_FOG_GEN_MODE_NV = $90AC; - GL_ACCUM_ADJACENT_PAIRS_NV = $90AD; - GL_ADJACENT_PAIRS_NV = $90AE; - GL_FIRST_TO_REST_NV = $90AF; - GL_PATH_GEN_MODE_NV = $90B0; - GL_PATH_GEN_COEFF_NV = $90B1; - GL_PATH_GEN_COLOR_FORMAT_NV = $90B2; - GL_PATH_GEN_COMPONENTS_NV = $90B3; - GL_PATH_STENCIL_FUNC_NV = $90B7; - GL_PATH_STENCIL_REF_NV = $90B8; - GL_PATH_STENCIL_VALUE_MASK_NV = $90B9; - GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV= $90BD; - GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV= $90BE; - GL_PATH_COVER_DEPTH_FUNC_NV = $90BF; - GL_PATH_DASH_OFFSET_RESET_NV = $90B4; - GL_MOVE_TO_RESETS_NV = $90B5; - GL_MOVE_TO_CONTINUES_NV = $90B6; - GL_CLOSE_PATH_NV = $00; - GL_MOVE_TO_NV = $02; - GL_RELATIVE_MOVE_TO_NV = $03; - GL_LINE_TO_NV = $04; - GL_RELATIVE_LINE_TO_NV = $05; - GL_HORIZONTAL_LINE_TO_NV = $06; - GL_RELATIVE_HORIZONTAL_LINE_TO_NV= $07; - GL_VERTICAL_LINE_TO_NV = $08; - GL_RELATIVE_VERTICAL_LINE_TO_NV = $09; - GL_QUADRATIC_CURVE_TO_NV = $0A; - GL_RELATIVE_QUADRATIC_CURVE_TO_NV= $0B; - GL_CUBIC_CURVE_TO_NV = $0C; - GL_RELATIVE_CUBIC_CURVE_TO_NV = $0D; - GL_SMOOTH_QUADRATIC_CURVE_TO_NV = $0E; - GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV= $0F; - GL_SMOOTH_CUBIC_CURVE_TO_NV = $10; - GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV= $11; - GL_SMALL_CCW_ARC_TO_NV = $12; - GL_RELATIVE_SMALL_CCW_ARC_TO_NV = $13; - GL_SMALL_CW_ARC_TO_NV = $14; - GL_RELATIVE_SMALL_CW_ARC_TO_NV = $15; - GL_LARGE_CCW_ARC_TO_NV = $16; - GL_RELATIVE_LARGE_CCW_ARC_TO_NV = $17; - GL_LARGE_CW_ARC_TO_NV = $18; - GL_RELATIVE_LARGE_CW_ARC_TO_NV = $19; - GL_RESTART_PATH_NV = $F0; - GL_DUP_FIRST_CUBIC_CURVE_TO_NV = $F2; - GL_DUP_LAST_CUBIC_CURVE_TO_NV = $F4; - GL_RECT_NV = $F6; - GL_CIRCULAR_CCW_ARC_TO_NV = $F8; - GL_CIRCULAR_CW_ARC_TO_NV = $FA; - GL_CIRCULAR_TANGENT_ARC_TO_NV = $FC; - GL_ARC_TO_NV = $FE; - GL_RELATIVE_ARC_TO_NV = $FF; - GL_BOLD_BIT_NV = $01; - GL_ITALIC_BIT_NV = $02; - GL_GLYPH_WIDTH_BIT_NV = $01; - GL_GLYPH_HEIGHT_BIT_NV = $02; - GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV= $04; - GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV= $08; - GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV= $10; - GL_GLYPH_VERTICAL_BEARING_X_BIT_NV= $20; - GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV= $40; - GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV= $80; - GL_GLYPH_HAS_KERNING_NV = $100; - GL_FONT_X_MIN_BOUNDS_NV = $00010000; - GL_FONT_Y_MIN_BOUNDS_NV = $00020000; - GL_FONT_X_MAX_BOUNDS_NV = $00040000; - GL_FONT_Y_MAX_BOUNDS_NV = $00080000; - GL_FONT_UNITS_PER_EM_NV = $00100000; - GL_FONT_ASCENDER_NV = $00200000; - GL_FONT_DESCENDER_NV = $00400000; - GL_FONT_HEIGHT_NV = $00800000; - GL_FONT_MAX_ADVANCE_WIDTH_NV = $01000000; - GL_FONT_MAX_ADVANCE_HEIGHT_NV = $02000000; - GL_FONT_UNDERLINE_POSITION_NV = $04000000; - GL_FONT_UNDERLINE_THICKNESS_NV = $08000000; - GL_FONT_HAS_KERNING_NV = $10000000; - - // (4.3) GL_AMD_pinned_memory - GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD= $9160; - - // (4.3) GL_AMD_stencil_operation_extended - GL_SET_AMD = $874A; - GL_REPLACE_VALUE_AMD = $874B; - GL_STENCIL_OP_VALUE_AMD = $874C; - GL_STENCIL_BACK_OP_VALUE_AMD = $874D; - - // (4.3) GL_AMD_vertex_shader_viewport_index - - // (4.3) GL_AMD_vertex_shader_layer - - // (4.3) GL_NV_bindless_texture - - // (4.3) GL_NV_shader_atomic_float - - // (4.3) GL_AMD_query_buffer_object - GL_QUERY_BUFFER_AMD = $9192; - GL_QUERY_BUFFER_BINDING_AMD = $9193; - GL_QUERY_RESULT_NO_WAIT_AMD = $9194; - - // GL_FfdMaskSGIX - GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001; - GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002; - - // GL_HP_convolution_border_modes - GL_IGNORE_BORDER_HP = $8150; - GL_CONSTANT_BORDER_HP = $8151; - GL_REPLICATE_BORDER_HP = $8153; - GL_CONVOLUTION_BORDER_COLOR_HP = $8154; - - // GL_HP_image_transform - GL_IMAGE_SCALE_X_HP = $8155; - GL_IMAGE_SCALE_Y_HP = $8156; - GL_IMAGE_TRANSLATE_X_HP = $8157; - GL_IMAGE_TRANSLATE_Y_HP = $8158; - GL_IMAGE_ROTATE_ANGLE_HP = $8159; - GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A; - GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B; - GL_IMAGE_MAG_FILTER_HP = $815C; - GL_IMAGE_MIN_FILTER_HP = $815D; - GL_IMAGE_CUBIC_WEIGHT_HP = $815E; - GL_CUBIC_HP = $815F; - GL_AVERAGE_HP = $8160; - GL_IMAGE_TRANSFORM_2D_HP = $8161; - GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162; - GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163; - - // GL_HP_occlusion_test - GL_OCCLUSION_TEST_HP = $8165; - GL_OCCLUSION_TEST_RESULT_HP = $8166; - - // GL_HP_texture_lighting - GL_TEXTURE_LIGHTING_MODE_HP = $8167; - GL_TEXTURE_POST_SPECULAR_HP = $8168; - GL_TEXTURE_PRE_SPECULAR_HP = $8169; - - // GL_IBM_cull_vertex - GL_CULL_VERTEX_IBM = 103050; - - // GL_IBM_rasterpos_clip - GL_RASTER_POSITION_UNCLIPPED_IBM = $19262; - - // GL_IBM_texture_mirrored_repeat - GL_MIRRORED_REPEAT_IBM = $8370; - - // GL_IBM_vertex_array_lists - GL_VERTEX_ARRAY_LIST_IBM = 103070; - GL_NORMAL_ARRAY_LIST_IBM = 103071; - GL_COLOR_ARRAY_LIST_IBM = 103072; - GL_INDEX_ARRAY_LIST_IBM = 103073; - GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074; - GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075; - GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076; - GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077; - GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080; - GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081; - GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082; - GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083; - GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084; - GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085; - GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086; - GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087; - - // GL_INGR_color_clamp - GL_RED_MIN_CLAMP_INGR = $8560; - GL_GREEN_MIN_CLAMP_INGR = $8561; - GL_BLUE_MIN_CLAMP_INGR = $8562; - GL_ALPHA_MIN_CLAMP_INGR = $8563; - GL_RED_MAX_CLAMP_INGR = $8564; - GL_GREEN_MAX_CLAMP_INGR = $8565; - GL_BLUE_MAX_CLAMP_INGR = $8566; - GL_ALPHA_MAX_CLAMP_INGR = $8567; - - // GL_INGR_interlace_read - GL_INTERLACE_READ_INGR = $8568; - - // GL_INTEL_parallel_arrays - GL_PARALLEL_ARRAYS_INTEL = $83F4; - GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5; - GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6; - GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7; - GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8; - - // GL_NV_copy_depth_to_color - GL_DEPTH_STENCIL_TO_RGBA_NV = $886E; - GL_DEPTH_STENCIL_TO_BGRA_NV = $886F; - - // GL_NV_depth_clamp - GL_DEPTH_CLAMP_NV = $864F; - - // GL_NV_evaluators - GL_EVAL_2D_NV = $86C0; - GL_EVAL_TRIANGULAR_2D_NV = $86C1; - GL_MAP_TESSELLATION_NV = $86C2; - GL_MAP_ATTRIB_U_ORDER_NV = $86C3; - GL_MAP_ATTRIB_V_ORDER_NV = $86C4; - GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5; - GL_EVAL_VERTEX_ATTRIB0_NV = $86C6; - GL_EVAL_VERTEX_ATTRIB1_NV = $86C7; - GL_EVAL_VERTEX_ATTRIB2_NV = $86C8; - GL_EVAL_VERTEX_ATTRIB3_NV = $86C9; - GL_EVAL_VERTEX_ATTRIB4_NV = $86CA; - GL_EVAL_VERTEX_ATTRIB5_NV = $86CB; - GL_EVAL_VERTEX_ATTRIB6_NV = $86CC; - GL_EVAL_VERTEX_ATTRIB7_NV = $86CD; - GL_EVAL_VERTEX_ATTRIB8_NV = $86CE; - GL_EVAL_VERTEX_ATTRIB9_NV = $86CF; - GL_EVAL_VERTEX_ATTRIB10_NV = $86D0; - GL_EVAL_VERTEX_ATTRIB11_NV = $86D1; - GL_EVAL_VERTEX_ATTRIB12_NV = $86D2; - GL_EVAL_VERTEX_ATTRIB13_NV = $86D3; - GL_EVAL_VERTEX_ATTRIB14_NV = $86D4; - GL_EVAL_VERTEX_ATTRIB15_NV = $86D5; - GL_MAX_MAP_TESSELLATION_NV = $86D6; - GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7; - - // GL_NV_fence - GL_ALL_COMPLETED_NV = $84F2; - GL_FENCE_STATUS_NV = $84F3; - GL_FENCE_CONDITION_NV = $84F4; - - // GL_NV_float_buffer - GL_FLOAT_R_NV = $8880; - GL_FLOAT_RG_NV = $8881; - GL_FLOAT_RGB_NV = $8882; - GL_FLOAT_RGBA_NV = $8883; - GL_FLOAT_R16_NV = $8884; - GL_FLOAT_R32_NV = $8885; - GL_FLOAT_RG16_NV = $8886; - GL_FLOAT_RG32_NV = $8887; - GL_FLOAT_RGB16_NV = $8888; - GL_FLOAT_RGB32_NV = $8889; - GL_FLOAT_RGBA16_NV = $888A; - GL_FLOAT_RGBA32_NV = $888B; - GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C; - GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D; - GL_FLOAT_RGBA_MODE_NV = $888E; - - // GL_NV_fog_distance - GL_FOG_DISTANCE_MODE_NV = $855A; - GL_EYE_RADIAL_NV = $855B; - GL_EYE_PLANE_ABSOLUTE_NV = $855C; - - // GL_NV_fragment_program - GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868; - GL_FRAGMENT_PROGRAM_NV = $8870; - GL_MAX_TEXTURE_COORDS_NV = $8871; - GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872; - GL_FRAGMENT_PROGRAM_BINDING_NV = $8873; - GL_PROGRAM_ERROR_STRING_NV = $8874; - - // GL_NV_half_float - GL_HALF_FLOAT_NV = $140B; - - // GL_NV_light_max_exponent - GL_MAX_SHININESS_NV = $8504; - GL_MAX_SPOT_EXPONENT_NV = $8505; - - // GL_NV_multisample_filter_hint - GL_MULTISAMPLE_FILTER_HINT_NV = $8534; - - // GL_NV_occlusion_query - GL_PIXEL_COUNTER_BITS_NV = $8864; - GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865; - GL_PIXEL_COUNT_NV = $8866; - GL_PIXEL_COUNT_AVAILABLE_NV = $8867; - - // GL_NV_packed_depth_stencil - GL_DEPTH_STENCIL_NV = $84F9; - GL_UNSIGNED_INT_24_8_NV = $84FA; - - // GL_NV_pixel_data_range - GL_WRITE_PIXEL_DATA_RANGE_NV = $8878; - GL_READ_PIXEL_DATA_RANGE_NV = $8879; - GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A; - GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B; - GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C; - GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D; - - // GL_NV_point_sprite - GL_POINT_SPRITE_NV = $8861; - GL_COORD_REPLACE_NV = $8862; - GL_POINT_SPRITE_R_MODE_NV = $8863; - - // GL_NV_primitive_restart - GL_PRIMITIVE_RESTART_NV = $8558; - GL_PRIMITIVE_RESTART_INDEX_NV = $8559; - - // GL_NV_register_combiners - GL_REGISTER_COMBINERS_NV = $8522; - GL_VARIABLE_A_NV = $8523; - GL_VARIABLE_B_NV = $8524; - GL_VARIABLE_C_NV = $8525; - GL_VARIABLE_D_NV = $8526; - GL_VARIABLE_E_NV = $8527; - GL_VARIABLE_F_NV = $8528; - GL_VARIABLE_G_NV = $8529; - GL_CONSTANT_COLOR0_NV = $852A; - GL_CONSTANT_COLOR1_NV = $852B; - GL_PRIMARY_COLOR_NV = $852C; - GL_SECONDARY_COLOR_NV = $852D; - GL_SPARE0_NV = $852E; - GL_SPARE1_NV = $852F; - GL_DISCARD_NV = $8530; - GL_E_TIMES_F_NV = $8531; - GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532; - GL_UNSIGNED_IDENTITY_NV = $8536; - GL_UNSIGNED_INVERT_NV = $8537; - GL_EXPAND_NORMAL_NV = $8538; - GL_EXPAND_NEGATE_NV = $8539; - GL_HALF_BIAS_NORMAL_NV = $853A; - GL_HALF_BIAS_NEGATE_NV = $853B; - GL_SIGNED_IDENTITY_NV = $853C; - GL_SIGNED_NEGATE_NV = $853D; - GL_SCALE_BY_TWO_NV = $853E; - GL_SCALE_BY_FOUR_NV = $853F; - GL_SCALE_BY_ONE_HALF_NV = $8540; - GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541; - GL_COMBINER_INPUT_NV = $8542; - GL_COMBINER_MAPPING_NV = $8543; - GL_COMBINER_COMPONENT_USAGE_NV = $8544; - GL_COMBINER_AB_DOT_PRODUCT_NV = $8545; - GL_COMBINER_CD_DOT_PRODUCT_NV = $8546; - GL_COMBINER_MUX_SUM_NV = $8547; - GL_COMBINER_SCALE_NV = $8548; - GL_COMBINER_BIAS_NV = $8549; - GL_COMBINER_AB_OUTPUT_NV = $854A; - GL_COMBINER_CD_OUTPUT_NV = $854B; - GL_COMBINER_SUM_OUTPUT_NV = $854C; - GL_MAX_GENERAL_COMBINERS_NV = $854D; - GL_NUM_GENERAL_COMBINERS_NV = $854E; - GL_COLOR_SUM_CLAMP_NV = $854F; - GL_COMBINER0_NV = $8550; - GL_COMBINER1_NV = $8551; - GL_COMBINER2_NV = $8552; - GL_COMBINER3_NV = $8553; - GL_COMBINER4_NV = $8554; - GL_COMBINER5_NV = $8555; - GL_COMBINER6_NV = $8556; - GL_COMBINER7_NV = $8557; - - // GL_NV_register_combiners2 - GL_PER_STAGE_CONSTANTS_NV = $8535; - - // GL_NV_texgen_emboss - GL_EMBOSS_LIGHT_NV = $855D; - GL_EMBOSS_CONSTANT_NV = $855E; - GL_EMBOSS_MAP_NV = $855F; - - // GL_NV_texgen_reflection - GL_NORMAL_MAP_NV = $8511; - GL_REFLECTION_MAP_NV = $8512; - - // GL_NV_texture_env_combine4 - GL_COMBINE4_NV = $8503; - GL_SOURCE3_RGB_NV = $8583; - GL_SOURCE3_ALPHA_NV = $858B; - GL_OPERAND3_RGB_NV = $8593; - GL_OPERAND3_ALPHA_NV = $859B; - - // GL_NV_texture_expand_normal - GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F; - - // GL_NV_texture_rectangle - GL_TEXTURE_RECTANGLE_NV = $84F5; - GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6; - GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7; - GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8; - - // GL_NV_texture_shader - GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C; - GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D; - GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E; - GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9; - GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA; - GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB; - GL_DSDT_MAG_INTENSITY_NV = $86DC; - GL_SHADER_CONSISTENT_NV = $86DD; - GL_TEXTURE_SHADER_NV = $86DE; - GL_SHADER_OPERATION_NV = $86DF; - GL_CULL_MODES_NV = $86E0; - GL_OFFSET_TEXTURE_MATRIX_NV = $86E1; - GL_OFFSET_TEXTURE_SCALE_NV = $86E2; - GL_OFFSET_TEXTURE_BIAS_NV = $86E3; - GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV; - GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV; - GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV; - GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4; - GL_CONST_EYE_NV = $86E5; - GL_PASS_THROUGH_NV = $86E6; - GL_CULL_FRAGMENT_NV = $86E7; - GL_OFFSET_TEXTURE_2D_NV = $86E8; - GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9; - GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA; - GL_DOT_PRODUCT_NV = $86EC; - GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED; - GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE; - GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0; - GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1; - GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2; - GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3; - GL_HILO_NV = $86F4; - GL_DSDT_NV = $86F5; - GL_DSDT_MAG_NV = $86F6; - GL_DSDT_MAG_VIB_NV = $86F7; - GL_HILO16_NV = $86F8; - GL_SIGNED_HILO_NV = $86F9; - GL_SIGNED_HILO16_NV = $86FA; - GL_SIGNED_RGBA_NV = $86FB; - GL_SIGNED_RGBA8_NV = $86FC; - GL_SIGNED_RGB_NV = $86FE; - GL_SIGNED_RGB8_NV = $86FF; - GL_SIGNED_LUMINANCE_NV = $8701; - GL_SIGNED_LUMINANCE8_NV = $8702; - GL_SIGNED_LUMINANCE_ALPHA_NV = $8703; - GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704; - GL_SIGNED_ALPHA_NV = $8705; - GL_SIGNED_ALPHA8_NV = $8706; - GL_SIGNED_INTENSITY_NV = $8707; - GL_SIGNED_INTENSITY8_NV = $8708; - GL_DSDT8_NV = $8709; - GL_DSDT8_MAG8_NV = $870A; - GL_DSDT8_MAG8_INTENSITY8_NV = $870B; - GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C; - GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D; - GL_HI_SCALE_NV = $870E; - GL_LO_SCALE_NV = $870F; - GL_DS_SCALE_NV = $8710; - GL_DT_SCALE_NV = $8711; - GL_MAGNITUDE_SCALE_NV = $8712; - GL_VIBRANCE_SCALE_NV = $8713; - GL_HI_BIAS_NV = $8714; - GL_LO_BIAS_NV = $8715; - GL_DS_BIAS_NV = $8716; - GL_DT_BIAS_NV = $8717; - GL_MAGNITUDE_BIAS_NV = $8718; - GL_VIBRANCE_BIAS_NV = $8719; - GL_TEXTURE_BORDER_VALUES_NV = $871A; - GL_TEXTURE_HI_SIZE_NV = $871B; - GL_TEXTURE_LO_SIZE_NV = $871C; - GL_TEXTURE_DS_SIZE_NV = $871D; - GL_TEXTURE_DT_SIZE_NV = $871E; - GL_TEXTURE_MAG_SIZE_NV = $871F; - - // GL_NV_texture_shader2 - GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF; - - // GL_NV_texture_shader3 - GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850; - GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851; - GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852; - GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853; - GL_OFFSET_HILO_TEXTURE_2D_NV = $8854; - GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855; - GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856; - GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857; - GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858; - GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859; - GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A; - GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B; - GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C; - GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D; - GL_HILO8_NV = $885E; - GL_SIGNED_HILO8_NV = $885F; - GL_FORCE_BLUE_TO_ONE_NV = $8860; - - // GL_NV_vertex_array_range - GL_VERTEX_ARRAY_RANGE_NV = $851D; - GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E; - GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F; - GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520; - GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521; - - // GL_NV_vertex_array_range2 - GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533; - - // GL_NV_vertex_program - GL_VERTEX_PROGRAM_NV = $8620; - GL_VERTEX_STATE_PROGRAM_NV = $8621; - GL_ATTRIB_ARRAY_SIZE_NV = $8623; - GL_ATTRIB_ARRAY_STRIDE_NV = $8624; - GL_ATTRIB_ARRAY_TYPE_NV = $8625; - GL_CURRENT_ATTRIB_NV = $8626; - GL_PROGRAM_LENGTH_NV = $8627; - GL_PROGRAM_STRING_NV = $8628; - GL_MODELVIEW_PROJECTION_NV = $8629; - GL_IDENTITY_NV = $862A; - GL_INVERSE_NV = $862B; - GL_TRANSPOSE_NV = $862C; - GL_INVERSE_TRANSPOSE_NV = $862D; - GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E; - GL_MAX_TRACK_MATRICES_NV = $862F; - GL_MATRIX0_NV = $8630; - GL_MATRIX1_NV = $8631; - GL_MATRIX2_NV = $8632; - GL_MATRIX3_NV = $8633; - GL_MATRIX4_NV = $8634; - GL_MATRIX5_NV = $8635; - GL_MATRIX6_NV = $8636; - GL_MATRIX7_NV = $8637; - GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640; - GL_CURRENT_MATRIX_NV = $8641; - GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642; - GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643; - GL_PROGRAM_PARAMETER_NV = $8644; - GL_ATTRIB_ARRAY_POINTER_NV = $8645; - GL_PROGRAM_TARGET_NV = $8646; - GL_PROGRAM_RESIDENT_NV = $8647; - GL_TRACK_MATRIX_NV = $8648; - GL_TRACK_MATRIX_TRANSFORM_NV = $8649; - GL_VERTEX_PROGRAM_BINDING_NV = $864A; - GL_PROGRAM_ERROR_POSITION_NV = $864B; - GL_VERTEX_ATTRIB_ARRAY0_NV = $8650; - GL_VERTEX_ATTRIB_ARRAY1_NV = $8651; - GL_VERTEX_ATTRIB_ARRAY2_NV = $8652; - GL_VERTEX_ATTRIB_ARRAY3_NV = $8653; - GL_VERTEX_ATTRIB_ARRAY4_NV = $8654; - GL_VERTEX_ATTRIB_ARRAY5_NV = $8655; - GL_VERTEX_ATTRIB_ARRAY6_NV = $8656; - GL_VERTEX_ATTRIB_ARRAY7_NV = $8657; - GL_VERTEX_ATTRIB_ARRAY8_NV = $8658; - GL_VERTEX_ATTRIB_ARRAY9_NV = $8659; - GL_VERTEX_ATTRIB_ARRAY10_NV = $865A; - GL_VERTEX_ATTRIB_ARRAY11_NV = $865B; - GL_VERTEX_ATTRIB_ARRAY12_NV = $865C; - GL_VERTEX_ATTRIB_ARRAY13_NV = $865D; - GL_VERTEX_ATTRIB_ARRAY14_NV = $865E; - GL_VERTEX_ATTRIB_ARRAY15_NV = $865F; - GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660; - GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661; - GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662; - GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663; - GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664; - GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665; - GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666; - GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667; - GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668; - GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669; - GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A; - GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B; - GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C; - GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D; - GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E; - GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F; - GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670; - GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671; - GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672; - GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673; - GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674; - GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675; - GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676; - GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677; - GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678; - GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679; - GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A; - GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B; - GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C; - GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D; - GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E; - GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F; - - // GL_NV_fragment_program2 and GL_NV_vertex_program2_option - GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4; - GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5; - - // GL_NV_fragment_program2 - GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6; - GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7; - GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8; - - // GL_NV_vertex_program3 - MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; - - // GL_NV_depth_buffer_float - GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD; - GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF; - - // GL_NV_framebuffer_multisample_coverage - GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB; - GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10; - - // GL_NV_geometry_program4 - GL_GEOMETRY_PROGRAM_NV = $8C26; - GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27; - GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28; - - // GL_NV_gpu_program4 - GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906; - GL_PROGRAM_RESULT_COMPONENTS_NV = $8907; - GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908; - GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909; - GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5; - GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6; - - // GL_NV_parameter_buffer_object - GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0; - GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1; - GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2; - GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3; - GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4; - - // GL_NV_transform_feedback - GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E; - GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84; - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85; - GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86; - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F; - GL_INTERLEAVED_ATTRIBS_NV = $8C8C; - GL_SEPARATE_ATTRIBS_NV = $8C8D; - GL_PRIMITIVES_GENERATED_NV = $8C87; - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88; - GL_RASTERIZER_DISCARD_NV = $8C89; - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B; - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80; - GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E; - GL_ACTIVE_VARYINGS_NV = $8C81; - GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82; - GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83; - GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F; - GL_BACK_PRIMARY_COLOR_NV = $8C77; - GL_BACK_SECONDARY_COLOR_NV = $8C78; - GL_TEXTURE_COORD_NV = $8C79; - GL_CLIP_DISTANCE_NV = $8C7A; - GL_VERTEX_ID_NV = $8C7B; - GL_PRIMITIVE_ID_NV = $8C7C; - GL_GENERIC_ATTRIB_NV = $8C7D; - GL_LAYER_NV = $8DAA; - GL_NEXT_BUFFER_NV = -2; - GL_SKIP_COMPONENTS4_NV = -3; - GL_SKIP_COMPONENTS3_NV = -4; - GL_SKIP_COMPONENTS2_NV = -5; - GL_SKIP_COMPONENTS1_NV = -6; - - // GL_NV_conditional_render - GL_QUERY_WAIT_NV = $8E13; - GL_QUERY_NO_WAIT_NV = $8E14; - GL_QUERY_BY_REGION_WAIT_NV = $8E15; - GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16; - - // GL_NV_present_video - GL_FRAME_NV = $8E26; - GL_FIELDS_NV = $8E27; - GL_CURRENT_TIME_NV = $8E28; - GL_NUM_FILL_STREAMS_NV = $8E29; - GL_PRESENT_TIME_NV = $8E2A; - GL_PRESENT_DURATION_NV = $8E2B; - - // GL_NV_explicit_multisample - GL_SAMPLE_POSITION_NV = $8E50; - GL_SAMPLE_MASK_NV = $8E51; - GL_SAMPLE_MASK_VALUE_NV = $8E52; - GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53; - GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54; - GL_TEXTURE_RENDERBUFFER_NV = $8E55; - GL_SAMPLER_RENDERBUFFER_NV = $8E56; - GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57; - GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58; - GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59; - - // GL_NV_transform_feedback2 - GL_TRANSFORM_FEEDBACK_NV = $8E22; - GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23; - GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24; - GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25; - - // GL_NV_video_capture - GL_VIDEO_BUFFER_NV = $9020; - GL_VIDEO_BUFFER_BINDING_NV = $9021; - GL_FIELD_UPPER_NV = $9022; - GL_FIELD_LOWER_NV = $9023; - GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024; - GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025; - GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026; - GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027; - GL_VIDEO_BUFFER_PITCH_NV = $9028; - GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029; - GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A; - GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B; - GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C; - GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D; - GL_PARTIAL_SUCCESS_NV = $902E; - GL_SUCCESS_NV = $902F; - GL_FAILURE_NV = $9030; - GL_YCBYCR8_422_NV = $9031; - GL_YCBAYCR8A_4224_NV = $9032; - GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033; - GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034; - GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035; - GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036; - GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037; - GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038; - GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039; - GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A; - GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B; - GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C; - - // GL_NV_shader_buffer_load - GL_BUFFER_GPU_ADDRESS_NV = $8F1D; - GL_GPU_ADDRESS_NV = $8F34; - GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35; - - // GL_NV_vertex_buffer_unified_memory - GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E; - GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F; - GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20; - GL_VERTEX_ARRAY_ADDRESS_NV = $8F21; - GL_NORMAL_ARRAY_ADDRESS_NV = $8F22; - GL_COLOR_ARRAY_ADDRESS_NV = $8F23; - GL_INDEX_ARRAY_ADDRESS_NV = $8F24; - GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25; - GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26; - GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27; - GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28; - GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29; - GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A; - GL_VERTEX_ARRAY_LENGTH_NV = $8F2B; - GL_NORMAL_ARRAY_LENGTH_NV = $8F2C; - GL_COLOR_ARRAY_LENGTH_NV = $8F2D; - GL_INDEX_ARRAY_LENGTH_NV = $8F2E; - GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F; - GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30; - GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31; - GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32; - GL_ELEMENT_ARRAY_LENGTH_NV = $8F33; - GL_DRAW_INDIRECT_UNIFIED_NV = $8F40; - GL_DRAW_INDIRECT_ADDRESS_NV = $8F41; - GL_DRAW_INDIRECT_LENGTH_NV = $8F42; - - // GL_NV_gpu_program5 - GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A; - GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B; - GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C; - GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D; - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E; - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F; - GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44; - GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45; - - // GL_NV_gpu_shader5 - GL_INT64_NV = $140E; - GL_UNSIGNED_INT64_NV = $140F; - GL_INT8_NV = $8FE0; - GL_INT8_VEC2_NV = $8FE1; - GL_INT8_VEC3_NV = $8FE2; - GL_INT8_VEC4_NV = $8FE3; - GL_INT16_NV = $8FE4; - GL_INT16_VEC2_NV = $8FE5; - GL_INT16_VEC3_NV = $8FE6; - GL_INT16_VEC4_NV = $8FE7; - GL_INT64_VEC2_NV = $8FE9; - GL_INT64_VEC3_NV = $8FEA; - GL_INT64_VEC4_NV = $8FEB; - GL_UNSIGNED_INT8_NV = $8FEC; - GL_UNSIGNED_INT8_VEC2_NV = $8FED; - GL_UNSIGNED_INT8_VEC3_NV = $8FEE; - GL_UNSIGNED_INT8_VEC4_NV = $8FEF; - GL_UNSIGNED_INT16_NV = $8FF0; - GL_UNSIGNED_INT16_VEC2_NV = $8FF1; - GL_UNSIGNED_INT16_VEC3_NV = $8FF2; - GL_UNSIGNED_INT16_VEC4_NV = $8FF3; - GL_UNSIGNED_INT64_VEC2_NV = $8FF5; - GL_UNSIGNED_INT64_VEC3_NV = $8FF6; - GL_UNSIGNED_INT64_VEC4_NV = $8FF7; - GL_FLOAT16_NV = $8FF8; - GL_FLOAT16_VEC2_NV = $8FF9; - GL_FLOAT16_VEC3_NV = $8FFA; - GL_FLOAT16_VEC4_NV = $8FFB; - { reuse GL_PATCHES } - - // GL_NV_shader_buffer_store - GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010; - { reuse GL_READ_WRITE } - { reuse GL_WRITE_ONLY } - - // GL_NV_tessellation_program5 - GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8; - GL_TESS_CONTROL_PROGRAM_NV = $891E; - GL_TESS_EVALUATION_PROGRAM_NV = $891F; - GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74; - GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75; - - // GL_NV_vertex_attrib_integer_64bit - { reuse GL_INT64_NV } - { reuse GL_UNSIGNED_INT64_NV } - - // GL_NV_multisample_coverage - GL_COVERAGE_SAMPLES_NV = $80A9; - GL_COLOR_SAMPLES_NV = $8E20; - - // GL_NV_vdpau_interop - GL_SURFACE_STATE_NV = $86EB; - GL_SURFACE_REGISTERED_NV = $86FD; - GL_SURFACE_MAPPED_NV = $8700; - GL_WRITE_DISCARD_NV = $88BE; - - // GL_OML_interlace - GL_INTERLACE_OML = $8980; - GL_INTERLACE_READ_OML = $8981; - - // GL_OML_resample - GL_PACK_RESAMPLE_OML = $8984; - GL_UNPACK_RESAMPLE_OML = $8985; - GL_RESAMPLE_REPLICATE_OML = $8986; - GL_RESAMPLE_ZERO_FILL_OML = $8987; - GL_RESAMPLE_AVERAGE_OML = $8988; - GL_RESAMPLE_DECIMATE_OML = $8989; - - // GL_OML_subsample - GL_FORMAT_SUBSAMPLE_24_24_OML = $8982; - GL_FORMAT_SUBSAMPLE_244_244_OML = $8983; - - // GL_PGI_misc_hints - GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8; - GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD; - GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE; - GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202; - GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203; - GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204; - GL_ALWAYS_FAST_HINT_PGI = $1A20C; - GL_ALWAYS_SOFT_HINT_PGI = $1A20D; - GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E; - GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F; - GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210; - GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211; - GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216; - GL_STRICT_LIGHTING_HINT_PGI = $1A217; - GL_STRICT_SCISSOR_HINT_PGI = $1A218; - GL_FULL_STIPPLE_HINT_PGI = $1A219; - GL_CLIP_NEAR_HINT_PGI = $1A220; - GL_CLIP_FAR_HINT_PGI = $1A221; - GL_WIDE_LINE_HINT_PGI = $1A222; - GL_BACK_NORMALS_HINT_PGI = $1A223; - - // GL_PGI_vertex_hints - GL_VERTEX_DATA_HINT_PGI = $1A22A; - GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B; - GL_MATERIAL_SIDE_HINT_PGI = $1A22C; - GL_MAX_VERTEX_HINT_PGI = $1A22D; - GL_COLOR3_BIT_PGI = $00010000; - GL_COLOR4_BIT_PGI = $00020000; - GL_EDGEFLAG_BIT_PGI = $00040000; - GL_INDEX_BIT_PGI = $00080000; - GL_MAT_AMBIENT_BIT_PGI = $00100000; - GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000; - GL_MAT_DIFFUSE_BIT_PGI = $00400000; - GL_MAT_EMISSION_BIT_PGI = $00800000; - GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000; - GL_MAT_SHININESS_BIT_PGI = $02000000; - GL_MAT_SPECULAR_BIT_PGI = $04000000; - GL_NORMAL_BIT_PGI = $08000000; - GL_TEXCOORD1_BIT_PGI = $10000000; - GL_TEXCOORD2_BIT_PGI = $20000000; - GL_TEXCOORD3_BIT_PGI = $40000000; - GL_TEXCOORD4_BIT_PGI = $80000000; - GL_VERTEX23_BIT_PGI = $00000004; - GL_VERTEX4_BIT_PGI = $00000008; - - // GL_REND_screen_coordinates - GL_SCREEN_COORDINATES_REND = $8490; - GL_INVERTED_SCREEN_W_REND = $8491; - - // GL_S3_s3tc - GL_RGB_S3TC = $83A0; - GL_RGB4_S3TC = $83A1; - GL_RGBA_S3TC = $83A2; - GL_RGBA4_S3TC = $83A3; - - // GL_SGIS_detail_texture - GL_DETAIL_TEXTURE_2D_SGIS = $8095; - GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096; - GL_LINEAR_DETAIL_SGIS = $8097; - GL_LINEAR_DETAIL_ALPHA_SGIS = $8098; - GL_LINEAR_DETAIL_COLOR_SGIS = $8099; - GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A; - GL_DETAIL_TEXTURE_MODE_SGIS = $809B; - GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C; - - // GL_SGIS_fog_function - GL_FOG_FUNC_SGIS = $812A; - GL_FOG_FUNC_POINTS_SGIS = $812B; - GL_MAX_FOG_FUNC_POINTS_SGIS = $812C; - - // GL_SGIS_generate_mipmap - GL_GENERATE_MIPMAP_SGIS = $8191; - GL_GENERATE_MIPMAP_HINT_SGIS = $8192; - - // GL_SGIS_multisample - GL_MULTISAMPLE_SGIS = $809D; - GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E; - GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F; - GL_SAMPLE_MASK_SGIS = $80A0; - GL_1PASS_SGIS = $80A1; - GL_2PASS_0_SGIS = $80A2; - GL_2PASS_1_SGIS = $80A3; - GL_4PASS_0_SGIS = $80A4; - GL_4PASS_1_SGIS = $80A5; - GL_4PASS_2_SGIS = $80A6; - GL_4PASS_3_SGIS = $80A7; - GL_SAMPLE_BUFFERS_SGIS = $80A8; - GL_SAMPLES_SGIS = $80A9; - GL_SAMPLE_MASK_VALUE_SGIS = $80AA; - GL_SAMPLE_MASK_INVERT_SGIS = $80AB; - GL_SAMPLE_PATTERN_SGIS = $80AC; - - // GL_SGIS_pixel_texture - GL_PIXEL_TEXTURE_SGIS = $8353; - GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354; - GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355; - GL_PIXEL_GROUP_COLOR_SGIS = $8356; - - // GL_SGIS_point_line_texgen - GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0; - GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1; - GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2; - GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3; - GL_EYE_POINT_SGIS = $81F4; - GL_OBJECT_POINT_SGIS = $81F5; - GL_EYE_LINE_SGIS = $81F6; - GL_OBJECT_LINE_SGIS = $81F7; - - // GL_SGIS_point_parameters - GL_POINT_SIZE_MIN_SGIS = $8126; - GL_POINT_SIZE_MAX_SGIS = $8127; - GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128; - GL_DISTANCE_ATTENUATION_SGIS = $8129; - - // GL_SGIS_sharpen_texture - GL_LINEAR_SHARPEN_SGIS = $80AD; - GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE; - GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF; - GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0; - - // GL_SGIS_texture4D - GL_PACK_SKIP_VOLUMES_SGIS = $8130; - GL_PACK_IMAGE_DEPTH_SGIS = $8131; - GL_UNPACK_SKIP_VOLUMES_SGIS = $8132; - GL_UNPACK_IMAGE_DEPTH_SGIS = $8133; - GL_TEXTURE_4D_SGIS = $8134; - GL_PROXY_TEXTURE_4D_SGIS = $8135; - GL_TEXTURE_4DSIZE_SGIS = $8136; - GL_TEXTURE_WRAP_Q_SGIS = $8137; - GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138; - GL_TEXTURE_4D_BINDING_SGIS = $814F; - - // GL_SGIS_texture_color_mask - GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF; - - // GL_SGIS_texture_edge_clamp - GL_CLAMP_TO_EDGE_SGIS = $812F; - - // GL_SGIS_texture_filter4 - GL_FILTER4_SGIS = $8146; - GL_TEXTURE_FILTER4_SIZE_SGIS = $8147; - - // GL_SGIS_texture_lod - GL_TEXTURE_MIN_LOD_SGIS = $813A; - GL_TEXTURE_MAX_LOD_SGIS = $813B; - GL_TEXTURE_BASE_LEVEL_SGIS = $813C; - GL_TEXTURE_MAX_LEVEL_SGIS = $813D; - - // GL_SGIS_texture_select - GL_DUAL_ALPHA4_SGIS = $8110; - GL_DUAL_ALPHA8_SGIS = $8111; - GL_DUAL_ALPHA12_SGIS = $8112; - GL_DUAL_ALPHA16_SGIS = $8113; - GL_DUAL_LUMINANCE4_SGIS = $8114; - GL_DUAL_LUMINANCE8_SGIS = $8115; - GL_DUAL_LUMINANCE12_SGIS = $8116; - GL_DUAL_LUMINANCE16_SGIS = $8117; - GL_DUAL_INTENSITY4_SGIS = $8118; - GL_DUAL_INTENSITY8_SGIS = $8119; - GL_DUAL_INTENSITY12_SGIS = $811A; - GL_DUAL_INTENSITY16_SGIS = $811B; - GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C; - GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D; - GL_QUAD_ALPHA4_SGIS = $811E; - GL_QUAD_ALPHA8_SGIS = $811F; - GL_QUAD_LUMINANCE4_SGIS = $8120; - GL_QUAD_LUMINANCE8_SGIS = $8121; - GL_QUAD_INTENSITY4_SGIS = $8122; - GL_QUAD_INTENSITY8_SGIS = $8123; - GL_DUAL_TEXTURE_SELECT_SGIS = $8124; - GL_QUAD_TEXTURE_SELECT_SGIS = $8125; - - // GL_SGIX_async - GL_ASYNC_MARKER_SGIX = $8329; - - // GL_SGIX_async_histogram - GL_ASYNC_HISTOGRAM_SGIX = $832C; - GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D; - - // GL_SGIX_async_pixel - GL_ASYNC_TEX_IMAGE_SGIX = $835C; - GL_ASYNC_DRAW_PIXELS_SGIX = $835D; - GL_ASYNC_READ_PIXELS_SGIX = $835E; - GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F; - GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360; - GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361; - - // GL_SGIX_blend_alpha_minmax - GL_ALPHA_MIN_SGIX = $8320; - GL_ALPHA_MAX_SGIX = $8321; - - // GL_SGIX_calligraphic_fragment - GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183; - - // GL_SGIX_clipmap - GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170; - GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171; - GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172; - GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173; - GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174; - GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175; - GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176; - GL_MAX_CLIPMAP_DEPTH_SGIX = $8177; - GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178; - GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D; - GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E; - GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F; - - // GL_SGIX_convolution_accuracy - GL_CONVOLUTION_HINT_SGIX = $8316; - - // GL_SGIX_depth_texture - GL_DEPTH_COMPONENT16_SGIX = $81A5; - GL_DEPTH_COMPONENT24_SGIX = $81A6; - GL_DEPTH_COMPONENT32_SGIX = $81A7; - - // GL_SGIX_fog_offset - GL_FOG_OFFSET_SGIX = $8198; - GL_FOG_OFFSET_VALUE_SGIX = $8199; - - // GL_SGIX_fog_scale - GL_FOG_SCALE_SGIX = $81FC; - GL_FOG_SCALE_VALUE_SGIX = $81FD; - - // GL_SGIX_fragment_lighting - GL_FRAGMENT_LIGHTING_SGIX = $8400; - GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401; - GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402; - GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403; - GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404; - GL_MAX_ACTIVE_LIGHTS_SGIX = $8405; - GL_CURRENT_RASTER_NORMAL_SGIX = $8406; - GL_LIGHT_ENV_MODE_SGIX = $8407; - GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408; - GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409; - GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A; - GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B; - GL_FRAGMENT_LIGHT0_SGIX = $840C; - GL_FRAGMENT_LIGHT1_SGIX = $840D; - GL_FRAGMENT_LIGHT2_SGIX = $840E; - GL_FRAGMENT_LIGHT3_SGIX = $840F; - GL_FRAGMENT_LIGHT4_SGIX = $8410; - GL_FRAGMENT_LIGHT5_SGIX = $8411; - GL_FRAGMENT_LIGHT6_SGIX = $8412; - GL_FRAGMENT_LIGHT7_SGIX = $8413; - - // GL_SGIX_framezoom - GL_FRAMEZOOM_SGIX = $818B; - GL_FRAMEZOOM_FACTOR_SGIX = $818C; - GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D; - - // GL_SGIX_impact_pixel_texture - GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184; - GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185; - GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186; - GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187; - GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188; - GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189; - GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A; - - // GL_SGIX_instruments - GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180; - GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181; - - // GL_SGIX_interlace - GL_INTERLACE_SGIX = $8094; - - // GL_SGIX_ir_instrument1 - GL_IR_INSTRUMENT1_SGIX = $817F; - - // GL_SGIX_list_priority - GL_LIST_PRIORITY_SGIX = $8182; - - // GL_SGIX_pixel_texture - GL_PIXEL_TEX_GEN_SGIX = $8139; - GL_PIXEL_TEX_GEN_MODE_SGIX = $832B; - - // GL_SGIX_pixel_tiles - GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E; - GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F; - GL_PIXEL_TILE_WIDTH_SGIX = $8140; - GL_PIXEL_TILE_HEIGHT_SGIX = $8141; - GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142; - GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143; - GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144; - GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145; - - // GL_SGIX_polynomial_ffd - GL_GEOMETRY_DEFORMATION_SGIX = $8194; - GL_TEXTURE_DEFORMATION_SGIX = $8195; - GL_DEFORMATIONS_MASK_SGIX = $8196; - GL_MAX_DEFORMATION_ORDER_SGIX = $8197; - - // GL_SGIX_reference_plane - GL_REFERENCE_PLANE_SGIX = $817D; - GL_REFERENCE_PLANE_EQUATION_SGIX = $817E; - - // GL_SGIX_resample - GL_PACK_RESAMPLE_SGIX = $842C; - GL_UNPACK_RESAMPLE_SGIX = $842D; - GL_RESAMPLE_REPLICATE_SGIX = $842E; - GL_RESAMPLE_ZERO_FILL_SGIX = $842F; - GL_RESAMPLE_DECIMATE_SGIX = $8430; - - // GL_SGIX_scalebias_hint - GL_SCALEBIAS_HINT_SGIX = $8322; - - // GL_SGIX_shadow - GL_TEXTURE_COMPARE_SGIX = $819A; - GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B; - GL_TEXTURE_LEQUAL_R_SGIX = $819C; - GL_TEXTURE_GEQUAL_R_SGIX = $819D; - - // GL_SGIX_shadow_ambient - GL_SHADOW_AMBIENT_SGIX = $80BF; - - // GL_SGIX_sprite - GL_SPRITE_SGIX = $8148; - GL_SPRITE_MODE_SGIX = $8149; - GL_SPRITE_AXIS_SGIX = $814A; - GL_SPRITE_TRANSLATION_SGIX = $814B; - GL_SPRITE_AXIAL_SGIX = $814C; - GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D; - GL_SPRITE_EYE_ALIGNED_SGIX = $814E; - - // GL_SGIX_subsample - GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0; - GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1; - GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2; - GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3; - GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4; - - // GL_SGIX_texture_add_env - GL_TEXTURE_ENV_BIAS_SGIX = $80BE; - - // GL_SGIX_texture_coordinate_clamp - GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369; - GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A; - GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B; - - // GL_SGIX_texture_lod_bias - GL_TEXTURE_LOD_BIAS_S_SGIX = $818E; - GL_TEXTURE_LOD_BIAS_T_SGIX = $818F; - GL_TEXTURE_LOD_BIAS_R_SGIX = $8190; - - // GL_SGIX_texture_multi_buffer - GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E; - - // GL_SGIX_texture_scale_bias - GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179; - GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A; - GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B; - GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C; - - // GL_SGIX_vertex_preclip - GL_VERTEX_PRECLIP_SGIX = $83EE; - GL_VERTEX_PRECLIP_HINT_SGIX = $83EF; - - // GL_SGIX_ycrcb - GL_YCRCB_422_SGIX = $81BB; - GL_YCRCB_444_SGIX = $81BC; - - // GL_SGIX_ycrcba - GL_YCRCB_SGIX = $8318; - GL_YCRCBA_SGIX = $8319; - - // GL_SGI_color_matrix - GL_COLOR_MATRIX_SGI = $80B1; - GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2; - GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3; - GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4; - GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5; - GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6; - GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7; - GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8; - GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9; - GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA; - GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB; - - // GL_SGI_color_table - GL_COLOR_TABLE_SGI = $80D0; - GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1; - GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2; - GL_PROXY_COLOR_TABLE_SGI = $80D3; - GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4; - GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5; - GL_COLOR_TABLE_SCALE_SGI = $80D6; - GL_COLOR_TABLE_BIAS_SGI = $80D7; - GL_COLOR_TABLE_FORMAT_SGI = $80D8; - GL_COLOR_TABLE_WIDTH_SGI = $80D9; - GL_COLOR_TABLE_RED_SIZE_SGI = $80DA; - GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB; - GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC; - GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD; - GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE; - GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF; - - // GL_SGI_depth_pass_instrument - GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310; - GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311; - GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312; - - // GL_SGI_texture_color_table - GL_TEXTURE_COLOR_TABLE_SGI = $80BC; - GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD; - - // GL_SUNX_constant_data - GL_UNPACK_CONSTANT_DATA_SUNX = $81D5; - GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6; - - // GL_SUN_convolution_border_modes - GL_WRAP_BORDER_SUN = $81D4; - - // GL_SUN_global_alpha - GL_GLOBAL_ALPHA_SUN = $81D9; - GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA; - - // GL_SUN_mesh_array - GL_QUAD_MESH_SUN = $8614; - GL_TRIANGLE_MESH_SUN = $8615; - - // GL_SUN_slice_accum - GL_SLICE_ACCUM_SUN = $85CC; - - // GL_SUN_triangle_list - GL_RESTART_SUN = $0001; - GL_REPLACE_MIDDLE_SUN = $0002; - GL_REPLACE_OLDEST_SUN = $0003; - GL_TRIANGLE_LIST_SUN = $81D7; - GL_REPLACEMENT_CODE_SUN = $81D8; - GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0; - GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1; - GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2; - GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3; - GL_R1UI_V3F_SUN = $85C4; - GL_R1UI_C4UB_V3F_SUN = $85C5; - GL_R1UI_C3F_V3F_SUN = $85C6; - GL_R1UI_N3F_V3F_SUN = $85C7; - GL_R1UI_C4F_N3F_V3F_SUN = $85C8; - GL_R1UI_T2F_V3F_SUN = $85C9; - GL_R1UI_T2F_N3F_V3F_SUN = $85CA; - GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB; - - // GL_WIN_phong_shading - GL_PHONG_WIN = $80EA; - GL_PHONG_HINT_WIN = $80EB; - - // GL_WIN_specular_fog - GL_FOG_SPECULAR_TEXTURE_WIN = $80EC; - - // GL_ARB_vertex_shader - GL_VERTEX_SHADER_ARB = $8B31; - GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A; - GL_MAX_VARYING_FLOATS_ARB = $8B4B; - GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C; - GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D; - GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89; - GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A; - - // GL_ARB_fragment_shader - GL_FRAGMENT_SHADER_ARB = $8B30; - GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4 - GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4 - - // GL_ARB_occlusion_query - GL_SAMPLES_PASSED_ARB = $8914; - GL_QUERY_COUNTER_BITS_ARB = $8864; - GL_CURRENT_QUERY_ARB = $8865; - GL_QUERY_RESULT_ARB = $8866; - GL_QUERY_RESULT_AVAILABLE_ARB = $8867; - - // GL_ARB_point_sprite - GL_POINT_SPRITE_ARB = $8861; - GL_COORD_REPLACE_ARB = $8862; - - // GL_ARB_shading_language_100 - GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4 - - // GL_ARB_shader_objects - GL_PROGRAM_OBJECT_ARB = $8B40; - - GL_OBJECT_TYPE_ARB = $8B4E; - GL_OBJECT_SUBTYPE_ARB = $8B4F; - GL_OBJECT_DELETE_STATUS_ARB = $8B80; - GL_OBJECT_COMPILE_STATUS_ARB = $8B81; - GL_OBJECT_LINK_STATUS_ARB = $8B82; - GL_OBJECT_VALIDATE_STATUS_ARB = $8B83; - GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84; - GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85; - GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86; - GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87; - GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88; - - GL_SHADER_OBJECT_ARB = $8B48; - - GL_FLOAT_VEC2_ARB = $8B50; - GL_FLOAT_VEC3_ARB = $8B51; - GL_FLOAT_VEC4_ARB = $8B52; - GL_INT_VEC2_ARB = $8B53; - GL_INT_VEC3_ARB = $8B54; - GL_INT_VEC4_ARB = $8B55; - GL_BOOL_ARB = $8B56; - GL_BOOL_VEC2_ARB = $8B57; - GL_BOOL_VEC3_ARB = $8B58; - GL_BOOL_VEC4_ARB = $8B59; - GL_FLOAT_MAT2_ARB = $8B5A; - GL_FLOAT_MAT3_ARB = $8B5B; - GL_FLOAT_MAT4_ARB = $8B5C; - GL_SAMPLER_1D_ARB = $8B5D; - GL_SAMPLER_2D_ARB = $8B5E; - GL_SAMPLER_3D_ARB = $8B5F; - GL_SAMPLER_CUBE_ARB = $8B60; - GL_SAMPLER_1D_SHADOW_ARB = $8B61; - GL_SAMPLER_2D_SHADOW_ARB = $8B62; - GL_SAMPLER_2D_RECT_ARB = $8B63; - GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64; - - // WGL_3DFX_multisample - WGL_SAMPLE_BUFFERS_3DFX = $2060; - WGL_SAMPLES_3DFX = $2061; - - // WGL_ARB_buffer_region - WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001; - WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002; - WGL_DEPTH_BUFFER_BIT_ARB = $00000004; - WGL_STENCIL_BUFFER_BIT_ARB = $00000008; - - // WGL_ARB_make_current_read - ERROR_INVALID_PIXEL_TYPE_ARB = $2043; - ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054; - - // WGL_ARB_multisample - WGL_SAMPLE_BUFFERS_ARB = $2041; - WGL_SAMPLES_ARB = $2042; - - // WGL_ARB_pbuffer - WGL_DRAW_TO_PBUFFER_ARB = $202D; - WGL_MAX_PBUFFER_PIXELS_ARB = $202E; - WGL_MAX_PBUFFER_WIDTH_ARB = $202F; - WGL_MAX_PBUFFER_HEIGHT_ARB = $2030; - WGL_PBUFFER_LARGEST_ARB = $2033; - WGL_PBUFFER_WIDTH_ARB = $2034; - WGL_PBUFFER_HEIGHT_ARB = $2035; - WGL_PBUFFER_LOST_ARB = $2036; - - // WGL_ARB_pixel_format - WGL_NUMBER_PIXEL_FORMATS_ARB = $2000; - WGL_DRAW_TO_WINDOW_ARB = $2001; - WGL_DRAW_TO_BITMAP_ARB = $2002; - WGL_ACCELERATION_ARB = $2003; - WGL_NEED_PALETTE_ARB = $2004; - WGL_NEED_SYSTEM_PALETTE_ARB = $2005; - WGL_SWAP_LAYER_BUFFERS_ARB = $2006; - WGL_SWAP_METHOD_ARB = $2007; - WGL_NUMBER_OVERLAYS_ARB = $2008; - WGL_NUMBER_UNDERLAYS_ARB = $2009; - WGL_TRANSPARENT_ARB = $200A; - WGL_TRANSPARENT_RED_VALUE_ARB = $2037; - WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038; - WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039; - WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A; - WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B; - WGL_SHARE_DEPTH_ARB = $200C; - WGL_SHARE_STENCIL_ARB = $200D; - WGL_SHARE_ACCUM_ARB = $200E; - WGL_SUPPORT_GDI_ARB = $200F; - WGL_SUPPORT_OPENGL_ARB = $2010; - WGL_DOUBLE_BUFFER_ARB = $2011; - WGL_STEREO_ARB = $2012; - WGL_PIXEL_TYPE_ARB = $2013; - WGL_COLOR_BITS_ARB = $2014; - WGL_RED_BITS_ARB = $2015; - WGL_RED_SHIFT_ARB = $2016; - WGL_GREEN_BITS_ARB = $2017; - WGL_GREEN_SHIFT_ARB = $2018; - WGL_BLUE_BITS_ARB = $2019; - WGL_BLUE_SHIFT_ARB = $201A; - WGL_ALPHA_BITS_ARB = $201B; - WGL_ALPHA_SHIFT_ARB = $201C; - WGL_ACCUM_BITS_ARB = $201D; - WGL_ACCUM_RED_BITS_ARB = $201E; - WGL_ACCUM_GREEN_BITS_ARB = $201F; - WGL_ACCUM_BLUE_BITS_ARB = $2020; - WGL_ACCUM_ALPHA_BITS_ARB = $2021; - WGL_DEPTH_BITS_ARB = $2022; - WGL_STENCIL_BITS_ARB = $2023; - WGL_AUX_BUFFERS_ARB = $2024; - WGL_NO_ACCELERATION_ARB = $2025; - WGL_GENERIC_ACCELERATION_ARB = $2026; - WGL_FULL_ACCELERATION_ARB = $2027; - WGL_SWAP_EXCHANGE_ARB = $2028; - WGL_SWAP_COPY_ARB = $2029; - WGL_SWAP_UNDEFINED_ARB = $202A; - WGL_TYPE_RGBA_ARB = $202B; - WGL_TYPE_COLORINDEX_ARB = $202C; - - // WGL_ARB_pixel_format_float - WGL_RGBA_FLOAT_MODE_ARB = $8820; - WGL_CLAMP_VERTEX_COLOR_ARB = $891A; - WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B; - WGL_CLAMP_READ_COLOR_ARB = $891C; - WGL_FIXED_ONLY_ARB = $891D; - - // WGL_ARB_render_texture - WGL_BIND_TO_TEXTURE_RGB_ARB = $2070; - WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071; - WGL_TEXTURE_FORMAT_ARB = $2072; - WGL_TEXTURE_TARGET_ARB = $2073; - WGL_MIPMAP_TEXTURE_ARB = $2074; - WGL_TEXTURE_RGB_ARB = $2075; - WGL_TEXTURE_RGBA_ARB = $2076; - WGL_NO_TEXTURE_ARB = $2077; - WGL_TEXTURE_CUBE_MAP_ARB = $2078; - WGL_TEXTURE_1D_ARB = $2079; - WGL_TEXTURE_2D_ARB = $207A; - WGL_MIPMAP_LEVEL_ARB = $207B; - WGL_CUBE_MAP_FACE_ARB = $207C; - WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D; - WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E; - WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F; - WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080; - WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081; - WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082; - WGL_FRONT_LEFT_ARB = $2083; - WGL_FRONT_RIGHT_ARB = $2084; - WGL_BACK_LEFT_ARB = $2085; - WGL_BACK_RIGHT_ARB = $2086; - WGL_AUX0_ARB = $2087; - WGL_AUX1_ARB = $2088; - WGL_AUX2_ARB = $2089; - WGL_AUX3_ARB = $208A; - WGL_AUX4_ARB = $208B; - WGL_AUX5_ARB = $208C; - WGL_AUX6_ARB = $208D; - WGL_AUX7_ARB = $208E; - WGL_AUX8_ARB = $208F; - WGL_AUX9_ARB = $2090; - - // WGL_ARB_create_context - WGL_CONTEXT_DEBUG_BIT_ARB = $00000001; - WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; - WGL_CONTEXT_MAJOR_VERSION_ARB = $2091; - WGL_CONTEXT_MINOR_VERSION_ARB = $2092; - WGL_CONTEXT_LAYER_PLANE_ARB = $2093; - WGL_CONTEXT_FLAGS_ARB = $2094; - ERROR_INVALID_VERSION_ARB = $2095; - - // WGL_ARB_create_context_profile - WGL_CONTEXT_PROFILE_MASK_ARB = $9126; - WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; - WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; - ERROR_INVALID_PROFILE_ARB = $2096; - - // WGL_ARB_framebuffer_sRGB - WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20A9; - - // WGL_ARB_create_context_robustness - WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; - WGL_LOSE_CONTEXT_ON_RESET_ARB = $8252; - WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; - WGL_NO_RESET_NOTIFICATION_ARB = $8261; - - // WGL_ATI_pixel_format_float - WGL_TYPE_RGBA_FLOAT_ATI = $21A0; - GL_TYPE_RGBA_FLOAT_ATI = $8820; - GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835; - - // WGL_AMD_gpu_association - WGL_GPU_VENDOR_AMD = $1F00; - WGL_GPU_RENDERER_STRING_AMD = $1F01; - WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02; - WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2; - WGL_GPU_RAM_AMD = $21A3; - WGL_GPU_CLOCK_AMD = $21A4; - WGL_GPU_NUM_PIPES_AMD = $21A5; - WGL_GPU_NUM_SIMD_AMD = $21A6; - WGL_GPU_NUM_RB_AMD = $21A7; - WGL_GPU_NUM_SPI_AMD = $21A8; - - // WGL_EXT_depth_float - WGL_DEPTH_FLOAT_EXT = $2040; - - // WGL_EXT_make_current_read - ERROR_INVALID_PIXEL_TYPE_EXT = $2043; - - // WGL_EXT_multisample - WGL_SAMPLE_BUFFERS_EXT = $2041; - WGL_SAMPLES_EXT = $2042; - - // WGL_EXT_pbuffer - WGL_DRAW_TO_PBUFFER_EXT = $202D; - WGL_MAX_PBUFFER_PIXELS_EXT = $202E; - WGL_MAX_PBUFFER_WIDTH_EXT = $202F; - WGL_MAX_PBUFFER_HEIGHT_EXT = $2030; - WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031; - WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032; - WGL_PBUFFER_LARGEST_EXT = $2033; - WGL_PBUFFER_WIDTH_EXT = $2034; - WGL_PBUFFER_HEIGHT_EXT = $2035; - - // WGL_EXT_pixel_format - WGL_NUMBER_PIXEL_FORMATS_EXT = $2000; - WGL_DRAW_TO_WINDOW_EXT = $2001; - WGL_DRAW_TO_BITMAP_EXT = $2002; - WGL_ACCELERATION_EXT = $2003; - WGL_NEED_PALETTE_EXT = $2004; - WGL_NEED_SYSTEM_PALETTE_EXT = $2005; - WGL_SWAP_LAYER_BUFFERS_EXT = $2006; - WGL_SWAP_METHOD_EXT = $2007; - WGL_NUMBER_OVERLAYS_EXT = $2008; - WGL_NUMBER_UNDERLAYS_EXT = $2009; - WGL_TRANSPARENT_EXT = $200A; - WGL_TRANSPARENT_VALUE_EXT = $200B; - WGL_SHARE_DEPTH_EXT = $200C; - WGL_SHARE_STENCIL_EXT = $200D; - WGL_SHARE_ACCUM_EXT = $200E; - WGL_SUPPORT_GDI_EXT = $200F; - WGL_SUPPORT_OPENGL_EXT = $2010; - WGL_DOUBLE_BUFFER_EXT = $2011; - WGL_STEREO_EXT = $2012; - WGL_PIXEL_TYPE_EXT = $2013; - WGL_COLOR_BITS_EXT = $2014; - WGL_RED_BITS_EXT = $2015; - WGL_RED_SHIFT_EXT = $2016; - WGL_GREEN_BITS_EXT = $2017; - WGL_GREEN_SHIFT_EXT = $2018; - WGL_BLUE_BITS_EXT = $2019; - WGL_BLUE_SHIFT_EXT = $201A; - WGL_ALPHA_BITS_EXT = $201B; - WGL_ALPHA_SHIFT_EXT = $201C; - WGL_ACCUM_BITS_EXT = $201D; - WGL_ACCUM_RED_BITS_EXT = $201E; - WGL_ACCUM_GREEN_BITS_EXT = $201F; - WGL_ACCUM_BLUE_BITS_EXT = $2020; - WGL_ACCUM_ALPHA_BITS_EXT = $2021; - WGL_DEPTH_BITS_EXT = $2022; - WGL_STENCIL_BITS_EXT = $2023; - WGL_AUX_BUFFERS_EXT = $2024; - WGL_NO_ACCELERATION_EXT = $2025; - WGL_GENERIC_ACCELERATION_EXT = $2026; - WGL_FULL_ACCELERATION_EXT = $2027; - WGL_SWAP_EXCHANGE_EXT = $2028; - WGL_SWAP_COPY_EXT = $2029; - WGL_SWAP_UNDEFINED_EXT = $202A; - WGL_TYPE_RGBA_EXT = $202B; - WGL_TYPE_COLORINDEX_EXT = $202C; - - // WGL_I3D_digital_video_control - WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050; - WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051; - WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052; - WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053; - - // WGL_I3D_gamma - WGL_GAMMA_TABLE_SIZE_I3D = $204E; - WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F; - - // WGL_I3D_genlock - WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044; - WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045; - WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046; - WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047; - WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048; - WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049; - WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A; - WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B; - WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C; - - // WGL_I3D_image_buffer - WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001; - WGL_IMAGE_BUFFER_LOCK_I3D = $00000002; - - // WGL_NV_float_buffer - WGL_FLOAT_COMPONENTS_NV = $20B0; - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1; - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2; - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3; - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4; - WGL_TEXTURE_FLOAT_R_NV = $20B5; - WGL_TEXTURE_FLOAT_RG_NV = $20B6; - WGL_TEXTURE_FLOAT_RGB_NV = $20B7; - WGL_TEXTURE_FLOAT_RGBA_NV = $20B8; - - // WGL_NV_render_depth_texture - WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3; - WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4; - WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5; - WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6; - WGL_DEPTH_COMPONENT_NV = $20A7; - - // WGL_NV_render_texture_rectangle - WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0; - WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1; - WGL_TEXTURE_RECTANGLE_NV = $20A2; - - // WGL_NV_present_video - WGL_NUM_VIDEO_SLOTS_NV = $20F0; - - // WGL_NV_video_output - WGL_BIND_TO_VIDEO_RGB_NV = $20C0; - WGL_BIND_TO_VIDEO_RGBA_NV = $20C1; - WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2; - WGL_VIDEO_OUT_COLOR_NV = $20C3; - WGL_VIDEO_OUT_ALPHA_NV = $20C4; - WGL_VIDEO_OUT_DEPTH_NV = $20C5; - WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6; - WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7; - WGL_VIDEO_OUT_FRAME = $20C8; - WGL_VIDEO_OUT_FIELD_1 = $20C9; - WGL_VIDEO_OUT_FIELD_2 = $20CA; - WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB; - WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC; - - // WGL_NV_gpu_affinity - WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0; - WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1; - - // WGL_NV_video_capture - WGL_UNIQUE_ID_NV = $20CE; - WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = $20CF; - - // WGL_NV_multisample_coverage - WGL_COVERAGE_SAMPLES_NV = $2042; - WGL_COLOR_SAMPLES_NV = $20B9; - - // WGL_EXT_create_context_es2_profile - WGL_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; - - // WGL_NV_DX_interop - WGL_ACCESS_READ_ONLY_NV = $00000000; - WGL_ACCESS_READ_WRITE_NV = $00000001; - WGL_ACCESS_WRITE_DISCARD_NV = $00000002; - - // WIN_draw_range_elements - GL_MAX_ELEMENTS_VERTICES_WIN = $80E8; - GL_MAX_ELEMENTS_INDICES_WIN = $80E9; - - // GLX 1.1 and later: - GLX_VENDOR = 1; - GLX_VERSION = 2; - GLX_EXTENSIONS = 3; - - GLX_USE_GL = 1; - GLX_BUFFER_SIZE = 2; - GLX_LEVEL = 3; - GLX_RGBA = 4; - GLX_DOUBLEBUFFER = 5; - GLX_STEREO = 6; - GLX_AUX_BUFFERS = 7; - GLX_RED_SIZE = 8; - GLX_GREEN_SIZE = 9; - GLX_BLUE_SIZE = 10; - GLX_ALPHA_SIZE = 11; - GLX_DEPTH_SIZE = 12; - GLX_STENCIL_SIZE = 13; - GLX_ACCUM_RED_SIZE = 14; - GLX_ACCUM_GREEN_SIZE = 15; - GLX_ACCUM_BLUE_SIZE = 16; - GLX_ACCUM_ALPHA_SIZE = 17; - - // GLX_VERSION_1_3 - GLX_WINDOW_BIT = $00000001; - GLX_PIXMAP_BIT = $00000002; - GLX_PBUFFER_BIT = $00000004; - GLX_RGBA_BIT = $00000001; - GLX_COLOR_INDEX_BIT = $00000002; - GLX_PBUFFER_CLOBBER_MASK = $08000000; - GLX_FRONT_LEFT_BUFFER_BIT = $00000001; - GLX_FRONT_RIGHT_BUFFER_BIT = $00000002; - GLX_BACK_LEFT_BUFFER_BIT = $00000004; - GLX_BACK_RIGHT_BUFFER_BIT = $00000008; - GLX_AUX_BUFFERS_BIT = $00000010; - GLX_DEPTH_BUFFER_BIT = $00000020; - GLX_STENCIL_BUFFER_BIT = $00000040; - GLX_ACCUM_BUFFER_BIT = $00000080; - GLX_CONFIG_CAVEAT = $20; - GLX_X_VISUAL_TYPE = $22; - GLX_TRANSPARENT_TYPE = $23; - GLX_TRANSPARENT_INDEX_VALUE = $24; - GLX_TRANSPARENT_RED_VALUE = $25; - GLX_TRANSPARENT_GREEN_VALUE = $26; - GLX_TRANSPARENT_BLUE_VALUE = $27; - GLX_TRANSPARENT_ALPHA_VALUE = $28; - GLX_DONT_CARE = $FFFFFFFF; - GLX_NONE = $8000; - GLX_SLOW_CONFIG = $8001; - GLX_TRUE_COLOR = $8002; - GLX_DIRECT_COLOR = $8003; - GLX_PSEUDO_COLOR = $8004; - GLX_STATIC_COLOR = $8005; - GLX_GRAY_SCALE = $8006; - GLX_STATIC_GRAY = $8007; - GLX_TRANSPARENT_RGB = $8008; - GLX_TRANSPARENT_INDEX = $8009; - GLX_VISUAL_ID = $800B; - GLX_SCREEN = $800C; - GLX_NON_CONFORMANT_CONFIG = $800D; - GLX_DRAWABLE_TYPE = $8010; - GLX_RENDER_TYPE = $8011; - GLX_X_RENDERABLE = $8012; - GLX_FBCONFIG_ID = $8013; - GLX_RGBA_TYPE = $8014; - GLX_COLOR_INDEX_TYPE = $8015; - GLX_MAX_PBUFFER_WIDTH = $8016; - GLX_MAX_PBUFFER_HEIGHT = $8017; - GLX_MAX_PBUFFER_PIXELS = $8018; - GLX_PRESERVED_CONTENTS = $801B; - GLX_LARGEST_PBUFFER = $801C; - GLX_WIDTH = $801D; - GLX_HEIGHT = $801E; - GLX_EVENT_MASK = $801F; - GLX_DAMAGED = $8020; - GLX_SAVED = $8021; - GLX_WINDOW = $8022; - GLX_PBUFFER = $8023; - GLX_PBUFFER_HEIGHT = $8040; - GLX_PBUFFER_WIDTH = $8041; - - // GLX_VERSION_1_4 - GLX_SAMPLE_BUFFERS = 100000; - GLX_SAMPLES = 100001; - - // GLX_ARB_multisample - GLX_SAMPLE_BUFFERS_ARB = 100000; - GLX_SAMPLES_ARB = 100001; - - // GLX_ARB_fbconfig_float - GLX_RGBA_FLOAT_TYPE_ARB = $20B9; - GLX_RGBA_FLOAT_BIT_ARB = $00000004; - - // GLX_ARB_create_context - GLX_CONTEXT_DEBUG_BIT_ARB = $00000001; - GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002; - GLX_CONTEXT_MAJOR_VERSION_ARB = $2091; - GLX_CONTEXT_MINOR_VERSION_ARB = $2092; - GLX_CONTEXT_FLAGS_ARB = $2094; - - // GLX_ARB_create_context_profile - GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001; - GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002; - GLX_CONTEXT_PROFILE_MASK_ARB = $9126; - - // GLX_ARB_vertex_buffer_object - GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = $2095; - - // GLX_ARB_framebuffer_sRGB - GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20B2; - - // GLX_ARB_create_context_robustness - GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004; - GLX_LOSE_CONTEXT_ON_RESET_ARB = $8252; - GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256; - GLX_NO_RESET_NOTIFICATION_ARB = $8261; - - // GLX_EXT_visual_info - GLX_X_VISUAL_TYPE_EXT = $22; - GLX_TRANSPARENT_TYPE_EXT = $23; - GLX_TRANSPARENT_INDEX_VALUE_EXT = $24; - GLX_TRANSPARENT_RED_VALUE_EXT = $25; - GLX_TRANSPARENT_GREEN_VALUE_EXT = $26; - GLX_TRANSPARENT_BLUE_VALUE_EXT = $27; - GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28; - GLX_NONE_EXT = $8000; - GLX_TRUE_COLOR_EXT = $8002; - GLX_DIRECT_COLOR_EXT = $8003; - GLX_PSEUDO_COLOR_EXT = $8004; - GLX_STATIC_COLOR_EXT = $8005; - GLX_GRAY_SCALE_EXT = $8006; - GLX_STATIC_GRAY_EXT = $8007; - GLX_TRANSPARENT_RGB_EXT = $8008; - GLX_TRANSPARENT_INDEX_EXT = $8009; - - // GLX_EXT_visual_rating - GLX_VISUAL_CAVEAT_EXT = $20; - GLX_SLOW_VISUAL_EXT = $8001; - GLX_NON_CONFORMANT_VISUAL_EXT = $800D; - (* reuse GLX_NONE_EXT *) - - // GLX_EXT_import_context - GLX_SHARE_CONTEXT_EXT = $800A; - GLX_VISUAL_ID_EXT = $800B; - GLX_SCREEN_EXT = $800C; - - // GLX_EXT_fbconfig_packed_float -// GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1; -// GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; - - // GLX_EXT_framebuffer_sRGB -// GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; - - // GLX_EXT_texture_from_pixmap - GLX_TEXTURE_1D_BIT_EXT = $00000001; - GLX_TEXTURE_2D_BIT_EXT = $00000002; - GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004; - GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0; - GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1; - GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2; - GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3; - GLX_Y_INVERTED_EXT = $20D4; - GLX_TEXTURE_FORMAT_EXT = $20D5; - GLX_TEXTURE_TARGET_EXT = $20D6; - GLX_MIPMAP_TEXTURE_EXT = $20D7; - GLX_TEXTURE_FORMAT_NONE_EXT = $20D8; - GLX_TEXTURE_FORMAT_RGB_EXT = $20D9; - GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA; - GLX_TEXTURE_1D_EXT = $20DB; - GLX_TEXTURE_2D_EXT = $20DC; - GLX_TEXTURE_RECTANGLE_EXT = $20DD; - GLX_FRONT_LEFT_EXT = $20DE; - GLX_FRONT_RIGHT_EXT = $20DF; - GLX_BACK_LEFT_EXT = $20E0; - GLX_BACK_RIGHT_EXT = $20E1; - GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT; - GLX_BACK_EXT = GLX_BACK_LEFT_EXT; - GLX_AUX0_EXT = $20E2; - GLX_AUX1_EXT = $20E3; - GLX_AUX2_EXT = $20E4; - GLX_AUX3_EXT = $20E5; - GLX_AUX4_EXT = $20E6; - GLX_AUX5_EXT = $20E7; - GLX_AUX6_EXT = $20E8; - GLX_AUX7_EXT = $20E9; - GLX_AUX8_EXT = $20EA; - GLX_AUX9_EXT = $20EB; - - // GLX_EXT_swap_control - GLX_SWAP_INTERVAL_EXT = $20F1; - GLX_MAX_SWAP_INTERVAL_EXT = $20F2; - - // GLX_EXT_create_context_es2_profile - GLX_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004; - - // GL_EXT_Late_Swaps - GLX_LATE_SWAPS_TEAR_EXT = $20F3; - - // GLU - GLU_INVALID_ENUM = 100900; - GLU_INVALID_VALUE = 100901; - GLU_OUT_OF_MEMORY = 100902; - GLU_INCOMPATIBLE_GL_VERSION = 100903; - GLU_VERSION = 100800; - GLU_EXTENSIONS = 100801; - GLU_TRUE = GL_TRUE; - GLU_FALSE = GL_FALSE; - GLU_SMOOTH = 100000; - GLU_FLAT = 100001; - GLU_NONE = 100002; - GLU_POINT = 100010; - GLU_LINE = 100011; - GLU_FILL = 100012; - GLU_SILHOUETTE = 100013; - GLU_OUTSIDE = 100020; - GLU_INSIDE = 100021; - GLU_TESS_MAX_COORD = 1.0E150; - GLU_TESS_WINDING_RULE = 100140; - GLU_TESS_BOUNDARY_ONLY = 100141; - GLU_TESS_TOLERANCE = 100142; - GLU_TESS_WINDING_ODD = 100130; - GLU_TESS_WINDING_NONZERO = 100131; - GLU_TESS_WINDING_POSITIVE = 100132; - GLU_TESS_WINDING_NEGATIVE = 100133; - GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; - GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc - GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc - GLU_TESS_END = 100102; // TGLUTessEndProc - GLU_TESS_ERROR = 100103; // TGLUTessErrorProc - GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc - GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc - GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc - GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc - GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc - GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc - GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc - GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc - GLU_TESS_ERROR1 = 100151; - GLU_TESS_ERROR2 = 100152; - GLU_TESS_ERROR3 = 100153; - GLU_TESS_ERROR4 = 100154; - GLU_TESS_ERROR5 = 100155; - GLU_TESS_ERROR6 = 100156; - GLU_TESS_ERROR7 = 100157; - GLU_TESS_ERROR8 = 100158; - GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1; - GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2; - GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3; - GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4; - GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5; - GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6; - GLU_AUTO_LOAD_MATRIX = 100200; - GLU_CULLING = 100201; - GLU_SAMPLING_TOLERANCE = 100203; - GLU_DISPLAY_MODE = 100204; - GLU_PARAMETRIC_TOLERANCE = 100202; - GLU_SAMPLING_METHOD = 100205; - GLU_U_STEP = 100206; - GLU_V_STEP = 100207; - GLU_PATH_LENGTH = 100215; - GLU_PARAMETRIC_ERROR = 100216; - GLU_DOMAIN_DISTANCE = 100217; - GLU_MAP1_TRIM_2 = 100210; - GLU_MAP1_TRIM_3 = 100211; - GLU_OUTLINE_POLYGON = 100240; - GLU_OUTLINE_PATCH = 100241; - GLU_NURBS_ERROR1 = 100251; - GLU_NURBS_ERROR2 = 100252; - GLU_NURBS_ERROR3 = 100253; - GLU_NURBS_ERROR4 = 100254; - GLU_NURBS_ERROR5 = 100255; - GLU_NURBS_ERROR6 = 100256; - GLU_NURBS_ERROR7 = 100257; - GLU_NURBS_ERROR8 = 100258; - GLU_NURBS_ERROR9 = 100259; - GLU_NURBS_ERROR10 = 100260; - GLU_NURBS_ERROR11 = 100261; - GLU_NURBS_ERROR12 = 100262; - GLU_NURBS_ERROR13 = 100263; - GLU_NURBS_ERROR14 = 100264; - GLU_NURBS_ERROR15 = 100265; - GLU_NURBS_ERROR16 = 100266; - GLU_NURBS_ERROR17 = 100267; - GLU_NURBS_ERROR18 = 100268; - GLU_NURBS_ERROR19 = 100269; - GLU_NURBS_ERROR20 = 100270; - GLU_NURBS_ERROR21 = 100271; - GLU_NURBS_ERROR22 = 100272; - GLU_NURBS_ERROR23 = 100273; - GLU_NURBS_ERROR24 = 100274; - GLU_NURBS_ERROR25 = 100275; - GLU_NURBS_ERROR26 = 100276; - GLU_NURBS_ERROR27 = 100277; - GLU_NURBS_ERROR28 = 100278; - GLU_NURBS_ERROR29 = 100279; - GLU_NURBS_ERROR30 = 100280; - GLU_NURBS_ERROR31 = 100281; - GLU_NURBS_ERROR32 = 100282; - GLU_NURBS_ERROR33 = 100283; - GLU_NURBS_ERROR34 = 100284; - GLU_NURBS_ERROR35 = 100285; - GLU_NURBS_ERROR36 = 100286; - GLU_NURBS_ERROR37 = 100287; - GLU_CW = 100120; - GLU_CCW = 100121; - GLU_INTERIOR = 100122; - GLU_EXTERIOR = 100123; - GLU_UNKNOWN = 100124; - GLU_BEGIN = GLU_TESS_BEGIN; - GLU_VERTEX = GLU_TESS_VERTEX; - GLU_END = GLU_TESS_END; - GLU_ERROR = GLU_TESS_ERROR; - GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG; - -type - // GL_VERSION_1_0 - TglCullFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFrontFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglHint = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLineWidth = procedure(width: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointSize = procedure(size: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPolygonMode = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScissor = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClear = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearStencil = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearDepth = procedure(depth: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorMask = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthMask = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinish = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFlush = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFunc = procedure(sfactor: GLenum; dfactor: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLogicOp = procedure(opcode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilFunc = procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilOp = procedure(fail: GLenum; zfail: GLenum; zpass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthFunc = procedure(func: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelStoref = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReadBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBooleanv = procedure(pname: GLenum; params: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDoublev = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetError = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFloatv = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsEnabled = function(cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthRange = procedure(zNear: GLclampd; zFar: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglViewport = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_1_1 - TglDrawArrays = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElements = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPointerv = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPolygonOffset = procedure(factor: GLfloat; units: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexImage1D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexImage2D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - -{$ifdef DGL_DEPRECATED} - TglAccum = procedure(op: GLenum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAlphaFunc = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglArrayElement = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBegin = procedure(mode: GLenum); {$IFNDEF CLR}{$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}{$ENDIF} - TglBitmap = procedure(width: GLsizei; height: GLsizei; xorig: GLfloat; yorig: GLfloat; xmove: GLfloat; ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCallList = procedure(list: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCallLists = procedure(n: GLsizei; _type: GLenum; const lists: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearAccum = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearIndex = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClipPlane = procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte; alpha: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble; alpha: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4i = procedure(red: GLint; green: GLint; blue: GLint; alpha: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4s = procedure(red: GLshort; green: GLshort; blue: GLshort; alpha: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte; alpha: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ui = procedure(red: GLuint; green: GLuint; blue: GLuint; alpha: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4us = procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorMaterial = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; _type: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteLists = procedure(list: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawPixels = procedure(width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlag = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlagPointer = procedure(stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlagv = procedure(const flag: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnd = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndList = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord1d = procedure(u: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord1dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord1f = procedure(u: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord1fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord2d = procedure(u: GLdouble; v: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord2dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord2f = procedure(u: GLfloat; v: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalCoord2fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalMesh1 = procedure(mode: GLenum; i1: GLint; i2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalMesh2 = procedure(mode: GLenum; i1: GLint; i2: GLint; j1: GLint; j2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalPoint1 = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalPoint2 = procedure(i: GLint; j: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFeedbackBuffer = procedure(size: GLsizei; _type: GLenum; buffer: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogiv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFrustum = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenLists = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetClipPlane = procedure(plane: GLenum; equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetLightfv = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetLightiv = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapdv = procedure(target: GLenum; query: GLenum; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapfv = procedure(target: GLenum; query: GLenum; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapiv = procedure(target: GLenum; query: GLenum; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMaterialfv = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMaterialiv = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPixelMapfv = procedure(map: GLenum; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPixelMapuiv = procedure(map: GLenum; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPixelMapusv = procedure(map: GLenum; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPolygonStipple = procedure(mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexEnvfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexEnviv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexGendv = procedure(coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexGenfv = procedure(coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexGeniv = procedure(coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexd = procedure(c: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexdv = procedure(const c: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexf = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexfv = procedure(const c: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexi = procedure(c: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexiv = procedure(const c: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexs = procedure(c: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexsv = procedure(const c: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexub = procedure(c: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexubv = procedure(const c: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInitNames = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInterleavedArrays = procedure(format: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsList = function(list: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsTexture = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightModelf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightModelfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightModeli = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightModeliv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightf = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightfv = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLighti = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightiv = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLineStipple = procedure(factor: GLint; pattern: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglListBase = procedure(base: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadIdentity = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMap1d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMap1f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMap2d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMap2f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapGrid1d = procedure(un: GLint; u1: GLdouble; u2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapGrid1f = procedure(un: GLint; u1: GLfloat; u2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapGrid2d = procedure(un: GLint; u1: GLdouble; u2: GLdouble; vn: GLint; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapGrid2f = procedure(un: GLint; u1: GLfloat; u2: GLfloat; vn: GLint; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMaterialf = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMaterialfv = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMateriali = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMaterialiv = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixMode = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNewList = procedure(list: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3b = procedure(nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3d = procedure(nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3f = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3i = procedure(nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3s = procedure(nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglOrtho = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPassThrough = procedure(token: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelMapfv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelMapuiv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelMapusv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTransferf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTransferi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelZoom = procedure(xfactor: GLfloat; yfactor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPolygonStipple = procedure(const mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPopAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPopClientAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPopMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPopName = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPrioritizeTextures = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushClientAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRasterPos4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectd = procedure(x1: GLdouble; y1: GLdouble; x2: GLdouble; y2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectdv = procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectf = procedure(x1: GLfloat; y1: GLfloat; x2: GLfloat; y2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectfv = procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRecti = procedure(x1: GLint; y1: GLint; x2: GLint; y2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectiv = procedure(const v1: PGLint; const v2: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRects = procedure(x1: GLshort; y1: GLshort; x2: GLshort; y2: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRectsv = procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRenderMode = function(mode: GLenum): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRotated = procedure(angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRotatef = procedure(angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScaled = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScalef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSelectBuffer = procedure(size: GLsizei; buffer: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShadeModel = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1d = procedure(s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1f = procedure(s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1i = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1s = procedure(s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2d = procedure(s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2f = procedure(s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2i = procedure(s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2s = procedure(s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3d = procedure(s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3f = procedure(s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3i = procedure(s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3s = procedure(s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4d = procedure(s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4f = procedure(s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4i = procedure(s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4s = procedure(s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexEnvf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexEnvfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexEnvi = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexEnviv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGend = procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGendv = procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGenf = procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGenfv = procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexGeniv = procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - - TglTranslated = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTranslatef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$endif} - - // GL_VERSION_1_2 - TglBlendColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquation = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawRangeElements = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$ifdef DGL_DEPRECATED} - TglColorTable = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorTableParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorTableParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyColorTable = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTable = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorSubTable = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyColorSubTable = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameterf = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameteri = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSeparableFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSeparableFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHistogram = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHistogramParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHistogramParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmax = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmaxParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmaxParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglHistogram = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMinmax = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResetHistogram = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResetMinmax = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$endif} - - // GL_VERSION_1_3 - TglActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSampleCoverage = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$ifdef DGL_DEPRECATED} - TglClientActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1d = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1f = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1i = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1s = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2d = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2f = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2i = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2s = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$endif} - - // GL_VERSION_1_4 - TglBlendFuncSeparate = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawArrays = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawElements = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameteri = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameteriv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$ifdef DGL_DEPRECATED} - TglFogCoordf = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordd = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -{$endif} - - // GL_VERSION_1_5 - TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBuffer = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteBuffers = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenBuffers = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsBuffer = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBufferData = procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapBuffer = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUnmapBuffer = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferPointerv = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_2_0 - TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilFuncSeparate = procedure(face: GLenum; func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveAttrib = procedure(programObj: GLhandle; index: GLuint; maxlength: GLsizei; var length: GLint; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniform = procedure(programObj: GLhandle; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetAttribLocation = function(programObj: GLhandle; char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramiv = procedure(programObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; var length: GLint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; var length: glint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsProgram = function(programObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsShader = function(shaderObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; const _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_2_1 - TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_3_0 - { OpenGL 3.0 also reuses entry points from these extensions: } - { ARB_framebuffer_object } - { ARB_map_buffer_range } - { ARB_vertex_array_object } - TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_2_1 - TglEnableVertexArrayEXT = procedure(vaobj: GLuint; array_: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableVertexArrayAttribEXT = procedure(vaobj: GLuint; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; normalized: GLboolean; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_3_1 - { OpenGL 3.1 also reuses entry points from these extensions: } - { ARB_copy_buffer } - { ARB_uniform_buffer_object } - TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_3_2 - { OpenGL 3.2 also reuses entry points from these extensions: } - { ARB_draw_elements_base_vertex } - { ARB_provoking_vertex } - { ARB_sync } - { ARB_texture_multisample } - TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -// TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_3_3 - { OpenGL 3.3 also reuses entry points from these extensions: } - { ARB_blend_func_extended } - { ARB_sampler_objects } - { ARB_explicit_attrib_location, but it has none } - { ARB_occlusion_query2 (no entry points) } - { ARB_shader_bit_encoding (no entry points) } - { ARB_texture_rgb10_a2ui (no entry points) } - { ARB_texture_swizzle (no entry points) } - { ARB_timer_query } - { ARB_vertex_type_2_10_10_10_rev } - TglVertexAttribDivisor = procedure(index: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_4_0 - { OpenGL 4.0 also reuses entry points from these extensions: } - { ARB_texture_query_lod (no entry points) } - { ARB_draw_indirect } - { ARB_gpu_shader5 (no entry points) } - { ARB_gpu_shader_fp64 } - { ARB_shader_subroutine } - { ARB_tessellation_shader } - { ARB_texture_buffer_object_rgb32 (no entry points) } - { ARB_texture_cube_map_array (no entry points) } - { ARB_texture_gather (no entry points) } - { ARB_transform_feedback2 } - { ARB_transform_feedback3 } - TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_VERSION_4_1 - { OpenGL 4.1 also reuses entry points from these extensions: } - { ARB_ES2_compatibility } - { ARB_get_program_binary } - { ARB_separate_shader_objects } - { ARB_shader_precision (no entry points) } - { ARB_vertex_attrib_64bit } - { ARB_viewport_array } - - // GL_3DFX_tbuffer - TglTbufferMask3DFX = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_element_array - TglElementPointerAPPLE = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementArrayAPPLE = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawElementArrayAPPLE = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_fence - TglGenFencesAPPLE = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteFencesAPPLE = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSetFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTestFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinishFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTestObjectAPPLE = function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinishObjectAPPLE = procedure(_object: GLenum; name: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_vertex_array_object - TglBindVertexArrayAPPLE = procedure(_array: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsVertexArrayAPPLE = function(_array: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_vertex_array_range - TglVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFlushVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayParameteriAPPLE = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_texture_range - TglTextureRangeAPPLE = procedure(target: GLenum; length: GLsizei; const Pointer_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterPointervAPPLE = procedure(target: GLenum; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_vertex_program_evaluators - TglEnableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsVertexAttribEnabledAPPLE = function(index_: GLuint; pname: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapVertexAttrib1dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapVertexAttrib1fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapVertexAttrib2dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapVertexAttrib2fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; ustride: GLint; order: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_APPLE_object_purgeable - TglObjectPurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglObjectUnpurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectParameterivAPPLE = procedure(objectType: GLenum; name: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_matrix_palette - TglCurrentPaletteMatrixARB = procedure(index: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixIndexubvARB = procedure(size: GLint; const indices: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixIndexusvARB = procedure(size: GLint; const indices: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixIndexuivARB = procedure(size: GLint; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixIndexPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_multisample - TglSampleCoverageARB = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_multitexture - TglActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClientActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1dARB = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1fARB = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1iARB = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1sARB = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2iARB = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2sARB = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_point_parameters - TglPointParameterfARB = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterfvARB = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_texture_compression - TglCompressedTexImage3DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexImage2DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexImage1DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage3DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage2DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTexSubImage1DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCompressedTexImageARB = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_transpose_matrix - TglLoadTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_blend - TglWeightbvARB = procedure(size: GLint; const weights: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightsvARB = procedure(size: GLint; const weights: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightivARB = procedure(size: GLint; const weights: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightfvARB = procedure(size: GLint; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightdvARB = procedure(size: GLint; const weights: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightubvARB = procedure(size: GLint; const weights: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightusvARB = procedure(size: GLint; const weights: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightuivARB = procedure(size: GLint; const weights: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexBlendARB = procedure(count: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_buffer_object - TglBindBufferARB = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteBuffersARB = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenBuffersARB = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsBufferARB = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBufferDataARB = procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapBufferARB = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUnmapBufferARB = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferParameterivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferPointervARB = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_program - TglVertexAttrib1dARB = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1fARB = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1sARB = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2sARB = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NbvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NsvARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NubARB = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NuivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4NusvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4bvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4ivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4ubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4uivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4usvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribPointerARB = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramStringARB = procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindProgramARB = procedure(target: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteProgramsARB = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenProgramsARB = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramEnvParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramEnvParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramLocalParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramLocalParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramStringARB = procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribdvARB = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribfvARB = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribivARB = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribPointervARB = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsProgramARB = function(_program: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_window_pos - TglWindowPos2dARB = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2fARB = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2iARB = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2sARB = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3dARB = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3fARB = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3iARB = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3sARB = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_draw_buffers - TglDrawBuffersARB = procedure(n: GLsizei; bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_color_buffer_float - TglClampColorARB = procedure(target: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_shader - TglGetActiveAttribARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetAttribLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindAttribLocationARB = procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_shader_objects - TglDeleteObjectARB = procedure(Obj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHandleARB = function(pname: GlEnum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDetachObjectARB = procedure(container, attached: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateShaderObjectARB = function(shaderType: glenum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderSourceARB = procedure(shaderObj: GLHandleARB; count: glsizei; const _string: PPGLCharARB; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompileShaderARB = procedure(shaderObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateProgramObjectARB = function: GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAttachObjectARB = procedure(programObj, shaderObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLinkProgramARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUseProgramObjectARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglValidateProgramARB = procedure(programObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1fARB = procedure(location: glint; v0: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2fARB = procedure(location: glint; v0, v1: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3fARB = procedure(location: glint; v0, v1, v2: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4fARB = procedure(location: glint; v0, v1, v2, v3: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1iARB = procedure(location: glint; v0: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2iARB = procedure(location: glint; v0, v1: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3iARB = procedure(location: glint; v0, v1, v2: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4iARB = procedure(location: glint; v0, v1, v2, v3: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectParameterfvARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectParameterivARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetInfoLogARB = procedure(shaderObj: GLHandleARB; maxLength: glsizei; var length: glint; infoLog: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetAttachedObjectsARB = procedure(programobj: GLhandleARB; maxCount: GLsizei; var count: GLsizei; objects: PGLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniformARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformfvARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformivARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetShaderSourceARB = procedure(shader: GLhandleARB; maxLength: GLsizei; var length: GLsizei; source: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_Occlusion_Query - TglGenQueriesARB = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteQueriesARB = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsQueryARB = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginQueryARB = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndQueryARB = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryivARB = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectivARB = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectuivARB = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_draw_instanced - TglDrawArraysInstancedARB = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstancedARB = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_framebuffer_object - TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_geometry_shader4 - TglProgramParameteriARB = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureLayerARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureFaceARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_instanced_arrays - TglVertexAttribDivisorARB = procedure(index_: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_map_buffer_range - TglMapBufferRange = function(target: GLenum; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_texture_buffer_object - TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_array_object - TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_uniform_buffer_object - TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_copy_buffer - TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_draw_elements_base_vertex - TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_provoking_vertex - TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_sync - TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_texture_multisample - TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_draw_buffers_blend - TglBlendEquationiARB = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquationSeparateiARB = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFunciARB = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFuncSeparateiARB = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_sample_shading - TglMinSampleShadingARB = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_shading_language_include - TglNamedStringARB = procedure(type_: GLenum; namelen: GLint; const name: PGLchar; stringlen: GLint; const string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteNamedStringARB = procedure(namelen: GLint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompileShaderIncludeARB = procedure (shader: GLuint; count: GLsizei; const path: PPGLchar; const length: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsNamedStringARB = function(namelen: GLint; const name: PGLchar): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedStringARB = procedure(namelen: GLint; const name: PGLchar; bufSize: GLsizei; stringlen: GLint; string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedStringivARB = procedure(namelen: GLint; const name: PGLchar; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_blend_func_extended - TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_sampler_objects - TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_timer_query - TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_type_2_10_10_10_rev - TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_draw_indirect - TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_gpu_shader_fp64 - TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_shader_subroutine - TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_tessellation_shader - TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_transform_feedback2 - TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_transform_feedback3 - TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_ES2_compatibility - TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_get_program_binary - TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_separate_shader_objects - TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_attrib_64bit - TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_viewport_array - TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL 4.2 - - // GL_ARB_base_instance - TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_transform_feedback_instanced - TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_internalformat_query - TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_shader_atomic_counters - TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - /// GL_ARB_shader_image_load_store - TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_texture_storage - TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureStorage1DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureStorage2DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureStorage3DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - - // GL 4.3 - - // GL_KHR_debug - TglDebugMessageControl = procedure(source : GLenum; type_ : GLenum; severity : TGLenum; count : GLsizei; const ids : PGLUInt; enabled : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageInsert = procedure(source : GLenum; type_ : GLenum; id : GLuint; sverity : GLenum; length : GLsizei; const buf : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageCallback = procedure(callback : TGLDEBUGPROC; const userParam : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDebugMessageLog = function(count : GLuint; bufsize : GLsizei; sources : PGLenum; types : PGLenum; ids : PGLuint; sverities : PGLenum; lengths : PGLSizei; messagelog : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushDebugGroup = procedure(source : GLenum; id : GLuint; length : GLsizei; const message_ : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPopDebugGroup = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglObjectLabel = procedure(identifier : GLenum; name : GLuint; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectLabel = procedure(identifier : GLenum; name : GLuint; bufsize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglObjectPtrLabel = procedure(const ptr : Pointer; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectPtrLabel = procedure(const ptr : Pointer; bufSize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_clear_buffer_object - TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearNamedBufferDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearNamedBufferSubDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLenum; type_ : GLenum; offset : GLsizeiptr; size : GLsizeiptr; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_compute_shader 1 - TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_copy_image - TglCopyImageSubData = procedure(srcName : GLUInt; srcTarget : GLenum; srcLevel : GLint; srcX : GLint; srcY : GLint; srcZ : GLint; dstName : GLUInt; dstTarget : GLEnum; dstLevel : GLInt; dstX : GLInt; dstY : GLint; dstZ : GLint; srcWidth : GLsizei; srcHeight : GLsizei; srcDepth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_debug_group - // ARB_debug_group reuses entry points from KHR_debug - - // GL_ARB_debug_label - // ARB_debug_label reuses entry points from KHR_debug - - // GL_ARB_debug_output2 - - // GL_ARB_ES3_compatibility - - // GL_ARB_explicit_uniform_location - - // GL_ARB_fragment_layer_viewport - - // GL_ARB_framebuffer_no_attachments - TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferParameteriEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedFramebufferParameterivEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_internalformat_query2 - TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_invalidate_subdata - TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_multi_draw_indirect - TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_program_interface_query - TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_robust_buffer_access_behavior - - // GL_ARB_shader_image_size - - // GL_ARB_shader_storage_buffer_object - TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_stencil_texturing - - // GL_ARB_texture_buffer_range - TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureBufferRangeEXT = procedure(texture : GLuint; target : GLenum; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_texture_query_levels - - // GL_ARB_texture_storage_multisample - TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureStorage2DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureStorage3DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL 4.4 - - TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // END GL 4.4 - - - // GL_ARB_texture_view - TglTextureView = procedure(texture : GLuint; target : GLenum; origtexture : GLuint; internalformat : GLenum; minlevel : GLuint; numlevels : GLuint; minlayer : GLuint; numlayers : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_vertex_attrib_binding - TglBindVertexBuffer = procedure(bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribIFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribLFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribBinding = procedure(attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexBindingDivisor = procedure(bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayBindVertexBufferEXT = procedure(vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribIFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribLFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribBindingEXT = procedure(vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexBindingDivisorEXT = procedure(vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_robustness_isolation - - // - - // GL_ARB_cl_event - TglCreateSyncFromCLeventARB = function(context: p_cl_context; event: p_cl_event; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_debug_output - TglDebugMessageControlARB = procedure(source: GLenum; type_: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageInsertARB = procedure(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageCallbackARB = procedure(callback: TglDebugProcARB; const userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDebugMessageLogARB = function(count: GLuint; bufsize: GLsizei; sources: PGLenum; types: PGLenum; ids: PGLuint; severities: PGLenum; lengths: PGLsizei; messageLog: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ARB_robustness - TglGetGraphicsResetStatusARB = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnMapdvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnMapfvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnMapivARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnPixelMapfvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnPixelMapuivARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnPixelMapusvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnPolygonStippleARB = procedure(bufSize: GLsizei; pattern: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnColorTableARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnConvolutionFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnSeparableFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; rowBufSize: GLsizei; row: PGLvoid; columnBufSize: GLsizei; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnHistogramARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnMinmaxARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnTexImageARB = procedure(target: GLenum; level: GLint; format: GLenum; type_: GLenum; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReadnPixelsARB = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; bufSize: GLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnCompressedTexImageARB = procedure(target: GLenum; lod: GLint; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnUniformfvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnUniformivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnUniformuivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetnUniformdvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_draw_buffers - TglDrawBuffersATI = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_element_array - TglElementPointerATI = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementArrayATI = procedure(mode: GLenum; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawRangeElementArrayATI = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_envmap_bumpmap - TglTexBumpParameterivATI = procedure(pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexBumpParameterfvATI = procedure(pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexBumpParameterivATI = procedure(pname: GLenum; param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexBumpParameterfvATI = procedure(pname: GLenum; param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_fragment_shader - TglGenFragmentShadersATI = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPassTexCoordATI = procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSampleMapATI = procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAlphaFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAlphaFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglAlphaFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSetFragmentShaderConstantATI = procedure(dst: GLuint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_map_object_buffer - TglMapObjectBufferATI = function(buffer: GLuint): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUnmapObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_pn_triangles - TglPNTrianglesiATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPNTrianglesfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_separate_stencil - TglStencilOpSeparateATI = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilFuncSeparateATI = procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_vertex_array_object - TglNewObjectBufferATI = function(size: GLsizei; const _pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsObjectBufferATI = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUpdateObjectBufferATI = procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const _pointer: PGLvoid; preserve: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectBufferfvATI = procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetObjectBufferivATI = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFreeObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglArrayObjectATI = procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetArrayObjectfvATI = procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetArrayObjectivATI = procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantArrayObjectATI = procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantArrayObjectfvATI = procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantArrayObjectivATI = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_vertex_attrib_array_object - TglVertexAttribArrayObjectATI = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribArrayObjectfvATI = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribArrayObjectivATI = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_ATI_vertex_streams - TglVertexStream1sATI = procedure(stream: GLenum; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1iATI = procedure(stream: GLenum; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1fATI = procedure(stream: GLenum; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1dATI = procedure(stream: GLenum; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream1dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2sATI = procedure(stream: GLenum; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2iATI = procedure(stream: GLenum; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream2dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexStream4dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3bATI = procedure(stream: GLenum; nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3bvATI = procedure(stream: GLenum; const coords: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3sATI = procedure(stream: GLenum; nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3iATI = procedure(stream: GLenum; nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3fATI = procedure(stream: GLenum; nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3dATI = procedure(stream: GLenum; nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClientActiveVertexStreamATI = procedure(stream: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexBlendEnviATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexBlendEnvfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_performance_monitor - TglGetPerfMonitorGroupsAMD = procedure(numGroups: PGLint; groupsSize: GLsizei; groups: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPerfMonitorCountersAMD = procedure(group: GLuint; numCounters: PGLint; maxActiveCouters: PGLint; counterSize: GLsizei; counters: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPerfMonitorGroupStringAMD = procedure(group: GLuint; bufSize: GLsizei; length: PGLsizei; groupString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPerfMonitorCounterStringAMD = procedure(group: GLuint; counter: GLuint; bufSize: GLsizei; length: PGLsizei; counterString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPerfMonitorCounterInfoAMD = procedure(group: GLuint; counter: GLuint; pname: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenPerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeletePerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSelectPerfMonitorCountersAMD = procedure(monitor: GLuint; enable: GLboolean; group: GLuint; numCounters: GLint; counterList: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPerfMonitorCounterDataAMD = procedure(monitor: GLuint; pname: GLenum; dataSize: GLsizei; data: PGLuint; bytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_vertex_shader_tesselator - TglTessellationFactorAMD = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTessellationModeAMD = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_draw_buffers_blend - TglBlendFuncIndexedAMD = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendFuncSeparateIndexedAMD = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquationIndexedAMD = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBlendEquationSeparateIndexedAMD = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_name_gen_delete - TglGenNamesAMD = procedure(identifier: GLenum; num: GLuint; names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteNamesAMD = procedure(identifier: GLenum; num: GLuint; const names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsNameAMD = function(identifier: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_debug_output - TglDebugMessageEnableAMD = procedure(category: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageInsertAMD = procedure(category: GLenum; severity: GLenum; id: GLuint; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDebugMessageCallbackAMD = procedure(callback: TGLDebugProcAMD; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDebugMessageLogAMD = function(count: GLuint; bufsize: GLsizei; categories: PGLenum; severities: PGLuint; ids: PGLuint; lengths: PGLsizei; message: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_blend_color - TglBlendColorEXT = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_blend_func_separate - TglBlendFuncSeparateEXT = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_blend_minmax - TglBlendEquationEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_color_subtable - TglColorSubTableEXT = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyColorSubTableEXT = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_compiled_vertex_array - TglLockArraysEXT = procedure(first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUnlockArraysEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_convolution - TglConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameterfEXT = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameteriEXT = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSeparableFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSeparableFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_coordinate_frame - TglTangent3bEXT = procedure(tx: GLbyte; ty: GLbyte; tz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3dEXT = procedure(tx: GLdouble; ty: GLdouble; tz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3fEXT = procedure(tx: GLfloat; ty: GLfloat; tz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3iEXT = procedure(tx: GLint; ty: GLint; tz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3sEXT = procedure(tx: GLshort; ty: GLshort; tz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangent3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3bEXT = procedure(bx: GLbyte; by: GLbyte; bz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3dEXT = procedure(bx: GLdouble; by: GLdouble; bz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3fEXT = procedure(bx: GLfloat; by: GLfloat; bz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3iEXT = procedure(bx: GLint; by: GLint; bz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3sEXT = procedure(bx: GLshort; by: GLshort; bz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormal3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTangentPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBinormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_copy_texture - TglCopyTexImage1DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexImage2DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_cull_vertex - TglCullParameterdvEXT = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCullParameterfvEXT = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_draw_range_elements - TglDrawRangeElementsEXT = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_fog_coord - TglFogCoordfEXT = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordfvEXT = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoorddEXT = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoorddvEXT = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_framebuffer_object - TglIsRenderbufferEXT = function(renderbuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindRenderbufferEXT = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteRenderbuffersEXT = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenRenderbuffersEXT = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRenderbufferStorageEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetRenderbufferParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsFramebufferEXT = function(framebuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindFramebufferEXT = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteFramebuffersEXT = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenFramebuffersEXT = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCheckFramebufferStatusEXT = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture1DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture2DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTexture3DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferRenderbufferEXT = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFramebufferAttachmentParameterivEXT = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenerateMipmapEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_histogram - TglGetHistogramEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHistogramParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetHistogramParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmaxEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmaxParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMinmaxParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglHistogramEXT = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMinmaxEXT = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResetHistogramEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResetMinmaxEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_index_func - TglIndexFuncEXT = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_index_material - TglIndexMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_light_texture - TglApplyTextureEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureLightEXT = procedure(pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_multi_draw_arrays - TglMultiDrawArraysEXT = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiDrawElementsEXT = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_multisample - TglSampleMaskEXT = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplePatternEXT = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_paletted_texture - TglColorTableEXT = procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_pixel_transform - TglPixelTransformParameteriEXT = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTransformParameterfEXT = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTransformParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTransformParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_point_parameters - TglPointParameterfEXT = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterfvEXT = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_polygon_offset - TglPolygonOffsetEXT = procedure(factor: GLfloat; bias: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_secondary_color - TglSecondaryColor3bEXT = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3dEXT = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3fEXT = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3iEXT = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3sEXT = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ubEXT = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3ubvEXT = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3uiEXT = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3uivEXT = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3usEXT = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3usvEXT = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_stencil_two_side - TglActiveStencilFaceEXT = procedure(face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_subtexture - TglTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_texture3D - TglTexImage3DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_texture_object - TglAreTexturesResidentEXT = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTextureEXT = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteTexturesEXT = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenTexturesEXT = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsTextureEXT = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPrioritizeTexturesEXT = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_texture_perturb_normal - TglTextureNormalEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_vertex_array - TglArrayElementEXT = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawArraysEXT = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlagPointerEXT = procedure(stride: GLsizei; count: GLsizei; const _pointer: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPointervEXT = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_vertex_shader - TglBeginVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenVertexShadersEXT = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderOp1EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderOp2EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglShaderOp3EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSwizzleEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWriteMaskEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInsertComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglExtractComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenSymbolsEXT = function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSetInvariantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSetLocalConstantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantbvEXT = procedure(id: GLuint; const addr: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantsvEXT = procedure(id: GLuint; const addr: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantivEXT = procedure(id: GLuint; const addr: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantfvEXT = procedure(id: GLuint; const addr: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantdvEXT = procedure(id: GLuint; const addr: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantubvEXT = procedure(id: GLuint; const addr: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantusvEXT = procedure(id: GLuint; const addr: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantuivEXT = procedure(id: GLuint; const addr: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVariantPointerEXT = procedure(id: GLuint; _type: GLenum; stride: GLuint; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindLightParameterEXT = function(light: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindMaterialParameterEXT = function(face: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTexGenParameterEXT = function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTextureUnitParameterEXT = function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindParameterEXT = function(value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsVariantEnabledEXT = function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVariantPointervEXT = procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetInvariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetInvariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetInvariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetLocalConstantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetLocalConstantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetLocalConstantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_vertex_weighting - TglVertexWeightfEXT = procedure(weight: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexWeightfvEXT = procedure(const weight: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexWeightPointerEXT = procedure(size: GLsizei; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_stencil_clear_tag - TglStencilClearTagEXT = procedure(stencilTagBits: GLsizei; stencilClearTag: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_framebuffer_blit - TglBlitFramebufferEXT = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_framebuffer_multisample - TglRenderbufferStorageMultisampleEXT = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_timer_query - TglGetQueryObjecti64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetQueryObjectui64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_gpu_program_parameters - TglProgramEnvParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_bindable_uniform - TglUniformBufferEXT = procedure(_program: GLuint; location: GLint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformBufferSizeEXT = function(_program: GLuint; location: GLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformOffsetEXT = function(_program: GLuint; location: GLint): GLintptr; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_draw_buffers2 - TglColorMaskIndexedEXT = procedure(buf: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBooleanIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegerIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsEnabledIndexedEXT = function(target: GLenum; index: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_draw_instanced - TglDrawArraysInstancedEXT = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawElementsInstancedEXT = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: Pointer; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_geometry_shader4 - TglProgramParameteriEXT = procedure (_program: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -// TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferTextureFaceEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_gpu_shader4 - TglVertexAttribI1iEXT = procedure(index: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2iEXT = procedure(index: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1uiEXT = procedure(index: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI1uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI2uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI3uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4bvEXT = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4svEXT = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4ubvEXT = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribI4usvEXT = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribIPointerEXT = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const _pointer: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribIivEXT = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribIuivEXT = procedure(index: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1uiEXT = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformuivEXT = procedure(_program: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindFragDataLocationEXT = procedure(_program: GLuint; colorNumber: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragDataLocationEXT = function(_program: GLuint; const name: PGLchar): GLint; - - // GL_EXT_texture_array - TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_texture_buffer_object - TglTexBufferEXT = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_texture_integer - TglClearColorIiEXT = procedure(r: GLint; g: GLint; b: GLint; a: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearColorIuiEXT = procedure(r: GLuint; g: GLuint; b: GLuint; a: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterIuivEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterIiuvEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_HP_image_transform - TglImageTransformParameteriHP = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglImageTransformParameterfHP = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_depth_bounds_test - TglDepthBoundsEXT = procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_blend_equation_separate - TglBlendEquationSeparateEXT = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_transform_feedback - TglBeginTransformFeedbackEXT = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndTransformFeedbackEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferRangeEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferOffsetEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferBaseEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformFeedbackVaryingsEXT = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTransformFeedbackVaryingEXT = procedure(program_: GLuint; index_: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_direct_state_access - TglClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPushClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixLoadfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixLoaddEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixMultfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixMultdEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixLoadIdentityEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixRotatefEXT = procedure(mode: GLenum; angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixRotatedEXT = procedure(mode: GLenum; angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixScalefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixScaledEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixTranslatefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixTranslatedEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixFrustumEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixOrthoEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixPopEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixPushEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixLoadTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixLoadTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixMultTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMatrixMultTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameterfEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameteriEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureImageEXT = procedure(texture: GLuint; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureLevelParameterfvEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureLevelParameterivEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameterfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameteriEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexLevelParameterfvEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexLevelParameterivEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels:PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindMultiTextureEXT = procedure(texunit: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEnableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoordPointerEXT = procedure(texunit: GLenum; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexEnvfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexEnviEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGendEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGendvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGenfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGenfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGeniEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexGenivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexGendvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexGenfvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexGenivEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFloatIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDoubleIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPointerIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCompressedTextureImageEXT = procedure(texture: GLuint; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCompressedMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCompressedMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; format: GLenum; len: GLsizei; const string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameter4dEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameter4dvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameter4fEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameter4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramLocalParameterdvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramLocalParameterfvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramivEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameters4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameterI4iEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameterI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParametersI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameterI4uiEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParameterI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedProgramLocalParametersI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramLocalParameterIivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedProgramLocalParameterIuivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1iEXT = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedBufferDataEXT = procedure(buffer: GLuint; size: GLsizei; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapNamedBufferEXT = function(buffer: GLuint; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUnmapNamedBufferEXT = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapNamedBufferRangeEXT = function(buffer: GLuint; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFlushMappedNamedBufferRangeEXT = procedure(buffer: GLuint; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedCopyBufferSubDataEXT = procedure(readBuffer: GLuint; writeBuffer: GLuint; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedBufferParameterivEXT = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedBufferPointervEXT = procedure(buffer: GLuint; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureBufferEXT = procedure(texture: GLuint; target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexBufferEXT = procedure(texunit: GLenum; target: GLenum; interformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedRenderbufferStorageEXT = procedure(renderbuffer: GLuint; interformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedRenderbufferParameterivEXT = procedure(renderbuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCheckNamedFramebufferStatusEXT = function(framebuffer: GLuint; target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTexture1DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTexture2DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTexture3DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferRenderbufferEXT = procedure(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedFramebufferAttachmentParameterivEXT = procedure(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenerateTextureMipmapEXT = procedure(texture: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenerateMultiTexMipmapEXT = procedure(texunit: GLenum; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferDrawBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferDrawBuffersEXT = procedure(framebuffer: GLuint; n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFramebufferReadBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFramebufferParameterivEXT = procedure(framebuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedRenderbufferStorageMultisampleEXT = procedure(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedRenderbufferStorageMultisampleCoverageEXT = procedure(renderbuffer: GLuint; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTextureEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTextureLayerEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNamedFramebufferTextureFaceEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTextureRenderbufferEXT = procedure(texture: GLuint; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexRenderbufferEXT = procedure(texunit: GLenum; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix2x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix3x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformMatrix4x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_separate_shader_objects - TglUseShaderProgramEXT = procedure(_type: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglActiveProgramEXT = procedure(_program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCreateShaderProgramEXT = function(_type: GLenum; const _string: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_shader_image_load_store - TglBindImageTextureEXT = procedure(index: GLuint; texture: GLuint; level: GLint; layered: GLboolean; layer: GLint; access: GLenum; format: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMemoryBarrierEXT = procedure(barriers: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_EXT_vertex_attrib_64bit - TglVertexAttribL1dEXT = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL1dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribLPointerEXT = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribLdvEXT = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayVertexAttribLOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_IBM_multimode_draw_arrays - TglMultiModeDrawArraysIBM = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiModeDrawElementsIBM = procedure(const mode: PGLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_IBM_vertex_array_lists - TglColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlagPointerListIBM = procedure(stride: GLint; const _pointer: PGLboolean; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_INGR_blend_func_separate - TglBlendFuncSeparateINGR = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_INTEL_parallel_arrays - TglVertexPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalPointervINTEL = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_MESA_resize_buffers - TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_MESA_window_pos - TglWindowPos2dMESA = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2fMESA = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2iMESA = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2sMESA = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3iMESA = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3sMESA = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4iMESA = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4sMESA = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_evaluators - TglMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapParameterivNV = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMapParameterfvNV = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapParameterivNV = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapParameterfvNV = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapAttribParameterivNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetMapAttribParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEvalMapsNV = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_fence - TglDeleteFencesNV = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenFencesNV = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTestFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFenceivNV = procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinishFenceNV = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSetFenceNV = procedure(fence: GLuint; condition: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_fragment_program - TglProgramNamedParameter4fNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramNamedParameter4dNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramNamedParameter4fvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramNamedParameter4dvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramNamedParameterfvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramNamedParameterdvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_half_float - TglVertex2hNV = procedure(x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3hNV = procedure(nx: GLhalfNV; ny: GLhalfNV; nz: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV; alpha: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1hNV = procedure(s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2hNV = procedure(s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1hNV = procedure(target: GLenum; s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord1hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord2hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord3hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMultiTexCoord4hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordhNV = procedure(fog: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexWeighthNV = procedure(weight: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1hNV = procedure(index: GLuint; x: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs1hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs2hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs3hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs4hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_occlusion_query - TglGenOcclusionQueriesNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteOcclusionQueriesNV = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsOcclusionQueryNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBeginOcclusionQueryNV = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetOcclusionQueryivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetOcclusionQueryuivNV = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_pixel_data_range - TglPixelDataRangeNV = procedure(target: GLenum; length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFlushPixelDataRangeNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_point_sprite - TglPointParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_primitive_restart - TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPrimitiveRestartIndexNV = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_register_combiners - TglCombinerParameterfvNV = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCombinerParameterfNV = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCombinerParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCombinerParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCombinerInputNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCombinerOutputNV = procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinalCombinerInputNV = procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCombinerInputParameterfvNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCombinerInputParameterivNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCombinerOutputParameterfvNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCombinerOutputParameterivNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFinalCombinerInputParameterfvNV = procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFinalCombinerInputParameterivNV = procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_register_combiners2 - TglCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vertex_array_range - TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexArrayRangeNV = procedure(length: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vertex_program - TglAreProgramsResidentNV = function(n: GLsizei; const programs: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindProgramNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglExecuteProgramNV = procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenProgramsNV = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramParameterdvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramStringNV = procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTrackMatrixivNV = procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribdvNV = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribfvNV = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribivNV = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribPointervNV = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsProgramNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadProgramNV = procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameter4dNV = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameter4dvNV = procedure(target: GLenum; index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameter4fNV = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameter4fvNV = procedure(target: GLenum; index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameters4dvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramParameters4fvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglRequestResidentProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTrackMatrixNV = procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribPointerNV = procedure(index: GLuint; fsize: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1dNV = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1fNV = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1sNV = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib1svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2sNV = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib2svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib3svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4ubNV = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttrib4ubvNV = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs1dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs1fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs1svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs2dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs2fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs2svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs3dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs3fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs3svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs4dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs4fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs4svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribs4ubvNV = procedure(index: GLuint; count: GLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_depth_buffer_float - TglDepthRangedNV = procedure(n: GLdouble; f: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglClearDepthdNV = procedure(d: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDepthBoundsdNV = procedure(zmin: GLdouble; zmax: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_framebuffer_multisample_coverage - TglRenderbufferStorageMultsampleCoverageNV = procedure(target: GLenum; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_geometry_program4 - TglProgramVertexLimitNV = procedure(target: GLenum; limit: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_gpu_program4 - TglProgramLocalParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramLocalParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramEnvParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramLocalParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramLocalParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramEnvParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramEnvParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_parameter_buffer_object - TglProgramBufferParametersfvNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramBufferParametersIivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramBufferParametersIuivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_transform_feedback - TglBeginTransformFeedbackNV = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformFeedbackAttribsNV = procedure(count: GLsizei; const attribs: GLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformFeedbackVaryingsNV = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglActiveVaryingNV = procedure(program_: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVaryingLocationNV = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetActiveVaryingNV = procedure(program_: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTransformFeedbackVaryingNV = procedure(program_: GLuint; index: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformFeedbackStreamAttribsNV = procedure(count: GLsizei; const attribs: PGLint; nbuffers: GLsizei; const bufstreams: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_conditional_render - TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_present_video - TglPresentFrameKeyedNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDuratioId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; key0: GLuint; target1: GLenum; fill1: GLuint; key1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPresentFrameDualFillNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDurationId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; target1: GLenum; fill1: GLuint; target2: GLenum; fill2: GLuint; target3: GLenum; fill3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} -// TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_explicit_multisample - TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_transform_feedback2 - TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_video_capture - TglBeginVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindVideoCaptureStreamBufferNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; offset: GLintptrARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindVideoCaptureStreamTextureNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEndVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoCaptureivNV = procedure(video_capture_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoCaptureStreamivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoCaptureStreamfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVideoCaptureStreamdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVideoCaptureNV = function(video_capture_slot: GLuint; sequence_num: PGLuint; capture_time: PGLuint64EXT): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVideoCaptureStreamParameterivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVideoCaptureStreamParameterfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVideoCaptureStreamParameterdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_copy_image - TglCopyImageSubDataNV = procedure(srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_shader_buffer_load - TglMakeBufferResidentNV = procedure(target: GLenum; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeBufferNonResidentNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsBufferResidentNV = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeNamedBufferResidentNV = procedure(buffer: GLuint; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeNamedBufferNonResidentNV = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsNamedBufferResidentNV = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetBufferParameterui64vNV = procedure(target: GLenum; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetNamedBufferParameterui64vNV = procedure(buffer: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegerui64vNV = procedure(value: GLenum; result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformui64NV = procedure(location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformui64vNV = procedure(_program: GLuint; location: GLint; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformui64NV = procedure(_program: GLuint; location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformui64vNV = procedure(_program: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vertex_buffer_unified_memory - TglBufferAddressRangeNV = procedure(pname: GLenum; index: GLuint; adress: GLuint64EXT; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormalFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIndexFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoordFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglEdgeFlagFormatNV = procedure(stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSecondaryColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFogCoordFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribIFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegerui64i_vNV = procedure(value: GLenum; index: GLuint; Result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_gpu_program5 - TglProgramSubroutineParametersuivNV = procedure(target: GLenum; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetProgramSubroutineParameteruivNV = procedure(target: GLenum; index: GLuint; param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_gpu_shader5 - TglUniform1i64NV = procedure(location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1ui64NV = procedure(location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform1ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform2ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform3ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniform4ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetUniformi64vNV = procedure(program_: GLuint; location: GLint; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform1ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform2ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform3ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniform4ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vertex_attrib_integer_64bit - TglVertexAttribL1i64NV = procedure(index: GLuint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL1i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL1ui64NV = procedure(index: GLuint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL1ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL2ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL3ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribL4ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribLi64vNV = procedure(index: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetVertexAttribLui64vNV = procedure(index: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVertexAttribLFormatNV = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_vdpau_interop - TglVDPAUInitNV = procedure(const vdpDevice: PGLvoid; const getProcAddress: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUFiniNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAURegisterVideoSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAURegisterOutputSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUIsSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUUnregisterSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUGetSurfaceivNV = procedure(surface: GLvdpauSurfaceNV; pname: GLenum; bufSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUSurfaceAccessNV = procedure(surface: GLvdpauSurfaceNV; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUMapSurfacesNV = procedure(numSurfaces: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglVDPAUUnmapSurfacesNV = procedure(numSurface: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_texture_barrier - TglTextureBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // (4.3) - // GL_NV_path_rendering - TglGenPathsNV = function(range : GLsizei) : GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeletePathsNV = procedure(path : GLUInt; range : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsPathNV = function(path : GLUInt) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathCommandsNV = procedure(path : GLUInt; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLsizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathCoordsNV = procedure(path : GLUInt; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathSubCommandsNV = procedure(path : GLUInt; commandStart : GLsizei; commandsToDelete : GLsizei; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathSubCoordsNV = procedure(path : GLUInt; coordStart : GLsizei; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathStringNV = procedure(path : GLUInt; format : GLenum; length : GLsizei; const pathString : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathGlyphsNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; numGlyphs : GLsizei; type_ : GLenum; const charcodes : PGLvoid; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathGlyphRangeNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; firstGlyph : GLuint; numGlyphs : GLsizei; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglWeightPathsNV = procedure(resultPath : GLUInt; numPaths : GLSizei; const paths : PGLuint; const weights : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyPathNV = procedure(resultPath : GLUInt; srcPath : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInterpolatePathsNV = procedure(resultPath : GLUInt; pathA : GLUInt; pathB : GLUInt; weight : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTransformPathNV = procedure(resultPath : GLUInt; srcPath : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathParameteriNV = procedure(path : GLUInt; pname : GLEnum; value : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathParameterfNV = procedure(path : GLUInt; pname : GLEnum; value : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathDashArrayNV = procedure(path : GLUInt; dashCount : GLsizei; const dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathStencilFuncNV = procedure(func : GLenum; ref : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathStencilDepthOffsetNV = procedure(factor : GLfloat; units : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilFillPathNV = procedure(path : GLUInt; fillMode : GLenum; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilStrokePathNV = procedure(path : GLUInt; reference : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; fillMode : GLenum; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStencilStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; reference : GLint; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathCoverDepthFuncNV = procedure(func : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathColorGenNV = procedure(color : GLenum; genMode : GLenum; colorFormat : GLenum; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathTexGenNV = procedure(texCoordSet : GLenum; genMode : GLenum; components : GLint; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPathFogGenNV = procedure(genMode : GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCoverFillPathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCoverStrokePathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCoverFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCoverStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathCommandsNV = procedure(path : GLUInt; commands : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathCoordsNV = procedure(path : GLUInt; coords : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathDashArrayNV = procedure(path : GLUInt; dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathMetricsNV = procedure(metricQueryMask : GLbitfield; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathMetricRangeNV = procedure(metricQueryMask : GLbitfield; firstPathName : GLuint; numPaths : GLSizei; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathSpacingNV = procedure(pathListMode : GLenum; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; advanceScale : GLfloat; kerningScale : GLfloat; transformType : GLenum; returnedSpacing : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathColorGenivNV = procedure(color : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathColorGenfvNV = procedure(color : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathTexGenivNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathTexGenfvNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsPointInFillPathNV = function(path : GLUInt; mask : GLuint; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsPointInStrokePathNV = function (path : GLUInt; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPathLengthNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei) : GLfloat; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointAlongPathNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei; distance : GLfloat; x : PGLfloat; y : PGLfloat; tangentX : PGLfloat; tangentY : PGLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_pinned_memory - - // GL_AMD_stencil_operation_extended - TglStencilOpValueAMD = procedure(face : GLEnum; value : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_AMD_vertex_shader_viewport_index - - // GL_AMD_vertex_shader_layer - - // GL_NV_bindless_texture - TglGetTextureHandleNV = function(texture : GLuint ) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTextureSamplerHandleNV = function(texture : GLuint; sampler : GLuint) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeTextureHandleResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeTextureHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetImageHandleNV = function(texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeImageHandleResidentNV = procedure(handle : GLUint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglMakeImageHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformHandleui64NV = procedure(location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglUniformHandleui64vNV = procedure(location : GLint; cowunt : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformHandleui64NV = procedure(program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglProgramUniformHandleui64vNV = procedure(program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsTextureHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsImageHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_NV_shader_atomic_float - - // GL_AMD_query_buffer_object - - // - - // GL_PGI_misc_hints - TglHintPGI = procedure(target: GLenum; mode: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_detail_texture - TglDetailTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetDetailTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_fog_function - TglFogFuncSGIS = procedure(n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFogFuncSGIS = procedure(points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_multisample - TglSampleMaskSGIS = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSamplePatternSGIS = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_pixel_texture - TglPixelTexGenParameteriSGIS = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTexGenParameterivSGIS = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTexGenParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelTexGenParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPixelTexGenParameterivSGIS = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetPixelTexGenParameterfvSGIS = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_point_parameters - TglPointParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPointParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_sharpen_texture - TglSharpenTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetSharpenTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_texture4D - TglTexImage4DSGIS = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexSubImage4DSGIS = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; woffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_texture_color_mask - TglTextureColorMaskSGIS = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIS_texture_filter4 - TglGetTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; n: GLsizei; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_async - TglAsyncMarkerSGIX = procedure(marker: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFinishAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPollAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenAsyncMarkersSGIX = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteAsyncMarkersSGIX = procedure(marker: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglIsAsyncMarkerSGIX = function(marker: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_flush_raster - TglFlushRasterSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_fragment_lighting - TglFragmentColorMaterialSGIX = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightfSGIX = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightiSGIX = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightModelfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightModelfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightModeliSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentLightModelivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentMaterialfSGIX = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentMaterialiSGIX = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLightEnviSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_framezoom - TglFrameZoomSGIX = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_igloo_interface - TglIglooInterfaceSGIX = procedure(pname: GLenum; const params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_instruments - TglGetInstrumentsSGIX = function(): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglInstrumentsBufferSGIX = procedure(size: GLsizei; buffer: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPollInstrumentsSGIX = function(marker_p: PGLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReadInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStartInstrumentsSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglStopInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_list_priority - TglGetListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetListParameterivSGIX = procedure(list: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglListParameterfSGIX = procedure(list: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglListParameteriSGIX = procedure(list: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglListParameterivSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_pixel_texture - TglPixelTexGenSGIX = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_polynomial_ffd - TglDeformationMap3dSGIX = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; w1: GLdouble; w2: GLdouble; wstride: GLint; worder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeformationMap3fSGIX = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; w1: GLfloat; w2: GLfloat; wstride: GLint; worder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeformSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglLoadIdentityDeformationMapSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_reference_plane - TglReferencePlaneSGIX = procedure(const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_sprite - TglSpriteParameterfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSpriteParameterfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSpriteParameteriSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglSpriteParameterivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGIX_tag_sample_buffer - TglTagSampleBufferSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SGI_color_table - TglColorTableSGI = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglCopyColorTableSGI = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableSGI = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SUNX_constant_data - TglFinishTextureSUNX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SUN_global_alpha - TglGlobalAlphaFactorbSUN = procedure(factor: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactorsSUN = procedure(factor: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactoriSUN = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactorfSUN = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactordSUN = procedure(factor: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactorubSUN = procedure(factor: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactorusSUN = procedure(factor: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGlobalAlphaFactoruiSUN = procedure(factor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SUN_mesh_array - TglDrawMeshArraysSUN = procedure(mode: GLenum; first: GLint; count: GLsizei; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SUN_triangle_list - TglReplacementCodeuiSUN = procedure(code: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeusSUN = procedure(code: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeubSUN = procedure(code: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuivSUN = procedure(const code: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeusvSUN = procedure(const code: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeubvSUN = procedure(const code: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodePointerSUN = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // GL_SUN_vertex - TglColor4ubVertex2fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ubVertex2fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ubVertex3fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4ubVertex3fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor3fVertex3fvSUN = procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3fVertex3fSUN = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglNormal3fVertex3fvSUN = procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4fNormal3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglColor4fNormal3fVertex3fvSUN = procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fVertex3fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4fVertex4fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor4ubVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor4ubVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor4fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4fColor4fNormal3fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexCoord4fColor4fNormal3fVertex4fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiVertex3fSUN = procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiVertex3fvSUN = procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor4ubVertex3fSUN = procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor4ubVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiNormal3fVertex3fSUN = procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - // window support functions -{$IFDEF DGL_WIN} - TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall; - TwglCopyContext = function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall; - TwglCreateContext = function(DC: HDC): HGLRC; stdcall; - TwglCreateLayerContext = function(p1: HDC; p2: Integer): HGLRC; stdcall; - TwglDeleteContext = function(p1: HGLRC): BOOL; stdcall; - TwglDescribeLayerPlane = function(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall; - TwglGetCurrentContext = function: HGLRC; stdcall; - TwglGetCurrentDC = function: HDC; stdcall; - TwglGetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; - TwglMakeCurrent = function(DC: HDC; p2: HGLRC): BOOL; stdcall; - TwglRealizeLayerPalette = function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall; - TwglSetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; - TwglShareLists = function(p1, p2: HGLRC): BOOL; stdcall; - TwglSwapLayerBuffers = function(p1: HDC; p2: Cardinal): BOOL; stdcall; - TwglSwapMultipleBuffers = function(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall; - TwglUseFontBitmapsA = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; - TwglUseFontBitmapsW = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; - TwglUseFontBitmaps = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; - - TwglUseFontOutlinesA = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; - TwglUseFontOutlinesW = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; - TwglUseFontOutlines = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; - - - // WGL_ARB_buffer_region - TwglCreateBufferRegionARB = function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; stdcall; - TwglDeleteBufferRegionARB = procedure(hRegion: THandle); stdcall; - TwglSaveBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): Boolean; stdcall; - TwglRestoreBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): Boolean; stdcall; - - // WGL_ARB_extensions_string - TwglGetExtensionsStringARB = function(hdc: HDC): PAnsiChar; stdcall; - - // WGL_ARB_make_current_read - TwglMakeContextCurrentARB = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall; - TwglGetCurrentReadDCARB = function(): HDC; stdcall; - - // WGL_ARB_pbuffer - TwglCreatePbufferARB = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFERARB; stdcall; - TwglGetPbufferDCARB = function(hPbuffer: HPBUFFERARB): HDC; stdcall; - TwglReleasePbufferDCARB = function(hPbuffer: HPBUFFERARB; hDC: HDC): GLint; stdcall; - TwglDestroyPbufferARB = function(hPbuffer: HPBUFFERARB): Boolean; stdcall; - TwglQueryPbufferARB = function(hPbuffer: HPBUFFERARB; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; - - // WGL_ARB_pixel_format - TwglGetPixelFormatAttribivARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): Boolean; stdcall; - TwglGetPixelFormatAttribfvARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall; - TwglChoosePixelFormatARB = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; stdcall; - - // WGL_ARB_color_buffer_float - TwglClampColorARB = procedure(target: GLenum; clamp: GLenum); stdcall; - - // WGL_ARB_render_texture - TwglBindTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall; - TwglReleaseTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall; - TwglSetPbufferAttribARB = function(hPbuffer: HPBUFFERARB; const piAttribList: PGLint): Boolean; stdcall; - - // WGL_ARB_create_context - TwglCreateContextAttribsARB = function(hDC: HDC; hShareContext: HGLRC; const attribList: PGLint): HGLRC; stdcall; - - // WGL_AMD_gpu_association - TwglGetGPUIDsAMD = function(maxCount: Cardinal; ids: PCardinal): Cardinal; stdcall; - TwglGetGPUInfoAMD = function(id: Cardinal; property_: Integer; dataType: GLenum; size: Cardinal; data: Pointer): Integer; stdcall; - TwglGetContextGPUIDAMD = function(hglrc: HGLRC): Cardinal; stdcall; - TwglCreateAssociatedContextAMD = function(id: Cardinal): HGLRC; stdcall; - TwglCreateAssociatedContextAttribsAMD = function(id: Cardinal; hShareContext: HGLRC; const attribList: PInteger): HGLRC; stdcall; - TwglDeleteAssociatedContextAMD = function(hglrc: HGLRC): Boolean; stdcall; - TwglMakeAssociatedContextCurrentAMD = function(hglrc: HGLRC): Boolean; stdcall; - TwglGetCurrentAssociatedContextAMD = function(): HGLRC; stdcall; - TwglBlitContextFramebufferAMD = procedure(dstCtx: HGLRC; srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); stdcall; - - // WGL_EXT_display_color_table - TwglCreateDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall; - TwglLoadDisplayColorTableEXT = function(const table: PGLushort; length: GLuint): GLboolean; stdcall; - TwglBindDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall; - TwglDestroyDisplayColorTableEXT = procedure(id: GLushort); stdcall; - - // WGL_EXT_extensions_string - TwglGetExtensionsStringEXT = function(): PAnsiChar; stdcall; - - // WGL_EXT_make_current_read - TwglMakeContextCurrentEXT = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall; - TwglGetCurrentReadDCEXT = function(): HDC; stdcall; - - // WGL_EXT_pbuffer - TwglCreatePbufferEXT = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFEREXT; stdcall; - TwglGetPbufferDCEXT = function(hPbuffer: HPBUFFEREXT): HDC; stdcall; - TwglReleasePbufferDCEXT = function(hPbuffer: HPBUFFEREXT; hDC: HDC): GLint; stdcall; - TwglDestroyPbufferEXT = function(hPbuffer: HPBUFFEREXT): Boolean; stdcall; - TwglQueryPbufferEXT = function(hPbuffer: HPBUFFEREXT; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; - - // WGL_EXT_pixel_format - TwglGetPixelFormatAttribivEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): Boolean; stdcall; - TwglGetPixelFormatAttribfvEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall; - TwglChoosePixelFormatEXT = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): Boolean; stdcall; - - // WGL_EXT_swap_control - TwglSwapIntervalEXT = function(interval: GLint): Boolean; stdcall; - TwglGetSwapIntervalEXT = function(): GLint; stdcall; - - // WGL_I3D_digital_video_control - TwglGetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; - TwglSetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall; - - // WGL_I3D_gamma - TwglGetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall; - TwglSetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall; - TwglGetGammaTableI3D = function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): Boolean; stdcall; - TwglSetGammaTableI3D = function(hDC: HDC; iEntries: GLint; const puRed: PGLushort; const puGreen: PGLushort; const puBlue: PGLushort): Boolean; stdcall; - - // WGL_I3D_genlock - TwglEnableGenlockI3D = function(hDC: HDC): Boolean; stdcall; - TwglDisableGenlockI3D = function(hDC: HDC): Boolean; stdcall; - TwglIsEnabledGenlockI3D = function(hDC: HDC; pFlag: Boolean): Boolean; stdcall; - TwglGenlockSourceI3D = function(hDC: HDC; uSource: GLuint): Boolean; stdcall; - TwglGetGenlockSourceI3D = function(hDC: HDC; uSource: PGLuint): Boolean; stdcall; - TwglGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: GLuint): Boolean; stdcall; - TwglGetGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: PGLuint): Boolean; stdcall; - TwglGenlockSampleRateI3D = function(hDC: HDC; uRate: GLuint): Boolean; stdcall; - TwglGetGenlockSampleRateI3D = function(hDC: HDC; uRate: PGLuint): Boolean; stdcall; - TwglGenlockSourceDelayI3D = function(hDC: HDC; uDelay: GLuint): Boolean; stdcall; - TwglGetGenlockSourceDelayI3D = function(hDC: HDC; uDelay: PGLuint): Boolean; stdcall; - TwglQueryGenlockMaxSourceDelayI3D = function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): Boolean; stdcall; - - // WGL_I3D_image_buffer - TwglCreateImageBufferI3D = function(hDC: HDC; dwSize: GLuint; uFlags: GLuint): GLvoid; stdcall; - TwglDestroyImageBufferI3D = function(hDC: HDC; pAddress: GLvoid): Boolean; stdcall; - TwglAssociateImageBufferEventsI3D = function(hDC: HDC; const pEvent: THandle; const pAddress: PGLvoid; const pSize: PGLuint; count: GLuint): Boolean; stdcall; - TwglReleaseImageBufferEventsI3D = function(hDC: HDC; const pAddress: PGLvoid; count: GLuint): Boolean; stdcall; - - // WGL_I3D_swap_frame_lock - TwglEnableFrameLockI3D = function(): Boolean; stdcall; - TwglDisableFrameLockI3D = function(): Boolean; stdcall; - TwglIsEnabledFrameLockI3D = function(pFlag: Boolean): Boolean; stdcall; - TwglQueryFrameLockMasterI3D = function(pFlag: Boolean): Boolean; stdcall; - - // WGL_I3D_swap_frame_usage - TwglGetFrameUsageI3D = function(pUsage: PGLfloat): Boolean; stdcall; - TwglBeginFrameTrackingI3D = function(): Boolean; stdcall; - TwglEndFrameTrackingI3D = function(): Boolean; stdcall; - TwglQueryFrameTrackingI3D = function(pFrameCount: PGLuint; pMissedFrames: PGLuint; pLastMissedUsage: PGLfloat): Boolean; stdcall; - - // WGL_NV_vertex_array_range - TwglAllocateMemoryNV = procedure(size: GLsizei; readfreq: GLfloat; writefreq: GLfloat; priority: GLfloat); stdcall; - TwglFreeMemoryNV = procedure(_pointer: Pointer); stdcall; - - // WGL_NV_present_video - TwglEnumerateVideoDevicesNV = function(hdc: HDC; phDeviceList: PHVIDEOOUTPUTDEVICENV): Integer; stdcall; - TwglBindVideoDeviceNV = function(hd: HDC; uVideoSlot: Cardinal; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: PInteger): Boolean; stdcall; - TwglQueryCurrentContextNV = function(iAttribute: Integer; piValue: PInteger): Boolean; stdcall; - - // WGL_NV_video_output - TwglGetVideoDeviceNV = function(hDC: HDC; numDevices: Integer; hVideoDevice: PHPVIDEODEV): Boolean; stdcall; - TwglReleaseVideoDeviceNV = function(hVideoDevice: HPVIDEODEV): Boolean; stdcall; - TwglBindVideoImageNV = function(hVideoDevice: HPVIDEODEV; hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall; - TwglReleaseVideoImageNV = function(hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall; - TwglSendPbufferToVideoNV = function(hPbuffer: HPBUFFERARB; iBufferType: Integer; pulCounterPbuffer: PCardinal; bBlock: Boolean): Boolean; stdcall; - TwglGetVideoInfoNV = function(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: PCardinal; pulCounterOutputVideo: PCardinal): Boolean; stdcall; - - // WGL_NV_swap_group - TwglJoinSwapGroupNV = function(hDC: HDC; group: GLuint): Boolean; stdcall; - TwglBindSwapBarrierNV = function(group: GLuint; barrier: GLuint): Boolean; stdcall; - TwglQuerySwapGroupNV = function(hDC: HDC; group: PGLuint; barrier: PGLuint): Boolean; stdcall; - TwglQueryMaxSwapGroupsNV = function(hDC: HDC; mxGroups: PGLuint; maxBarriers: PGLuint): Boolean; stdcall; - TwglQueryFrameCountNV = function(hDC: HDC; count: PGLuint): Boolean; stdcall; - TwglResetFrameCountNV = function(hDC: HDC): Boolean; stdcall; - - // WGL_NV_gpu_affinity - TwglEnumGpusNV = function(iGpuIndex: Cardinal; phGpu: PHGPUNV): Boolean; stdcall; - TwglEnumGpuDevicesNV = function(hGpu: HGPUNV; iDeviceIndex: Cardinal; lpGpuDevice: PGPU_DEVICE): Boolean; stdcall; - TwglCreateAffinityDCNV = function(const phGpuList: PHGPUNV): HDC; stdcall; - TwglEnumGpusFromAffinityDCNV = function(hAffinityDC: HDC; iGpuIndex: Cardinal; hGpu: PHGPUNV): Boolean; stdcall; - TwglDeleteDCNV = function(hDC: HDC): Boolean; stdcall; - - // WGL_NV_video_capture - TwglBindVideoCaptureDeviceNV = function(uVideoSlot: Cardinal; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; - TwglEnumerateVideoCaptureDevicesNV = function(hDc: HDC; phDeviceList: PHVIDEOINPUTDEVICENV): Cardinal; stdcall; - TwglLockVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; - TwglQueryVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Integer; piValue: PInteger): Boolean; stdcall; - TwglReleaseVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall; - - // WGL_NV_copy_image - TwglCopyImageSubDataNV = function(hSrcRc: HGLRC; srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; hDstRC: HGLRC; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei): Boolean; stdcall; - - // WGL_NV_DX_interop - TwglDXSetResourceShareHandleNV = function(dxObject : PGLVoid; hareHandle : Cardinal) : Boolean; stdcall; - TwglDXOpenDeviceNV = function(dxDevice : PGLVoid) : Cardinal; stdcall; - TwglDXCloseDeviceNV = function(hDevice : Cardinal) : Boolean; stdcall; - TwglDXRegisterObjectNV = function(hDevice : Cardinal; dxObject : PGLVoid; name : GLUInt; _type : TGLEnum; access : TGLenum) : Cardinal; stdcall; - TwglDXUnregisterObjectNV = function(hDevice : Cardinal; hObject : Cardinal) : Boolean; stdcall; - TwglDXObjectAccessNV = function(hObject : Cardinal; access : GLenum) : Boolean; stdcall; - TwglDXLockObjectsNV = function(hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall; - TwglDXUnlockObjectsNV = function (hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall; - - // WGL_OML_sync_control - TwglGetSyncValuesOML = function(hdc: HDC; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; - TwglGetMscRateOML = function(hdc: HDC; numerator: PGLint; denominator: PGLint): Boolean; stdcall; - TwglSwapBuffersMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall; - TwglSwapLayerBuffersMscOML = function(hdc: HDC; fuPlanes: GLint; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall; - TwglWaitForMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; - TwglWaitForSbcOML = function(hdc: HDC; target_sbc: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall; - - // WGL_3DL_stereo_control - TwglSetStereoEmitterState3DL = function(hDC: HDC; uState: UINT): Boolean; stdcall; - - // WIN_draw_range_elements - TglDrawRangeElementsWIN = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); stdcall; - - // WIN_swap_hint - TglAddSwapHintRectWIN = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall; -{$ENDIF} - -{$IFDEF DGL_LINUX} - TglXChooseVisual = function(dpy: PDisplay; screen: GLint; attribList: PGLint): PXVisualInfo; cdecl; - TglXCopyContext = procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: GLuint); cdecl; - TglXCreateContext = function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: GLboolean): GLXContext; cdecl; - TglXCreateGLXPixmap = function(dpy: PDisplay; vis: PXVisualInfo; pixmap: Pixmap): GLXPixmap cdecl; - TglXDestroyContext = procedure(dpy: PDisplay; ctx: GLXContext); cdecl; - TglXDestroyGLXPixmap = procedure(dpy : PDisplay; pix: GLXPixmap); cdecl; - TglXGetConfig = function(dpy : PDisplay; vis: PXVisualInfo; attrib: GLint; value: PGLint): GLint; cdecl; - TglXGetCurrentContext = function: GLXContext cdecl; - TglXGetCurrentDrawable = function: GLXDrawable cdecl; - TglXIsDirect = function(dpy: PDisplay; ctx: GLXContext): glboolean; cdecl; - TglXMakeCurrent = function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): GLboolean cdecl; - TglXQueryExtension = function(dpy: PDisplay; errorBase: PGLint; eventBase: PGLint): GLboolean; cdecl; - TglXQueryVersion = function(dpy: PDisplay; major: PGLint; minor: PGLint): GLboolean cdecl; - TglXSwapBuffers = procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl; - TglXUseXFont = procedure(font: Font; first: GLint; count: GLint; listBase: GLint); cdecl; - TglXWaitGL = procedure; cdecl; - TglXWaitX = procedure; cdecl; - - TglXGetClientString = function(dpy: PDisplay; name: GLint): PGLchar; cdecl; - TglXQueryServerString = function(dpy: PDisplay; screen: GLint; name: GLint): PGLchar; cdecl; - TglXQueryExtensionsString = function(dpy: PDisplay; screen: GLint): PGLchar; cdecl; - - // GLX_VERSION_1_3 - TglXGetFBConfigs = function(dpy: PDisplay; screen: GLint; nelements: PGLint): GLXFBConfig; cdecl; - TglXChooseFBConfig = function(dpy: PDisplay; screen: GLint; attrib_list: PGLint; nelements: PGLint): GLXFBConfig; cdecl; - TglXGetFBConfigAttrib = function(dpy: PDisplay; config: GLXFBConfig; attribute: GLint; value: PGLint): glint; cdecl; - TglXGetVisualFromFBConfig = function(dpy: PDisplay; config: GLXFBConfig) : PXVisualInfo; cdecl; - TglXCreateWindow = function(dpy: PDisplay; config: GLXFBConfig; win: Window; attrib_list: PGLint): GLXWindow; cdecl; - TglXDestroyWindow = procedure(dpy: PDisplay; win: GLXWindow); cdecl; - TglXCreatePixmap = function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attrib_list: PGLint): GLXPixmap; cdecl; - - TglXDestroyPixmap = procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl; - TglXCreatePbuffer = function(dpy: PDisplay; config: GLXFBConfig; attrib_list: PGLint): GLXPbuffer; cdecl; - TglXDestroyPbuffer = procedure(dpy: PDisplay; pbuf: GLXPbuffer); cdecl; - TglXQueryDrawable = procedure(dpy: PDisplay; draw: GLXDrawable; attribute: GLint; value: PGLuint); cdecl; - TglXCreateNewContext = function(dpy: PDisplay; config: GLXFBConfig; render_type: GLint; share_list: GLXContext; direct: GLboolean): GLXContext cdecl; - TglXMakeContextCurrent = function(display: PDisplay; draw: GLXDrawable; read_: GLXDrawable; ctx: GLXContext): GLboolean; cdecl; - TglXGetCurrentReadDrawable = function: GLXDrawable; cdecl; - TglXGetCurreentDisplay = function: PDisplay; - - TglXQueryContext = function(dpy: PDisplay; ctx: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl; - TglXSelectEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: GLuint); cdecl; - TglXGetSelectedEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: PGLuint); cdecl; - - // GLX_VERSION_1_4 - TglXGetProcAddress = function(const name: PAnsiChar): pointer; cdecl; - - // GLX_ARB_get_proc_address - TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl; - - // GLX_ARB_create_context - TglXCreateContextAttribsARB = function(dpy: PDisplay; config: GLXFBConfig; share_context: GLXContext; direct: GLboolean; const attrib_list: PGLint): GLXContext; cdecl; - - // GLX_EXT_import_context - TglXGetCurrentDisplayEXT = function: PDisplay; cdecl; - TglXQueryContextInfoEXT = function(dpy: PDisplay; context: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl; - TglXGetContextIDEXT = function(const context: GLXContext): GLXContextID; cdecl; - TglXImportContextEXT = function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl; - TglXFreeContextEXT = procedure(dpy: PDisplay; context: GLXContext); cdecl; - - // GLX_EXT_texture_from_pixmap - TglXBindTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint; const attrib_list: PGLint); cdecl; - TglXReleaseTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint); cdecl; - - // GLX_EXT_swap_control - TglXSwapIntervalEXT = procedure (dpy: PDisplay; drawable: GLXDrawable; interval: GLint); cdecl; -{$ENDIF} - - // GL utility functions and procedures - TgluErrorString = function(errCode: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluGetString = function(name: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluOrtho2D = procedure(left, right, bottom, top: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluPerspective = procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluPickMatrix = procedure(x, y, width, height: GLdouble; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluLookAt = procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluProject = function(objx, objy, objz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; winx, winy, winz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluUnProject = function(winx, winy, winz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; objx, objy, objz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluScaleImage = function(format: GLEnum; widthin, heightin: GLint; typein: GLEnum; datain: Pointer; widthout, heightout: GLint; typeout: GLEnum; const dataout: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNewQuadric = function: PGLUquadric; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluDeleteQuadric = procedure(state: PGLUquadric); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluQuadricNormals = procedure(quadObject: PGLUquadric; normals: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluQuadricTexture = procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluQuadricOrientation = procedure(quadObject: PGLUquadric; orientation: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluQuadricDrawStyle = procedure(quadObject: PGLUquadric; drawStyle: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluCylinder = procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluPartialDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluSphere = procedure(quadObject: PGLUquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluQuadricCallback = procedure(quadObject: PGLUquadric; which: GLEnum; fn: TGLUQuadricErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNewTess = function: PGLUtesselator; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluDeleteTess = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessBeginPolygon = procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessBeginContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessVertex = procedure(tess: PGLUtesselator; const coords: TGLArrayd3; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessEndContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessNormal = procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluTessCallback = procedure(tess: PGLUtesselator; which: GLEnum; fn: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluGetTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNewNurbsRenderer = function: PGLUnurbs; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluDeleteNurbsRenderer = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBeginSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBeginCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluEndCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluEndSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBeginTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluEndTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluPwlCurve = procedure(nobj: PGLUnurbs; count: GLint; points: PGLfloat; stride: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNurbsCurve = procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNurbsSurface = procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluLoadSamplingMatrices = procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: TGLMatrixf4; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluGetNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNurbsCallback = procedure(nobj: PGLUnurbs; which: GLEnum; fn: TGLUNurbsErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBeginPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluNextContour = procedure(tess: PGLUtesselator; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - -var - // GL_VERSION_1_0 - glCullFace: TglCullFace; - glFrontFace: TglFrontFace; - glHint: TglHint; - glLineWidth: TglLineWidth; - glPointSize: TglPointSize; - glPolygonMode: TglPolygonMode; - glScissor: TglScissor; - glTexParameterf: TglTexParameterf; - glTexParameterfv: TglTexParameterfv; - glTexParameteri: TglTexParameteri; - glTexParameteriv: TglTexParameteriv; - glTexImage1D: TglTexImage1D; - glTexImage2D: TglTexImage2D; - glDrawBuffer: TglDrawBuffer; - glClear: TglClear; - glClearColor: TglClearColor; - glClearStencil: TglClearStencil; - glClearDepth: TglClearDepth; - glStencilMask: TglStencilMask; - glColorMask: TglColorMask; - glDepthMask: TglDepthMask; - glDisable: TglDisable; - glEnable: TglEnable; - glFinish: TglFinish; - glFlush: TglFlush; - glBlendFunc: TglBlendFunc; - glLogicOp: TglLogicOp; - glStencilFunc: TglStencilFunc; - glStencilOp: TglStencilOp; - glDepthFunc: TglDepthFunc; - glPixelStoref: TglPixelStoref; - glPixelStorei: TglPixelStorei; - glReadBuffer: TglReadBuffer; - glReadPixels: TglReadPixels; - glGetBooleanv: TglGetBooleanv; - glGetDoublev: TglGetDoublev; - glGetError: TglGetError; - glGetFloatv: TglGetFloatv; - glGetIntegerv: TglGetIntegerv; - glGetString: TglGetString; - glGetTexImage: TglGetTexImage; - glGetTexParameteriv: TglGetTexParameteriv; - glGetTexParameterfv: TglGetTexParameterfv; - glGetTexLevelParameterfv: TglGetTexLevelParameterfv; - glGetTexLevelParameteriv: TglGetTexLevelParameteriv; - glIsEnabled: TglIsEnabled; - glDepthRange: TglDepthRange; - glViewport: TglViewport; - - // GL_VERSION_1_1 - glDrawArrays: TglDrawArrays; - glDrawElements: TglDrawElements; - glGetPointerv: TglGetPointerv; - glPolygonOffset: TglPolygonOffset; - glCopyTexImage1D: TglCopyTexImage1D; - glCopyTexImage2D: TglCopyTexImage2D; - glCopyTexSubImage1D: TglCopyTexSubImage1D; - glCopyTexSubImage2D: TglCopyTexSubImage2D; - glTexSubImage1D: TglTexSubImage1D; - glTexSubImage2D: TglTexSubImage2D; - glBindTexture: TglBindTexture; - glDeleteTextures: TglDeleteTextures; - glGenTextures: TglGenTextures; -{$ifdef DGL_DEPRECATED} - glAccum: TglAccum; - glAlphaFunc: TglAlphaFunc; - glAreTexturesResident: TglAreTexturesResident; - glArrayElement: TglArrayElement; - glBegin: TglBegin; - glBitmap: TglBitmap; - glCallList: TglCallList; - glCallLists: TglCallLists; - glClearAccum: TglClearAccum; - glClearIndex: TglClearIndex; - glClipPlane: TglClipPlane; - glColor3b: TglColor3b; - glColor3bv: TglColor3bv; - glColor3d: TglColor3d; - glColor3dv: TglColor3dv; - glColor3f: TglColor3f; - glColor3fv: TglColor3fv; - glColor3i: TglColor3i; - glColor3iv: TglColor3iv; - glColor3s: TglColor3s; - glColor3sv: TglColor3sv; - glColor3ub: TglColor3ub; - glColor3ubv: TglColor3ubv; - glColor3ui: TglColor3ui; - glColor3uiv: TglColor3uiv; - glColor3us: TglColor3us; - glColor3usv: TglColor3usv; - glColor4b: TglColor4b; - glColor4bv: TglColor4bv; - glColor4d: TglColor4d; - glColor4dv: TglColor4dv; - glColor4f: TglColor4f; - glColor4fv: TglColor4fv; - glColor4i: TglColor4i; - glColor4iv: TglColor4iv; - glColor4s: TglColor4s; - glColor4sv: TglColor4sv; - glColor4ub: TglColor4ub; - glColor4ubv: TglColor4ubv; - glColor4ui: TglColor4ui; - glColor4uiv: TglColor4uiv; - glColor4us: TglColor4us; - glColor4usv: TglColor4usv; - glColorMaterial: TglColorMaterial; - glColorPointer: TglColorPointer; - glCopyPixels: TglCopyPixels; - glDeleteLists: TglDeleteLists; - glDisableClientState: TglDisableClientState; - glDrawPixels: TglDrawPixels; - glEdgeFlag: TglEdgeFlag; - glEdgeFlagPointer: TglEdgeFlagPointer; - glEdgeFlagv: TglEdgeFlagv; - glEnableClientState: TglEnableClientState; - glEnd: TglEnd; - glEndList: TglEndList; - glEvalCoord1d: TglEvalCoord1d; - glEvalCoord1dv: TglEvalCoord1dv; - glEvalCoord1f: TglEvalCoord1f; - glEvalCoord1fv: TglEvalCoord1fv; - glEvalCoord2d: TglEvalCoord2d; - glEvalCoord2dv: TglEvalCoord2dv; - glEvalCoord2f: TglEvalCoord2f; - glEvalCoord2fv: TglEvalCoord2fv; - glEvalMesh1: TglEvalMesh1; - glEvalMesh2: TglEvalMesh2; - glEvalPoint1: TglEvalPoint1; - glEvalPoint2: TglEvalPoint2; - glFeedbackBuffer: TglFeedbackBuffer; - glFogf: TglFogf; - glFogfv: TglFogfv; - glFogi: TglFogi; - glFogiv: TglFogiv; - glFrustum: TglFrustum; - glGenLists: TglGenLists; - glGetClipPlane: TglGetClipPlane; - glGetLightfv: TglGetLightfv; - glGetLightiv: TglGetLightiv; - glGetMapdv: TglGetMapdv; - glGetMapfv: TglGetMapfv; - glGetMapiv: TglGetMapiv; - glGetMaterialfv: TglGetMaterialfv; - glGetMaterialiv: TglGetMaterialiv; - glGetPixelMapfv: TglGetPixelMapfv; - glGetPixelMapuiv: TglGetPixelMapuiv; - glGetPixelMapusv: TglGetPixelMapusv; - glGetPolygonStipple: TglGetPolygonStipple; - glGetTexEnvfv: TglGetTexEnvfv; - glGetTexEnviv: TglGetTexEnviv; - glGetTexGendv: TglGetTexGendv; - glGetTexGenfv: TglGetTexGenfv; - glGetTexGeniv: TglGetTexGeniv; - glIndexMask: TglIndexMask; - glIndexPointer: TglIndexPointer; - glIndexd: TglIndexd; - glIndexdv: TglIndexdv; - glIndexf: TglIndexf; - glIndexfv: TglIndexfv; - glIndexi: TglIndexi; - glIndexiv: TglIndexiv; - glIndexs: TglIndexs; - glIndexsv: TglIndexsv; - glIndexub: TglIndexub; - glIndexubv: TglIndexubv; - glInitNames: TglInitNames; - glInterleavedArrays: TglInterleavedArrays; - glIsList: TglIsList; - glIsTexture: TglIsTexture; - glLightModelf: TglLightModelf; - glLightModelfv: TglLightModelfv; - glLightModeli: TglLightModeli; - glLightModeliv: TglLightModeliv; - glLightf: TglLightf; - glLightfv: TglLightfv; - glLighti: TglLighti; - glLightiv: TglLightiv; - glLineStipple: TglLineStipple; - glListBase: TglListBase; - glLoadIdentity: TglLoadIdentity; - glLoadMatrixd: TglLoadMatrixd; - glLoadMatrixf: TglLoadMatrixf; - glLoadName: TglLoadName; - glMap1d: TglMap1d; - glMap1f: TglMap1f; - glMap2d: TglMap2d; - glMap2f: TglMap2f; - glMapGrid1d: TglMapGrid1d; - glMapGrid1f: TglMapGrid1f; - glMapGrid2d: TglMapGrid2d; - glMapGrid2f: TglMapGrid2f; - glMaterialf: TglMaterialf; - glMaterialfv: TglMaterialfv; - glMateriali: TglMateriali; - glMaterialiv: TglMaterialiv; - glMatrixMode: TglMatrixMode; - glMultMatrixd: TglMultMatrixd; - glMultMatrixf: TglMultMatrixf; - glNewList: TglNewList; - glNormal3b: TglNormal3b; - glNormal3bv: TglNormal3bv; - glNormal3d: TglNormal3d; - glNormal3dv: TglNormal3dv; - glNormal3f: TglNormal3f; - glNormal3fv: TglNormal3fv; - glNormal3i: TglNormal3i; - glNormal3iv: TglNormal3iv; - glNormal3s: TglNormal3s; - glNormal3sv: TglNormal3sv; - glNormalPointer: TglNormalPointer; - glOrtho: TglOrtho; - glPassThrough: TglPassThrough; - glPixelMapfv: TglPixelMapfv; - glPixelMapuiv: TglPixelMapuiv; - glPixelMapusv: TglPixelMapusv; - glPixelTransferf: TglPixelTransferf; - glPixelTransferi: TglPixelTransferi; - glPixelZoom: TglPixelZoom; - glPolygonStipple: TglPolygonStipple; - glPopAttrib: TglPopAttrib; - glPopClientAttrib: TglPopClientAttrib; - glPopMatrix: TglPopMatrix; - glPopName: TglPopName; - glPrioritizeTextures: TglPrioritizeTextures; - glPushAttrib: TglPushAttrib; - glPushClientAttrib: TglPushClientAttrib; - glPushMatrix: TglPushMatrix; - glPushName: TglPushName; - glRasterPos2d: TglRasterPos2d; - glRasterPos2dv: TglRasterPos2dv; - glRasterPos2f: TglRasterPos2f; - glRasterPos2fv: TglRasterPos2fv; - glRasterPos2i: TglRasterPos2i; - glRasterPos2iv: TglRasterPos2iv; - glRasterPos2s: TglRasterPos2s; - glRasterPos2sv: TglRasterPos2sv; - glRasterPos3d: TglRasterPos3d; - glRasterPos3dv: TglRasterPos3dv; - glRasterPos3f: TglRasterPos3f; - glRasterPos3fv: TglRasterPos3fv; - glRasterPos3i: TglRasterPos3i; - glRasterPos3iv: TglRasterPos3iv; - glRasterPos3s: TglRasterPos3s; - glRasterPos3sv: TglRasterPos3sv; - glRasterPos4d: TglRasterPos4d; - glRasterPos4dv: TglRasterPos4dv; - glRasterPos4f: TglRasterPos4f; - glRasterPos4fv: TglRasterPos4fv; - glRasterPos4i: TglRasterPos4i; - glRasterPos4iv: TglRasterPos4iv; - glRasterPos4s: TglRasterPos4s; - glRasterPos4sv: TglRasterPos4sv; - glRectd: TglRectd; - glRectdv: TglRectdv; - glRectf: TglRectf; - glRectfv: TglRectfv; - glRecti: TglRecti; - glRectiv: TglRectiv; - glRects: TglRects; - glRectsv: TglRectsv; - glRenderMode: TglRenderMode; - glRotated: TglRotated; - glRotatef: TglRotatef; - glScaled: TglScaled; - glScalef: TglScalef; - glSelectBuffer: TglSelectBuffer; - glShadeModel: TglShadeModel; - glTexCoord1d: TglTexCoord1d; - glTexCoord1dv: TglTexCoord1dv; - glTexCoord1f: TglTexCoord1f; - glTexCoord1fv: TglTexCoord1fv; - glTexCoord1i: TglTexCoord1i; - glTexCoord1iv: TglTexCoord1iv; - glTexCoord1s: TglTexCoord1s; - glTexCoord1sv: TglTexCoord1sv; - glTexCoord2d: TglTexCoord2d; - glTexCoord2dv: TglTexCoord2dv; - glTexCoord2f: TglTexCoord2f; - glTexCoord2fv: TglTexCoord2fv; - glTexCoord2i: TglTexCoord2i; - glTexCoord2iv: TglTexCoord2iv; - glTexCoord2s: TglTexCoord2s; - glTexCoord2sv: TglTexCoord2sv; - glTexCoord3d: TglTexCoord3d; - glTexCoord3dv: TglTexCoord3dv; - glTexCoord3f: TglTexCoord3f; - glTexCoord3fv: TglTexCoord3fv; - glTexCoord3i: TglTexCoord3i; - glTexCoord3iv: TglTexCoord3iv; - glTexCoord3s: TglTexCoord3s; - glTexCoord3sv: TglTexCoord3sv; - glTexCoord4d: TglTexCoord4d; - glTexCoord4dv: TglTexCoord4dv; - glTexCoord4f: TglTexCoord4f; - glTexCoord4fv: TglTexCoord4fv; - glTexCoord4i: TglTexCoord4i; - glTexCoord4iv: TglTexCoord4iv; - glTexCoord4s: TglTexCoord4s; - glTexCoord4sv: TglTexCoord4sv; - glTexCoordPointer: TglTexCoordPointer; - glTexEnvf: TglTexEnvf; - glTexEnvfv: TglTexEnvfv; - glTexEnvi: TglTexEnvi; - glTexEnviv: TglTexEnviv; - glTexGend: TglTexGend; - glTexGendv: TglTexGendv; - glTexGenf: TglTexGenf; - glTexGenfv: TglTexGenfv; - glTexGeni: TglTexGeni; - glTexGeniv: TglTexGeniv; - glTranslated: TglTranslated; - glTranslatef: TglTranslatef; - glVertex2d: TglVertex2d; - glVertex2dv: TglVertex2dv; - glVertex2f: TglVertex2f; - glVertex2fv: TglVertex2fv; - glVertex2i: TglVertex2i; - glVertex2iv: TglVertex2iv; - glVertex2s: TglVertex2s; - glVertex2sv: TglVertex2sv; - glVertex3d: TglVertex3d; - glVertex3dv: TglVertex3dv; - glVertex3f: TglVertex3f; - glVertex3fv: TglVertex3fv; - glVertex3i: TglVertex3i; - glVertex3iv: TglVertex3iv; - glVertex3s: TglVertex3s; - glVertex3sv: TglVertex3sv; - glVertex4d: TglVertex4d; - glVertex4dv: TglVertex4dv; - glVertex4f: TglVertex4f; - glVertex4fv: TglVertex4fv; - glVertex4i: TglVertex4i; - glVertex4iv: TglVertex4iv; - glVertex4s: TglVertex4s; - glVertex4sv: TglVertex4sv; - glVertexPointer: TglVertexPointer; -{$endif} - - // GL_VERSION_1_2 - glBlendColor: TglBlendColor; - glBlendEquation: TglBlendEquation; - glDrawRangeElements: TglDrawRangeElements; - glTexImage3D: TglTexImage3D; - glTexSubImage3D: TglTexSubImage3D; - glCopyTexSubImage3D: TglCopyTexSubImage3D; -{$ifdef DGL_DEPRECATED} - glColorTable: TglColorTable; - glColorTableParameterfv: TglColorTableParameterfv; - glColorTableParameteriv: TglColorTableParameteriv; - glCopyColorTable: TglCopyColorTable; - glGetColorTable: TglGetColorTable; - glGetColorTableParameterfv: TglGetColorTableParameterfv; - glGetColorTableParameteriv: TglGetColorTableParameteriv; - glColorSubTable: TglColorSubTable; - glCopyColorSubTable: TglCopyColorSubTable; - glConvolutionFilter1D: TglConvolutionFilter1D; - glConvolutionFilter2D: TglConvolutionFilter2D; - glConvolutionParameterf: TglConvolutionParameterf; - glConvolutionParameterfv: TglConvolutionParameterfv; - glConvolutionParameteri: TglConvolutionParameteri; - glConvolutionParameteriv: TglConvolutionParameteriv; - glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D; - glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D; - glGetConvolutionFilter: TglGetConvolutionFilter; - glGetConvolutionParameterfv: TglGetConvolutionParameterfv; - glGetConvolutionParameteriv: TglGetConvolutionParameteriv; - glGetSeparableFilter: TglGetSeparableFilter; - glSeparableFilter2D: TglSeparableFilter2D; - glGetHistogram: TglGetHistogram; - glGetHistogramParameterfv: TglGetHistogramParameterfv; - glGetHistogramParameteriv: TglGetHistogramParameteriv; - glGetMinmax: TglGetMinmax; - glGetMinmaxParameterfv: TglGetMinmaxParameterfv; - glGetMinmaxParameteriv: TglGetMinmaxParameteriv; - glHistogram: TglHistogram; - glMinmax: TglMinmax; - glResetHistogram: TglResetHistogram; - glResetMinmax: TglResetMinmax; -{$endif} - - // GL_VERSION_1_3 - glActiveTexture: TglActiveTexture; - glSampleCoverage: TglSampleCoverage; - glCompressedTexImage3D: TglCompressedTexImage3D; - glCompressedTexImage2D: TglCompressedTexImage2D; - glCompressedTexImage1D: TglCompressedTexImage1D; - glCompressedTexSubImage3D: TglCompressedTexSubImage3D; - glCompressedTexSubImage2D: TglCompressedTexSubImage2D; - glCompressedTexSubImage1D: TglCompressedTexSubImage1D; - glGetCompressedTexImage: TglGetCompressedTexImage; -{$ifdef DGL_DEPRECATED} - glClientActiveTexture: TglClientActiveTexture; - glMultiTexCoord1d: TglMultiTexCoord1d; - glMultiTexCoord1dv: TglMultiTexCoord1dv; - glMultiTexCoord1f: TglMultiTexCoord1f; - glMultiTexCoord1fv: TglMultiTexCoord1fv; - glMultiTexCoord1i: TglMultiTexCoord1i; - glMultiTexCoord1iv: TglMultiTexCoord1iv; - glMultiTexCoord1s: TglMultiTexCoord1s; - glMultiTexCoord1sv: TglMultiTexCoord1sv; - glMultiTexCoord2d: TglMultiTexCoord2d; - glMultiTexCoord2dv: TglMultiTexCoord2dv; - glMultiTexCoord2f: TglMultiTexCoord2f; - glMultiTexCoord2fv: TglMultiTexCoord2fv; - glMultiTexCoord2i: TglMultiTexCoord2i; - glMultiTexCoord2iv: TglMultiTexCoord2iv; - glMultiTexCoord2s: TglMultiTexCoord2s; - glMultiTexCoord2sv: TglMultiTexCoord2sv; - glMultiTexCoord3d: TglMultiTexCoord3d; - glMultiTexCoord3dv: TglMultiTexCoord3dv; - glMultiTexCoord3f: TglMultiTexCoord3f; - glMultiTexCoord3fv: TglMultiTexCoord3fv; - glMultiTexCoord3i: TglMultiTexCoord3i; - glMultiTexCoord3iv: TglMultiTexCoord3iv; - glMultiTexCoord3s: TglMultiTexCoord3s; - glMultiTexCoord3sv: TglMultiTexCoord3sv; - glMultiTexCoord4d: TglMultiTexCoord4d; - glMultiTexCoord4dv: TglMultiTexCoord4dv; - glMultiTexCoord4f: TglMultiTexCoord4f; - glMultiTexCoord4fv: TglMultiTexCoord4fv; - glMultiTexCoord4i: TglMultiTexCoord4i; - glMultiTexCoord4iv: TglMultiTexCoord4iv; - glMultiTexCoord4s: TglMultiTexCoord4s; - glMultiTexCoord4sv: TglMultiTexCoord4sv; - glLoadTransposeMatrixf: TglLoadTransposeMatrixf; - glLoadTransposeMatrixd: TglLoadTransposeMatrixd; - glMultTransposeMatrixf: TglMultTransposeMatrixf; - glMultTransposeMatrixd: TglMultTransposeMatrixd; -{$endif} - - // GL_VERSION_1_4 - glBlendFuncSeparate: TglBlendFuncSeparate; - glMultiDrawArrays: TglMultiDrawArrays; - glMultiDrawElements: TglMultiDrawElements; - glPointParameterf: TglPointParameterf; - glPointParameterfv: TglPointParameterfv; - glPointParameteri: TglPointParameteri; - glPointParameteriv: TglPointParameteriv; -{$ifdef DGL_DEPRECATED} - glFogCoordf: TglFogCoordf; - glFogCoordfv: TglFogCoordfv; - glFogCoordd: TglFogCoordd; - glFogCoorddv: TglFogCoorddv; - glFogCoordPointer: TglFogCoordPointer; - glSecondaryColor3b: TglSecondaryColor3b; - glSecondaryColor3bv: TglSecondaryColor3bv; - glSecondaryColor3d: TglSecondaryColor3d; - glSecondaryColor3dv: TglSecondaryColor3dv; - glSecondaryColor3f: TglSecondaryColor3f; - glSecondaryColor3fv: TglSecondaryColor3fv; - glSecondaryColor3i: TglSecondaryColor3i; - glSecondaryColor3iv: TglSecondaryColor3iv; - glSecondaryColor3s: TglSecondaryColor3s; - glSecondaryColor3sv: TglSecondaryColor3sv; - glSecondaryColor3ub: TglSecondaryColor3ub; - glSecondaryColor3ubv: TglSecondaryColor3ubv; - glSecondaryColor3ui: TglSecondaryColor3ui; - glSecondaryColor3uiv: TglSecondaryColor3uiv; - glSecondaryColor3us: TglSecondaryColor3us; - glSecondaryColor3usv: TglSecondaryColor3usv; - glSecondaryColorPointer: TglSecondaryColorPointer; - glWindowPos2d: TglWindowPos2d; - glWindowPos2dv: TglWindowPos2dv; - glWindowPos2f: TglWindowPos2f; - glWindowPos2fv: TglWindowPos2fv; - glWindowPos2i: TglWindowPos2i; - glWindowPos2iv: TglWindowPos2iv; - glWindowPos2s: TglWindowPos2s; - glWindowPos2sv: TglWindowPos2sv; - glWindowPos3d: TglWindowPos3d; - glWindowPos3dv: TglWindowPos3dv; - glWindowPos3f: TglWindowPos3f; - glWindowPos3fv: TglWindowPos3fv; - glWindowPos3i: TglWindowPos3i; - glWindowPos3iv: TglWindowPos3iv; - glWindowPos3s: TglWindowPos3s; - glWindowPos3sv: TglWindowPos3sv; -{$endif} - - // GL_VERSION_1_5 - glGenQueries: TglGenQueries; - glDeleteQueries: TglDeleteQueries; - glIsQuery: TglIsQuery; - glBeginQuery: TglBeginQuery; - glEndQuery: TglEndQuery; - glGetQueryiv: TglGetQueryiv; - glGetQueryObjectiv: TglGetQueryObjectiv; - glGetQueryObjectuiv: TglGetQueryObjectuiv; - glBindBuffer: TglBindBuffer; - glDeleteBuffers: TglDeleteBuffers; - glGenBuffers: TglGenBuffers; - glIsBuffer: TglIsBuffer; - glBufferData: TglBufferData; - glBufferSubData: TglBufferSubData; - glGetBufferSubData: TglGetBufferSubData; - glMapBuffer: TglMapBuffer; - glUnmapBuffer: TglUnmapBuffer; - glGetBufferParameteriv: TglGetBufferParameteriv; - glGetBufferPointerv: TglGetBufferPointerv; - - // GL_VERSION_2_0 - glBlendEquationSeparate: TglBlendEquationSeparate; - glDrawBuffers: TglDrawBuffers; - glStencilOpSeparate: TglStencilOpSeparate; - glStencilFuncSeparate: TglStencilFuncSeparate; - glStencilMaskSeparate: TglStencilMaskSeparate; - glAttachShader: TglAttachShader; - glBindAttribLocation: TglBindAttribLocation; - glCompileShader: TglCompileShader; - glCreateProgram: TglCreateProgram; - glCreateShader: TglCreateShader; - glDeleteProgram: TglDeleteProgram; - glDeleteShader: TglDeleteShader; - glDetachShader: TglDetachShader; - glDisableVertexAttribArray: TglDisableVertexAttribArray; - glEnableVertexAttribArray: TglEnableVertexAttribArray; - glGetActiveAttrib: TglGetActiveAttrib; - glGetActiveUniform: TglGetActiveUniform; - glGetAttachedShaders: TglGetAttachedShaders; - glGetAttribLocation: TglGetAttribLocation; - glGetProgramiv: TglGetProgramiv; - glGetProgramInfoLog: TglGetProgramInfoLog; - glGetShaderiv: TglGetShaderiv; - glGetShaderInfoLog: TglGetShaderInfoLog; - glGetShaderSource: TglGetShaderSource; - glGetUniformLocation: TglGetUniformLocation; - glGetUniformfv: TglGetUniformfv; - glGetUniformiv: TglGetUniformiv; - glGetVertexAttribfv: TglGetVertexAttribfv; - glGetVertexAttribiv: TglGetVertexAttribiv; - glGetVertexAttribPointerv: TglGetVertexAttribPointerv; - glIsProgram: TglIsProgram; - glIsShader: TglIsShader; - glLinkProgram: TglLinkProgram; - glShaderSource: TglShaderSource; - glUseProgram: TglUseProgram; - glUniform1f: TglUniform1f; - glUniform2f: TglUniform2f; - glUniform3f: TglUniform3f; - glUniform4f: TglUniform4f; - glUniform1i: TglUniform1i; - glUniform2i: TglUniform2i; - glUniform3i: TglUniform3i; - glUniform4i: TglUniform4i; - glUniform1fv: TglUniform1fv; - glUniform2fv: TglUniform2fv; - glUniform3fv: TglUniform3fv; - glUniform4fv: TglUniform4fv; - glUniform1iv: TglUniform1iv; - glUniform2iv: TglUniform2iv; - glUniform3iv: TglUniform3iv; - glUniform4iv: TglUniform4iv; - glUniformMatrix2fv: TglUniformMatrix2fv; - glUniformMatrix3fv: TglUniformMatrix3fv; - glUniformMatrix4fv: TglUniformMatrix4fv; - glValidateProgram: TglValidateProgram; - glVertexAttrib1d: TglVertexAttrib1d; - glVertexAttrib1dv: TglVertexAttrib1dv; - glVertexAttrib1f: TglVertexAttrib1f; - glVertexAttrib1fv: TglVertexAttrib1fv; - glVertexAttrib1s: TglVertexAttrib1s; - glVertexAttrib1sv: TglVertexAttrib1sv; - glVertexAttrib2d: TglVertexAttrib2d; - glVertexAttrib2dv: TglVertexAttrib2dv; - glVertexAttrib2f: TglVertexAttrib2f; - glVertexAttrib2fv: TglVertexAttrib2fv; - glVertexAttrib2s: TglVertexAttrib2s; - glVertexAttrib2sv: TglVertexAttrib2sv; - glVertexAttrib3d: TglVertexAttrib3d; - glVertexAttrib3dv: TglVertexAttrib3dv; - glVertexAttrib3f: TglVertexAttrib3f; - glVertexAttrib3fv: TglVertexAttrib3fv; - glVertexAttrib3s: TglVertexAttrib3s; - glVertexAttrib3sv: TglVertexAttrib3sv; - glVertexAttrib4Nbv: TglVertexAttrib4Nbv; - glVertexAttrib4Niv: TglVertexAttrib4Niv; - glVertexAttrib4Nsv: TglVertexAttrib4Nsv; - glVertexAttrib4Nub: TglVertexAttrib4Nub; - glVertexAttrib4Nubv: TglVertexAttrib4Nubv; - glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv; - glVertexAttrib4Nusv: TglVertexAttrib4Nusv; - glVertexAttrib4bv: TglVertexAttrib4bv; - glVertexAttrib4d: TglVertexAttrib4d; - glVertexAttrib4dv: TglVertexAttrib4dv; - glVertexAttrib4f: TglVertexAttrib4f; - glVertexAttrib4fv: TglVertexAttrib4fv; - glVertexAttrib4iv: TglVertexAttrib4iv; - glVertexAttrib4s: TglVertexAttrib4s; - glVertexAttrib4sv: TglVertexAttrib4sv; - glVertexAttrib4ubv: TglVertexAttrib4ubv; - glVertexAttrib4uiv: TglVertexAttrib4uiv; - glVertexAttrib4usv: TglVertexAttrib4usv; - glVertexAttribPointer: TglVertexAttribPointer; - - // GL_VERSION_2_1 - glUniformMatrix2x3fv: TglUniformMatrix2x3fv; - glUniformMatrix3x2fv: TglUniformMatrix3x2fv; - glUniformMatrix2x4fv: TglUniformMatrix2x4fv; - glUniformMatrix4x2fv: TglUniformMatrix4x2fv; - glUniformMatrix3x4fv: TglUniformMatrix3x4fv; - glUniformMatrix4x3fv: TglUniformMatrix4x3fv; - - // GL_VERSION_3_0 - glColorMaski: TglColorMaski; - glGetBooleani_v: TglGetBooleani_v; - glGetIntegeri_v: TglGetIntegeri_v; - glEnablei: TglEnablei; - glDisablei: TglDisablei; - glIsEnabledi: TglIsEnabledi; - glBeginTransformFeedback: TglBeginTransformFeedback; - glEndTransformFeedback: TglEndTransformFeedback; - glBindBufferRange: TglBindBufferRange; - glBindBufferBase: TglBindBufferBase; - glTransformFeedbackVaryings: TglTransformFeedbackVaryings; - glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying; - glClampColor: TglClampColor; - glBeginConditionalRender: TglBeginConditionalRender; - glEndConditionalRender: TglEndConditionalRender; - glVertexAttribI1i: TglVertexAttribI1i; - glVertexAttribI2i: TglVertexAttribI2i; - glVertexAttribI3i: TglVertexAttribI3i; - glVertexAttribI4i: TglVertexAttribI4i; - glVertexAttribI1ui: TglVertexAttribI1ui; - glVertexAttribI2ui: TglVertexAttribI2ui; - glVertexAttribI3ui: TglVertexAttribI3ui; - glVertexAttribI4ui: TglVertexAttribI4ui; - glVertexAttribI1iv: TglVertexAttribI1iv; - glVertexAttribI2iv: TglVertexAttribI2iv; - glVertexAttribI3iv: TglVertexAttribI3iv; - glVertexAttribI4iv: TglVertexAttribI4iv; - glVertexAttribI1uiv: TglVertexAttribI1uiv; - glVertexAttribI2uiv: TglVertexAttribI2uiv; - glVertexAttribI3uiv: TglVertexAttribI3uiv; - glVertexAttribI4uiv: TglVertexAttribI4uiv; - glVertexAttribI4bv: TglVertexAttribI4bv; - glVertexAttribI4sv: TglVertexAttribI4sv; - glVertexAttribI4ubv: TglVertexAttribI4ubv; - glVertexAttribI4usv: TglVertexAttribI4usv; - glVertexAttribIPointer: TglVertexAttribIPointer; - glGetVertexAttribIiv: TglGetVertexAttribIiv; - glGetVertexAttribIuiv: TglGetVertexAttribIuiv; - glGetUniformuiv: TglGetUniformuiv; - glBindFragDataLocation: TglBindFragDataLocation; - glGetFragDataLocation: TglGetFragDataLocation; - glUniform1ui: TglUniform1ui; - glUniform2ui: TglUniform2ui; - glUniform3ui: TglUniform3ui; - glUniform4ui: TglUniform4ui; - glUniform1uiv: TglUniform1uiv; - glUniform2uiv: TglUniform2uiv; - glUniform3uiv: TglUniform3uiv; - glUniform4uiv: TglUniform4uiv; - glTexParameterIiv: TglTexParameterIiv; - glTexParameterIuiv: TglTexParameterIuiv; - glGetTexParameterIiv: TglGetTexParameterIiv; - glGetTexParameterIuiv: TglGetTexParameterIuiv; - glClearBufferiv: TglClearBufferiv; - glClearBufferuiv: TglClearBufferuiv; - glClearBufferfv: TglClearBufferfv; - glClearBufferfi: TglClearBufferfi; - glGetStringi: TglGetStringi; - - // GL_VERSION_2_1 - glEnableVertexArrayEXT : TglEnableVertexArrayEXT; - glEnableVertexArrayAttribEXT : TglEnableVertexArrayAttribEXT; - glVertexArrayVertexAttribOffsetEXT : TglVertexArrayVertexAttribOffsetEXT; - - // GL_VERSION_3_1 - glDrawArraysInstanced: TglDrawArraysInstanced; - glDrawElementsInstanced: TglDrawElementsInstanced; - glTexBuffer: TglTexBuffer; - glPrimitiveRestartIndex: TglPrimitiveRestartIndex; - - // GL_VERSION_3_2 - glGetInteger64i_v: TglGetInteger64i_v; - glGetBufferParameteri64v: TglGetBufferParameteri64v; - glFramebufferTexture: TglFramebufferTexture; - - // GL_VERSION_3_3 - glVertexAttribDivisor: TglVertexAttribDivisor; - - // GL_VERSION_4_0 - { OpenGL 4.0 also reuses entry points from these extensions: } - { ARB_texture_query_lod (no entry points) } - { ARB_draw_indirect } - { ARB_gpu_shader5 (no entry points) } - { ARB_gpu_shader_fp64 } - { ARB_shader_subroutine } - { ARB_tessellation_shader } - { ARB_texture_buffer_object_rgb32 (no entry points) } - { ARB_texture_cube_map_array (no entry points) } - { ARB_texture_gather (no entry points) } - { ARB_transform_feedback2 } - { ARB_transform_feedback3 } - glMinSampleShading: TglMinSampleShading; - glBlendEquationi: TglBlendEquationi; - glBlendEquationSeparatei: TglBlendEquationSeparatei; - glBlendFunci: TglBlendFunci; - glBlendFuncSeparatei: TglBlendFuncSeparatei; - - // GL_3DFX_tbuffer - glTbufferMask3DFX: TglTbufferMask3DFX; - - // GL_APPLE_element_array - glElementPointerAPPLE: TglElementPointerAPPLE; - glDrawElementArrayAPPLE: TglDrawElementArrayAPPLE; - glDrawRangeElementArrayAPPLE: TglDrawRangeElementArrayAPPLE; - glMultiDrawElementArrayAPPLE: TglMultiDrawElementArrayAPPLE; - glMultiDrawRangeElementArrayAPPLE: TglMultiDrawRangeElementArrayAPPLE; - - // GL_APPLE_fence - glGenFencesAPPLE: TglGenFencesAPPLE; - glDeleteFencesAPPLE: TglDeleteFencesAPPLE; - glSetFenceAPPLE: TglSetFenceAPPLE; - glIsFenceAPPLE: TglIsFenceAPPLE; - glTestFenceAPPLE: TglTestFenceAPPLE; - glFinishFenceAPPLE: TglFinishFenceAPPLE; - glTestObjectAPPLE: TglTestObjectAPPLE; - glFinishObjectAPPLE: TglFinishObjectAPPLE; - - // GL_APPLE_vertex_array_object - glBindVertexArrayAPPLE: TglBindVertexArrayAPPLE; - glDeleteVertexArraysAPPLE: TglDeleteVertexArraysAPPLE; - glGenVertexArraysAPPLE: TglGenVertexArraysAPPLE; - glIsVertexArrayAPPLE: TglIsVertexArrayAPPLE; - - // GL_APPLE_vertex_array_range - glVertexArrayRangeAPPLE: TglVertexArrayRangeAPPLE; - glFlushVertexArrayRangeAPPLE: TglFlushVertexArrayRangeAPPLE; - glVertexArrayParameteriAPPLE: TglVertexArrayParameteriAPPLE; - - // GL_APPLE_texture_range - glTextureRangeAPPLE: TglTextureRangeAPPLE; - glGetTexParameterPointervAPPLE: TglGetTexParameterPointervAPPLE; - - // GL_APPLE_vertex_program_evaluators - glEnableVertexAttribAPPLE: TglEnableVertexAttribAPPLE; - glDisableVertexAttribAPPLE: TglDisableVertexAttribAPPLE; - glIsVertexAttribEnabledAPPLE: TglIsVertexAttribEnabledAPPLE; - glMapVertexAttrib1dAPPLE: TglMapVertexAttrib1dAPPLE; - glMapVertexAttrib1fAPPLE: TglMapVertexAttrib1fAPPLE; - glMapVertexAttrib2dAPPLE: TglMapVertexAttrib2dAPPLE; - glMapVertexAttrib2fAPPLE: TglMapVertexAttrib2fAPPLE; - - // GL_APPLE_object_purgeable - glObjectPurgeableAPPLE: TglObjectPurgeableAPPLE; - glObjectUnpurgeableAPPLE: TglObjectUnpurgeableAPPLE; - glGetObjectParameterivAPPLE: TglGetObjectParameterivAPPLE; - - // GL_ARB_matrix_palette - glCurrentPaletteMatrixARB: TglCurrentPaletteMatrixARB; - glMatrixIndexubvARB: TglMatrixIndexubvARB; - glMatrixIndexusvARB: TglMatrixIndexusvARB; - glMatrixIndexuivARB: TglMatrixIndexuivARB; - glMatrixIndexPointerARB: TglMatrixIndexPointerARB; - - // GL_ARB_multisample - glSampleCoverageARB: TglSampleCoverageARB; - - // GL_ARB_multitexture - glActiveTextureARB: TglActiveTextureARB; - glClientActiveTextureARB: TglClientActiveTextureARB; - glMultiTexCoord1dARB: TglMultiTexCoord1dARB; - glMultiTexCoord1dvARB: TglMultiTexCoord1dvARB; - glMultiTexCoord1fARB: TglMultiTexCoord1fARB; - glMultiTexCoord1fvARB: TglMultiTexCoord1fvARB; - glMultiTexCoord1iARB: TglMultiTexCoord1iARB; - glMultiTexCoord1ivARB: TglMultiTexCoord1ivARB; - glMultiTexCoord1sARB: TglMultiTexCoord1sARB; - glMultiTexCoord1svARB: TglMultiTexCoord1svARB; - glMultiTexCoord2dARB: TglMultiTexCoord2dARB; - glMultiTexCoord2dvARB: TglMultiTexCoord2dvARB; - glMultiTexCoord2fARB: TglMultiTexCoord2fARB; - glMultiTexCoord2fvARB: TglMultiTexCoord2fvARB; - glMultiTexCoord2iARB: TglMultiTexCoord2iARB; - glMultiTexCoord2ivARB: TglMultiTexCoord2ivARB; - glMultiTexCoord2sARB: TglMultiTexCoord2sARB; - glMultiTexCoord2svARB: TglMultiTexCoord2svARB; - glMultiTexCoord3dARB: TglMultiTexCoord3dARB; - glMultiTexCoord3dvARB: TglMultiTexCoord3dvARB; - glMultiTexCoord3fARB: TglMultiTexCoord3fARB; - glMultiTexCoord3fvARB: TglMultiTexCoord3fvARB; - glMultiTexCoord3iARB: TglMultiTexCoord3iARB; - glMultiTexCoord3ivARB: TglMultiTexCoord3ivARB; - glMultiTexCoord3sARB: TglMultiTexCoord3sARB; - glMultiTexCoord3svARB: TglMultiTexCoord3svARB; - glMultiTexCoord4dARB: TglMultiTexCoord4dARB; - glMultiTexCoord4dvARB: TglMultiTexCoord4dvARB; - glMultiTexCoord4fARB: TglMultiTexCoord4fARB; - glMultiTexCoord4fvARB: TglMultiTexCoord4fvARB; - glMultiTexCoord4iARB: TglMultiTexCoord4iARB; - glMultiTexCoord4ivARB: TglMultiTexCoord4ivARB; - glMultiTexCoord4sARB: TglMultiTexCoord4sARB; - glMultiTexCoord4svARB: TglMultiTexCoord4svARB; - - // GL_ARB_point_parameters - glPointParameterfARB: TglPointParameterfARB; - glPointParameterfvARB: TglPointParameterfvARB; - - // GL_ARB_texture_compression - glCompressedTexImage3DARB: TglCompressedTexImage3DARB; - glCompressedTexImage2DARB: TglCompressedTexImage2DARB; - glCompressedTexImage1DARB: TglCompressedTexImage1DARB; - glCompressedTexSubImage3DARB: TglCompressedTexSubImage3DARB; - glCompressedTexSubImage2DARB: TglCompressedTexSubImage2DARB; - glCompressedTexSubImage1DARB: TglCompressedTexSubImage1DARB; - glGetCompressedTexImageARB: TglGetCompressedTexImageARB; - - // GL_ARB_transpose_matrix - glLoadTransposeMatrixfARB: TglLoadTransposeMatrixfARB; - glLoadTransposeMatrixdARB: TglLoadTransposeMatrixdARB; - glMultTransposeMatrixfARB: TglMultTransposeMatrixfARB; - glMultTransposeMatrixdARB: TglMultTransposeMatrixdARB; - - // GL_ARB_vertex_blend - glWeightbvARB: TglWeightbvARB; - glWeightsvARB: TglWeightsvARB; - glWeightivARB: TglWeightivARB; - glWeightfvARB: TglWeightfvARB; - glWeightdvARB: TglWeightdvARB; - glWeightubvARB: TglWeightubvARB; - glWeightusvARB: TglWeightusvARB; - glWeightuivARB: TglWeightuivARB; - glWeightPointerARB: TglWeightPointerARB; - glVertexBlendARB: TglVertexBlendARB; - - // GL_ARB_vertex_buffer_object - glBindBufferARB: TglBindBufferARB; - glDeleteBuffersARB: TglDeleteBuffersARB; - glGenBuffersARB: TglGenBuffersARB; - glIsBufferARB: TglIsBufferARB; - glBufferDataARB: TglBufferDataARB; - glBufferSubDataARB: TglBufferSubData; - glGetBufferSubDataARB: TglGetBufferSubDataARB; - glMapBufferARB: TglMapBufferARB; - glUnmapBufferARB: TglUnmapBufferARB; - glGetBufferParameterivARB: TglGetBufferParameterivARB; - glGetBufferPointervARB: TglGetBufferPointervARB; - - // GL_ARB_vertex_program - glVertexAttrib1dARB: TglVertexAttrib1dARB; - glVertexAttrib1dvARB: TglVertexAttrib1dvARB; - glVertexAttrib1fARB: TglVertexAttrib1fARB; - glVertexAttrib1fvARB: TglVertexAttrib1fvARB; - glVertexAttrib1sARB: TglVertexAttrib1sARB; - glVertexAttrib1svARB: TglVertexAttrib1svARB; - glVertexAttrib2dARB: TglVertexAttrib2dARB; - glVertexAttrib2dvARB: TglVertexAttrib2dvARB; - glVertexAttrib2fARB: TglVertexAttrib2fARB; - glVertexAttrib2fvARB: TglVertexAttrib2fvARB; - glVertexAttrib2sARB: TglVertexAttrib2sARB; - glVertexAttrib2svARB: TglVertexAttrib2svARB; - glVertexAttrib3dARB: TglVertexAttrib3dARB; - glVertexAttrib3dvARB: TglVertexAttrib3dvARB; - glVertexAttrib3fARB: TglVertexAttrib3fARB; - glVertexAttrib3fvARB: TglVertexAttrib3fvARB; - glVertexAttrib3sARB: TglVertexAttrib3sARB; - glVertexAttrib3svARB: TglVertexAttrib3svARB; - glVertexAttrib4NbvARB: TglVertexAttrib4NbvARB; - glVertexAttrib4NivARB: TglVertexAttrib4NivARB; - glVertexAttrib4NsvARB: TglVertexAttrib4NsvARB; - glVertexAttrib4NubARB: TglVertexAttrib4NubARB; - glVertexAttrib4NubvARB: TglVertexAttrib4NubvARB; - glVertexAttrib4NuivARB: TglVertexAttrib4NuivARB; - glVertexAttrib4NusvARB: TglVertexAttrib4NusvARB; - glVertexAttrib4bvARB: TglVertexAttrib4bvARB; - glVertexAttrib4dARB: TglVertexAttrib4dARB; - glVertexAttrib4dvARB: TglVertexAttrib4dvARB; - glVertexAttrib4fARB: TglVertexAttrib4fARB; - glVertexAttrib4fvARB: TglVertexAttrib4fvARB; - glVertexAttrib4ivARB: TglVertexAttrib4ivARB; - glVertexAttrib4sARB: TglVertexAttrib4sARB; - glVertexAttrib4svARB: TglVertexAttrib4svARB; - glVertexAttrib4ubvARB: TglVertexAttrib4ubvARB; - glVertexAttrib4uivARB: TglVertexAttrib4uivARB; - glVertexAttrib4usvARB: TglVertexAttrib4usvARB; - glVertexAttribPointerARB: TglVertexAttribPointerARB; - glEnableVertexAttribArrayARB: TglEnableVertexAttribArrayARB; - glDisableVertexAttribArrayARB: TglDisableVertexAttribArrayARB; - glProgramStringARB: TglProgramStringARB; - glBindProgramARB: TglBindProgramARB; - glDeleteProgramsARB: TglDeleteProgramsARB; - glGenProgramsARB: TglGenProgramsARB; - - glProgramEnvParameter4dARB: TglProgramEnvParameter4dARB; - glProgramEnvParameter4dvARB: TglProgramEnvParameter4dvARB; - glProgramEnvParameter4fARB: TglProgramEnvParameter4fARB; - glProgramEnvParameter4fvARB: TglProgramEnvParameter4fvARB; - glProgramLocalParameter4dARB: TglProgramLocalParameter4dARB; - glProgramLocalParameter4dvARB: TglProgramLocalParameter4dvARB; - glProgramLocalParameter4fARB: TglProgramLocalParameter4fARB; - glProgramLocalParameter4fvARB: TglProgramLocalParameter4fvARB; - glGetProgramEnvParameterdvARB: TglGetProgramEnvParameterdvARB; - glGetProgramEnvParameterfvARB: TglGetProgramEnvParameterfvARB; - glGetProgramLocalParameterdvARB: TglGetProgramLocalParameterdvARB; - glGetProgramLocalParameterfvARB: TglGetProgramLocalParameterfvARB; - glGetProgramivARB: TglGetProgramivARB; - glGetProgramStringARB: TglGetProgramStringARB; - glGetVertexAttribdvARB: TglGetVertexAttribdvARB; - glGetVertexAttribfvARB: TglGetVertexAttribfvARB; - glGetVertexAttribivARB: TglGetVertexAttribivARB; - glGetVertexAttribPointervARB: TglGetVertexAttribPointervARB; - glIsProgramARB: TglIsProgramARB; - - // GL_ARB_window_pos - glWindowPos2dARB: TglWindowPos2dARB; - glWindowPos2dvARB: TglWindowPos2dvARB; - glWindowPos2fARB: TglWindowPos2fARB; - glWindowPos2fvARB: TglWindowPos2fvARB; - glWindowPos2iARB: TglWindowPos2iARB; - glWindowPos2ivARB: TglWindowPos2ivARB; - glWindowPos2sARB: TglWindowPos2sARB; - glWindowPos2svARB: TglWindowPos2svARB; - glWindowPos3dARB: TglWindowPos3dARB; - glWindowPos3dvARB: TglWindowPos3dvARB; - glWindowPos3fARB: TglWindowPos3fARB; - glWindowPos3fvARB: TglWindowPos3fvARB; - glWindowPos3iARB: TglWindowPos3iARB; - glWindowPos3ivARB: TglWindowPos3ivARB; - glWindowPos3sARB: TglWindowPos3sARB; - glWindowPos3svARB: TglWindowPos3svARB; - - // GL_ARB_draw_buffers - glDrawBuffersARB: TglDrawBuffersARB; - - // GL_ARB_color_buffer_float - glClampColorARB: TglClampColorARB; - - // GL_ARB_vertex_shader - glGetActiveAttribARB: TglGetActiveAttribARB; - glGetAttribLocationARB: TglGetAttribLocationARB; - glBindAttribLocationARB: TglBindAttribLocationARB; - - // GL_ARB_shader_objects - glDeleteObjectARB: TglDeleteObjectARB; - glGetHandleARB: TglGetHandleARB; - glDetachObjectARB: TglDetachObjectARB; - glCreateShaderObjectARB: TglCreateShaderObjectARB; - glShaderSourceARB: TglShaderSourceARB; - glCompileShaderARB: TglCompileShaderARB; - glCreateProgramObjectARB: TglCreateProgramObjectARB; - glAttachObjectARB: TglAttachObjectARB; - glLinkProgramARB: TglLinkProgramARB; - glUseProgramObjectARB: TglUseProgramObjectARB; - glValidateProgramARB: TglValidateProgramARB; - glUniform1fARB: TglUniform1fARB; - glUniform2fARB: TglUniform2fARB; - glUniform3fARB: TglUniform3fARB; - glUniform4fARB: TglUniform4fARB; - glUniform1iARB: TglUniform1iARB; - glUniform2iARB: TglUniform2iARB; - glUniform3iARB: TglUniform3iARB; - glUniform4iARB: TglUniform4iARB; - glUniform1fvARB: TglUniform1fvARB; - glUniform2fvARB: TglUniform2fvARB; - glUniform3fvARB: TglUniform3fvARB; - glUniform4fvARB: TglUniform4fvARB; - glUniform1ivARB: TglUniform1ivARB; - glUniform2ivARB: TglUniform2ivARB; - glUniform3ivARB: TglUniform3ivARB; - glUniform4ivARB: TglUniform4ivARB; - glUniformMatrix2fvARB: TglUniformMatrix2fvARB; - glUniformMatrix3fvARB: TglUniformMatrix3fvARB; - glUniformMatrix4fvARB: TglUniformMatrix4fvARB; - glGetObjectParameterfvARB: TglGetObjectParameterfvARB; - glGetObjectParameterivARB: TglGetObjectParameterivARB; - glGetInfoLogARB: TglGetInfoLogARB; - glGetAttachedObjectsARB: TglGetAttachedObjectsARB; - glGetUniformLocationARB: TglGetUniformLocationARB; - glGetActiveUniformARB: TglGetActiveUniformARB; - glGetUniformfvARB: TglGetUniformfvARB; - glGetUniformivARB: TglGetUniformivARB; - glGetShaderSourceARB: TglGetShaderSourceARB; - - // GL_ARB_Occlusion_Query - glGenQueriesARB: TglGenQueriesARB; - glDeleteQueriesARB: TglDeleteQueriesARB; - glIsQueryARB: TglIsQueryARB; - glBeginQueryARB: TglBeginQueryARB; - glEndQueryARB: TglEndQueryARB; - glGetQueryivARB: TglGetQueryivARB; - glGetQueryObjectivARB: TglGetQueryObjectivARB; - glGetQueryObjectuivARB: TglGetQueryObjectuivARB; - - // GL_ARB_draw_instanced - glDrawArraysInstancedARB: TglDrawArraysInstancedARB; - glDrawElementsInstancedARB: TglDrawElementsInstancedARB; - - // GL_ARB_framebuffer_object - glIsRenderbuffer: TglIsRenderbuffer; - glBindRenderbuffer: TglBindRenderbuffer; - glDeleteRenderbuffers: TglDeleteRenderbuffers; - glGenRenderbuffers: TglGenRenderbuffers; - glRenderbufferStorage: TglRenderbufferStorage; - glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv; - glIsFramebuffer: TglIsFramebuffer; - glBindFramebuffer: TglBindFramebuffer; - glDeleteFramebuffers: TglDeleteFramebuffers; - glGenFramebuffers: TglGenFramebuffers; - glCheckFramebufferStatus: TglCheckFramebufferStatus; - glFramebufferTexture1D: TglFramebufferTexture1D; - glFramebufferTexture2D: TglFramebufferTexture2D; - glFramebufferTexture3D: TglFramebufferTexture3D; - glFramebufferRenderbuffer: TglFramebufferRenderbuffer; - glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv; - glGenerateMipmap: TglGenerateMipmap; - glBlitFramebuffer: TglBlitFramebuffer; - glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample; - glFramebufferTextureLayer: TglFramebufferTextureLayer; - - // GL_ARB_geometry_shader4 - glProgramParameteriARB: TglProgramParameteriARB; - glFramebufferTextureARB: TglFramebufferTextureARB; - glFramebufferTextureLayerARB: TglFramebufferTextureLayerARB; - glFramebufferTextureFaceARB: TglFramebufferTextureFaceARB; - - // GL_ARB_instanced_arrays - glVertexAttribDivisorARB: TglVertexAttribDivisorARB; - - // GL_ARB_map_buffer_range - glMapBufferRange: TglMapBufferRange; - glFlushMappedBufferRange: TglFlushMappedBufferRange; - - // GL_ARB_texture_buffer_object - glTexBufferARB: TglTexBufferARB; - - // GL_ARB_vertex_array_object - glBindVertexArray: TglBindVertexArray; - glDeleteVertexArrays: TglDeleteVertexArrays; - glGenVertexArrays: TglGenVertexArrays; - glIsVertexArray: TglIsVertexArray; - - // GL_ARB_uniform_buffer_object - glGetUniformIndices: TglGetUniformIndices; - glGetActiveUniformsiv: TglGetActiveUniformsiv; - glGetActiveUniformName: TglGetActiveUniformName; - glGetUniformBlockIndex: TglGetUniformBlockIndex; - glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv; - glGetActiveUniformBlockName: TglGetActiveUniformBlockName; - glUniformBlockBinding: TglUniformBlockBinding; - - // GL_ARB_copy_buffer - glCopyBufferSubData: TglCopyBufferSubData; - - // GL_ARB_draw_elements_base_vertex - glDrawElementsBaseVertex: TglDrawElementsBaseVertex; - glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex; - glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex; - glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex; - - // GL_ARB_provoking_vertex - glProvokingVertex: TglProvokingVertex; - - // GL_ARB_sync - glFenceSync: TglFenceSync; - glIsSync: TglIsSync; - glDeleteSync: TglDeleteSync; - glClientWaitSync: TglClientWaitSync; - glWaitSync: TglWaitSync; - glGetInteger64v: TglGetInteger64v; - glGetSynciv: TglGetSynciv; - - // GL_ARB_texture_multisample - glTexImage2DMultisample: TglTexImage2DMultisample; - glTexImage3DMultisample: TglTexImage3DMultisample; - glGetMultisamplefv: TglGetMultisamplefv; - glSampleMaski: TglSampleMaski; - - // GL_ARB_draw_buffers_blend - glBlendEquationiARB: TglBlendEquationiARB; - glBlendEquationSeparateiARB: TglBlendEquationSeparateiARB; - glBlendFunciARB: TglBlendFunciARB; - glBlendFuncSeparateiARB: TglBlendFuncSeparateiARB; - - // GL_ARB_sample_shading - glMinSampleShadingARB: TglMinSampleShadingARB; - - // GL_ARB_shading_language_include - glNamedStringARB: TglNamedStringARB; - glDeleteNamedStringARB: TglDeleteNamedStringARB; - glCompileShaderIncludeARB: TglCompileShaderIncludeARB; - glIsNamedStringARB: TglIsNamedStringARB; - glGetNamedStringARB: TglGetNamedStringARB; - glGetNamedStringivARB: TglGetNamedStringivARB; - - // GL_ARB_blend_func_extended - glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed; - glGetFragDataIndex: TglGetFragDataIndex; - - // GL_ARB_sampler_objects - glGenSamplers: TglGenSamplers; - glDeleteSamplers: TglDeleteSamplers; - glIsSampler: TglIsSampler; - glBindSampler: TglBindSampler; - glSamplerParameteri: TglSamplerParameteri; - glSamplerParameteriv: TglSamplerParameteriv; - glSamplerParameterf: TglSamplerParameterf; - glSamplerParameterfv: TglSamplerParameterfv; - glSamplerParameterIiv: TglSamplerParameterIiv; - glSamplerParameterIuiv: TglSamplerParameterIuiv; - glGetSamplerParameteriv: TglGetSamplerParameteriv; - glGetSamplerParameterIiv: TglGetSamplerParameterIiv; - glGetSamplerParameterfv: TglGetSamplerParameterfv; - glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv; - - // GL_ARB_timer_query - glQueryCounter: TglQueryCounter; - glGetQueryObjecti64v: TglGetQueryObjecti64v; - glGetQueryObjectui64v: TglGetQueryObjectui64v; - - // GL_ARB_vertex_type_2_10_10_10_rev - glVertexP2ui: TglVertexP2ui; - glVertexP2uiv: TglVertexP2uiv; - glVertexP3ui: TglVertexP3ui; - glVertexP3uiv: TglVertexP3uiv; - glVertexP4ui: TglVertexP4ui; - glVertexP4uiv: TglVertexP4uiv; - glTexCoordP1ui: TglTexCoordP1ui; - glTexCoordP1uiv: TglTexCoordP1uiv; - glTexCoordP2ui: TglTexCoordP2ui; - glTexCoordP2uiv: TglTexCoordP2uiv; - glTexCoordP3ui: TglTexCoordP3ui; - glTexCoordP3uiv: TglTexCoordP3uiv; - glTexCoordP4ui: TglTexCoordP4ui; - glTexCoordP4uiv: TglTexCoordP4uiv; - glMultiTexCoordP1ui: TglMultiTexCoordP1ui; - glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv; - glMultiTexCoordP2ui: TglMultiTexCoordP2ui; - glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv; - glMultiTexCoordP3ui: TglMultiTexCoordP3ui; - glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv; - glMultiTexCoordP4ui: TglMultiTexCoordP4ui; - glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv; - glNormalP3ui: TglNormalP3ui; - glNormalP3uiv: TglNormalP3uiv; - glColorP3ui: TglColorP3ui; - glColorP3uiv: TglColorP3uiv; - glColorP4ui: TglColorP4ui; - glColorP4uiv: TglColorP4uiv; - glSecondaryColorP3ui: TglSecondaryColorP3ui; - glSecondaryColorP3uiv: TglSecondaryColorP3uiv; - glVertexAttribP1ui: TglVertexAttribP1ui; - glVertexAttribP1uiv: TglVertexAttribP1uiv; - glVertexAttribP2ui: TglVertexAttribP2ui; - glVertexAttribP2uiv: TglVertexAttribP2uiv; - glVertexAttribP3ui: TglVertexAttribP3ui; - glVertexAttribP3uiv: TglVertexAttribP3uiv; - glVertexAttribP4ui: TglVertexAttribP4ui; - glVertexAttribP4uiv: TglVertexAttribP4uiv; - - // GL_ARB_draw_indirect - glDrawArraysIndirect: TglDrawArraysIndirect; - glDrawElementsIndirect: TglDrawElementsIndirect; - - // GL_ARB_gpu_shader_fp64 - glUniform1d: TglUniform1d; - glUniform2d: TglUniform2d; - glUniform3d: TglUniform3d; - glUniform4d: TglUniform4d; - glUniform1dv: TglUniform1dv; - glUniform2dv: TglUniform2dv; - glUniform3dv: TglUniform3dv; - glUniform4dv: TglUniform4dv; - glUniformMatrix2dv: TglUniformMatrix2dv; - glUniformMatrix3dv: TglUniformMatrix3dv; - glUniformMatrix4dv: TglUniformMatrix4dv; - glUniformMatrix2x3dv: TglUniformMatrix2x3dv; - glUniformMatrix2x4dv: TglUniformMatrix2x4dv; - glUniformMatrix3x2dv: TglUniformMatrix3x2dv; - glUniformMatrix3x4dv: TglUniformMatrix3x4dv; - glUniformMatrix4x2dv: TglUniformMatrix4x2dv; - glUniformMatrix4x3dv: TglUniformMatrix4x3dv; - glGetUniformdv: TglGetUniformdv; - - // GL_ARB_shader_subroutine - glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation; - glGetSubroutineIndex: TglGetSubroutineIndex; - glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv; - glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName; - glGetActiveSubroutineName: TglGetActiveSubroutineName; - glUniformSubroutinesuiv: TglUniformSubroutinesuiv; - glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv; - glGetProgramStageiv: TglGetProgramStageiv; - - // GL_ARB_tessellation_shader - glPatchParameteri: TglPatchParameteri; - glPatchParameterfv: TglPatchParameterfv; - - // GL_ARB_transform_feedback2 - glBindTransformFeedback: TglBindTransformFeedback; - glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks; - glGenTransformFeedbacks: TglGenTransformFeedbacks; - glIsTransformFeedback: TglIsTransformFeedback; - glPauseTransformFeedback: TglPauseTransformFeedback; - glResumeTransformFeedback: TglResumeTransformFeedback; - glDrawTransformFeedback: TglDrawTransformFeedback; - - // GL_ARB_transform_feedback3 - glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream; - glBeginQueryIndexed: TglBeginQueryIndexed; - glEndQueryIndexed: TglEndQueryIndexed; - glGetQueryIndexediv: TglGetQueryIndexediv; - - // GL_ARB_ES2_compatibility - glReleaseShaderCompiler: TglReleaseShaderCompiler; - glShaderBinary: TglShaderBinary; - glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat; - glDepthRangef: TglDepthRangef; - glClearDepthf: TglClearDepthf; - - // GL_ARB_get_program_binary - glGetProgramBinary: TglGetProgramBinary; - glProgramBinary: TglProgramBinary; - glProgramParameteri: TglProgramParameteri; - - // GL_ARB_separate_shader_objects - glUseProgramStages: TglUseProgramStages; - glActiveShaderProgram: TglActiveShaderProgram; - glCreateShaderProgramv: TglCreateShaderProgramv; - glBindProgramPipeline: TglBindProgramPipeline; - glDeleteProgramPipelines: TglDeleteProgramPipelines; - glGenProgramPipelines: TglGenProgramPipelines; - glIsProgramPipeline: TglIsProgramPipeline; - glGetProgramPipelineiv: TglGetProgramPipelineiv; - glProgramUniform1i: TglProgramUniform1i; - glProgramUniform1iv: TglProgramUniform1iv; - glProgramUniform1f: TglProgramUniform1f; - glProgramUniform1fv: TglProgramUniform1fv; - glProgramUniform1d: TglProgramUniform1d; - glProgramUniform1dv: TglProgramUniform1dv; - glProgramUniform1ui: TglProgramUniform1ui; - glProgramUniform1uiv: TglProgramUniform1uiv; - glProgramUniform2i: TglProgramUniform2i; - glProgramUniform2iv: TglProgramUniform2iv; - glProgramUniform2f: TglProgramUniform2f; - glProgramUniform2fv: TglProgramUniform2fv; - glProgramUniform2d: TglProgramUniform2d; - glProgramUniform2dv: TglProgramUniform2dv; - glProgramUniform2ui: TglProgramUniform2ui; - glProgramUniform2uiv: TglProgramUniform2uiv; - glProgramUniform3i: TglProgramUniform3i; - glProgramUniform3iv: TglProgramUniform3iv; - glProgramUniform3f: TglProgramUniform3f; - glProgramUniform3fv: TglProgramUniform3fv; - glProgramUniform3d: TglProgramUniform3d; - glProgramUniform3dv: TglProgramUniform3dv; - glProgramUniform3ui: TglProgramUniform3ui; - glProgramUniform3uiv: TglProgramUniform3uiv; - glProgramUniform4i: TglProgramUniform4i; - glProgramUniform4iv: TglProgramUniform4iv; - glProgramUniform4f: TglProgramUniform4f; - glProgramUniform4fv: TglProgramUniform4fv; - glProgramUniform4d: TglProgramUniform4d; - glProgramUniform4dv: TglProgramUniform4dv; - glProgramUniform4ui: TglProgramUniform4ui; - glProgramUniform4uiv: TglProgramUniform4uiv; - glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv; - glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv; - glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv; - glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv; - glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv; - glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv; - glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv; - glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv; - glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv; - glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv; - glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv; - glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv; - glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv; - glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv; - glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv; - glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv; - glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv; - glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv; - glValidateProgramPipeline: TglValidateProgramPipeline; - glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog; - - // GL_ARB_vertex_attrib_64bit - glVertexAttribL1d: TglVertexAttribL1d; - glVertexAttribL2d: TglVertexAttribL2d; - glVertexAttribL3d: TglVertexAttribL3d; - glVertexAttribL4d: TglVertexAttribL4d; - glVertexAttribL1dv: TglVertexAttribL1dv; - glVertexAttribL2dv: TglVertexAttribL2dv; - glVertexAttribL3dv: TglVertexAttribL3dv; - glVertexAttribL4dv: TglVertexAttribL4dv; - glVertexAttribLPointer: TglVertexAttribLPointer; - glGetVertexAttribLdv: TglGetVertexAttribLdv; - - // GL_ARB_viewport_array - glViewportArrayv: TglViewportArrayv; - glViewportIndexedf: TglViewportIndexedf; - glViewportIndexedfv: TglViewportIndexedfv; - glScissorArrayv: TglScissorArrayv; - glScissorIndexed: TglScissorIndexed; - glScissorIndexedv: TglScissorIndexedv; - glDepthRangeArrayv: TglDepthRangeArrayv; - glDepthRangeIndexed: TglDepthRangeIndexed; - glGetFloati_v: TglGetFloati_v; - glGetDoublei_v: TglGetDoublei_v; - - // GL 4.2 - - // GL_ARB_base_instance - glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance; - glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance; - glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance; - - // GL_ARB_transform_feedback_instanced - glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced; - glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced; - - // GL_ARB_internalformat_query - glGetInternalformativ : TglGetInternalformativ; - - // GL_ARB_shader_atomic_counters - glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv; - - /// GL_ARB_shader_image_load_store - glBindImageTexture : TglBindImageTexture; - glMemoryBarrier : TglMemoryBarrier; - - // GL_ARB_texture_storage - glTexStorage1D : TglTexStorage1D; - glTexStorage2D : TglTexStorage2D; - glTexStorage3D : TglTexStorage3D; - glTextureStorage1DEXT : TglTextureStorage1DEXT; - glTextureStorage2DEXT : TglTextureStorage2DEXT; - glTextureStorage3DEXT : TglTextureStorage3DEXT; - - - // GL 4.3 - // GL_KHR_debug - glDebugMessageControl : TglDebugMessageControl; - glDebugMessageInsert : TglDebugMessageInsert; - glDebugMessageCallback : TglDebugMessageCallback; - glGetDebugMessageLog : TglGetDebugMessageLog; - glPushDebugGroup : TglPushDebugGroup; - glPopDebugGroup : TglPopDebugGroup; - glObjectLabel : TglObjectLabel; - glGetObjectLabel : TglGetObjectLabel; - glObjectPtrLabel : TglObjectPtrLabel; - glGetObjectPtrLabel : TglGetObjectPtrLabel; - // GL_ARB_clear_buffer_object - glClearBufferData : TglClearBufferData; - glClearBufferSubData : TglClearBufferSubData; - glClearNamedBufferDataEXT : TglClearNamedBufferDataEXT; - glClearNamedBufferSubDataEXT : TglClearNamedBufferSubDataEXT; - // GL_ARB_compute_shader - glDispatchCompute : TglDispatchCompute; - glDispatchComputeIndirect : TglDispatchComputeIndirect; - // GL_ARB_copy_image - glCopyImageSubData : TglCopyImageSubData; - // GL_ARB_framebuffer_no_attachments - glFramebufferParameteri : TglFramebufferParameteri; - glGetFramebufferParameteriv : TglGetFramebufferParameteriv; - glNamedFramebufferParameteriEXT : TglNamedFramebufferParameteriEXT; - glGetNamedFramebufferParameterivEXT : TglGetNamedFramebufferParameterivEXT; - // GL_ARB_internalformat_query2 - glGetInternalformati64v : TglGetInternalformati64v; - // GL_ARB_invalidate_subdata - glInvalidateTexSubImage : TglInvalidateTexSubImage; - glInvalidateTexImage : TglInvalidateTexImage; - glInvalidateBufferSubData : TglInvalidateBufferSubData; - glInvalidateBufferData : TglInvalidateBufferData; - glInvalidateFramebuffer : TglInvalidateFramebuffer; - glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer; - // GL_ARB_multi_draw_indirect - glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect; - glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect; - // GL_ARB_program_interface_query - glGetProgramInterfaceiv : TglGetProgramInterfaceiv; - glGetProgramResourceIndex : TglGetProgramResourceIndex; - glGetProgramResourceName : TglGetProgramResourceName; - glGetProgramResourceiv : TglGetProgramResourceiv; - glGetProgramResourceLocation : TglGetProgramResourceLocation; - glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex; - // GL_ARB_shader_storage_buffer_object - glShaderStorageBlockBinding : TglShaderStorageBlockBinding; - // GL_ARB_texture_buffer_range - glTexBufferRange : TglTexBufferRange; - glTextureBufferRangeEXT : TglTextureBufferRangeEXT; - // GL_ARB_texture_storage_multisample - glTexStorage2DMultisample : TglTexStorage2DMultisample; - glTexStorage3DMultisample : TglTexStorage3DMultisample; - glTextureStorage2DMultisampleEXT : TglTextureStorage2DMultisampleEXT; - glTextureStorage3DMultisampleEXT : TglTextureStorage3DMultisampleEXT; - // GL_ARB_texture_view - glTextureView : TglTextureView; - // GL_ARB_vertex_attrib_binding - glBindVertexBuffer : TglBindVertexBuffer; - glVertexAttribFormat : TglVertexAttribFormat; - glVertexAttribIFormat : TglVertexAttribIFormat; - glVertexAttribLFormat : TglVertexAttribLFormat; - glVertexAttribBinding : TglVertexAttribBinding; - glVertexBindingDivisor : TglVertexBindingDivisor; - glVertexArrayBindVertexBufferEXT : TglVertexArrayBindVertexBufferEXT; - glVertexArrayVertexAttribFormatEXT : TglVertexArrayVertexAttribFormatEXT; - glVertexArrayVertexAttribIFormatEXT : TglVertexArrayVertexAttribIFormatEXT; - glVertexArrayVertexAttribLFormatEXT : TglVertexArrayVertexAttribLFormatEXT; - glVertexArrayVertexAttribBindingEXT : TglVertexArrayVertexAttribBindingEXT; - glVertexArrayVertexBindingDivisorEXT : TglVertexArrayVertexBindingDivisorEXT; - // END GL 4.3 - - - // GL 4.4 - glBufferStorage : TglBufferStorage; - glClearTexImage : TglClearTexImage; - glClearTexSubImage : TglClearTexSubImage; - glBindBuffersBase : TglBindBuffersBase; - glBindBuffersRange : TglBindBuffersRange; - glBindTextures : TglBindTextures; - glBindSamplers : TglBindSamplers; - glBindImageTextures : TglBindImageTextures; - glBindVertexBuffers : TglBindVertexBuffers; - // END GL 4.4 - - - // GL_ARB_cl_event - glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB; - - // GL_ARB_debug_output - glDebugMessageControlARB: TglDebugMessageControlARB; - glDebugMessageInsertARB: TglDebugMessageInsertARB; - glDebugMessageCallbackARB: TglDebugMessageCallbackARB; - glGetDebugMessageLogARB: TglGetDebugMessageLogARB; - - // GL_ARB_robustness - glGetGraphicsResetStatusARB: TglGetGraphicsResetStatusARB; - glGetnMapdvARB: TglGetnMapdvARB; - glGetnMapfvARB: TglGetnMapfvARB; - glGetnMapivARB: TglGetnMapivARB; - glGetnPixelMapfvARB: TglGetnPixelMapfvARB; - glGetnPixelMapuivARB: TglGetnPixelMapuivARB; - glGetnPixelMapusvARB: TglGetnPixelMapusvARB; - glGetnPolygonStippleARB: TglGetnPolygonStippleARB; - glGetnColorTableARB: TglGetnColorTableARB; - glGetnConvolutionFilterARB: TglGetnConvolutionFilterARB; - glGetnSeparableFilterARB: TglGetnSeparableFilterARB; - glGetnHistogramARB: TglGetnHistogramARB; - glGetnMinmaxARB: TglGetnMinmaxARB; - glGetnTexImageARB: TglGetnTexImageARB; - glReadnPixelsARB: TglReadnPixelsARB; - glGetnCompressedTexImageARB: TglGetnCompressedTexImageARB; - glGetnUniformfvARB: TglGetnUniformfvARB; - glGetnUniformivARB: TglGetnUniformivARB; - glGetnUniformuivARB: TglGetnUniformuivARB; - glGetnUniformdvARB: TglGetnUniformdvARB; - - // GL_ATI_draw_buffers - glDrawBuffersATI: TglDrawBuffersATI; - - // GL_ATI_element_array - glElementPointerATI: TglElementPointerATI; - glDrawElementArrayATI: TglDrawElementArrayATI; - glDrawRangeElementArrayATI: TglDrawRangeElementArrayATI; - - // GL_ATI_envmap_bumpmap - glTexBumpParameterivATI: TglTexBumpParameterivATI; - glTexBumpParameterfvATI: TglTexBumpParameterfvATI; - glGetTexBumpParameterivATI: TglGetTexBumpParameterivATI; - glGetTexBumpParameterfvATI: TglGetTexBumpParameterfvATI; - - // GL_ATI_fragment_shader - glGenFragmentShadersATI: TglGenFragmentShadersATI; - glBindFragmentShaderATI: TglBindFragmentShaderATI; - glDeleteFragmentShaderATI: TglDeleteFragmentShaderATI; - glBeginFragmentShaderATI: TglBeginFragmentShaderATI; - glEndFragmentShaderATI: TglEndFragmentShaderATI; - glPassTexCoordATI: TglPassTexCoordATI; - glSampleMapATI: TglSampleMapATI; - glColorFragmentOp1ATI: TglColorFragmentOp1ATI; - glColorFragmentOp2ATI: TglColorFragmentOp2ATI; - glColorFragmentOp3ATI: TglColorFragmentOp3ATI; - glAlphaFragmentOp1ATI: TglAlphaFragmentOp1ATI; - glAlphaFragmentOp2ATI: TglAlphaFragmentOp2ATI; - glAlphaFragmentOp3ATI: TglAlphaFragmentOp3ATI; - glSetFragmentShaderConstantATI: TglSetFragmentShaderConstantATI; - - // GL_ATI_map_object_buffer - glMapObjectBufferATI: TglMapObjectBufferATI; - glUnmapObjectBufferATI: TglUnmapObjectBufferATI; - - // GL_ATI_pn_triangles - glPNTrianglesiATI: TglPNTrianglesiATI; - glPNTrianglesfATI: TglPNTrianglesfATI; - - // GL_ATI_separate_stencil - glStencilOpSeparateATI: TglStencilOpSeparateATI; - glStencilFuncSeparateATI: TglStencilFuncSeparateATI; - - // GL_ATI_vertex_array_object - glNewObjectBufferATI: TglNewObjectBufferATI; - glIsObjectBufferATI: TglIsObjectBufferATI; - glUpdateObjectBufferATI: TglUpdateObjectBufferATI; - glGetObjectBufferfvATI: TglGetObjectBufferfvATI; - glGetObjectBufferivATI: TglGetObjectBufferivATI; - glFreeObjectBufferATI: TglFreeObjectBufferATI; - glArrayObjectATI: TglArrayObjectATI; - glGetArrayObjectfvATI: TglGetArrayObjectfvATI; - glGetArrayObjectivATI: TglGetArrayObjectivATI; - glVariantArrayObjectATI: TglVariantArrayObjectATI; - glGetVariantArrayObjectfvATI: TglGetVariantArrayObjectfvATI; - glGetVariantArrayObjectivATI: TglGetVariantArrayObjectivATI; - glVertexAttribArrayObjectATI: TglVertexAttribArrayObjectATI; - glGetVertexAttribArrayObjectfvATI: TglGetVertexAttribArrayObjectfvATI; - glGetVertexAttribArrayObjectivATI: TglGetVertexAttribArrayObjectivATI; - - // GL_ATI_vertex_streams - glVertexStream1sATI: TglVertexStream1sATI; - glVertexStream1svATI: TglVertexStream1svATI; - glVertexStream1iATI: TglVertexStream1iATI; - glVertexStream1ivATI: TglVertexStream1ivATI; - glVertexStream1fATI: TglVertexStream1fATI; - glVertexStream1fvATI: TglVertexStream1fvATI; - glVertexStream1dATI: TglVertexStream1dATI; - glVertexStream1dvATI: TglVertexStream1dvATI; - glVertexStream2sATI: TglVertexStream2sATI; - glVertexStream2svATI: TglVertexStream2svATI; - glVertexStream2iATI: TglVertexStream2iATI; - glVertexStream2ivATI: TglVertexStream2ivATI; - glVertexStream2fATI: TglVertexStream2fATI; - glVertexStream2fvATI: TglVertexStream2fvATI; - glVertexStream2dATI: TglVertexStream2dATI; - glVertexStream2dvATI: TglVertexStream2dvATI; - glVertexStream3sATI: TglVertexStream3sATI; - glVertexStream3svATI: TglVertexStream3svATI; - glVertexStream3iATI: TglVertexStream3iATI; - glVertexStream3ivATI: TglVertexStream3ivATI; - glVertexStream3fATI: TglVertexStream3fATI; - glVertexStream3fvATI: TglVertexStream3fvATI; - glVertexStream3dATI: TglVertexStream3dATI; - glVertexStream3dvATI: TglVertexStream3dvATI; - glVertexStream4sATI: TglVertexStream4sATI; - glVertexStream4svATI: TglVertexStream4svATI; - glVertexStream4iATI: TglVertexStream4iATI; - glVertexStream4ivATI: TglVertexStream4ivATI; - glVertexStream4fATI: TglVertexStream4fATI; - glVertexStream4fvATI: TglVertexStream4fvATI; - glVertexStream4dATI: TglVertexStream4dATI; - glVertexStream4dvATI: TglVertexStream4dvATI; - glNormalStream3bATI: TglNormalStream3bATI; - glNormalStream3bvATI: TglNormalStream3bvATI; - glNormalStream3sATI: TglNormalStream3sATI; - glNormalStream3svATI: TglNormalStream3svATI; - glNormalStream3iATI: TglNormalStream3iATI; - glNormalStream3ivATI: TglNormalStream3ivATI; - glNormalStream3fATI: TglNormalStream3fATI; - glNormalStream3fvATI: TglNormalStream3fvATI; - glNormalStream3dATI: TglNormalStream3dATI; - glNormalStream3dvATI: TglNormalStream3dvATI; - glClientActiveVertexStreamATI: TglClientActiveVertexStreamATI; - glVertexBlendEnviATI: TglVertexBlendEnviATI; - glVertexBlendEnvfATI: TglVertexBlendEnvfATI; - - // GL_AMD_performance_monitor - glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD; - glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD; - glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD; - glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD; - glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD; - glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD; - glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD; - glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD; - glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD; - glEndPerfMonitorAMD: TglEndPerfMonitorAMD; - glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD; - - // GL_AMD_vertex_shader_tesselator - glTessellationFactorAMD: TglTessellationFactorAMD; - glTessellationModeAMD: TglTessellationModeAMD; - - // GL_AMD_draw_buffers_blend - glBlendFuncIndexedAMD: TglBlendFuncIndexedAMD; - glBlendFuncSeparateIndexedAMD: TglBlendFuncSeparateIndexedAMD; - glBlendEquationIndexedAMD: TglBlendEquationIndexedAMD; - glBlendEquationSeparateIndexedAMD: TglBlendEquationSeparateIndexedAMD; - - // GL_AMD_name_gen_delete - glGenNamesAMD: TglGenNamesAMD; - glDeleteNamesAMD: TglDeleteNamesAMD; - glIsNameAMD: TglIsNameAMD; - - // GL_AMD_debug_output - glDebugMessageEnableAMD: TglDebugMessageEnableAMD; - glDebugMessageInsertAMD: TglDebugMessageInsertAMD; - glDebugMessageCallbackAMD: TglDebugMessageCallbackAMD; - glGetDebugMessageLogAMD: TglGetDebugMessageLogAMD; - - // GL_EXT_blend_color - glBlendColorEXT: TglBlendColorEXT; - - // GL_EXT_blend_func_separate - glBlendFuncSeparateEXT: TglBlendFuncSeparateEXT; - - // GL_EXT_blend_minmax - glBlendEquationEXT: TglBlendEquationEXT; - - // GL_EXT_color_subtable - glColorSubTableEXT: TglColorSubTableEXT; - glCopyColorSubTableEXT: TglCopyColorSubTableEXT; - - // GL_EXT_compiled_vertex_array - glLockArraysEXT: TglLockArraysEXT; - glUnlockArraysEXT: TglUnlockArraysEXT; - - // GL_EXT_convolution - glConvolutionFilter1DEXT: TglConvolutionFilter1DEXT; - glConvolutionFilter2DEXT: TglConvolutionFilter2DEXT; - glConvolutionParameterfEXT: TglConvolutionParameterfEXT; - glConvolutionParameterfvEXT: TglConvolutionParameterfvEXT; - glConvolutionParameteriEXT: TglConvolutionParameteriEXT; - glConvolutionParameterivEXT: TglConvolutionParameterivEXT; - glCopyConvolutionFilter1DEXT: TglCopyConvolutionFilter1DEXT; - glCopyConvolutionFilter2DEXT: TglCopyConvolutionFilter2DEXT; - glGetConvolutionFilterEXT: TglGetConvolutionFilterEXT; - glGetConvolutionParameterfvEXT: TglGetConvolutionParameterfvEXT; - glGetConvolutionParameterivEXT: TglGetConvolutionParameterivEXT; - glGetSeparableFilterEXT: TglGetSeparableFilterEXT; - glSeparableFilter2DEXT: TglSeparableFilter2DEXT; - - // GL_EXT_coordinate_frame - glTangent3bEXT: TglTangent3bEXT; - glTangent3bvEXT: TglTangent3bvEXT; - glTangent3dEXT: TglTangent3dEXT; - glTangent3dvEXT: TglTangent3dvEXT; - glTangent3fEXT: TglTangent3fEXT; - glTangent3fvEXT: TglTangent3fvEXT; - glTangent3iEXT: TglTangent3iEXT; - glTangent3ivEXT: TglTangent3ivEXT; - glTangent3sEXT: TglTangent3sEXT; - glTangent3svEXT: TglTangent3svEXT; - glBinormal3bEXT: TglBinormal3bEXT; - glBinormal3bvEXT: TglBinormal3bvEXT; - glBinormal3dEXT: TglBinormal3dEXT; - glBinormal3dvEXT: TglBinormal3dvEXT; - glBinormal3fEXT: TglBinormal3fEXT; - glBinormal3fvEXT: TglBinormal3fvEXT; - glBinormal3iEXT: TglBinormal3iEXT; - glBinormal3ivEXT: TglBinormal3ivEXT; - glBinormal3sEXT: TglBinormal3sEXT; - glBinormal3svEXT: TglBinormal3svEXT; - glTangentPointerEXT: TglTangentPointerEXT; - glBinormalPointerEXT: TglBinormalPointerEXT; - - // GL_EXT_copy_texture - glCopyTexImage1DEXT: TglCopyTexImage1DEXT; - glCopyTexImage2DEXT: TglCopyTexImage2DEXT; - glCopyTexSubImage1DEXT: TglCopyTexSubImage1DEXT; - glCopyTexSubImage2DEXT: TglCopyTexSubImage2DEXT; - glCopyTexSubImage3DEXT: TglCopyTexSubImage3DEXT; - - // GL_EXT_cull_vertex - glCullParameterdvEXT: TglCullParameterdvEXT; - glCullParameterfvEXT: TglCullParameterfvEXT; - - // GL_EXT_draw_range_elements - glDrawRangeElementsEXT: TglDrawRangeElementsEXT; - - // GL_EXT_fog_coord - glFogCoordfEXT: TglFogCoordfEXT; - glFogCoordfvEXT: TglFogCoordfvEXT; - glFogCoorddEXT: TglFogCoorddEXT; - glFogCoorddvEXT: TglFogCoorddvEXT; - glFogCoordPointerEXT: TglFogCoordPointerEXT; - - // GL_EXT_framebuffer_object - glIsRenderbufferEXT: TglIsRenderbufferEXT; - glBindRenderbufferEXT: TglBindRenderbufferEXT; - glDeleteRenderbuffersEXT: TglDeleteRenderbuffersEXT; - glGenRenderbuffersEXT: TglGenRenderbuffersEXT; - glRenderbufferStorageEXT: TglRenderbufferStorageEXT; - glGetRenderbufferParameterivEXT: TglGetRenderbufferParameterivEXT; - glIsFramebufferEXT: TglIsFramebufferEXT; - glBindFramebufferEXT: TglBindFramebufferEXT; - glDeleteFramebuffersEXT: TglDeleteFramebuffersEXT; - glGenFramebuffersEXT: TglGenFramebuffersEXT; - glCheckFramebufferStatusEXT: TglCheckFramebufferStatusEXT; - glFramebufferTexture1DEXT: TglFramebufferTexture1DEXT; - glFramebufferTexture2DEXT: TglFramebufferTexture2DEXT; - glFramebufferTexture3DEXT: TglFramebufferTexture3DEXT; - glFramebufferRenderbufferEXT: TglFramebufferRenderbufferEXT; - glGetFramebufferAttachmentParameterivEXT: TglGetFramebufferAttachmentParameterivEXT; - glGenerateMipmapEXT: TglGenerateMipmapEXT; - - // GL_EXT_histogram - glGetHistogramEXT: TglGetHistogramEXT; - glGetHistogramParameterfvEXT: TglGetHistogramParameterfvEXT; - glGetHistogramParameterivEXT: TglGetHistogramParameterivEXT; - glGetMinmaxEXT: TglGetMinmaxEXT; - glGetMinmaxParameterfvEXT: TglGetMinmaxParameterfvEXT; - glGetMinmaxParameterivEXT: TglGetMinmaxParameterivEXT; - glHistogramEXT: TglHistogramEXT; - glMinmaxEXT: TglMinmaxEXT; - glResetHistogramEXT: TglResetHistogramEXT; - glResetMinmaxEXT: TglResetMinmaxEXT; - - // GL_EXT_index_func - glIndexFuncEXT: TglIndexFuncEXT; - - // GL_EXT_index_material - glIndexMaterialEXT: TglIndexMaterialEXT; - - // GL_EXT_light_texture - glApplyTextureEXT: TglApplyTextureEXT; - glTextureLightEXT: TglTextureLightEXT; - glTextureMaterialEXT: TglTextureMaterialEXT; - - // GL_EXT_multi_draw_arrays - glMultiDrawArraysEXT: TglMultiDrawArraysEXT; - glMultiDrawElementsEXT: TglMultiDrawElementsEXT; - - // GL_EXT_multisample - glSampleMaskEXT: TglSampleMaskEXT; - glSamplePatternEXT: TglSamplePatternEXT; - - // GL_EXT_paletted_texture - glColorTableEXT: TglColorTableEXT; - glGetColorTableEXT: TglGetColorTableEXT; - glGetColorTableParameterivEXT: TglGetColorTableParameterivEXT; - glGetColorTableParameterfvEXT: TglGetColorTableParameterfvEXT; - - // GL_EXT_pixel_transform - glPixelTransformParameteriEXT: TglPixelTransformParameteriEXT; - glPixelTransformParameterfEXT: TglPixelTransformParameterfEXT; - glPixelTransformParameterivEXT: TglPixelTransformParameterivEXT; - glPixelTransformParameterfvEXT: TglPixelTransformParameterfvEXT; - - // GL_EXT_point_parameters - glPointParameterfEXT: TglPointParameterfEXT; - glPointParameterfvEXT: TglPointParameterfvEXT; - - // GL_EXT_polygon_offset - glPolygonOffsetEXT: TglPolygonOffsetEXT; - - // GL_EXT_secondary_color - glSecondaryColor3bEXT: TglSecondaryColor3bEXT; - glSecondaryColor3bvEXT: TglSecondaryColor3bvEXT; - glSecondaryColor3dEXT: TglSecondaryColor3dEXT; - glSecondaryColor3dvEXT: TglSecondaryColor3dvEXT; - glSecondaryColor3fEXT: TglSecondaryColor3fEXT; - glSecondaryColor3fvEXT: TglSecondaryColor3fvEXT; - glSecondaryColor3iEXT: TglSecondaryColor3iEXT; - glSecondaryColor3ivEXT: TglSecondaryColor3ivEXT; - glSecondaryColor3sEXT: TglSecondaryColor3sEXT; - glSecondaryColor3svEXT: TglSecondaryColor3svEXT; - glSecondaryColor3ubEXT: TglSecondaryColor3ubEXT; - glSecondaryColor3ubvEXT: TglSecondaryColor3ubvEXT; - glSecondaryColor3uiEXT: TglSecondaryColor3uiEXT; - glSecondaryColor3uivEXT: TglSecondaryColor3uivEXT; - glSecondaryColor3usEXT: TglSecondaryColor3usEXT; - glSecondaryColor3usvEXT: TglSecondaryColor3usvEXT; - glSecondaryColorPointerEXT: TglSecondaryColorPointerEXT; - - // GL_EXT_stencil_two_side - glActiveStencilFaceEXT: TglActiveStencilFaceEXT; - - // GL_EXT_subtexture - glTexSubImage1DEXT: TglTexSubImage1DEXT; - glTexSubImage2DEXT: TglTexSubImage2DEXT; - - // GL_EXT_texture3D - glTexImage3DEXT: TglTexImage3DEXT; - glTexSubImage3DEXT: TglTexSubImage3DEXT; - - // GL_EXT_texture_object - glAreTexturesResidentEXT: TglAreTexturesResidentEXT; - glBindTextureEXT: TglBindTextureEXT; - glDeleteTexturesEXT: TglDeleteTexturesEXT; - glGenTexturesEXT: TglGenTexturesEXT; - glIsTextureEXT: TglIsTextureEXT; - glPrioritizeTexturesEXT: TglPrioritizeTexturesEXT; - - // GL_EXT_texture_perturb_normal - glTextureNormalEXT: TglTextureNormalEXT; - - // GL_EXT_vertex_array - glArrayElementEXT: TglArrayElementEXT; - glColorPointerEXT: TglColorPointerEXT; - glDrawArraysEXT: TglDrawArraysEXT; - glEdgeFlagPointerEXT: TglEdgeFlagPointerEXT; - glGetPointervEXT: TglGetPointervEXT; - glIndexPointerEXT: TglIndexPointerEXT; - glNormalPointerEXT: TglNormalPointerEXT; - glTexCoordPointerEXT: TglTexCoordPointerEXT; - glVertexPointerEXT: TglVertexPointerEXT; - - // GL_EXT_vertex_shader - glBeginVertexShaderEXT: TglBeginVertexShaderEXT; - glEndVertexShaderEXT: TglEndVertexShaderEXT; - glBindVertexShaderEXT: TglBindVertexShaderEXT; - glGenVertexShadersEXT: TglGenVertexShadersEXT; - glDeleteVertexShaderEXT: TglDeleteVertexShaderEXT; - glShaderOp1EXT: TglShaderOp1EXT; - glShaderOp2EXT: TglShaderOp2EXT; - glShaderOp3EXT: TglShaderOp3EXT; - glSwizzleEXT: TglSwizzleEXT; - glWriteMaskEXT: TglWriteMaskEXT; - glInsertComponentEXT: TglInsertComponentEXT; - glExtractComponentEXT: TglExtractComponentEXT; - glGenSymbolsEXT: TglGenSymbolsEXT; - glSetInvariantEXT: TglSetInvariantEXT; - glSetLocalConstantEXT: TglSetLocalConstantEXT; - glVariantbvEXT: TglVariantbvEXT; - glVariantsvEXT: TglVariantsvEXT; - glVariantivEXT: TglVariantivEXT; - glVariantfvEXT: TglVariantfvEXT; - glVariantdvEXT: TglVariantdvEXT; - glVariantubvEXT: TglVariantubvEXT; - glVariantusvEXT: TglVariantusvEXT; - glVariantuivEXT: TglVariantuivEXT; - glVariantPointerEXT: TglVariantPointerEXT; - glEnableVariantClientStateEXT: TglEnableVariantClientStateEXT; - glDisableVariantClientStateEXT: TglDisableVariantClientStateEXT; - glBindLightParameterEXT: TglBindLightParameterEXT; - glBindMaterialParameterEXT: TglBindMaterialParameterEXT; - glBindTexGenParameterEXT: TglBindTexGenParameterEXT; - glBindTextureUnitParameterEXT: TglBindTextureUnitParameterEXT; - glBindParameterEXT: TglBindParameterEXT; - glIsVariantEnabledEXT: TglIsVariantEnabledEXT; - glGetVariantBooleanvEXT: TglGetVariantBooleanvEXT; - glGetVariantIntegervEXT: TglGetVariantIntegervEXT; - glGetVariantFloatvEXT: TglGetVariantFloatvEXT; - glGetVariantPointervEXT: TglGetVariantPointervEXT; - glGetInvariantBooleanvEXT: TglGetInvariantBooleanvEXT; - glGetInvariantIntegervEXT: TglGetInvariantIntegervEXT; - glGetInvariantFloatvEXT: TglGetInvariantFloatvEXT; - glGetLocalConstantBooleanvEXT: TglGetLocalConstantBooleanvEXT; - glGetLocalConstantIntegervEXT: TglGetLocalConstantIntegervEXT; - glGetLocalConstantFloatvEXT: TglGetLocalConstantFloatvEXT; - - // GL_EXT_vertex_weighting - glVertexWeightfEXT: TglVertexWeightfEXT; - glVertexWeightfvEXT: TglVertexWeightfvEXT; - glVertexWeightPointerEXT: TglVertexWeightPointerEXT; - - // GL_EXT_stencil_clear_tag - glStencilClearTagEXT: TglStencilClearTagEXT; - - // GL_EXT_framebuffer_blit - glBlitFramebufferEXT: TglBlitFramebufferEXT; - - // GL_EXT_framebuffer_multisample - glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT; - - // GL_EXT_timer_query - glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT; - glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT; - - // GL_EXT_gpu_program_parameters - glProgramEnvParameters4fvEXT: TglProgramEnvParameters4fvEXT; - glProgramLocalParameters4fvEXT: TglProgramLocalParameters4fvEXT; - - // GL_EXT_bindable_uniform - glUniformBufferEXT: TglUniformBufferEXT; - glGetUniformBufferSizeEXT: TglGetUniformBufferSizeEXT; - glGetUniformOffsetEXT: TglGetUniformOffsetEXT; - - // GL_EXT_draw_buffers2 - glColorMaskIndexedEXT: TglColorMaskIndexedEXT; - glGetBooleanIndexedvEXT: TglGetBooleanIndexedvEXT; - glGetIntegerIndexedvEXT: TglGetIntegerIndexedvEXT; - glEnableIndexedEXT: TglEnableIndexedEXT; - glDisableIndexedEXT: TglDisableIndexedEXT; - glIsEnabledIndexedEXT: TglIsEnabledIndexedEXT; - - // GL_EXT_draw_instanced - glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT; - glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT; - - // GL_EXT_geometry_shader4 - glProgramParameteriEXT: TglProgramParameteriEXT; - glFramebufferTextureEXT: TglFramebufferTextureEXT; -// glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT; - glFramebufferTextureFaceEXT: TglFramebufferTextureFaceEXT; - - // GL_EXT_gpu_shader4 - glVertexAttribI1iEXT: TglVertexAttribI1iEXT; - glVertexAttribI2iEXT: TglVertexAttribI2iEXT; - glVertexAttribI3iEXT: TglVertexAttribI3iEXT; - glVertexAttribI4iEXT: TglVertexAttribI4iEXT; - glVertexAttribI1uiEXT: TglVertexAttribI1uiEXT; - glVertexAttribI2uiEXT: TglVertexAttribI2uiEXT; - glVertexAttribI3uiEXT: TglVertexAttribI3uiEXT; - glVertexAttribI4uiEXT: TglVertexAttribI4uiEXT; - glVertexAttribI1ivEXT: TglVertexAttribI1ivEXT; - glVertexAttribI2ivEXT: TglVertexAttribI2ivEXT; - glVertexAttribI3ivEXT: TglVertexAttribI3ivEXT; - glVertexAttribI4ivEXT: TglVertexAttribI4ivEXT; - glVertexAttribI1uivEXT: TglVertexAttribI1uivEXT; - glVertexAttribI2uivEXT: TglVertexAttribI2uivEXT; - glVertexAttribI3uivEXT: TglVertexAttribI3uivEXT; - glVertexAttribI4uivEXT: TglVertexAttribI4uivEXT; - glVertexAttribI4bvEXT: TglVertexAttribI4bvEXT; - glVertexAttribI4svEXT: TglVertexAttribI4svEXT; - glVertexAttribI4ubvEXT: TglVertexAttribI4ubvEXT; - glVertexAttribI4usvEXT: TglVertexAttribI4usvEXT; - glVertexAttribIPointerEXT: TglVertexAttribIPointerEXT; - glGetVertexAttribIivEXT: TglGetVertexAttribIivEXT; - glGetVertexAttribIuivEXT: TglGetVertexAttribIuivEXT; - glUniform1uiEXT: TglUniform1uiEXT; - glUniform2uiEXT: TglUniform2uiEXT; - glUniform3uiEXT: TglUniform3uiEXT; - glUniform4uiEXT: TglUniform4uiEXT; - glUniform1uivEXT: TglUniform1uivEXT; - glUniform2uivEXT: TglUniform2uivEXT; - glUniform3uivEXT: TglUniform3uivEXT; - glUniform4uivEXT: TglUniform4uivEXT; - glGetUniformuivEXT: TglGetUniformuivEXT; - glBindFragDataLocationEXT: TglBindFragDataLocationEXT; - glGetFragDataLocationEXT: TglGetFragDataLocationEXT; - - // GL_EXT_texture_array - glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT; - - // GL_EXT_texture_buffer_object - glTexBufferEXT: TglTexBufferEXT; - - // GL_EXT_texture_integer - glClearColorIiEXT: TglClearColorIiEXT; - glClearColorIuiEXT: TglClearColorIuiEXT; - glTexParameterIivEXT: TglTexParameterIivEXT; - glTexParameterIuivEXT: TglTexParameterIuivEXT; - glGetTexParameterIivEXT: TglGetTexParameterIivEXT; - glGetTexParameterIiuvEXT: TglGetTexParameterIiuvEXT; - - // GL_EXT_transform_feedback - glBeginTransformFeedbackEXT: TglBeginTransformFeedbackEXT; - glEndTransformFeedbackEXT: TglEndTransformFeedbackEXT; - glBindBufferRangeEXT: TglBindBufferRangeEXT; - glBindBufferOffsetEXT: TglBindBufferOffsetEXT; - glBindBufferBaseEXT: TglBindBufferBaseEXT; - glTransformFeedbackVaryingsEXT: TglTransformFeedbackVaryingsEXT; - glGetTransformFeedbackVaryingEXT: TglGetTransformFeedbackVaryingEXT; - - // GL_EXT_direct_state_access - glClientAttribDefaultEXT: TglClientAttribDefaultEXT; - glPushClientAttribDefaultEXT: TglPushClientAttribDefaultEXT; - glMatrixLoadfEXT: TglMatrixLoadfEXT; - glMatrixLoaddEXT: TglMatrixLoaddEXT; - glMatrixMultfEXT: TglMatrixMultfEXT; - glMatrixMultdEXT: TglMatrixMultdEXT; - glMatrixLoadIdentityEXT: TglMatrixLoadIdentityEXT; - glMatrixRotatefEXT: TglMatrixRotatefEXT; - glMatrixRotatedEXT: TglMatrixRotatedEXT; - glMatrixScalefEXT: TglMatrixScalefEXT; - glMatrixScaledEXT: TglMatrixScaledEXT; - glMatrixTranslatefEXT: TglMatrixTranslatefEXT; - glMatrixTranslatedEXT: TglMatrixTranslatedEXT; - glMatrixFrustumEXT: TglMatrixFrustumEXT; - glMatrixOrthoEXT: TglMatrixOrthoEXT; - glMatrixPopEXT: TglMatrixPopEXT; - glMatrixPushEXT: TglMatrixPushEXT; - glMatrixLoadTransposefEXT: TglMatrixLoadTransposefEXT; - glMatrixLoadTransposedEXT: TglMatrixLoadTransposedEXT; - glMatrixMultTransposefEXT: TglMatrixMultTransposefEXT; - glMatrixMultTransposedEXT: TglMatrixMultTransposedEXT; - glTextureParameterfEXT: TglTextureParameterfEXT; - glTextureParameterfvEXT: TglTextureParameterfvEXT; - glTextureParameteriEXT: TglTextureParameteriEXT; - glTextureParameterivEXT: TglTextureParameterivEXT; - glTextureImage1DEXT: TglTextureImage1DEXT; - glTextureImage2DEXT: TglTextureImage2DEXT; - glTextureSubImage1DEXT: TglTextureSubImage1DEXT; - glTextureSubImage2DEXT: TglTextureSubImage2DEXT; - glCopyTextureImage1DEXT: TglCopyTextureImage1DEXT; - glCopyTextureImage2DEXT: TglCopyTextureImage2DEXT; - glCopyTextureSubImage1DEXT: TglCopyTextureSubImage1DEXT; - glCopyTextureSubImage2DEXT: TglCopyTextureSubImage2DEXT; - glGetTextureImageEXT: TglGetTextureImageEXT; - glGetTextureParameterfvEXT: TglGetTextureParameterfvEXT; - glGetTextureParameterivEXT: TglGetTextureParameterivEXT; - glGetTextureLevelParameterfvEXT: TglGetTextureLevelParameterfvEXT; - glGetTextureLevelParameterivEXT: TglGetTextureLevelParameterivEXT; - glTextureImage3DEXT: TglTextureImage3DEXT; - glTextureSubImage3DEXT: TglTextureSubImage3DEXT; - glCopyTextureSubImage3DEXT: TglCopyTextureSubImage3DEXT; - glMultiTexParameterfEXT: TglMultiTexParameterfEXT; - glMultiTexParameterfvEXT: TglMultiTexParameterfvEXT; - glMultiTexParameteriEXT: TglMultiTexParameteriEXT; - glMultiTexParameterivEXT: TglMultiTexParameterivEXT; - glMultiTexImage1DEXT: TglMultiTexImage1DEXT; - glMultiTexImage2DEXT: TglMultiTexImage2DEXT; - glMultiTexSubImage1DEXT: TglMultiTexSubImage1DEXT; - glMultiTexSubImage2DEXT: TglMultiTexSubImage2DEXT; - glCopyMultiTexImage1DEXT: TglCopyMultiTexImage1DEXT; - glCopyMultiTexImage2DEXT: TglCopyMultiTexImage2DEXT; - glCopyMultiTexSubImage1DEXT: TglCopyMultiTexSubImage1DEXT; - glCopyMultiTexSubImage2DEXT: TglCopyMultiTexSubImage2DEXT; - glGetMultiTexImageEXT: TglGetMultiTexImageEXT; - glGetMultiTexParameterfvEXT: TglGetMultiTexParameterfvEXT; - glGetMultiTexParameterivEXT: TglGetMultiTexParameterivEXT; - glGetMultiTexLevelParameterfvEXT: TglGetMultiTexLevelParameterfvEXT; - glGetMultiTexLevelParameterivEXT: TglGetMultiTexLevelParameterivEXT; - glMultiTexImage3DEXT: TglMultiTexImage3DEXT; - glMultiTexSubImage3DEXT: TglMultiTexSubImage3DEXT; - glCopyMultiTexSubImage3DEXT: TglCopyMultiTexSubImage3DEXT; - glBindMultiTextureEXT: TglBindMultiTextureEXT; - glEnableClientStateIndexedEXT: TglEnableClientStateIndexedEXT; - glDisableClientStateIndexedEXT: TglDisableClientStateIndexedEXT; - glMultiTexCoordPointerEXT: TglMultiTexCoordPointerEXT; - glMultiTexEnvfEXT: TglMultiTexEnvfEXT; - glMultiTexEnvfvEXT: TglMultiTexEnvfvEXT; - glMultiTexEnviEXT: TglMultiTexEnviEXT; - glMultiTexEnvivEXT: TglMultiTexEnvivEXT; - glMultiTexGendEXT: TglMultiTexGendEXT; - glMultiTexGendvEXT: TglMultiTexGendvEXT; - glMultiTexGenfEXT: TglMultiTexGenfEXT; - glMultiTexGenfvEXT: TglMultiTexGenfvEXT; - glMultiTexGeniEXT: TglMultiTexGeniEXT; - glMultiTexGenivEXT: TglMultiTexGenivEXT; - glGetMultiTexEnvfvEXT: TglGetMultiTexEnvfvEXT; - glGetMultiTexEnvivEXT: TglGetMultiTexEnvivEXT; - glGetMultiTexGendvEXT: TglGetMultiTexGendvEXT; - glGetMultiTexGenfvEXT: TglGetMultiTexGenfvEXT; - glGetMultiTexGenivEXT: TglGetMultiTexGenivEXT; - glGetFloatIndexedvEXT: TglGetFloatIndexedvEXT; - glGetDoubleIndexedvEXT: TglGetDoubleIndexedvEXT; - glGetPointerIndexedvEXT: TglGetPointerIndexedvEXT; - glCompressedTextureImage3DEXT: TglCompressedTextureImage3DEXT; - glCompressedTextureImage2DEXT: TglCompressedTextureImage2DEXT; - glCompressedTextureImage1DEXT: TglCompressedTextureImage1DEXT; - glCompressedTextureSubImage3DEXT: TglCompressedTextureSubImage3DEXT; - glCompressedTextureSubImage2DEXT: TglCompressedTextureSubImage2DEXT; - glCompressedTextureSubImage1DEXT: TglCompressedTextureSubImage1DEXT; - glGetCompressedTextureImageEXT: TglGetCompressedTextureImageEXT; - glCompressedMultiTexImage3DEXT: TglCompressedMultiTexImage3DEXT; - glCompressedMultiTexImage2DEXT: TglCompressedMultiTexImage2DEXT; - glCompressedMultiTexImage1DEXT: TglCompressedMultiTexImage1DEXT; - glCompressedMultiTexSubImage3DEXT: TglCompressedMultiTexSubImage3DEXT; - glCompressedMultiTexSubImage2DEXT: TglCompressedMultiTexSubImage2DEXT; - glCompressedMultiTexSubImage1DEXT: TglCompressedMultiTexSubImage1DEXT; - glGetCompressedMultiTexImageEXT: TglGetCompressedMultiTexImageEXT; - glNamedProgramStringEXT: TglNamedProgramStringEXT; - glNamedProgramLocalParameter4dEXT: TglNamedProgramLocalParameter4dEXT; - glNamedProgramLocalParameter4dvEXT: TglNamedProgramLocalParameter4dvEXT; - glNamedProgramLocalParameter4fEXT: TglNamedProgramLocalParameter4fEXT; - glNamedProgramLocalParameter4fvEXT: TglNamedProgramLocalParameter4fvEXT; - glGetNamedProgramLocalParameterdvEXT: TglGetNamedProgramLocalParameterdvEXT; - glGetNamedProgramLocalParameterfvEXT: TglGetNamedProgramLocalParameterfvEXT; - glGetNamedProgramivEXT: TglGetNamedProgramivEXT; - glGetNamedProgramStringEXT: TglGetNamedProgramStringEXT; - glNamedProgramLocalParameters4fvEXT: TglNamedProgramLocalParameters4fvEXT; - glNamedProgramLocalParameterI4iEXT: TglNamedProgramLocalParameterI4iEXT; - glNamedProgramLocalParameterI4ivEXT: TglNamedProgramLocalParameterI4ivEXT; - glNamedProgramLocalParametersI4ivEXT: TglNamedProgramLocalParametersI4ivEXT; - glNamedProgramLocalParameterI4uiEXT: TglNamedProgramLocalParameterI4uiEXT; - glNamedProgramLocalParameterI4uivEXT: TglNamedProgramLocalParameterI4uivEXT; - glNamedProgramLocalParametersI4uivEXT: TglNamedProgramLocalParametersI4uivEXT; - glGetNamedProgramLocalParameterIivEXT: TglGetNamedProgramLocalParameterIivEXT; - glGetNamedProgramLocalParameterIuivEXT: TglGetNamedProgramLocalParameterIuivEXT; - glTextureParameterIivEXT: TglTextureParameterIivEXT; - glTextureParameterIuivEXT: TglTextureParameterIuivEXT; - glGetTextureParameterIivEXT: TglGetTextureParameterIivEXT; - glGetTextureParameterIuivEXT: TglGetTextureParameterIuivEXT; - glMultiTexParameterIivEXT: TglMultiTexParameterIivEXT; - glMultiTexParameterIuivEXT: TglMultiTexParameterIuivEXT; - glGetMultiTexParameterIivEXT: TglGetMultiTexParameterIivEXT; - glGetMultiTexParameterIuivEXT: TglGetMultiTexParameterIuivEXT; - glProgramUniform1fEXT: TglProgramUniform1fEXT; - glProgramUniform2fEXT: TglProgramUniform2fEXT; - glProgramUniform3fEXT: TglProgramUniform3fEXT; - glProgramUniform4fEXT: TglProgramUniform4fEXT; - glProgramUniform1iEXT: TglProgramUniform1iEXT; - glProgramUniform2iEXT: TglProgramUniform2iEXT; - glProgramUniform3iEXT: TglProgramUniform3iEXT; - glProgramUniform4iEXT: TglProgramUniform4iEXT; - glProgramUniform1fvEXT: TglProgramUniform1fvEXT; - glProgramUniform2fvEXT: TglProgramUniform2fvEXT; - glProgramUniform3fvEXT: TglProgramUniform3fvEXT; - glProgramUniform4fvEXT: TglProgramUniform4fvEXT; - glProgramUniform1ivEXT: TglProgramUniform1ivEXT; - glProgramUniform2ivEXT: TglProgramUniform2ivEXT; - glProgramUniform3ivEXT: TglProgramUniform3ivEXT; - glProgramUniform4ivEXT: TglProgramUniform4ivEXT; - glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT; - glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT; - glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT; - glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT; - glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT; - glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT; - glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT; - glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT; - glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT; - glProgramUniform1uiEXT: TglProgramUniform1uiEXT; - glProgramUniform2uiEXT: TglProgramUniform2uiEXT; - glProgramUniform3uiEXT: TglProgramUniform3uiEXT; - glProgramUniform4uiEXT: TglProgramUniform4uiEXT; - glProgramUniform1uivEXT: TglProgramUniform1uivEXT; - glProgramUniform2uivEXT: TglProgramUniform2uivEXT; - glProgramUniform3uivEXT: TglProgramUniform3uivEXT; - glProgramUniform4uivEXT: TglProgramUniform4uivEXT; - glNamedBufferDataEXT: TglNamedBufferDataEXT; - glNamedBufferSubDataEXT: TglNamedBufferSubDataEXT; - glMapNamedBufferEXT: TglMapNamedBufferEXT; - glUnmapNamedBufferEXT: TglUnmapNamedBufferEXT; - glMapNamedBufferRangeEXT: TglMapNamedBufferRangeEXT; - glFlushMappedNamedBufferRangeEXT: TglFlushMappedNamedBufferRangeEXT; - glNamedCopyBufferSubDataEXT: TglNamedCopyBufferSubDataEXT; - glGetNamedBufferParameterivEXT: TglGetNamedBufferParameterivEXT; - glGetNamedBufferPointervEXT: TglGetNamedBufferPointervEXT; - glGetNamedBufferSubDataEXT: TglGetNamedBufferSubDataEXT; - glTextureBufferEXT: TglTextureBufferEXT; - glMultiTexBufferEXT: TglMultiTexBufferEXT; - glNamedRenderbufferStorageEXT: TglNamedRenderbufferStorageEXT; - glGetNamedRenderbufferParameterivEXT: TglGetNamedRenderbufferParameterivEXT; - glCheckNamedFramebufferStatusEXT: TglCheckNamedFramebufferStatusEXT; - glNamedFramebufferTexture1DEXT: TglNamedFramebufferTexture1DEXT; - glNamedFramebufferTexture2DEXT: TglNamedFramebufferTexture2DEXT; - glNamedFramebufferTexture3DEXT: TglNamedFramebufferTexture3DEXT; - glNamedFramebufferRenderbufferEXT: TglNamedFramebufferRenderbufferEXT; - glGetNamedFramebufferAttachmentParameterivEXT: TglGetNamedFramebufferAttachmentParameterivEXT; - glGenerateTextureMipmapEXT: TglGenerateTextureMipmapEXT; - glGenerateMultiTexMipmapEXT: TglGenerateMultiTexMipmapEXT; - glFramebufferDrawBufferEXT: TglFramebufferDrawBufferEXT; - glFramebufferDrawBuffersEXT: TglFramebufferDrawBuffersEXT; - glFramebufferReadBufferEXT: TglFramebufferReadBufferEXT; - glGetFramebufferParameterivEXT: TglGetFramebufferParameterivEXT; - glNamedRenderbufferStorageMultisampleEXT: TglNamedRenderbufferStorageMultisampleEXT; - glNamedRenderbufferStorageMultisampleCoverageEXT: TglNamedRenderbufferStorageMultisampleCoverageEXT; - glNamedFramebufferTextureEXT: TglNamedFramebufferTextureEXT; - glNamedFramebufferTextureLayerEXT: TglNamedFramebufferTextureLayerEXT; - glNamedFramebufferTextureFaceEXT: TglNamedFramebufferTextureFaceEXT; - glTextureRenderbufferEXT: TglTextureRenderbufferEXT; - glMultiTexRenderbufferEXT: TglMultiTexRenderbufferEXT; - glProgramUniform1dEXT: TglProgramUniform1dEXT; - glProgramUniform2dEXT: TglProgramUniform2dEXT; - glProgramUniform3dEXT: TglProgramUniform3dEXT; - glProgramUniform4dEXT: TglProgramUniform4dEXT; - glProgramUniform1dvEXT: TglProgramUniform1dvEXT; - glProgramUniform2dvEXT: TglProgramUniform2dvEXT; - glProgramUniform3dvEXT: TglProgramUniform3dvEXT; - glProgramUniform4dvEXT: TglProgramUniform4dvEXT; - glProgramUniformMatrix2dvEXT: TglProgramUniformMatrix2dvEXT; - glProgramUniformMatrix3dvEXT: TglProgramUniformMatrix3dvEXT; - glProgramUniformMatrix4dvEXT: TglProgramUniformMatrix4dvEXT; - glProgramUniformMatrix2x3dvEXT: TglProgramUniformMatrix2x3dvEXT; - glProgramUniformMatrix2x4dvEXT: TglProgramUniformMatrix2x4dvEXT; - glProgramUniformMatrix3x2dvEXT: TglProgramUniformMatrix3x2dvEXT; - glProgramUniformMatrix3x4dvEXT: TglProgramUniformMatrix3x4dvEXT; - glProgramUniformMatrix4x2dvEXT: TglProgramUniformMatrix4x2dvEXT; - glProgramUniformMatrix4x3dvEXT: TglProgramUniformMatrix4x3dvEXT; - - // GL_EXT_separate_shader_objects - glUseShaderProgramEXT: TglUseShaderProgramEXT; - glActiveProgramEXT: TglActiveProgramEXT; - glCreateShaderProgramEXT: TglCreateShaderProgramEXT; - - // GL_EXT_shader_image_load_store - glBindImageTextureEXT: TglBindImageTextureEXT; - glMemoryBarrierEXT: TglMemoryBarrierEXT; - - // GL_EXT_vertex_attrib_64bit - glVertexAttribL1dEXT: TglVertexAttribL1dEXT; - glVertexAttribL2dEXT: TglVertexAttribL2dEXT; - glVertexAttribL3dEXT: TglVertexAttribL3dEXT; - glVertexAttribL4dEXT: TglVertexAttribL4dEXT; - glVertexAttribL1dvEXT: TglVertexAttribL1dvEXT; - glVertexAttribL2dvEXT: TglVertexAttribL2dvEXT; - glVertexAttribL3dvEXT: TglVertexAttribL3dvEXT; - glVertexAttribL4dvEXT: TglVertexAttribL4dvEXT; - glVertexAttribLPointerEXT: TglVertexAttribLPointerEXT; - glGetVertexAttribLdvEXT: TglGetVertexAttribLdvEXT; - glVertexArrayVertexAttribLOffsetEXT: TglVertexArrayVertexAttribLOffsetEXT; - - // GL_HP_image_transform - glImageTransformParameteriHP: TglImageTransformParameteriHP; - glImageTransformParameterfHP: TglImageTransformParameterfHP; - glImageTransformParameterivHP: TglImageTransformParameterivHP; - glImageTransformParameterfvHP: TglImageTransformParameterfvHP; - glGetImageTransformParameterivHP: TglGetImageTransformParameterivHP; - glGetImageTransformParameterfvHP: TglGetImageTransformParameterfvHP; - - // GL_EXT_depth_bounds_test - glDepthBoundsEXT: TglDepthBoundsEXT; - - // GL_EXT_blend_equation_separate - glBlendEquationSeparateEXT: TglBlendEquationSeparateEXT; - - // GL_IBM_multimode_draw_arrays - glMultiModeDrawArraysIBM: TglMultiModeDrawArraysIBM; - glMultiModeDrawElementsIBM: TglMultiModeDrawElementsIBM; - - // GL_IBM_vertex_array_lists - glColorPointerListIBM: TglColorPointerListIBM; - glSecondaryColorPointerListIBM: TglSecondaryColorPointerListIBM; - glEdgeFlagPointerListIBM: TglEdgeFlagPointerListIBM; - glFogCoordPointerListIBM: TglFogCoordPointerListIBM; - glIndexPointerListIBM: TglIndexPointerListIBM; - glNormalPointerListIBM: TglNormalPointerListIBM; - glTexCoordPointerListIBM: TglTexCoordPointerListIBM; - glVertexPointerListIBM: TglVertexPointerListIBM; - - // GL_INGR_blend_func_separate - glBlendFuncSeparateINGR: TglBlendFuncSeparateINGR; - - // GL_INTEL_parallel_arrays - glVertexPointervINTEL: TglVertexPointervINTEL; - glNormalPointervINTEL: TglNormalPointervINTEL; - glColorPointervINTEL: TglColorPointervINTEL; - glTexCoordPointervINTEL: TglTexCoordPointervINTEL; - - // GL_MESA_resize_buffers - glResizeBuffersMESA: TglResizeBuffersMESA; - - // GL_MESA_window_pos - glWindowPos2dMESA: TglWindowPos2dMESA; - glWindowPos2dvMESA: TglWindowPos2dvMESA; - glWindowPos2fMESA: TglWindowPos2fMESA; - glWindowPos2fvMESA: TglWindowPos2fvMESA; - glWindowPos2iMESA: TglWindowPos2iMESA; - glWindowPos2ivMESA: TglWindowPos2ivMESA; - glWindowPos2sMESA: TglWindowPos2sMESA; - glWindowPos2svMESA: TglWindowPos2svMESA; - glWindowPos3dMESA: TglWindowPos3dMESA; - glWindowPos3dvMESA: TglWindowPos3dvMESA; - glWindowPos3fMESA: TglWindowPos3fMESA; - glWindowPos3fvMESA: TglWindowPos3fvMESA; - glWindowPos3iMESA: TglWindowPos3iMESA; - glWindowPos3ivMESA: TglWindowPos3ivMESA; - glWindowPos3sMESA: TglWindowPos3sMESA; - glWindowPos3svMESA: TglWindowPos3svMESA; - glWindowPos4dMESA: TglWindowPos4dMESA; - glWindowPos4dvMESA: TglWindowPos4dvMESA; - glWindowPos4fMESA: TglWindowPos4fMESA; - glWindowPos4fvMESA: TglWindowPos4fvMESA; - glWindowPos4iMESA: TglWindowPos4iMESA; - glWindowPos4ivMESA: TglWindowPos4ivMESA; - glWindowPos4sMESA: TglWindowPos4sMESA; - glWindowPos4svMESA: TglWindowPos4svMESA; - - // GL_NV_evaluators - glMapControlPointsNV: TglMapControlPointsNV; - glMapParameterivNV: TglMapParameterivNV; - glMapParameterfvNV: TglMapParameterfvNV; - glGetMapControlPointsNV: TglGetMapControlPointsNV; - glGetMapParameterivNV: TglGetMapParameterivNV; - glGetMapParameterfvNV: TglGetMapParameterfvNV; - glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV; - glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV; - glEvalMapsNV: TglEvalMapsNV; - - // GL_NV_fence - glDeleteFencesNV: TglDeleteFencesNV; - glGenFencesNV: TglGenFencesNV; - glIsFenceNV: TglIsFenceNV; - glTestFenceNV: TglTestFenceNV; - glGetFenceivNV: TglGetFenceivNV; - glFinishFenceNV: TglFinishFenceNV; - glSetFenceNV: TglSetFenceNV; - - // GL_NV_fragment_program - glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV; - glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV; - glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV; - glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV; - glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV; - glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV; - - // GL_NV_half_float - glVertex2hNV: TglVertex2hNV; - glVertex2hvNV: TglVertex2hvNV; - glVertex3hNV: TglVertex3hNV; - glVertex3hvNV: TglVertex3hvNV; - glVertex4hNV: TglVertex4hNV; - glVertex4hvNV: TglVertex4hvNV; - glNormal3hNV: TglNormal3hNV; - glNormal3hvNV: TglNormal3hvNV; - glColor3hNV: TglColor3hNV; - glColor3hvNV: TglColor3hvNV; - glColor4hNV: TglColor4hNV; - glColor4hvNV: TglColor4hvNV; - glTexCoord1hNV: TglTexCoord1hNV; - glTexCoord1hvNV: TglTexCoord1hvNV; - glTexCoord2hNV: TglTexCoord2hNV; - glTexCoord2hvNV: TglTexCoord2hvNV; - glTexCoord3hNV: TglTexCoord3hNV; - glTexCoord3hvNV: TglTexCoord3hvNV; - glTexCoord4hNV: TglTexCoord4hNV; - glTexCoord4hvNV: TglTexCoord4hvNV; - glMultiTexCoord1hNV: TglMultiTexCoord1hNV; - glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV; - glMultiTexCoord2hNV: TglMultiTexCoord2hNV; - glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV; - glMultiTexCoord3hNV: TglMultiTexCoord3hNV; - glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV; - glMultiTexCoord4hNV: TglMultiTexCoord4hNV; - glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV; - glFogCoordhNV: TglFogCoordhNV; - glFogCoordhvNV: TglFogCoordhvNV; - glSecondaryColor3hNV: TglSecondaryColor3hNV; - glSecondaryColor3hvNV: TglSecondaryColor3hvNV; - glVertexWeighthNV: TglVertexWeighthNV; - glVertexWeighthvNV: TglVertexWeighthvNV; - glVertexAttrib1hNV: TglVertexAttrib1hNV; - glVertexAttrib1hvNV: TglVertexAttrib1hvNV; - glVertexAttrib2hNV: TglVertexAttrib2hNV; - glVertexAttrib2hvNV: TglVertexAttrib2hvNV; - glVertexAttrib3hNV: TglVertexAttrib3hNV; - glVertexAttrib3hvNV: TglVertexAttrib3hvNV; - glVertexAttrib4hNV: TglVertexAttrib4hNV; - glVertexAttrib4hvNV: TglVertexAttrib4hvNV; - glVertexAttribs1hvNV: TglVertexAttribs1hvNV; - glVertexAttribs2hvNV: TglVertexAttribs2hvNV; - glVertexAttribs3hvNV: TglVertexAttribs3hvNV; - glVertexAttribs4hvNV: TglVertexAttribs4hvNV; - - // GL_NV_occlusion_query - glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV; - glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV; - glIsOcclusionQueryNV: TglIsOcclusionQueryNV; - glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV; - glEndOcclusionQueryNV: TglEndOcclusionQueryNV; - glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV; - glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV; - - // GL_NV_pixel_data_range - glPixelDataRangeNV: TglPixelDataRangeNV; - glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV; - - // GL_NV_point_sprite - glPointParameteriNV: TglPointParameteriNV; - glPointParameterivNV: TglPointParameterivNV; - - // GL_NV_primitive_restart - glPrimitiveRestartNV: TglPrimitiveRestartNV; - glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV; - - // GL_NV_register_combiners - glCombinerParameterfvNV: TglCombinerParameterfvNV; - glCombinerParameterfNV: TglCombinerParameterfNV; - glCombinerParameterivNV: TglCombinerParameterivNV; - glCombinerParameteriNV: TglCombinerParameteriNV; - glCombinerInputNV: TglCombinerInputNV; - glCombinerOutputNV: TglCombinerOutputNV; - glFinalCombinerInputNV: TglFinalCombinerInputNV; - glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV; - glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV; - glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV; - glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV; - glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV; - glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV; - - // GL_NV_register_combiners2 - glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV; - glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV; - - // GL_NV_vertex_array_range - glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV; - glVertexArrayRangeNV: TglVertexArrayRangeNV; - - // GL_NV_vertex_program - glAreProgramsResidentNV: TglAreProgramsResidentNV; - glBindProgramNV: TglBindProgramNV; - glDeleteProgramsNV: TglDeleteProgramsNV; - glExecuteProgramNV: TglExecuteProgramNV; - glGenProgramsNV: TglGenProgramsNV; - glGetProgramParameterdvNV: TglGetProgramParameterdvNV; - glGetProgramParameterfvNV: TglGetProgramParameterfvNV; - glGetProgramivNV: TglGetProgramivNV; - glGetProgramStringNV: TglGetProgramStringNV; - glGetTrackMatrixivNV: TglGetTrackMatrixivNV; - glGetVertexAttribdvNV: TglGetVertexAttribdvNV; - glGetVertexAttribfvNV: TglGetVertexAttribfvNV; - glGetVertexAttribivNV: TglGetVertexAttribivNV; - glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV; - glIsProgramNV: TglIsProgramNV; - glLoadProgramNV: TglLoadProgramNV; - glProgramParameter4dNV: TglProgramParameter4dNV; - glProgramParameter4dvNV: TglProgramParameter4dvNV; - glProgramParameter4fNV: TglProgramParameter4fNV; - glProgramParameter4fvNV: TglProgramParameter4fvNV; - glProgramParameters4dvNV: TglProgramParameters4dvNV; - glProgramParameters4fvNV: TglProgramParameters4fvNV; - glRequestResidentProgramsNV: TglRequestResidentProgramsNV; - glTrackMatrixNV: TglTrackMatrixNV; - glVertexAttribPointerNV: TglVertexAttribPointerNV; - glVertexAttrib1dNV: TglVertexAttrib1dNV; - glVertexAttrib1dvNV: TglVertexAttrib1dvNV; - glVertexAttrib1fNV: TglVertexAttrib1fNV; - glVertexAttrib1fvNV: TglVertexAttrib1fvNV; - glVertexAttrib1sNV: TglVertexAttrib1sNV; - glVertexAttrib1svNV: TglVertexAttrib1svNV; - glVertexAttrib2dNV: TglVertexAttrib2dNV; - glVertexAttrib2dvNV: TglVertexAttrib2dvNV; - glVertexAttrib2fNV: TglVertexAttrib2fNV; - glVertexAttrib2fvNV: TglVertexAttrib2fvNV; - glVertexAttrib2sNV: TglVertexAttrib2sNV; - glVertexAttrib2svNV: TglVertexAttrib2svNV; - glVertexAttrib3dNV: TglVertexAttrib3dNV; - glVertexAttrib3dvNV: TglVertexAttrib3dvNV; - glVertexAttrib3fNV: TglVertexAttrib3fNV; - glVertexAttrib3fvNV: TglVertexAttrib3fvNV; - glVertexAttrib3sNV: TglVertexAttrib3sNV; - glVertexAttrib3svNV: TglVertexAttrib3svNV; - glVertexAttrib4dNV: TglVertexAttrib4dNV; - glVertexAttrib4dvNV: TglVertexAttrib4dvNV; - glVertexAttrib4fNV: TglVertexAttrib4fNV; - glVertexAttrib4fvNV: TglVertexAttrib4fvNV; - glVertexAttrib4sNV: TglVertexAttrib4sNV; - glVertexAttrib4svNV: TglVertexAttrib4svNV; - glVertexAttrib4ubNV: TglVertexAttrib4ubNV; - glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV; - glVertexAttribs1dvNV: TglVertexAttribs1dvNV; - glVertexAttribs1fvNV: TglVertexAttribs1fvNV; - glVertexAttribs1svNV: TglVertexAttribs1svNV; - glVertexAttribs2dvNV: TglVertexAttribs2dvNV; - glVertexAttribs2fvNV: TglVertexAttribs2fvNV; - glVertexAttribs2svNV: TglVertexAttribs2svNV; - glVertexAttribs3dvNV: TglVertexAttribs3dvNV; - glVertexAttribs3fvNV: TglVertexAttribs3fvNV; - glVertexAttribs3svNV: TglVertexAttribs3svNV; - glVertexAttribs4dvNV: TglVertexAttribs4dvNV; - glVertexAttribs4fvNV: TglVertexAttribs4fvNV; - glVertexAttribs4svNV: TglVertexAttribs4svNV; - glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV; - - // GL_NV_depth_buffer_float - glDepthRangedNV: TglDepthRangedNV; - glClearDepthdNV: TglClearDepthdNV; - glDepthBoundsdNV: TglDepthBoundsdNV; - - // GL_NV_framebuffer_multisample_coverage - glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV; - - // GL_NV_geometry_program4 - glProgramVertexLimitNV: TglProgramVertexLimitNV; - - // GL_NV_gpu_program4 - glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV; - glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV; - glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV; - glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV; - glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV; - glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV; - glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV; - glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV; - glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV; - glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV; - glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV; - glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV; - glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV; - glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV; - glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV; - glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV; - - // GL_NV_parameter_buffer_object - glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV; - glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV; - glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV; - - // GL_NV_transform_feedback - glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV; - glEndTransformFeedbackNV: TglEndTransformFeedbackNV; - glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV; - glBindBufferRangeNV: TglBindBufferRangeNV; - glBindBufferOffsetNV: TglBindBufferOffsetNV; - glBindBufferBaseNV: TglBindBufferBaseNV; - glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV; - glActiveVaryingNV: TglActiveVaryingNV; - glGetVaryingLocationNV: TglGetVaryingLocationNV; - glGetActiveVaryingNV: TglGetActiveVaryingNV; - glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV; - glTransformFeedbackStreamAttribsNV: TglTransformFeedbackStreamAttribsNV; - - // GL_NV_conditional_render - glBeginConditionalRenderNV: TglBeginConditionalRenderNV; - glEndConditionalRenderNV: TglEndConditionalRenderNV; - - // GL_NV_present_video - glPresentFrameKeyedNV: TglPresentFrameKeyedNV; - glPresentFrameDualFillNV: TglPresentFrameDualFillNV; - glGetVideoivNV: TglGetVideoivNV; - glGetVideouivNV: TglGetVideouivNV; - glGetVideoi64vNV: TglGetVideoi64vNV; - glGetVideoui64vNV: TglGetVideoui64vNV; -// glVideoParameterivNV: TglVideoParameterivNV; - - // GL_NV_explicit_multisample - glGetMultisamplefvNV: TglGetMultisamplefvNV; - glSampleMaskIndexedNV: TglSampleMaskIndexedNV; - glTexRenderbufferNV: TglTexRenderbufferNV; - - // GL_NV_transform_feedback2 - glBindTransformFeedbackNV: TglBindTransformFeedbackNV; - glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV; - glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV; - glIsTransformFeedbackNV: TglIsTransformFeedbackNV; - glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV; - glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV; - glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV; - - // GL_NV_video_capture - glBeginVideoCaptureNV: TglBeginVideoCaptureNV; - glBindVideoCaptureStreamBufferNV: TglBindVideoCaptureStreamBufferNV; - glBindVideoCaptureStreamTextureNV: TglBindVideoCaptureStreamTextureNV; - glEndVideoCaptureNV: TglEndVideoCaptureNV; - glGetVideoCaptureivNV: TglGetVideoCaptureivNV; - glGetVideoCaptureStreamivNV: TglGetVideoCaptureStreamivNV; - glGetVideoCaptureStreamfvNV: TglGetVideoCaptureStreamfvNV; - glGetVideoCaptureStreamdvNV: TglGetVideoCaptureStreamdvNV; - glVideoCaptureNV: TglVideoCaptureNV; - glVideoCaptureStreamParameterivNV: TglVideoCaptureStreamParameterivNV; - glVideoCaptureStreamParameterfvNV: TglVideoCaptureStreamParameterfvNV; - glVideoCaptureStreamParameterdvNV: TglVideoCaptureStreamParameterdvNV; - - // GL_NV_copy_image - glCopyImageSubDataNV: TglCopyImageSubDataNV; - - // GL_NV_shader_buffer_load - glMakeBufferResidentNV: TglMakeBufferResidentNV; - glMakeBufferNonResidentNV: TglMakeBufferNonResidentNV; - glIsBufferResidentNV: TglIsBufferResidentNV; - glMakeNamedBufferResidentNV: TglMakeNamedBufferResidentNV; - glMakeNamedBufferNonResidentNV: TglMakeNamedBufferNonResidentNV; - glIsNamedBufferResidentNV: TglIsNamedBufferResidentNV; - glGetBufferParameterui64vNV: TglGetBufferParameterui64vNV; - glGetNamedBufferParameterui64vNV: TglGetNamedBufferParameterui64vNV; - glGetIntegerui64vNV: TglGetIntegerui64vNV; - glUniformui64NV: TglUniformui64NV; - glUniformui64vNV: TglUniformui64vNV; - glGetUniformui64vNV: TglGetUniformui64vNV; - glProgramUniformui64NV: TglProgramUniformui64NV; - glProgramUniformui64vNV: TglProgramUniformui64vNV; - - // GL_NV_vertex_buffer_unified_memory - glBufferAddressRangeNV: TglBufferAddressRangeNV; - glVertexFormatNV: TglVertexFormatNV; - glNormalFormatNV: TglNormalFormatNV; - glColorFormatNV: TglColorFormatNV; - glIndexFormatNV: TglIndexFormatNV; - glTexCoordFormatNV: TglTexCoordFormatNV; - glEdgeFlagFormatNV: TglEdgeFlagFormatNV; - glSecondaryColorFormatNV: TglSecondaryColorFormatNV; - glFogCoordFormatNV: TglFogCoordFormatNV; - glVertexAttribFormatNV: TglVertexAttribFormatNV; - glVertexAttribIFormatNV: TglVertexAttribIFormatNV; - glGetIntegerui64i_vNV: TglGetIntegerui64i_vNV; - - // GL_NV_gpu_program5 - glProgramSubroutineParametersuivNV: TglProgramSubroutineParametersuivNV; - glGetProgramSubroutineParameteruivNV: TglGetProgramSubroutineParameteruivNV; - - // GL_NV_gpu_shader5 - glUniform1i64NV: TglUniform1i64NV; - glUniform2i64NV: TglUniform2i64NV; - glUniform3i64NV: TglUniform3i64NV; - glUniform4i64NV: TglUniform4i64NV; - glUniform1i64vNV: TglUniform1i64vNV; - glUniform2i64vNV: TglUniform2i64vNV; - glUniform3i64vNV: TglUniform3i64vNV; - glUniform4i64vNV: TglUniform4i64vNV; - glUniform1ui64NV: TglUniform1ui64NV; - glUniform2ui64NV: TglUniform2ui64NV; - glUniform3ui64NV: TglUniform3ui64NV; - glUniform4ui64NV: TglUniform4ui64NV; - glUniform1ui64vNV: TglUniform1ui64vNV; - glUniform2ui64vNV: TglUniform2ui64vNV; - glUniform3ui64vNV: TglUniform3ui64vNV; - glUniform4ui64vNV: TglUniform4ui64vNV; - glGetUniformi64vNV: TglGetUniformi64vNV; - glProgramUniform1i64NV: TglProgramUniform1i64NV; - glProgramUniform2i64NV: TglProgramUniform2i64NV; - glProgramUniform3i64NV: TglProgramUniform3i64NV; - glProgramUniform4i64NV: TglProgramUniform4i64NV; - glProgramUniform1i64vNV: TglProgramUniform1i64vNV; - glProgramUniform2i64vNV: TglProgramUniform2i64vNV; - glProgramUniform3i64vNV: TglProgramUniform3i64vNV; - glProgramUniform4i64vNV: TglProgramUniform4i64vNV; - glProgramUniform1ui64NV: TglProgramUniform1ui64NV; - glProgramUniform2ui64NV: TglProgramUniform2ui64NV; - glProgramUniform3ui64NV: TglProgramUniform3ui64NV; - glProgramUniform4ui64NV: TglProgramUniform4ui64NV; - glProgramUniform1ui64vNV: TglProgramUniform1ui64vNV; - glProgramUniform2ui64vNV: TglProgramUniform2ui64vNV; - glProgramUniform3ui64vNV: TglProgramUniform3ui64vNV; - glProgramUniform4ui64vNV: TglProgramUniform4ui64vNV; - - // GL_NV_vertex_attrib_integer_64bit - glVertexAttribL1i64NV: TglVertexAttribL1i64NV; - glVertexAttribL2i64NV: TglVertexAttribL2i64NV; - glVertexAttribL3i64NV: TglVertexAttribL3i64NV; - glVertexAttribL4i64NV: TglVertexAttribL4i64NV; - glVertexAttribL1i64vNV: TglVertexAttribL1i64vNV; - glVertexAttribL2i64vNV: TglVertexAttribL2i64vNV; - glVertexAttribL3i64vNV: TglVertexAttribL3i64vNV; - glVertexAttribL4i64vNV: TglVertexAttribL4i64vNV; - glVertexAttribL1ui64NV: TglVertexAttribL1ui64NV; - glVertexAttribL2ui64NV: TglVertexAttribL2ui64NV; - glVertexAttribL3ui64NV: TglVertexAttribL3ui64NV; - glVertexAttribL4ui64NV: TglVertexAttribL4ui64NV; - glVertexAttribL1ui64vNV: TglVertexAttribL1ui64vNV; - glVertexAttribL2ui64vNV: TglVertexAttribL2ui64vNV; - glVertexAttribL3ui64vNV: TglVertexAttribL3ui64vNV; - glVertexAttribL4ui64vNV: TglVertexAttribL4ui64vNV; - glGetVertexAttribLi64vNV: TglGetVertexAttribLi64vNV; - glGetVertexAttribLui64vNV: TglGetVertexAttribLui64vNV; - glVertexAttribLFormatNV: TglVertexAttribLFormatNV; - - // GL_NV_vdpau_interop - glVDPAUInitNV: TglVDPAUInitNV; - glVDPAUFiniNV: TglVDPAUFiniNV; - glVDPAURegisterVideoSurfaceNV: TglVDPAURegisterVideoSurfaceNV; - glVDPAURegisterOutputSurfaceNV: TglVDPAURegisterOutputSurfaceNV; - glVDPAUIsSurfaceNV: TglVDPAUIsSurfaceNV; - glVDPAUUnregisterSurfaceNV: TglVDPAUUnregisterSurfaceNV; - glVDPAUGetSurfaceivNV: TglVDPAUGetSurfaceivNV; - glVDPAUSurfaceAccessNV: TglVDPAUSurfaceAccessNV; - glVDPAUMapSurfacesNV: TglVDPAUMapSurfacesNV; - glVDPAUUnmapSurfacesNV: TglVDPAUUnmapSurfacesNV; - - // GL_NV_texture_barrier - glTextureBarrierNV: TglTextureBarrierNV; - - // (4.3) GL_NV_path_rendering - glGenPathsNV : TglGenPathsNV; - glDeletePathsNV : TglDeletePathsNV; - glIsPathNV : TglIsPathNV; - glPathCommandsNV : TglPathCommandsNV; - glPathCoordsNV : TglPathCoordsNV; - glPathSubCommandsNV : TglPathSubCommandsNV; - glPathSubCoordsNV : TglPathSubCoordsNV; - glPathStringNV : TglPathStringNV; - glPathGlyphsNV : TglPathGlyphsNV; - glPathGlyphRangeNV : TglPathGlyphRangeNV; - glWeightPathsNV : TglWeightPathsNV; - glCopyPathNV : TglCopyPathNV; - glInterpolatePathsNV : TglInterpolatePathsNV; - glTransformPathNV : TglTransformPathNV; - glPathParameterivNV : TglPathParameterivNV; - glPathParameteriNV : TglPathParameteriNV; - glPathParameterfvNV : TglPathParameterfvNV; - glPathParameterfNV : TglPathParameterfNV; - glPathDashArrayNV : TglPathDashArrayNV; - glPathStencilFuncNV : TglPathStencilFuncNV; - glPathStencilDepthOffsetNV : TglPathStencilDepthOffsetNV; - glStencilFillPathNV : TglStencilFillPathNV; - glStencilStrokePathNV : TglStencilStrokePathNV; - glStencilFillPathInstancedNV : TglStencilFillPathInstancedNV; - glStencilStrokePathInstancedNV : TglStencilStrokePathInstancedNV; - glPathCoverDepthFuncNV : TglPathCoverDepthFuncNV; - glPathColorGenNV : TglPathColorGenNV; - glPathTexGenNV : TglPathTexGenNV; - glPathFogGenNV : TglPathFogGenNV; - glCoverFillPathNV : TglCoverFillPathNV; - glCoverStrokePathNV : TglCoverStrokePathNV; - glCoverFillPathInstancedNV : TglCoverFillPathInstancedNV; - glCoverStrokePathInstancedNV : TglCoverStrokePathInstancedNV; - glGetPathParameterivNV : TglGetPathParameterivNV; - glGetPathParameterfvNV : TglGetPathParameterfvNV; - glGetPathCommandsNV : TglGetPathCommandsNV; - glGetPathCoordsNV : TglGetPathCoordsNV; - glGetPathDashArrayNV : TglGetPathDashArrayNV; - glGetPathMetricsNV : TglGetPathMetricsNV; - glGetPathMetricRangeNV : TglGetPathMetricRangeNV; - glGetPathSpacingNV : TglGetPathSpacingNV; - glGetPathColorGenivNV : TglGetPathColorGenivNV; - glGetPathColorGenfvNV : TglGetPathColorGenfvNV; - glGetPathTexGenivNV : TglGetPathTexGenivNV; - glGetPathTexGenfvNV : TglGetPathTexGenfvNV; - glIsPointInFillPathNV : TglIsPointInFillPathNV; - glIsPointInStrokePathNV : TglIsPointInStrokePathNV; - glGetPathLengthNV : TglGetPathLengthNV; - glPointAlongPathNV : TglPointAlongPathNV; - - // GL_AMD_pinned_memory - - // GL_AMD_stencil_operation_extended - glStencilOpValueAMD : TglStencilOpValueAMD; - - // GL_AMD_vertex_shader_viewport_index - - // GL_AMD_vertex_shader_layer - - // GL_NV_bindless_texture - glGetTextureHandleNV : TglGetTextureHandleNV; - glGetTextureSamplerHandleNV : TglGetTextureSamplerHandleNV; - glMakeTextureHandleResidentNV : TglMakeTextureHandleResidentNV; - glMakeTextureHandleNonResidentNV : TglMakeTextureHandleNonResidentNV; - glGetImageHandleNV : TglGetImageHandleNV; - glMakeImageHandleResidentNV : TglMakeImageHandleResidentNV; - glMakeImageHandleNonResidentNV : TglMakeImageHandleNonResidentNV; - glUniformHandleui64NV : TglUniformHandleui64NV; - glUniformHandleui64vNV : TglUniformHandleui64vNV; - glProgramUniformHandleui64NV : TglProgramUniformHandleui64NV; - glProgramUniformHandleui64vNV : TglProgramUniformHandleui64vNV; - glIsTextureHandleResidentNV : TglIsTextureHandleResidentNV; - glIsImageHandleResidentNV : TglIsImageHandleResidentNV; - - // - - // GL_PGI_misc_hints - glHintPGI: TglHintPGI; - - // GL_SGIS_detail_texture - glDetailTexFuncSGIS: TglDetailTexFuncSGIS; - glGetDetailTexFuncSGIS: TglGetDetailTexFuncSGIS; - - // GL_SGIS_fog_function - glFogFuncSGIS: TglFogFuncSGIS; - glGetFogFuncSGIS: TglGetFogFuncSGIS; - - // GL_SGIS_multisample - glSampleMaskSGIS: TglSampleMaskSGIS; - glSamplePatternSGIS: TglSamplePatternSGIS; - - // GL_SGIS_pixel_texture - glPixelTexGenParameteriSGIS: TglPixelTexGenParameteriSGIS; - glPixelTexGenParameterivSGIS: TglPixelTexGenParameterivSGIS; - glPixelTexGenParameterfSGIS: TglPixelTexGenParameterfSGIS; - glPixelTexGenParameterfvSGIS: TglPixelTexGenParameterfvSGIS; - glGetPixelTexGenParameterivSGIS: TglGetPixelTexGenParameterivSGIS; - glGetPixelTexGenParameterfvSGIS: TglGetPixelTexGenParameterfvSGIS; - - // GL_SGIS_point_parameters - glPointParameterfSGIS: TglPointParameterfSGIS; - glPointParameterfvSGIS: TglPointParameterfvSGIS; - - // GL_SGIS_sharpen_texture - glSharpenTexFuncSGIS: TglSharpenTexFuncSGIS; - glGetSharpenTexFuncSGIS: TglGetSharpenTexFuncSGIS; - - // GL_SGIS_texture4D - glTexImage4DSGIS: TglTexImage4DSGIS; - glTexSubImage4DSGIS: TglTexSubImage4DSGIS; - - // GL_SGIS_texture_color_mask - glTextureColorMaskSGIS: TglTextureColorMaskSGIS; - - // GL_SGIS_texture_filter4 - glGetTexFilterFuncSGIS: TglGetTexFilterFuncSGIS; - glTexFilterFuncSGIS: TglTexFilterFuncSGIS; - - // GL_SGIX_async - glAsyncMarkerSGIX: TglAsyncMarkerSGIX; - glFinishAsyncSGIX: TglFinishAsyncSGIX; - glPollAsyncSGIX: TglPollAsyncSGIX; - glGenAsyncMarkersSGIX: TglGenAsyncMarkersSGIX; - glDeleteAsyncMarkersSGIX: TglDeleteAsyncMarkersSGIX; - glIsAsyncMarkerSGIX: TglIsAsyncMarkerSGIX; - - // GL_SGIX_flush_raster - glFlushRasterSGIX: TglFlushRasterSGIX; - - // GL_SGIX_fragment_lighting - glFragmentColorMaterialSGIX: TglFragmentColorMaterialSGIX; - glFragmentLightfSGIX: TglFragmentLightfSGIX; - glFragmentLightfvSGIX: TglFragmentLightfvSGIX; - glFragmentLightiSGIX: TglFragmentLightiSGIX; - glFragmentLightivSGIX: TglFragmentLightivSGIX; - glFragmentLightModelfSGIX: TglFragmentLightModelfSGIX; - glFragmentLightModelfvSGIX: TglFragmentLightModelfvSGIX; - glFragmentLightModeliSGIX: TglFragmentLightModeliSGIX; - glFragmentLightModelivSGIX: TglFragmentLightModelivSGIX; - glFragmentMaterialfSGIX: TglFragmentMaterialfSGIX; - glFragmentMaterialfvSGIX: TglFragmentMaterialfvSGIX; - glFragmentMaterialiSGIX: TglFragmentMaterialiSGIX; - glFragmentMaterialivSGIX: TglFragmentMaterialivSGIX; - glGetFragmentLightfvSGIX: TglGetFragmentLightfvSGIX; - glGetFragmentLightivSGIX: TglGetFragmentLightivSGIX; - glGetFragmentMaterialfvSGIX: TglGetFragmentMaterialfvSGIX; - glGetFragmentMaterialivSGIX: TglGetFragmentMaterialivSGIX; - glLightEnviSGIX: TglLightEnviSGIX; - - // GL_SGIX_framezoom - glFrameZoomSGIX: TglFrameZoomSGIX; - - // GL_SGIX_igloo_interface - glIglooInterfaceSGIX: TglIglooInterfaceSGIX; - - // GL_SGIX_instruments - glGetInstrumentsSGIX: TglGetInstrumentsSGIX; - glInstrumentsBufferSGIX: TglInstrumentsBufferSGIX; - glPollInstrumentsSGIX: TglPollInstrumentsSGIX; - glReadInstrumentsSGIX: TglReadInstrumentsSGIX; - glStartInstrumentsSGIX: TglStartInstrumentsSGIX; - glStopInstrumentsSGIX: TglStopInstrumentsSGIX; - - // GL_SGIX_list_priority - glGetListParameterfvSGIX: TglGetListParameterfvSGIX; - glGetListParameterivSGIX: TglGetListParameterivSGIX; - glListParameterfSGIX: TglListParameterfSGIX; - glListParameterfvSGIX: TglListParameterfvSGIX; - glListParameteriSGIX: TglListParameteriSGIX; - glListParameterivSGIX: TglListParameterivSGIX; - - // GL_SGIX_pixel_texture - glPixelTexGenSGIX: TglPixelTexGenSGIX; - - // GL_SGIX_polynomial_ffd - glDeformationMap3dSGIX: TglDeformationMap3dSGIX; - glDeformationMap3fSGIX: TglDeformationMap3fSGIX; - glDeformSGIX: TglDeformSGIX; - glLoadIdentityDeformationMapSGIX: TglLoadIdentityDeformationMapSGIX; - - // GL_SGIX_reference_plane - glReferencePlaneSGIX: TglReferencePlaneSGIX; - - // GL_SGIX_sprite - glSpriteParameterfSGIX: TglSpriteParameterfSGIX; - glSpriteParameterfvSGIX: TglSpriteParameterfvSGIX; - glSpriteParameteriSGIX: TglSpriteParameteriSGIX; - glSpriteParameterivSGIX: TglSpriteParameterivSGIX; - - // GL_SGIX_tag_sample_buffer - glTagSampleBufferSGIX: TglTagSampleBufferSGIX; - - // GL_SGI_color_table - glColorTableSGI: TglColorTableSGI; - glColorTableParameterfvSGI: TglColorTableParameterfvSGI; - glColorTableParameterivSGI: TglColorTableParameterivSGI; - glCopyColorTableSGI: TglCopyColorTableSGI; - glGetColorTableSGI: TglGetColorTableSGI; - glGetColorTableParameterfvSGI: TglGetColorTableParameterfvSGI; - glGetColorTableParameterivSGI: TglGetColorTableParameterivSGI; - - // GL_SUNX_constant_data - glFinishTextureSUNX: TglFinishTextureSUNX; - - // GL_SUN_global_alpha - glGlobalAlphaFactorbSUN: TglGlobalAlphaFactorbSUN; - glGlobalAlphaFactorsSUN: TglGlobalAlphaFactorsSUN; - glGlobalAlphaFactoriSUN: TglGlobalAlphaFactoriSUN; - glGlobalAlphaFactorfSUN: TglGlobalAlphaFactorfSUN; - glGlobalAlphaFactordSUN: TglGlobalAlphaFactordSUN; - glGlobalAlphaFactorubSUN: TglGlobalAlphaFactorubSUN; - glGlobalAlphaFactorusSUN: TglGlobalAlphaFactorusSUN; - glGlobalAlphaFactoruiSUN: TglGlobalAlphaFactoruiSUN; - - // GL_SUN_mesh_array - glDrawMeshArraysSUN: TglDrawMeshArraysSUN; - - // GL_SUN_triangle_list - glReplacementCodeuiSUN: TglReplacementCodeuiSUN; - glReplacementCodeusSUN: TglReplacementCodeusSUN; - glReplacementCodeubSUN: TglReplacementCodeubSUN; - glReplacementCodeuivSUN: TglReplacementCodeuivSUN; - glReplacementCodeusvSUN: TglReplacementCodeusvSUN; - glReplacementCodeubvSUN: TglReplacementCodeubvSUN; - glReplacementCodePointerSUN: TglReplacementCodePointerSUN; - - // GL_SUN_vertex - glColor4ubVertex2fSUN: TglColor4ubVertex2fSUN; - glColor4ubVertex2fvSUN: TglColor4ubVertex2fvSUN; - glColor4ubVertex3fSUN: TglColor4ubVertex3fSUN; - glColor4ubVertex3fvSUN: TglColor4ubVertex3fvSUN; - glColor3fVertex3fSUN: TglColor3fVertex3fSUN; - glColor3fVertex3fvSUN: TglColor3fVertex3fvSUN; - glNormal3fVertex3fSUN: TglNormal3fVertex3fSUN; - glNormal3fVertex3fvSUN: TglNormal3fVertex3fvSUN; - glColor4fNormal3fVertex3fSUN: TglColor4fNormal3fVertex3fSUN; - glColor4fNormal3fVertex3fvSUN: TglColor4fNormal3fVertex3fvSUN; - glTexCoord2fVertex3fSUN: TglTexCoord2fVertex3fSUN; - glTexCoord2fVertex3fvSUN: TglTexCoord2fVertex3fvSUN; - glTexCoord4fVertex4fSUN: TglTexCoord4fVertex4fSUN; - glTexCoord4fVertex4fvSUN: TglTexCoord4fVertex4fvSUN; - glTexCoord2fColor4ubVertex3fSUN: TglTexCoord2fColor4ubVertex3fSUN; - glTexCoord2fColor4ubVertex3fvSUN: TglTexCoord2fColor4ubVertex3fvSUN; - glTexCoord2fColor3fVertex3fSUN: TglTexCoord2fColor3fVertex3fSUN; - glTexCoord2fColor3fVertex3fvSUN: TglTexCoord2fColor3fVertex3fvSUN; - glTexCoord2fNormal3fVertex3fSUN: TglTexCoord2fNormal3fVertex3fSUN; - glTexCoord2fNormal3fVertex3fvSUN: TglTexCoord2fNormal3fVertex3fvSUN; - glTexCoord2fColor4fNormal3fVertex3fSUN: TglTexCoord2fColor4fNormal3fVertex3fSUN; - glTexCoord2fColor4fNormal3fVertex3fvSUN: TglTexCoord2fColor4fNormal3fVertex3fvSUN; - glTexCoord4fColor4fNormal3fVertex4fSUN: TglTexCoord4fColor4fNormal3fVertex4fSUN; - glTexCoord4fColor4fNormal3fVertex4fvSUN: TglTexCoord4fColor4fNormal3fVertex4fvSUN; - glReplacementCodeuiVertex3fSUN: TglReplacementCodeuiVertex3fSUN; - glReplacementCodeuiVertex3fvSUN: TglReplacementCodeuiVertex3fvSUN; - glReplacementCodeuiColor4ubVertex3fSUN: TglReplacementCodeuiColor4ubVertex3fSUN; - glReplacementCodeuiColor4ubVertex3fvSUN: TglReplacementCodeuiColor4ubVertex3fvSUN; - glReplacementCodeuiColor3fVertex3fSUN: TglReplacementCodeuiColor3fVertex3fSUN; - glReplacementCodeuiColor3fVertex3fvSUN: TglReplacementCodeuiColor3fVertex3fvSUN; - glReplacementCodeuiNormal3fVertex3fSUN: TglReplacementCodeuiNormal3fVertex3fSUN; - glReplacementCodeuiNormal3fVertex3fvSUN: TglReplacementCodeuiNormal3fVertex3fvSUN; - glReplacementCodeuiColor4fNormal3fVertex3fSUN: TglReplacementCodeuiColor4fNormal3fVertex3fSUN; - glReplacementCodeuiColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiColor4fNormal3fVertex3fvSUN; - glReplacementCodeuiTexCoord2fVertex3fSUN: TglReplacementCodeuiTexCoord2fVertex3fSUN; - glReplacementCodeuiTexCoord2fVertex3fvSUN: TglReplacementCodeuiTexCoord2fVertex3fvSUN; - glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; - glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; - -{$IFDEF DGL_WIN} - wglGetProcAddress: TwglGetProcAddress; - wglCopyContext: TwglCopyContext; - wglCreateContext: TwglCreateContext; - wglCreateLayerContext: TwglCreateLayerContext; - wglDeleteContext: TwglDeleteContext; - wglDescribeLayerPlane: TwglDescribeLayerPlane; - wglGetCurrentContext: TwglGetCurrentContext; - wglGetCurrentDC: TwglGetCurrentDC; - wglGetLayerPaletteEntries: TwglGetLayerPaletteEntries; - wglMakeCurrent: TwglMakeCurrent; - wglRealizeLayerPalette: TwglRealizeLayerPalette; - wglSetLayerPaletteEntries: TwglSetLayerPaletteEntries; - wglShareLists: TwglShareLists; - wglSwapLayerBuffers: TwglSwapLayerBuffers; - wglSwapMultipleBuffers: TwglSwapMultipleBuffers; - wglUseFontBitmapsA: TwglUseFontBitmapsA; - wglUseFontOutlinesA: TwglUseFontOutlinesA; - wglUseFontBitmapsW: TwglUseFontBitmapsW; - wglUseFontOutlinesW: TwglUseFontOutlinesW; - wglUseFontBitmaps: TwglUseFontBitmaps; - wglUseFontOutlines: TwglUseFontOutlines; - - // WGL_ARB_buffer_region - wglCreateBufferRegionARB: TwglCreateBufferRegionARB; - wglDeleteBufferRegionARB: TwglDeleteBufferRegionARB; - wglSaveBufferRegionARB: TwglSaveBufferRegionARB; - wglRestoreBufferRegionARB: TwglRestoreBufferRegionARB; - - // WGL_ARB_extensions_string - wglGetExtensionsStringARB: TwglGetExtensionsStringARB; - - // WGL_ARB_make_current_read - wglMakeContextCurrentARB: TwglMakeContextCurrentARB; - wglGetCurrentReadDCARB: TwglGetCurrentReadDCARB; - - // WGL_ARB_pbuffer - wglCreatePbufferARB: TwglCreatePbufferARB; - wglGetPbufferDCARB: TwglGetPbufferDCARB; - wglReleasePbufferDCARB: TwglReleasePbufferDCARB; - wglDestroyPbufferARB: TwglDestroyPbufferARB; - wglQueryPbufferARB: TwglQueryPbufferARB; - - // WGL_ARB_pixel_format - wglGetPixelFormatAttribivARB: TwglGetPixelFormatAttribivARB; - wglGetPixelFormatAttribfvARB: TwglGetPixelFormatAttribfvARB; - wglChoosePixelFormatARB: TwglChoosePixelFormatARB; - // WGL_ARB_color_buffer_float - wglClampColorARB: TwglClampColorARB; - - // WGL_ARB_render_texture - wglBindTexImageARB: TwglBindTexImageARB; - wglReleaseTexImageARB: TwglReleaseTexImageARB; - wglSetPbufferAttribARB: TwglSetPbufferAttribARB; - - // WGL_ARB_create_context - wglCreateContextAttribsARB: TwglCreateContextAttribsARB; - - // WGL_AMD_gpu_association - wglGetGPUIDsAMD: TwglGetGPUIDsAMD; - wglGetGPUInfoAMD: TwglGetGPUInfoAMD; - wglGetContextGPUIDAMD: TwglGetContextGPUIDAMD; - wglCreateAssociatedContextAMD: TwglCreateAssociatedContextAMD; - wglCreateAssociatedContextAttribsAMD: TwglCreateAssociatedContextAttribsAMD; - wglDeleteAssociatedContextAMD: TwglDeleteAssociatedContextAMD; - wglMakeAssociatedContextCurrentAMD: TwglMakeAssociatedContextCurrentAMD; - wglGetCurrentAssociatedContextAMD: TwglGetCurrentAssociatedContextAMD; - wglBlitContextFramebufferAMD: TwglBlitContextFramebufferAMD; - - // WGL_EXT_display_color_table - wglCreateDisplayColorTableEXT: TwglCreateDisplayColorTableEXT; - wglLoadDisplayColorTableEXT: TwglLoadDisplayColorTableEXT; - wglBindDisplayColorTableEXT: TwglBindDisplayColorTableEXT; - wglDestroyDisplayColorTableEXT: TwglDestroyDisplayColorTableEXT; - - // WGL_EXT_extensions_string - wglGetExtensionsStringEXT: TwglGetExtensionsStringEXT; - - // WGL_EXT_make_current_read - wglMakeContextCurrentEXT: TwglMakeContextCurrentEXT; - wglGetCurrentReadDCEXT: TwglGetCurrentReadDCEXT; - - // WGL_EXT_pbuffer - wglCreatePbufferEXT: TwglCreatePbufferEXT; - wglGetPbufferDCEXT: TwglGetPbufferDCEXT; - wglReleasePbufferDCEXT: TwglReleasePbufferDCEXT; - wglDestroyPbufferEXT: TwglDestroyPbufferEXT; - wglQueryPbufferEXT: TwglQueryPbufferEXT; - - // WGL_EXT_pixel_format - wglGetPixelFormatAttribivEXT: TwglGetPixelFormatAttribivEXT; - wglGetPixelFormatAttribfvEXT: TwglGetPixelFormatAttribfvEXT; - wglChoosePixelFormatEXT: TwglChoosePixelFormatEXT; - - // WGL_EXT_swap_control - wglSwapIntervalEXT: TwglSwapIntervalEXT; - wglGetSwapIntervalEXT: TwglGetSwapIntervalEXT; - - // WGL_I3D_digital_video_control - wglGetDigitalVideoParametersI3D: TwglGetDigitalVideoParametersI3D; - wglSetDigitalVideoParametersI3D: TwglSetDigitalVideoParametersI3D; - - // WGL_I3D_gamma - wglGetGammaTableParametersI3D: TwglGetGammaTableParametersI3D; - wglSetGammaTableParametersI3D: TwglSetGammaTableParametersI3D; - wglGetGammaTableI3D: TwglGetGammaTableI3D; - wglSetGammaTableI3D: TwglSetGammaTableI3D; - - // WGL_I3D_genlock - wglEnableGenlockI3D: TwglEnableGenlockI3D; - wglDisableGenlockI3D: TwglDisableGenlockI3D; - wglIsEnabledGenlockI3D: TwglIsEnabledGenlockI3D; - wglGenlockSourceI3D: TwglGenlockSourceI3D; - wglGetGenlockSourceI3D: TwglGetGenlockSourceI3D; - wglGenlockSourceEdgeI3D: TwglGenlockSourceEdgeI3D; - wglGetGenlockSourceEdgeI3D: TwglGetGenlockSourceEdgeI3D; - wglGenlockSampleRateI3D: TwglGenlockSampleRateI3D; - wglGetGenlockSampleRateI3D: TwglGetGenlockSampleRateI3D; - wglGenlockSourceDelayI3D: TwglGenlockSourceDelayI3D; - wglGetGenlockSourceDelayI3D: TwglGetGenlockSourceDelayI3D; - wglQueryGenlockMaxSourceDelayI3D: TwglQueryGenlockMaxSourceDelayI3D; - - // WGL_I3D_image_buffer - wglCreateImageBufferI3D: TwglCreateImageBufferI3D; - wglDestroyImageBufferI3D: TwglDestroyImageBufferI3D; - wglAssociateImageBufferEventsI3D: TwglAssociateImageBufferEventsI3D; - wglReleaseImageBufferEventsI3D: TwglReleaseImageBufferEventsI3D; - - // WGL_I3D_swap_frame_lock - wglEnableFrameLockI3D: TwglEnableFrameLockI3D; - wglDisableFrameLockI3D: TwglDisableFrameLockI3D; - wglIsEnabledFrameLockI3D: TwglIsEnabledFrameLockI3D; - wglQueryFrameLockMasterI3D: TwglQueryFrameLockMasterI3D; - - // WGL_I3D_swap_frame_usage - wglGetFrameUsageI3D: TwglGetFrameUsageI3D; - wglBeginFrameTrackingI3D: TwglBeginFrameTrackingI3D; - wglEndFrameTrackingI3D: TwglEndFrameTrackingI3D; - wglQueryFrameTrackingI3D: TwglQueryFrameTrackingI3D; - - // WGL_NV_vertex_array_range - wglAllocateMemoryNV: TwglAllocateMemoryNV; - wglFreeMemoryNV: TwglFreeMemoryNV; - - // WGL_NV_present_video - wglEnumerateVideoDevicesNV: TwglEnumerateVideoDevicesNV; - wglBindVideoDeviceNV: TwglBindVideoDeviceNV; - wglQueryCurrentContextNV: TwglQueryCurrentContextNV; - - // WGL_NV_video_output - wglGetVideoDeviceNV: TwglGetVideoDeviceNV; - wglReleaseVideoDeviceNV: TwglReleaseVideoDeviceNV; - wglBindVideoImageNV: TwglBindVideoImageNV; - wglReleaseVideoImageNV: TwglReleaseVideoImageNV; - wglSendPbufferToVideoNV: TwglSendPbufferToVideoNV; - wglGetVideoInfoNV: TwglGetVideoInfoNV; - - // WGL_NV_swap_group - wglJoinSwapGroupNV: TwglJoinSwapGroupNV; - wglBindSwapBarrierNV: TwglBindSwapBarrierNV; - wglQuerySwapGroupNV: TwglQuerySwapGroupNV; - wglQueryMaxSwapGroupsNV: TwglQueryMaxSwapGroupsNV; - wglQueryFrameCountNV: TwglQueryFrameCountNV; - wglResetFrameCountNV: TwglResetFrameCountNV; - - // WGL_NV_gpu_affinity - wglEnumGpusNV: TwglEnumGpusNV; - wglEnumGpuDevicesNV: TwglEnumGpuDevicesNV; - wglCreateAffinityDCNV: TwglCreateAffinityDCNV; - wglEnumGpusFromAffinityDCNV: TwglEnumGpusFromAffinityDCNV; - wglDeleteDCNV: TwglDeleteDCNV; - - // WGL_NV_video_capture - wglBindVideoCaptureDeviceNV: TwglBindVideoCaptureDeviceNV; - wglEnumerateVideoCaptureDevicesNV: TwglEnumerateVideoCaptureDevicesNV; - wglLockVideoCaptureDeviceNV: TwglLockVideoCaptureDeviceNV; - wglQueryVideoCaptureDeviceNV: TwglQueryVideoCaptureDeviceNV; - wglReleaseVideoCaptureDeviceNV: TwglReleaseVideoCaptureDeviceNV; - - // WGL_NV_copy_image - wglCopyImageSubDataNV: TwglCopyImageSubDataNV; - - // WGL_NV_DX_interop - wglDXSetResourceShareHandleNV : TwglDXSetResourceShareHandleNV; - wglDXOpenDeviceNV : TwglDXOpenDeviceNV; - wglDXCloseDeviceNV : TwglDXCloseDeviceNV; - wglDXRegisterObjectNV : TwglDXRegisterObjectNV; - wglDXUnregisterObjectNV : TwglDXUnregisterObjectNV; - wglDXObjectAccessNV : TwglDXObjectAccessNV; - wglDXLockObjectsNV : TwglDXLockObjectsNV; - wglDXUnlockObjectsNV : TwglDXUnlockObjectsNV; - - // WGL_OML_sync_control - wglGetSyncValuesOML: TwglGetSyncValuesOML; - wglGetMscRateOML: TwglGetMscRateOML; - wglSwapBuffersMscOML: TwglSwapBuffersMscOML; - wglSwapLayerBuffersMscOML: TwglSwapLayerBuffersMscOML; - wglWaitForMscOML: TwglWaitForMscOML; - wglWaitForSbcOML: TwglWaitForSbcOML; - - // WGL_3DL_stereo_control - wglSetStereoEmitterState3DL: TwglSetStereoEmitterState3DL; - - // WIN_draw_range_elements - glDrawRangeElementsWIN: TglDrawRangeElementsWIN; - - // WIN_swap_hint - glAddSwapHintRectWIN: TglAddSwapHintRectWIN; -{$ENDIF} - -{$IFDEF DGL_LINUX} - glXChooseVisual: TglXChooseVisual; - glXCopyContext: TglXCopyContext; - glXCreateContext: TglXCreateContext; - glXCreateGLXPixmap: TglXCreateGLXPixmap; - glXDestroyContext: TglXDestroyContext; - glXDestroyGLXPixmap: TglXDestroyGLXPixmap; - glXGetConfig: TglXGetConfig; - glXGetCurrentContext: TglXGetCurrentContext; - glXGetCurrentDrawable: TglXGetCurrentDrawable; - glXIsDirect: TglXIsDirect; - glXMakeCurrent: TglXMakeCurrent; - glXQueryExtension: TglXQueryExtension; - glXQueryVersion: TglXQueryVersion; - glXSwapBuffers: TglXSwapBuffers; - glXUseXFont: TglXUseXFont; - glXWaitGL: TglXWaitGL; - glXWaitX: TglXWaitX; - - glXGetClientString: TglXGetClientString; - glXQueryServerString: TglXQueryServerString; - glXQueryExtensionsString: TglXQueryExtensionsString; - - // GLX_VERSION_1_3 - glXGetFBConfigs: TglXGetFBConfigs; - glXChooseFBConfig: TglXChooseFBConfig; - glXGetFBConfigAttrib: TglXGetFBConfigAttrib; - glXGetVisualFromFBConfig: TglXGetVisualFromFBConfig; - glXCreateWindow: TglXCreateWindow; - glXDestroyWindow: TglXDestroyWindow; - glXCreatePixmap: TglXCreatePixmap; - - glXDestroyPixmap: TglXDestroyPixmap; - glXCreatePbuffer: TglXCreatePbuffer; - glXDestroyPbuffer: TglXDestroyPbuffer; - glXQueryDrawable: TglXQueryDrawable; - glXCreateNewContext: TglXCreateNewContext; - glXMakeContextCurrent: TglXMakeContextCurrent; - glXGetCurrentReadDrawable: TglXGetCurrentReadDrawable; - glXGetCurreentDisplay: TglXGetCurreentDisplay; - - glXQueryContext: TglXQueryContext; - glXSelectEvent: TglXSelectEvent; - glXGetSelectedEvent: TglXGetSelectedEvent; - - // GLX_VERSION_1_4 - glXGetProcAddress: TglXGetProcAddress; - - // GLX_ARB_get_proc_address - glXGetProcAddressARB: TglXGetProcAddressARB; - - // GLX_ARB_create_context - glXCreateContextAttribsARB: TglXCreateContextAttribsARB; - - // GLX_EXT_import_context - glXGetCurrentDisplayEXT: TglXGetCurrentDisplayEXT; - glXQueryContextInfoEXT: TglXQueryContextInfoEXT; - glXGetContextIDEXT: TglXGetContextIDEXT; - glXImportContextEXT: TglXImportContextEXT; - glXFreeContextEXT: TglXFreeContextEXT; - - // GLX_EXT_texture_from_pixmap - glXBindTexImageEXT: TglXBindTexImageEXT; - glXReleaseTexImageEXT: TglXReleaseTexImageEXT; - - // GLX_EXT_swap_control - glXSwapIntervalEXT: TglXSwapIntervalEXT; -{$ENDIF} - - // GL utility functions and procedures - gluErrorString: TgluErrorString; - gluGetString: TgluGetString; - gluOrtho2D: TgluOrtho2D; - gluPerspective: TgluPerspective; - gluPickMatrix: TgluPickMatrix; - gluLookAt: TgluLookAt; - gluProject: TgluProject; - gluUnProject: TgluUnProject; - gluScaleImage: TgluScaleImage; - gluBuild1DMipmaps: TgluBuild1DMipmaps; - gluBuild2DMipmaps: TgluBuild2DMipmaps; - gluNewQuadric: TgluNewQuadric; - gluDeleteQuadric: TgluDeleteQuadric; - gluQuadricNormals: TgluQuadricNormals; - gluQuadricTexture: TgluQuadricTexture; - gluQuadricOrientation: TgluQuadricOrientation; - gluQuadricDrawStyle: TgluQuadricDrawStyle; - gluCylinder: TgluCylinder; - gluDisk: TgluDisk; - gluPartialDisk: TgluPartialDisk; - gluSphere: TgluSphere; - gluQuadricCallback: TgluQuadricCallback; - gluNewTess: TgluNewTess; - gluDeleteTess: TgluDeleteTess; - gluTessBeginPolygon: TgluTessBeginPolygon; - gluTessBeginContour: TgluTessBeginContour; - gluTessVertex: TgluTessVertex; - gluTessEndContour: TgluTessEndContour; - gluTessEndPolygon: TgluTessEndPolygon; - gluTessProperty: TgluTessProperty; - gluTessNormal: TgluTessNormal; - gluTessCallback: TgluTessCallback; - gluGetTessProperty: TgluGetTessProperty; - gluNewNurbsRenderer: TgluNewNurbsRenderer; - gluDeleteNurbsRenderer: TgluDeleteNurbsRenderer; - gluBeginSurface: TgluBeginSurface; - gluBeginCurve: TgluBeginCurve; - gluEndCurve: TgluEndCurve; - gluEndSurface: TgluEndSurface; - gluBeginTrim: TgluBeginTrim; - gluEndTrim: TgluEndTrim; - gluPwlCurve: TgluPwlCurve; - gluNurbsCurve: TgluNurbsCurve; - gluNurbsSurface: TgluNurbsSurface; - gluLoadSamplingMatrices: TgluLoadSamplingMatrices; - gluNurbsProperty: TgluNurbsProperty; - gluGetNurbsProperty: TgluGetNurbsProperty; - gluNurbsCallback: TgluNurbsCallback; - gluBeginPolygon: TgluBeginPolygon; - gluNextContour: TgluNextContour; - gluEndPolygon: TgluEndPolygon; - - -type - TRCOptions = set of (opDoubleBuffered, opGDI, opStereo); - -var - GL_LibHandle: Pointer = nil; - GLU_LibHandle: Pointer = nil; - - LastPixelFormat: Integer; - ExtensionsRead: Boolean; - ImplementationRead: Boolean; - - -const -{$IFDEF DGL_WIN} - OPENGL_LIBNAME = 'OpenGL32.dll'; - GLU_LIBNAME = 'GLU32.dll'; -{$ELSE} - {$IFDEF darwin} - OPENGL_LIBNAME = 'libGL.dylib'; - GLU_LIBNAME = 'libGLU.dylib'; - {$ELSE} - OPENGL_LIBNAME = 'libGL.so.1'; - GLU_LIBNAME = 'libGLU.so.1'; - {$ENDIF} -{$ENDIF} - -function InitOpenGL(LibName: String = OPENGL_LIBNAME; GLULibName: String = GLU_LIBNAME): Boolean; - -function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer; -function dglCheckExtension(Extension: AnsiString): Boolean; - -procedure ReadExtensions; -procedure ReadImplementationProperties; - -// ============================================================================= -// Helper-Functions -// ============================================================================= -{$IFDEF DGL_WIN} - function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; - function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; - procedure DestroyRenderingContext(RC: HGLRC); - - procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true); - procedure DeactivateRenderingContext; -{$ENDIF} - - -procedure ReadOpenGLCore; -procedure Read_GL_3DFX_tbuffer; -procedure Read_GL_APPLE_element_array; -procedure Read_GL_APPLE_fence; -procedure Read_GL_APPLE_vertex_array_object; -procedure Read_GL_APPLE_vertex_array_range; -procedure Read_GL_APPLE_texture_range; -procedure Read_GL_APPLE_vertex_program_evaluators; -procedure Read_GL_APPLE_object_purgeable; -procedure Read_GL_ARB_matrix_palette; -procedure Read_GL_ARB_multitexture; -procedure Read_GL_ARB_point_parameters; -procedure Read_GL_ARB_texture_compression; -procedure Read_GL_ARB_transpose_matrix; -procedure Read_GL_ARB_vertex_blend; -procedure Read_GL_ARB_vertex_buffer_object; -procedure Read_GL_ARB_vertex_program; -procedure Read_GL_ARB_window_pos; -procedure Read_GL_ARB_color_buffer_float; -procedure Read_GL_ARB_Shader_Objects; -procedure Read_GL_ARB_occlusion_query; -procedure Read_GL_ARB_draw_instanced; -procedure Read_GL_ARB_framebuffer_object; -procedure Read_GL_ARB_geometry_shader4; -procedure Read_GL_ARB_instanced_arrays; -procedure Read_GL_ARB_map_buffer_range; -procedure Read_GL_ARB_texture_buffer_object; -procedure Read_GL_ARB_vertex_array_object; -procedure Read_GL_ARB_uniform_buffer_object; -procedure Read_GL_ARB_copy_buffer; -procedure Read_GL_ARB_draw_elements_base_vertex; -procedure Read_GL_ARB_provoking_vertex; -procedure Read_GL_ARB_sync; -procedure Read_GL_ARB_texture_multisample; -procedure Read_GL_ARB_draw_buffers_blend; -procedure Read_GL_ARB_sample_shading; -procedure Read_GL_ARB_shading_language_include; -procedure Read_GL_ARB_blend_func_extended; -procedure Read_GL_ARB_sampler_objects; -procedure Read_GL_ARB_timer_query; -procedure Read_GL_ARB_vertex_type_2_10_10_10_rev; -procedure Read_GL_ARB_draw_indirect; -procedure Read_GL_ARB_gpu_shader_fp64; -procedure Read_GL_ARB_shader_subroutine; -procedure Read_GL_ARB_tessellation_shader; -procedure Read_GL_ARB_transform_feedback2; -procedure Read_GL_ARB_transform_feedback3; -procedure Read_GL_ARB_ES2_compatibility; -procedure Read_GL_ARB_get_program_binary; -procedure Read_GL_ARB_separate_shader_objects; -procedure Read_GL_ARB_vertex_attrib_64bit; -procedure Read_GL_ARB_viewport_array; -// GL 4.2 -procedure Read_GL_ARB_base_instance; -procedure Read_GL_ARB_transform_feedback_instanced; -procedure Read_GL_ARB_internalformat_query; -procedure Read_GL_ARB_shader_atomic_counters; -procedure Read_GL_ARB_shader_image_load_store; -procedure Read_GL_ARB_texture_storage; -// GL 4.3 -procedure Read_GL_KHR_debug; -procedure Read_GL_ARB_clear_buffer_object; -procedure Read_GL_ARB_compute_shader; -procedure Read_GL_ARB_copy_image; -procedure Read_GL_ARB_framebuffer_no_attachments; -procedure Read_GL_ARB_internalformat_query2; -procedure Read_GL_ARB_invalidate_subdata; -procedure Read_GL_ARB_multi_draw_indirect; -procedure Read_GL_ARB_program_interface_query; -procedure Read_GL_ARB_shader_storage_buffer_object; -procedure Read_GL_ARB_texture_buffer_range; -procedure Read_GL_ARB_texture_storage_multisample; -procedure Read_GL_ARB_texture_view; -procedure Read_GL_ARB_vertex_attrib_binding; - -// GL 4.4 -procedure Read_GL_4_4; - -// -procedure Read_GL_ARB_cl_event; -procedure Read_GL_ARB_debug_output; -procedure Read_GL_ARB_robustness; -procedure Read_GL_ATI_draw_buffers; -procedure Read_GL_ATI_element_array; -procedure Read_GL_ATI_envmap_bumpmap; -procedure Read_GL_ATI_fragment_shader; -procedure Read_GL_ATI_map_object_buffer; -procedure Read_GL_ATI_pn_triangles; -procedure Read_GL_ATI_separate_stencil; -procedure Read_GL_ATI_vertex_array_object; -procedure Read_GL_ATI_vertex_attrib_array_object; -procedure Read_GL_ATI_vertex_streams; -procedure Read_GL_AMD_performance_monitor; -procedure Read_GL_AMD_vertex_shader_tesselator; -procedure Read_GL_AMD_draw_buffers_blend; -procedure Read_GL_AMD_name_gen_delete; -procedure Read_GL_AMD_debug_output; -procedure Read_GL_EXT_blend_color; -procedure Read_GL_EXT_blend_func_separate; -procedure Read_GL_EXT_blend_minmax; -procedure Read_GL_EXT_color_subtable; -procedure Read_GL_EXT_compiled_vertex_array; -procedure Read_GL_EXT_convolution; -procedure Read_GL_EXT_coordinate_frame; -procedure Read_GL_EXT_copy_texture; -procedure Read_GL_EXT_cull_vertex; -procedure Read_GL_EXT_draw_range_elements; -procedure Read_GL_EXT_fog_coord; -procedure Read_GL_EXT_framebuffer_object; -procedure Read_GL_EXT_histogram; -procedure Read_GL_EXT_index_func; -procedure Read_GL_EXT_index_material; -procedure Read_GL_EXT_multi_draw_arrays; -procedure Read_GL_EXT_multisample; -procedure Read_GL_EXT_paletted_texture; -procedure Read_GL_EXT_pixel_transform; -procedure Read_GL_EXT_point_parameters; -procedure Read_GL_EXT_polygon_offset; -procedure Read_GL_EXT_secondary_color; -procedure Read_GL_EXT_stencil_two_side; -procedure Read_GL_EXT_subtexture; -procedure Read_GL_EXT_texture3D; -procedure Read_GL_EXT_texture_object; -procedure Read_GL_EXT_texture_perturb_normal; -procedure Read_GL_EXT_vertex_array; -procedure Read_GL_EXT_vertex_shader; -procedure Read_GL_EXT_vertex_weighting; -procedure Read_GL_EXT_depth_bounds_test; -procedure Read_GL_EXT_blend_equation_separate; -procedure Read_GL_EXT_stencil_clear_tag; -procedure Read_GL_EXT_framebuffer_blit; -procedure Read_GL_EXT_framebuffer_multisample; -procedure Read_GL_EXT_timer_query; -procedure Read_GL_EXT_gpu_program_parameters; -procedure Read_GL_EXT_bindable_uniform; -procedure Read_GL_EXT_draw_buffers2; -procedure Read_GL_EXT_draw_instanced; -procedure Read_GL_EXT_geometry_shader4; -procedure Read_GL_EXT_gpu_shader4; -procedure Read_GL_EXT_texture_array; -procedure Read_GL_EXT_texture_buffer_object; -procedure Read_GL_EXT_texture_integer; -procedure Read_GL_EXT_transform_feedback; -procedure Read_GL_EXT_direct_state_access; -procedure Read_GL_EXT_separate_shader_objects; -procedure Read_GL_EXT_shader_image_load_store; -procedure Read_GL_EXT_vertex_attrib_64bit; -procedure Read_GL_HP_image_transform; -procedure Read_GL_IBM_multimode_draw_arrays; -procedure Read_GL_IBM_vertex_array_lists; -procedure Read_GL_INGR_blend_func_separate; -procedure Read_GL_INTEL_parallel_arrays; -procedure Read_GL_MESA_resize_buffers; -procedure Read_GL_MESA_window_pos; -procedure Read_GL_NV_evaluators; -procedure Read_GL_NV_fence; -procedure Read_GL_NV_fragment_program; -procedure Read_GL_NV_half_float; -procedure Read_GL_NV_occlusion_query; -procedure Read_GL_NV_pixel_data_range; -procedure Read_GL_NV_point_sprite; -procedure Read_GL_NV_primitive_restart; -procedure Read_GL_NV_register_combiners; -procedure Read_GL_NV_register_combiners2; -procedure Read_GL_NV_vertex_array_range; -procedure Read_GL_NV_vertex_program; -procedure Read_GL_NV_depth_buffer_float; -procedure Read_GL_NV_framebuffer_multisample_coverage; -procedure Read_GL_NV_geometry_program4; -procedure Read_GL_NV_gpu_program4; -procedure Read_GL_NV_parameter_buffer_object; -procedure Read_GL_NV_transform_feedback; -procedure Read_GL_NV_conditional_render; -procedure Read_GL_NV_present_video; -procedure Read_GL_NV_explicit_multisample; -procedure Read_GL_NV_transform_feedback2; -procedure Read_GL_NV_video_capture; -procedure Read_GL_NV_copy_image; -procedure Read_GL_NV_shader_buffer_load; -procedure Read_GL_NV_vertex_buffer_unified_memory; -procedure Read_GL_NV_gpu_program5; -procedure Read_GL_NV_gpu_shader5; -procedure Read_GL_NV_vertex_attrib_integer_64bit; -procedure Read_GL_NV_vdpau_interop; -procedure Read_GL_NV_texture_barrier; -procedure Read_GL_PGI_misc_hints; -procedure Read_GL_SGIS_detail_texture; -procedure Read_GL_SGIS_fog_function; -procedure Read_GL_SGIS_multisample; -procedure Read_GL_SGIS_pixel_texture; -procedure Read_GL_SGIS_point_parameters; -procedure Read_GL_SGIS_sharpen_texture; -procedure Read_GL_SGIS_texture4D; -procedure Read_GL_SGIS_texture_color_mask; -procedure Read_GL_SGIS_texture_filter4; -procedure Read_GL_SGIX_async; -procedure Read_GL_SGIX_flush_raster; -procedure Read_GL_SGIX_fragment_lighting; -procedure Read_GL_SGIX_framezoom; -procedure Read_GL_SGIX_igloo_interface; -procedure Read_GL_SGIX_instruments; -procedure Read_GL_SGIX_list_priority; -procedure Read_GL_SGIX_pixel_texture; -procedure Read_GL_SGIX_polynomial_ffd; -procedure Read_GL_SGIX_reference_plane; -procedure Read_GL_SGIX_sprite; -procedure Read_GL_SGIX_tag_sample_buffer; -procedure Read_GL_SGI_color_table; -procedure Read_GL_SUNX_constant_data; -procedure Read_GL_SUN_global_alpha; -procedure Read_GL_SUN_mesh_array; -procedure Read_GL_SUN_triangle_list; -procedure Read_GL_SUN_vertex; - -{$IFDEF DGL_WIN} -procedure Read_WGL_ARB_buffer_region; -procedure Read_WGL_ARB_extensions_string; -procedure Read_WGL_ARB_make_current_read; -procedure Read_WGL_ARB_pbuffer; -procedure Read_WGL_ARB_pixel_format; -procedure Read_WGL_ARB_pixel_format_float; -procedure Read_WGL_ARB_render_texture; -procedure Read_WGL_ARB_create_context; -procedure Read_WGL_AMD_gpu_association; -procedure Read_WGL_EXT_display_color_table; -procedure Read_WGL_EXT_extensions_string; -procedure Read_WGL_EXT_make_current_read; -procedure Read_WGL_EXT_pbuffer; -procedure Read_WGL_EXT_pixel_format; -procedure Read_WGL_EXT_swap_control; -procedure Read_WGL_I3D_digital_video_control; -procedure Read_WGL_I3D_gamma; -procedure Read_WGL_I3D_genlock; -procedure Read_WGL_I3D_image_buffer; -procedure Read_WGL_I3D_swap_frame_lock; -procedure Read_WGL_I3D_swap_frame_usage; -procedure Read_WGL_NV_vertex_array_range; -procedure Read_WGL_NV_present_video; -procedure Read_WGL_NV_video_output; -procedure Read_WGL_NV_swap_group; -procedure Read_WGL_NV_gpu_affinity; -procedure Read_WGL_NV_video_capture; -procedure Read_WGL_NV_copy_image; -procedure Read_WGL_OML_sync_control; -procedure Read_WGL_3DL_stereo_control; - -procedure Read_WIN_draw_range_elements; -procedure Read_WIN_swap_hint; -{$ENDIF} - - -implementation - - -{$IFDEF DGL_LINUX} -const - RTLD_LAZY = $001; - RTLD_NOW = $002; - RTLD_BINDING_MASK = $003; - - // Seems to work on Debian / Fedora - LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF}; - -function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen'; -function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose'; - -function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym'; -{$ENDIF} - -{$IFDEF DGL_MAC}{$IFDEF OPENGL_FRAMEWORK} // OpenGL framework used -const - RTLD_DEFAULT = Pointer(-2); -{$ENDIF}{$ENDIF} - -function dglLoadLibrary(Name: PChar): Pointer; -begin - {$IFDEF DGL_WIN} - Result := {%H-}Pointer(LoadLibrary(Name)); - {$ENDIF} - - {$IFDEF DGL_LINUX} - Result := dlopen(Name, RTLD_LAZY); - {$ENDIF} - - {$IFDEF DGL_MAC} - {$IFDEF OPENGL_FRAMEWORK} - Result := RTLD_DEFAULT; - {$ELSE} - Result := Pointer(LoadLibrary(Name)); - {$ENDIF} - {$ENDIF} -end; - - -function dglFreeLibrary(LibHandle: Pointer): Boolean; -begin - if LibHandle = nil then - Result := False - else - {$IFDEF DGL_WIN} - Result := FreeLibrary({%H-}HMODULE(LibHandle)); - {$ENDIF} - - {$IFDEF DGL_LINUX} - Result := dlclose(LibHandle) = 0; - {$ENDIF} - - {$IFDEF DGL_MAC} - {$IFDEF OPENGL_FRAMEWORK} - Result := true; - {$ELSE} - Result := FreeLibrary(HMODULE(LibHandle)); - {$ENDIF} - {$ENDIF} -end; - - -function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer; -begin - if LibHandle = nil then - LibHandle := GL_LibHandle; - - Result := nil; - - {$IFDEF DGL_WIN} - Result := GetProcAddress({%H-}HMODULE(LibHandle), ProcName); - - if result <> nil then - exit; - - if Addr(wglGetProcAddress) <> nil then - Result := wglGetProcAddress(ProcName); - {$ENDIF} - - {$IFDEF DGL_LINUX} - if not ForceDLSym then begin - if Addr(glXGetProcAddress) <> nil then - Result := glXGetProcAddress(ProcName); - - if result <> nil then - exit; - - if Addr(glXGetProcAddressARB) <> nil then - Result := glXGetProcAddressARB(ProcName); - - if result <> nil then - exit; - end; - - Result := dlsym(LibHandle, ProcName); - {$ENDIF} - - {$IFDEF DGL_MAC} - Result := GetProcAddress(HMODULE(LibHandle), ProcName); - {$ENDIF} -end; - - -function Int_GetExtensionString: AnsiString; -var - ExtensionCount : GLint; - i : Integer; -begin - if GL_VERSION_3_0 - then - begin - if not Assigned(@glGetIntegerv) then glGetIntegerv := dglGetProcAddress('glGetIntegerv'); - if not Assigned(@glGetStringi) then glGetStringi := dglGetProcAddress('glGetStringi'); - - result := ''; - - if Assigned(@glGetIntegerv) and Assigned(@glGetStringi) - then - begin - glGetIntegerv(GL_NUM_EXTENSIONS, @extensionCount); - - For I := 0 to extensionCount - 1 do - result := result + #32 + PAnsiChar(glGetStringi(GL_EXTENSIONS, I)); - end; - end - else - begin - if not Assigned(@glGetString) then glGetString := dglGetProcAddress('glGetString'); - - if Assigned(@glGetString) - then result := glGetString(GL_EXTENSIONS) - else result := ''; - end; - - if (GL_LibHandle <> nil) then begin - {$IFDEF DGL_WIN} - // wglGetExtensionsStringEXT - if not Assigned(@wglGetExtensionsStringEXT) then - wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT'); - - if Assigned(@wglGetExtensionsStringEXT) then - Result := Result + #32 + wglGetExtensionsStringEXT; - - // wglGetExtensionsStringARB - if not Assigned(@wglGetExtensionsStringARB) then - wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB'); - - if Assigned(@wglGetExtensionsStringARB) then - Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC); - {$ENDIF} - end; - - Result := #32 + Result + #32; -end; - - -function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean; -begin - Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0; -end; - - -function dglCheckExtension(Extension: AnsiString): Boolean; -var - Extensions: AnsiString; -begin - Extensions := Int_GetExtensionString; - Result := Int_CheckExtension(Extensions, Extension); -end; - - - -function InitOpenGL(LibName: String; GLULibName: String): Boolean; -begin - Result := False; - - // free opened libraries - if GL_LibHandle <> nil then - dglFreeLibrary(GL_LibHandle); - - if GLU_LibHandle <> nil then - dglFreeLibrary(GLU_LibHandle); - - // load library - GL_LibHandle := dglLoadLibrary(PChar(LibName)); - GLU_LibHandle := dglLoadLibrary(PChar(GLULibName)); - - // load GL functions - if (GL_LibHandle <> nil) then begin - {$IFDEF DGL_WIN} - wglCopyContext := dglGetProcAddress('wglCopyContext'); - wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext'); - wglCreateContext := dglGetProcAddress('wglCreateContext'); - wglDeleteContext := dglGetProcAddress('wglDeleteContext'); - wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane'); - wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext'); - wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC'); - wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries'); - wglGetProcAddress := dglGetProcAddress('wglGetProcAddress'); - wglMakeCurrent := dglGetProcAddress('wglMakeCurrent'); - wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette'); - wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries'); - wglShareLists := dglGetProcAddress('wglShareLists'); - wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers'); - wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers'); - wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA'); - wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA'); - wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW'); - wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW'); - wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA'); - wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA'); - {$ENDIF} - - {$IFDEF DGL_LINUX} - // GLX_VERSION_1_4 (needs to be first) - glXGetProcAddress := dglGetProcAddress('glXGetProcAddress', nil, True); - - // GLX_ARB_get_proc_address (also needs to be first) - glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB', nil, True); - - glXChooseVisual := dglGetProcAddress('glXChooseVisual'); - glXCopyContext := dglGetProcAddress('glXCopyContext'); - glXCreateContext := dglGetProcAddress('glXCreateContext'); - glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap'); - glXDestroyContext := dglGetProcAddress('glXDestroyContext'); - glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap'); - glXGetConfig := dglGetProcAddress('glXGetConfig'); - glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext'); - glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable'); - glXIsDirect := dglGetProcAddress('glXIsDirect'); - glXMakeCurrent := dglGetProcAddress('glXMakeCurrent'); - glXQueryExtension := dglGetProcAddress('glXQueryExtension'); - glXQueryVersion := dglGetProcAddress('glXQueryVersion'); - glXSwapBuffers := dglGetProcAddress('glXSwapBuffers'); - glXUseXFont := dglGetProcAddress('glXUseXFont'); - glXWaitGL := dglGetProcAddress('glXWaitGL'); - glXWaitX := dglGetProcAddress('glXWaitX'); - - glXGetClientString := dglGetProcAddress('glXGetClientString'); - glXQueryServerString := dglGetProcAddress('glXQueryServerString'); - glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString'); - - // GLX_VERSION_1_3 - glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs'); - glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig'); - glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib'); - glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig'); - glXCreateWindow := dglGetProcAddress('glXCreateWindow'); - glXDestroyWindow := dglGetProcAddress('glXDestroyWindow'); - glXCreatePixmap := dglGetProcAddress('glXCreatePixmap'); - - glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap'); - glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer'); - glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer'); - glXQueryDrawable := dglGetProcAddress('glXQueryDrawable'); - glXCreateNewContext := dglGetProcAddress('glXCreateNewContext'); - glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent'); - glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable'); - glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay'); - - glXQueryContext := dglGetProcAddress('glXQueryContext'); - glXSelectEvent := dglGetProcAddress('glXSelectEvent'); - glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent'); - - // GLX_ARB_create_context - glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB'); - - // GLX_EXT_import_context - glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT'); - glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT'); - glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT'); - glXImportContextEXT := dglGetProcAddress('glXImportContextEXT'); - glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT'); - - // GLX_EXT_texture_from_pixmap - glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT'); - glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT'); - - // GLX_EXT_swap_control - glXSwapIntervalEXT := dglGetProcAddress('glXSwapIntervalEXT'); - {$ENDIF} - - Result := True; - end; - - // load GLU functions - if GLU_LibHandle <> nil then begin - // GLU ======================================================================== - gluBeginCurve := dglGetProcAddress('gluBeginCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluBeginPolygon := dglGetProcAddress('gluBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluBeginSurface := dglGetProcAddress('gluBeginSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluBeginTrim := dglGetProcAddress('gluBeginTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluBuild1DMipmaps := dglGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluBuild2DMipmaps := dglGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluCylinder := dglGetProcAddress('gluCylinder', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluDeleteNurbsRenderer := dglGetProcAddress('gluDeleteNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluDeleteQuadric := dglGetProcAddress('gluDeleteQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluDeleteTess := dglGetProcAddress('gluDeleteTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluDisk := dglGetProcAddress('gluDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluEndCurve := dglGetProcAddress('gluEndCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluEndPolygon := dglGetProcAddress('gluEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluEndSurface := dglGetProcAddress('gluEndSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluEndTrim := dglGetProcAddress('gluEndTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluErrorString := dglGetProcAddress('gluErrorString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluGetNurbsProperty := dglGetProcAddress('gluGetNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluGetString := dglGetProcAddress('gluGetString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluGetTessProperty := dglGetProcAddress('gluGetTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluLoadSamplingMatrices := dglGetProcAddress('gluLoadSamplingMatrices', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluLookAt := dglGetProcAddress('gluLookAt', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNewNurbsRenderer := dglGetProcAddress('gluNewNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNewQuadric := dglGetProcAddress('gluNewQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNewTess := dglGetProcAddress('gluNewTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNextContour := dglGetProcAddress('gluNextContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNurbsCallback := dglGetProcAddress('gluNurbsCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNurbsCurve := dglGetProcAddress('gluNurbsCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNurbsProperty := dglGetProcAddress('gluNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluNurbsSurface := dglGetProcAddress('gluNurbsSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluOrtho2D := dglGetProcAddress('gluOrtho2D', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluPartialDisk := dglGetProcAddress('gluPartialDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluPerspective := dglGetProcAddress('gluPerspective', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluPickMatrix := dglGetProcAddress('gluPickMatrix', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluProject := dglGetProcAddress('gluProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluPwlCurve := dglGetProcAddress('gluPwlCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluQuadricCallback := dglGetProcAddress('gluQuadricCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluQuadricDrawStyle := dglGetProcAddress('gluQuadricDrawStyle', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluQuadricNormals := dglGetProcAddress('gluQuadricNormals', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluQuadricOrientation := dglGetProcAddress('gluQuadricOrientation', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluQuadricTexture := dglGetProcAddress('gluQuadricTexture', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluScaleImage := dglGetProcAddress('gluScaleImage', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluSphere := dglGetProcAddress('gluSphere', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessBeginContour := dglGetProcAddress('gluTessBeginContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessBeginPolygon := dglGetProcAddress('gluTessBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessCallback := dglGetProcAddress('gluTessCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessEndContour := dglGetProcAddress('gluTessEndContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessEndPolygon := dglGetProcAddress('gluTessEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessNormal := dglGetProcAddress('gluTessNormal', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessProperty := dglGetProcAddress('gluTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluTessVertex := dglGetProcAddress('gluTessVertex', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - gluUnProject := dglGetProcAddress('gluUnProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF}); - end; -end; - -procedure ReadOpenGLCore; -begin - // GL_VERSION_1_0 - glCullFace := dglGetProcAddress('glCullFace'); - glFrontFace := dglGetProcAddress('glFrontFace'); - glHint := dglGetProcAddress('glHint'); - glLineWidth := dglGetProcAddress('glLineWidth'); - glPointSize := dglGetProcAddress('glPointSize'); - glPolygonMode := dglGetProcAddress('glPolygonMode'); - glScissor := dglGetProcAddress('glScissor'); - glTexParameterf := dglGetProcAddress('glTexParameterf'); - glTexParameterfv := dglGetProcAddress('glTexParameterfv'); - glTexParameteri := dglGetProcAddress('glTexParameteri'); - glTexParameteriv := dglGetProcAddress('glTexParameteriv'); - glTexImage1D := dglGetProcAddress('glTexImage1D'); - glTexImage2D := dglGetProcAddress('glTexImage2D'); - glDrawBuffer := dglGetProcAddress('glDrawBuffer'); - glClear := dglGetProcAddress('glClear'); - glClearColor := dglGetProcAddress('glClearColor'); - glClearStencil := dglGetProcAddress('glClearStencil'); - glClearDepth := dglGetProcAddress('glClearDepth'); - glStencilMask := dglGetProcAddress('glStencilMask'); - glColorMask := dglGetProcAddress('glColorMask'); - glDepthMask := dglGetProcAddress('glDepthMask'); - glDisable := dglGetProcAddress('glDisable'); - glEnable := dglGetProcAddress('glEnable'); - glFinish := dglGetProcAddress('glFinish'); - glFlush := dglGetProcAddress('glFlush'); - glBlendFunc := dglGetProcAddress('glBlendFunc'); - glLogicOp := dglGetProcAddress('glLogicOp'); - glStencilFunc := dglGetProcAddress('glStencilFunc'); - glStencilOp := dglGetProcAddress('glStencilOp'); - glDepthFunc := dglGetProcAddress('glDepthFunc'); - glPixelStoref := dglGetProcAddress('glPixelStoref'); - glPixelStorei := dglGetProcAddress('glPixelStorei'); - glReadBuffer := dglGetProcAddress('glReadBuffer'); - glReadPixels := dglGetProcAddress('glReadPixels'); - glGetBooleanv := dglGetProcAddress('glGetBooleanv'); - glGetDoublev := dglGetProcAddress('glGetDoublev'); - glGetError := dglGetProcAddress('glGetError'); - glGetFloatv := dglGetProcAddress('glGetFloatv'); - glGetIntegerv := dglGetProcAddress('glGetIntegerv'); - glGetString := dglGetProcAddress('glGetString'); - glGetTexImage := dglGetProcAddress('glGetTexImage'); - glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv'); - glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv'); - glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv'); - glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv'); - glIsEnabled := dglGetProcAddress('glIsEnabled'); - glDepthRange := dglGetProcAddress('glDepthRange'); - glViewport := dglGetProcAddress('glViewport'); - - // GL_VERSION_1_1 - glDrawArrays := dglGetProcAddress('glDrawArrays'); - glDrawElements := dglGetProcAddress('glDrawElements'); - glGetPointerv := dglGetProcAddress('glGetPointerv'); - glPolygonOffset := dglGetProcAddress('glPolygonOffset'); - glCopyTexImage1D := dglGetProcAddress('glCopyTexImage1D'); - glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D'); - glCopyTexSubImage1D := dglGetProcAddress('glCopyTexSubImage1D'); - glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D'); - glTexSubImage1D := dglGetProcAddress('glTexSubImage1D'); - glTexSubImage2D := dglGetProcAddress('glTexSubImage2D'); - glBindTexture := dglGetProcAddress('glBindTexture'); - glDeleteTextures := dglGetProcAddress('glDeleteTextures'); - glGenTextures := dglGetProcAddress('glGenTextures'); - -{$ifdef DGL_DEPRECATED} - glAccum := dglGetProcAddress('glAccum'); - glAlphaFunc := dglGetProcAddress('glAlphaFunc'); - glAreTexturesResident := dglGetProcAddress('glAreTexturesResident'); - glArrayElement := dglGetProcAddress('glArrayElement'); - glBegin := dglGetProcAddress('glBegin'); - glBitmap := dglGetProcAddress('glBitmap'); - glCallList := dglGetProcAddress('glCallList'); - glCallLists := dglGetProcAddress('glCallLists'); - glClearAccum := dglGetProcAddress('glClearAccum'); - glClearIndex := dglGetProcAddress('glClearIndex'); - glClipPlane := dglGetProcAddress('glClipPlane'); - glColor3b := dglGetProcAddress('glColor3b'); - glColor3bv := dglGetProcAddress('glColor3bv'); - glColor3d := dglGetProcAddress('glColor3d'); - glColor3dv := dglGetProcAddress('glColor3dv'); - glColor3f := dglGetProcAddress('glColor3f'); - glColor3fv := dglGetProcAddress('glColor3fv'); - glColor3i := dglGetProcAddress('glColor3i'); - glColor3iv := dglGetProcAddress('glColor3iv'); - glColor3s := dglGetProcAddress('glColor3s'); - glColor3sv := dglGetProcAddress('glColor3sv'); - glColor3ub := dglGetProcAddress('glColor3ub'); - glColor3ubv := dglGetProcAddress('glColor3ubv'); - glColor3ui := dglGetProcAddress('glColor3ui'); - glColor3uiv := dglGetProcAddress('glColor3uiv'); - glColor3us := dglGetProcAddress('glColor3us'); - glColor3usv := dglGetProcAddress('glColor3usv'); - glColor4b := dglGetProcAddress('glColor4b'); - glColor4bv := dglGetProcAddress('glColor4bv'); - glColor4d := dglGetProcAddress('glColor4d'); - glColor4dv := dglGetProcAddress('glColor4dv'); - glColor4f := dglGetProcAddress('glColor4f'); - glColor4fv := dglGetProcAddress('glColor4fv'); - glColor4i := dglGetProcAddress('glColor4i'); - glColor4iv := dglGetProcAddress('glColor4iv'); - glColor4s := dglGetProcAddress('glColor4s'); - glColor4sv := dglGetProcAddress('glColor4sv'); - glColor4ub := dglGetProcAddress('glColor4ub'); - glColor4ubv := dglGetProcAddress('glColor4ubv'); - glColor4ui := dglGetProcAddress('glColor4ui'); - glColor4uiv := dglGetProcAddress('glColor4uiv'); - glColor4us := dglGetProcAddress('glColor4us'); - glColor4usv := dglGetProcAddress('glColor4usv'); - glColorMaterial := dglGetProcAddress('glColorMaterial'); - glColorPointer := dglGetProcAddress('glColorPointer'); - glCopyPixels := dglGetProcAddress('glCopyPixels'); - glDeleteLists := dglGetProcAddress('glDeleteLists'); - glDisableClientState := dglGetProcAddress('glDisableClientState'); - glDrawPixels := dglGetProcAddress('glDrawPixels'); - glEdgeFlag := dglGetProcAddress('glEdgeFlag'); - glEdgeFlagPointer := dglGetProcAddress('glEdgeFlagPointer'); - glEdgeFlagv := dglGetProcAddress('glEdgeFlagv'); - glEnableClientState := dglGetProcAddress('glEnableClientState'); - glEnd := dglGetProcAddress('glEnd'); - glEndList := dglGetProcAddress('glEndList'); - glEvalCoord1d := dglGetProcAddress('glEvalCoord1d'); - glEvalCoord1dv := dglGetProcAddress('glEvalCoord1dv'); - glEvalCoord1f := dglGetProcAddress('glEvalCoord1f'); - glEvalCoord1fv := dglGetProcAddress('glEvalCoord1fv'); - glEvalCoord2d := dglGetProcAddress('glEvalCoord2d'); - glEvalCoord2dv := dglGetProcAddress('glEvalCoord2dv'); - glEvalCoord2f := dglGetProcAddress('glEvalCoord2f'); - glEvalCoord2fv := dglGetProcAddress('glEvalCoord2fv'); - glEvalMesh1 := dglGetProcAddress('glEvalMesh1'); - glEvalMesh2 := dglGetProcAddress('glEvalMesh2'); - glEvalPoint1 := dglGetProcAddress('glEvalPoint1'); - glEvalPoint2 := dglGetProcAddress('glEvalPoint2'); - glFeedbackBuffer := dglGetProcAddress('glFeedbackBuffer'); - glFogf := dglGetProcAddress('glFogf'); - glFogfv := dglGetProcAddress('glFogfv'); - glFogi := dglGetProcAddress('glFogi'); - glFogiv := dglGetProcAddress('glFogiv'); - glFrustum := dglGetProcAddress('glFrustum'); - glGenLists := dglGetProcAddress('glGenLists'); - glGetClipPlane := dglGetProcAddress('glGetClipPlane'); - glGetLightfv := dglGetProcAddress('glGetLightfv'); - glGetLightiv := dglGetProcAddress('glGetLightiv'); - glGetMapdv := dglGetProcAddress('glGetMapdv'); - glGetMapfv := dglGetProcAddress('glGetMapfv'); - glGetMapiv := dglGetProcAddress('glGetMapiv'); - glGetMaterialfv := dglGetProcAddress('glGetMaterialfv'); - glGetMaterialiv := dglGetProcAddress('glGetMaterialiv'); - glGetPixelMapfv := dglGetProcAddress('glGetPixelMapfv'); - glGetPixelMapuiv := dglGetProcAddress('glGetPixelMapuiv'); - glGetPixelMapusv := dglGetProcAddress('glGetPixelMapusv'); - glGetPolygonStipple := dglGetProcAddress('glGetPolygonStipple'); - glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv'); - glGetTexEnviv := dglGetProcAddress('glGetTexEnviv'); - glGetTexGendv := dglGetProcAddress('glGetTexGendv'); - glGetTexGenfv := dglGetProcAddress('glGetTexGenfv'); - glGetTexGeniv := dglGetProcAddress('glGetTexGeniv'); - glIndexMask := dglGetProcAddress('glIndexMask'); - glIndexPointer := dglGetProcAddress('glIndexPointer'); - glIndexd := dglGetProcAddress('glIndexd'); - glIndexdv := dglGetProcAddress('glIndexdv'); - glIndexf := dglGetProcAddress('glIndexf'); - glIndexfv := dglGetProcAddress('glIndexfv'); - glIndexi := dglGetProcAddress('glIndexi'); - glIndexiv := dglGetProcAddress('glIndexiv'); - glIndexs := dglGetProcAddress('glIndexs'); - glIndexsv := dglGetProcAddress('glIndexsv'); - glIndexub := dglGetProcAddress('glIndexub'); - glIndexubv := dglGetProcAddress('glIndexubv'); - glInitNames := dglGetProcAddress('glInitNames'); - glInterleavedArrays := dglGetProcAddress('glInterleavedArrays'); - glIsList := dglGetProcAddress('glIsList'); - glIsTexture := dglGetProcAddress('glIsTexture'); - glLightModelf := dglGetProcAddress('glLightModelf'); - glLightModelfv := dglGetProcAddress('glLightModelfv'); - glLightModeli := dglGetProcAddress('glLightModeli'); - glLightModeliv := dglGetProcAddress('glLightModeliv'); - glLightf := dglGetProcAddress('glLightf'); - glLightfv := dglGetProcAddress('glLightfv'); - glLighti := dglGetProcAddress('glLighti'); - glLightiv := dglGetProcAddress('glLightiv'); - glLineStipple := dglGetProcAddress('glLineStipple'); - glListBase := dglGetProcAddress('glListBase'); - glLoadIdentity := dglGetProcAddress('glLoadIdentity'); - glLoadMatrixd := dglGetProcAddress('glLoadMatrixd'); - glLoadMatrixf := dglGetProcAddress('glLoadMatrixf'); - glLoadName := dglGetProcAddress('glLoadName'); - glMap1d := dglGetProcAddress('glMap1d'); - glMap1f := dglGetProcAddress('glMap1f'); - glMap2d := dglGetProcAddress('glMap2d'); - glMap2f := dglGetProcAddress('glMap2f'); - glMapGrid1d := dglGetProcAddress('glMapGrid1d'); - glMapGrid1f := dglGetProcAddress('glMapGrid1f'); - glMapGrid2d := dglGetProcAddress('glMapGrid2d'); - glMapGrid2f := dglGetProcAddress('glMapGrid2f'); - glMaterialf := dglGetProcAddress('glMaterialf'); - glMaterialfv := dglGetProcAddress('glMaterialfv'); - glMateriali := dglGetProcAddress('glMateriali'); - glMaterialiv := dglGetProcAddress('glMaterialiv'); - glMatrixMode := dglGetProcAddress('glMatrixMode'); - glMultMatrixd := dglGetProcAddress('glMultMatrixd'); - glMultMatrixf := dglGetProcAddress('glMultMatrixf'); - glNewList := dglGetProcAddress('glNewList'); - glNormal3b := dglGetProcAddress('glNormal3b'); - glNormal3bv := dglGetProcAddress('glNormal3bv'); - glNormal3d := dglGetProcAddress('glNormal3d'); - glNormal3dv := dglGetProcAddress('glNormal3dv'); - glNormal3f := dglGetProcAddress('glNormal3f'); - glNormal3fv := dglGetProcAddress('glNormal3fv'); - glNormal3i := dglGetProcAddress('glNormal3i'); - glNormal3iv := dglGetProcAddress('glNormal3iv'); - glNormal3s := dglGetProcAddress('glNormal3s'); - glNormal3sv := dglGetProcAddress('glNormal3sv'); - glNormalPointer := dglGetProcAddress('glNormalPointer'); - glOrtho := dglGetProcAddress('glOrtho'); - glPassThrough := dglGetProcAddress('glPassThrough'); - glPixelMapfv := dglGetProcAddress('glPixelMapfv'); - glPixelMapuiv := dglGetProcAddress('glPixelMapuiv'); - glPixelMapusv := dglGetProcAddress('glPixelMapusv'); - glPixelTransferf := dglGetProcAddress('glPixelTransferf'); - glPixelTransferi := dglGetProcAddress('glPixelTransferi'); - glPixelZoom := dglGetProcAddress('glPixelZoom'); - glPolygonStipple := dglGetProcAddress('glPolygonStipple'); - glPopAttrib := dglGetProcAddress('glPopAttrib'); - glPopClientAttrib := dglGetProcAddress('glPopClientAttrib'); - glPopMatrix := dglGetProcAddress('glPopMatrix'); - glPopName := dglGetProcAddress('glPopName'); - glPrioritizeTextures := dglGetProcAddress('glPrioritizeTextures'); - glPushAttrib := dglGetProcAddress('glPushAttrib'); - glPushClientAttrib := dglGetProcAddress('glPushClientAttrib'); - glPushMatrix := dglGetProcAddress('glPushMatrix'); - glPushName := dglGetProcAddress('glPushName'); - glRasterPos2d := dglGetProcAddress('glRasterPos2d'); - glRasterPos2dv := dglGetProcAddress('glRasterPos2dv'); - glRasterPos2f := dglGetProcAddress('glRasterPos2f'); - glRasterPos2fv := dglGetProcAddress('glRasterPos2fv'); - glRasterPos2i := dglGetProcAddress('glRasterPos2i'); - glRasterPos2iv := dglGetProcAddress('glRasterPos2iv'); - glRasterPos2s := dglGetProcAddress('glRasterPos2s'); - glRasterPos2sv := dglGetProcAddress('glRasterPos2sv'); - glRasterPos3d := dglGetProcAddress('glRasterPos3d'); - glRasterPos3dv := dglGetProcAddress('glRasterPos3dv'); - glRasterPos3f := dglGetProcAddress('glRasterPos3f'); - glRasterPos3fv := dglGetProcAddress('glRasterPos3fv'); - glRasterPos3i := dglGetProcAddress('glRasterPos3i'); - glRasterPos3iv := dglGetProcAddress('glRasterPos3iv'); - glRasterPos3s := dglGetProcAddress('glRasterPos3s'); - glRasterPos3sv := dglGetProcAddress('glRasterPos3sv'); - glRasterPos4d := dglGetProcAddress('glRasterPos4d'); - glRasterPos4dv := dglGetProcAddress('glRasterPos4dv'); - glRasterPos4f := dglGetProcAddress('glRasterPos4f'); - glRasterPos4fv := dglGetProcAddress('glRasterPos4fv'); - glRasterPos4i := dglGetProcAddress('glRasterPos4i'); - glRasterPos4iv := dglGetProcAddress('glRasterPos4iv'); - glRasterPos4s := dglGetProcAddress('glRasterPos4s'); - glRasterPos4sv := dglGetProcAddress('glRasterPos4sv'); - glRectd := dglGetProcAddress('glRectd'); - glRectdv := dglGetProcAddress('glRectdv'); - glRectf := dglGetProcAddress('glRectf'); - glRectfv := dglGetProcAddress('glRectfv'); - glRecti := dglGetProcAddress('glRecti'); - glRectiv := dglGetProcAddress('glRectiv'); - glRects := dglGetProcAddress('glRects'); - glRectsv := dglGetProcAddress('glRectsv'); - glRenderMode := dglGetProcAddress('glRenderMode'); - glRotated := dglGetProcAddress('glRotated'); - glRotatef := dglGetProcAddress('glRotatef'); - glScaled := dglGetProcAddress('glScaled'); - glScalef := dglGetProcAddress('glScalef'); - glSelectBuffer := dglGetProcAddress('glSelectBuffer'); - glShadeModel := dglGetProcAddress('glShadeModel'); - glTexCoord1d := dglGetProcAddress('glTexCoord1d'); - glTexCoord1dv := dglGetProcAddress('glTexCoord1dv'); - glTexCoord1f := dglGetProcAddress('glTexCoord1f'); - glTexCoord1fv := dglGetProcAddress('glTexCoord1fv'); - glTexCoord1i := dglGetProcAddress('glTexCoord1i'); - glTexCoord1iv := dglGetProcAddress('glTexCoord1iv'); - glTexCoord1s := dglGetProcAddress('glTexCoord1s'); - glTexCoord1sv := dglGetProcAddress('glTexCoord1sv'); - glTexCoord2d := dglGetProcAddress('glTexCoord2d'); - glTexCoord2dv := dglGetProcAddress('glTexCoord2dv'); - glTexCoord2f := dglGetProcAddress('glTexCoord2f'); - glTexCoord2fv := dglGetProcAddress('glTexCoord2fv'); - glTexCoord2i := dglGetProcAddress('glTexCoord2i'); - glTexCoord2iv := dglGetProcAddress('glTexCoord2iv'); - glTexCoord2s := dglGetProcAddress('glTexCoord2s'); - glTexCoord2sv := dglGetProcAddress('glTexCoord2sv'); - glTexCoord3d := dglGetProcAddress('glTexCoord3d'); - glTexCoord3dv := dglGetProcAddress('glTexCoord3dv'); - glTexCoord3f := dglGetProcAddress('glTexCoord3f'); - glTexCoord3fv := dglGetProcAddress('glTexCoord3fv'); - glTexCoord3i := dglGetProcAddress('glTexCoord3i'); - glTexCoord3iv := dglGetProcAddress('glTexCoord3iv'); - glTexCoord3s := dglGetProcAddress('glTexCoord3s'); - glTexCoord3sv := dglGetProcAddress('glTexCoord3sv'); - glTexCoord4d := dglGetProcAddress('glTexCoord4d'); - glTexCoord4dv := dglGetProcAddress('glTexCoord4dv'); - glTexCoord4f := dglGetProcAddress('glTexCoord4f'); - glTexCoord4fv := dglGetProcAddress('glTexCoord4fv'); - glTexCoord4i := dglGetProcAddress('glTexCoord4i'); - glTexCoord4iv := dglGetProcAddress('glTexCoord4iv'); - glTexCoord4s := dglGetProcAddress('glTexCoord4s'); - glTexCoord4sv := dglGetProcAddress('glTexCoord4sv'); - glTexCoordPointer := dglGetProcAddress('glTexCoordPointer'); - glTexEnvf := dglGetProcAddress('glTexEnvf'); - glTexEnvfv := dglGetProcAddress('glTexEnvfv'); - glTexEnvi := dglGetProcAddress('glTexEnvi'); - glTexEnviv := dglGetProcAddress('glTexEnviv'); - glTexGend := dglGetProcAddress('glTexGend'); - glTexGendv := dglGetProcAddress('glTexGendv'); - glTexGenf := dglGetProcAddress('glTexGenf'); - glTexGenfv := dglGetProcAddress('glTexGenfv'); - glTexGeni := dglGetProcAddress('glTexGeni'); - glTexGeniv := dglGetProcAddress('glTexGeniv'); - glTranslated := dglGetProcAddress('glTranslated'); - glTranslatef := dglGetProcAddress('glTranslatef'); - glVertex2d := dglGetProcAddress('glVertex2d'); - glVertex2dv := dglGetProcAddress('glVertex2dv'); - glVertex2f := dglGetProcAddress('glVertex2f'); - glVertex2fv := dglGetProcAddress('glVertex2fv'); - glVertex2i := dglGetProcAddress('glVertex2i'); - glVertex2iv := dglGetProcAddress('glVertex2iv'); - glVertex2s := dglGetProcAddress('glVertex2s'); - glVertex2sv := dglGetProcAddress('glVertex2sv'); - glVertex3d := dglGetProcAddress('glVertex3d'); - glVertex3dv := dglGetProcAddress('glVertex3dv'); - glVertex3f := dglGetProcAddress('glVertex3f'); - glVertex3fv := dglGetProcAddress('glVertex3fv'); - glVertex3i := dglGetProcAddress('glVertex3i'); - glVertex3iv := dglGetProcAddress('glVertex3iv'); - glVertex3s := dglGetProcAddress('glVertex3s'); - glVertex3sv := dglGetProcAddress('glVertex3sv'); - glVertex4d := dglGetProcAddress('glVertex4d'); - glVertex4dv := dglGetProcAddress('glVertex4dv'); - glVertex4f := dglGetProcAddress('glVertex4f'); - glVertex4fv := dglGetProcAddress('glVertex4fv'); - glVertex4i := dglGetProcAddress('glVertex4i'); - glVertex4iv := dglGetProcAddress('glVertex4iv'); - glVertex4s := dglGetProcAddress('glVertex4s'); - glVertex4sv := dglGetProcAddress('glVertex4sv'); - glVertexPointer := dglGetProcAddress('glVertexPointer'); -{$endif} - - // GL_VERSION_1_2 - glBlendColor := dglGetProcAddress('glBlendColor'); - glBlendEquation := dglGetProcAddress('glBlendEquation'); - glDrawRangeElements := dglGetProcAddress('glDrawRangeElements'); - glTexImage3D := dglGetProcAddress('glTexImage3D'); - glTexSubImage3D := dglGetProcAddress('glTexSubImage3D'); - glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D'); -{$ifdef DGL_DEPRECATED} - glColorTable := dglGetProcAddress('glColorTable'); - glColorTableParameterfv := dglGetProcAddress('glColorTableParameterfv'); - glColorTableParameteriv := dglGetProcAddress('glColorTableParameteriv'); - glCopyColorTable := dglGetProcAddress('glCopyColorTable'); - glGetColorTable := dglGetProcAddress('glGetColorTable'); - glGetColorTableParameterfv := dglGetProcAddress('glGetColorTableParameterfv'); - glGetColorTableParameteriv := dglGetProcAddress('glGetColorTableParameteriv'); - glColorSubTable := dglGetProcAddress('glColorSubTable'); - glCopyColorSubTable := dglGetProcAddress('glCopyColorSubTable'); - glConvolutionFilter1D := dglGetProcAddress('glConvolutionFilter1D'); - glConvolutionFilter2D := dglGetProcAddress('glConvolutionFilter2D'); - glConvolutionParameterf := dglGetProcAddress('glConvolutionParameterf'); - glConvolutionParameterfv := dglGetProcAddress('glConvolutionParameterfv'); - glConvolutionParameteri := dglGetProcAddress('glConvolutionParameteri'); - glConvolutionParameteriv := dglGetProcAddress('glConvolutionParameteriv'); - glCopyConvolutionFilter1D := dglGetProcAddress('glCopyConvolutionFilter1D'); - glCopyConvolutionFilter2D := dglGetProcAddress('glCopyConvolutionFilter2D'); - glGetConvolutionFilter := dglGetProcAddress('glGetConvolutionFilter'); - glGetConvolutionParameterfv := dglGetProcAddress('glGetConvolutionParameterfv'); - glGetConvolutionParameteriv := dglGetProcAddress('glGetConvolutionParameteriv'); - glGetSeparableFilter := dglGetProcAddress('glGetSeparableFilter'); - glSeparableFilter2D := dglGetProcAddress('glSeparableFilter2D'); - glGetHistogram := dglGetProcAddress('glGetHistogram'); - glGetHistogramParameterfv := dglGetProcAddress('glGetHistogramParameterfv'); - glGetHistogramParameteriv := dglGetProcAddress('glGetHistogramParameteriv'); - glGetMinmax := dglGetProcAddress('glGetMinmax'); - glGetMinmaxParameterfv := dglGetProcAddress('glGetMinmaxParameterfv'); - glGetMinmaxParameteriv := dglGetProcAddress('glGetMinmaxParameteriv'); - glHistogram := dglGetProcAddress('glHistogram'); - glMinmax := dglGetProcAddress('glMinmax'); - glResetHistogram := dglGetProcAddress('glResetHistogram'); - glResetMinmax := dglGetProcAddress('glResetMinmax'); -{$endif} - - // GL_VERSION_1_3 - glActiveTexture := dglGetProcAddress('glActiveTexture'); - glSampleCoverage := dglGetProcAddress('glSampleCoverage'); - glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D'); - glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D'); - glCompressedTexImage1D := dglGetProcAddress('glCompressedTexImage1D'); - glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D'); - glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D'); - glCompressedTexSubImage1D := dglGetProcAddress('glCompressedTexSubImage1D'); - glGetCompressedTexImage := dglGetProcAddress('glGetCompressedTexImage'); -{$ifdef DGL_DEPRECATED} - glClientActiveTexture := dglGetProcAddress('glClientActiveTexture'); - glMultiTexCoord1d := dglGetProcAddress('glMultiTexCoord1d'); - glMultiTexCoord1dv := dglGetProcAddress('glMultiTexCoord1dv'); - glMultiTexCoord1f := dglGetProcAddress('glMultiTexCoord1f'); - glMultiTexCoord1fv := dglGetProcAddress('glMultiTexCoord1fv'); - glMultiTexCoord1i := dglGetProcAddress('glMultiTexCoord1i'); - glMultiTexCoord1iv := dglGetProcAddress('glMultiTexCoord1iv'); - glMultiTexCoord1s := dglGetProcAddress('glMultiTexCoord1s'); - glMultiTexCoord1sv := dglGetProcAddress('glMultiTexCoord1sv'); - glMultiTexCoord2d := dglGetProcAddress('glMultiTexCoord2d'); - glMultiTexCoord2dv := dglGetProcAddress('glMultiTexCoord2dv'); - glMultiTexCoord2f := dglGetProcAddress('glMultiTexCoord2f'); - glMultiTexCoord2fv := dglGetProcAddress('glMultiTexCoord2fv'); - glMultiTexCoord2i := dglGetProcAddress('glMultiTexCoord2i'); - glMultiTexCoord2iv := dglGetProcAddress('glMultiTexCoord2iv'); - glMultiTexCoord2s := dglGetProcAddress('glMultiTexCoord2s'); - glMultiTexCoord2sv := dglGetProcAddress('glMultiTexCoord2sv'); - glMultiTexCoord3d := dglGetProcAddress('glMultiTexCoord3d'); - glMultiTexCoord3dv := dglGetProcAddress('glMultiTexCoord3dv'); - glMultiTexCoord3f := dglGetProcAddress('glMultiTexCoord3f'); - glMultiTexCoord3fv := dglGetProcAddress('glMultiTexCoord3fv'); - glMultiTexCoord3i := dglGetProcAddress('glMultiTexCoord3i'); - glMultiTexCoord3iv := dglGetProcAddress('glMultiTexCoord3iv'); - glMultiTexCoord3s := dglGetProcAddress('glMultiTexCoord3s'); - glMultiTexCoord3sv := dglGetProcAddress('glMultiTexCoord3sv'); - glMultiTexCoord4d := dglGetProcAddress('glMultiTexCoord4d'); - glMultiTexCoord4dv := dglGetProcAddress('glMultiTexCoord4dv'); - glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f'); - glMultiTexCoord4fv := dglGetProcAddress('glMultiTexCoord4fv'); - glMultiTexCoord4i := dglGetProcAddress('glMultiTexCoord4i'); - glMultiTexCoord4iv := dglGetProcAddress('glMultiTexCoord4iv'); - glMultiTexCoord4s := dglGetProcAddress('glMultiTexCoord4s'); - glMultiTexCoord4sv := dglGetProcAddress('glMultiTexCoord4sv'); - glLoadTransposeMatrixf := dglGetProcAddress('glLoadTransposeMatrixf'); - glLoadTransposeMatrixd := dglGetProcAddress('glLoadTransposeMatrixd'); - glMultTransposeMatrixf := dglGetProcAddress('glMultTransposeMatrixf'); - glMultTransposeMatrixd := dglGetProcAddress('glMultTransposeMatrixd'); -{$endif} - - // GL_VERSION_1_4 - glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate'); - glMultiDrawArrays := dglGetProcAddress('glMultiDrawArrays'); - glMultiDrawElements := dglGetProcAddress('glMultiDrawElements'); - glPointParameterf := dglGetProcAddress('glPointParameterf'); - glPointParameterfv := dglGetProcAddress('glPointParameterfv'); - glPointParameteri := dglGetProcAddress('glPointParameteri'); - glPointParameteriv := dglGetProcAddress('glPointParameteriv'); -{$ifdef DGL_DEPRECATED} - glFogCoordf := dglGetProcAddress('glFogCoordf'); - glFogCoordfv := dglGetProcAddress('glFogCoordfv'); - glFogCoordd := dglGetProcAddress('glFogCoordd'); - glFogCoorddv := dglGetProcAddress('glFogCoorddv'); - glFogCoordPointer := dglGetProcAddress('glFogCoordPointer'); - glSecondaryColor3b := dglGetProcAddress('glSecondaryColor3b'); - glSecondaryColor3bv := dglGetProcAddress('glSecondaryColor3bv'); - glSecondaryColor3d := dglGetProcAddress('glSecondaryColor3d'); - glSecondaryColor3dv := dglGetProcAddress('glSecondaryColor3dv'); - glSecondaryColor3f := dglGetProcAddress('glSecondaryColor3f'); - glSecondaryColor3fv := dglGetProcAddress('glSecondaryColor3fv'); - glSecondaryColor3i := dglGetProcAddress('glSecondaryColor3i'); - glSecondaryColor3iv := dglGetProcAddress('glSecondaryColor3iv'); - glSecondaryColor3s := dglGetProcAddress('glSecondaryColor3s'); - glSecondaryColor3sv := dglGetProcAddress('glSecondaryColor3sv'); - glSecondaryColor3ub := dglGetProcAddress('glSecondaryColor3ub'); - glSecondaryColor3ubv := dglGetProcAddress('glSecondaryColor3ubv'); - glSecondaryColor3ui := dglGetProcAddress('glSecondaryColor3ui'); - glSecondaryColor3uiv := dglGetProcAddress('glSecondaryColor3uiv'); - glSecondaryColor3us := dglGetProcAddress('glSecondaryColor3us'); - glSecondaryColor3usv := dglGetProcAddress('glSecondaryColor3usv'); - glSecondaryColorPointer := dglGetProcAddress('glSecondaryColorPointer'); - glWindowPos2d := dglGetProcAddress('glWindowPos2d'); - glWindowPos2dv := dglGetProcAddress('glWindowPos2dv'); - glWindowPos2f := dglGetProcAddress('glWindowPos2f'); - glWindowPos2fv := dglGetProcAddress('glWindowPos2fv'); - glWindowPos2i := dglGetProcAddress('glWindowPos2i'); - glWindowPos2iv := dglGetProcAddress('glWindowPos2iv'); - glWindowPos2s := dglGetProcAddress('glWindowPos2s'); - glWindowPos2sv := dglGetProcAddress('glWindowPos2sv'); - glWindowPos3d := dglGetProcAddress('glWindowPos3d'); - glWindowPos3dv := dglGetProcAddress('glWindowPos3dv'); - glWindowPos3f := dglGetProcAddress('glWindowPos3f'); - glWindowPos3fv := dglGetProcAddress('glWindowPos3fv'); - glWindowPos3i := dglGetProcAddress('glWindowPos3i'); - glWindowPos3iv := dglGetProcAddress('glWindowPos3iv'); - glWindowPos3s := dglGetProcAddress('glWindowPos3s'); - glWindowPos3sv := dglGetProcAddress('glWindowPos3sv'); -{$endif} - - // GL_VERSION_1_5 - glGenQueries := dglGetProcAddress('glGenQueries'); - glDeleteQueries := dglGetProcAddress('glDeleteQueries'); - glIsQuery := dglGetProcAddress('glIsQuery'); - glBeginQuery := dglGetProcAddress('glBeginQuery'); - glEndQuery := dglGetProcAddress('glEndQuery'); - glGetQueryiv := dglGetProcAddress('glGetQueryiv'); - glGetQueryObjectiv := dglGetProcAddress('glGetQueryObjectiv'); - glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv'); - glBindBuffer := dglGetProcAddress('glBindBuffer'); - glDeleteBuffers := dglGetProcAddress('glDeleteBuffers'); - glGenBuffers := dglGetProcAddress('glGenBuffers'); - glIsBuffer := dglGetProcAddress('glIsBuffer'); - glBufferData := dglGetProcAddress('glBufferData'); - glBufferSubData := dglGetProcAddress('glBufferSubData'); - glGetBufferSubData := dglGetProcAddress('glGetBufferSubData'); - glMapBuffer := dglGetProcAddress('glMapBuffer'); - glUnmapBuffer := dglGetProcAddress('glUnmapBuffer'); - glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv'); - glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv'); - - // GL_VERSION_2_0 - glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate'); - glDrawBuffers := dglGetProcAddress('glDrawBuffers'); - glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate'); - glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate'); - glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate'); - glAttachShader := dglGetProcAddress('glAttachShader'); - glBindAttribLocation := dglGetProcAddress('glBindAttribLocation'); - glCompileShader := dglGetProcAddress('glCompileShader'); - glCreateProgram := dglGetProcAddress('glCreateProgram'); - glCreateShader := dglGetProcAddress('glCreateShader'); - glDeleteProgram := dglGetProcAddress('glDeleteProgram'); - glDeleteShader := dglGetProcAddress('glDeleteShader'); - glDetachShader := dglGetProcAddress('glDetachShader'); - glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray'); - glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray'); - glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib'); - glGetActiveUniform := dglGetProcAddress('glGetActiveUniform'); - glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders'); - glGetAttribLocation := dglGetProcAddress('glGetAttribLocation'); - glGetProgramiv := dglGetProcAddress('glGetProgramiv'); - glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog'); - glGetShaderiv := dglGetProcAddress('glGetShaderiv'); - glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog'); - glGetShaderSource := dglGetProcAddress('glGetShaderSource'); - glGetUniformLocation := dglGetProcAddress('glGetUniformLocation'); - glGetUniformfv := dglGetProcAddress('glGetUniformfv'); - glGetUniformiv := dglGetProcAddress('glGetUniformiv'); - glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv'); - glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv'); - glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv'); - glIsProgram := dglGetProcAddress('glIsProgram'); - glIsShader := dglGetProcAddress('glIsShader'); - glLinkProgram := dglGetProcAddress('glLinkProgram'); - glShaderSource := dglGetProcAddress('glShaderSource'); - glUseProgram := dglGetProcAddress('glUseProgram'); - glUniform1f := dglGetProcAddress('glUniform1f'); - glUniform2f := dglGetProcAddress('glUniform2f'); - glUniform3f := dglGetProcAddress('glUniform3f'); - glUniform4f := dglGetProcAddress('glUniform4f'); - glUniform1i := dglGetProcAddress('glUniform1i'); - glUniform2i := dglGetProcAddress('glUniform2i'); - glUniform3i := dglGetProcAddress('glUniform3i'); - glUniform4i := dglGetProcAddress('glUniform4i'); - glUniform1fv := dglGetProcAddress('glUniform1fv'); - glUniform2fv := dglGetProcAddress('glUniform2fv'); - glUniform3fv := dglGetProcAddress('glUniform3fv'); - glUniform4fv := dglGetProcAddress('glUniform4fv'); - glUniform1iv := dglGetProcAddress('glUniform1iv'); - glUniform2iv := dglGetProcAddress('glUniform2iv'); - glUniform3iv := dglGetProcAddress('glUniform3iv'); - glUniform4iv := dglGetProcAddress('glUniform4iv'); - glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv'); - glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv'); - glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv'); - glValidateProgram := dglGetProcAddress('glValidateProgram'); - glVertexAttrib1d := dglGetProcAddress('glVertexAttrib1d'); - glVertexAttrib1dv := dglGetProcAddress('glVertexAttrib1dv'); - glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f'); - glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv'); - glVertexAttrib1s := dglGetProcAddress('glVertexAttrib1s'); - glVertexAttrib1sv := dglGetProcAddress('glVertexAttrib1sv'); - glVertexAttrib2d := dglGetProcAddress('glVertexAttrib2d'); - glVertexAttrib2dv := dglGetProcAddress('glVertexAttrib2dv'); - glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f'); - glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv'); - glVertexAttrib2s := dglGetProcAddress('glVertexAttrib2s'); - glVertexAttrib2sv := dglGetProcAddress('glVertexAttrib2sv'); - glVertexAttrib3d := dglGetProcAddress('glVertexAttrib3d'); - glVertexAttrib3dv := dglGetProcAddress('glVertexAttrib3dv'); - glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f'); - glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv'); - glVertexAttrib3s := dglGetProcAddress('glVertexAttrib3s'); - glVertexAttrib3sv := dglGetProcAddress('glVertexAttrib3sv'); - glVertexAttrib4Nbv := dglGetProcAddress('glVertexAttrib4Nbv'); - glVertexAttrib4Niv := dglGetProcAddress('glVertexAttrib4Niv'); - glVertexAttrib4Nsv := dglGetProcAddress('glVertexAttrib4Nsv'); - glVertexAttrib4Nub := dglGetProcAddress('glVertexAttrib4Nub'); - glVertexAttrib4Nubv := dglGetProcAddress('glVertexAttrib4Nubv'); - glVertexAttrib4Nuiv := dglGetProcAddress('glVertexAttrib4Nuiv'); - glVertexAttrib4Nusv := dglGetProcAddress('glVertexAttrib4Nusv'); - glVertexAttrib4bv := dglGetProcAddress('glVertexAttrib4bv'); - glVertexAttrib4d := dglGetProcAddress('glVertexAttrib4d'); - glVertexAttrib4dv := dglGetProcAddress('glVertexAttrib4dv'); - glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f'); - glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv'); - glVertexAttrib4iv := dglGetProcAddress('glVertexAttrib4iv'); - glVertexAttrib4s := dglGetProcAddress('glVertexAttrib4s'); - glVertexAttrib4sv := dglGetProcAddress('glVertexAttrib4sv'); - glVertexAttrib4ubv := dglGetProcAddress('glVertexAttrib4ubv'); - glVertexAttrib4uiv := dglGetProcAddress('glVertexAttrib4uiv'); - glVertexAttrib4usv := dglGetProcAddress('glVertexAttrib4usv'); - glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer'); - - // GL_VERSION_2_1 - glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv'); - glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv'); - glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv'); - glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv'); - glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv'); - glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv'); - - // GL_VERSION_3_0 - { OpenGL 3.0 also reuses entry points from these extensions: } - Read_GL_ARB_framebuffer_object; - Read_GL_ARB_map_buffer_range; - Read_GL_ARB_vertex_array_object; - - glColorMaski := dglGetProcAddress('glColorMaski'); - glGetBooleani_v := dglGetProcAddress('glGetBooleani_v'); - glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v'); - glEnablei := dglGetProcAddress('glEnablei'); - glDisablei := dglGetProcAddress('glDisablei'); - glIsEnabledi := dglGetProcAddress('glIsEnabledi'); - glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback'); - glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback'); - glBindBufferRange := dglGetProcAddress('glBindBufferRange'); - glBindBufferBase := dglGetProcAddress('glBindBufferBase'); - glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings'); - glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying'); - glClampColor := dglGetProcAddress('glClampColor'); - glBeginConditionalRender := dglGetProcAddress('glBeginConditionalRender'); - glEndConditionalRender := dglGetProcAddress('glEndConditionalRender'); - glVertexAttribI1i := dglGetProcAddress('glVertexAttribI1i'); - glVertexAttribI2i := dglGetProcAddress('glVertexAttribI2i'); - glVertexAttribI3i := dglGetProcAddress('glVertexAttribI3i'); - glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i'); - glVertexAttribI1ui := dglGetProcAddress('glVertexAttribI1ui'); - glVertexAttribI2ui := dglGetProcAddress('glVertexAttribI2ui'); - glVertexAttribI3ui := dglGetProcAddress('glVertexAttribI3ui'); - glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui'); - glVertexAttribI1iv := dglGetProcAddress('glVertexAttribI1iv'); - glVertexAttribI2iv := dglGetProcAddress('glVertexAttribI2iv'); - glVertexAttribI3iv := dglGetProcAddress('glVertexAttribI3iv'); - glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv'); - glVertexAttribI1uiv := dglGetProcAddress('glVertexAttribI1uiv'); - glVertexAttribI2uiv := dglGetProcAddress('glVertexAttribI2uiv'); - glVertexAttribI3uiv := dglGetProcAddress('glVertexAttribI3uiv'); - glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv'); - glVertexAttribI4bv := dglGetProcAddress('glVertexAttribI4bv'); - glVertexAttribI4sv := dglGetProcAddress('glVertexAttribI4sv'); - glVertexAttribI4ubv := dglGetProcAddress('glVertexAttribI4ubv'); - glVertexAttribI4usv := dglGetProcAddress('glVertexAttribI4usv'); - glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer'); - glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv'); - glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv'); - glGetUniformuiv := dglGetProcAddress('glGetUniformuiv'); - glBindFragDataLocation := dglGetProcAddress('glBindFragDataLocation'); - glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation'); - glUniform1ui := dglGetProcAddress('glUniform1ui'); - glUniform2ui := dglGetProcAddress('glUniform2ui'); - glUniform3ui := dglGetProcAddress('glUniform3ui'); - glUniform4ui := dglGetProcAddress('glUniform4ui'); - glUniform1uiv := dglGetProcAddress('glUniform1uiv'); - glUniform2uiv := dglGetProcAddress('glUniform2uiv'); - glUniform3uiv := dglGetProcAddress('glUniform3uiv'); - glUniform4uiv := dglGetProcAddress('glUniform4uiv'); - glTexParameterIiv := dglGetProcAddress('glTexParameterIiv'); - glTexParameterIuiv := dglGetProcAddress('glTexParameterIuiv'); - glGetTexParameterIiv := dglGetProcAddress('glGetTexParameterIiv'); - glGetTexParameterIuiv := dglGetProcAddress('glGetTexParameterIuiv'); - glClearBufferiv := dglGetProcAddress('glClearBufferiv'); - glClearBufferuiv := dglGetProcAddress('glClearBufferuiv'); - glClearBufferfv := dglGetProcAddress('glClearBufferfv'); - glClearBufferfi := dglGetProcAddress('glClearBufferfi'); - glGetStringi := dglGetProcAddress('glGetStringi'); - - // GL_VERSION_2_1 - glEnableVertexArrayEXT := dglGetProcAddress('glEnableVertexArrayEXT'); - glEnableVertexArrayAttribEXT := dglGetProcAddress('glEnableVertexArrayAttribEXT'); - glVertexArrayVertexAttribOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribOffsetEXT'); - - // GL_VERSION_3_1 - { OpenGL 3.1 also reuses entry points from these extensions: } - Read_GL_ARB_copy_buffer; - Read_GL_ARB_uniform_buffer_object; - - glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced'); - glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced'); - glTexBuffer := dglGetProcAddress('glTexBuffer'); - glPrimitiveRestartIndex := dglGetProcAddress('glPrimitiveRestartIndex'); - - // GL_VERSION_3_2 - { OpenGL 3.2 also reuses entry points from these extensions: } - Read_GL_ARB_draw_elements_base_vertex; - Read_GL_ARB_provoking_vertex; - Read_GL_ARB_sync; - Read_GL_ARB_texture_multisample; - - glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v'); - glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v'); - glFramebufferTexture := dglGetProcAddress('glFramebufferTexture'); -// glFramebufferTextureFace := dglGetProcAddress('glFramebufferTextureFace'); - - // GL_VERSION_3_3 - { OpenGL 3.3 also reuses entry points from these extensions: } - Read_GL_ARB_blend_func_extended; - Read_GL_ARB_sampler_objects; - { ARB_explicit_attrib_location, but it has none } - { ARB_occlusion_query2 (no entry points) } - { ARB_shader_bit_encoding (no entry points) } - { ARB_texture_rgb10_a2ui (no entry points) } - { ARB_texture_swizzle (no entry points) } - Read_GL_ARB_timer_query; - Read_GL_ARB_vertex_type_2_10_10_10_rev; - - glVertexAttribDivisor := dglGetProcAddress('glVertexAttribDivisor'); - - // GL_VERSION_4_0 - { OpenGL 4.0 also reuses entry points from these extensions: } - { ARB_texture_query_lod (no entry points) } - Read_GL_ARB_draw_indirect; - { ARB_gpu_shader5 (no entry points) } - Read_GL_ARB_gpu_shader_fp64; - Read_GL_ARB_shader_subroutine; - Read_GL_ARB_tessellation_shader; - { ARB_texture_buffer_object_rgb32 (no entry points) } - { ARB_texture_cube_map_array (no entry points) } - { ARB_texture_gather (no entry points) } - Read_GL_ARB_transform_feedback2; - Read_GL_ARB_transform_feedback3; - - glMinSampleShading := dglGetProcAddress('glMinSampleShading'); - glBlendEquationi := dglGetProcAddress('glBlendEquationi'); - glBlendEquationSeparatei := dglGetProcAddress('glBlendEquationSeparatei'); - glBlendFunci := dglGetProcAddress('glBlendFunci'); - glBlendFuncSeparatei := dglGetProcAddress('glBlendFuncSeparatei'); - - // GL_VERSION_4_1 - { OpenGL 4.1 also reuses entry points from these extensions: } - Read_GL_ARB_ES2_compatibility; - Read_GL_ARB_get_program_binary; - Read_GL_ARB_separate_shader_objects; - { ARB_shader_precision (no entry points) } - Read_GL_ARB_vertex_attrib_64bit; - Read_GL_ARB_viewport_array; - - // GL_VERSION_4_2 - { OpenGL 4.2 reuses entry points from these extensions: } - Read_GL_ARB_base_instance; - //Read_GL_ARB_shading_language_420pack (no entry points) - Read_GL_ARB_transform_feedback_instanced; - //Read_GL_ARB_compressed_texture_pixel_storage (no entry points) - //Read_GL_ARB_conservative_depth; - Read_GL_ARB_internalformat_query; - //Read_GL_ARB_map_buffer_alignment; - Read_GL_ARB_shader_atomic_counters; - Read_GL_ARB_shader_image_load_store; - //Read_GL_ARB_shading_language_packing; - Read_GL_ARB_texture_storage; - - // GL_VERSION_4_3 - // OpenGL 4.3 reuses entry points from these extensions: - // Read_GL_ARB_arrays_of_arrays (none, GLSL only) (no entry points) - // Read_GL_ARB_fragment_layer_viewport (none, GLSL only) (no entry points) - // Read_GL_ARB_shader_image_size (none, GLSL only) (no entry points) - // Read_GL_ARB_ES3_compatibility (no entry points) - Read_GL_ARB_clear_buffer_object; - Read_GL_ARB_compute_shader; - Read_GL_ARB_copy_image; - Read_GL_KHR_debug; - // Read_GL_ARB_explicit_uniform_location (no entry points) - Read_GL_ARB_framebuffer_no_attachments; - Read_GL_ARB_internalformat_query2; - Read_GL_ARB_invalidate_subdata; - Read_GL_ARB_multi_draw_indirect; - Read_GL_ARB_program_interface_query; - // Read_GL_ARB_robust_buffer_access_behavior (none) (no entry points) - Read_GL_ARB_shader_storage_buffer_object; - // Read_GL_ARB_stencil_texturing (no entry points) - Read_GL_ARB_texture_buffer_range; - // Read_GL_ARB_texture_query_levels (none) (no entry points) - Read_GL_ARB_texture_storage_multisample; - Read_GL_ARB_texture_view; - Read_GL_ARB_vertex_attrib_binding; - - // GL_VERSION_4_4 - // Note (Due to Khronos' change in header conventions, no more single read_ functions) - Read_GL_4_4; -end; - -procedure Read_GL_3DFX_tbuffer; -begin - glTbufferMask3DFX := dglGetProcAddress('glTbufferMask3DFX'); -end; - -procedure Read_GL_APPLE_element_array; -begin - glElementPointerAPPLE := dglGetProcAddress('glElementPointerAPPLE'); - glDrawElementArrayAPPLE := dglGetProcAddress('glDrawElementArrayAPPLE'); - glDrawRangeElementArrayAPPLE := dglGetProcAddress('glDrawRangeElementArrayAPPLE'); - glMultiDrawElementArrayAPPLE := dglGetProcAddress('glMultiDrawElementArrayAPPLE'); - glMultiDrawRangeElementArrayAPPLE := dglGetProcAddress('glMultiDrawRangeElementArrayAPPLE'); -end; - -procedure Read_GL_APPLE_fence; -begin - glGenFencesAPPLE := dglGetProcAddress('glGenFencesAPPLE'); - glDeleteFencesAPPLE := dglGetProcAddress('glDeleteFencesAPPLE'); - glSetFenceAPPLE := dglGetProcAddress('glSetFenceAPPLE'); - glIsFenceAPPLE := dglGetProcAddress('glIsFenceAPPLE'); - glTestFenceAPPLE := dglGetProcAddress('glTestFenceAPPLE'); - glFinishFenceAPPLE := dglGetProcAddress('glFinishFenceAPPLE'); - glTestObjectAPPLE := dglGetProcAddress('glTestObjectAPPLE'); - glFinishObjectAPPLE := dglGetProcAddress('glFinishObjectAPPLE'); -end; - -procedure Read_GL_APPLE_vertex_array_object; -begin - glBindVertexArrayAPPLE := dglGetProcAddress('glBindVertexArrayAPPLE'); - glDeleteVertexArraysAPPLE := dglGetProcAddress('glDeleteVertexArraysAPPLE'); - glGenVertexArraysAPPLE := dglGetProcAddress('glGenVertexArraysAPPLE'); - glIsVertexArrayAPPLE := dglGetProcAddress('glIsVertexArrayAPPLE'); -end; - -procedure Read_GL_APPLE_vertex_array_range; -begin - glVertexArrayRangeAPPLE := dglGetProcAddress('glVertexArrayRangeAPPLE'); - glFlushVertexArrayRangeAPPLE := dglGetProcAddress('glFlushVertexArrayRangeAPPLE'); - glVertexArrayParameteriAPPLE := dglGetProcAddress('glVertexArrayParameteriAPPLE'); -end; - -procedure Read_GL_APPLE_texture_range; -begin - glTextureRangeAPPLE := dglGetProcAddress('glTextureRangeAPPLE'); - glGetTexParameterPointervAPPLE := dglGetProcAddress('glGetTexParameterPointervAPPLE'); -end; - -procedure Read_GL_APPLE_vertex_program_evaluators; -begin - glEnableVertexAttribAPPLE := dglGetProcAddress('glEnableVertexAttribAPPLE'); - glDisableVertexAttribAPPLE := dglGetProcAddress('glDisableVertexAttribAPPLE'); - glIsVertexAttribEnabledAPPLE := dglGetProcAddress('glIsVertexAttribEnabledAPPLE'); - glMapVertexAttrib1dAPPLE := dglGetProcAddress('glMapVertexAttrib1dAPPLE'); - glMapVertexAttrib1fAPPLE := dglGetProcAddress('glMapVertexAttrib1fAPPLE'); - glMapVertexAttrib2dAPPLE := dglGetProcAddress('glMapVertexAttrib2dAPPLE'); - glMapVertexAttrib2fAPPLE := dglGetProcAddress('glMapVertexAttrib2fAPPLE'); -end; - -procedure Read_GL_APPLE_object_purgeable; -begin - glObjectPurgeableAPPLE := dglGetProcAddress('glObjectPurgeableAPPLE'); - glObjectUnpurgeableAPPLE := dglGetProcAddress('glObjectUnpurgeableAPPLE'); - glGetObjectParameterivAPPLE := dglGetProcAddress('glGetObjectParameterivAPPLE'); -end; - -procedure Read_GL_ARB_matrix_palette; -begin - glCurrentPaletteMatrixARB := dglGetProcAddress('glCurrentPaletteMatrixARB'); - glMatrixIndexubvARB := dglGetProcAddress('glMatrixIndexubvARB'); - glMatrixIndexusvARB := dglGetProcAddress('glMatrixIndexusvARB'); - glMatrixIndexuivARB := dglGetProcAddress('glMatrixIndexuivARB'); - glMatrixIndexPointerARB := dglGetProcAddress('glMatrixIndexPointerARB'); -end; - -procedure Read_GL_ARB_multisample; -begin - glSampleCoverageARB := dglGetProcAddress('glSampleCoverageARB'); -end; - -procedure Read_GL_ARB_multitexture; -begin - glActiveTextureARB := dglGetProcAddress('glActiveTextureARB'); - glClientActiveTextureARB := dglGetProcAddress('glClientActiveTextureARB'); - glMultiTexCoord1dARB := dglGetProcAddress('glMultiTexCoord1dARB'); - glMultiTexCoord1dvARB := dglGetProcAddress('glMultiTexCoord1dvARB'); - glMultiTexCoord1fARB := dglGetProcAddress('glMultiTexCoord1fARB'); - glMultiTexCoord1fvARB := dglGetProcAddress('glMultiTexCoord1fvARB'); - glMultiTexCoord1iARB := dglGetProcAddress('glMultiTexCoord1iARB'); - glMultiTexCoord1ivARB := dglGetProcAddress('glMultiTexCoord1ivARB'); - glMultiTexCoord1sARB := dglGetProcAddress('glMultiTexCoord1sARB'); - glMultiTexCoord1svARB := dglGetProcAddress('glMultiTexCoord1svARB'); - glMultiTexCoord2dARB := dglGetProcAddress('glMultiTexCoord2dARB'); - glMultiTexCoord2dvARB := dglGetProcAddress('glMultiTexCoord2dvARB'); - glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB'); - glMultiTexCoord2fvARB := dglGetProcAddress('glMultiTexCoord2fvARB'); - glMultiTexCoord2iARB := dglGetProcAddress('glMultiTexCoord2iARB'); - glMultiTexCoord2ivARB := dglGetProcAddress('glMultiTexCoord2ivARB'); - glMultiTexCoord2sARB := dglGetProcAddress('glMultiTexCoord2sARB'); - glMultiTexCoord2svARB := dglGetProcAddress('glMultiTexCoord2svARB'); - glMultiTexCoord3dARB := dglGetProcAddress('glMultiTexCoord3dARB'); - glMultiTexCoord3dvARB := dglGetProcAddress('glMultiTexCoord3dvARB'); - glMultiTexCoord3fARB := dglGetProcAddress('glMultiTexCoord3fARB'); - glMultiTexCoord3fvARB := dglGetProcAddress('glMultiTexCoord3fvARB'); - glMultiTexCoord3iARB := dglGetProcAddress('glMultiTexCoord3iARB'); - glMultiTexCoord3ivARB := dglGetProcAddress('glMultiTexCoord3ivARB'); - glMultiTexCoord3sARB := dglGetProcAddress('glMultiTexCoord3sARB'); - glMultiTexCoord3svARB := dglGetProcAddress('glMultiTexCoord3svARB'); - glMultiTexCoord4dARB := dglGetProcAddress('glMultiTexCoord4dARB'); - glMultiTexCoord4dvARB := dglGetProcAddress('glMultiTexCoord4dvARB'); - glMultiTexCoord4fARB := dglGetProcAddress('glMultiTexCoord4fARB'); - glMultiTexCoord4fvARB := dglGetProcAddress('glMultiTexCoord4fvARB'); - glMultiTexCoord4iARB := dglGetProcAddress('glMultiTexCoord4iARB'); - glMultiTexCoord4ivARB := dglGetProcAddress('glMultiTexCoord4ivARB'); - glMultiTexCoord4sARB := dglGetProcAddress('glMultiTexCoord4sARB'); - glMultiTexCoord4svARB := dglGetProcAddress('glMultiTexCoord4svARB'); -end; - -procedure Read_GL_ARB_point_parameters; -begin - glPointParameterfARB := dglGetProcAddress('glPointParameterfARB'); - glPointParameterfvARB := dglGetProcAddress('glPointParameterfvARB'); -end; - -procedure Read_GL_ARB_texture_compression; -begin - glCompressedTexImage3DARB := dglGetProcAddress('glCompressedTexImage3DARB'); - glCompressedTexImage2DARB := dglGetProcAddress('glCompressedTexImage2DARB'); - glCompressedTexImage1DARB := dglGetProcAddress('glCompressedTexImage1DARB'); - glCompressedTexSubImage3DARB := dglGetProcAddress('glCompressedTexSubImage3DARB'); - glCompressedTexSubImage2DARB := dglGetProcAddress('glCompressedTexSubImage2DARB'); - glCompressedTexSubImage1DARB := dglGetProcAddress('glCompressedTexSubImage1DARB'); - glGetCompressedTexImageARB := dglGetProcAddress('glGetCompressedTexImageARB'); -end; - -procedure Read_GL_ARB_transpose_matrix; -begin - glLoadTransposeMatrixfARB := dglGetProcAddress('glLoadTransposeMatrixfARB'); - glLoadTransposeMatrixdARB := dglGetProcAddress('glLoadTransposeMatrixdARB'); - glMultTransposeMatrixfARB := dglGetProcAddress('glMultTransposeMatrixfARB'); - glMultTransposeMatrixdARB := dglGetProcAddress('glMultTransposeMatrixdARB'); -end; - -procedure Read_GL_ARB_vertex_blend; -begin - glWeightbvARB := dglGetProcAddress('glWeightbvARB'); - glWeightsvARB := dglGetProcAddress('glWeightsvARB'); - glWeightivARB := dglGetProcAddress('glWeightivARB'); - glWeightfvARB := dglGetProcAddress('glWeightfvARB'); - glWeightdvARB := dglGetProcAddress('glWeightdvARB'); - glWeightubvARB := dglGetProcAddress('glWeightubvARB'); - glWeightusvARB := dglGetProcAddress('glWeightusvARB'); - glWeightuivARB := dglGetProcAddress('glWeightuivARB'); - glWeightPointerARB := dglGetProcAddress('glWeightPointerARB'); - glVertexBlendARB := dglGetProcAddress('glVertexBlendARB'); -end; - -procedure Read_GL_ARB_vertex_buffer_object; -begin - glBindBufferARB := dglGetProcAddress('glBindBufferARB'); - glDeleteBuffersARB := dglGetProcAddress('glDeleteBuffersARB'); - glGenBuffersARB := dglGetProcAddress('glGenBuffersARB'); - glIsBufferARB := dglGetProcAddress('glIsBufferARB'); - glBufferDataARB := dglGetProcAddress('glBufferDataARB'); - glBufferSubDataARB := dglGetProcAddress('glBufferSubDataARB'); - glGetBufferSubDataARB := dglGetProcAddress('glGetBufferSubDataARB'); - glMapBufferARB := dglGetProcAddress('glMapBufferARB'); - glUnmapBufferARB := dglGetProcAddress('glUnmapBufferARB'); - glGetBufferParameterivARB := dglGetProcAddress('glGetBufferParameterivARB'); - glGetBufferPointervARB := dglGetProcAddress('glGetBufferPointervARB'); -end; - -procedure Read_GL_ARB_vertex_program; -begin - glVertexAttrib1dARB := dglGetProcAddress('glVertexAttrib1dARB'); - glVertexAttrib1dvARB := dglGetProcAddress('glVertexAttrib1dvARB'); - glVertexAttrib1fARB := dglGetProcAddress('glVertexAttrib1fARB'); - glVertexAttrib1fvARB := dglGetProcAddress('glVertexAttrib1fvARB'); - glVertexAttrib1sARB := dglGetProcAddress('glVertexAttrib1sARB'); - glVertexAttrib1svARB := dglGetProcAddress('glVertexAttrib1svARB'); - glVertexAttrib2dARB := dglGetProcAddress('glVertexAttrib2dARB'); - glVertexAttrib2dvARB := dglGetProcAddress('glVertexAttrib2dvARB'); - glVertexAttrib2fARB := dglGetProcAddress('glVertexAttrib2fARB'); - glVertexAttrib2fvARB := dglGetProcAddress('glVertexAttrib2fvARB'); - glVertexAttrib2sARB := dglGetProcAddress('glVertexAttrib2sARB'); - glVertexAttrib2svARB := dglGetProcAddress('glVertexAttrib2svARB'); - glVertexAttrib3dARB := dglGetProcAddress('glVertexAttrib3dARB'); - glVertexAttrib3dvARB := dglGetProcAddress('glVertexAttrib3dvARB'); - glVertexAttrib3fARB := dglGetProcAddress('glVertexAttrib3fARB'); - glVertexAttrib3fvARB := dglGetProcAddress('glVertexAttrib3fvARB'); - glVertexAttrib3sARB := dglGetProcAddress('glVertexAttrib3sARB'); - glVertexAttrib3svARB := dglGetProcAddress('glVertexAttrib3svARB'); - glVertexAttrib4NbvARB := dglGetProcAddress('glVertexAttrib4NbvARB'); - glVertexAttrib4NivARB := dglGetProcAddress('glVertexAttrib4NivARB'); - glVertexAttrib4NsvARB := dglGetProcAddress('glVertexAttrib4NsvARB'); - glVertexAttrib4NubARB := dglGetProcAddress('glVertexAttrib4NubARB'); - glVertexAttrib4NubvARB := dglGetProcAddress('glVertexAttrib4NubvARB'); - glVertexAttrib4NuivARB := dglGetProcAddress('glVertexAttrib4NuivARB'); - glVertexAttrib4NusvARB := dglGetProcAddress('glVertexAttrib4NusvARB'); - glVertexAttrib4bvARB := dglGetProcAddress('glVertexAttrib4bvARB'); - glVertexAttrib4dARB := dglGetProcAddress('glVertexAttrib4dARB'); - glVertexAttrib4dvARB := dglGetProcAddress('glVertexAttrib4dvARB'); - glVertexAttrib4fARB := dglGetProcAddress('glVertexAttrib4fARB'); - glVertexAttrib4fvARB := dglGetProcAddress('glVertexAttrib4fvARB'); - glVertexAttrib4ivARB := dglGetProcAddress('glVertexAttrib4ivARB'); - glVertexAttrib4sARB := dglGetProcAddress('glVertexAttrib4sARB'); - glVertexAttrib4svARB := dglGetProcAddress('glVertexAttrib4svARB'); - glVertexAttrib4ubvARB := dglGetProcAddress('glVertexAttrib4ubvARB'); - glVertexAttrib4uivARB := dglGetProcAddress('glVertexAttrib4uivARB'); - glVertexAttrib4usvARB := dglGetProcAddress('glVertexAttrib4usvARB'); - glVertexAttribPointerARB := dglGetProcAddress('glVertexAttribPointerARB'); - glEnableVertexAttribArrayARB := dglGetProcAddress('glEnableVertexAttribArrayARB'); - glDisableVertexAttribArrayARB := dglGetProcAddress('glDisableVertexAttribArrayARB'); - glProgramStringARB := dglGetProcAddress('glProgramStringARB'); - glBindProgramARB := dglGetProcAddress('glBindProgramARB'); - glDeleteProgramsARB := dglGetProcAddress('glDeleteProgramsARB'); - glGenProgramsARB := dglGetProcAddress('glGenProgramsARB'); - glProgramEnvParameter4dARB := dglGetProcAddress('glProgramEnvParameter4dARB'); - glProgramEnvParameter4dvARB := dglGetProcAddress('glProgramEnvParameter4dvARB'); - glProgramEnvParameter4fARB := dglGetProcAddress('glProgramEnvParameter4fARB'); - glProgramEnvParameter4fvARB := dglGetProcAddress('glProgramEnvParameter4fvARB'); - glProgramLocalParameter4dARB := dglGetProcAddress('glProgramLocalParameter4dARB'); - glProgramLocalParameter4dvARB := dglGetProcAddress('glProgramLocalParameter4dvARB'); - glProgramLocalParameter4fARB := dglGetProcAddress('glProgramLocalParameter4fARB'); - glProgramLocalParameter4fvARB := dglGetProcAddress('glProgramLocalParameter4fvARB'); - glGetProgramEnvParameterdvARB := dglGetProcAddress('glGetProgramEnvParameterdvARB'); - glGetProgramEnvParameterfvARB := dglGetProcAddress('glGetProgramEnvParameterfvARB'); - glGetProgramLocalParameterdvARB := dglGetProcAddress('glGetProgramLocalParameterdvARB'); - glGetProgramLocalParameterfvARB := dglGetProcAddress('glGetProgramLocalParameterfvARB'); - glGetProgramivARB := dglGetProcAddress('glGetProgramivARB'); - glGetProgramStringARB := dglGetProcAddress('glGetProgramStringARB'); - glGetVertexAttribdvARB := dglGetProcAddress('glGetVertexAttribdvARB'); - glGetVertexAttribfvARB := dglGetProcAddress('glGetVertexAttribfvARB'); - glGetVertexAttribivARB := dglGetProcAddress('glGetVertexAttribivARB'); - glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB'); - glIsProgramARB := dglGetProcAddress('glIsProgramARB'); -end; - -procedure Read_GL_ARB_window_pos; -begin - glWindowPos2dARB := dglGetProcAddress('glWindowPos2dARB'); - glWindowPos2dvARB := dglGetProcAddress('glWindowPos2dvARB'); - glWindowPos2fARB := dglGetProcAddress('glWindowPos2fARB'); - glWindowPos2fvARB := dglGetProcAddress('glWindowPos2fvARB'); - glWindowPos2iARB := dglGetProcAddress('glWindowPos2iARB'); - glWindowPos2ivARB := dglGetProcAddress('glWindowPos2ivARB'); - glWindowPos2sARB := dglGetProcAddress('glWindowPos2sARB'); - glWindowPos2svARB := dglGetProcAddress('glWindowPos2svARB'); - glWindowPos3dARB := dglGetProcAddress('glWindowPos3dARB'); - glWindowPos3dvARB := dglGetProcAddress('glWindowPos3dvARB'); - glWindowPos3fARB := dglGetProcAddress('glWindowPos3fARB'); - glWindowPos3fvARB := dglGetProcAddress('glWindowPos3fvARB'); - glWindowPos3iARB := dglGetProcAddress('glWindowPos3iARB'); - glWindowPos3ivARB := dglGetProcAddress('glWindowPos3ivARB'); - glWindowPos3sARB := dglGetProcAddress('glWindowPos3sARB'); - glWindowPos3svARB := dglGetProcAddress('glWindowPos3svARB'); -end; - -procedure Read_GL_ARB_draw_buffers; -begin - glDrawBuffersARB := dglGetProcAddress('glDrawBuffersARB'); -end; - -procedure Read_GL_ARB_color_buffer_float; -begin - glClampColorARB := dglGetProcAddress('glClampColorARB'); -end; - -procedure Read_GL_ARB_Shader_Objects; -begin - // GL_ARB_Shader_Objects - glCreateShaderObjectARB := dglGetProcAddress('glCreateShaderObjectARB'); - glShaderSourceARB := dglGetProcAddress('glShaderSourceARB'); - glCompileShaderARB := dglGetProcAddress('glCompileShaderARB'); - glDeleteObjectARB := dglGetProcAddress('glDeleteObjectARB'); - glGetHandleARB := dglGetProcAddress('glGetHandleARB'); - glDetachObjectARB := dglGetProcAddress('glDetachObjectARB'); - glCreateProgramObjectARB := dglGetProcAddress('glCreateProgramObjectARB'); - glAttachObjectARB := dglGetProcAddress('glAttachObjectARB'); - glLinkProgramARB := dglGetProcAddress('glLinkProgramARB'); - glUseProgramObjectARB := dglGetProcAddress('glUseProgramObjectARB'); - glValidateProgramARB := dglGetProcAddress('glValidateProgramARB'); - glGetObjectParameterfvARB := dglGetProcAddress('glGetObjectParameterfvARB'); - glGetObjectParameterivARB := dglGetProcAddress('glGetObjectParameterivARB'); - glGetActiveUniformARB := dglGetProcAddress('glGetActiveUniformARB'); - glGetAttachedObjectsARB := dglGetProcAddress('glGetAttachedObjectsARB'); - glGetShaderSourceARB := dglGetProcAddress('glGetShaderSourceARB'); - glGetUniformfvARB := dglGetProcAddress('glGetUniformfvARB'); - glGetUniformivARB := dglGetProcAddress('glGetUniformivARB'); - glGetUniformLocationARB := dglGetProcAddress('glGetUniformLocationARB'); - glGetInfoLogARB := dglGetProcAddress('glGetInfoLogARB'); - glUniform1fARB := dglGetProcAddress('glUniform1fARB'); - glUniform2fARB := dglGetProcAddress('glUniform2fARB'); - glUniform3fARB := dglGetProcAddress('glUniform3fARB'); - glUniform4fARB := dglGetProcAddress('glUniform4fARB'); - glUniform1iARB := dglGetProcAddress('glUniform1iARB'); - glUniform2iARB := dglGetProcAddress('glUniform2iARB'); - glUniform3iARB := dglGetProcAddress('glUniform3iARB'); - glUniform4iARB := dglGetProcAddress('glUniform4iARB'); - glUniform1fvARB := dglGetProcAddress('glUniform1fvARB'); - glUniform2fvARB := dglGetProcAddress('glUniform2fvARB'); - glUniform3fvARB := dglGetProcAddress('glUniform3fvARB'); - glUniform4fvARB := dglGetProcAddress('glUniform4fvARB'); - glUniform1ivARB := dglGetProcAddress('glUniform1ivARB'); - glUniform2ivARB := dglGetProcAddress('glUniform2ivARB'); - glUniform3ivARB := dglGetProcAddress('glUniform3ivARB'); - glUniform4ivARB := dglGetProcAddress('glUniform4ivARB'); - glUniformMatrix2fvARB := dglGetProcAddress('glUniformMatrix2fvARB'); - glUniformMatrix3fvARB := dglGetProcAddress('glUniformMatrix3fvARB'); - glUniformMatrix4fvARB := dglGetProcAddress('glUniformMatrix4fvARB'); - - // GL_ARB_vertex_shader - glGetActiveAttribARB := dglGetProcAddress('glGetActiveAttribARB'); - glGetAttribLocationARB := dglGetProcAddress('glGetAttribLocationARB'); - glBindAttribLocationARB := dglGetProcAddress('glBindAttribLocationARB'); - glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB'); -end; - -procedure Read_GL_ARB_occlusion_query; -begin - glGenQueriesARB := dglGetProcAddress('glGenQueriesARB'); - glDeleteQueriesARB := dglGetProcAddress('glDeleteQueriesARB'); - glIsQueryARB := dglGetProcAddress('glIsQueryARB'); - glBeginQueryARB := dglGetProcAddress('glBeginQueryARB'); - glEndQueryARB := dglGetProcAddress('glEndQueryARB'); - glGetQueryivARB := dglGetProcAddress('glGetQueryivARB'); - glGetQueryObjectivARB := dglGetProcAddress('glGetQueryObjectivARB'); - glGetQueryObjectuivARB := dglGetProcAddress('glGetQueryObjectuivARB'); -end; - -procedure Read_GL_ARB_draw_instanced; -begin - glDrawArraysInstancedARB := dglGetProcAddress('glDrawArraysInstancedARB'); - glDrawElementsInstancedARB := dglGetProcAddress('glDrawElementsInstancedARB'); -end; - -procedure Read_GL_ARB_framebuffer_object; -begin - glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer'); - glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer'); - glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers'); - glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers'); - glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage'); - glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv'); - glIsFramebuffer := dglGetProcAddress('glIsFramebuffer'); - glBindFramebuffer := dglGetProcAddress('glBindFramebuffer'); - glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers'); - glGenFramebuffers := dglGetProcAddress('glGenFramebuffers'); - glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus'); - glFramebufferTexture1D := dglGetProcAddress('glFramebufferTexture1D'); - glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D'); - glFramebufferTexture3D := dglGetProcAddress('glFramebufferTexture3D'); - glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer'); - glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv'); - glGenerateMipmap := dglGetProcAddress('glGenerateMipmap'); - glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer'); - glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample'); - glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer'); -end; - -procedure Read_GL_ARB_geometry_shader4; -begin - glProgramParameteriARB := dglGetProcAddress('glProgramParameteriARB'); - glFramebufferTextureARB := dglGetProcAddress('glFramebufferTextureARB'); - glFramebufferTextureLayerARB := dglGetProcAddress('glFramebufferTextureLayerARB'); - glFramebufferTextureFaceARB := dglGetProcAddress('glFramebufferTextureFaceARB'); -end; - -procedure Read_GL_ARB_instanced_arrays; -begin - glVertexAttribDivisorARB := dglGetProcAddress('glVertexAttribDivisorARB'); -end; - -procedure Read_GL_ARB_map_buffer_range; -begin - glMapBufferRange := dglGetProcAddress('glMapBufferRange'); - glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange'); -end; - -procedure Read_GL_ARB_texture_buffer_object; -begin - glTexBufferARB := dglGetProcAddress('glTexBufferARB'); -end; - -procedure Read_GL_ARB_vertex_array_object; -begin - glBindVertexArray := dglGetProcAddress('glBindVertexArray'); - glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays'); - glGenVertexArrays := dglGetProcAddress('glGenVertexArrays'); - glIsVertexArray := dglGetProcAddress('glIsVertexArray'); -end; - -procedure Read_GL_ARB_uniform_buffer_object; -begin - glGetUniformIndices := dglGetProcAddress('glGetUniformIndices'); - glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv'); - glGetActiveUniformName := dglGetProcAddress('glGetActiveUniformName'); - glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex'); - glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv'); - glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName'); - glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding'); -end; - -procedure Read_GL_ARB_copy_buffer; -begin - glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData'); -end; - -procedure Read_GL_ARB_draw_elements_base_vertex; -begin - glDrawElementsBaseVertex := dglGetProcAddress('glDrawElementsBaseVertex'); - glDrawRangeElementsBaseVertex := dglGetProcAddress('glDrawRangeElementsBaseVertex'); - glDrawElementsInstancedBaseVertex := dglGetProcAddress('glDrawElementsInstancedBaseVertex'); - glMultiDrawElementsBaseVertex := dglGetProcAddress('glMultiDrawElementsBaseVertex'); -end; - -procedure Read_GL_ARB_provoking_vertex; -begin - glProvokingVertex := dglGetProcAddress('glProvokingVertex'); -end; - -procedure Read_GL_ARB_sync; -begin - glFenceSync := dglGetProcAddress('glFenceSync'); - glIsSync := dglGetProcAddress('glIsSync'); - glDeleteSync := dglGetProcAddress('glDeleteSync'); - glClientWaitSync := dglGetProcAddress('glClientWaitSync'); - glWaitSync := dglGetProcAddress('glWaitSync'); - glGetInteger64v := dglGetProcAddress('glGetInteger64v'); - glGetSynciv := dglGetProcAddress('glGetSynciv'); -end; - -procedure Read_GL_ARB_texture_multisample; -begin - glTexImage2DMultisample := dglGetProcAddress('glTexImage2DMultisample'); - glTexImage3DMultisample := dglGetProcAddress('glTexImage3DMultisample'); - glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv'); - glSampleMaski := dglGetProcAddress('glSampleMaski'); -end; - -procedure Read_GL_ARB_draw_buffers_blend; -begin - glBlendEquationiARB := dglGetProcAddress('glBlendEquationiARB'); - glBlendEquationSeparateiARB := dglGetProcAddress('glBlendEquationSeparateiARB'); - glBlendFunciARB := dglGetProcAddress('glBlendFunciARB'); - glBlendFuncSeparateiARB := dglGetProcAddress('glBlendFuncSeparateiARB'); -end; - -procedure Read_GL_ARB_sample_shading; -begin - glMinSampleShadingARB := dglGetProcAddress('glMinSampleShadingARB'); -end; - -procedure Read_GL_ARB_shading_language_include; -begin - glNamedStringARB := dglGetProcAddress('glNamedStringARB'); - glDeleteNamedStringARB := dglGetProcAddress('glDeleteNamedStringARB'); - glCompileShaderIncludeARB := dglGetProcAddress('glCompileShaderIncludeARB'); - glIsNamedStringARB := dglGetProcAddress('glIsNamedStringARB'); - glGetNamedStringARB := dglGetProcAddress('glGetNamedStringARB'); - glGetNamedStringivARB := dglGetProcAddress('glGetNamedStringivARB'); -end; - -procedure Read_GL_ARB_blend_func_extended; -begin - glBindFragDataLocationIndexed := dglGetProcAddress('glBindFragDataLocationIndexed'); - glGetFragDataIndex := dglGetProcAddress('glGetFragDataIndex'); -end; - -procedure Read_GL_ARB_sampler_objects; -begin - glGenSamplers := dglGetProcAddress('glGenSamplers'); - glDeleteSamplers := dglGetProcAddress('glDeleteSamplers'); - glIsSampler := dglGetProcAddress('glIsSampler'); - glBindSampler := dglGetProcAddress('glBindSampler'); - glSamplerParameteri := dglGetProcAddress('glSamplerParameteri'); - glSamplerParameteriv := dglGetProcAddress('glSamplerParameteriv'); - glSamplerParameterf := dglGetProcAddress('glSamplerParameterf'); - glSamplerParameterfv := dglGetProcAddress('glSamplerParameterfv'); - glSamplerParameterIiv := dglGetProcAddress('glSamplerParameterIiv'); - glSamplerParameterIuiv := dglGetProcAddress('glSamplerParameterIuiv'); - glGetSamplerParameteriv := dglGetProcAddress('glGetSamplerParameteriv'); - glGetSamplerParameterIiv := dglGetProcAddress('glGetSamplerParameterIiv'); - glGetSamplerParameterfv := dglGetProcAddress('glGetSamplerParameterfv'); - glGetSamplerParameterIuiv := dglGetProcAddress('glGetSamplerParameterIuiv'); -end; - -procedure Read_GL_ARB_timer_query; -begin - glQueryCounter := dglGetProcAddress('glQueryCounter'); - glGetQueryObjecti64v := dglGetProcAddress('glGetQueryObjecti64v'); - glGetQueryObjectui64v := dglGetProcAddress('glGetQueryObjectui64v'); -end; - -procedure Read_GL_ARB_vertex_type_2_10_10_10_rev; -begin - glVertexP2ui := dglGetProcAddress('glVertexP2ui'); - glVertexP2uiv := dglGetProcAddress('glVertexP2uiv'); - glVertexP3ui := dglGetProcAddress('glVertexP3ui'); - glVertexP3uiv := dglGetProcAddress('glVertexP3uiv'); - glVertexP4ui := dglGetProcAddress('glVertexP4ui'); - glVertexP4uiv := dglGetProcAddress('glVertexP4uiv'); - glTexCoordP1ui := dglGetProcAddress('glTexCoordP1ui'); - glTexCoordP1uiv := dglGetProcAddress('glTexCoordP1uiv'); - glTexCoordP2ui := dglGetProcAddress('glTexCoordP2ui'); - glTexCoordP2uiv := dglGetProcAddress('glTexCoordP2uiv'); - glTexCoordP3ui := dglGetProcAddress('glTexCoordP3ui'); - glTexCoordP3uiv := dglGetProcAddress('glTexCoordP3uiv'); - glTexCoordP4ui := dglGetProcAddress('glTexCoordP4ui'); - glTexCoordP4uiv := dglGetProcAddress('glTexCoordP4uiv'); - glMultiTexCoordP1ui := dglGetProcAddress('glMultiTexCoordP1ui'); - glMultiTexCoordP1uiv := dglGetProcAddress('glMultiTexCoordP1uiv'); - glMultiTexCoordP2ui := dglGetProcAddress('glMultiTexCoordP2ui'); - glMultiTexCoordP2uiv := dglGetProcAddress('glMultiTexCoordP2uiv'); - glMultiTexCoordP3ui := dglGetProcAddress('glMultiTexCoordP3ui'); - glMultiTexCoordP3uiv := dglGetProcAddress('glMultiTexCoordP3uiv'); - glMultiTexCoordP4ui := dglGetProcAddress('glMultiTexCoordP4ui'); - glMultiTexCoordP4uiv := dglGetProcAddress('glMultiTexCoordP4uiv'); - glNormalP3ui := dglGetProcAddress('glNormalP3ui'); - glNormalP3uiv := dglGetProcAddress('glNormalP3uiv'); - glColorP3ui := dglGetProcAddress('glColorP3ui'); - glColorP3uiv := dglGetProcAddress('glColorP3uiv'); - glColorP4ui := dglGetProcAddress('glColorP4ui'); - glColorP4uiv := dglGetProcAddress('glColorP4uiv'); - glSecondaryColorP3ui := dglGetProcAddress('glSecondaryColorP3ui'); - glSecondaryColorP3uiv := dglGetProcAddress('glSecondaryColorP3uiv'); - glVertexAttribP1ui := dglGetProcAddress('glVertexAttribP1ui'); - glVertexAttribP1uiv := dglGetProcAddress('glVertexAttribP1uiv'); - glVertexAttribP2ui := dglGetProcAddress('glVertexAttribP2ui'); - glVertexAttribP2uiv := dglGetProcAddress('glVertexAttribP2uiv'); - glVertexAttribP3ui := dglGetProcAddress('glVertexAttribP3ui'); - glVertexAttribP3uiv := dglGetProcAddress('glVertexAttribP3uiv'); - glVertexAttribP4ui := dglGetProcAddress('glVertexAttribP4ui'); - glVertexAttribP4uiv := dglGetProcAddress('glVertexAttribP4uiv'); -end; - -procedure Read_GL_ARB_draw_indirect; -begin - glDrawArraysIndirect := dglGetProcAddress('glDrawArraysIndirect'); - glDrawElementsIndirect := dglGetProcAddress('glDrawElementsIndirect'); -end; - -procedure Read_GL_ARB_gpu_shader_fp64; -begin - glUniform1d := dglGetProcAddress('glUniform1d'); - glUniform2d := dglGetProcAddress('glUniform2d'); - glUniform3d := dglGetProcAddress('glUniform3d'); - glUniform4d := dglGetProcAddress('glUniform4d'); - glUniform1dv := dglGetProcAddress('glUniform1dv'); - glUniform2dv := dglGetProcAddress('glUniform2dv'); - glUniform3dv := dglGetProcAddress('glUniform3dv'); - glUniform4dv := dglGetProcAddress('glUniform4dv'); - glUniformMatrix2dv := dglGetProcAddress('glUniformMatrix2dv'); - glUniformMatrix3dv := dglGetProcAddress('glUniformMatrix3dv'); - glUniformMatrix4dv := dglGetProcAddress('glUniformMatrix4dv'); - glUniformMatrix2x3dv := dglGetProcAddress('glUniformMatrix2x3dv'); - glUniformMatrix2x4dv := dglGetProcAddress('glUniformMatrix2x4dv'); - glUniformMatrix3x2dv := dglGetProcAddress('glUniformMatrix3x2dv'); - glUniformMatrix3x4dv := dglGetProcAddress('glUniformMatrix3x4dv'); - glUniformMatrix4x2dv := dglGetProcAddress('glUniformMatrix4x2dv'); - glUniformMatrix4x3dv := dglGetProcAddress('glUniformMatrix4x3dv'); - glGetUniformdv := dglGetProcAddress('glGetUniformdv'); -end; - -procedure Read_GL_ARB_shader_subroutine; -begin - glGetSubroutineUniformLocation := dglGetProcAddress('glGetSubroutineUniformLocation'); - glGetSubroutineIndex := dglGetProcAddress('glGetSubroutineIndex'); - glGetActiveSubroutineUniformiv := dglGetProcAddress('glGetActiveSubroutineUniformiv'); - glGetActiveSubroutineUniformName := dglGetProcAddress('glGetActiveSubroutineUniformName'); - glGetActiveSubroutineName := dglGetProcAddress('glGetActiveSubroutineName'); - glUniformSubroutinesuiv := dglGetProcAddress('glUniformSubroutinesuiv'); - glGetUniformSubroutineuiv := dglGetProcAddress('glGetUniformSubroutineuiv'); - glGetProgramStageiv := dglGetProcAddress('glGetProgramStageiv'); -end; - -procedure Read_GL_ARB_tessellation_shader; -begin - glPatchParameteri := dglGetProcAddress('glPatchParameteri'); - glPatchParameterfv := dglGetProcAddress('glPatchParameterfv'); -end; - -procedure Read_GL_ARB_transform_feedback2; -begin - glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback'); - glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks'); - glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks'); - glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback'); - glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback'); - glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback'); - glDrawTransformFeedback := dglGetProcAddress('glDrawTransformFeedback'); -end; - -procedure Read_GL_ARB_transform_feedback3; -begin - glDrawTransformFeedbackStream := dglGetProcAddress('glDrawTransformFeedbackStream'); - glBeginQueryIndexed := dglGetProcAddress('glBeginQueryIndexed'); - glEndQueryIndexed := dglGetProcAddress('glEndQueryIndexed'); - glGetQueryIndexediv := dglGetProcAddress('glGetQueryIndexediv'); -end; - -procedure Read_GL_ARB_ES2_compatibility; -begin - glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler'); - glShaderBinary := dglGetProcAddress('glShaderBinary'); - glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat'); - glDepthRangef := dglGetProcAddress('glDepthRangef'); - glClearDepthf := dglGetProcAddress('glClearDepthf'); -end; - -procedure Read_GL_ARB_get_program_binary; -begin - glGetProgramBinary := dglGetProcAddress('glGetProgramBinary'); - glProgramBinary := dglGetProcAddress('glProgramBinary'); - glProgramParameteri := dglGetProcAddress('glProgramParameteri'); -end; - -procedure Read_GL_ARB_separate_shader_objects; -begin - glUseProgramStages := dglGetProcAddress('glUseProgramStages'); - glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram'); - glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv'); - glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline'); - glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines'); - glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines'); - glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline'); - glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv'); - glProgramUniform1i := dglGetProcAddress('glProgramUniform1i'); - glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv'); - glProgramUniform1f := dglGetProcAddress('glProgramUniform1f'); - glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv'); - glProgramUniform1d := dglGetProcAddress('glProgramUniform1d'); - glProgramUniform1dv := dglGetProcAddress('glProgramUniform1dv'); - glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui'); - glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv'); - glProgramUniform2i := dglGetProcAddress('glProgramUniform2i'); - glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv'); - glProgramUniform2f := dglGetProcAddress('glProgramUniform2f'); - glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv'); - glProgramUniform2d := dglGetProcAddress('glProgramUniform2d'); - glProgramUniform2dv := dglGetProcAddress('glProgramUniform2dv'); - glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui'); - glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv'); - glProgramUniform3i := dglGetProcAddress('glProgramUniform3i'); - glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv'); - glProgramUniform3f := dglGetProcAddress('glProgramUniform3f'); - glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv'); - glProgramUniform3d := dglGetProcAddress('glProgramUniform3d'); - glProgramUniform3dv := dglGetProcAddress('glProgramUniform3dv'); - glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui'); - glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv'); - glProgramUniform4i := dglGetProcAddress('glProgramUniform4i'); - glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv'); - glProgramUniform4f := dglGetProcAddress('glProgramUniform4f'); - glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv'); - glProgramUniform4d := dglGetProcAddress('glProgramUniform4d'); - glProgramUniform4dv := dglGetProcAddress('glProgramUniform4dv'); - glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui'); - glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv'); - glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv'); - glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv'); - glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv'); - glProgramUniformMatrix2dv := dglGetProcAddress('glProgramUniformMatrix2dv'); - glProgramUniformMatrix3dv := dglGetProcAddress('glProgramUniformMatrix3dv'); - glProgramUniformMatrix4dv := dglGetProcAddress('glProgramUniformMatrix4dv'); - glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv'); - glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv'); - glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv'); - glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv'); - glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv'); - glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv'); - glProgramUniformMatrix2x3dv := dglGetProcAddress('glProgramUniformMatrix2x3dv'); - glProgramUniformMatrix3x2dv := dglGetProcAddress('glProgramUniformMatrix3x2dv'); - glProgramUniformMatrix2x4dv := dglGetProcAddress('glProgramUniformMatrix2x4dv'); - glProgramUniformMatrix4x2dv := dglGetProcAddress('glProgramUniformMatrix4x2dv'); - glProgramUniformMatrix3x4dv := dglGetProcAddress('glProgramUniformMatrix3x4dv'); - glProgramUniformMatrix4x3dv := dglGetProcAddress('glProgramUniformMatrix4x3dv'); - glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline'); - glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog'); -end; - -procedure Read_GL_ARB_vertex_attrib_64bit; -begin - glVertexAttribL1d := dglGetProcAddress('glVertexAttribL1d'); - glVertexAttribL2d := dglGetProcAddress('glVertexAttribL2d'); - glVertexAttribL3d := dglGetProcAddress('glVertexAttribL3d'); - glVertexAttribL4d := dglGetProcAddress('glVertexAttribL4d'); - glVertexAttribL1dv := dglGetProcAddress('glVertexAttribL1dv'); - glVertexAttribL2dv := dglGetProcAddress('glVertexAttribL2dv'); - glVertexAttribL3dv := dglGetProcAddress('glVertexAttribL3dv'); - glVertexAttribL4dv := dglGetProcAddress('glVertexAttribL4dv'); - glVertexAttribLPointer := dglGetProcAddress('glVertexAttribLPointer'); - glGetVertexAttribLdv := dglGetProcAddress('glGetVertexAttribLdv'); -end; - -procedure Read_GL_ARB_viewport_array; -begin - glViewportArrayv := dglGetProcAddress('glViewportArrayv'); - glViewportIndexedf := dglGetProcAddress('glViewportIndexedf'); - glViewportIndexedfv := dglGetProcAddress('glViewportIndexedfv'); - glScissorArrayv := dglGetProcAddress('glScissorArrayv'); - glScissorIndexed := dglGetProcAddress('glScissorIndexed'); - glScissorIndexedv := dglGetProcAddress('glScissorIndexedv'); - glDepthRangeArrayv := dglGetProcAddress('glDepthRangeArrayv'); - glDepthRangeIndexed := dglGetProcAddress('glDepthRangeIndexed'); - glGetFloati_v := dglGetProcAddress('glGetFloati_v'); - glGetDoublei_v := dglGetProcAddress('glGetDoublei_v'); -end; - -// GL 4.2 - -procedure Read_GL_ARB_base_instance; -begin -glDrawArraysInstancedBaseInstance := dglGetProcAddress('glDrawArraysInstancedBaseInstance'); -glDrawElementsInstancedBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseInstance'); -glDrawElementsInstancedBaseVertexBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstance'); -end; - -procedure Read_GL_ARB_transform_feedback_instanced; -begin -glDrawTransformFeedbackInstanced := dglGetProcAddress('glDrawTransformFeedbackInstanced'); -glDrawTransformFeedbackStreamInstanced := dglGetProcAddress('glDrawTransformFeedbackStreamInstanced'); -end; - -procedure Read_GL_ARB_internalformat_query; -begin -glGetInternalformativ := dglGetProcAddress('glGetInternalformativ'); -end; - -procedure Read_GL_ARB_shader_atomic_counters; -begin -glGetActiveAtomicCounterBufferiv := dglGetProcAddress('glGetActiveAtomicCounterBufferiv'); -end; - -procedure Read_GL_ARB_shader_image_load_store; -begin -glBindImageTexture := dglGetProcAddress('glBindImageTexture'); -glMemoryBarrier := dglGetProcAddress('glMemoryBarrier'); -end; - -procedure Read_GL_ARB_texture_storage; -begin -glTexStorage1D := dglGetProcAddress('glTexStorage1D'); -glTexStorage2D := dglGetProcAddress('glTexStorage2D'); -glTexStorage3D := dglGetProcAddress('glTexStorage3D'); -glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT'); -glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT'); -glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT'); -end; - - -// GL 4.3 -procedure Read_GL_KHR_debug; -begin - glDebugMessageControl := dglGetProcAddress('glDebugMessageControl'); - glDebugMessageInsert := dglGetProcAddress('glDebugMessageInsert'); - glDebugMessageCallback := dglGetProcAddress('glDebugMessageCallback'); - glGetDebugMessageLog := dglGetProcAddress('glGetDebugMessageLog'); - glPushDebugGroup := dglGetProcAddress('glPushDebugGroup'); - glPopDebugGroup := dglGetProcAddress('glPopDebugGroup'); - glObjectLabel := dglGetProcAddress('glObjectLabel'); - glGetObjectLabel := dglGetProcAddress('glGetObjectLabel'); - glObjectPtrLabel := dglGetProcAddress('glObjectPtrLabel'); - glGetObjectPtrLabel := dglGetProcAddress('glGetObjectPtrLabel'); -end; - -procedure Read_GL_ARB_clear_buffer_object; -begin - glClearBufferData := dglGetProcAddress('glClearBufferData'); - glClearBufferSubData := dglGetProcAddress('glClearBufferSubData'); - glClearNamedBufferDataEXT := dglGetProcAddress('glClearNamedBufferDataEXT'); - glClearNamedBufferSubDataEXT := dglGetProcAddress('glClearNamedBufferSubDataEXT'); -end; - -procedure Read_GL_ARB_compute_shader; -begin - glDispatchCompute := dglGetProcAddress('glDispatchCompute'); - glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect'); -end; - -procedure Read_GL_ARB_copy_image; -begin - glCopyImageSubData := dglGetProcAddress('glCopyImageSubData'); -end; - -procedure Read_GL_ARB_framebuffer_no_attachments; -begin - glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri'); - glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv'); - glNamedFramebufferParameteriEXT := dglGetProcAddress('glNamedFramebufferParameteriEXT'); - glGetNamedFramebufferParameterivEXT := dglGetProcAddress('glGetNamedFramebufferParameterivEXT'); -end; - -procedure Read_GL_ARB_internalformat_query2; -begin - glGetInternalformati64v := dglGetProcAddress('glGetInternalformati64v');; -end; - -procedure Read_GL_ARB_invalidate_subdata; -begin - glInvalidateTexSubImage := dglGetProcAddress('glInvalidateTexSubImage'); - glInvalidateTexImage := dglGetProcAddress('glInvalidateTexImage'); - glInvalidateBufferSubData := dglGetProcAddress('glInvalidateBufferSubData'); - glInvalidateBufferData := dglGetProcAddress('glInvalidateBufferData'); - glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer'); - glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer'); -end; - -procedure Read_GL_ARB_multi_draw_indirect; -begin - glMultiDrawArraysIndirect := dglGetProcAddress('glMultiDrawArraysIndirect'); - glMultiDrawElementsIndirect := dglGetProcAddress('glMultiDrawElementsIndirect'); -end; - -procedure Read_GL_ARB_program_interface_query; -begin - glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv'); - glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex'); - glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName'); - glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv'); - glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation'); - glGetProgramResourceLocationIndex := dglGetProcAddress('glGetProgramResourceLocationIndex'); -end; - -procedure Read_GL_ARB_shader_storage_buffer_object; -begin - glShaderStorageBlockBinding := dglGetProcAddress('glShaderStorageBlockBinding'); -end; - -procedure Read_GL_ARB_texture_buffer_range; -begin - glTexBufferRange := dglGetProcAddress('glTexBufferRange'); - glTextureBufferRangeEXT := dglGetProcAddress('glTextureBufferRangeEXT'); -end; - -procedure Read_GL_ARB_texture_storage_multisample; -begin - glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample'); - glTexStorage3DMultisample := dglGetProcAddress('glTexStorage3DMultisample'); - glTextureStorage2DMultisampleEXT := dglGetProcAddress('glTextureStorage2DMultisampleEXT'); - glTextureStorage3DMultisampleEXT := dglGetProcAddress('glTextureStorage3DMultisampleEXT'); -end; - -procedure Read_GL_ARB_texture_view; -begin - glTextureView := dglGetProcAddress('glTextureView'); -end; - -procedure Read_GL_ARB_vertex_attrib_binding; -begin - glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer'); - glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat'); - glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat'); - glVertexAttribLFormat := dglGetProcAddress('glVertexAttribLFormat'); - glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding'); - glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor'); - glVertexArrayBindVertexBufferEXT := dglGetProcAddress('glVertexArrayBindVertexBufferEXT'); - glVertexArrayVertexAttribFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribFormatEXT'); - glVertexArrayVertexAttribIFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribIFormatEXT'); - glVertexArrayVertexAttribLFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribLFormatEXT'); - glVertexArrayVertexAttribBindingEXT := dglGetProcAddress('glVertexArrayVertexAttribBindingEXT'); - glVertexArrayVertexBindingDivisorEXT := dglGetProcAddress('glVertexArrayVertexBindingDivisorEXT'); -end; - -procedure Read_GL_4_4; -begin - glBufferStorage := dglGetProcAddress('glBufferStorage'); - glClearTexImage := dglGetProcAddress('glClearTexImage'); - glClearTexSubImage := dglGetProcAddress('glClearTexSubImage'); - glBindBuffersBase := dglGetProcAddress('glBindBuffersBase'); - glBindBuffersRange := dglGetProcAddress('glBindBuffersRange'); - glBindTextures := dglGetProcAddress('glBindTextures'); - glBindSamplers := dglGetProcAddress('glBindSamplers'); - glBindImageTextures := dglGetProcAddress('glBindImageTextures'); - glBindVertexBuffers := dglGetProcAddress('glBindVertexBuffers'); -end; - - -procedure Read_GL_NV_path_rendering; -begin - glGenPathsNV := dglGetProcAddress('glGenPathsNV'); - glDeletePathsNV := dglGetProcAddress('glDeletePathsNV'); - glIsPathNV := dglGetProcAddress('glIsPathNV'); - glPathCommandsNV := dglGetProcAddress('glPathCommandsNV'); - glPathCoordsNV := dglGetProcAddress('glPathCoordsNV'); - glPathSubCommandsNV := dglGetProcAddress('glPathSubCommandsNV'); - glPathSubCoordsNV := dglGetProcAddress('glPathSubCoordsNV'); - glPathStringNV := dglGetProcAddress('glPathStringNV'); - glPathGlyphsNV := dglGetProcAddress('glPathGlyphsNV'); - glPathGlyphRangeNV := dglGetProcAddress('glPathGlyphRangeNV'); - glWeightPathsNV := dglGetProcAddress('glWeightPathsNV'); - glCopyPathNV := dglGetProcAddress('glCopyPathNV'); - glInterpolatePathsNV := dglGetProcAddress('glInterpolatePathsNV'); - glTransformPathNV := dglGetProcAddress('glTransformPathNV'); - glPathParameterivNV := dglGetProcAddress('glPathParameterivNV'); - glPathParameteriNV := dglGetProcAddress('glPathParameteriNV'); - glPathParameterfvNV := dglGetProcAddress('glPathParameterfvNV'); - glPathParameterfNV := dglGetProcAddress('glPathParameterfNV'); - glPathDashArrayNV := dglGetProcAddress('glPathDashArrayNV'); - glPathStencilFuncNV := dglGetProcAddress('glPathStencilFuncNV'); - glPathStencilDepthOffsetNV := dglGetProcAddress('glPathStencilDepthOffsetNV'); - glStencilFillPathNV := dglGetProcAddress('glStencilFillPathNV'); - glStencilStrokePathNV := dglGetProcAddress('glStencilStrokePathNV'); - glStencilFillPathInstancedNV := dglGetProcAddress('glStencilFillPathInstancedNV'); - glStencilStrokePathInstancedNV := dglGetProcAddress('glStencilStrokePathInstancedNV'); - glPathCoverDepthFuncNV := dglGetProcAddress('glPathCoverDepthFuncNV'); - glPathColorGenNV := dglGetProcAddress('glPathColorGenNV'); - glPathTexGenNV := dglGetProcAddress('glPathTexGenNV'); - glPathFogGenNV := dglGetProcAddress('glPathFogGenNV'); - glCoverFillPathNV := dglGetProcAddress('glCoverFillPathNV'); - glCoverStrokePathNV := dglGetProcAddress('glCoverStrokePathNV'); - glCoverFillPathInstancedNV := dglGetProcAddress('glCoverFillPathInstancedNV'); - glCoverStrokePathInstancedNV := dglGetProcAddress('glCoverStrokePathInstancedNV'); - glGetPathParameterivNV := dglGetProcAddress('glGetPathParameterivNV'); - glGetPathParameterfvNV := dglGetProcAddress('glGetPathParameterfvNV'); - glGetPathCommandsNV := dglGetProcAddress('glGetPathCommandsNV'); - glGetPathCoordsNV := dglGetProcAddress('glGetPathCoordsNV'); - glGetPathDashArrayNV := dglGetProcAddress('glGetPathDashArrayNV'); - glGetPathMetricsNV := dglGetProcAddress('glGetPathMetricsNV'); - glGetPathMetricRangeNV := dglGetProcAddress('glGetPathMetricRangeNV'); - glGetPathSpacingNV := dglGetProcAddress('glGetPathSpacingNV'); - glGetPathColorGenivNV := dglGetProcAddress('glGetPathColorGenivNV'); - glGetPathColorGenfvNV := dglGetProcAddress('glGetPathColorGenfvNV'); - glGetPathTexGenivNV := dglGetProcAddress('glGetPathTexGenivNV'); - glGetPathTexGenfvNV := dglGetProcAddress('glGetPathTexGenfvNV'); - glIsPointInFillPathNV := dglGetProcAddress('glIsPointInFillPathNV'); - glIsPointInStrokePathNV := dglGetProcAddress('glIsPointInStrokePathNV'); - glGetPathLengthNV := dglGetProcAddress('glGetPathLengthNV'); - glPointAlongPathNV := dglGetProcAddress('glPointAlongPathNV'); -end; - -procedure Read_GL_AMD_stencil_operation_extended; -begin - glStencilOpValueAMD := dglGetProcAddress('glStencilOpValueAMD'); -end; - -procedure Read_GL_NV_bindless_texture; -begin - glGetTextureHandleNV := dglGetProcAddress('glGetTextureHandleNV'); - glGetTextureSamplerHandleNV := dglGetProcAddress('glGetTextureSamplerHandleNV'); - glMakeTextureHandleResidentNV := dglGetProcAddress('glMakeTextureHandleResidentNV'); - glMakeTextureHandleNonResidentNV := dglGetProcAddress('glMakeTextureHandleNonResidentNV'); - glGetImageHandleNV := dglGetProcAddress('glGetImageHandleNV'); - glMakeImageHandleResidentNV := dglGetProcAddress('glMakeImageHandleResidentNV'); - glMakeImageHandleNonResidentNV := dglGetProcAddress('glMakeImageHandleNonResidentNV'); - glUniformHandleui64NV := dglGetProcAddress('glUniformHandleui64NV'); - glUniformHandleui64vNV := dglGetProcAddress('glUniformHandleui64vNV'); - glProgramUniformHandleui64NV := dglGetProcAddress('glProgramUniformHandleui64NV'); - glProgramUniformHandleui64vNV := dglGetProcAddress('glProgramUniformHandleui64vNV'); - glIsTextureHandleResidentNV := dglGetProcAddress('glIsTextureHandleResidentNV'); - glIsImageHandleResidentNV := dglGetProcAddress('glIsImageHandleResidentNV'); -end; - -procedure Read_GL_ARB_cl_event; -begin - glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB'); -end; - -procedure Read_GL_ARB_debug_output; -begin - glDebugMessageControlARB := dglGetProcAddress('glDebugMessageControlARB'); - glDebugMessageInsertARB := dglGetProcAddress('glDebugMessageInsertARB'); - glDebugMessageCallbackARB := dglGetProcAddress('glDebugMessageCallbackARB'); - glGetDebugMessageLogARB := dglGetProcAddress('glGetDebugMessageLogARB'); -end; - -procedure Read_GL_ARB_robustness; -begin - glGetGraphicsResetStatusARB := dglGetProcAddress('glGetGraphicsResetStatusARB'); - glGetnMapdvARB := dglGetProcAddress('glGetnMapdvARB'); - glGetnMapfvARB := dglGetProcAddress('glGetnMapfvARB'); - glGetnMapivARB := dglGetProcAddress('glGetnMapivARB'); - glGetnPixelMapfvARB := dglGetProcAddress('glGetnPixelMapfvARB'); - glGetnPixelMapuivARB := dglGetProcAddress('glGetnPixelMapuivARB'); - glGetnPixelMapusvARB := dglGetProcAddress('glGetnPixelMapusvARB'); - glGetnPolygonStippleARB := dglGetProcAddress('glGetnPolygonStippleARB'); - glGetnColorTableARB := dglGetProcAddress('glGetnColorTableARB'); - glGetnConvolutionFilterARB := dglGetProcAddress('glGetnConvolutionFilterARB'); - glGetnSeparableFilterARB := dglGetProcAddress('glGetnSeparableFilterARB'); - glGetnHistogramARB := dglGetProcAddress('glGetnHistogramARB'); - glGetnMinmaxARB := dglGetProcAddress('glGetnMinmaxARB'); - glGetnTexImageARB := dglGetProcAddress('glGetnTexImageARB'); - glReadnPixelsARB := dglGetProcAddress('glReadnPixelsARB'); - glGetnCompressedTexImageARB := dglGetProcAddress('glGetnCompressedTexImageARB'); - glGetnUniformfvARB := dglGetProcAddress('glGetnUniformfvARB'); - glGetnUniformivARB := dglGetProcAddress('glGetnUniformivARB'); - glGetnUniformuivARB := dglGetProcAddress('glGetnUniformuivARB'); - glGetnUniformdvARB := dglGetProcAddress('glGetnUniformdvARB'); -end; - -procedure Read_GL_ATI_draw_buffers; -begin - glDrawBuffersATI := dglGetProcAddress('glDrawBuffersATI'); -end; - -procedure Read_GL_ATI_element_array; -begin - glElementPointerATI := dglGetProcAddress('glElementPointerATI'); - glDrawElementArrayATI := dglGetProcAddress('glDrawElementArrayATI'); - glDrawRangeElementArrayATI := dglGetProcAddress('glDrawRangeElementArrayATI'); -end; - -procedure Read_GL_ATI_envmap_bumpmap; -begin - glTexBumpParameterivATI := dglGetProcAddress('glTexBumpParameterivATI'); - glTexBumpParameterfvATI := dglGetProcAddress('glTexBumpParameterfvATI'); - glGetTexBumpParameterivATI := dglGetProcAddress('glGetTexBumpParameterivATI'); - glGetTexBumpParameterfvATI := dglGetProcAddress('glGetTexBumpParameterfvATI'); -end; - -procedure Read_GL_ATI_fragment_shader; -begin - glGenFragmentShadersATI := dglGetProcAddress('glGenFragmentShadersATI'); - glBindFragmentShaderATI := dglGetProcAddress('glBindFragmentShaderATI'); - glDeleteFragmentShaderATI := dglGetProcAddress('glDeleteFragmentShaderATI'); - glBeginFragmentShaderATI := dglGetProcAddress('glBeginFragmentShaderATI'); - glEndFragmentShaderATI := dglGetProcAddress('glEndFragmentShaderATI'); - glPassTexCoordATI := dglGetProcAddress('glPassTexCoordATI'); - glSampleMapATI := dglGetProcAddress('glSampleMapATI'); - glColorFragmentOp1ATI := dglGetProcAddress('glColorFragmentOp1ATI'); - glColorFragmentOp2ATI := dglGetProcAddress('glColorFragmentOp2ATI'); - glColorFragmentOp3ATI := dglGetProcAddress('glColorFragmentOp3ATI'); - glAlphaFragmentOp1ATI := dglGetProcAddress('glAlphaFragmentOp1ATI'); - glAlphaFragmentOp2ATI := dglGetProcAddress('glAlphaFragmentOp2ATI'); - glAlphaFragmentOp3ATI := dglGetProcAddress('glAlphaFragmentOp3ATI'); - glSetFragmentShaderConstantATI := dglGetProcAddress('glSetFragmentShaderConstantATI'); -end; - -procedure Read_GL_ATI_map_object_buffer; -begin - glMapObjectBufferATI := dglGetProcAddress('glMapObjectBufferATI'); - glUnmapObjectBufferATI := dglGetProcAddress('glUnmapObjectBufferATI'); -end; - -procedure Read_GL_ATI_pn_triangles; -begin - glPNTrianglesiATI := dglGetProcAddress('glPNTrianglesiATI'); - glPNTrianglesfATI := dglGetProcAddress('glPNTrianglesfATI'); -end; - -procedure Read_GL_ATI_separate_stencil; -begin - glStencilOpSeparateATI := dglGetProcAddress('glStencilOpSeparateATI'); - glStencilFuncSeparateATI := dglGetProcAddress('glStencilFuncSeparateATI'); -end; - -procedure Read_GL_ATI_vertex_array_object; -begin - glNewObjectBufferATI := dglGetProcAddress('glNewObjectBufferATI'); - glIsObjectBufferATI := dglGetProcAddress('glIsObjectBufferATI'); - glUpdateObjectBufferATI := dglGetProcAddress('glUpdateObjectBufferATI'); - glGetObjectBufferfvATI := dglGetProcAddress('glGetObjectBufferfvATI'); - glGetObjectBufferivATI := dglGetProcAddress('glGetObjectBufferivATI'); - glFreeObjectBufferATI := dglGetProcAddress('glFreeObjectBufferATI'); - glArrayObjectATI := dglGetProcAddress('glArrayObjectATI'); - glGetArrayObjectfvATI := dglGetProcAddress('glGetArrayObjectfvATI'); - glGetArrayObjectivATI := dglGetProcAddress('glGetArrayObjectivATI'); - glVariantArrayObjectATI := dglGetProcAddress('glVariantArrayObjectATI'); - glGetVariantArrayObjectfvATI := dglGetProcAddress('glGetVariantArrayObjectfvATI'); - glGetVariantArrayObjectivATI := dglGetProcAddress('glGetVariantArrayObjectivATI'); - -end; - -procedure Read_GL_ATI_vertex_attrib_array_object; -begin - glVertexAttribArrayObjectATI := dglGetProcAddress('glVertexAttribArrayObjectATI'); - glGetVertexAttribArrayObjectfvATI := dglGetProcAddress('glGetVertexAttribArrayObjectfvATI'); - glGetVertexAttribArrayObjectivATI := dglGetProcAddress('glGetVertexAttribArrayObjectivATI'); -end; - -procedure Read_GL_ATI_vertex_streams; -begin - glVertexStream1sATI := dglGetProcAddress('glVertexStream1sATI'); - glVertexStream1svATI := dglGetProcAddress('glVertexStream1svATI'); - glVertexStream1iATI := dglGetProcAddress('glVertexStream1iATI'); - glVertexStream1ivATI := dglGetProcAddress('glVertexStream1ivATI'); - glVertexStream1fATI := dglGetProcAddress('glVertexStream1fATI'); - glVertexStream1fvATI := dglGetProcAddress('glVertexStream1fvATI'); - glVertexStream1dATI := dglGetProcAddress('glVertexStream1dATI'); - glVertexStream1dvATI := dglGetProcAddress('glVertexStream1dvATI'); - glVertexStream2sATI := dglGetProcAddress('glVertexStream2sATI'); - glVertexStream2svATI := dglGetProcAddress('glVertexStream2svATI'); - glVertexStream2iATI := dglGetProcAddress('glVertexStream2iATI'); - glVertexStream2ivATI := dglGetProcAddress('glVertexStream2ivATI'); - glVertexStream2fATI := dglGetProcAddress('glVertexStream2fATI'); - glVertexStream2fvATI := dglGetProcAddress('glVertexStream2fvATI'); - glVertexStream2dATI := dglGetProcAddress('glVertexStream2dATI'); - glVertexStream2dvATI := dglGetProcAddress('glVertexStream2dvATI'); - glVertexStream3sATI := dglGetProcAddress('glVertexStream3sATI'); - glVertexStream3svATI := dglGetProcAddress('glVertexStream3svATI'); - glVertexStream3iATI := dglGetProcAddress('glVertexStream3iATI'); - glVertexStream3ivATI := dglGetProcAddress('glVertexStream3ivATI'); - glVertexStream3fATI := dglGetProcAddress('glVertexStream3fATI'); - glVertexStream3fvATI := dglGetProcAddress('glVertexStream3fvATI'); - glVertexStream3dATI := dglGetProcAddress('glVertexStream3dATI'); - glVertexStream3dvATI := dglGetProcAddress('glVertexStream3dvATI'); - glVertexStream4sATI := dglGetProcAddress('glVertexStream4sATI'); - glVertexStream4svATI := dglGetProcAddress('glVertexStream4svATI'); - glVertexStream4iATI := dglGetProcAddress('glVertexStream4iATI'); - glVertexStream4ivATI := dglGetProcAddress('glVertexStream4ivATI'); - glVertexStream4fATI := dglGetProcAddress('glVertexStream4fATI'); - glVertexStream4fvATI := dglGetProcAddress('glVertexStream4fvATI'); - glVertexStream4dATI := dglGetProcAddress('glVertexStream4dATI'); - glVertexStream4dvATI := dglGetProcAddress('glVertexStream4dvATI'); - glNormalStream3bATI := dglGetProcAddress('glNormalStream3bATI'); - glNormalStream3bvATI := dglGetProcAddress('glNormalStream3bvATI'); - glNormalStream3sATI := dglGetProcAddress('glNormalStream3sATI'); - glNormalStream3svATI := dglGetProcAddress('glNormalStream3svATI'); - glNormalStream3iATI := dglGetProcAddress('glNormalStream3iATI'); - glNormalStream3ivATI := dglGetProcAddress('glNormalStream3ivATI'); - glNormalStream3fATI := dglGetProcAddress('glNormalStream3fATI'); - glNormalStream3fvATI := dglGetProcAddress('glNormalStream3fvATI'); - glNormalStream3dATI := dglGetProcAddress('glNormalStream3dATI'); - glNormalStream3dvATI := dglGetProcAddress('glNormalStream3dvATI'); - glClientActiveVertexStreamATI := dglGetProcAddress('glClientActiveVertexStreamATI'); - glVertexBlendEnviATI := dglGetProcAddress('glVertexBlendEnviATI'); - glVertexBlendEnvfATI := dglGetProcAddress('glVertexBlendEnvfATI'); -end; - -procedure Read_GL_AMD_performance_monitor; -begin - glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD'); - glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD'); - glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD'); - glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD'); - glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD'); - glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD'); - glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD'); - glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD'); - glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD'); - glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD'); - glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD'); -end; - -procedure Read_GL_AMD_vertex_shader_tesselator; -begin - glTessellationFactorAMD := dglGetProcAddress('glTessellationFactorAMD'); - glTessellationModeAMD := dglGetProcAddress('glTessellationModeAMD'); -end; - -procedure Read_GL_AMD_draw_buffers_blend; -begin - glBlendFuncIndexedAMD := dglGetProcAddress('glBlendFuncIndexedAMD'); - glBlendFuncSeparateIndexedAMD := dglGetProcAddress('glBlendFuncSeparateIndexedAMD'); - glBlendEquationIndexedAMD := dglGetProcAddress('glBlendEquationIndexedAMD'); - glBlendEquationSeparateIndexedAMD := dglGetProcAddress('glBlendEquationSeparateIndexedAMD'); -end; - -procedure Read_GL_AMD_name_gen_delete; -begin - glGenNamesAMD := dglGetProcAddress('glGenNamesAMD'); - glDeleteNamesAMD := dglGetProcAddress('glDeleteNamesAMD'); - glIsNameAMD := dglGetProcAddress('glIsNameAMD'); -end; - -procedure Read_GL_AMD_debug_output; -begin - glDebugMessageEnableAMD := dglGetProcAddress('glDebugMessageEnableAMD'); - glDebugMessageInsertAMD := dglGetProcAddress('glDebugMessageInsertAMD'); - glDebugMessageCallbackAMD := dglGetProcAddress('glDebugMessageCallbackAMD'); - glGetDebugMessageLogAMD := dglGetProcAddress('glGetDebugMessageLogAMD'); -end; - -procedure Read_GL_EXT_blend_color; -begin - glBlendColorEXT := dglGetProcAddress('glBlendColorEXT'); -end; - -procedure Read_GL_EXT_blend_func_separate; -begin - glBlendFuncSeparateEXT := dglGetProcAddress('glBlendFuncSeparateEXT'); -end; - -procedure Read_GL_EXT_blend_minmax; -begin - glBlendEquationEXT := dglGetProcAddress('glBlendEquationEXT'); -end; - -procedure Read_GL_EXT_color_subtable; -begin - glColorSubTableEXT := dglGetProcAddress('glColorSubTableEXT'); - glCopyColorSubTableEXT := dglGetProcAddress('glCopyColorSubTableEXT'); -end; - -procedure Read_GL_EXT_compiled_vertex_array; -begin - glLockArraysEXT := dglGetProcAddress('glLockArraysEXT'); - glUnlockArraysEXT := dglGetProcAddress('glUnlockArraysEXT'); -end; - -procedure Read_GL_EXT_convolution; -begin - glConvolutionFilter1DEXT := dglGetProcAddress('glConvolutionFilter1DEXT'); - glConvolutionFilter2DEXT := dglGetProcAddress('glConvolutionFilter2DEXT'); - glConvolutionParameterfEXT := dglGetProcAddress('glConvolutionParameterfEXT'); - glConvolutionParameterfvEXT := dglGetProcAddress('glConvolutionParameterfvEXT'); - glConvolutionParameteriEXT := dglGetProcAddress('glConvolutionParameteriEXT'); - glConvolutionParameterivEXT := dglGetProcAddress('glConvolutionParameterivEXT'); - glCopyConvolutionFilter1DEXT := dglGetProcAddress('glCopyConvolutionFilter1DEXT'); - glCopyConvolutionFilter2DEXT := dglGetProcAddress('glCopyConvolutionFilter2DEXT'); - glGetConvolutionFilterEXT := dglGetProcAddress('glGetConvolutionFilterEXT'); - glGetConvolutionParameterfvEXT := dglGetProcAddress('glGetConvolutionParameterfvEXT'); - glGetConvolutionParameterivEXT := dglGetProcAddress('glGetConvolutionParameterivEXT'); - glGetSeparableFilterEXT := dglGetProcAddress('glGetSeparableFilterEXT'); - glSeparableFilter2DEXT := dglGetProcAddress('glSeparableFilter2DEXT'); -end; - -procedure Read_GL_EXT_coordinate_frame; -begin - glTangent3bEXT := dglGetProcAddress('glTangent3bEXT'); - glTangent3bvEXT := dglGetProcAddress('glTangent3bvEXT'); - glTangent3dEXT := dglGetProcAddress('glTangent3dEXT'); - glTangent3dvEXT := dglGetProcAddress('glTangent3dvEXT'); - glTangent3fEXT := dglGetProcAddress('glTangent3fEXT'); - glTangent3fvEXT := dglGetProcAddress('glTangent3fvEXT'); - glTangent3iEXT := dglGetProcAddress('glTangent3iEXT'); - glTangent3ivEXT := dglGetProcAddress('glTangent3ivEXT'); - glTangent3sEXT := dglGetProcAddress('glTangent3sEXT'); - glTangent3svEXT := dglGetProcAddress('glTangent3svEXT'); - glBinormal3bEXT := dglGetProcAddress('glBinormal3bEXT'); - glBinormal3bvEXT := dglGetProcAddress('glBinormal3bvEXT'); - glBinormal3dEXT := dglGetProcAddress('glBinormal3dEXT'); - glBinormal3dvEXT := dglGetProcAddress('glBinormal3dvEXT'); - glBinormal3fEXT := dglGetProcAddress('glBinormal3fEXT'); - glBinormal3fvEXT := dglGetProcAddress('glBinormal3fvEXT'); - glBinormal3iEXT := dglGetProcAddress('glBinormal3iEXT'); - glBinormal3ivEXT := dglGetProcAddress('glBinormal3ivEXT'); - glBinormal3sEXT := dglGetProcAddress('glBinormal3sEXT'); - glBinormal3svEXT := dglGetProcAddress('glBinormal3svEXT'); - glTangentPointerEXT := dglGetProcAddress('glTangentPointerEXT'); - glBinormalPointerEXT := dglGetProcAddress('glBinormalPointerEXT'); -end; - -procedure Read_GL_EXT_copy_texture; -begin - glCopyTexImage1DEXT := dglGetProcAddress('glCopyTexImage1DEXT'); - glCopyTexImage2DEXT := dglGetProcAddress('glCopyTexImage2DEXT'); - glCopyTexSubImage1DEXT := dglGetProcAddress('glCopyTexSubImage1DEXT'); - glCopyTexSubImage2DEXT := dglGetProcAddress('glCopyTexSubImage2DEXT'); - glCopyTexSubImage3DEXT := dglGetProcAddress('glCopyTexSubImage3DEXT'); -end; - -procedure Read_GL_EXT_cull_vertex; -begin - glCullParameterdvEXT := dglGetProcAddress('glCullParameterdvEXT'); - glCullParameterfvEXT := dglGetProcAddress('glCullParameterfvEXT'); -end; - -procedure Read_GL_EXT_draw_range_elements; -begin - glDrawRangeElementsEXT := dglGetProcAddress('glDrawRangeElementsEXT'); -end; - -procedure Read_GL_EXT_fog_coord; -begin - glFogCoordfEXT := dglGetProcAddress('glFogCoordfEXT'); - glFogCoordfvEXT := dglGetProcAddress('glFogCoordfvEXT'); - glFogCoorddEXT := dglGetProcAddress('glFogCoorddEXT'); - glFogCoorddvEXT := dglGetProcAddress('glFogCoorddvEXT'); - glFogCoordPointerEXT := dglGetProcAddress('glFogCoordPointerEXT'); -end; - -procedure Read_GL_EXT_framebuffer_object; -begin - glIsRenderbufferEXT := dglGetProcAddress('glIsRenderbufferEXT'); - glBindRenderbufferEXT := dglGetProcAddress('glBindRenderbufferEXT'); - glDeleteRenderbuffersEXT := dglGetProcAddress('glDeleteRenderbuffersEXT'); - glGenRenderbuffersEXT := dglGetProcAddress('glGenRenderbuffersEXT'); - glRenderbufferStorageEXT := dglGetProcAddress('glRenderbufferStorageEXT'); - glGetRenderbufferParameterivEXT := dglGetProcAddress('glGetRenderbufferParameterivEXT'); - glIsFramebufferEXT := dglGetProcAddress('glIsFramebufferEXT'); - glBindFramebufferEXT := dglGetProcAddress('glBindFramebufferEXT'); - glDeleteFramebuffersEXT := dglGetProcAddress('glDeleteFramebuffersEXT'); - glGenFramebuffersEXT := dglGetProcAddress('glGenFramebuffersEXT'); - glCheckFramebufferStatusEXT := dglGetProcAddress('glCheckFramebufferStatusEXT'); - glFramebufferTexture1DEXT := dglGetProcAddress('glFramebufferTexture1DEXT'); - glFramebufferTexture2DEXT := dglGetProcAddress('glFramebufferTexture2DEXT'); - glFramebufferTexture3DEXT := dglGetProcAddress('glFramebufferTexture3DEXT'); - glFramebufferRenderbufferEXT := dglGetProcAddress('glFramebufferRenderbufferEXT'); - glGetFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetFramebufferAttachmentParameterivEXT'); - glGenerateMipmapEXT := dglGetProcAddress('glGenerateMipmapEXT'); -end; - -procedure Read_GL_EXT_histogram; -begin - glGetHistogramEXT := dglGetProcAddress('glGetHistogramEXT'); - glGetHistogramParameterfvEXT := dglGetProcAddress('glGetHistogramParameterfvEXT'); - glGetHistogramParameterivEXT := dglGetProcAddress('glGetHistogramParameterivEXT'); - glGetMinmaxEXT := dglGetProcAddress('glGetMinmaxEXT'); - glGetMinmaxParameterfvEXT := dglGetProcAddress('glGetMinmaxParameterfvEXT'); - glGetMinmaxParameterivEXT := dglGetProcAddress('glGetMinmaxParameterivEXT'); - glHistogramEXT := dglGetProcAddress('glHistogramEXT'); - glMinmaxEXT := dglGetProcAddress('glMinmaxEXT'); - glResetHistogramEXT := dglGetProcAddress('glResetHistogramEXT'); - glResetMinmaxEXT := dglGetProcAddress('glResetMinmaxEXT'); -end; - -procedure Read_GL_EXT_index_func; -begin - glIndexFuncEXT := dglGetProcAddress('glIndexFuncEXT'); -end; - -procedure Read_GL_EXT_index_material; -begin - glIndexMaterialEXT := dglGetProcAddress('glIndexMaterialEXT'); -end; - -procedure Read_GL_EXT_light_texture; -begin - glApplyTextureEXT := dglGetProcAddress('glApplyTextureEXT'); - glTextureLightEXT := dglGetProcAddress('glTextureLightEXT'); - glTextureMaterialEXT := dglGetProcAddress('glTextureMaterialEXT'); -end; - -procedure Read_GL_EXT_multi_draw_arrays; -begin - glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT'); - glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT'); -end; - -procedure Read_GL_EXT_multisample; -begin - glSampleMaskEXT := dglGetProcAddress('glSampleMaskEXT'); - glSamplePatternEXT := dglGetProcAddress('glSamplePatternEXT'); -end; - -procedure Read_GL_EXT_paletted_texture; -begin - glColorTableEXT := dglGetProcAddress('glColorTableEXT'); - glGetColorTableEXT := dglGetProcAddress('glGetColorTableEXT'); - glGetColorTableParameterivEXT := dglGetProcAddress('glGetColorTableParameterivEXT'); - glGetColorTableParameterfvEXT := dglGetProcAddress('glGetColorTableParameterfvEXT'); -end; - -procedure Read_GL_EXT_pixel_transform; -begin - glPixelTransformParameteriEXT := dglGetProcAddress('glPixelTransformParameteriEXT'); - glPixelTransformParameterfEXT := dglGetProcAddress('glPixelTransformParameterfEXT'); - glPixelTransformParameterivEXT := dglGetProcAddress('glPixelTransformParameterivEXT'); - glPixelTransformParameterfvEXT := dglGetProcAddress('glPixelTransformParameterfvEXT'); -end; - -procedure Read_GL_EXT_point_parameters; -begin - glPointParameterfEXT := dglGetProcAddress('glPointParameterfEXT'); - glPointParameterfvEXT := dglGetProcAddress('glPointParameterfvEXT'); -end; - -procedure Read_GL_EXT_polygon_offset; -begin - glPolygonOffsetEXT := dglGetProcAddress('glPolygonOffsetEXT'); -end; - -procedure Read_GL_EXT_secondary_color; -begin - glSecondaryColor3bEXT := dglGetProcAddress('glSecondaryColor3bEXT'); - glSecondaryColor3bvEXT := dglGetProcAddress('glSecondaryColor3bvEXT'); - glSecondaryColor3dEXT := dglGetProcAddress('glSecondaryColor3dEXT'); - glSecondaryColor3dvEXT := dglGetProcAddress('glSecondaryColor3dvEXT'); - glSecondaryColor3fEXT := dglGetProcAddress('glSecondaryColor3fEXT'); - glSecondaryColor3fvEXT := dglGetProcAddress('glSecondaryColor3fvEXT'); - glSecondaryColor3iEXT := dglGetProcAddress('glSecondaryColor3iEXT'); - glSecondaryColor3ivEXT := dglGetProcAddress('glSecondaryColor3ivEXT'); - glSecondaryColor3sEXT := dglGetProcAddress('glSecondaryColor3sEXT'); - glSecondaryColor3svEXT := dglGetProcAddress('glSecondaryColor3svEXT'); - glSecondaryColor3ubEXT := dglGetProcAddress('glSecondaryColor3ubEXT'); - glSecondaryColor3ubvEXT := dglGetProcAddress('glSecondaryColor3ubvEXT'); - glSecondaryColor3uiEXT := dglGetProcAddress('glSecondaryColor3uiEXT'); - glSecondaryColor3uivEXT := dglGetProcAddress('glSecondaryColor3uivEXT'); - glSecondaryColor3usEXT := dglGetProcAddress('glSecondaryColor3usEXT'); - glSecondaryColor3usvEXT := dglGetProcAddress('glSecondaryColor3usvEXT'); - glSecondaryColorPointerEXT := dglGetProcAddress('glSecondaryColorPointerEXT'); -end; - -procedure Read_GL_EXT_stencil_two_side; -begin - glActiveStencilFaceEXT := dglGetProcAddress('glActiveStencilFaceEXT'); -end; - -procedure Read_GL_EXT_subtexture; -begin - glTexSubImage1DEXT := dglGetProcAddress('glTexSubImage1DEXT'); - glTexSubImage2DEXT := dglGetProcAddress('glTexSubImage2DEXT'); -end; - -procedure Read_GL_EXT_texture3D; -begin - glTexImage3DEXT := dglGetProcAddress('glTexImage3DEXT'); - glTexSubImage3DEXT := dglGetProcAddress('glTexSubImage3DEXT'); -end; - -procedure Read_GL_EXT_texture_object; -begin - glAreTexturesResidentEXT := dglGetProcAddress('glAreTexturesResidentEXT'); - glBindTextureEXT := dglGetProcAddress('glBindTextureEXT'); - glDeleteTexturesEXT := dglGetProcAddress('glDeleteTexturesEXT'); - glGenTexturesEXT := dglGetProcAddress('glGenTexturesEXT'); - glIsTextureEXT := dglGetProcAddress('glIsTextureEXT'); - glPrioritizeTexturesEXT := dglGetProcAddress('glPrioritizeTexturesEXT'); -end; - -procedure Read_GL_EXT_texture_perturb_normal; -begin - glTextureNormalEXT := dglGetProcAddress('glTextureNormalEXT'); -end; - -procedure Read_GL_EXT_vertex_array; -begin - glArrayElementEXT := dglGetProcAddress('glArrayElementEXT'); - glColorPointerEXT := dglGetProcAddress('glColorPointerEXT'); - glDrawArraysEXT := dglGetProcAddress('glDrawArraysEXT'); - glEdgeFlagPointerEXT := dglGetProcAddress('glEdgeFlagPointerEXT'); - glGetPointervEXT := dglGetProcAddress('glGetPointervEXT'); - glIndexPointerEXT := dglGetProcAddress('glIndexPointerEXT'); - glNormalPointerEXT := dglGetProcAddress('glNormalPointerEXT'); - glTexCoordPointerEXT := dglGetProcAddress('glTexCoordPointerEXT'); - glVertexPointerEXT := dglGetProcAddress('glVertexPointerEXT'); -end; - -procedure Read_GL_EXT_vertex_shader; -begin - glBeginVertexShaderEXT := dglGetProcAddress('glBeginVertexShaderEXT'); - glEndVertexShaderEXT := dglGetProcAddress('glEndVertexShaderEXT'); - glBindVertexShaderEXT := dglGetProcAddress('glBindVertexShaderEXT'); - glGenVertexShadersEXT := dglGetProcAddress('glGenVertexShadersEXT'); - glDeleteVertexShaderEXT := dglGetProcAddress('glDeleteVertexShaderEXT'); - glShaderOp1EXT := dglGetProcAddress('glShaderOp1EXT'); - glShaderOp2EXT := dglGetProcAddress('glShaderOp2EXT'); - glShaderOp3EXT := dglGetProcAddress('glShaderOp3EXT'); - glSwizzleEXT := dglGetProcAddress('glSwizzleEXT'); - glWriteMaskEXT := dglGetProcAddress('glWriteMaskEXT'); - glInsertComponentEXT := dglGetProcAddress('glInsertComponentEXT'); - glExtractComponentEXT := dglGetProcAddress('glExtractComponentEXT'); - glGenSymbolsEXT := dglGetProcAddress('glGenSymbolsEXT'); - glSetInvariantEXT := dglGetProcAddress('glSetInvariantEXT'); - glSetLocalConstantEXT := dglGetProcAddress('glSetLocalConstantEXT'); - glVariantbvEXT := dglGetProcAddress('glVariantbvEXT'); - glVariantsvEXT := dglGetProcAddress('glVariantsvEXT'); - glVariantivEXT := dglGetProcAddress('glVariantivEXT'); - glVariantfvEXT := dglGetProcAddress('glVariantfvEXT'); - glVariantdvEXT := dglGetProcAddress('glVariantdvEXT'); - glVariantubvEXT := dglGetProcAddress('glVariantubvEXT'); - glVariantusvEXT := dglGetProcAddress('glVariantusvEXT'); - glVariantuivEXT := dglGetProcAddress('glVariantuivEXT'); - glVariantPointerEXT := dglGetProcAddress('glVariantPointerEXT'); - glEnableVariantClientStateEXT := dglGetProcAddress('glEnableVariantClientStateEXT'); - glDisableVariantClientStateEXT := dglGetProcAddress('glDisableVariantClientStateEXT'); - glBindLightParameterEXT := dglGetProcAddress('glBindLightParameterEXT'); - glBindMaterialParameterEXT := dglGetProcAddress('glBindMaterialParameterEXT'); - glBindTexGenParameterEXT := dglGetProcAddress('glBindTexGenParameterEXT'); - glBindTextureUnitParameterEXT := dglGetProcAddress('glBindTextureUnitParameterEXT'); - glBindParameterEXT := dglGetProcAddress('glBindParameterEXT'); - glIsVariantEnabledEXT := dglGetProcAddress('glIsVariantEnabledEXT'); - glGetVariantBooleanvEXT := dglGetProcAddress('glGetVariantBooleanvEXT'); - glGetVariantIntegervEXT := dglGetProcAddress('glGetVariantIntegervEXT'); - glGetVariantFloatvEXT := dglGetProcAddress('glGetVariantFloatvEXT'); - glGetVariantPointervEXT := dglGetProcAddress('glGetVariantPointervEXT'); - glGetInvariantBooleanvEXT := dglGetProcAddress('glGetInvariantBooleanvEXT'); - glGetInvariantIntegervEXT := dglGetProcAddress('glGetInvariantIntegervEXT'); - glGetInvariantFloatvEXT := dglGetProcAddress('glGetInvariantFloatvEXT'); - glGetLocalConstantBooleanvEXT := dglGetProcAddress('glGetLocalConstantBooleanvEXT'); - glGetLocalConstantIntegervEXT := dglGetProcAddress('glGetLocalConstantIntegervEXT'); - glGetLocalConstantFloatvEXT := dglGetProcAddress('glGetLocalConstantFloatvEXT'); -end; - -procedure Read_GL_EXT_vertex_weighting; -begin - glVertexWeightfEXT := dglGetProcAddress('glVertexWeightfEXT'); - glVertexWeightfvEXT := dglGetProcAddress('glVertexWeightfvEXT'); - glVertexWeightPointerEXT := dglGetProcAddress('glVertexWeightPointerEXT'); -end; - -procedure Read_GL_EXT_depth_bounds_test; -begin - glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP'); - glDepthBoundsEXT := dglGetProcAddress('glDepthBoundsEXT'); -end; - -procedure Read_GL_EXT_blend_equation_separate; -begin - glBlendEquationSeparateEXT := dglGetProcAddress('glBlendEquationSeparateEXT'); -end; - -procedure Read_GL_EXT_stencil_clear_tag; -begin - glStencilClearTagEXT := dglGetProcAddress('glStencilClearTagEXT'); -end; - -procedure Read_GL_EXT_framebuffer_blit; -begin - glBlitFramebufferEXT := dglGetProcAddress('glBlitFramebufferEXT'); -end; - -procedure Read_GL_EXT_framebuffer_multisample; -begin - glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT'); -end; - -procedure Read_GL_EXT_timer_query; -begin - glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT'); - glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT'); -end; - -procedure Read_GL_EXT_gpu_program_parameters; -begin - glProgramEnvParameters4fvEXT := dglGetProcAddress('glProgramEnvParameters4fvEXT'); - glProgramLocalParameters4fvEXT := dglGetProcAddress('glProgramLocalParameters4fvEXT'); -end; - -procedure Read_GL_EXT_bindable_uniform; -begin - glUniformBufferEXT := dglGetProcAddress('glUniformBufferEXT'); - glGetUniformBufferSizeEXT := dglGetProcAddress('glGetUniformBufferSizeEXT'); - glGetUniformOffsetEXT := dglGetProcAddress('glGetUniformOffsetEXT'); -end; - -procedure Read_GL_EXT_draw_buffers2; -begin - glColorMaskIndexedEXT := dglGetProcAddress('glColorMaskIndexedEXT'); - glGetBooleanIndexedvEXT := dglGetProcAddress('glGetBooleanIndexedvEXT'); - glGetIntegerIndexedvEXT := dglGetProcAddress('glGetIntegerIndexedvEXT'); - glEnableIndexedEXT := dglGetProcAddress('glEnableIndexedEXT'); - glDisableIndexedEXT := dglGetProcAddress('glDisableIndexedEXT'); - glIsEnabledIndexedEXT := dglGetProcAddress('glIsEnabledIndexedEXT'); -end; - -procedure Read_GL_EXT_draw_instanced; -begin - glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT'); - glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT'); -end; - -procedure Read_GL_EXT_geometry_shader4; -begin - glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT'); - glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT'); -// glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT'); - glFramebufferTextureFaceEXT := dglGetProcAddress('glFramebufferTextureFaceEXT'); -end; - -procedure Read_GL_EXT_gpu_shader4; -begin - glVertexAttribI1iEXT := dglGetProcAddress('glVertexAttribI1iEXT'); - glVertexAttribI2iEXT := dglGetProcAddress('glVertexAttribI2iEXT'); - glVertexAttribI3iEXT := dglGetProcAddress('glVertexAttribI3iEXT'); - glVertexAttribI4iEXT := dglGetProcAddress('glVertexAttribI4iEXT'); - glVertexAttribI1uiEXT := dglGetProcAddress('glVertexAttribI1uiEXT'); - glVertexAttribI2uiEXT := dglGetProcAddress('glVertexAttribI2uiEXT'); - glVertexAttribI3uiEXT := dglGetProcAddress('glVertexAttribI3uiEXT'); - glVertexAttribI4uiEXT := dglGetProcAddress('glVertexAttribI4uiEXT'); - glVertexAttribI1ivEXT := dglGetProcAddress('glVertexAttribI1ivEXT'); - glVertexAttribI2ivEXT := dglGetProcAddress('glVertexAttribI2ivEXT'); - glVertexAttribI3ivEXT := dglGetProcAddress('glVertexAttribI3ivEXT'); - glVertexAttribI4ivEXT := dglGetProcAddress('glVertexAttribI4ivEXT'); - glVertexAttribI1uivEXT := dglGetProcAddress('glVertexAttribI1uivEXT'); - glVertexAttribI2uivEXT := dglGetProcAddress('glVertexAttribI2uivEXT'); - glVertexAttribI3uivEXT := dglGetProcAddress('glVertexAttribI3uivEXT'); - glVertexAttribI4uivEXT := dglGetProcAddress('glVertexAttribI4uivEXT'); - glVertexAttribI4bvEXT := dglGetProcAddress('glVertexAttribI4bvEXT'); - glVertexAttribI4svEXT := dglGetProcAddress('glVertexAttribI4svEXT'); - glVertexAttribI4ubvEXT := dglGetProcAddress('glVertexAttribI4ubvEXT'); - glVertexAttribI4usvEXT := dglGetProcAddress('glVertexAttribI4usvEXT'); - glVertexAttribIPointerEXT := dglGetProcAddress('glVertexAttribIPointerEXT'); - glGetVertexAttribIivEXT := dglGetProcAddress('glGetVertexAttribIivEXT'); - glGetVertexAttribIuivEXT := dglGetProcAddress('glGetVertexAttribIuivEXT'); - glUniform1uiEXT := dglGetProcAddress('glUniform1uiEXT'); - glUniform2uiEXT := dglGetProcAddress('glUniform2uiEXT'); - glUniform3uiEXT := dglGetProcAddress('glUniform3uiEXT'); - glUniform4uiEXT := dglGetProcAddress('glUniform4uiEXT'); - glUniform1uivEXT := dglGetProcAddress('glUniform1uivEXT'); - glUniform2uivEXT := dglGetProcAddress('glUniform2uivEXT'); - glUniform3uivEXT := dglGetProcAddress('glUniform3uivEXT'); - glUniform4uivEXT := dglGetProcAddress('glUniform4uivEXT'); - glGetUniformuivEXT := dglGetProcAddress('glGetUniformuivEXT'); - glBindFragDataLocationEXT := dglGetProcAddress('glBindFragDataLocationEXT'); - glGetFragDataLocationEXT := dglGetProcAddress('glGetFragDataLocationEXT'); -end; - -procedure Read_GL_EXT_texture_array; -begin - glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT'); -end; - -procedure Read_GL_EXT_texture_buffer_object; -begin - glTexBufferEXT := dglGetProcAddress('glTexBufferEXT'); -end; - -procedure Read_GL_EXT_texture_integer; -begin - glClearColorIiEXT := dglGetProcAddress('glClearColorIiEXT'); - glClearColorIuiEXT := dglGetProcAddress('glClearColorIuiEXT'); - glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT'); - glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT'); - glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT'); - glGetTexParameterIiuvEXT := dglGetProcAddress('glGetTexParameterIiuvEXT'); -end; - -procedure Read_GL_EXT_transform_feedback; -begin - glBeginTransformFeedbackEXT := dglGetProcAddress('lBeginTransformFeedbackEXT'); - glEndTransformFeedbackEXT := dglGetProcAddress('glEndTransformFeedbackEXT'); - glBindBufferRangeEXT := dglGetProcAddress('glBindBufferRangeEXT'); - glBindBufferOffsetEXT := dglGetProcAddress('glBindBufferOffsetEXT'); - glBindBufferBaseEXT := dglGetProcAddress('glBindBufferBaseEXT'); - glTransformFeedbackVaryingsEXT := dglGetProcAddress('glTransformFeedbackVaryingsEXT'); - glGetTransformFeedbackVaryingEXT := dglGetProcAddress('glGetTransformFeedbackVaryingEXT'); -end; - -procedure Read_GL_EXT_direct_state_access; -begin - glClientAttribDefaultEXT := dglGetProcAddress('glClientAttribDefaultEXT'); - glPushClientAttribDefaultEXT := dglGetProcAddress('glPushClientAttribDefaultEXT'); - glMatrixLoadfEXT := dglGetProcAddress('glMatrixLoadfEXT'); - glMatrixLoaddEXT := dglGetProcAddress('glMatrixLoaddEXT'); - glMatrixMultfEXT := dglGetProcAddress('glMatrixMultfEXT'); - glMatrixMultdEXT := dglGetProcAddress('glMatrixMultdEXT'); - glMatrixLoadIdentityEXT := dglGetProcAddress('glMatrixLoadIdentityEXT'); - glMatrixRotatefEXT := dglGetProcAddress('glMatrixRotatefEXT'); - glMatrixRotatedEXT := dglGetProcAddress('glMatrixRotatedEXT'); - glMatrixScalefEXT := dglGetProcAddress('glMatrixScalefEXT'); - glMatrixScaledEXT := dglGetProcAddress('glMatrixScaledEXT'); - glMatrixTranslatefEXT := dglGetProcAddress('glMatrixTranslatefEXT'); - glMatrixTranslatedEXT := dglGetProcAddress('glMatrixTranslatedEXT'); - glMatrixFrustumEXT := dglGetProcAddress('glMatrixFrustumEXT'); - glMatrixOrthoEXT := dglGetProcAddress('glMatrixOrthoEXT'); - glMatrixPopEXT := dglGetProcAddress('glMatrixPopEXT'); - glMatrixPushEXT := dglGetProcAddress('glMatrixPushEXT'); - glMatrixLoadTransposefEXT := dglGetProcAddress('glMatrixLoadTransposefEXT'); - glMatrixLoadTransposedEXT := dglGetProcAddress('glMatrixLoadTransposedEXT'); - glMatrixMultTransposefEXT := dglGetProcAddress('glMatrixMultTransposefEXT'); - glMatrixMultTransposedEXT := dglGetProcAddress('glMatrixMultTransposedEXT'); - glTextureParameterfEXT := dglGetProcAddress('glTextureParameterfEXT'); - glTextureParameterfvEXT := dglGetProcAddress('glTextureParameterfvEXT'); - glTextureParameteriEXT := dglGetProcAddress('glTextureParameteriEXT'); - glTextureParameterivEXT := dglGetProcAddress('glTextureParameterivEXT'); - glTextureImage1DEXT := dglGetProcAddress('glTextureImage1DEXT'); - glTextureImage2DEXT := dglGetProcAddress('glTextureImage2DEXT'); - glTextureSubImage1DEXT := dglGetProcAddress('glTextureSubImage1DEXT'); - glTextureSubImage2DEXT := dglGetProcAddress('glTextureSubImage2DEXT'); - glCopyTextureImage1DEXT := dglGetProcAddress('glCopyTextureImage1DEXT'); - glCopyTextureImage2DEXT := dglGetProcAddress('glCopyTextureImage2DEXT'); - glCopyTextureSubImage1DEXT := dglGetProcAddress('glCopyTextureSubImage1DEXT'); - glCopyTextureSubImage2DEXT := dglGetProcAddress('glCopyTextureSubImage2DEXT'); - glGetTextureImageEXT := dglGetProcAddress('glGetTextureImageEXT'); - glGetTextureParameterfvEXT := dglGetProcAddress('glGetTextureParameterfvEXT'); - glGetTextureParameterivEXT := dglGetProcAddress('glGetTextureParameterivEXT'); - glGetTextureLevelParameterfvEXT := dglGetProcAddress('glGetTextureLevelParameterfvEXT'); - glGetTextureLevelParameterivEXT := dglGetProcAddress('glGetTextureLevelParameterivEXT'); - glTextureImage3DEXT := dglGetProcAddress('glTextureImage3DEXT'); - glTextureSubImage3DEXT := dglGetProcAddress('glTextureSubImage3DEXT'); - glCopyTextureSubImage3DEXT := dglGetProcAddress('glCopyTextureSubImage3DEXT'); - glMultiTexParameterfEXT := dglGetProcAddress('glMultiTexParameterfEXT'); - glMultiTexParameterfvEXT := dglGetProcAddress('glMultiTexParameterfvEXT'); - glMultiTexParameteriEXT := dglGetProcAddress('glMultiTexParameteriEXT'); - glMultiTexParameterivEXT := dglGetProcAddress('glMultiTexParameterivEXT'); - glMultiTexImage1DEXT := dglGetProcAddress('glMultiTexImage1DEXT'); - glMultiTexImage2DEXT := dglGetProcAddress('glMultiTexImage2DEXT'); - glMultiTexSubImage1DEXT := dglGetProcAddress('glMultiTexSubImage1DEXT'); - glMultiTexSubImage2DEXT := dglGetProcAddress('glMultiTexSubImage2DEXT'); - glCopyMultiTexImage1DEXT := dglGetProcAddress('glCopyMultiTexImage1DEXT'); - glCopyMultiTexImage2DEXT := dglGetProcAddress('glCopyMultiTexImage2DEXT'); - glCopyMultiTexSubImage1DEXT := dglGetProcAddress('glCopyMultiTexSubImage1DEXT'); - glCopyMultiTexSubImage2DEXT := dglGetProcAddress('glCopyMultiTexSubImage2DEXT'); - glGetMultiTexImageEXT := dglGetProcAddress('glGetMultiTexImageEXT'); - glGetMultiTexParameterfvEXT := dglGetProcAddress('glGetMultiTexParameterfvEXT'); - glGetMultiTexParameterivEXT := dglGetProcAddress('glGetMultiTexParameterivEXT'); - glGetMultiTexLevelParameterfvEXT := dglGetProcAddress('glGetMultiTexLevelParameterfvEXT'); - glGetMultiTexLevelParameterivEXT := dglGetProcAddress('glGetMultiTexLevelParameterivEXT'); - glMultiTexImage3DEXT := dglGetProcAddress('glMultiTexImage3DEXT'); - glMultiTexSubImage3DEXT := dglGetProcAddress('glMultiTexSubImage3DEXT'); - glCopyMultiTexSubImage3DEXT := dglGetProcAddress('glCopyMultiTexSubImage3DEXT'); - glBindMultiTextureEXT := dglGetProcAddress('glBindMultiTextureEXT'); - glEnableClientStateIndexedEXT := dglGetProcAddress('glEnableClientStateIndexedEXT'); - glDisableClientStateIndexedEXT := dglGetProcAddress('glDisableClientStateIndexedEXT'); - glMultiTexCoordPointerEXT := dglGetProcAddress('glMultiTexCoordPointerEXT'); - glMultiTexEnvfEXT := dglGetProcAddress('glMultiTexEnvfEXT'); - glMultiTexEnvfvEXT := dglGetProcAddress('glMultiTexEnvfvEXT'); - glMultiTexEnviEXT := dglGetProcAddress('glMultiTexEnviEXT'); - glMultiTexEnvivEXT := dglGetProcAddress('glMultiTexEnvivEXT'); - glMultiTexGendEXT := dglGetProcAddress('glMultiTexGendEXT'); - glMultiTexGendvEXT := dglGetProcAddress('glMultiTexGendvEXT'); - glMultiTexGenfEXT := dglGetProcAddress('glMultiTexGenfEXT'); - glMultiTexGenfvEXT := dglGetProcAddress('glMultiTexGenfvEXT'); - glMultiTexGeniEXT := dglGetProcAddress('glMultiTexGeniEXT'); - glMultiTexGenivEXT := dglGetProcAddress('glMultiTexGenivEXT'); - glGetMultiTexEnvfvEXT := dglGetProcAddress('glGetMultiTexEnvfvEXT'); - glGetMultiTexEnvivEXT := dglGetProcAddress('glGetMultiTexEnvivEXT'); - glGetMultiTexGendvEXT := dglGetProcAddress('glGetMultiTexGendvEXT'); - glGetMultiTexGenfvEXT := dglGetProcAddress('glGetMultiTexGenfvEXT'); - glGetMultiTexGenivEXT := dglGetProcAddress('glGetMultiTexGenivEXT'); - glGetFloatIndexedvEXT := dglGetProcAddress('glGetFloatIndexedvEXT'); - glGetDoubleIndexedvEXT := dglGetProcAddress('glGetDoubleIndexedvEXT'); - glGetPointerIndexedvEXT := dglGetProcAddress('glGetPointerIndexedvEXT'); - glCompressedTextureImage3DEXT := dglGetProcAddress('glCompressedTextureImage3DEXT'); - glCompressedTextureImage2DEXT := dglGetProcAddress('glCompressedTextureImage2DEXT'); - glCompressedTextureImage1DEXT := dglGetProcAddress('glCompressedTextureImage1DEXT'); - glCompressedTextureSubImage3DEXT := dglGetProcAddress('glCompressedTextureSubImage3DEXT'); - glCompressedTextureSubImage2DEXT := dglGetProcAddress('glCompressedTextureSubImage2DEXT'); - glCompressedTextureSubImage1DEXT := dglGetProcAddress('glCompressedTextureSubImage1DEXT'); - glGetCompressedTextureImageEXT := dglGetProcAddress('glGetCompressedTextureImageEXT'); - glCompressedMultiTexImage3DEXT := dglGetProcAddress('glCompressedMultiTexImage3DEXT'); - glCompressedMultiTexImage2DEXT := dglGetProcAddress('glCompressedMultiTexImage2DEXT'); - glCompressedMultiTexImage1DEXT := dglGetProcAddress('glCompressedMultiTexImage1DEXT'); - glCompressedMultiTexSubImage3DEXT := dglGetProcAddress('glCompressedMultiTexSubImage3DEXT'); - glCompressedMultiTexSubImage2DEXT := dglGetProcAddress('glCompressedMultiTexSubImage2DEXT'); - glCompressedMultiTexSubImage1DEXT := dglGetProcAddress('glCompressedMultiTexSubImage1DEXT'); - glGetCompressedMultiTexImageEXT := dglGetProcAddress('glGetCompressedMultiTexImageEXT'); - glNamedProgramStringEXT := dglGetProcAddress('glNamedProgramStringEXT'); - glNamedProgramLocalParameter4dEXT := dglGetProcAddress('glNamedProgramLocalParameter4dEXT'); - glNamedProgramLocalParameter4dvEXT := dglGetProcAddress('glNamedProgramLocalParameter4dvEXT'); - glNamedProgramLocalParameter4fEXT := dglGetProcAddress('glNamedProgramLocalParameter4fEXT'); - glNamedProgramLocalParameter4fvEXT := dglGetProcAddress('glNamedProgramLocalParameter4fvEXT'); - glGetNamedProgramLocalParameterdvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterdvEXT'); - glGetNamedProgramLocalParameterfvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterfvEXT'); - glGetNamedProgramivEXT := dglGetProcAddress('glGetNamedProgramivEXT'); - glGetNamedProgramStringEXT := dglGetProcAddress('glGetNamedProgramStringEXT'); - glNamedProgramLocalParameters4fvEXT := dglGetProcAddress('glNamedProgramLocalParameters4fvEXT'); - glNamedProgramLocalParameterI4iEXT := dglGetProcAddress('glNamedProgramLocalParameterI4iEXT'); - glNamedProgramLocalParameterI4ivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4ivEXT'); - glNamedProgramLocalParametersI4ivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4ivEXT'); - glNamedProgramLocalParameterI4uiEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uiEXT'); - glNamedProgramLocalParameterI4uivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uivEXT'); - glNamedProgramLocalParametersI4uivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4uivEXT'); - glGetNamedProgramLocalParameterIivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIivEXT'); - glGetNamedProgramLocalParameterIuivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIuivEXT'); - glTextureParameterIivEXT := dglGetProcAddress('glTextureParameterIivEXT'); - glTextureParameterIuivEXT := dglGetProcAddress('glTextureParameterIuivEXT'); - glGetTextureParameterIivEXT := dglGetProcAddress('glGetTextureParameterIivEXT'); - glGetTextureParameterIuivEXT := dglGetProcAddress('glGetTextureParameterIuivEXT'); - glMultiTexParameterIivEXT := dglGetProcAddress('glMultiTexParameterIivEXT'); - glMultiTexParameterIuivEXT := dglGetProcAddress('glMultiTexParameterIuivEXT'); - glGetMultiTexParameterIivEXT := dglGetProcAddress('glGetMultiTexParameterIivEXT'); - glGetMultiTexParameterIuivEXT := dglGetProcAddress('glGetMultiTexParameterIuivEXT'); - glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT'); - glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT'); - glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT'); - glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT'); - glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT'); - glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT'); - glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT'); - glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT'); - glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT'); - glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT'); - glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT'); - glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT'); - glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT'); - glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT'); - glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT'); - glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT'); - glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT'); - glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT'); - glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT'); - glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT'); - glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT'); - glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT'); - glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT'); - glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT'); - glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT'); - glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT'); - glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT'); - glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT'); - glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT'); - glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT'); - glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT'); - glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT'); - glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT'); - glNamedBufferDataEXT := dglGetProcAddress('glNamedBufferDataEXT'); - glNamedBufferSubDataEXT := dglGetProcAddress('glNamedBufferSubDataEXT'); - glMapNamedBufferEXT := dglGetProcAddress('glMapNamedBufferEXT'); - glUnmapNamedBufferEXT := dglGetProcAddress('glUnmapNamedBufferEXT'); - glMapNamedBufferRangeEXT := dglGetProcAddress('glMapNamedBufferRangeEXT'); - glFlushMappedNamedBufferRangeEXT := dglGetProcAddress('glFlushMappedNamedBufferRangeEXT'); - glNamedCopyBufferSubDataEXT := dglGetProcAddress('glNamedCopyBufferSubDataEXT'); - glGetNamedBufferParameterivEXT := dglGetProcAddress('glGetNamedBufferParameterivEXT'); - glGetNamedBufferPointervEXT := dglGetProcAddress('glGetNamedBufferPointervEXT'); - glGetNamedBufferSubDataEXT := dglGetProcAddress('glGetNamedBufferSubDataEXT'); - glTextureBufferEXT := dglGetProcAddress('glTextureBufferEXT'); - glMultiTexBufferEXT := dglGetProcAddress('glMultiTexBufferEXT'); - glNamedRenderbufferStorageEXT := dglGetProcAddress('glNamedRenderbufferStorageEXT'); - glGetNamedRenderbufferParameterivEXT := dglGetProcAddress('glGetNamedRenderbufferParameterivEXT'); - glCheckNamedFramebufferStatusEXT := dglGetProcAddress('glCheckNamedFramebufferStatusEXT'); - glNamedFramebufferTexture1DEXT := dglGetProcAddress('glNamedFramebufferTexture1DEXT'); - glNamedFramebufferTexture2DEXT := dglGetProcAddress('glNamedFramebufferTexture2DEXT'); - glNamedFramebufferTexture3DEXT := dglGetProcAddress('glNamedFramebufferTexture3DEXT'); - glNamedFramebufferRenderbufferEXT := dglGetProcAddress('glNamedFramebufferRenderbufferEXT'); - glGetNamedFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetNamedFramebufferAttachmentParameterivEXT'); - glGenerateTextureMipmapEXT := dglGetProcAddress('glGenerateTextureMipmapEXT'); - glGenerateMultiTexMipmapEXT := dglGetProcAddress('glGenerateMultiTexMipmapEXT'); - glFramebufferDrawBufferEXT := dglGetProcAddress('glFramebufferDrawBufferEXT'); - glFramebufferDrawBuffersEXT := dglGetProcAddress('glFramebufferDrawBuffersEXT'); - glFramebufferReadBufferEXT := dglGetProcAddress('glFramebufferReadBufferEXT'); - glGetFramebufferParameterivEXT := dglGetProcAddress('glGetFramebufferParameterivEXT'); - glNamedRenderbufferStorageMultisampleEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleEXT'); - glNamedRenderbufferStorageMultisampleCoverageEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleCoverageEXT'); - glNamedFramebufferTextureEXT := dglGetProcAddress('glNamedFramebufferTextureEXT'); - glNamedFramebufferTextureLayerEXT := dglGetProcAddress('glNamedFramebufferTextureLayerEXT'); - glNamedFramebufferTextureFaceEXT := dglGetProcAddress('glNamedFramebufferTextureFaceEXT'); - glTextureRenderbufferEXT := dglGetProcAddress('glTextureRenderbufferEXT'); - glMultiTexRenderbufferEXT := dglGetProcAddress('glMultiTexRenderbufferEXT'); - glProgramUniform1dEXT := dglGetProcAddress('glProgramUniform1dEXT'); - glProgramUniform2dEXT := dglGetProcAddress('glProgramUniform2dEXT'); - glProgramUniform3dEXT := dglGetProcAddress('glProgramUniform3dEXT'); - glProgramUniform4dEXT := dglGetProcAddress('glProgramUniform4dEXT'); - glProgramUniform1dvEXT := dglGetProcAddress('glProgramUniform1dvEXT'); - glProgramUniform2dvEXT := dglGetProcAddress('glProgramUniform2dvEXT'); - glProgramUniform3dvEXT := dglGetProcAddress('glProgramUniform3dvEXT'); - glProgramUniform4dvEXT := dglGetProcAddress('glProgramUniform4dvEXT'); - glProgramUniformMatrix2dvEXT := dglGetProcAddress('glProgramUniformMatrix2dvEXT'); - glProgramUniformMatrix3dvEXT := dglGetProcAddress('glProgramUniformMatrix3dvEXT'); - glProgramUniformMatrix4dvEXT := dglGetProcAddress('glProgramUniformMatrix4dvEXT'); - glProgramUniformMatrix2x3dvEXT := dglGetProcAddress('glProgramUniformMatrix2x3dvEXT'); - glProgramUniformMatrix2x4dvEXT := dglGetProcAddress('glProgramUniformMatrix2x4dvEXT'); - glProgramUniformMatrix3x2dvEXT := dglGetProcAddress('glProgramUniformMatrix3x2dvEXT'); - glProgramUniformMatrix3x4dvEXT := dglGetProcAddress('glProgramUniformMatrix3x4dvEXT'); - glProgramUniformMatrix4x2dvEXT := dglGetProcAddress('glProgramUniformMatrix4x2dvEXT'); - glProgramUniformMatrix4x3dvEXT := dglGetProcAddress('glProgramUniformMatrix4x3dvEXT'); -end; - -procedure Read_GL_EXT_separate_shader_objects; -begin - glUseShaderProgramEXT := dglGetProcAddress('glUseShaderProgramEXT'); - glActiveProgramEXT := dglGetProcAddress('glActiveProgramEXT'); - glCreateShaderProgramEXT := dglGetProcAddress('glCreateShaderProgramEXT'); -end; - -procedure Read_GL_EXT_shader_image_load_store; -begin - glBindImageTextureEXT := dglGetProcAddress('glBindImageTextureEXT'); - glMemoryBarrierEXT := dglGetProcAddress('glMemoryBarrierEXT'); -end; - -procedure Read_GL_EXT_vertex_attrib_64bit; -begin - glVertexAttribL1dEXT := dglGetProcAddress('glVertexAttribL1dEXT'); - glVertexAttribL2dEXT := dglGetProcAddress('glVertexAttribL2dEXT'); - glVertexAttribL3dEXT := dglGetProcAddress('glVertexAttribL3dEXT'); - glVertexAttribL4dEXT := dglGetProcAddress('glVertexAttribL4dEXT'); - glVertexAttribL1dvEXT := dglGetProcAddress('glVertexAttribL1dvEXT'); - glVertexAttribL2dvEXT := dglGetProcAddress('glVertexAttribL2dvEXT'); - glVertexAttribL3dvEXT := dglGetProcAddress('glVertexAttribL3dvEXT'); - glVertexAttribL4dvEXT := dglGetProcAddress('glVertexAttribL4dvEXT'); - glVertexAttribLPointerEXT := dglGetProcAddress('glVertexAttribLPointerEXT'); - glGetVertexAttribLdvEXT := dglGetProcAddress('glGetVertexAttribLdvEXT'); - glVertexArrayVertexAttribLOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribLOffsetEXT'); -end; - -procedure Read_GL_HP_image_transform; -begin - glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP'); - glImageTransformParameterfHP := dglGetProcAddress('glImageTransformParameterfHP'); - glImageTransformParameterivHP := dglGetProcAddress('glImageTransformParameterivHP'); - glImageTransformParameterfvHP := dglGetProcAddress('glImageTransformParameterfvHP'); - glGetImageTransformParameterivHP := dglGetProcAddress('glGetImageTransformParameterivHP'); - glGetImageTransformParameterfvHP := dglGetProcAddress('glGetImageTransformParameterfvHP'); -end; - -procedure Read_GL_IBM_multimode_draw_arrays; -begin - glMultiModeDrawArraysIBM := dglGetProcAddress('glMultiModeDrawArraysIBM'); - glMultiModeDrawElementsIBM := dglGetProcAddress('glMultiModeDrawElementsIBM'); -end; - -procedure Read_GL_IBM_vertex_array_lists; -begin - glColorPointerListIBM := dglGetProcAddress('glColorPointerListIBM'); - glSecondaryColorPointerListIBM := dglGetProcAddress('glSecondaryColorPointerListIBM'); - glEdgeFlagPointerListIBM := dglGetProcAddress('glEdgeFlagPointerListIBM'); - glFogCoordPointerListIBM := dglGetProcAddress('glFogCoordPointerListIBM'); - glIndexPointerListIBM := dglGetProcAddress('glIndexPointerListIBM'); - glNormalPointerListIBM := dglGetProcAddress('glNormalPointerListIBM'); - glTexCoordPointerListIBM := dglGetProcAddress('glTexCoordPointerListIBM'); - glVertexPointerListIBM := dglGetProcAddress('glVertexPointerListIBM'); -end; - -procedure Read_GL_INGR_blend_func_separate; -begin - glBlendFuncSeparateINGR := dglGetProcAddress('glBlendFuncSeparateINGR'); -end; - -procedure Read_GL_INTEL_parallel_arrays; -begin - glVertexPointervINTEL := dglGetProcAddress('glVertexPointervINTEL'); - glNormalPointervINTEL := dglGetProcAddress('glNormalPointervINTEL'); - glColorPointervINTEL := dglGetProcAddress('glColorPointervINTEL'); - glTexCoordPointervINTEL := dglGetProcAddress('glTexCoordPointervINTEL'); -end; - -procedure Read_GL_MESA_resize_buffers; -begin - glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA'); -end; - -procedure Read_GL_MESA_window_pos; -begin - glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA'); - glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA'); - glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA'); - glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA'); - glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA'); - glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA'); - glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA'); - glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA'); - glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA'); - glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA'); - glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA'); - glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA'); - glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA'); - glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA'); - glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA'); - glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA'); - glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA'); - glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA'); - glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA'); - glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA'); - glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA'); - glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA'); - glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA'); - glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA'); -end; - -procedure Read_GL_NV_evaluators; -begin - glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV'); - glMapParameterivNV := dglGetProcAddress('glMapParameterivNV'); - glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV'); - glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV'); - glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV'); - glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV'); - glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV'); - glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV'); - glEvalMapsNV := dglGetProcAddress('glEvalMapsNV'); -end; - -procedure Read_GL_NV_fence; -begin - glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV'); - glGenFencesNV := dglGetProcAddress('glGenFencesNV'); - glIsFenceNV := dglGetProcAddress('glIsFenceNV'); - glTestFenceNV := dglGetProcAddress('glTestFenceNV'); - glGetFenceivNV := dglGetProcAddress('glGetFenceivNV'); - glFinishFenceNV := dglGetProcAddress('glFinishFenceNV'); - glSetFenceNV := dglGetProcAddress('glSetFenceNV'); -end; - -procedure Read_GL_NV_fragment_program; -begin - glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV'); - glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV'); - glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV'); - glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV'); - glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV'); - glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV'); -end; - -procedure Read_GL_NV_half_float; -begin - glVertex2hNV := dglGetProcAddress('glVertex2hNV'); - glVertex2hvNV := dglGetProcAddress('glVertex2hvNV'); - glVertex3hNV := dglGetProcAddress('glVertex3hNV'); - glVertex3hvNV := dglGetProcAddress('glVertex3hvNV'); - glVertex4hNV := dglGetProcAddress('glVertex4hNV'); - glVertex4hvNV := dglGetProcAddress('glVertex4hvNV'); - glNormal3hNV := dglGetProcAddress('glNormal3hNV'); - glNormal3hvNV := dglGetProcAddress('glNormal3hvNV'); - glColor3hNV := dglGetProcAddress('glColor3hNV'); - glColor3hvNV := dglGetProcAddress('glColor3hvNV'); - glColor4hNV := dglGetProcAddress('glColor4hNV'); - glColor4hvNV := dglGetProcAddress('glColor4hvNV'); - glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV'); - glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV'); - glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV'); - glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV'); - glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV'); - glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV'); - glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV'); - glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV'); - glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV'); - glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV'); - glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV'); - glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV'); - glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV'); - glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV'); - glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV'); - glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV'); - glFogCoordhNV := dglGetProcAddress('glFogCoordhNV'); - glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV'); - glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV'); - glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV'); - glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV'); - glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV'); - glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV'); - glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV'); - glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV'); - glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV'); - glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV'); - glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV'); - glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV'); - glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV'); - glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV'); - glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV'); - glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV'); - glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV'); -end; - -procedure Read_GL_NV_occlusion_query; -begin - glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV'); - glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV'); - glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV'); - glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV'); - glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV'); - glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV'); - glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV'); -end; - -procedure Read_GL_NV_pixel_data_range; -begin - glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV'); - glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV'); -end; - -procedure Read_GL_NV_point_sprite; -begin - glPointParameteriNV := dglGetProcAddress('glPointParameteriNV'); - glPointParameterivNV := dglGetProcAddress('glPointParameterivNV'); -end; - -procedure Read_GL_NV_primitive_restart; -begin - glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV'); - glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV'); -end; - -procedure Read_GL_NV_register_combiners; -begin - glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV'); - glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV'); - glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV'); - glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV'); - glCombinerInputNV := dglGetProcAddress('glCombinerInputNV'); - glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV'); - glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV'); - glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV'); - glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV'); - glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV'); - glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV'); - glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV'); - glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV'); -end; - -procedure Read_GL_NV_register_combiners2; -begin - glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV'); - glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV'); -end; - -procedure Read_GL_NV_vertex_array_range; -begin - glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV'); - glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV'); -end; - -procedure Read_GL_NV_vertex_program; -begin - glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV'); - glBindProgramNV := dglGetProcAddress('glBindProgramNV'); - glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV'); - glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV'); - glGenProgramsNV := dglGetProcAddress('glGenProgramsNV'); - glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV'); - glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV'); - glGetProgramivNV := dglGetProcAddress('glGetProgramivNV'); - glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV'); - glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV'); - glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV'); - glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV'); - glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV'); - glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV'); - glIsProgramNV := dglGetProcAddress('glIsProgramNV'); - glLoadProgramNV := dglGetProcAddress('glLoadProgramNV'); - glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV'); - glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV'); - glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV'); - glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV'); - glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV'); - glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV'); - glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV'); - glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV'); - glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV'); - glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV'); - glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV'); - glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV'); - glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV'); - glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV'); - glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV'); - glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV'); - glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV'); - glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV'); - glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV'); - glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV'); - glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV'); - glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV'); - glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV'); - glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV'); - glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV'); - glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV'); - glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV'); - glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV'); - glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV'); - glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV'); - glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV'); - glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV'); - glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV'); - glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV'); - glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV'); - glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV'); - glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV'); - glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV'); - glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV'); - glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV'); - glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV'); - glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV'); - glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV'); - glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV'); - glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV'); - glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV'); - glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV'); - glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV'); -end; - -procedure Read_GL_NV_depth_buffer_float; -begin - glDepthRangedNV := dglGetProcAddress('glDepthRangedNV'); - glClearDepthdNV := dglGetProcAddress('glClearDepthdNV'); - glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV'); -end; - -procedure Read_GL_NV_framebuffer_multisample_coverage; -begin - glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV'); -end; - -procedure Read_GL_NV_geometry_program4; -begin - glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV'); -end; - -procedure Read_GL_NV_gpu_program4; -begin - glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV'); - glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV'); - glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV'); - glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV'); - glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV'); - glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV'); - glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV'); - glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV'); - glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV'); - glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV'); - glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV'); - glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV'); - glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV'); - glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV'); - glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV'); - glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV'); -end; - -procedure Read_GL_NV_parameter_buffer_object; -begin - glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV'); - glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV'); - glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV'); -end; - -procedure Read_GL_NV_transform_feedback; -begin - glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV'); - glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV'); - glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV'); - glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV'); - glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV'); - glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV'); - glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV'); - glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV'); - glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV'); - glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV'); - glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV'); - glTransformFeedbackStreamAttribsNV := dglGetProcAddress('glTransformFeedbackStreamAttribsNV'); -end; - -procedure Read_GL_NV_conditional_render; -begin - glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV'); - glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV'); -end; - -procedure Read_GL_NV_present_video; -begin - glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV'); - glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV'); - glGetVideoivNV := dglGetProcAddress('glGetVideoivNV'); - glGetVideouivNV := dglGetProcAddress('glGetVideouivNV'); - glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV'); - glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV'); -// glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV'); -end; - -procedure Read_GL_NV_explicit_multisample; -begin - glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV'); - glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV'); - glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV'); -end; - -procedure Read_GL_NV_transform_feedback2; -begin - glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV'); - glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV'); - glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV'); - glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV'); - glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV'); - glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV'); - glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV'); -end; - -procedure Read_GL_NV_video_capture; -begin - glBeginVideoCaptureNV := dglGetProcAddress('glBeginVideoCaptureNV'); - glBindVideoCaptureStreamBufferNV := dglGetProcAddress('glBindVideoCaptureStreamBufferNV'); - glBindVideoCaptureStreamTextureNV := dglGetProcAddress('glBindVideoCaptureStreamTextureNV'); - glEndVideoCaptureNV := dglGetProcAddress('glEndVideoCaptureNV'); - glGetVideoCaptureivNV := dglGetProcAddress('glGetVideoCaptureivNV'); - glGetVideoCaptureStreamivNV := dglGetProcAddress('glGetVideoCaptureStreamivNV'); - glGetVideoCaptureStreamfvNV := dglGetProcAddress('glGetVideoCaptureStreamfvNV'); - glGetVideoCaptureStreamdvNV := dglGetProcAddress('glGetVideoCaptureStreamdvNV'); - glVideoCaptureNV := dglGetProcAddress('glVideoCaptureNV'); - glVideoCaptureStreamParameterivNV := dglGetProcAddress('glVideoCaptureStreamParameterivNV'); - glVideoCaptureStreamParameterfvNV := dglGetProcAddress('glVideoCaptureStreamParameterfvNV'); - glVideoCaptureStreamParameterdvNV := dglGetProcAddress('glVideoCaptureStreamParameterdvNV'); -end; - -procedure Read_GL_NV_copy_image; -begin - glCopyImageSubDataNV := dglGetProcAddress('glCopyImageSubDataNV'); -end; - -procedure Read_GL_NV_shader_buffer_load; -begin - glMakeBufferResidentNV := dglGetProcAddress('glMakeBufferResidentNV'); - glMakeBufferNonResidentNV := dglGetProcAddress('glMakeBufferNonResidentNV'); - glIsBufferResidentNV := dglGetProcAddress('glIsBufferResidentNV'); - glMakeNamedBufferResidentNV := dglGetProcAddress('glMakeNamedBufferResidentNV'); - glMakeNamedBufferNonResidentNV := dglGetProcAddress('glMakeNamedBufferNonResidentNV'); - glIsNamedBufferResidentNV := dglGetProcAddress('glIsNamedBufferResidentNV'); - glGetBufferParameterui64vNV := dglGetProcAddress('glGetBufferParameterui64vNV'); - glGetNamedBufferParameterui64vNV := dglGetProcAddress('glGetNamedBufferParameterui64vNV'); - glGetIntegerui64vNV := dglGetProcAddress('glGetIntegerui64vNV'); - glUniformui64NV := dglGetProcAddress('glUniformui64NV'); - glUniformui64vNV := dglGetProcAddress('glUniformui64vNV'); - glGetUniformui64vNV := dglGetProcAddress('glGetUniformui64vNV'); - glProgramUniformui64NV := dglGetProcAddress('glProgramUniformui64NV'); - glProgramUniformui64vNV := dglGetProcAddress('glProgramUniformui64vNV'); -end; - -procedure Read_GL_NV_vertex_buffer_unified_memory; -begin - glBufferAddressRangeNV := dglGetProcAddress('glBufferAddressRangeNV'); - glVertexFormatNV := dglGetProcAddress('glVertexFormatNV'); - glNormalFormatNV := dglGetProcAddress('glNormalFormatNV'); - glColorFormatNV := dglGetProcAddress('glColorFormatNV'); - glIndexFormatNV := dglGetProcAddress('glIndexFormatNV'); - glTexCoordFormatNV := dglGetProcAddress('glTexCoordFormatNV'); - glEdgeFlagFormatNV := dglGetProcAddress('glEdgeFlagFormatNV'); - glSecondaryColorFormatNV := dglGetProcAddress('glSecondaryColorFormatNV'); - glFogCoordFormatNV := dglGetProcAddress('glFogCoordFormatNV'); - glVertexAttribFormatNV := dglGetProcAddress('glVertexAttribFormatNV'); - glVertexAttribIFormatNV := dglGetProcAddress('glVertexAttribIFormatNV'); - glGetIntegerui64i_vNV := dglGetProcAddress('glGetIntegerui64i_vNV'); -end; - -procedure Read_GL_NV_gpu_program5; -begin - glProgramSubroutineParametersuivNV := dglGetProcAddress('glProgramSubroutineParametersuivNV'); - glGetProgramSubroutineParameteruivNV := dglGetProcAddress('glGetProgramSubroutineParameteruivNV'); -end; - -procedure Read_GL_NV_gpu_shader5; -begin - glUniform1i64NV := dglGetProcAddress('glUniform1i64NV'); - glUniform2i64NV := dglGetProcAddress('glUniform2i64NV'); - glUniform3i64NV := dglGetProcAddress('glUniform3i64NV'); - glUniform4i64NV := dglGetProcAddress('glUniform4i64NV'); - glUniform1i64vNV := dglGetProcAddress('glUniform1i64vNV'); - glUniform2i64vNV := dglGetProcAddress('glUniform2i64vNV'); - glUniform3i64vNV := dglGetProcAddress('glUniform3i64vNV'); - glUniform4i64vNV := dglGetProcAddress('glUniform4i64vNV'); - glUniform1ui64NV := dglGetProcAddress('glUniform1ui64NV'); - glUniform2ui64NV := dglGetProcAddress('glUniform2ui64NV'); - glUniform3ui64NV := dglGetProcAddress('glUniform3ui64NV'); - glUniform4ui64NV := dglGetProcAddress('glUniform4ui64NV'); - glUniform1ui64vNV := dglGetProcAddress('glUniform1ui64vNV'); - glUniform2ui64vNV := dglGetProcAddress('glUniform2ui64vNV'); - glUniform3ui64vNV := dglGetProcAddress('glUniform3ui64vNV'); - glUniform4ui64vNV := dglGetProcAddress('glUniform4ui64vNV'); - glGetUniformi64vNV := dglGetProcAddress('glGetUniformi64vNV'); - glProgramUniform1i64NV := dglGetProcAddress('glProgramUniform1i64NV'); - glProgramUniform2i64NV := dglGetProcAddress('glProgramUniform2i64NV'); - glProgramUniform3i64NV := dglGetProcAddress('glProgramUniform3i64NV'); - glProgramUniform4i64NV := dglGetProcAddress('glProgramUniform4i64NV'); - glProgramUniform1i64vNV := dglGetProcAddress('glProgramUniform1i64vNV'); - glProgramUniform2i64vNV := dglGetProcAddress('glProgramUniform2i64vNV'); - glProgramUniform3i64vNV := dglGetProcAddress('glProgramUniform3i64vNV'); - glProgramUniform4i64vNV := dglGetProcAddress('glProgramUniform4i64vNV'); - glProgramUniform1ui64NV := dglGetProcAddress('glProgramUniform1ui64NV'); - glProgramUniform2ui64NV := dglGetProcAddress('glProgramUniform2ui64NV'); - glProgramUniform3ui64NV := dglGetProcAddress('glProgramUniform3ui64NV'); - glProgramUniform4ui64NV := dglGetProcAddress('glProgramUniform4ui64NV'); - glProgramUniform1ui64vNV := dglGetProcAddress('glProgramUniform1ui64vNV'); - glProgramUniform2ui64vNV := dglGetProcAddress('glProgramUniform2ui64vNV'); - glProgramUniform3ui64vNV := dglGetProcAddress('glProgramUniform3ui64vNV'); - glProgramUniform4ui64vNV := dglGetProcAddress('glProgramUniform4ui64vNV'); -end; - -procedure Read_GL_NV_vertex_attrib_integer_64bit; -begin - glVertexAttribL1i64NV := dglGetProcAddress('glVertexAttribL1i64NV'); - glVertexAttribL2i64NV := dglGetProcAddress('glVertexAttribL2i64NV'); - glVertexAttribL3i64NV := dglGetProcAddress('glVertexAttribL3i64NV'); - glVertexAttribL4i64NV := dglGetProcAddress('glVertexAttribL4i64NV'); - glVertexAttribL1i64vNV := dglGetProcAddress('glVertexAttribL1i64vNV'); - glVertexAttribL2i64vNV := dglGetProcAddress('glVertexAttribL2i64vNV'); - glVertexAttribL3i64vNV := dglGetProcAddress('glVertexAttribL3i64vNV'); - glVertexAttribL4i64vNV := dglGetProcAddress('glVertexAttribL4i64vNV'); - glVertexAttribL1ui64NV := dglGetProcAddress('glVertexAttribL1ui64NV'); - glVertexAttribL2ui64NV := dglGetProcAddress('glVertexAttribL2ui64NV'); - glVertexAttribL3ui64NV := dglGetProcAddress('glVertexAttribL3ui64NV'); - glVertexAttribL4ui64NV := dglGetProcAddress('glVertexAttribL4ui64NV'); - glVertexAttribL1ui64vNV := dglGetProcAddress('glVertexAttribL1ui64vNV'); - glVertexAttribL2ui64vNV := dglGetProcAddress('glVertexAttribL2ui64vNV'); - glVertexAttribL3ui64vNV := dglGetProcAddress('glVertexAttribL3ui64vNV'); - glVertexAttribL4ui64vNV := dglGetProcAddress('glVertexAttribL4ui64vNV'); - glGetVertexAttribLi64vNV := dglGetProcAddress('glGetVertexAttribLi64vNV'); - glGetVertexAttribLui64vNV := dglGetProcAddress('glGetVertexAttribLui64vNV'); - glVertexAttribLFormatNV := dglGetProcAddress('glVertexAttribLFormatNV'); -end; - -procedure Read_GL_NV_vdpau_interop; -begin - glVDPAUInitNV := dglGetProcAddress('glVDPAUInitNV'); - glVDPAUFiniNV := dglGetProcAddress('glVDPAUFiniNV'); - glVDPAURegisterVideoSurfaceNV := dglGetProcAddress('glVDPAURegisterVideoSurfaceNV'); - glVDPAURegisterOutputSurfaceNV := dglGetProcAddress('glVDPAURegisterOutputSurfaceNV'); - glVDPAUIsSurfaceNV := dglGetProcAddress('glVDPAUIsSurfaceNV'); - glVDPAUUnregisterSurfaceNV := dglGetProcAddress('glVDPAUUnregisterSurfaceNV'); - glVDPAUGetSurfaceivNV := dglGetProcAddress('glVDPAUGetSurfaceivNV'); - glVDPAUSurfaceAccessNV := dglGetProcAddress('glVDPAUSurfaceAccessNV'); - glVDPAUMapSurfacesNV := dglGetProcAddress('glVDPAUMapSurfacesNV'); - glVDPAUUnmapSurfacesNV := dglGetProcAddress('glVDPAUUnmapSurfacesNV'); -end; - -procedure Read_GL_NV_texture_barrier; -begin - glTextureBarrierNV := dglGetProcAddress('glTextureBarrierNV'); -end; - -procedure Read_GL_PGI_misc_hints; -begin - glHintPGI := dglGetProcAddress('glHintPGI'); -end; - -procedure Read_GL_SGIS_detail_texture; -begin - glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS'); - glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS'); -end; - -procedure Read_GL_SGIS_fog_function; -begin - glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS'); - glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS'); -end; - -procedure Read_GL_SGIS_multisample; -begin - glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS'); - glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS'); -end; - -procedure Read_GL_SGIS_pixel_texture; -begin - glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS'); - glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS'); - glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS'); - glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS'); - glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS'); - glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS'); -end; - -procedure Read_GL_SGIS_point_parameters; -begin - glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS'); - glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS'); -end; - -procedure Read_GL_SGIS_sharpen_texture; -begin - glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS'); - glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS'); -end; - -procedure Read_GL_SGIS_texture4D; -begin - glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS'); - glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS'); -end; - -procedure Read_GL_SGIS_texture_color_mask; -begin - glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS'); -end; - -procedure Read_GL_SGIS_texture_filter4; -begin - glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS'); - glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS'); -end; - -procedure Read_GL_SGIX_async; -begin - glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX'); - glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX'); - glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX'); - glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX'); - glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX'); - glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX'); -end; - -procedure Read_GL_SGIX_flush_raster; -begin - glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX'); -end; - -procedure Read_GL_SGIX_fragment_lighting; -begin - glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX'); - glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX'); - glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX'); - glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX'); - glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX'); - glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX'); - glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX'); - glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX'); - glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX'); - glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX'); - glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX'); - glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX'); - glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX'); - glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX'); - glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX'); - glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX'); - glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX'); - glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX'); -end; - -procedure Read_GL_SGIX_framezoom; -begin - glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX'); -end; - -procedure Read_GL_SGIX_igloo_interface; -begin - glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX'); -end; - -procedure Read_GL_SGIX_instruments; -begin - glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX'); - glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX'); - glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX'); - glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX'); - glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX'); - glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX'); -end; - -procedure Read_GL_SGIX_list_priority; -begin - glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX'); - glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX'); - glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX'); - glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX'); - glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX'); - glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX'); -end; - -procedure Read_GL_SGIX_pixel_texture; -begin - glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX'); -end; - -procedure Read_GL_SGIX_polynomial_ffd; -begin - glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX'); - glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX'); - glDeformSGIX := dglGetProcAddress('glDeformSGIX'); - glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX'); -end; - -procedure Read_GL_SGIX_reference_plane; -begin - glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX'); -end; - -procedure Read_GL_SGIX_sprite; -begin - glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX'); - glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX'); - glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX'); - glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX'); -end; - -procedure Read_GL_SGIX_tag_sample_buffer; -begin - glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX'); -end; - -procedure Read_GL_SGI_color_table; -begin - glColorTableSGI := dglGetProcAddress('glColorTableSGI'); - glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI'); - glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI'); - glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI'); - glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI'); - glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI'); - glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI'); -end; - -procedure Read_GL_SUNX_constant_data; -begin - glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX'); -end; - -procedure Read_GL_SUN_global_alpha; -begin - glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN'); - glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN'); - glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN'); - glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN'); - glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN'); - glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN'); - glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN'); - glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN'); -end; - -procedure Read_GL_SUN_mesh_array; -begin - glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN'); -end; - -procedure Read_GL_SUN_triangle_list; -begin - glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN'); - glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN'); - glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN'); - glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN'); - glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN'); - glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN'); - glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN'); -end; - -procedure Read_GL_SUN_vertex; -begin - glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN'); - glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN'); - glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN'); - glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN'); - glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN'); - glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN'); - glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN'); - glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN'); - glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN'); - glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN'); - glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN'); - glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN'); - glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN'); - glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN'); - glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN'); - glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN'); - glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN'); - glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN'); - glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN'); - glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN'); - glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN'); - glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN'); - glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN'); - glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN'); - glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN'); - glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN'); - glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN'); - glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN'); - glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN'); - glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN'); - glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN'); - glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN'); - glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN'); - glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN'); - glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN'); - glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN'); - glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN'); - glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN'); - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN'); - glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN'); -end; - -{$IFDEF DGL_WIN} -procedure Read_WGL_ARB_buffer_region; -begin - wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB'); - wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB'); - wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB'); - wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB'); -end; - -procedure Read_WGL_ARB_extensions_string; -begin - wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB'); -end; - -procedure Read_WGL_ARB_make_current_read; -begin - wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB'); - wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB'); -end; - -procedure Read_WGL_ARB_pbuffer; -begin - wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB'); - wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB'); - wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB'); - wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB'); - wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB'); -end; - -procedure Read_WGL_ARB_pixel_format; -begin - wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB'); - wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB'); - wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB'); -end; - -procedure Read_WGL_ARB_pixel_format_float; -begin - wglClampColorARB := dglGetProcAddress('wglClampColorARB'); -end; - -procedure Read_WGL_ARB_render_texture; -begin - wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB'); - wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB'); - wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB'); -end; - -procedure Read_WGL_ARB_create_context; -begin - wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB'); -end; - -procedure Read_WGL_AMD_gpu_association; -begin - wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD'); - wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD'); - wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD'); - wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD'); - wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD'); - wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD'); - wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD'); - wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD'); - wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD'); -end; - -procedure Read_WGL_EXT_display_color_table; -begin - wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT'); - wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT'); - wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT'); - wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT'); -end; - -procedure Read_WGL_EXT_extensions_string; -begin - wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT'); -end; - -procedure Read_WGL_EXT_make_current_read; -begin - wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT'); - wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT'); -end; - -procedure Read_WGL_EXT_pbuffer; -begin - wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT'); - wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT'); - wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT'); - wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT'); - wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT'); -end; - -procedure Read_WGL_EXT_pixel_format; -begin - wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT'); - wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT'); - wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT'); -end; - -procedure Read_WGL_EXT_swap_control; -begin - wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT'); - wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT'); -end; - -procedure Read_WGL_I3D_digital_video_control; -begin - wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D'); - wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D'); -end; - -procedure Read_WGL_I3D_gamma; -begin - wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D'); - wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D'); - wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D'); - wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D'); -end; - -procedure Read_WGL_I3D_genlock; -begin - wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D'); - wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D'); - wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D'); - wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D'); - wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D'); - wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D'); - wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D'); - wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D'); - wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D'); - wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D'); - wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D'); - wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D'); -end; - -procedure Read_WGL_I3D_image_buffer; -begin - wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D'); - wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D'); - wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D'); - wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D'); -end; - -procedure Read_WGL_I3D_swap_frame_lock; -begin - wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D'); - wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D'); - wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D'); - wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D'); -end; - -procedure Read_WGL_I3D_swap_frame_usage; -begin - wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D'); - wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D'); - wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D'); - wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D'); -end; - -procedure Read_WGL_NV_vertex_array_range; -begin - wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV'); - wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV'); -end; - -procedure Read_WGL_NV_present_video; -begin - wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV'); - wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV'); - wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV'); -end; - -procedure Read_WGL_NV_video_output; -begin - wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV'); - wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV'); - wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV'); - wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV'); - wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV'); - wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV'); -end; - -procedure Read_WGL_NV_swap_group; -begin - wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV'); - wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV'); - wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV'); - wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV'); - wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV'); - wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV'); -end; - -procedure Read_WGL_NV_gpu_affinity; -begin - wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV'); - wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV'); - wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV'); - wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV'); - wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV'); -end; - -procedure Read_WGL_NV_video_capture; -begin - wglBindVideoCaptureDeviceNV := dglGetProcAddress('wglBindVideoCaptureDeviceNV'); - wglEnumerateVideoCaptureDevicesNV := dglGetProcAddress('wglEnumerateVideoCaptureDevicesNV'); - wglLockVideoCaptureDeviceNV := dglGetProcAddress('wglLockVideoCaptureDeviceNV'); - wglQueryVideoCaptureDeviceNV := dglGetProcAddress('wglQueryVideoCaptureDeviceNV'); - wglReleaseVideoCaptureDeviceNV := dglGetProcAddress('wglReleaseVideoCaptureDeviceNV'); -end; - -procedure Read_WGL_NV_copy_image; -begin - wglCopyImageSubDataNV := dglGetProcAddress('wglCopyImageSubDataNV'); -end; - -procedure Read_WGL_NV_DX_interop; -begin - wglDXSetResourceShareHandleNV := dglGetProcAddress('wglDXSetResourceShareHandleNV'); - wglDXOpenDeviceNV := dglGetProcAddress('wglDXOpenDeviceNV'); - wglDXCloseDeviceNV := dglGetProcAddress('wglDXCloseDeviceNV'); - wglDXRegisterObjectNV := dglGetProcAddress('wglDXRegisterObjectNV'); - wglDXUnregisterObjectNV := dglGetProcAddress('wglDXUnregisterObjectNV'); - wglDXObjectAccessNV := dglGetProcAddress('wglDXObjectAccessNV'); - wglDXLockObjectsNV := dglGetProcAddress('wglDXLockObjectsNV'); - wglDXUnlockObjectsNV := dglGetProcAddress('wglDXUnlockObjectsNV'); -end; - - -procedure Read_WGL_OML_sync_control; -begin - wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML'); - wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML'); - wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML'); - wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML'); - wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML'); - wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML'); -end; - -procedure Read_WGL_3DL_stereo_control; -begin - wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL'); -end; - -procedure Read_WIN_draw_range_elements; -begin - glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN'); -end; - -procedure Read_WIN_swap_hint; -begin - glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN'); -end; -{$ENDIF} - - -procedure ReadExtensions; -begin - ReadOpenGLCore; - - Read_GL_3DFX_tbuffer; - Read_GL_APPLE_element_array; - Read_GL_APPLE_fence; - Read_GL_APPLE_vertex_array_object; - Read_GL_APPLE_vertex_array_range; - Read_GL_APPLE_texture_range; - Read_GL_APPLE_vertex_program_evaluators; - Read_GL_APPLE_object_purgeable; - Read_GL_ARB_matrix_palette; - Read_GL_ARB_multitexture; - Read_GL_ARB_point_parameters; - Read_GL_ARB_texture_compression; - Read_GL_ARB_transpose_matrix; - Read_GL_ARB_vertex_blend; - Read_GL_ARB_vertex_buffer_object; - Read_GL_ARB_vertex_program; - Read_GL_ARB_window_pos; - Read_GL_ARB_color_buffer_float; - Read_GL_ARB_Shader_Objects; - Read_GL_ARB_occlusion_query; - Read_GL_ARB_draw_instanced; - Read_GL_ARB_framebuffer_object; - Read_GL_ARB_geometry_shader4; - Read_GL_ARB_instanced_arrays; - Read_GL_ARB_map_buffer_range; - Read_GL_ARB_texture_buffer_object; - Read_GL_ARB_vertex_array_object; - Read_GL_ARB_uniform_buffer_object; - Read_GL_ARB_copy_buffer; - Read_GL_ARB_draw_elements_base_vertex; - Read_GL_ARB_provoking_vertex; - Read_GL_ARB_sync; - Read_GL_ARB_texture_multisample; - Read_GL_ARB_draw_buffers_blend; - Read_GL_ARB_sample_shading; - Read_GL_ARB_shading_language_include; - Read_GL_ARB_blend_func_extended; - Read_GL_ARB_sampler_objects; - Read_GL_ARB_timer_query; - Read_GL_ARB_vertex_type_2_10_10_10_rev; - Read_GL_ARB_draw_indirect; - Read_GL_ARB_gpu_shader_fp64; - Read_GL_ARB_shader_subroutine; - Read_GL_ARB_tessellation_shader; - Read_GL_ARB_transform_feedback2; - Read_GL_ARB_transform_feedback3; - Read_GL_ARB_ES2_compatibility; - Read_GL_ARB_get_program_binary; - Read_GL_ARB_separate_shader_objects; - Read_GL_ARB_vertex_attrib_64bit; - Read_GL_ARB_viewport_array; - Read_GL_ARB_cl_event; - Read_GL_ARB_debug_output; - Read_GL_ARB_robustness; - // - Read_GL_ATI_draw_buffers; - Read_GL_ATI_element_array; - Read_GL_ATI_envmap_bumpmap; - Read_GL_ATI_fragment_shader; - Read_GL_ATI_map_object_buffer; - Read_GL_ATI_pn_triangles; - Read_GL_ATI_separate_stencil; - Read_GL_ATI_vertex_array_object; - Read_GL_ATI_vertex_attrib_array_object; - Read_GL_ATI_vertex_streams; - Read_GL_AMD_performance_monitor; - Read_GL_AMD_vertex_shader_tesselator; - Read_GL_AMD_draw_buffers_blend; - Read_GL_AMD_name_gen_delete; - Read_GL_AMD_debug_output; - Read_GL_AMD_stencil_operation_extended; - Read_GL_EXT_blend_color; - Read_GL_EXT_blend_func_separate; - Read_GL_EXT_blend_minmax; - Read_GL_EXT_color_subtable; - Read_GL_EXT_compiled_vertex_array; - Read_GL_EXT_convolution; - Read_GL_EXT_coordinate_frame; - Read_GL_EXT_copy_texture; - Read_GL_EXT_cull_vertex; - Read_GL_EXT_draw_range_elements; - Read_GL_EXT_fog_coord; - Read_GL_EXT_framebuffer_object; - Read_GL_EXT_histogram; - Read_GL_EXT_index_func; - Read_GL_EXT_index_material; - Read_GL_EXT_multi_draw_arrays; - Read_GL_EXT_multisample; - Read_GL_EXT_paletted_texture; - Read_GL_EXT_pixel_transform; - Read_GL_EXT_point_parameters; - Read_GL_EXT_polygon_offset; - Read_GL_EXT_secondary_color; - Read_GL_EXT_stencil_two_side; - Read_GL_EXT_subtexture; - Read_GL_EXT_texture3D; - Read_GL_EXT_texture_object; - Read_GL_EXT_texture_perturb_normal; - Read_GL_EXT_vertex_array; - Read_GL_EXT_vertex_shader; - Read_GL_EXT_vertex_weighting; - Read_GL_EXT_depth_bounds_test; - Read_GL_EXT_blend_equation_separate; - Read_GL_EXT_stencil_clear_tag; - Read_GL_EXT_framebuffer_blit; - Read_GL_EXT_framebuffer_multisample; - Read_GL_EXT_timer_query; - Read_GL_EXT_gpu_program_parameters; - Read_GL_EXT_bindable_uniform; - Read_GL_EXT_draw_buffers2; - Read_GL_EXT_draw_instanced; - Read_GL_EXT_geometry_shader4; - Read_GL_EXT_gpu_shader4; - Read_GL_EXT_texture_array; - Read_GL_EXT_texture_buffer_object; - Read_GL_EXT_texture_integer; - Read_GL_EXT_transform_feedback; - Read_GL_EXT_direct_state_access; - Read_GL_EXT_separate_shader_objects; - Read_GL_EXT_shader_image_load_store; - Read_GL_EXT_vertex_attrib_64bit; - Read_GL_HP_image_transform; - Read_GL_IBM_multimode_draw_arrays; - Read_GL_IBM_vertex_array_lists; - Read_GL_INGR_blend_func_separate; - Read_GL_INTEL_parallel_arrays; - Read_GL_MESA_resize_buffers; - Read_GL_MESA_window_pos; - Read_GL_NV_evaluators; - Read_GL_NV_fence; - Read_GL_NV_fragment_program; - Read_GL_NV_half_float; - Read_GL_NV_occlusion_query; - Read_GL_NV_pixel_data_range; - Read_GL_NV_point_sprite; - Read_GL_NV_primitive_restart; - Read_GL_NV_register_combiners; - Read_GL_NV_register_combiners2; - Read_GL_NV_vertex_array_range; - Read_GL_NV_vertex_program; - Read_GL_NV_depth_buffer_float; - Read_GL_NV_framebuffer_multisample_coverage; - Read_GL_NV_geometry_program4; - Read_GL_NV_gpu_program4; - Read_GL_NV_parameter_buffer_object; - Read_GL_NV_transform_feedback; - Read_GL_NV_conditional_render; - Read_GL_NV_present_video; - Read_GL_NV_explicit_multisample; - Read_GL_NV_transform_feedback2; - Read_GL_NV_video_capture; - Read_GL_NV_copy_image; - Read_GL_NV_shader_buffer_load; - Read_GL_NV_vertex_buffer_unified_memory; - Read_GL_NV_gpu_program5; - Read_GL_NV_gpu_shader5; - Read_GL_NV_vertex_attrib_integer_64bit; - Read_GL_NV_vdpau_interop; - Read_GL_NV_texture_barrier; - Read_GL_NV_path_rendering; - Read_GL_NV_bindless_texture; - Read_GL_PGI_misc_hints; - Read_GL_SGIS_detail_texture; - Read_GL_SGIS_fog_function; - Read_GL_SGIS_multisample; - Read_GL_SGIS_pixel_texture; - Read_GL_SGIS_point_parameters; - Read_GL_SGIS_sharpen_texture; - Read_GL_SGIS_texture4D; - Read_GL_SGIS_texture_color_mask; - Read_GL_SGIS_texture_filter4; - Read_GL_SGIX_async; - Read_GL_SGIX_flush_raster; - Read_GL_SGIX_fragment_lighting; - Read_GL_SGIX_framezoom; - Read_GL_SGIX_igloo_interface; - Read_GL_SGIX_instruments; - Read_GL_SGIX_list_priority; - Read_GL_SGIX_pixel_texture; - Read_GL_SGIX_polynomial_ffd; - Read_GL_SGIX_reference_plane; - Read_GL_SGIX_sprite; - Read_GL_SGIX_tag_sample_buffer; - Read_GL_SGI_color_table; - Read_GL_SUNX_constant_data; - Read_GL_SUN_global_alpha; - Read_GL_SUN_mesh_array; - Read_GL_SUN_triangle_list; - Read_GL_SUN_vertex; - -{$IFDEF DGL_WIN} - Read_WGL_ARB_buffer_region; - Read_WGL_ARB_extensions_string; - Read_WGL_ARB_make_current_read; - Read_WGL_ARB_pbuffer; - Read_WGL_ARB_pixel_format; - Read_WGL_ARB_pixel_format_float; - Read_WGL_ARB_render_texture; - Read_WGL_ARB_create_context; - Read_WGL_AMD_gpu_association; - Read_WGL_EXT_display_color_table; - Read_WGL_EXT_extensions_string; - Read_WGL_EXT_make_current_read; - Read_WGL_EXT_pbuffer; - Read_WGL_EXT_pixel_format; - Read_WGL_EXT_swap_control; - Read_WGL_I3D_digital_video_control; - Read_WGL_I3D_gamma; - Read_WGL_I3D_genlock; - Read_WGL_I3D_image_buffer; - Read_WGL_I3D_swap_frame_lock; - Read_WGL_I3D_swap_frame_usage; - Read_WGL_NV_vertex_array_range; - Read_WGL_NV_present_video; - Read_WGL_NV_video_output; - Read_WGL_NV_swap_group; - Read_WGL_NV_gpu_affinity; - Read_WGL_NV_video_capture; - Read_WGL_NV_copy_image; - Read_WGL_NV_DX_interop; - Read_WGL_OML_sync_control; - Read_WGL_3DL_stereo_control; - - Read_WIN_draw_range_elements; - Read_WIN_swap_hint; -{$ENDIF} - - ExtensionsRead := True; -end; - -// ============================================================================= -// ReadCoreVersion -// ============================================================================= - -procedure ReadCoreVersion; -var - AnsiBuffer: AnsiString; - Buffer: String; - MajorVersion, MinorVersion: Integer; - - procedure TrimAndSplitVersionString(Buffer: String; out Max, Min: Integer); - // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text" - // at least however "Major.Minor". - var - Separator: Integer; - begin - try - // There must be at least one dot to separate major and minor version number. - Separator := Pos('.', Buffer); - // At least one number must be before and one after the dot. - if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and - (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then - begin - // OK, it's a valid version string. Now remove unnecessary parts. - Dec(Separator); - // Find last non-numeric character before version number. - while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do - Dec(Separator); - // Delete leading characters which do not belong to the version string. - Delete(Buffer, 1, Separator); - Separator := Pos('.', Buffer) + 1; - // Find first non-numeric character after version number - while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do - Inc(Separator); - // delete trailing characters not belonging to the version string - Delete(Buffer, Separator, 255); - // Now translate the numbers. - Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed. - Max := StrToInt(Copy(Buffer, 1, Separator - 1)); - Min := StrToInt(Copy(Buffer, Separator + 1, 1)); - end - else - Abort; - except - Min := 0; - Max := 0; - end; - end; - - -begin - // determine version of implementation - // GL - if not Assigned(@glGetString) then - glGetString := dglGetProcAddress('glGetString'); - - AnsiBuffer := glGetString(GL_VERSION); - Buffer := String(AnsiBuffer); - - TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion); - - GL_VERSION_1_0 := True; - GL_VERSION_1_1 := False; - GL_VERSION_1_2 := False; - GL_VERSION_1_3 := False; - GL_VERSION_1_4 := False; - GL_VERSION_1_5 := False; - GL_VERSION_2_0 := False; - GL_VERSION_2_1 := False; - GL_VERSION_3_0 := False; - GL_VERSION_3_1 := False; - GL_VERSION_3_2 := False; - GL_VERSION_3_3 := False; - GL_VERSION_4_0 := False; - GL_VERSION_4_1 := False; - GL_VERSION_4_2 := False; - GL_VERSION_4_3 := False; - GL_VERSION_4_4 := False; - - if MajorVersion = 1 then - begin - if MinorVersion >= 1 then - GL_VERSION_1_1 := True; - if MinorVersion >= 2 then - GL_VERSION_1_2 := True; - if MinorVersion >= 3 then - GL_VERSION_1_3 := True; - if MinorVersion >= 4 then - GL_VERSION_1_4 := True; - if MinorVersion >= 5 then - GL_VERSION_1_5 := True; - end; - - if MajorVersion >= 2 then - begin - GL_VERSION_1_1 := True; - GL_VERSION_1_2 := True; - GL_VERSION_1_3 := True; - GL_VERSION_1_4 := True; - GL_VERSION_1_5 := True; - GL_VERSION_2_0 := True; - - if MinorVersion >= 1 then - GL_VERSION_2_1 := True; - end; - - if MajorVersion >= 3 then - begin - GL_VERSION_2_1 := True; - GL_VERSION_3_0 := True; - - if MinorVersion >= 1 then - GL_VERSION_3_1 := True; - if MinorVersion >= 2 then - GL_VERSION_3_2 := True; - if MinorVersion >= 3 then - GL_VERSION_3_3 := True; - end; - - if MajorVersion >= 4 then - begin - GL_VERSION_3_1 := True; - GL_VERSION_3_2 := True; - GL_VERSION_3_3 := True; - GL_VERSION_4_0 := True; - - if MinorVersion >= 1 then - GL_VERSION_4_1 := True; - if MinorVersion >= 2 then - GL_VERSION_4_2 := True; - if MinorVersion >= 3 then - GL_VERSION_4_3 := True; - if MinorVersion >= 4 then - GL_VERSION_4_4 := True; - end; - - // GLU - GLU_VERSION_1_1 := False; - GLU_VERSION_1_2 := False; - GLU_VERSION_1_3 := False; - - if Assigned(gluGetString) then begin - AnsiBuffer := gluGetString(GLU_VERSION); - Buffer := String(AnsiBuffer); - - TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion); - - GLU_VERSION_1_1 := True; - - if MinorVersion >= 2 then - GLU_VERSION_1_2 := True; - - if MinorVersion >= 3 then - GLU_VERSION_1_3 := True; - end; -end; - - -// ============================================================================= -// ReadImplementationProperties -// ============================================================================= - -procedure ReadImplementationProperties; -var - Buffer: Ansistring; -begin - ReadCoreVersion; - - // Check all extensions - Buffer := Int_GetExtensionString; - - // === 3DFX ==================================================================== - GL_3DFX_multisample := Int_CheckExtension(Buffer, 'GL_3DFX_multisample'); - GL_3DFX_tbuffer := Int_CheckExtension(Buffer, 'GL_3DFX_tbuffer'); - GL_3DFX_texture_compression_FXT1 := Int_CheckExtension(Buffer, 'GL_3DFX_texture_compression_FXT1'); - - // === APPLE =================================================================== - GL_APPLE_client_storage := Int_CheckExtension(Buffer, 'GL_APPLE_client_storage'); - GL_APPLE_element_array := Int_CheckExtension(Buffer, 'GL_APPLE_element_array'); - GL_APPLE_fence := Int_CheckExtension(Buffer, 'GL_APPLE_fence'); - GL_APPLE_specular_vector := Int_CheckExtension(Buffer, 'GL_APPLE_specular_vector'); - GL_APPLE_transform_hint := Int_CheckExtension(Buffer, 'GL_APPLE_transform_hint'); - GL_APPLE_vertex_array_object := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_object'); - GL_APPLE_vertex_array_range := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_range'); - GL_APPLE_ycbcr_422 := Int_CheckExtension(Buffer, 'GL_APPLE_ycbcr_422'); - GL_APPLE_texture_range := Int_CheckExtension(Buffer, 'GL_APPLE_texture_range'); - GL_APPLE_float_pixels := Int_CheckExtension(Buffer, 'GL_APPLE_float_pixels'); - GL_APPLE_vertex_program_evaluators := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_program_evaluators'); - GL_APPLE_aux_depth_stencil := Int_CheckExtension(Buffer, 'GL_APPLE_aux_depth_stencil'); - GL_APPLE_object_purgeable := Int_CheckExtension(Buffer, 'GL_APPLE_object_purgeable'); - GL_APPLE_row_bytes := Int_CheckExtension(Buffer, 'GL_APPLE_row_bytes'); - GL_APPLE_rgb_422 := Int_CheckExtension(Buffer, 'GL_APPLE_rgb_422'); - - // === ARB ===================================================================== - GL_ARB_depth_texture := Int_CheckExtension(Buffer, 'GL_ARB_depth_texture'); - GL_ARB_fragment_program := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program'); - GL_ARB_imaging := Int_CheckExtension(Buffer, 'GL_ARB_imaging'); - GL_ARB_matrix_palette := Int_CheckExtension(Buffer, 'GL_ARB_matrix_palette'); - GL_ARB_multisample := Int_CheckExtension(Buffer, 'GL_ARB_multisample'); - GL_ARB_multitexture := Int_CheckExtension(Buffer, 'GL_ARB_multitexture'); - GL_ARB_point_parameters := Int_CheckExtension(Buffer, 'GL_ARB_point_parameters'); - GL_ARB_shadow := Int_CheckExtension(Buffer, 'GL_ARB_shadow'); - GL_ARB_shadow_ambient := Int_CheckExtension(Buffer, 'GL_ARB_shadow_ambient'); - GL_ARB_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp'); - GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression'); - GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map'); - GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add'); - GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine'); - GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar'); - GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3'); - GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat'); - GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix'); - GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend'); - GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object'); - GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program'); - GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos'); - GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects'); - GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader'); - GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader'); - GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query'); - GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100'); - GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite'); - GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two'); - GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow'); - GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers'); - GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle'); - GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float'); - GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel'); - GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float'); - GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object'); - GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float'); - GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced'); - GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object'); - GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB'); - GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4'); - GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex'); - GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays'); - GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range'); - GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object'); - GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc'); - GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg'); - GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object'); - GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object'); - GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility'); - GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer'); - GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod'); - GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp'); - GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex'); - GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions'); - GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex'); - GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map'); - GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync'); - GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample'); - GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra'); - GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend'); - GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading'); - GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array'); - GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather'); - GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod'); - GL_ARB_shading_language_include := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_include'); - GL_ARB_texture_compression_bptc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_bptc'); - GL_ARB_blend_func_extended := Int_CheckExtension(Buffer, 'GL_ARB_blend_func_extended'); - GL_ARB_explicit_attrib_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_attrib_location'); - GL_ARB_occlusion_query2 := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query2'); - GL_ARB_sampler_objects := Int_CheckExtension(Buffer, 'GL_ARB_sampler_objects'); - GL_ARB_shader_bit_encoding := Int_CheckExtension(Buffer, 'GL_ARB_shader_bit_encoding'); - GL_ARB_texture_rgb10_a2ui := Int_CheckExtension(Buffer, 'GL_ARB_texture_rgb10_a2ui'); - GL_ARB_texture_swizzle := Int_CheckExtension(Buffer, 'GL_ARB_texture_swizzle'); - GL_ARB_timer_query := Int_CheckExtension(Buffer, 'GL_ARB_timer_query'); - GL_ARB_vertex_type_2_10_10_10_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_2_10_10_10_rev'); - GL_ARB_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_draw_indirect'); - GL_ARB_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader5'); - GL_ARB_gpu_shader_fp64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_fp64'); - GL_ARB_shader_subroutine := Int_CheckExtension(Buffer, 'GL_ARB_shader_subroutine'); - GL_ARB_tessellation_shader := Int_CheckExtension(Buffer, 'GL_ARB_tessellation_shader'); - GL_ARB_texture_buffer_object_rgb32 := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object_rgb32'); - GL_ARB_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback2'); - GL_ARB_transform_feedback3 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback3'); - GL_ARB_ES2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES2_compatibility'); - GL_ARB_get_program_binary := Int_CheckExtension(Buffer, 'GL_ARB_get_program_binary'); - GL_ARB_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_separate_shader_objects'); - GL_ARB_shader_precision := Int_CheckExtension(Buffer, 'GL_ARB_shader_precision'); - GL_ARB_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_64bit'); - GL_ARB_viewport_array := Int_CheckExtension(Buffer, 'GL_ARB_viewport_array'); - - // GL 4.2 - GL_ARB_base_instance := Int_CheckExtension(Buffer, 'GL_ARB_base_instance'); - GL_ARB_shading_language_420pack := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_420pack'); - GL_ARB_transform_feedback_instanced := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback_instanced'); - GL_ARB_compressed_texture_pixel_storage := Int_CheckExtension(Buffer, 'GL_ARB_compressed_texture_pixel_storage'); - GL_ARB_conservative_depth := Int_CheckExtension(Buffer, 'GL_ARB_conservative_depth'); - GL_ARB_internalformat_query := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query'); - GL_ARB_map_buffer_alignment := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_alignment'); - GL_ARB_shader_atomic_counters := Int_CheckExtension(Buffer, 'GL_ARB_shader_atomic_counters'); - GL_ARB_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_load_store'); - GL_ARB_shading_language_packing := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_packing'); - GL_ARB_texture_storage := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage'); - // END GL 4.2 - - // GL 4.3 - GL_ARB_arrays_of_arrays := Int_CheckExtension(Buffer, 'GL_ARB_arrays_of_arrays'); - GL_ARB_fragment_layer_viewport := Int_CheckExtension(Buffer, 'GL_ARB_fragment_layer_viewport'); - GL_ARB_shader_image_size := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_size'); - GL_ARB_ES3_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_compatibility'); - GL_ARB_clear_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_clear_buffer_object'); - GL_ARB_compute_shader := Int_CheckExtension(Buffer, 'GL_ARB_compute_shader'); - GL_ARB_copy_image := Int_CheckExtension(Buffer, 'GL_ARB_copy_image'); - GL_KHR_debug := Int_CheckExtension(Buffer, 'GL_KHR_debug'); - GL_ARB_explicit_uniform_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_uniform_location'); - GL_ARB_framebuffer_no_attachments := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_no_attachments'); - GL_ARB_internalformat_query2 := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query2'); - GL_ARB_invalidate_subdata := Int_CheckExtension(Buffer, 'GL_ARB_invalidate_subdata'); - GL_ARB_multi_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_multi_draw_indirect'); - GL_ARB_program_interface_query := Int_CheckExtension(Buffer, 'GL_ARB_program_interface_query'); - GL_ARB_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_ARB_robust_buffer_access_behavior'); - GL_ARB_shader_storage_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_shader_storage_buffer_object'); - GL_ARB_stencil_texturing := Int_CheckExtension(Buffer, 'GL_ARB_stencil_texturing'); - GL_ARB_texture_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_range'); - GL_ARB_texture_query_levels := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_levels'); - GL_ARB_texture_storage_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage_multisample'); - GL_ARB_texture_view := Int_CheckExtension(Buffer, 'GL_ARB_texture_view'); - GL_ARB_vertex_attrib_binding := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_binding'); - GL_ARB_cl_event := Int_CheckExtension(Buffer, 'GL_ARB_cl_event'); - GL_ARB_debug_output := Int_CheckExtension(Buffer, 'GL_ARB_debug_output'); - GL_ARB_robustness := Int_CheckExtension(Buffer, 'GL_ARB_robustness'); - GL_ARB_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_ARB_shader_stencil_export'); - // END GL 4.3 - - // GL 4.4 - GL_ARB_buffer_storage := Int_CheckExtension(Buffer, 'GL_ARB_buffer_storage'); - GL_ARB_clear_texture := Int_CheckExtension(Buffer, 'GL_ARB_clear_texture'); - GL_ARB_enhanced_layouts := Int_CheckExtension(Buffer, 'GL_ARB_enhanced_layouts'); - GL_ARB_multi_bind := Int_CheckExtension(Buffer, 'GL_ARB_multi_bind'); - GL_ARB_query_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_query_buffer_object'); - GL_ARB_texture_mirror_clamp_to_edge := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirror_clamp_to_edge'); - GL_ARB_texture_stencil8 := Int_CheckExtension(Buffer, 'GL_ARB_texture_stencil8'); - GL_ARB_vertex_type_10f_11f_11f_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_10f_11f_11f_rev'); - // END GL 4.4 - - // === ATI/AMD ================================================================ - GL_ATI_draw_buffers := Int_CheckExtension(Buffer, 'GL_ATI_draw_buffers'); - GL_ATI_element_array := Int_CheckExtension(Buffer, 'GL_ATI_element_array'); - GL_ATI_envmap_bumpmap := Int_CheckExtension(Buffer, 'GL_ATI_envmap_bumpmap'); - GL_ATI_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_fragment_shader'); - GL_ATI_map_object_buffer := Int_CheckExtension(Buffer, 'GL_ATI_map_object_buffer'); - GL_ATI_pn_triangles := Int_CheckExtension(Buffer, 'GL_ATI_pn_triangles'); - GL_ATI_separate_stencil := Int_CheckExtension(Buffer, 'GL_ATI_separate_stencil'); - GL_ATI_text_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_text_fragment_shader'); - GL_ATI_texture_env_combine3 := Int_CheckExtension(Buffer, 'GL_ATI_texture_env_combine3'); - GL_ATI_texture_float := Int_CheckExtension(Buffer, 'GL_ATI_texture_float'); - GL_ATI_texture_mirror_once := Int_CheckExtension(Buffer, 'GL_ATI_texture_mirror_once'); - GL_ATI_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_array_object'); - GL_ATI_vertex_attrib_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_attrib_array_object'); - GL_ATI_vertex_streams := Int_CheckExtension(Buffer, 'GL_ATI_vertex_streams'); - GL_ATI_meminfo := Int_CheckExtension(Buffer, 'GL_ATI_meminfo'); - GL_AMD_performance_monitor := Int_CheckExtension(Buffer, 'GL_AMD_performance_monitor'); - GL_AMD_texture_texture4 := Int_CheckExtension(Buffer, 'GL_AMD_texture_texture4'); - GL_AMD_vertex_shader_tesselator := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_tesselator'); - GL_AMD_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_AMD_draw_buffers_blend'); - GL_AMD_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_AMD_shader_stencil_export'); - GL_AMD_seamless_cubemap_per_texture := Int_CheckExtension(Buffer, 'GL_AMD_seamless_cubemap_per_texture'); - GL_AMD_conservative_depth := Int_CheckExtension(Buffer, 'GL_AMD_conservative_depth'); - GL_AMD_name_gen_delete := Int_CheckExtension(Buffer, 'GL_AMD_name_gen_delete'); - GL_AMD_debug_output := Int_CheckExtension(Buffer, 'GL_AMD_debug_output'); - GL_AMD_transform_feedback3_lines_triangles := Int_CheckExtension(Buffer, 'GL_AMD_transform_feedback3_lines_triangles'); - GL_AMD_depth_clamp_separate := Int_CheckExtension(Buffer, 'GL_AMD_depth_clamp_separate'); - // 4.3 - GL_AMD_pinned_memory := Int_CheckExtension(Buffer, 'GL_AMD_pinned_memory'); - GL_AMD_stencil_operation_extended := Int_CheckExtension(Buffer, 'GL_AMD_stencil_operation_extended'); - GL_AMD_vertex_shader_viewport_index := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_viewport_index'); - GL_AMD_vertex_shader_layer := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_layer'); - GL_AMD_query_buffer_object := Int_CheckExtension(Buffer, 'GL_AMD_query_buffer_object'); - - // === EXT ===================================================================== - GL_EXT_422_pixels := Int_CheckExtension(Buffer, 'GL_EXT_422_pixels'); - GL_EXT_abgr := Int_CheckExtension(Buffer, 'GL_EXT_abgr'); - GL_EXT_bgra := Int_CheckExtension(Buffer, 'GL_EXT_bgra'); - GL_EXT_blend_color := Int_CheckExtension(Buffer, 'GL_EXT_blend_color'); - GL_EXT_blend_func_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_func_separate'); - GL_EXT_blend_logic_op := Int_CheckExtension(Buffer, 'GL_EXT_blend_logic_op'); - GL_EXT_blend_minmax := Int_CheckExtension(Buffer, 'GL_EXT_blend_minmax'); - GL_EXT_blend_subtract := Int_CheckExtension(Buffer, 'GL_EXT_blend_subtract'); - GL_EXT_clip_volume_hint := Int_CheckExtension(Buffer, 'GL_EXT_clip_volume_hint'); - GL_EXT_cmyka := Int_CheckExtension(Buffer, 'GL_EXT_cmyka'); - GL_EXT_color_matrix := Int_CheckExtension(Buffer, 'GL_EXT_color_matrix'); - GL_EXT_color_subtable := Int_CheckExtension(Buffer, 'GL_EXT_color_subtable'); - GL_EXT_compiled_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_compiled_vertex_array'); - GL_EXT_convolution := Int_CheckExtension(Buffer, 'GL_EXT_convolution'); - GL_EXT_coordinate_frame := Int_CheckExtension(Buffer, 'GL_EXT_coordinate_frame'); - GL_EXT_copy_texture := Int_CheckExtension(Buffer, 'GL_EXT_copy_texture'); - GL_EXT_cull_vertex := Int_CheckExtension(Buffer, 'GL_EXT_cull_vertex'); - GL_EXT_draw_range_elements := Int_CheckExtension(Buffer, 'GL_EXT_draw_range_elements'); - GL_EXT_fog_coord := Int_CheckExtension(Buffer, 'GL_EXT_fog_coord'); - GL_EXT_framebuffer_object := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_object'); - GL_EXT_histogram := Int_CheckExtension(Buffer, 'GL_EXT_histogram'); - GL_EXT_index_array_formats := Int_CheckExtension(Buffer, 'GL_EXT_index_array_formats'); - GL_EXT_index_func := Int_CheckExtension(Buffer, 'GL_EXT_index_func'); - GL_EXT_index_material := Int_CheckExtension(Buffer, 'GL_EXT_index_material'); - GL_EXT_index_texture := Int_CheckExtension(Buffer, 'GL_EXT_index_texture'); - GL_EXT_light_texture := Int_CheckExtension(Buffer, 'GL_EXT_light_texture'); - GL_EXT_misc_attribute := Int_CheckExtension(Buffer, 'GL_EXT_misc_attribute'); - GL_EXT_multi_draw_arrays := Int_CheckExtension(Buffer, 'GL_EXT_multi_draw_arrays'); - GL_EXT_multisample := Int_CheckExtension(Buffer, 'GL_EXT_multisample'); - GL_EXT_packed_pixels := Int_CheckExtension(Buffer, 'GL_EXT_packed_pixels'); - GL_EXT_paletted_texture := Int_CheckExtension(Buffer, 'GL_EXT_paletted_texture'); - GL_EXT_pixel_transform := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform'); - GL_EXT_pixel_transform_color_table := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform_color_table'); - GL_EXT_point_parameters := Int_CheckExtension(Buffer, 'GL_EXT_point_parameters'); - GL_EXT_polygon_offset := Int_CheckExtension(Buffer, 'GL_EXT_polygon_offset'); - GL_EXT_rescale_normal := Int_CheckExtension(Buffer, 'GL_EXT_rescale_normal'); - GL_EXT_secondary_color := Int_CheckExtension(Buffer, 'GL_EXT_secondary_color'); - GL_EXT_separate_specular_color := Int_CheckExtension(Buffer, 'GL_EXT_separate_specular_color'); - GL_EXT_shadow_funcs := Int_CheckExtension(Buffer, 'GL_EXT_shadow_funcs'); - GL_EXT_shared_texture_palette := Int_CheckExtension(Buffer, 'GL_EXT_shared_texture_palette'); - GL_EXT_stencil_two_side := Int_CheckExtension(Buffer, 'GL_EXT_stencil_two_side'); - GL_EXT_stencil_wrap := Int_CheckExtension(Buffer, 'GL_EXT_stencil_wrap'); - GL_EXT_subtexture := Int_CheckExtension(Buffer, 'GL_EXT_subtexture'); - GL_EXT_texture := Int_CheckExtension(Buffer, 'GL_EXT_texture'); - GL_EXT_texture3D := Int_CheckExtension(Buffer, 'GL_EXT_texture3D'); - GL_EXT_texture_compression_s3tc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_s3tc'); - GL_EXT_texture_cube_map := Int_CheckExtension(Buffer, 'GL_EXT_texture_cube_map'); - GL_EXT_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_edge_clamp'); - GL_EXT_texture_env_add := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_add'); - GL_EXT_texture_env_combine := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_combine'); - GL_EXT_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_dot3'); - GL_EXT_texture_filter_anisotropic := Int_CheckExtension(Buffer, 'GL_EXT_texture_filter_anisotropic'); - GL_EXT_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_EXT_texture_lod_bias'); - GL_EXT_texture_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_object'); - GL_EXT_texture_perturb_normal := Int_CheckExtension(Buffer, 'GL_EXT_texture_perturb_normal'); - GL_EXT_texture_rectangle := Int_CheckExtension(Buffer, 'GL_EXT_texture_rectangle'); - GL_EXT_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array'); - GL_EXT_vertex_shader := Int_CheckExtension(Buffer, 'GL_EXT_vertex_shader'); - GL_EXT_vertex_weighting := Int_CheckExtension(Buffer, 'GL_EXT_vertex_weighting'); - GL_EXT_depth_bounds_test := Int_CheckExtension(Buffer, 'GL_EXT_depth_bounds_test'); - GL_EXT_texture_mirror_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_mirror_clamp'); - GL_EXT_blend_equation_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_equation_separate'); - GL_EXT_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_pixel_buffer_object'); - GL_EXT_texture_compression_dxt1 := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_dxt1'); - GL_EXT_stencil_clear_tag := Int_CheckExtension(Buffer, 'GL_EXT_stencil_clear_tag'); - GL_EXT_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_EXT_packed_depth_stencil'); - GL_EXT_texture_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB'); - GL_EXT_framebuffer_blit := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_blit'); - GL_EXT_framebuffer_multisample := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_multisample'); - GL_EXT_timer_query := Int_CheckExtension(Buffer, 'GL_EXT_timer_query'); - GL_EXT_gpu_program_parameters := Int_CheckExtension(Buffer, 'GL_EXT_gpu_program_parameters'); - GL_EXT_bindable_uniform := Int_CheckExtension(Buffer, 'GL_EXT_bindable_uniform'); - GL_EXT_draw_buffers2 := Int_CheckExtension(Buffer, 'GL_EXT_draw_buffers2'); - GL_EXT_draw_instanced := Int_CheckExtension(Buffer, 'GL_EXT_draw_instanced'); - GL_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_sRGB'); - GL_EXT_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_geometry_shader4'); - GL_EXT_gpu_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_gpu_shader4'); - GL_EXT_packed_float := Int_CheckExtension(Buffer, 'GL_EXT_packed_float'); - GL_EXT_texture_array := Int_CheckExtension(Buffer, 'GL_EXT_texture_array'); - GL_EXT_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_buffer_object'); - GL_EXT_texture_compression_latc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_latc'); - GL_EXT_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_rgtc'); - GL_EXT_texture_integer := Int_CheckExtension(Buffer, 'GL_EXT_texture_integer'); - GL_EXT_texture_shared_exponent := Int_CheckExtension(Buffer, 'GL_EXT_texture_shared_exponent'); - GL_EXT_transform_feedback := Int_CheckExtension(Buffer, 'GL_EXT_transform_feedback'); - GL_EXT_direct_state_access := Int_CheckExtension(Buffer, 'GL_EXT_direct_state_access'); - GL_EXT_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array_bgra'); - GL_EXT_texture_swizzle := Int_CheckExtension(Buffer, 'GL_EXT_texture_swizzle'); - GL_EXT_provoking_vertex := Int_CheckExtension(Buffer, 'GL_EXT_provoking_vertex'); - GL_EXT_texture_snorm := Int_CheckExtension(Buffer, 'GL_EXT_texture_snorm'); - GL_EXT_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_EXT_separate_shader_objects'); - GL_EXT_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_EXT_shader_image_load_store'); - GL_EXT_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_EXT_vertex_attrib_64bit'); - GL_EXT_texture_sRGB_decode := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB_decode'); - - // === HP ====================================================================== - GL_HP_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_HP_convolution_border_modes'); - GL_HP_image_transform := Int_CheckExtension(Buffer, 'GL_HP_image_transform'); - GL_HP_occlusion_test := Int_CheckExtension(Buffer, 'GL_HP_occlusion_test'); - GL_HP_texture_lighting := Int_CheckExtension(Buffer, 'GL_HP_texture_lighting'); - - // === IBM ===================================================================== - GL_IBM_cull_vertex := Int_CheckExtension(Buffer, 'GL_IBM_cull_vertex'); - GL_IBM_multimode_draw_arrays := Int_CheckExtension(Buffer, 'GL_IBM_multimode_draw_arrays'); - GL_IBM_rasterpos_clip := Int_CheckExtension(Buffer, 'GL_IBM_rasterpos_clip'); - GL_IBM_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_IBM_texture_mirrored_repeat'); - GL_IBM_vertex_array_lists := Int_CheckExtension(Buffer, 'GL_IBM_vertex_array_lists'); - - // === INGR ==================================================================== - GL_INGR_blend_func_separate := Int_CheckExtension(Buffer, 'GL_INGR_blend_func_separate'); - GL_INGR_color_clamp := Int_CheckExtension(Buffer, 'GL_INGR_color_clamp'); - GL_INGR_interlace_read := Int_CheckExtension(Buffer, 'GL_INGR_interlace_read'); - GL_INGR_palette_buffer := Int_CheckExtension(Buffer, 'GL_INGR_palette_buffer'); - - // === INTEL =================================================================== - GL_INTEL_parallel_arrays := Int_CheckExtension(Buffer, 'GL_INTEL_parallel_arrays'); - GL_INTEL_texture_scissor := Int_CheckExtension(Buffer, 'GL_INTEL_texture_scissor'); - - // === MESA ==================================================================== - GL_MESA_resize_buffers := Int_CheckExtension(Buffer, 'GL_MESA_resize_buffers'); - GL_MESA_window_pos := Int_CheckExtension(Buffer, 'GL_MESA_window_pos'); - - // === NVIDIA ================================================================== - GL_NV_blend_square := Int_CheckExtension(Buffer, 'GL_NV_blend_square'); - GL_NV_copy_depth_to_color := Int_CheckExtension(Buffer, 'GL_NV_copy_depth_to_color'); - GL_NV_depth_clamp := Int_CheckExtension(Buffer, 'GL_NV_depth_clamp'); - GL_NV_evaluators := Int_CheckExtension(Buffer, 'GL_NV_evaluators'); - GL_NV_fence := Int_CheckExtension(Buffer, 'GL_NV_fence'); - GL_NV_float_buffer := Int_CheckExtension(Buffer, 'GL_NV_float_buffer'); - GL_NV_fog_distance := Int_CheckExtension(Buffer, 'GL_NV_fog_distance'); - GL_NV_fragment_program := Int_CheckExtension(Buffer, 'GL_NV_fragment_program'); - GL_NV_half_float := Int_CheckExtension(Buffer, 'GL_NV_half_float'); - GL_NV_light_max_exponent := Int_CheckExtension(Buffer, 'GL_NV_light_max_exponent'); - GL_NV_multisample_filter_hint := Int_CheckExtension(Buffer, 'GL_NV_multisample_filter_hint'); - GL_NV_occlusion_query := Int_CheckExtension(Buffer, 'GL_NV_occlusion_query'); - GL_NV_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_NV_packed_depth_stencil'); - GL_NV_pixel_data_range := Int_CheckExtension(Buffer, 'GL_NV_pixel_data_range'); - GL_NV_point_sprite := Int_CheckExtension(Buffer, 'GL_NV_point_sprite'); - GL_NV_primitive_restart := Int_CheckExtension(Buffer, 'GL_NV_primitive_restart'); - GL_NV_register_combiners := Int_CheckExtension(Buffer, 'GL_NV_register_combiners'); - GL_NV_register_combiners2 := Int_CheckExtension(Buffer, 'GL_NV_register_combiners2'); - GL_NV_texgen_emboss := Int_CheckExtension(Buffer, 'GL_NV_texgen_emboss'); - GL_NV_texgen_reflection := Int_CheckExtension(Buffer, 'GL_NV_texgen_reflection'); - GL_NV_texture_compression_vtc := Int_CheckExtension(Buffer, 'GL_NV_texture_compression_vtc'); - GL_NV_texture_env_combine4 := Int_CheckExtension(Buffer, 'GL_NV_texture_env_combine4'); - GL_NV_texture_expand_normal := Int_CheckExtension(Buffer, 'GL_NV_texture_expand_normal'); - GL_NV_texture_rectangle := Int_CheckExtension(Buffer, 'GL_NV_texture_rectangle'); - GL_NV_texture_shader := Int_CheckExtension(Buffer, 'GL_NV_texture_shader'); - GL_NV_texture_shader2 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader2'); - GL_NV_texture_shader3 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader3'); - GL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range'); - GL_NV_vertex_array_range2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range2'); - GL_NV_vertex_program := Int_CheckExtension(Buffer, 'GL_NV_vertex_program'); - GL_NV_vertex_program1_1 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program1_1'); - GL_NV_vertex_program2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2'); - GL_NV_fragment_program_option := Int_CheckExtension(Buffer, 'GL_NV_fragment_program_option'); - GL_NV_fragment_program2 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program2'); - GL_NV_vertex_program2_option := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2_option'); - GL_NV_vertex_program3 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program3'); - GL_NV_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_NV_depth_buffer_float'); - GL_NV_fragment_program4 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program4'); - GL_NV_framebuffer_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_framebuffer_multisample_coverage'); - GL_NV_geometry_program4 := Int_CheckExtension(Buffer, 'GL_NV_geometry_program4'); - GL_NV_gpu_program4 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program4'); - GL_NV_parameter_buffer_object := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object'); - GL_NV_transform_feedback := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback'); - GL_NV_vertex_program4 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program4'); - GL_NV_conditional_render := Int_CheckExtension(Buffer, 'GL_NV_conditional_render'); - GL_NV_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video'); - GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample'); - GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2'); - GL_NV_video_capture := Int_CheckExtension(Buffer, 'GL_NV_video_capture'); - GL_NV_copy_image := Int_CheckExtension(Buffer, 'GL_NV_copy_image'); - GL_NV_parameter_buffer_object2 := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object2'); - GL_NV_shader_buffer_load := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_load'); - GL_NV_vertex_buffer_unified_memory := Int_CheckExtension(Buffer, 'GL_NV_vertex_buffer_unified_memory'); - GL_NV_gpu_program5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program5'); - GL_NV_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_shader5'); - GL_NV_shader_buffer_store := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_store'); - GL_NV_tessellation_program5 := Int_CheckExtension(Buffer, 'GL_NV_tessellation_program5'); - GL_NV_vertex_attrib_integer_64bit := Int_CheckExtension(Buffer, 'GL_NV_vertex_attrib_integer_64bit'); - GL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_multisample_coverage'); - GL_NV_vdpau_interop := Int_CheckExtension(Buffer, 'GL_NV_vdpau_interop'); - GL_NV_texture_barrier := Int_CheckExtension(Buffer, 'GL_NV_texture_barrier'); - // 4.3 - GL_NV_path_rendering := Int_CheckExtension(Buffer, 'GL_NV_path_rendering'); - GL_NV_bindless_texture := Int_CheckExtension(Buffer, 'GL_NV_bindless_texture'); - GL_NV_shader_atomic_float := Int_CheckExtension(Buffer, 'GL_NV_shader_atomic_float'); - - // === OML ===================================================================== - GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace'); - GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample'); - GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample'); - - // === PGI ===================================================================== - GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints'); - GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints'); - - // === REND ==================================================================== - GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates'); - - // === S3 ====================================================================== - GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc'); - - // === SGIS ==================================================================== - GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture'); - GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function'); - GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap'); - GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample'); - GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture'); - GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen'); - GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters'); - GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture'); - GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D'); - GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp'); - GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask'); - GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp'); - GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4'); - GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod'); - GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select'); - - // === SGIX ==================================================================== - GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX'); - GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async'); - GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram'); - GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel'); - GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax'); - GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment'); - GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap'); - GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy'); - GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument'); - GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture'); - GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster'); - GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset'); - GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale'); - GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting'); - GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom'); - GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface'); - GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture'); - GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments'); - GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace'); - GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1'); - GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority'); - GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture'); - GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles'); - GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd'); - GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane'); - GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample'); - GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint'); - GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow'); - GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient'); - GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite'); - GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample'); - GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer'); - GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env'); - GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp'); - GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias'); - GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer'); - GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias'); - GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select'); - GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip'); - GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb'); - GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample'); - GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba'); - - // === SGI ===================================================================== - GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix'); - GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table'); - GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument'); - GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table'); - - // === SUN ===================================================================== - GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data'); - GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes'); - GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha'); - GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array'); - GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum'); - GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list'); - GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex'); - - // === WIN ===================================================================== - GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading'); - GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog'); - - {$IFDEF DGL_WIN} - // === WGL ===================================================================== - WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample'); - WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region'); - WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string'); - WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read'); - WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample'); - WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer'); - WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format'); - WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float'); - WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture'); - WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context'); - WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile'); - WGL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'WGL_ARB_framebuffer_sRGB'); - WGL_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_robustness'); - WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float'); - WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association'); - WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float'); - WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table'); - WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string'); - WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read'); - WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample'); - WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer'); - WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format'); - WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control'); - WGL_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'WGL_EXT_create_context_es2_profile'); - WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control'); - WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma'); - WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock'); - WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer'); - WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock'); - WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage'); - WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer'); - WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture'); - WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle'); - WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range'); - WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video'); - WGL_NV_video_output := Int_CheckExtension(Buffer, 'WGL_NV_video_output'); - WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group'); - WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity'); - WGL_NV_video_capture := Int_CheckExtension(Buffer, 'WGL_NV_video_capture'); - WGL_NV_copy_image := Int_CheckExtension(Buffer, 'WGL_NV_copy_image'); - WGL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage'); - WGL_NV_DX_interop := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage'); - WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control'); - WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control'); - - WIN_draw_range_elements := Int_CheckExtension(Buffer, 'WIN_draw_range_elements'); - WIN_swap_hint := Int_CheckExtension(Buffer, 'WIN_swap_hint'); - {$ENDIF} - - {$IFDEF DGL_LINUX} - // === GLX ===================================================================== - GLX_ARB_multisample := Int_CheckExtension(Buffer, 'GLX_ARB_multisample'); - GLX_ARB_fbconfig_float := Int_CheckExtension(Buffer, 'GLX_ARB_fbconfig_float'); - GLX_ARB_get_proc_address := Int_CheckExtension(Buffer, 'GLX_ARB_get_proc_address'); - GLX_ARB_create_context := Int_CheckExtension(Buffer, 'GLX_ARB_create_context'); - GLX_ARB_create_context_profile := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_profile'); - GLX_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GLX_ARB_vertex_buffer_object'); - GLX_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_ARB_framebuffer_sRGB'); - GLX_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_robustness'); - GLX_EXT_visual_info := Int_CheckExtension(Buffer, 'GLX_EXT_visual_info'); - GLX_EXT_visual_rating := Int_CheckExtension(Buffer, 'GLX_EXT_visual_rating'); - GLX_EXT_import_context := Int_CheckExtension(Buffer, 'GLX_EXT_import_context'); - GLX_EXT_fbconfig_packed_float := Int_CheckExtension(Buffer, 'GLX_EXT_fbconfig_packed_float'); - GLX_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_EXT_framebuffer_sRGB'); - GLX_EXT_texture_from_pixmap := Int_CheckExtension(Buffer, 'GLX_EXT_texture_from_pixmap'); - GLX_EXT_swap_control := Int_CheckExtension(Buffer, 'GLX_EXT_swap_control'); - GLX_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'GLX_EXT_create_context_es2_profile'); - {$ENDIF} - ImplementationRead := True; -end; - -{$IFDEF DGL_WIN} -// ============================================================================= -// RaiseLastOSError -// ============================================================================= -// Needed for compatibility with older Delphiversions -// ============================================================================= - -procedure RaiseLastOSError; -begin -{$IFDEF FPC} - raise Exception.Create('RaiseLastOSError!'); // To-Do: find a better solution -{$ELSE} - {$IFDEF DELPHI6_AND_DOWN} // If Delphi 6 or later - SysUtils.RaiseLastWin32Error; - {$ELSE} - SysUtils.RaiseLastOSError; - {$ENDIF} -{$ENDIF} -end; - -// ============================================================================= -// CreateRenderingContext -// ============================================================================= - -function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; -const - OBJ_MEMDC = 10; - OBJ_ENHMETADC = 12; - OBJ_METADC = 4; - PFD_DOUBLEBUFFER = $00000001; - PFD_STEREO = $00000002; - PFD_DRAW_TO_WINDOW = $00000004; - PFD_DRAW_TO_BITMAP = $00000008; - PFD_SUPPORT_GDI = $00000010; - PFD_SUPPORT_OPENGL = $00000020; - PFD_TYPE_RGBA = 0; - PFD_MAIN_PLANE = 0; - PFD_OVERLAY_PLANE = 1; - PFD_UNDERLAY_PLANE = LongWord(-1); - MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC]; -var - PFDescriptor: TPixelFormatDescriptor; - PixelFormat: Integer; - AType: DWORD; -begin - if GL_LibHandle = nil then - InitOpenGL; - - FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0); - - with PFDescriptor do - begin - nSize := SizeOf(PFDescriptor); - nVersion := 1; - dwFlags := PFD_SUPPORT_OPENGL; - - AType := GetObjectType(DC); - - if AType = 0 then - RaiseLastOSError; - - if AType in MemoryDCs then - dwFlags := dwFlags or PFD_DRAW_TO_BITMAP - else - dwFlags := dwFlags or PFD_DRAW_TO_WINDOW; - - if opDoubleBuffered in Options then - dwFlags := dwFlags or PFD_DOUBLEBUFFER; - - if opGDI in Options then - dwFlags := dwFlags or PFD_SUPPORT_GDI; - - if opStereo in Options then - dwFlags := dwFlags or PFD_STEREO; - - iPixelType := PFD_TYPE_RGBA; - cColorBits := ColorBits; - cDepthBits := zBits; - cStencilBits := StencilBits; - cAccumBits := AccumBits; - cAuxBuffers := AuxBuffers; - - if Layer = 0 then - iLayerType := PFD_MAIN_PLANE - else - if Layer > 0 then - iLayerType := PFD_OVERLAY_PLANE - else - iLayerType := Byte(PFD_UNDERLAY_PLANE); - end; - - PixelFormat := ChoosePixelFormat(DC, @PFDescriptor); - - if PixelFormat = 0 then - RaiseLastOSError; - - if GetPixelFormat(DC) <> PixelFormat then - if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then - RaiseLastOSError; - - DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor); - - Result := wglCreateContext(DC); - - if Result = 0 then - RaiseLastOSError - else - LastPixelFormat := 0; -end; - -// ============================================================================= -// CreateRenderingContextVersion -// ============================================================================= -// Creates a context for the more recent OpenGL versions (3.0) and up -// For that we first need to get a normal GL context for getting the -// function pointer to wglCreateContextAttribsARB first -// ============================================================================= -function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC; -const - OBJ_MEMDC = 10; - OBJ_ENHMETADC = 12; - OBJ_METADC = 4; - PFD_DOUBLEBUFFER = $00000001; - PFD_STEREO = $00000002; - PFD_DRAW_TO_WINDOW = $00000004; - PFD_DRAW_TO_BITMAP = $00000008; - PFD_SUPPORT_GDI = $00000010; - PFD_SUPPORT_OPENGL = $00000020; - PFD_TYPE_RGBA = 0; - PFD_MAIN_PLANE = 0; - PFD_OVERLAY_PLANE = 1; - PFD_UNDERLAY_PLANE = LongWord(-1); - MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC]; -var - PFDescriptor : TPixelFormatDescriptor; - PixelFormat : Integer; - AType : DWORD; - LegacyRC : HGLRC; - Attribs : array of Integer; -begin - if GL_LibHandle = nil then - InitOpenGL; - - if not Assigned(GL_LibHandle) then - raise Exception.Create('GL_LibHandle is NIL. Could not load OpenGL library!'); - - FillChar(PFDescriptor{%H-}, SizeOf(PFDescriptor), 0); - - with PFDescriptor do - begin - nSize := SizeOf(PFDescriptor); - nVersion := 1; - dwFlags := PFD_SUPPORT_OPENGL; - AType := GetObjectType(DC); - - if AType = 0 then - RaiseLastOSError; - - if AType in MemoryDCs then - dwFlags := dwFlags or PFD_DRAW_TO_BITMAP - else - dwFlags := dwFlags or PFD_DRAW_TO_WINDOW; - - if opDoubleBuffered in Options then - dwFlags := dwFlags or PFD_DOUBLEBUFFER; - - if opGDI in Options then - dwFlags := dwFlags or PFD_SUPPORT_GDI; - - if opStereo in Options then - dwFlags := dwFlags or PFD_STEREO; - - iPixelType := PFD_TYPE_RGBA; - cColorBits := ColorBits; - cDepthBits := zBits; - cStencilBits := StencilBits; - cAccumBits := AccumBits; - cAuxBuffers := AuxBuffers; - - if Layer = 0 then - iLayerType := PFD_MAIN_PLANE - else - if Layer > 0 then - iLayerType := PFD_OVERLAY_PLANE - else - iLayerType := Byte(PFD_UNDERLAY_PLANE); - end; - - PixelFormat := ChoosePixelFormat(DC, @PFDescriptor); - - if PixelFormat = 0 then - RaiseLastOSError; - - if GetPixelFormat(DC) <> PixelFormat then - if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then - RaiseLastOSError; - - DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor); - - // Create legacy render context first for we need function pointers to - // create new OpenGL render contexts - LegacyRC := wglCreateContext(DC); - wglMakeCurrent(DC, LegacyRC); - - // Set attributes to describe our requested context - SetLength(Attribs, 5); - Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB; - Attribs[1] := MajorVersion; - Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB; - Attribs[3] := MinorVersion; - - // Add context flag for forward compatible context - // Forward compatible means no more support for legacy functions like - // immediate mode (glvertex, glrotate, gltranslate, etc.) - if ForwardCompatible then - begin - SetLength(Attribs, Length(Attribs)+2); - Attribs[4] := WGL_CONTEXT_FLAGS_ARB; - Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; - end; - - // Attribute flags must be finalized with a zero - Attribs[High(Attribs)] := 0; - - // Get function pointer for new context creation function - wglCreateContextAttribsARB := wglGetProcAddress('wglCreateContextAttribsARB'); - - if not Assigned(wglCreateContextAttribsARB) then - begin - raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!'); - wglDeleteContext(LegacyRC); - exit; - end; - - // Create context - Result := wglCreateContextAttribsARB(DC, 0, @Attribs[0]); - - if Result = 0 then - begin - raise Exception.Create('Could not create the desired OpenGL rendering context!'); - wglDeleteContext(LegacyRC); - exit; - end; - - wglDeleteContext(LegacyRC); - - if Result = 0 then - RaiseLastOSError - else - LastPixelFormat := 0; -end; - -// ============================================================================= -// DestroyRenderingContext -// ============================================================================= - -procedure DestroyRenderingContext(RC: HGLRC); -begin - wglDeleteContext(RC); -end; - - -// ============================================================================= -// ActivateRenderingContext -// ============================================================================= - -procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true); -begin - Assert((DC <> 0), 'DC must not be 0'); - Assert((RC <> 0), 'RC must not be 0'); - - wglMakeCurrent(DC, RC); - - {$ifdef DGL_TINY_HEADER} - ReadCoreVersion; - {$else} - ReadImplementationProperties; - - if (loadext) then - ReadExtensions; - {$endif} -end; - -// ============================================================================= -// DeactivateRenderingContext -// ============================================================================= - -procedure DeactivateRenderingContext; -begin - wglMakeCurrent(0, 0); -end; -{$ENDIF} - - -initialization - -{$IFDEF CPU386} - Set8087CW($133F); -{$ENDIF} - -finalization - -end. diff --git a/examples/glBitmapConf.inc b/examples/glBitmapConf.inc deleted file mode 100644 index 6a9c66c..0000000 --- a/examples/glBitmapConf.inc +++ /dev/null @@ -1,61 +0,0 @@ -{ 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 diff --git a/examples/simple/project1.lpi b/examples/simple/project1.lpi new file mode 100644 index 0000000..7e49921 --- /dev/null +++ b/examples/simple/project1.lpi @@ -0,0 +1,82 @@ +<?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> diff --git a/examples/simple/project1.lpr b/examples/simple/project1.lpr new file mode 100644 index 0000000..5ca8fd0 --- /dev/null +++ b/examples/simple/project1.lpr @@ -0,0 +1,21 @@ +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. + diff --git a/examples/simple/shader.glsl b/examples/simple/shader.glsl new file mode 100644 index 0000000..5993f08 --- /dev/null +++ b/examples/simple/shader.glsl @@ -0,0 +1,19 @@ +/* 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 diff --git a/examples/simple/uMainForm.lfm b/examples/simple/uMainForm.lfm new file mode 100644 index 0000000..712be2c --- /dev/null +++ b/examples/simple/uMainForm.lfm @@ -0,0 +1,35 @@ +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 diff --git a/examples/simple/uMainForm.pas b/examples/simple/uMainForm.pas new file mode 100644 index 0000000..1179a67 --- /dev/null +++ b/examples/simple/uMainForm.pas @@ -0,0 +1,122 @@ +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. + diff --git a/examples/texture/data/texture.png b/examples/texture/data/texture.png new file mode 100644 index 0000000..edd43da Binary files /dev/null and b/examples/texture/data/texture.png differ diff --git a/examples/texture/project1.lpi b/examples/texture/project1.lpi new file mode 100644 index 0000000..7e49921 --- /dev/null +++ b/examples/texture/project1.lpi @@ -0,0 +1,82 @@ +<?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> diff --git a/examples/texture/project1.lpr b/examples/texture/project1.lpr new file mode 100644 index 0000000..5ca8fd0 --- /dev/null +++ b/examples/texture/project1.lpr @@ -0,0 +1,21 @@ +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. + diff --git a/examples/texture/shader.glsl b/examples/texture/shader.glsl new file mode 100644 index 0000000..c70ab11 --- /dev/null +++ b/examples/texture/shader.glsl @@ -0,0 +1,23 @@ +/* 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 diff --git a/examples/texture/uMainForm.lfm b/examples/texture/uMainForm.lfm new file mode 100644 index 0000000..712be2c --- /dev/null +++ b/examples/texture/uMainForm.lfm @@ -0,0 +1,35 @@ +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 diff --git a/examples/texture/uMainForm.pas b/examples/texture/uMainForm.pas new file mode 100644 index 0000000..5b325a7 --- /dev/null +++ b/examples/texture/uMainForm.pas @@ -0,0 +1,156 @@ +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. + diff --git a/examples/textures/BMP_24_RGB8.bmp b/examples/textures/BMP_24_RGB8.bmp deleted file mode 100644 index e1318e8..0000000 Binary files a/examples/textures/BMP_24_RGB8.bmp and /dev/null differ diff --git a/examples/vertexarrayobject/data/texture.png b/examples/vertexarrayobject/data/texture.png new file mode 100644 index 0000000..edd43da Binary files /dev/null and b/examples/vertexarrayobject/data/texture.png differ diff --git a/examples/vertexarrayobject/project1.lpi b/examples/vertexarrayobject/project1.lpi new file mode 100644 index 0000000..42d2560 --- /dev/null +++ b/examples/vertexarrayobject/project1.lpi @@ -0,0 +1,91 @@ +<?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> diff --git a/examples/vertexarrayobject/project1.lpr b/examples/vertexarrayobject/project1.lpr new file mode 100644 index 0000000..66fcec0 --- /dev/null +++ b/examples/vertexarrayobject/project1.lpr @@ -0,0 +1,21 @@ +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. + diff --git a/examples/vertexarrayobject/shader.glsl b/examples/vertexarrayobject/shader.glsl new file mode 100644 index 0000000..c70ab11 --- /dev/null +++ b/examples/vertexarrayobject/shader.glsl @@ -0,0 +1,23 @@ +/* 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 diff --git a/examples/vertexarrayobject/uMainForm.lfm b/examples/vertexarrayobject/uMainForm.lfm new file mode 100644 index 0000000..712be2c --- /dev/null +++ b/examples/vertexarrayobject/uMainForm.lfm @@ -0,0 +1,35 @@ +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 diff --git a/examples/vertexarrayobject/uMainForm.pas b/examples/vertexarrayobject/uMainForm.pas new file mode 100644 index 0000000..02887d3 --- /dev/null +++ b/examples/vertexarrayobject/uMainForm.pas @@ -0,0 +1,170 @@ +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. + diff --git a/glBitmap.pas b/glBitmap.pas deleted file mode 100644 index 165ee38..0000000 --- a/glBitmap.pas +++ /dev/null @@ -1,8889 +0,0 @@ -{ 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. diff --git a/glBitmapConf.default.inc b/glBitmapConf.default.inc deleted file mode 100644 index 6a9c66c..0000000 --- a/glBitmapConf.default.inc +++ /dev/null @@ -1,61 +0,0 @@ -{ 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 diff --git a/glBitmapConf.inc b/glBitmapConf.inc new file mode 100644 index 0000000..a438dcd --- /dev/null +++ b/glBitmapConf.inc @@ -0,0 +1,61 @@ +{ 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 diff --git a/readme.txt b/readme.txt deleted file mode 100644 index 7a87264..0000000 --- a/readme.txt +++ /dev/null @@ -1,231 +0,0 @@ -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 diff --git a/uglcArrayBuffer.pas b/uglcArrayBuffer.pas new file mode 100644 index 0000000..5d6f8de --- /dev/null +++ b/uglcArrayBuffer.pas @@ -0,0 +1,219 @@ +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. + diff --git a/uglcBitmap.pas b/uglcBitmap.pas new file mode 100644 index 0000000..0a17caa --- /dev/null +++ b/uglcBitmap.pas @@ -0,0 +1,8901 @@ +{ 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. diff --git a/uglcCamera.pas b/uglcCamera.pas new file mode 100644 index 0000000..43110d0 --- /dev/null +++ b/uglcCamera.pas @@ -0,0 +1,346 @@ +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. + diff --git a/uglcContext.pas b/uglcContext.pas new file mode 100644 index 0000000..73f419a --- /dev/null +++ b/uglcContext.pas @@ -0,0 +1,365 @@ +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. + diff --git a/uglcContextGtk2GLX.pas b/uglcContextGtk2GLX.pas new file mode 100644 index 0000000..f9d1475 --- /dev/null +++ b/uglcContextGtk2GLX.pas @@ -0,0 +1,572 @@ +unit uglcContextGtk2GLX; + +{ Package: OpenGLCore + Prefix: glc - OpenGL Core + Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Kontexte für Linux + Hint: diese Unit sollte niemals direkt genutzt werden (siehe uglcContext) } + +interface + +uses + SysUtils, Controls, uglcContext, LCLType, XUtil, XLib, gdk2x, gtk2, gdk2, dglOpenGL, + LMessages, uglcContextGtkCustomVisual; + +type + EGLXError = class(EGLError); + + TRenderControl = class(TCustomVisualControl) + private + fTarget: TWinControl; + protected + procedure WndProc(var Message: TLMessage); override; + public + property Target: TWinControl read fTarget write fTarget; + end; + + { TglcContextGtk2GLX } + + TglcContextGtk2GLX = class(TglcContext) + private + FVisual: PXVisualInfo; + FDisplay: PDisplay; + FWidget: PGtkWidget; + FContext: GLXContext; + FRenderControl: TRenderControl; + procedure UpdateVisual(const aControl: TWinControl); + protected + procedure OpenContext; override; + public + constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); override; overload; + constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); override; overload; + destructor Destroy; override; + + procedure CloseContext; override; + procedure Activate; override; + procedure Deactivate; override; + function IsActive: boolean; override; + procedure SwapBuffers; override; + procedure SetSwapInterval(const aInterval: 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 + +type + TGLIntArray = packed array of GLInt; + +{$region messages -fold} +procedure TRenderControl.WndProc(var Message: TLMessage); +begin + case Message.msg of + //LM_ACTIVATEITEM, + //LM_CHANGED, + //LM_FOCUS, + LM_CLICKED, + //LM_RELEASED, + LM_ENTER, + LM_LEAVE, + //LM_CHECKRESIZE, + //LM_SETEDITABLE, + //LM_MOVEWORD, + //LM_MOVEPAGE, + //LM_MOVETOROW, + //LM_MOVETOCOLUMN, + //LM_KILLCHAR, + //LM_KILLWORD, + //LM_KILLLINE, + //LM_CLOSEQUERY, + //LM_DRAGSTART, + //LM_MONTHCHANGED, + //LM_YEARCHANGED, + //LM_DAYCHANGED, + LM_LBUTTONTRIPLECLK, + LM_LBUTTONQUADCLK, + LM_MBUTTONTRIPLECLK, + LM_MBUTTONQUADCLK, + LM_RBUTTONTRIPLECLK, + LM_RBUTTONQUADCLK, + LM_MOUSEENTER, + LM_MOUSELEAVE, + LM_XBUTTONTRIPLECLK, + LM_XBUTTONQUADCLK, + + //SC_SIZE, + //SC_MOVE, + //SC_MINIMIZE, + //SC_MAXIMIZE, + //SC_NEXTWINDOW, + //SC_PREVWINDOW, + //SC_CLOSE, + SC_VSCROLL, + SC_HSCROLL, + SC_MOUSEMENU, + SC_KEYMENU, + //SC_ARRANGE, + //SC_RESTORE, + //SC_TASKLIST, + //SC_SCREENSAVE, + //SC_HOTKEY, + //SC_DEFAULT, + //SC_MONITORPOWER, + //SC_CONTEXTHELP, + //SC_SEPARATOR, + + //LM_MOVE, + //LM_SIZE, + LM_ACTIVATE, + LM_SETFOCUS, + LM_KILLFOCUS, + //LM_ENABLE, + //LM_GETTEXTLENGTH, + //LM_SHOWWINDOW, + //LM_CANCELMODE, + //LM_DRAWITEM, + //LM_MEASUREITEM, + //LM_DELETEITEM, + //LM_VKEYTOITEM, + //LM_CHARTOITEM, + //LM_COMPAREITEM, + //LM_WINDOWPOSCHANGING, + //LM_WINDOWPOSCHANGED, + //LM_NOTIFY, + //LM_HELP, + //LM_NOTIFYFORMAT, + //LM_CONTEXTMENU, + //LM_NCCALCSIZE, + //LM_NCHITTEST, + //LM_NCPAINT, + //LM_NCACTIVATE, + //LM_GETDLGCODE, + LM_NCMOUSEMOVE, + LM_NCLBUTTONDOWN, + LM_NCLBUTTONUP, + LM_NCLBUTTONDBLCLK, + LM_KEYDOWN, + LM_KEYUP, + LM_CHAR, + LM_SYSKEYDOWN, + LM_SYSKEYUP, + LM_SYSCHAR, + LM_COMMAND, + LM_SYSCOMMAND, + LM_TIMER, + LM_HSCROLL, + LM_VSCROLL, + //LM_CTLCOLORMSGBOX, + //LM_CTLCOLOREDIT, + //LM_CTLCOLORLISTBOX, + //LM_CTLCOLORBTN, + //LM_CTLCOLORDLG, + //LM_CTLCOLORSCROLLBAR, + //LM_CTLCOLORSTATIC, + LM_MOUSEMOVE, + LM_LBUTTONDOWN, + LM_LBUTTONUP, + LM_LBUTTONDBLCLK, + LM_RBUTTONDOWN, + LM_RBUTTONUP, + LM_RBUTTONDBLCLK, + LM_MBUTTONDOWN, + LM_MBUTTONUP, + LM_MBUTTONDBLCLK, + LM_MOUSEWHEEL, + LM_XBUTTONDOWN, + LM_XBUTTONUP, + LM_XBUTTONDBLCLK, + //LM_PARENTNOTIFY, + //LM_CAPTURECHANGED, + //LM_DROPFILES, + //LM_SELCHANGE, + LM_CUT, + LM_COPY, + LM_PASTE, + //LM_CLEAR, + //LM_CONFIGUREEVENT, + //LM_EXIT, + //LM_QUIT, + //LM_NULL, + //LM_PAINT, + //LM_ERASEBKGND, + //LM_SETCURSOR, + //LM_SETFONT: + + //CM_ACTIVATE, + //CM_DEACTIVATE, + //CM_FOCUSCHANGED, + //CM_PARENTFONTCHANGED, + //CM_PARENTCOLORCHANGED, + //CM_HITTEST, + //CM_VISIBLECHANGED, + //CM_ENABLEDCHANGED, + //CM_COLORCHANGED, + //CM_FONTCHANGED, + //CM_CURSORCHANGED, + //CM_TEXTCHANGED, + CM_MOUSEENTER, + CM_MOUSELEAVE, + //CM_MENUCHANGED, + //CM_APPSYSCOMMAND, + //CM_BUTTONPRESSED, + //CM_SHOWINGCHANGED, + //CM_ENTER, + //CM_EXIT, + //CM_DESIGNHITTEST, + //CM_ICONCHANGED, + //CM_WANTSPECIALKEY, + //CM_RELEASE, + //CM_FONTCHANGE, + //CM_TABSTOPCHANGED, + //CM_UIACTIVATE, + //CM_CONTROLLISTCHANGE, + //CM_GETDATALINK, + //CM_CHILDKEY, + //CM_HINTSHOW, + //CM_SYSFONTCHANGED, + //CM_CONTROLCHANGE, + //CM_CHANGED, + //CM_BORDERCHANGED, + //CM_BIDIMODECHANGED, + //CM_PARENTBIDIMODECHANGED, + //CM_ALLCHILDRENFLIPPED, + //CM_ACTIONUPDATE, + //CM_ACTIONEXECUTE, + //CM_HINTSHOWPAUSE, + //CM_DOCKNOTIFICATION, + CM_MOUSEWHEEL, + //CM_APPSHOWBTNGLYPHCHANGED, + //CM_APPSHOWMENUGLYPHCHANGED, + + //CN_BASE, + //CN_CHARTOITEM, + //CN_COMMAND, + //CN_COMPAREITEM, + //CN_CTLCOLORBTN, + //CN_CTLCOLORDLG, + //CN_CTLCOLOREDIT, + //CN_CTLCOLORLISTBOX, + //CN_CTLCOLORMSGBOX, + //CN_CTLCOLORSCROLLBAR, + //CN_CTLCOLORSTATIC, + //CN_DELETEITEM, + //CN_DRAWITEM, + CN_HSCROLL, + //CN_MEASUREITEM, + //CN_PARENTNOTIFY, + //CN_VKEYTOITEM, + CN_VSCROLL, + CN_KEYDOWN, + CN_KEYUP, + CN_CHAR, + CN_SYSKEYUP, + CN_SYSKEYDOWN, + CN_SYSCHAR, + CN_NOTIFY: + begin + if Assigned(fTarget) then + Message.Result := fTarget.Perform(Message.msg, Message.wParam, Message.lParam); + end; + end; + inherited WndProc(Message); +end; + +{$endregion} + +function CreateOpenGLContextAttrList(UseFB: boolean; pf: TglcContextPixelFormatSettings): TGLIntArray; +var + p: integer; + + procedure Add(i: integer); + begin + SetLength(Result, p+1); + Result[p]:=i; + inc(p); + end; + + procedure CreateList; + begin + if UseFB then begin Add(GLX_X_RENDERABLE); Add(1); end; + if pf.DoubleBuffered then begin + if UseFB then begin + Add(GLX_DOUBLEBUFFER); Add(1); + end else + Add(GLX_DOUBLEBUFFER); + end; + if not UseFB and (pf.ColorBits>24) then Add(GLX_RGBA); + if UseFB then begin + Add(GLX_DRAWABLE_TYPE); + Add(GLX_WINDOW_BIT); + end; + Add(GLX_RED_SIZE); Add(8); + Add(GLX_GREEN_SIZE); Add(8); + Add(GLX_BLUE_SIZE); Add(8); + if pf.ColorBits>24 then + Add(GLX_ALPHA_SIZE); Add(8); + Add(GLX_DEPTH_SIZE); Add(pf.DepthBits); + Add(GLX_STENCIL_SIZE); Add(pf.StencilBits); + Add(GLX_AUX_BUFFERS); Add(pf.AUXBuffers); + + if pf.MultiSampling > 1 then begin + Add(GLX_SAMPLE_BUFFERS_ARB); Add(1); + Add(GLX_SAMPLES_ARB); Add(pf.MultiSampling); + end; + + Add(0); { 0 = X.None (be careful: GLX_NONE is something different) } + end; + +begin + SetLength(Result, 0); + p:=0; + CreateList; +end; + +function FBglXChooseVisual(dpy:PDisplay; screen:longint; attrib_list:Plongint):PXVisualInfo; +type + PGLXFBConfig = ^GLXFBConfig; +var + FBConfigsCount: integer; + FBConfigs: PGLXFBConfig; + FBConfig: GLXFBConfig; +begin + Result:= nil; + FBConfigsCount:=0; + FBConfigs:= glXChooseFBConfig(dpy, screen, attrib_list, @FBConfigsCount); + if FBConfigsCount = 0 then + exit; + + { just choose the first FB config from the FBConfigs list. + More involved selection possible. } + FBConfig := FBConfigs^; + Result:=glXGetVisualFromFBConfig(dpy, FBConfig); +end; + + +{ TglcContextGtk2GLX } + +procedure TglcContextGtk2GLX.UpdateVisual(const aControl: TWinControl); +var + attrList: TGLIntArray; + drawable: PGdkDrawable; +begin + if not Assigned(aControl) then + raise EArgumentException.Create('aControl is not assigned'); + + { + Temporary (realized) widget to get to display + } + FWidget:= {%H-}PGtkWidget(PtrUInt(aControl.Handle)); + gtk_widget_realize(FWidget); + drawable:= GTK_WIDGET(FWidget)^.window; + + FDisplay:= GDK_WINDOW_XDISPLAY(drawable); + + { + Find a suitable visual from PixelFormat using GLX 1.3 FBConfigs or + old-style Visuals + } + if Assigned(glXChooseFBConfig) then begin + attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings); + FVisual := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]); + if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin + fPixelFormatSettings.MultiSampling := 1; + attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings); + FVisual := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]); + end; + end; + if not Assigned(FVisual) then begin + attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings); + FVisual := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]); + if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin + fPixelFormatSettings.MultiSampling := 1; + attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings); + FVisual := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]); + end; + end; + if not Assigned(FVisual) then + raise EGLXError.Create('choose visual failed'); + + { + Most widgets inherit the drawable of their parent. In contrast to Windows, descending from + TWinControl does not mean it's actually always a window of its own. + Famous example: TPanel is just a frame painted on a canvas. + Also, the LCL does somethin weird to colormaps in window creation, so we have + to use a custom widget here to have full control about visual selection. + } + FRenderControl:= TRenderControl.Create(aControl, FVisual^.visual^.visualid); + try + FRenderControl.Parent := aControl; + FRenderControl.HandleNeeded; + FRenderControl.Target := aControl; + except + FreeAndNil(FRenderControl); + raise; + end; + + { + Real Widget handle, unrealized!!! + } + FWidget:= FRenderControl.Widget; + gtk_widget_realize(FWidget); + drawable:= GTK_WIDGET(FWidget)^.window; + FDisplay:= GDK_WINDOW_XDISPLAY(drawable); + + // FRenderControl.Align:= alClient breaks the context or something + FRenderControl.BoundsRect := aControl.ClientRect; + FRenderControl.Anchors := [akLeft, akTop, akRight, akBottom]; +end; + +procedure TglcContextGtk2GLX.OpenContext; +var + Attribs: array of GLint; + tmpContext: GLXContext; + glxID: GLXDrawable; +begin + inherited OpenContext; + + if not Assigned(FVisual) then + raise EGLXError.Create('Failed to find Visual'); + + tmpContext := glXCreateContext(FDisplay, FVisual, nil, true); + if fUseVersion and + (fVersionSettings.Major <> GLC_CONTEXT_VERSION_UNKNOWN) and + (fVersionSettings.Minor <> GLC_CONTEXT_VERSION_UNKNOWN) then + begin + // 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 + SetLength(Attribs, 1); + Attribs[High(Attribs)] := 0; + + glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window); + glXMakeCurrent(FDisplay, glxID, tmpContext); + ReadImplementationProperties; + if not Assigned(glXCreateContextAttribsARB) or not GLX_ARB_create_context then begin + glXDestroyContext(FDisplay, tmpContext); + raise Exception.Create('GLX_ARB_create_context not supported'); + end; + FContext := glXCreateContextAttribsARB(FDisplay, FVisual, nil, true, @Attribs[0]); + + glXDestroyContext(FDisplay, tmpContext); + end else + FContext := tmpContext; + + if (FContext = nil) then + raise EGLXError.Create('Failed to create Context'); +end; + +constructor TglcContextGtk2GLX.Create(const aControl: TWinControl; + const aPixelFormatSettings: TglcContextPixelFormatSettings); +begin + inherited Create(aControl, aPixelFormatSettings); + UpdateVisual(aControl); +end; + +constructor TglcContextGtk2GLX.Create(const aControl: TWinControl; + const aPixelFormatSettings: TglcContextPixelFormatSettings; + const aVersionSettings: TglcContextVersionSettings); +begin + inherited Create(aControl, aPixelFormatSettings, aVersionSettings); + UpdateVisual(aControl); +end; + +destructor TglcContextGtk2GLX.Destroy; +begin + FreeAndNil(FRenderControl); + XFree(FVisual); + inherited Destroy; +end; + +procedure TglcContextGtk2GLX.CloseContext; +begin + if not Assigned(FWidget) then exit; + if Assigned(FContext) then + glXDestroyContext(FDisplay, FContext); + FreeAndNil(FRenderControl); +end; + +procedure TglcContextGtk2GLX.Activate; +var + glxID: GLXDrawable; +begin + if not Assigned(FWidget) then exit; + // make sure the widget is realized + gtk_widget_realize(FWidget); + if not GTK_WIDGET_REALIZED(FWidget) then exit; + + // make current + glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window); + glXMakeCurrent(FDisplay, glxID, FContext); +end; + +procedure TglcContextGtk2GLX.Deactivate; +var + glxID: GLXDrawable; +begin + if not Assigned(FWidget) then exit; + glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window); + glXMakeCurrent(FDisplay, glxID, nil); +end; + +function TglcContextGtk2GLX.IsActive: boolean; +var + glxID: GLXDrawable; +begin + glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window); + Result:= (FContext = glXGetCurrentContext()) and + Assigned(FWidget) and + (glxID = glXGetCurrentDrawable()); +end; + +procedure TglcContextGtk2GLX.SwapBuffers; +var + glxID: GLXDrawable; +begin + if not Assigned(FWidget) then exit; + glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window); + glXSwapBuffers(FDisplay, glxID); +end; + +procedure TglcContextGtk2GLX.SetSwapInterval(const aInterval: GLint); +var + drawable: PGdkDrawable; +begin + drawable:= GTK_WIDGET(FWidget)^.window; + if GLX_EXT_swap_control then + glXSwapIntervalEXT(FDisplay, GDK_WINDOW_XWINDOW(drawable), aInterval); +end; + +procedure TglcContextGtk2GLX.Share(const aContext: TglcContext); +begin + raise Exception.Create('not yet implemented'); +end; + +class function TglcContextGtk2GLX.{%H-}ChangeDisplaySettings(const aWidth, aHeight, + aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean; +begin + raise Exception.Create('not yet implemented'); +end; + +class function TglcContextGtk2GLX.IsAnyContextActive: boolean; +begin + Result:= (glXGetCurrentContext()<>nil) and (glXGetCurrentDrawable()<>0); +end; + +end. + diff --git a/uglcContextGtkCustomVisual.pas b/uglcContextGtkCustomVisual.pas new file mode 100644 index 0000000..ffc8677 --- /dev/null +++ b/uglcContextGtkCustomVisual.pas @@ -0,0 +1,225 @@ +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. + diff --git a/uglcContextWGL.pas b/uglcContextWGL.pas new file mode 100644 index 0000000..16fc885 --- /dev/null +++ b/uglcContextWGL.pas @@ -0,0 +1,432 @@ +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. + diff --git a/uglcFrameBufferObject.pas b/uglcFrameBufferObject.pas new file mode 100644 index 0000000..a0d75e0 --- /dev/null +++ b/uglcFrameBufferObject.pas @@ -0,0 +1,677 @@ +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. + diff --git a/uglcLight.pas b/uglcLight.pas new file mode 100644 index 0000000..1889a40 --- /dev/null +++ b/uglcLight.pas @@ -0,0 +1,427 @@ +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. + diff --git a/uglcShader.pas b/uglcShader.pas new file mode 100644 index 0000000..bcc2360 --- /dev/null +++ b/uglcShader.pas @@ -0,0 +1,964 @@ +unit uglcShader; + +{ Package: OpenGLCore + Prefix: glc - OpenGL Core + Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL Shader Objekte + Beispiel: + var + shader: TglcShaderProgram; + + //write log message to console + // @param aSender: object that send the message + // @param aMsg: message to write to console + procedure LogMessage(aSender: TObject; const aMsg: String); + begin + writeln(Format('[%p]: %s', [aSender, aMsg]); + end; + + //load shader object from file and add it to 'shader' + // @param aFilename: name of file to load shader code from + // @param aType: type of shader object to create + procedure LoadShaderObject(const aFilename: String; const aType: TglcShaderType); + var + sl: TStringList; + so: TglcShaderObject; + begin + sl := TStringList.Create; + try + sl.LoadFromFile(aFileName); + so := TglcShaderObject.Create(aType); + shader.add(so); + finally + FreeAndNil(sl, @LogMessage); + end; + end; + + shader := TglcShaderProgram.Create(@LogMessage); + try + // load shader objects + LoadShaderObject('./test_shader.vert', TglcShaderType.stVertex); + LoadShaderObject('./test_shader.frag', TglcShaderType.stFragment); + + // compile shader + shader.Compile; + + // use shader + shader.Enable; + shader.Uniform1f('uTest', 0.1234); + // do normal rendering + shader.Disable; + + finally + FreeAndNil(shader); + end; } + +{$mode objfpc}{$H+} + +interface + +uses + Classes, SysUtils, fgl, {$IFNDEF OPENGL_ES}dglOpenGl{$ELSE}dglOpenGLES{$ENDIF}, uglcTypes, ugluMatrix; + +type +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + EglcShader = class(Exception); + TglcShaderProgram = class; + TglcShaderLogEvent = procedure(aSender: TObject; const aMsg: String) of Object; + TglcShaderObject = class(TObject) + private + fAtachedTo: TglcShaderProgram; + fShaderObj: GLuint; + fShaderType: TglcShaderType; + fCode: String; + fOnLog: TglcShaderLogEvent; + fAttachedTo: TglcShaderProgram; + + function GetInfoLog(aObj: GLuint): String; + function GetCompiled: Boolean; + procedure Log(const aMsg: String); + procedure CreateShaderObj; + procedure AttachTo(const aProgram: TglcShaderProgram); + public + property ShaderObj: GLuint read fShaderObj; + property ShaderType: TglcShaderType read fShaderType; + property Compiled: Boolean read GetCompiled; + property AtachedTo: TglcShaderProgram read fAtachedTo; + property Code: String read fCode write fCode; + property OnLog: TglcShaderLogEvent read fOnLog write fOnLog; + + procedure Compile; + + constructor Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent = nil); + destructor Destroy; override; + end; + TglcShaderObjectList = specialize TFPGObjectList<TglcShaderObject>; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglcShaderProgram = class(TglcShaderObjectList) + private + fProgramObj: GLuint; + fOnLog: TglcShaderLogEvent; + fFilename: String; + + function GetUniformLocation(const aName: String; out aPos: glInt): Boolean; + function GetInfoLog(Obj: GLuint): String; + function GetCompiled: Boolean; + function GetLinked: Boolean; + + procedure CreateProgramObj; + procedure Log(const msg: String); + procedure AttachShaderObj(const aShaderObj: TglcShaderObject); + public + property ProgramObj: GLuint read fProgramObj; + property Filename: String read fFilename; + property Compiled: Boolean read GetCompiled; + property Linked: Boolean read GetLinked; + property OnLog: TglcShaderLogEvent read fOnLog write fOnLog; + + procedure Compile; + procedure Enable; + procedure Disable; + + procedure Add(aShaderObj: TglcShaderObject); + procedure Delete(aID: Integer; aFreeOwnedObj: Boolean = True); + procedure Clear; + + function Uniform1f(const aName: String; aP1: GLFloat): Boolean; + function Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean; + function Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean; + function Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean; + function Uniform1i(const aName: String; aP1: GLint): Boolean; + function Uniform2i(const aName: String; aP1, aP2: GLint): Boolean; + function Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean; + function Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean; + function Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; + function Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; + function Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; + function Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; + function Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; + function Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; + function Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; + function Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; + function UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean; + function UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean; + function UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean; + + function GetUniformfv(const aName: String; aP: PGLfloat): Boolean; + function GetUniformfi(const aName: String; aP: PGLint): Boolean; + procedure BindAttribLocation(const aName: String; const aAttribIndex: GLint); + function GetAttribLocation(const aName: String): Integer; + function HasUniform(const aName: String): Boolean; + + procedure LoadFromFile(const aFilename: String); + procedure LoadFromStream(const aStream: TStream); + procedure SaveToFile(const aFilename: String); + procedure SaveToStream(const aStream: TStream); + + constructor Create(const aLogEvent: TglcShaderLogEvent = nil); + destructor Destroy; override; + end; + +implementation + +uses + RegExpr; + +const + ERROR_STR_VAR_NAME: String = 'can''t find the variable ''%s'' in the program'; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//glShaderObject//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//ließt das Log eines OpenGL-Objekts aus +//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll; +//@result: Log des Objekts; +function TglcShaderObject.GetInfoLog(aObj: GLuint): String; +var + Msg: PChar; + bLen: GLint; + sLen: GLsizei; +begin + bLen := 0; + glGetShaderiv(aObj, GL_INFO_LOG_LENGTH, @bLen); + if bLen > 1 then begin + GetMem(Msg, bLen * SizeOf(Char)); + glGetShaderInfoLog(aObj, bLen, @sLen, Msg); + result := PChar(Msg); + Dispose(Msg); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//ließt aus, ob der Shader ohne Fehler kompiliert wurde +//@result: TRUE wenn ohne Fehler kompiliert, sonst FALSE; +function TglcShaderObject.GetCompiled: Boolean; +var + value: GLint; +begin + glGetShaderiv(fShaderObj, GL_COMPILE_STATUS, @value); + result := (value = GLint(GL_TRUE)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//ruft das Log-Event auf, wenn es gesetzt ist +//@msg: Nachricht die geloggt werden soll; +procedure TglcShaderObject.Log(const aMsg: String); +begin + if Assigned(fOnLog) then begin + fOnLog(self, aMsg); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderObject.CreateShaderObj; +begin + if (fShaderObj <> 0) then + exit; + fShaderObj := glCreateShader(GLenum(fShaderType)); + if fShaderObj = 0 then + raise EglcShader.Create('can''t create ShaderObject'); + Log('shader object created: #'+IntToHex(fShaderObj, 4)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderObject.AttachTo(const aProgram: TglcShaderProgram); +begin + if (aProgram <> fAtachedTo) then begin + CreateShaderObj; + glAttachShader(aProgram.ProgramObj, fShaderObj); + fAttachedTo := aProgram; + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//kompiliert das Shader-Objekt +procedure TglcShaderObject.Compile; +var + len, i: GLint; + List: TStringList; + c: PAnsiChar; +begin + CreateShaderObj; + len := Length(fCode); + if len > 0 then begin + c := PAnsiChar(fCode); + glShaderSource(fShaderObj, 1, @c, @len); + glCompileShader(fShaderObj); + List := TStringList.Create; + List.Text := GetInfoLog(fShaderObj); + for i := 0 to List.Count-1 do + Log(List[i]); + List.Free; + end else Log('error while compiling: no bound shader code'); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//erzeugt das Objekt +//@ShaderType: Typ des Shader-Objekts; +//@LogEvent: Event zum loggen von Fehlern und Ereignissen; +//@raise: EglcShader wenn der Shadertyp unbekannt oder ungültig ist; +constructor TglcShaderObject.Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent); +begin + inherited Create; + fCode := ''; + fOnLog := aLogEvent; + fShaderType := aShaderType; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//gibt das Objekt frei +destructor TglcShaderObject.Destroy; +begin + if (fShaderObj <> 0) then + glDeleteShader(fShaderObj); + inherited Destroy; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//glShaderProgram/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglcShaderProgram.GetUniformLocation(const aName: String; out aPos: glInt): Boolean; +begin + aPos := glGetUniformLocation(fProgramObj, PChar(aName)); + result := (aPos <> -1); + if not result then + Log(StringReplace(ERROR_STR_VAR_NAME, '%s', aName, [rfIgnoreCase, rfReplaceAll])); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//ließt das Log eines OpenGL-Objekts aus +//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll; +//@result: Log des Objekts; +function TglcShaderProgram.GetInfoLog(Obj: GLuint): String; +var + Msg: PChar; + bLen: GLint; + sLen: GLsizei; +begin + bLen := 0; + glGetProgramiv(Obj, GL_INFO_LOG_LENGTH, @bLen); + if bLen > 1 then begin + GetMem(Msg, bLen * SizeOf(Char)); + glGetProgramInfoLog(Obj, bLen, @sLen, Msg); + result := PChar(Msg); + Dispose(Msg); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//prüft ob alle Shader ohne Fehler compiliert wurden +//@result: TRUE wenn alle erfolgreich compiliert, sonst FALSE; +function TglcShaderProgram.GetCompiled: Boolean; +var + i: Integer; +begin + result := (Count > 0); + for i := 0 to Count-1 do + result := result and Items[i].Compiled; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//prüft ob das Programm ohne Fehler gelinkt wurde +//@result: TRUE wenn linken erfolgreich, sonst FASLE; +function TglcShaderProgram.GetLinked: Boolean; +var + value: glInt; +begin + glGetProgramiv(fProgramObj, GL_LINK_STATUS, @value); + result := (value = GLint(GL_TRUE)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderProgram.CreateProgramObj; +begin + if (fProgramObj = 0) then begin + fProgramObj := glCreateProgram(); + Log('shader program created: #'+IntToHex(fProgramObj, 4)); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//ruft das Log-Event auf, wenn es gesetzt ist +//@msg: Nachricht die geloggt werden soll; +procedure TglcShaderProgram.Log(const msg: String); +begin + if Assigned(fOnLog) then begin + fOnLog(self, msg); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderProgram.AttachShaderObj(const aShaderObj: TglcShaderObject); +begin + CreateProgramObj; + aShaderObj.AttachTo(self); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//Kompiliert den Shader-Code +procedure TglcShaderProgram.Compile; +var + i: Integer; + l: TStringList; +begin + CreateProgramObj; + for i := 0 to Count-1 do begin + AttachShaderObj(Items[i]); + Items[i].Compile; + end; + glLinkProgram(fProgramObj); + l := TStringList.Create; + l.Text := GetInfoLog(fProgramObj); + for i := 0 to l.Count-1 do + Log(l[i]); + l.Free; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//aktiviert den Shader +procedure TglcShaderProgram.Enable; +begin + glUseProgram(fProgramObj); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//deaktiviert den Shader +procedure TglcShaderProgram.Disable; +begin + glUseProgram(0); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//fügt der Liste einen Shader hinzu +//@ShaderObj: Objekt, das hinzugefügt werden soll; +procedure TglcShaderProgram.Add(aShaderObj: TglcShaderObject); +begin + inherited Add(aShaderObj); + if (fProgramObj <> 0) then + AttachShaderObj(aShaderObj); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//löscht ein ShaderObjekt aus der Liste +//@ID: Index des Objekts, das gelöscht werden soll; +//@FreeOwnedObj: wenn TRUE wird das gelöschte Objekt freigegeben; +procedure TglcShaderProgram.Delete(aID: Integer; aFreeOwnedObj: Boolean); +var + b: Boolean; +begin + if (aID >= 0) and (aID < Count) and (fProgramObj <> 0) then begin + glDetachShader(fProgramObj, Items[aID].fShaderObj); + Items[aID].fAttachedTo := nil; + end; + b := FreeObjects; + FreeObjects := aFreeOwnedObj; + inherited Delete(aID); + FreeObjects := b; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderProgram.Clear; +begin + while (Count > 0) do + Delete(0); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 1-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform1f(const aName: String; aP1: GLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform1f(pos, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 2-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p2: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform2f(pos, aP1, aP2); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 3-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p2: Wert der Variable, der gesetzt werden soll; +//@p3: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform3f(pos, aP1, aP2, aP3); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 4-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p2: Wert der Variable, der gesetzt werden soll; +//@p3: Wert der Variable, der gesetzt werden soll; +//@p4: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform4f(pos, aP1, aP2, aP3, aP4); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 1-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform1i(const aName: String; aP1: GLint): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform1i(pos, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 2-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform2i(const aName: String; aP1, aP2: GLint): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform2i(pos, aP1, aP2); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 3-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p2: Wert der Variable, der gesetzt werden soll; +//@p3: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform3i(pos, aP1, aP2, aP3); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen 4-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@p1: Wert der Variable, der gesetzt werden soll; +//@p2: Wert der Variable, der gesetzt werden soll; +//@p3: Wert der Variable, der gesetzt werden soll; +//@p4: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform4i(pos, aP1, aP2, aP3, aP4); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 1-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform1fv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 2-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform2fv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 3-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform3fv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 4-Komponenten Float-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform4fv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 1-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform1iv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 2-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform2iv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 3-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform3iv(pos, aCount, aP1); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt einen oder mehrere 4-Komponenten Integer-Vektoren an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@count: Anzahl an Parametern auf die p1 zeigt; +//@p1: Zeiger auf den ersten Wert der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniform4iv(pos, aCount, aP1) ; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt eine oder mehrere 2x2-Matrizen an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert; +//@Count: Anzahl der zu übergebenden Elemente; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniformMatrix2fv(pos, aCount, aTranspose, PGLfloat(aP1)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt eine oder mehrere 3x3-Matrizen an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert; +//@Count: Anzahl der zu übergebenden Elemente; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniformMatrix3fv(pos, aCount, aTranspose, PGLfloat(aP1)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//übergibt eine oder mehrere 4x4-Matrizen an den Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gesetzt werden soll; +//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert; +//@Count: Anzahl der zu übergebenden Elemente; +//@p1: Wert der Variable, der gesetzt werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glUniformMatrix4fv(pos, aCount, aTranspose, PGLfloat(aP1)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//holt den Wert einer Float-Uniform-Variable aus dem Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gelesen werden soll; +//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.GetUniformfv(const aName: String; aP: PGLfloat): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glGetUniformfv(fProgramObj, pos, aP); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//holt den Wert einer Integer-Uniform-Variable aus dem Shader +//!!!Der Shader muss dazu aktiviert sein!!! +//@Name: Name der Variablen die gelesen werden soll; +//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll; +//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden); +function TglcShaderProgram.GetUniformfi(const aName: String; aP: PGLint): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); + if result then + glGetUniformiv(fProgramObj, pos, aP); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderProgram.BindAttribLocation(const aName: String; const aAttribIndex: GLint); +begin + CreateProgramObj; + glBindAttribLocation(fProgramObj, aAttribIndex, PGLchar(aName)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglcShaderProgram.GetAttribLocation(const aName: String): Integer; +begin + result := glGetAttribLocation(fProgramObj, PGLchar(aName)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglcShaderProgram.HasUniform(const aName: String): Boolean; +var + pos: GLint; +begin + result := GetUniformLocation(aName, pos); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//läd den Shader aus einer Datei +//@Filename: Datei aus der gelesen werden soll; +//@raise: EglcShader, wenn Datei nicht vorhanden ist; +procedure TglcShaderProgram.LoadFromFile(const aFilename: String); +var + Stream: TFileStream; +begin + if FileExists(aFilename) then begin + Stream := TFileStream.Create(aFilename, fmOpenRead); + try + LoadFromStream(Stream); + fFilename := aFilename; + finally + Stream.Free; + end; + end else raise EglcShader.Create('TglShaderProgram.LoadFromFile - file not found: '+Filename); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//läd den Shader aus einem Stream +//@Stream: Stream aus dem gelesen werden soll; +//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde; +procedure TglcShaderProgram.LoadFromStream(const aStream: TStream); + + function GetShaderType(const aStr: String): TglcShaderType; + begin + if (aStr = 'GL_VERTEX_SHADER') then + result := TglcShaderType.stVertex + else if (aStr = 'GL_FRAGMENT_SHADER') then + result := TglcShaderType.stFragment +{$IFNDEF OPENGL_ES} + else if (aStr = 'GL_GEOMETRY_SHADER') then + result := TglcShaderType.stGeometry + else if (aStr = 'GL_TESS_CONTROL_SHADER') then + result := TglcShaderType.stTessControl + else if (aStr = 'GL_TESS_EVALUATION_SHADER') then + result := TglcShaderType.stTessEvaluation +{$ENDIF} + else + raise Exception.Create('invalid shader type: ' + aStr); + end; + +var + sl: TStringList; + s: String; + rx: TRegExpr; + LastMatchPos: PtrInt; + st: TglcShaderType; + o: TglcShaderObject; + + procedure AddObj(const aPos: Integer); + begin + if (LastMatchPos > 0) then begin + o := TglcShaderObject.Create(st, fOnLog); + o.Code := Trim(Copy(s, LastMatchPos, aPos - LastMatchPos)); + Add(o); + end; + end; + +begin + if not Assigned(aStream) then + raise EglcShader.Create('TglShaderProgram.SaveToStream - stream is nil'); + + Clear; + sl := TStringList.Create; + rx := TRegExpr.Create; + try + sl.LoadFromStream(aStream); + s := sl.Text; + LastMatchPos := 0; + rx.Expression := '/\*\s*ShaderObject\s*:\s*(GL_[A-Z_]+)\s*\*/\s*$?'; + rx.InputString := s; + + while rx.Exec(LastMatchPos+1) do begin + AddObj(rx.MatchPos[0]); + LastMatchPos := rx.MatchPos[0] + rx.MatchLen[0]; + st := GetShaderType(rx.Match[1]); + end; + AddObj(Length(s)); + finally + rx.Free; + sl.Free; + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//speichert den Shader in einer Datei +//@Filename: Datei in die geschrieben werden soll; +procedure TglcShaderProgram.SaveToFile(const aFilename: String); +var + Stream: TFileStream; +begin + Stream := TFileStream.Create(aFilename, fmCreate); + try + SaveToStream(Stream); + fFilename := aFilename; + finally + Stream.Free; + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//speichert den Shader in einen Stream +//@Stream: Stream in den geschrieben werden soll; +//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde; +//@raise: EglcShader wenn ungültige Datei; +procedure TglcShaderProgram.SaveToStream(const aStream: TStream); +var + i: Integer; + sl: TStringList; + sObj: TglcShaderObject; + + function GetShaderTypeStr(const aShaderType: TglcShaderType): String; + begin + case aShaderType of + TglcShaderType.stVertex: result := 'GL_VERTEX_SHADER'; + TglcShaderType.stFragment: result := 'GL_FRAGMENT_SHADER'; +{$IFNDEF OPENGL_ES} + TglcShaderType.stGeometry: result := 'GL_GEOMETRY_SHADER'; + TglcShaderType.stTessControl: result := 'GL_TESS_CONTROL_SHADER'; + TglcShaderType.stTessEvaluation: result := 'GL_TESS_EVALUATION_SHADER'; +{$ENDIF} + else + result := 'UNKNOWN'; + end; + end; + +begin + if not Assigned(aStream) then + raise EglcShader.Create('TglShaderProgram.LoadFromStream - stream is nil'); + fFilename := ''; + sl := TStringList.Create; + try + for i := 0 to Count-1 do begin + sObj := Items[i]; + sl.Add('/* ShaderObject: ' + GetShaderTypeStr(sObj.ShaderType) + ' */'); + sl.Add(sObj.Code); + end; + sl.SaveToStream(aStream); + finally + sl.Free; + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//erzeugt das Objekt +//@LogEvent: Event zum loggen von Fehlern und Ereignissen; +//@raise: EglcShader wenn OpenGL nicht initialisiert werden konnte; +//@raise: +constructor TglcShaderProgram.Create(const aLogEvent: TglcShaderLogEvent); +begin + inherited Create; + fOnLog := aLogEvent; + fFilename := ''; + fProgramObj := 0; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//gibt das Objekt frei +destructor TglcShaderProgram.Destroy; +begin + if (fProgramObj <> 0) then + glDeleteProgram(fProgramObj); + inherited Destroy; +end; + +end. + diff --git a/uglcTypes.pas b/uglcTypes.pas new file mode 100644 index 0000000..b4ed36f --- /dev/null +++ b/uglcTypes.pas @@ -0,0 +1,362 @@ +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. + diff --git a/uglcVertexArrayObject.pas b/uglcVertexArrayObject.pas new file mode 100644 index 0000000..89e7ac2 --- /dev/null +++ b/uglcVertexArrayObject.pas @@ -0,0 +1,84 @@ +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. + diff --git a/ugluMatrix.pas b/ugluMatrix.pas new file mode 100644 index 0000000..1394a2d --- /dev/null +++ b/ugluMatrix.pas @@ -0,0 +1,318 @@ +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. + diff --git a/ugluQuaternion.pas b/ugluQuaternion.pas new file mode 100644 index 0000000..b806282 --- /dev/null +++ b/ugluQuaternion.pas @@ -0,0 +1,384 @@ +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. + diff --git a/ugluVector.pas b/ugluVector.pas new file mode 100644 index 0000000..bea8190 --- /dev/null +++ b/ugluVector.pas @@ -0,0 +1,1193 @@ +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. +