From: Bergmann89 Date: Sun, 7 Dec 2014 13:43:07 +0000 (+0100) Subject: Merge remote-tracking branch 'glBitmap.DGL/unstable' X-Git-Url: https://git.delphigl.com/?p=LazOpenGLCore.git;a=commitdiff_plain;h=f0b025bf1af258939bfd93cffde3f756a66b49f4;hp=6c6cf89280ab9c80fc6856c612aaabf137d69d04 Merge remote-tracking branch 'glBitmap.DGL/unstable' --- diff --git a/dglOpenGL.pas b/dglOpenGL.pas new file mode 100644 index 0000000..52499fc --- /dev/null +++ b/dglOpenGL.pas @@ -0,0 +1,20329 @@ +{ ============================================================================ + + OpenGL 4.5 - Headertranslation + Version 4.5 + + Supported environments and targets : + - (Win32) Delphi 4 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} + +// 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; + 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 + 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 = 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_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 = 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; 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 >= 4 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} + +finalization + +end. + diff --git a/glBitmap.pas b/glBitmap.pas deleted file mode 100644 index 4ee797b..0000000 --- a/glBitmap.pas +++ /dev/null @@ -1,9096 +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 ------------------------------------------------------------- -Version 3.0.1 ------------------------------------------------------------- -History -20-11-2013 -- refactoring of the complete library -21-03-2010 -- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi - then it's your problem if that isn't true. This prevents the unit for incompatibility - with newer versions of Delphi. -- Problems with D2009+ resolved (Thanks noeska and all i forgot) -- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson) -10-08-2008 -- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson) -- Additional Datapointer for functioninterface now has the name CustomData -24-07-2008 -- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson) -- If you load an texture from an file the property Filename will be set to the name of the file -- Three new properties to attach custom data to the Texture objects - - CustomName (free for use string) - - CustomNameW (free for use widestring) - - CustomDataPointer (free for use pointer to attach other objects or complex structures) -27-05-2008 -- RLE TGAs loaded much faster -26-05-2008 -- fixed some problem with reading RLE TGAs. -21-05-2008 -- function clone now only copys data if it's assigned and now it also copies the ID -- it seems that lazarus dont like comments in comments. -01-05-2008 -- It's possible to set the id of the texture -- define GLB_NO_NATIVE_GL deactivated by default -27-04-2008 -- Now supports the following libraries - - SDL and SDL_image - - libPNG - - libJPEG -- Linux compatibillity via free pascal compatibility (delphi sources optional) -- BMPs now loaded manuel -- Large restructuring -- Property DataPtr now has the name Data -- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR -- Unused Depth removed -- Function FreeData to freeing image data added -24-10-2007 -- ImageID flag of TGAs was ignored. (Thanks Zwoetzen) -15-11-2006 -- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER) -- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel -- Function ReadOpenGLExtension is now only intern -29-06-2006 -- pngimage now disabled by default like all other versions. -26-06-2006 -- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi) -22-06-2006 -- Fixed some Problem with Delphi 5 -- Now uses the newest version of pngimage. Makes saving pngs much easier. -22-03-2006 -- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi) -09-03-2006 -- Internal Format ifDepth8 added -- function GrabScreen now supports all uncompressed formats -31-01-2006 -- AddAlphaFromglBitmap implemented -29-12-2005 -- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID) -28-12-2005 -- Width, Height and Depth internal changed to TglBitmapPixelPosition. - property Width, Height, Depth are still existing and new property Dimension are avail -11-12-2005 -- Added native OpenGL Support. Breaking the dglOpenGL "barrier". -19-10-2005 -- Added function GrabScreen to class TglBitmap2D -18-10-2005 -- Added support to Save images -- Added function Clone to Clone Instance -11-10-2005 -- Functions now works with Cardinals for each channel. Up to 32 Bits per channel. - Usefull for Future -- Several speed optimizations -09-10-2005 -- Internal structure change. Loading of TGA, PNG and DDS improved. - Data, format and size will now set directly with SetDataPtr. -- AddFunc now works with all Types of Images and Formats -- Some Funtions moved to Baseclass TglBitmap -06-10-2005 -- Added Support to decompress DXT3 and DXT5 compressed Images. -- Added Mapping to convert data from one format into an other. -05-10-2005 -- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every - supported Input format (supported by GetPixel) into any uncompresed Format -- Added Support to decompress DXT1 compressed Images. -- SwapColors replaced by ConvertTo -04-10-2005 -- Added Support for compressed DDSs -- Added new internal formats (DXT1, DXT3, DXT5) -29-09-2005 -- Parameter Components renamed to InternalFormat -23-09-2005 -- Some AllocMem replaced with GetMem (little speed change) -- better exception handling. Better protection from memory leaks. -22-09-2005 -- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only) -- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5) -07-09-2005 -- Added support for Grayscale textures -- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8) -10-07-2005 -- Added support for GL_VERSION_2_0 -- Added support for GL_EXT_texture_filter_anisotropic -04-07-2005 -- Function FillWithColor fills the Image with one Color -- Function LoadNormalMap added -30-06-2005 -- ToNormalMap allows to Create an NormalMap from the Alphachannel -- ToNormalMap now supports Sobel (nmSobel) function. -29-06-2005 -- support for RLE Compressed RGB TGAs added -28-06-2005 -- Class TglBitmapNormalMap added to support Normalmap generation -- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures. - 3 Filters are supported. (4 Samples, 3x3 and 5x5) -16-06-2005 -- Method LoadCubeMapClass removed -- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures -- virtual abstract method GenTexture in class TglBitmap now is protected -12-06-2005 -- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal -10-06-2005 -- little enhancement for IsPowerOfTwo -- TglBitmap1D.GenTexture now tests NPOT Textures -06-06-2005 -- some little name changes. All properties or function with Texture in name are - now without texture in name. We have allways texture so we dosn't name it. -03-06-2005 -- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or - TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception. -02-06-2005 -- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle -25-04-2005 -- Function Unbind added -- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture. -21-04-2005 -- class TglBitmapCubeMap added (allows to Create Cubemaps) -29-03-2005 -- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/) - To Enable png's use the define pngimage -22-03-2005 -- New Functioninterface added -- Function GetPixel added -27-11-2004 -- Property BuildMipMaps renamed to MipMap -21-11-2004 -- property Name removed. -- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap -22-05-2004 -- property name added. Only used in glForms! -26-11-2003 -- property FreeDataAfterGenTexture is now available as default (default = true) -- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it) -- function MoveMemory replaced with function Move (little speed change) -- several calculations stored in variables (little speed change) -29-09-2003 -- property BuildMipsMaps added (default = true) - if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps -- property FreeDataAfterGenTexture added (default = true) - if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated. -- parameter DisableOtherTextureUnits of Bind removed -- parameter FreeDataAfterGeneration of GenTextures removed -12-09-2003 -- TglBitmap dosn't delete data if class was destroyed (fixed) -09-09-2003 -- Bind now enables TextureUnits (by params) -- GenTextures can leave data (by param) -- LoadTextures now optimal -03-09-2003 -- Performance optimization in AddFunc -- procedure Bind moved to subclasses -- Added new Class TglBitmap1D to support real OpenGL 1D Textures -19-08-2003 -- Texturefilter and texturewrap now also as defaults - Minfilter = GL_LINEAR_MIPMAP_LINEAR - Magfilter = GL_LINEAR - Wrap(str) = GL_CLAMP_TO_EDGE -- Added new format tfCompressed to create a compressed texture. -- propertys IsCompressed, TextureSize and IsResident added - IsCompressed and TextureSize only contains data from level 0 -18-08-2003 -- Added function AddFunc to add PerPixelEffects to Image -- LoadFromFunc now based on AddFunc -- Invert now based on AddFunc -- SwapColors now based on AddFunc -16-08-2003 -- Added function FlipHorz -15-08-2003 -- Added function LaodFromFunc to create images with function -- Added function FlipVert -- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported -29-07-2003 -- Added Alphafunctions to calculate alpha per function -- Added Alpha from ColorKey using alphafunctions -28-07-2003 -- First full functionally Version of glBitmap -- Support for 24Bit and 32Bit TGA Pictures added -25-07-2003 -- begin of programming -***********************************************************} -unit glBitmap; - -// Please uncomment the defines below to configure the glBitmap to your preferences. -// If you have configured the unit you can uncomment the warning above. -{$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// activate to enable build-in OpenGL support with statically linked methods -// use dglOpenGL.pas if not enabled -{.$DEFINE GLB_NATIVE_OGL_STATIC} - -// activate to enable build-in OpenGL support with dynamically linked methods -// use dglOpenGL.pas if not enabled -{.$DEFINE GLB_NATIVE_OGL_DYNAMIC} - - -// 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} - - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// PRIVATE: do not change anything! ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// 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} - -// native OpenGL Support -{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)} - {$DEFINE GLB_NATIVE_OGL} -{$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} - -// native OpenGL -{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)} - {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'} -{$IFEND} - -// general options -{$EXTENDEDSYNTAX ON} -{$LONGSTRINGS ON} -{$ALIGN ON} -{$IFNDEF FPC} - {$OPTIMIZATION ON} -{$ENDIF} - -interface - -uses - {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} - {$IF DEFINED(GLB_WIN) AND - (DEFINED(GLB_NATIVE_OGL) OR - 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; - -{$IFDEF GLB_NATIVE_OGL} -const - GL_TRUE = 1; - GL_FALSE = 0; - - GL_ZERO = 0; - GL_ONE = 1; - - GL_VERSION = $1F02; - GL_EXTENSIONS = $1F03; - - GL_TEXTURE_1D = $0DE0; - GL_TEXTURE_2D = $0DE1; - GL_TEXTURE_RECTANGLE = $84F5; - - GL_NORMAL_MAP = $8511; - GL_TEXTURE_CUBE_MAP = $8513; - GL_REFLECTION_MAP = $8512; - 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_TEXTURE_WIDTH = $1000; - GL_TEXTURE_HEIGHT = $1001; - GL_TEXTURE_INTERNAL_FORMAT = $1003; - GL_TEXTURE_SWIZZLE_RGBA = $8E46; - - GL_S = $2000; - GL_T = $2001; - GL_R = $2002; - GL_Q = $2003; - - GL_TEXTURE_GEN_S = $0C60; - GL_TEXTURE_GEN_T = $0C61; - GL_TEXTURE_GEN_R = $0C62; - GL_TEXTURE_GEN_Q = $0C63; - - GL_RED = $1903; - GL_GREEN = $1904; - GL_BLUE = $1905; - - GL_ALPHA = $1906; - GL_ALPHA4 = $803B; - GL_ALPHA8 = $803C; - GL_ALPHA12 = $803D; - GL_ALPHA16 = $803E; - - GL_LUMINANCE = $1909; - GL_LUMINANCE4 = $803F; - GL_LUMINANCE8 = $8040; - GL_LUMINANCE12 = $8041; - GL_LUMINANCE16 = $8042; - - GL_LUMINANCE_ALPHA = $190A; - 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_RGB = $1907; - GL_BGR = $80E0; - GL_R3_G3_B2 = $2A10; - GL_RGB4 = $804F; - GL_RGB5 = $8050; - GL_RGB565 = $8D62; - GL_RGB8 = $8051; - GL_RGB10 = $8052; - GL_RGB12 = $8053; - GL_RGB16 = $8054; - - GL_RGBA = $1908; - GL_BGRA = $80E1; - GL_RGBA2 = $8055; - GL_RGBA4 = $8056; - GL_RGB5_A1 = $8057; - GL_RGBA8 = $8058; - GL_RGB10_A2 = $8059; - GL_RGBA12 = $805A; - GL_RGBA16 = $805B; - - GL_DEPTH_COMPONENT = $1902; - GL_DEPTH_COMPONENT16 = $81A5; - GL_DEPTH_COMPONENT24 = $81A6; - GL_DEPTH_COMPONENT32 = $81A7; - - GL_COMPRESSED_RGB = $84ED; - GL_COMPRESSED_RGBA = $84EE; - 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_UNSIGNED_BYTE = $1401; - GL_UNSIGNED_BYTE_3_3_2 = $8032; - GL_UNSIGNED_BYTE_2_3_3_REV = $8362; - - GL_UNSIGNED_SHORT = $1403; - GL_UNSIGNED_SHORT_5_6_5 = $8363; - GL_UNSIGNED_SHORT_4_4_4_4 = $8033; - GL_UNSIGNED_SHORT_5_5_5_1 = $8034; - 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 = $1405; - GL_UNSIGNED_INT_8_8_8_8 = $8035; - GL_UNSIGNED_INT_10_10_10_2 = $8036; - GL_UNSIGNED_INT_8_8_8_8_REV = $8367; - GL_UNSIGNED_INT_2_10_10_10_REV = $8368; - - { Texture Filter } - GL_TEXTURE_MAG_FILTER = $2800; - GL_TEXTURE_MIN_FILTER = $2801; - GL_NEAREST = $2600; - GL_NEAREST_MIPMAP_NEAREST = $2700; - GL_NEAREST_MIPMAP_LINEAR = $2702; - GL_LINEAR = $2601; - GL_LINEAR_MIPMAP_NEAREST = $2701; - GL_LINEAR_MIPMAP_LINEAR = $2703; - - { Texture Wrap } - GL_TEXTURE_WRAP_S = $2802; - GL_TEXTURE_WRAP_T = $2803; - GL_TEXTURE_WRAP_R = $8072; - GL_CLAMP = $2900; - GL_REPEAT = $2901; - GL_CLAMP_TO_EDGE = $812F; - GL_CLAMP_TO_BORDER = $812D; - GL_MIRRORED_REPEAT = $8370; - - { Other } - GL_GENERATE_MIPMAP = $8191; - GL_TEXTURE_BORDER_COLOR = $1004; - GL_MAX_TEXTURE_SIZE = $0D33; - GL_PACK_ALIGNMENT = $0D05; - GL_UNPACK_ALIGNMENT = $0CF5; - - GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; - GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; - GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; - GL_TEXTURE_GEN_MODE = $2500; - -{$IF DEFINED(GLB_WIN)} - libglu = 'glu32.dll'; - libopengl = 'opengl32.dll'; -{$ELSEIF DEFINED(GLB_LINUX)} - libglu = 'libGLU.so.1'; - libopengl = 'libGL.so.1'; -{$IFEND} - -type - GLboolean = BYTEBOOL; - GLint = Integer; - GLsizei = Integer; - GLuint = Cardinal; - GLfloat = Single; - GLenum = Cardinal; - - PGLvoid = Pointer; - PGLboolean = ^GLboolean; - PGLint = ^GLint; - PGLuint = ^GLuint; - PGLfloat = ^GLfloat; - - TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - -{$IF DEFINED(GLB_WIN)} - TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall; -{$ELSEIF DEFINED(GLB_LINUX)} - TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl; - TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl; -{$IFEND} - -{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)} - TglEnable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_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 GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - - TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} - -{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)} - procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - function glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; - - function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; - function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; -{$IFEND} - -var - GL_VERSION_1_2, - GL_VERSION_1_3, - GL_VERSION_1_4, - GL_VERSION_2_0, - GL_VERSION_3_3, - - GL_SGIS_generate_mipmap, - - GL_ARB_texture_border_clamp, - GL_ARB_texture_mirrored_repeat, - GL_ARB_texture_rectangle, - GL_ARB_texture_non_power_of_two, - GL_ARB_texture_swizzle, - GL_ARB_texture_cube_map, - - GL_IBM_texture_mirrored_repeat, - - GL_NV_texture_rectangle, - - GL_EXT_texture_edge_clamp, - GL_EXT_texture_rectangle, - GL_EXT_texture_swizzle, - GL_EXT_texture_cube_map, - GL_EXT_texture_filter_anisotropic: Boolean; - - glCompressedTexImage1D: TglCompressedTexImage1D; - glCompressedTexImage2D: TglCompressedTexImage2D; - glGetCompressedTexImage: TglGetCompressedTexImage; - -{$IF DEFINED(GLB_WIN)} - wglGetProcAddress: TwglGetProcAddress; -{$ELSEIF DEFINED(GLB_LINUX)} - glXGetProcAddress: TglXGetProcAddress; - glXGetProcAddressARB: TglXGetProcAddress; -{$IFEND} - -{$IFDEF GLB_NATIVE_OGL_DYNAMIC} - glEnable: TglEnable; - glDisable: TglDisable; - - glGetString: TglGetString; - glGetIntegerv: TglGetIntegerv; - - glTexParameteri: TglTexParameteri; - glTexParameteriv: TglTexParameteriv; - glTexParameterfv: TglTexParameterfv; - glGetTexParameteriv: TglGetTexParameteriv; - glGetTexParameterfv: TglGetTexParameterfv; - glGetTexLevelParameteriv: TglGetTexLevelParameteriv; - glGetTexLevelParameterfv: TglGetTexLevelParameterfv; - - glTexGeni: TglTexGeni; - glGenTextures: TglGenTextures; - glBindTexture: TglBindTexture; - glDeleteTextures: TglDeleteTextures; - - glAreTexturesResident: TglAreTexturesResident; - glReadPixels: TglReadPixels; - glPixelStorei: TglPixelStorei; - - glTexImage1D: TglTexImage1D; - glTexImage2D: TglTexImage2D; - glGetTexImage: TglGetTexImage; - - gluBuild1DMipmaps: TgluBuild1DMipmaps; - gluBuild2DMipmaps: TgluBuild2DMipmaps; -{$ENDIF} -{$ENDIF} - -type -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapFormat = ( - tfEmpty = 0, //must be smallest value! - - tfAlpha4, - tfAlpha8, - tfAlpha16, - - tfLuminance4, - tfLuminance8, - tfLuminance16, - - tfLuminance4Alpha4, - tfLuminance6Alpha2, - tfLuminance8Alpha8, - tfLuminance12Alpha4, - tfLuminance16Alpha16, - - tfR3G3B2, - tfRGBX4, - tfXRGB4, - tfR5G6B5, - tfRGB5X1, - tfX1RGB5, - tfRGB8, - tfRGBX8, - tfXRGB8, - tfRGB10X2, - tfX2RGB10, - tfRGB16, - - tfRGBA4, - tfARGB4, - tfRGB5A1, - tfA1RGB5, - tfRGBA8, - tfARGB8, - tfRGB10A2, - tfA2RGB10, - tfRGBA16, - - tfBGRX4, - tfXBGR4, - tfB5G6R5, - tfBGR5X1, - tfX1BGR5, - tfBGR8, - tfBGRX8, - tfXBGR8, - tfBGR10X2, - tfX2BGR10, - tfBGR16, - - tfBGRA4, - tfABGR4, - tfBGR5A1, - tfA1BGR5, - tfBGRA8, - tfABGR8, - tfBGR10A2, - tfA2BGR10, - tfBGRA16, - - tfDepth16, - tfDepth24, - tfDepth32, - - tfS3tcDtx1RGBA, - tfS3tcDtx3RGBA, - tfS3tcDtx5RGBA - ); - - TglBitmapFileType = ( - {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} - ftDDS, - ftTGA, - ftBMP); - TglBitmapFileTypes = set of TglBitmapFileType; - - TglBitmapMipMap = ( - mmNone, - mmMipmap, - mmMipmapGlu); - - TglBitmapNormalMapFunc = ( - nm4Samples, - nmSobel, - nm3x3, - nm5x5); - - //////////////////////////////////////////////////////////////////////////////////////////////////// - EglBitmap = class(Exception); - EglBitmapNotSupported = class(Exception); - EglBitmapSizeToLarge = class(EglBitmap); - EglBitmapNonPowerOfTwo = class(EglBitmap); - EglBitmapUnsupportedFormat = class(EglBitmap) - public - constructor Create(const aFormat: TglBitmapFormat); overload; - constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload; - end; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapColorRec = packed record - case Integer of - 0: (r, g, b, a: Cardinal); - 1: (arr: array[0..3] of Cardinal); - end; - - TglBitmapPixelData = packed record - Data, Range: TglBitmapColorRec; - Format: TglBitmapFormat; - end; - PglBitmapPixelData = ^TglBitmapPixelData; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapPixelPositionFields = set of (ffX, ffY); - TglBitmapPixelPosition = record - Fields : TglBitmapPixelPositionFields; - X : Word; - Y : Word; - end; - - TglBitmapFormatDescriptor = class(TObject) - protected - function GetIsCompressed: Boolean; virtual; abstract; - function GetHasRed: Boolean; virtual; abstract; - function GetHasGreen: Boolean; virtual; abstract; - function GetHasBlue: Boolean; virtual; abstract; - function GetHasAlpha: Boolean; virtual; abstract; - - function GetRGBInverted: TglBitmapFormat; virtual; abstract; - function GetWithAlpha: TglBitmapFormat; virtual; abstract; - function GetWithoutAlpha: TglBitmapFormat; virtual; abstract; - function GetOpenGLFormat: TglBitmapFormat; virtual; abstract; - function GetUncompressed: TglBitmapFormat; virtual; abstract; - - function GetglDataFormat: GLenum; virtual; abstract; - function GetglFormat: GLenum; virtual; abstract; - function GetglInternalFormat: GLenum; virtual; abstract; - public - property IsCompressed: Boolean read GetIsCompressed; - property HasRed: Boolean read GetHasRed; - property HasGreen: Boolean read GetHasGreen; - property HasBlue: Boolean read GetHasBlue; - property HasAlpha: Boolean read GetHasAlpha; - - property RGBInverted: TglBitmapFormat read GetRGBInverted; - property WithAlpha: TglBitmapFormat read GetWithAlpha; - property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha; - property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat; - property Uncompressed: TglBitmapFormat read GetUncompressed; - - property glFormat: GLenum read GetglFormat; - property glInternalFormat: GLenum read GetglInternalFormat; - property glDataFormat: GLenum read GetglDataFormat; - public - class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; - end; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmap = class; - TglBitmapFunctionRec = record - Sender: TglBitmap; - Size: TglBitmapPixelPosition; - Position: TglBitmapPixelPosition; - Source: TglBitmapPixelData; - Dest: TglBitmapPixelData; - Args: Pointer; - end; - TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec); - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmap = class - private - function GetFormatDesc: TglBitmapFormatDescriptor; - protected - fID: GLuint; - fTarget: GLuint; - fAnisotropic: Integer; - fDeleteTextureOnFree: Boolean; - fFreeDataOnDestroy: Boolean; - fFreeDataAfterGenTexture: Boolean; - fData: PByte; - fIsResident: GLboolean; - fBorderColor: array[0..3] of Single; - - fDimension: TglBitmapPixelPosition; - fMipMap: TglBitmapMipMap; - fFormat: TglBitmapFormat; - - // Mapping - fPixelSize: Integer; - fRowSize: Integer; - - // Filtering - fFilterMin: GLenum; - fFilterMag: GLenum; - - // TexturWarp - fWrapS: GLenum; - fWrapT: GLenum; - fWrapR: GLenum; - - //Swizzle - fSwizzle: array[0..3] of GLenum; - - // CustomData - fFilename: String; - fCustomName: String; - fCustomNameW: WideString; - fCustomData: Pointer; - - //Getter - function GetWidth: Integer; virtual; - function GetHeight: Integer; virtual; - - function GetFileWidth: Integer; virtual; - function GetFileHeight: Integer; virtual; - - //Setter - procedure SetCustomData(const aValue: Pointer); - procedure SetCustomName(const aValue: String); - procedure SetCustomNameW(const aValue: WideString); - procedure SetFreeDataOnDestroy(const aValue: Boolean); - procedure SetDeleteTextureOnFree(const aValue: Boolean); - procedure SetFormat(const aValue: TglBitmapFormat); - procedure SetFreeDataAfterGenTexture(const aValue: Boolean); - procedure SetID(const aValue: Cardinal); - procedure SetMipMap(const aValue: TglBitmapMipMap); - procedure SetTarget(const aValue: Cardinal); - procedure SetAnisotropic(const aValue: Integer); - - procedure CreateID; - procedure SetupParameters(out aBuildWithGlu: Boolean); - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; //be careful, aData could be freed by this method - procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract; - - function FlipHorz: Boolean; virtual; - function FlipVert: Boolean; virtual; - - property Width: Integer read GetWidth; - property Height: Integer read GetHeight; - - property FileWidth: Integer read GetFileWidth; - property FileHeight: Integer read GetFileHeight; - public - //Properties - property ID: Cardinal read fID write SetID; - property Target: Cardinal read fTarget write SetTarget; - property Format: TglBitmapFormat read fFormat write SetFormat; - property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; - property Anisotropic: Integer read fAnisotropic write SetAnisotropic; - - property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; - - property Filename: String read fFilename; - property CustomName: String read fCustomName write SetCustomName; - property CustomNameW: WideString read fCustomNameW write SetCustomNameW; - property CustomData: Pointer read fCustomData write SetCustomData; - - property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; - property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; - property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; - - property Dimension: TglBitmapPixelPosition read fDimension; - property Data: PByte read fData; - property IsResident: GLboolean read fIsResident; - - procedure AfterConstruction; override; - procedure BeforeDestruction; override; - - procedure PrepareResType(var aResource: String; var aResType: PChar); - - //Load - procedure LoadFromFile(const aFilename: String); - procedure LoadFromStream(const aStream: TStream); virtual; - procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: Pointer = nil); - procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil); - procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); - - //Save - procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); - procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual; - - //Convert - function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload; - function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; - const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload; - public - //Alpha & Co - {$IFDEF GLB_SDL} - function AssignToSurface(out aSurface: PSDL_Surface): Boolean; - function AssignFromSurface(const aSurface: PSDL_Surface): Boolean; - function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; - function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - - {$IFDEF GLB_DELPHI} - function AssignToBitmap(const aBitmap: TBitmap): Boolean; - function AssignFromBitmap(const aBitmap: TBitmap): Boolean; - function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; - function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - - {$IFDEF GLB_LAZARUS} - function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; - function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; - function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; - function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; - const aArgs: Pointer = nil): Boolean; - {$ENDIF} - - function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; - const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - - function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual; - function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - - function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean; - function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean; - function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean; - - function AddAlphaFromValue(const aAlpha: Byte): Boolean; - function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; - function AddAlphaFromValueFloat(const aAlpha: Single): Boolean; - - function RemoveAlpha: Boolean; virtual; - public - //Common - function Clone: TglBitmap; - function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; - procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false); - procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); - procedure FreeData; - - //ColorFill - procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255); - procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF); - procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1); - - //TexParameters - procedure SetFilter(const aMin, aMag: GLenum); - procedure SetWrap( - const S: GLenum = GL_CLAMP_TO_EDGE; - const T: GLenum = GL_CLAMP_TO_EDGE; - const R: GLenum = GL_CLAMP_TO_EDGE); - procedure SetSwizzle(const r, g, b, a: GLenum); - - procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; - procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; - - //Constructors - constructor Create; overload; - constructor Create(const aFileName: String); overload; - constructor Create(const aStream: TStream); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; - constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload; - constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload; - private - {$IFDEF GLB_SUPPORT_PNG_READ} function LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF} - {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF} - - {$IFDEF GLB_SUPPORT_JPEG_READ} function LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF} - - function LoadBMP(const aStream: TStream): Boolean; virtual; - procedure SaveBMP(const aStream: TStream); virtual; - - function LoadTGA(const aStream: TStream): Boolean; virtual; - procedure SaveTGA(const aStream: TStream); virtual; - - function LoadDDS(const aStream: TStream): Boolean; virtual; - procedure SaveDDS(const aStream: TStream); virtual; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmap1D = class(TglBitmap) - protected - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; - procedure UploadData(const aBuildWithGlu: Boolean); - public - property Width; - procedure AfterConstruction; override; - function FlipHorz: Boolean; override; - procedure GenTexture(const aTestTextureSize: Boolean = true); override; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmap2D = class(TglBitmap) - protected - fLines: array of PByte; - function GetScanline(const aIndex: Integer): Pointer; - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; - procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); - public - property Width; - property Height; - property Scanline[const aIndex: Integer]: Pointer read GetScanline; - - procedure AfterConstruction; override; - - procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); - procedure GetDataFromTexture; - procedure GenTexture(const aTestTextureSize: Boolean = true); override; - - function FlipHorz: Boolean; override; - function FlipVert: Boolean; override; - - procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; - const aScale: Single = 2; const aUseAlpha: Boolean = false); - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapCubeMap = class(TglBitmap2D) - protected - fGenMode: Integer; - procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; - public - procedure AfterConstruction; override; - procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); - procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual; - procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapNormalMap = class(TglBitmapCubeMap) - public - procedure AfterConstruction; override; - procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); - end; - -const - NULL_SIZE: TglBitmapPixelPosition = (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); - -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); - -function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition; -function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; - -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; - -{$IFDEF GLB_DELPHI} -function CreateGrayPalette: HPALETTE; -{$ENDIF} - -implementation - -uses - Math, syncobjs, typinfo - {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; - -type -{$IFNDEF fpc} - QWord = System.UInt64; - PQWord = ^QWord; - - PtrInt = Longint; - PtrUInt = DWord; -{$ENDIF} - -//////////////////////////////////////////////////////////////////////////////////////////////////// - TShiftRec = packed record - case Integer of - 0: (r, g, b, a: Byte); - 1: (arr: array[0..3] of Byte); - end; - - TFormatDescriptor = class(TglBitmapFormatDescriptor) - private - function GetRedMask: QWord; - function GetGreenMask: QWord; - function GetBlueMask: QWord; - function GetAlphaMask: QWord; - protected - fFormat: TglBitmapFormat; - fWithAlpha: TglBitmapFormat; - fWithoutAlpha: TglBitmapFormat; - fOpenGLFormat: TglBitmapFormat; - fRGBInverted: TglBitmapFormat; - fUncompressed: TglBitmapFormat; - - fPixelSize: Single; - fIsCompressed: Boolean; - - fRange: TglBitmapColorRec; - fShift: TShiftRec; - - fglFormat: GLenum; - fglInternalFormat: GLenum; - fglDataFormat: GLenum; - - function GetIsCompressed: Boolean; override; - function GetHasRed: Boolean; override; - function GetHasGreen: Boolean; override; - function GetHasBlue: Boolean; override; - function GetHasAlpha: Boolean; override; - - function GetRGBInverted: TglBitmapFormat; override; - function GetWithAlpha: TglBitmapFormat; override; - function GetWithoutAlpha: TglBitmapFormat; override; - function GetOpenGLFormat: TglBitmapFormat; override; - function GetUncompressed: TglBitmapFormat; override; - - function GetglFormat: GLenum; override; - function GetglInternalFormat: GLenum; override; - function GetglDataFormat: GLenum; override; - - function GetComponents: Integer; virtual; - public - property Format: TglBitmapFormat read fFormat; - property Components: Integer read GetComponents; - property PixelSize: Single read fPixelSize; - - property Range: TglBitmapColorRec read fRange; - property Shift: TShiftRec read fShift; - - property RedMask: QWord read GetRedMask; - property GreenMask: QWord read GetGreenMask; - property BlueMask: QWord read GetBlueMask; - property AlphaMask: QWord read GetAlphaMask; - - procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract; - procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; - - function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual; - function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; - - function CreateMappingData: Pointer; virtual; - procedure FreeMappingData(var aMappingData: Pointer); virtual; - - function IsEmpty: Boolean; virtual; - function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): 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 procedure Clear; - class procedure Finalize; - end; - TFormatDescriptorClass = class of TFormatDescriptor; - - TfdEmpty = class(TFormatDescriptor); - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_UB1 = 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; - - TfdLuminance_UB1 = 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; - - TfdUniversal_UB1 = 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; - - TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //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; - - TfdRGB_UB3 = 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; - - TfdBGR_UB3 = 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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_US1 = 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; - - TfdLuminance_US1 = 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; - - TfdUniversal_US1 = 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; - - TfdDepth_US1 = 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; - - TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //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; - - TfdRGB_US3 = 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; - - TfdBGR_US3 = 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; - - TfdRGBA_US4 = class(TfdRGB_US3) //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; - - TfdARGB_US4 = class(TfdRGB_US3) //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; - - TfdBGRA_US4 = class(TfdBGR_US3) //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; - - TfdABGR_US4 = class(TfdBGR_US3) //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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdUniversal_UI1 = 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; - - TfdDepth_UI1 = 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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha4 = class(TfdAlpha_UB1) - constructor Create; override; - end; - - TfdAlpha8 = class(TfdAlpha_UB1) - constructor Create; override; - end; - - TfdAlpha16 = class(TfdAlpha_US1) - constructor Create; override; - end; - - TfdLuminance4 = class(TfdLuminance_UB1) - constructor Create; override; - end; - - TfdLuminance8 = class(TfdLuminance_UB1) - constructor Create; override; - end; - - TfdLuminance16 = class(TfdLuminance_US1) - constructor Create; override; - end; - - TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; - end; - - TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; - end; - - TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; - end; - - TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2) - constructor Create; override; - end; - - TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) - constructor Create; override; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdR3G3B2 = class(TfdUniversal_UB1) - constructor Create; override; - end; - - TfdRGBX4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdXRGB4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdR5G6B5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdRGB5X1 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdX1RGB5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdRGB8 = class(TfdRGB_UB3) - constructor Create; override; - end; - - TfdRGBX8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdXRGB8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdRGB10X2 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdX2RGB10 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdRGB16 = class(TfdRGB_US3) - constructor Create; override; - end; - - TfdRGBA4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdARGB4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdRGB5A1 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdA1RGB5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdRGBA8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdARGB8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdRGB10A2 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdA2RGB10 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdRGBA16 = class(TfdUniversal_UI1) - constructor Create; override; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdBGRX4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdXBGR4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdB5G6R5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdBGR5X1 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdX1BGR5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdBGR8 = class(TfdBGR_UB3) - constructor Create; override; - end; - - TfdBGRX8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdXBGR8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdBGR10X2 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdX2BGR10 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdBGR16 = class(TfdBGR_US3) - constructor Create; override; - end; - - TfdBGRA4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdABGR4 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdBGR5A1 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdA1BGR5 = class(TfdUniversal_US1) - constructor Create; override; - end; - - TfdBGRA8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdABGR8 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdBGR10A2 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdA2BGR10 = class(TfdUniversal_UI1) - constructor Create; override; - end; - - TfdBGRA16 = class(TfdBGRA_US4) - constructor Create; override; - end; - - TfdDepth16 = class(TfdDepth_US1) - constructor Create; override; - end; - - TfdDepth24 = class(TfdDepth_UI1) - constructor Create; override; - end; - - TfdDepth32 = class(TfdDepth_UI1) - constructor Create; 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; - constructor Create; 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; - constructor Create; 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; - constructor Create; override; - end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TbmpBitfieldFormat = class(TFormatDescriptor) - private - procedure SetRedMask (const aValue: QWord); - procedure SetGreenMask(const aValue: QWord); - procedure SetBlueMask (const aValue: QWord); - procedure SetAlphaMask(const aValue: QWord); - - procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); - public - property RedMask: QWord read GetRedMask write SetRedMask; - property GreenMask: QWord read GetGreenMask write SetGreenMask; - property BlueMask: QWord read GetBlueMask write SetBlueMask; - property AlphaMask: QWord read GetAlphaMask write SetAlphaMask; - - property PixelSize: Single read fPixelSize write fPixelSize; - - 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; - public - property PixelSize: Single read fPixelSize write fPixelSize; - property ColorTable: TbmpColorTable read fColorTable write fColorTable; - property Range: TglBitmapColorRec read fRange write fRange; - property Shift: TShiftRec read fShift write fShift; - property Format: TglBitmapFormat read fFormat write fFormat; - - procedure CreateColorTable; - - 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; - - UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.'; - - FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = ( - TfdEmpty, - - TfdAlpha4, - TfdAlpha8, - TfdAlpha16, - - TfdLuminance4, - TfdLuminance8, - TfdLuminance16, - - TfdLuminance4Alpha4, - TfdLuminance6Alpha2, - TfdLuminance8Alpha8, - TfdLuminance12Alpha4, - TfdLuminance16Alpha16, - - TfdR3G3B2, - TfdRGBX4, - TfdXRGB4, - TfdR5G6B5, - TfdRGB5X1, - TfdX1RGB5, - TfdRGB8, - TfdRGBX8, - TfdXRGB8, - TfdRGB10X2, - TfdX2RGB10, - TfdRGB16, - - TfdRGBA4, - TfdARGB4, - TfdRGB5A1, - TfdA1RGB5, - TfdRGBA8, - TfdARGB8, - TfdRGB10A2, - TfdA2RGB10, - TfdRGBA16, - - TfdBGRX4, - TfdXBGR4, - TfdB5G6R5, - TfdBGR5X1, - TfdX1BGR5, - TfdBGR8, - TfdBGRX8, - TfdXBGR8, - TfdBGR10X2, - TfdX2BGR10, - TfdBGR16, - - TfdBGRA4, - TfdABGR4, - TfdBGR5A1, - TfdA1BGR5, - TfdBGRA8, - TfdABGR8, - TfdBGR10A2, - TfdA2BGR10, - TfdBGRA16, - - TfdDepth16, - TfdDepth24, - TfdDepth32, - - 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 glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition; -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 glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; -begin - result.r := r; - result.g := g; - result.b := b; - result.a := a; -end; - -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): 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 glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec; -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 [ - //4 bbp - tfLuminance4, - - //8bpp - tfR3G3B2, tfLuminance8, - - //16bpp - tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, - tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, - - //24bpp - tfBGR8, tfRGB8, - - //32bpp - tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, - tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then - result := result + [ftBMP]; - - if (aFormat in [ - //8 bpp - tfLuminance8, tfAlpha8, - - //16 bpp - tfLuminance16, tfLuminance8Alpha8, - tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, - tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, - - //24 bpp - tfRGB8, tfBGR8, - - //32 bpp - tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then - result := result + [ftTGA]; - - if (aFormat in [ - //8 bpp - tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, - tfR3G3B2, - - //16 bpp - tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, - tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5, - tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5, - - //24 bpp - tfRGB8, tfBGR8, - - //32 bbp - tfLuminance16Alpha16, - tfRGBA8, tfRGB10A2, - tfBGRA8, tfBGR10A2, - - //compressed - tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then - result := result + [ftDDS]; - - {$IFDEF GLB_SUPPORT_PNG_WRITE} - if aFormat in [ - tfAlpha8, tfLuminance8, tfLuminance8Alpha8, - tfRGB8, tfRGBA8, - tfBGR8, tfBGRA8] then - result := result + [ftPNG]; - {$ENDIF} - - {$IFDEF GLB_SUPPORT_JPEG_WRITE} - if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] 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_NATIVE_OGL} -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//OpenGLInitialization/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -var - GL_LibHandle: Pointer = nil; - -function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer; -begin - if not Assigned(aLibHandle) then - aLibHandle := GL_LibHandle; - -{$IF DEFINED(GLB_WIN)} - result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName); - if Assigned(result) then - exit; - - if Assigned(wglGetProcAddress) then - result := wglGetProcAddress(aProcName); -{$ELSEIF DEFINED(GLB_LINUX)} - if Assigned(glXGetProcAddress) then begin - result := glXGetProcAddress(aProcName); - if Assigned(result) then - exit; - end; - - if Assigned(glXGetProcAddressARB) then begin - result := glXGetProcAddressARB(aProcName); - if Assigned(result) then - exit; - end; - - result := dlsym(aLibHandle, aProcName); -{$IFEND} - if not Assigned(result) and aRaiseOnErr then - raise EglBitmap.Create('unable to load procedure form library: ' + aProcName); -end; - -{$IFDEF GLB_NATIVE_OGL_DYNAMIC} -var - GLU_LibHandle: Pointer = nil; - OpenGLInitialized: Boolean; - InitOpenGLCS: TCriticalSection; - -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glbInitOpenGL; - - //////////////////////////////////////////////////////////////////////////////// - function glbLoadLibrary(const aName: PChar): Pointer; - begin - {$IF DEFINED(GLB_WIN)} - result := {%H-}Pointer(LoadLibrary(aName)); - {$ELSEIF DEFINED(GLB_LINUX)} - result := dlopen(Name, RTLD_LAZY); - {$ELSE} - result := nil; - {$IFEND} - end; - - //////////////////////////////////////////////////////////////////////////////// - function glbFreeLibrary(const aLibHandle: Pointer): Boolean; - begin - result := false; - if not Assigned(aLibHandle) then - exit; - - {$IF DEFINED(GLB_WIN)} - Result := FreeLibrary({%H-}HINST(aLibHandle)); - {$ELSEIF DEFINED(GLB_LINUX)} - Result := dlclose(aLibHandle) = 0; - {$IFEND} - end; - -begin - if Assigned(GL_LibHandle) then - glbFreeLibrary(GL_LibHandle); - - if Assigned(GLU_LibHandle) then - glbFreeLibrary(GLU_LibHandle); - - GL_LibHandle := glbLoadLibrary(libopengl); - if not Assigned(GL_LibHandle) then - raise EglBitmap.Create('unable to load library: ' + libopengl); - - GLU_LibHandle := glbLoadLibrary(libglu); - if not Assigned(GLU_LibHandle) then - raise EglBitmap.Create('unable to load library: ' + libglu); - -{$IF DEFINED(GLB_WIN)} - wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); -{$ELSEIF DEFINED(GLB_LINUX)} - glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); - glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); -{$IFEND} - - glEnable := glbGetProcAddress('glEnable'); - glDisable := glbGetProcAddress('glDisable'); - glGetString := glbGetProcAddress('glGetString'); - glGetIntegerv := glbGetProcAddress('glGetIntegerv'); - glTexParameteri := glbGetProcAddress('glTexParameteri'); - glTexParameteriv := glbGetProcAddress('glTexParameteriv'); - glTexParameterfv := glbGetProcAddress('glTexParameterfv'); - glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv'); - glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv'); - glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv'); - glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv'); - glTexGeni := glbGetProcAddress('glTexGeni'); - glGenTextures := glbGetProcAddress('glGenTextures'); - glBindTexture := glbGetProcAddress('glBindTexture'); - glDeleteTextures := glbGetProcAddress('glDeleteTextures'); - glAreTexturesResident := glbGetProcAddress('glAreTexturesResident'); - glReadPixels := glbGetProcAddress('glReadPixels'); - glPixelStorei := glbGetProcAddress('glPixelStorei'); - glTexImage1D := glbGetProcAddress('glTexImage1D'); - glTexImage2D := glbGetProcAddress('glTexImage2D'); - glGetTexImage := glbGetProcAddress('glGetTexImage'); - - gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle); - gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle); -end; -{$ENDIF} - -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glbReadOpenGLExtensions; -var - Buffer: AnsiString; - MajorVersion, MinorVersion: Integer; - - /////////////////////////////////////////////////////////////////////////////////////////// - procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer); - var - Separator: Integer; - begin - aMinor := 0; - aMajor := 0; - - Separator := Pos(AnsiString('.'), aBuffer); - if (Separator > 1) and (Separator < Length(aBuffer)) and - (aBuffer[Separator - 1] in ['0'..'9']) and - (aBuffer[Separator + 1] in ['0'..'9']) then begin - - Dec(Separator); - while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do - Dec(Separator); - - Delete(aBuffer, 1, Separator); - Separator := Pos(AnsiString('.'), aBuffer) + 1; - - while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do - Inc(Separator); - - Delete(aBuffer, Separator, 255); - Separator := Pos(AnsiString('.'), aBuffer); - - aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1)); - aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1)); - end; - end; - - /////////////////////////////////////////////////////////////////////////////////////////// - function CheckExtension(const Extension: AnsiString): Boolean; - var - ExtPos: Integer; - begin - ExtPos := Pos(Extension, Buffer); - result := ExtPos > 0; - if result then - result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']); - end; - - /////////////////////////////////////////////////////////////////////////////////////////// - function CheckVersion(const aMajor, aMinor: Integer): Boolean; - begin - result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor)); - end; - -begin -{$IFDEF GLB_NATIVE_OGL_DYNAMIC} - InitOpenGLCS.Enter; - try - if not OpenGLInitialized then begin - glbInitOpenGL; - OpenGLInitialized := true; - end; - finally - InitOpenGLCS.Leave; - end; -{$ENDIF} - - // Version - Buffer := glGetString(GL_VERSION); - TrimVersionString(Buffer, MajorVersion, MinorVersion); - - GL_VERSION_1_2 := CheckVersion(1, 2); - GL_VERSION_1_3 := CheckVersion(1, 3); - GL_VERSION_1_4 := CheckVersion(1, 4); - GL_VERSION_2_0 := CheckVersion(2, 0); - GL_VERSION_3_3 := CheckVersion(3, 3); - - // Extensions - Buffer := glGetString(GL_EXTENSIONS); - GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp'); - GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two'); - GL_ARB_texture_swizzle := CheckExtension('GL_ARB_texture_swizzle'); - GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map'); - GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle'); - GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat'); - GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp'); - GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic'); - GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle'); - GL_EXT_texture_swizzle := CheckExtension('GL_EXT_texture_swizzle'); - GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map'); - GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle'); - GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat'); - GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap'); - - if GL_VERSION_1_3 then begin - glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1D'); - glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D'); - glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage'); - end else begin - glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB', nil, false); - glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB', nil, false); - glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false); - end; -end; -{$ENDIF} - -{$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 EglBitmapException.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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: GLenum); -begin - aMin := glBitmapDefaultFilterMin; - aMag := glBitmapDefaultFilterMag; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum); -begin - S := glBitmapDefaultWrapS; - T := glBitmapDefaultWrapT; - R := glBitmapDefaultWrapR; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); -begin - r := glDefaultSwizzle[0]; - g := glDefaultSwizzle[1]; - b := glDefaultSwizzle[2]; - a := glDefaultSwizzle[3]; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetRedMask: QWord; -begin - result := fRange.r shl fShift.r; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetGreenMask: QWord; -begin - result := fRange.g shl fShift.g; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetBlueMask: QWord; -begin - result := fRange.b shl fShift.b; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetAlphaMask: QWord; -begin - result := fRange.a shl fShift.a; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetIsCompressed: Boolean; -begin - result := fIsCompressed; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasRed: Boolean; -begin - result := (fRange.r > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasGreen: Boolean; -begin - result := (fRange.g > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasBlue: Boolean; -begin - result := (fRange.b > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasAlpha: Boolean; -begin - result := (fRange.a > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetRGBInverted: TglBitmapFormat; -begin - result := fRGBInverted; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetWithAlpha: TglBitmapFormat; -begin - result := fWithAlpha; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat; -begin - result := fWithoutAlpha; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat; -begin - result := fOpenGLFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetUncompressed: TglBitmapFormat; -begin - result := fUncompressed; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglFormat: GLenum; -begin - result := fglFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglInternalFormat: GLenum; -begin - result := fglInternalFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglDataFormat: GLenum; -begin - result := fglDataFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetComponents: Integer; -var - i: Integer; -begin - result := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - inc(result); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): 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 TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; -begin - result := 0; - if (aWidth <= 0) or (aHeight <= 0) then - exit; - result := Ceil(aWidth * aHeight * fPixelSize); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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 aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; -begin - result := false; - if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then - raise EglBitmap.Create('FormatCheckFormat - All Masks are 0'); - if (aRedMask <> RedMask) then - exit; - if (aGreenMask <> GreenMask) then - exit; - if (aBlueMask <> BlueMask) then - exit; - if (aAlphaMask <> AlphaMask) then - exit; - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData); -begin - FillChar(aPixel{%H-}, SizeOf(aPixel), 0); - aPixel.Data := fRange; - aPixel.Range := fRange; - aPixel.Format := fFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TFormatDescriptor.Create; -begin - inherited Create; - - fFormat := tfEmpty; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfEmpty; - fOpenGLFormat := tfEmpty; - fRGBInverted := tfEmpty; - fUncompressed := tfEmpty; - - fPixelSize := 0.0; - fIsCompressed := false; - - fglFormat := 0; - fglInternalFormat := 0; - fglDataFormat := 0; - - FillChar(fRange, 0, SizeOf(fRange)); - FillChar(fShift, 0, SizeOf(fShift)); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdAlpha_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - aData^ := aPixel.Data.a; - inc(aData); -end; - -procedure TfdAlpha_UB1.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 TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - aData^ := LuminanceWeight(aPixel); - inc(aData); -end; - -procedure TfdLuminance_UB1.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 TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - i: Integer; -begin - aData^ := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); - inc(aData); -end; - -procedure TfdUniversal_UB1.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 fRange.arr[i]; - inc(aData); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - inherited Map(aPixel, aData, aMapData); - aData^ := aPixel.Data.a; - inc(aData); -end; - -procedure TfdLuminanceAlpha_UB2.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 TfdRGB_UB3.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 TfdRGB_UB3.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGR_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGR_UB3.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 TfdBGR_UB3.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdAlpha_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - PWord(aData)^ := aPixel.Data.a; - inc(aData, 2); -end; - -procedure TfdAlpha_US1.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 TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - PWord(aData)^ := LuminanceWeight(aPixel); - inc(aData, 2); -end; - -procedure TfdLuminance_US1.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 TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - i: Integer; -begin - PWord(aData)^ := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); - inc(aData, 2); -end; - -procedure TfdUniversal_US1.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 fRange.arr[i]; - inc(aData, 2); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - PWord(aData)^ := DepthWeight(aPixel); - inc(aData, 2); -end; - -procedure TfdDepth_US1.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 TfdLuminanceAlpha_US2.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 TfdLuminanceAlpha_US2.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 TfdRGB_US3.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 TfdRGB_US3.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGR_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGR_US3.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 TfdBGR_US3.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_US4.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 TfdRGBA_US4.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdARGB_US4.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 TfdARGB_US4.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGRA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_US4.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 TfdBGRA_US4.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdABGR_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdABGR_US4.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 TfdABGR_US4.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdUniversal_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - i: Integer; -begin - PCardinal(aData)^ := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); - inc(aData, 4); -end; - -procedure TfdUniversal_UI1.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 fRange.arr[i]; - inc(aData, 2); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -begin - PCardinal(aData)^ := DepthWeight(aPixel); - inc(aData, 4); -end; - -procedure TfdDepth_UI1.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 := 0; - inc(aData, 4); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TfdAlpha4.Create; -begin - inherited Create; - fPixelSize := 1.0; - fFormat := tfAlpha4; - fWithAlpha := tfAlpha4; - fOpenGLFormat := tfAlpha4; - fRange.a := $FF; - fglFormat := GL_ALPHA; - fglInternalFormat := GL_ALPHA4; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdAlpha8.Create; -begin - inherited Create; - fPixelSize := 1.0; - fFormat := tfAlpha8; - fWithAlpha := tfAlpha8; - fOpenGLFormat := tfAlpha8; - fRange.a := $FF; - fglFormat := GL_ALPHA; - fglInternalFormat := GL_ALPHA8; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdAlpha16.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfAlpha16; - fWithAlpha := tfAlpha16; - fOpenGLFormat := tfAlpha16; - fRange.a := $FFFF; - fglFormat := GL_ALPHA; - fglInternalFormat := GL_ALPHA16; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdLuminance4.Create; -begin - inherited Create; - fPixelSize := 1.0; - fFormat := tfLuminance4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; - fOpenGLFormat := tfLuminance4; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fglFormat := GL_LUMINANCE; - fglInternalFormat := GL_LUMINANCE4; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdLuminance8.Create; -begin - inherited Create; - fPixelSize := 1.0; - fFormat := tfLuminance8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; - fOpenGLFormat := tfLuminance8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fglFormat := GL_LUMINANCE; - fglInternalFormat := GL_LUMINANCE8; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdLuminance16.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfLuminance16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; - fOpenGLFormat := tfLuminance16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fglFormat := GL_LUMINANCE; - fglInternalFormat := GL_LUMINANCE16; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdLuminance4Alpha4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfLuminance4Alpha4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; - fOpenGLFormat := tfLuminance4Alpha4; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 0; - fShift.g := 0; - fShift.b := 0; - fShift.a := 8; - fglFormat := GL_LUMINANCE_ALPHA; - fglInternalFormat := GL_LUMINANCE4_ALPHA4; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdLuminance6Alpha2.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfLuminance6Alpha2; - fWithAlpha := tfLuminance6Alpha2; - fWithoutAlpha := tfLuminance8; - fOpenGLFormat := tfLuminance6Alpha2; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 0; - fShift.g := 0; - fShift.b := 0; - fShift.a := 8; - fglFormat := GL_LUMINANCE_ALPHA; - fglInternalFormat := GL_LUMINANCE6_ALPHA2; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdLuminance8Alpha8.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfLuminance8Alpha8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; - fOpenGLFormat := tfLuminance8Alpha8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 0; - fShift.g := 0; - fShift.b := 0; - fShift.a := 8; - fglFormat := GL_LUMINANCE_ALPHA; - fglInternalFormat := GL_LUMINANCE8_ALPHA8; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdLuminance12Alpha4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfLuminance12Alpha4; - fWithAlpha := tfLuminance12Alpha4; - fWithoutAlpha := tfLuminance16; - fOpenGLFormat := tfLuminance12Alpha4; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fRange.a := $FFFF; - fShift.r := 0; - fShift.g := 0; - fShift.b := 0; - fShift.a := 16; - fglFormat := GL_LUMINANCE_ALPHA; - fglInternalFormat := GL_LUMINANCE12_ALPHA4; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdLuminance16Alpha16.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfLuminance16Alpha16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; - fOpenGLFormat := tfLuminance16Alpha16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fRange.a := $FFFF; - fShift.r := 0; - fShift.g := 0; - fShift.b := 0; - fShift.a := 16; - fglFormat := GL_LUMINANCE_ALPHA; - fglInternalFormat := GL_LUMINANCE16_ALPHA16; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdR3G3B2.Create; -begin - inherited Create; - fPixelSize := 1.0; - fFormat := tfR3G3B2; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfR3G3B2; - fOpenGLFormat := tfR3G3B2; - fRGBInverted := tfEmpty; - fRange.r := $07; - fRange.g := $07; - fRange.b := $04; - fShift.r := 5; - fShift.g := 2; - fShift.b := 0; - fglFormat := GL_RGB; - fglInternalFormat := GL_R3_G3_B2; - fglDataFormat := GL_UNSIGNED_BYTE_3_3_2; -end; - -constructor TfdRGBX4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfRGBX4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGBX4; - fOpenGLFormat := tfRGBX4; - fRGBInverted := tfBGRX4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $00; - fShift.r := 12; - fShift.g := 8; - fShift.b := 4; - fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; -end; - -constructor TfdXRGB4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfXRGB4; - fWithAlpha := tfARGB4; - fWithoutAlpha := tfXRGB4; - fOpenGLFormat := tfXRGB4; - fRGBInverted := tfXBGR4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fShift.r := 8; - fShift.g := 4; - fShift.b := 0; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; -end; - -constructor TfdR5G6B5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfR5G6B5; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfR5G6B5; - fOpenGLFormat := tfR5G6B5; - fRGBInverted := tfB5G6R5; - fRange.r := $1F; - fRange.g := $3F; - fRange.b := $1F; - fShift.r := 11; - fShift.g := 5; - fShift.b := 0; - fglFormat := GL_RGB; - fglInternalFormat := GL_RGB565; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; -end; - -constructor TfdRGB5X1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfRGB5X1; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5X1; - fOpenGLFormat := tfRGB5X1; - fRGBInverted := tfBGR5X1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 11; - fShift.g := 6; - fShift.b := 1; - fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB5; - fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; -end; - -constructor TfdX1RGB5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfX1RGB5; - fWithAlpha := tfA1RGB5; - fWithoutAlpha := tfX1RGB5; - fOpenGLFormat := tfX1RGB5; - fRGBInverted := tfX1BGR5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - 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; -end; - -constructor TfdRGB8.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfRGB8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fOpenGLFormat := tfRGB8; - fRGBInverted := tfBGR8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 16; - fShift.g := 8; - fShift.b := 0; - fglFormat := GL_BGR; // reverse byte order to match little endianess - fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdRGBX8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfRGBX8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGBX8; - fOpenGLFormat := tfRGB8; - fRGBInverted := tfBGRX8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 24; - fShift.g := 16; - fShift.b := 8; - fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; -end; - -constructor TfdXRGB8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfXRGB8; - fWithAlpha := tfXRGB8; - fWithoutAlpha := tfXRGB8; - fOpenGLFormat := tfRGB8; - fRGBInverted := tfXBGR8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 16; - fShift.g := 8; - fShift.b := 0; - 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; -end; - -constructor TfdRGB10X2.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfRGB10X2; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10X2; - fOpenGLFormat := tfRGB10X2; - fRGBInverted := tfBGR10X2; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fShift.r := 22; - fShift.g := 12; - fShift.b := 2; - fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; -end; - -constructor TfdX2RGB10.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfX2RGB10; - fWithAlpha := tfA2RGB10; - fWithoutAlpha := tfX2RGB10; - fOpenGLFormat := tfX2RGB10; - fRGBInverted := tfX2BGR10; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - 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; -end; - -constructor TfdRGB16.Create; -begin - inherited Create; - fPixelSize := 6.0; - fFormat := tfRGB16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fOpenGLFormat := tfRGB16; - fRGBInverted := tfBGR16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 32; - fShift.g := 16; - fShift.b := 0; - fglFormat := GL_BGR; // reverse byte order to match little endianess - fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdRGBA4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfRGBA4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGBX4; - fOpenGLFormat := tfRGBA4; - fRGBInverted := tfBGRA4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $0F; - fShift.r := 12; - fShift.g := 8; - fShift.b := 4; - fShift.a := 0; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGBA4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; -end; - -constructor TfdARGB4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfARGB4; - fWithAlpha := tfARGB4; - fWithoutAlpha := tfXRGB4; - fOpenGLFormat := tfARGB4; - fRGBInverted := tfABGR4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $0F; - fShift.r := 8; - fShift.g := 4; - fShift.b := 0; - fShift.a := 12; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGBA4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; -end; - -constructor TfdRGB5A1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfRGB5A1; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5X1; - fOpenGLFormat := tfRGB5A1; - fRGBInverted := tfBGR5A1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 11; - fShift.g := 6; - fShift.b := 1; - fShift.a := 0; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGB5_A1; - fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; -end; - -constructor TfdA1RGB5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfA1RGB5; - fWithAlpha := tfA1RGB5; - fWithoutAlpha := tfX1RGB5; - fOpenGLFormat := tfA1RGB5; - fRGBInverted := tfA1BGR5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - fShift.a := 15; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB5_A1; - fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; -end; - -constructor TfdRGBA8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfRGBA8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fOpenGLFormat := tfRGBA8; - fRGBInverted := tfBGRA8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 24; - fShift.g := 16; - fShift.b := 8; - fShift.a := 0; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGBA8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; -end; - -constructor TfdARGB8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfARGB8; - fWithAlpha := tfARGB8; - fWithoutAlpha := tfRGB8; - fOpenGLFormat := tfARGB8; - fRGBInverted := tfABGR8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 16; - fShift.g := 8; - fShift.b := 0; - fShift.a := 24; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGBA8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; -end; - -constructor TfdRGB10A2.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfRGB10A2; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10X2; - fOpenGLFormat := tfRGB10A2; - fRGBInverted := tfBGR10A2; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fRange.a := $0003; - fShift.r := 22; - fShift.g := 12; - fShift.b := 2; - fShift.a := 0; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; -end; - -constructor TfdA2RGB10.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfA2RGB10; - fWithAlpha := tfA2RGB10; - fWithoutAlpha := tfX2RGB10; - fOpenGLFormat := tfA2RGB10; - fRGBInverted := tfA2BGR10; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fRange.a := $0003; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - fShift.a := 30; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; -end; - -constructor TfdRGBA16.Create; -begin - inherited Create; - fPixelSize := 8.0; - fFormat := tfRGBA16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fOpenGLFormat := tfRGBA16; - fRGBInverted := tfBGRA16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fRange.a := $FFFF; - fShift.r := 48; - fShift.g := 32; - fShift.b := 16; - fShift.a := 0; - fglFormat := GL_BGRA; // reverse byte order to match little endianess - fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TfdBGRX4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGRX4; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGRX4; - fOpenGLFormat := tfBGRX4; - fRGBInverted := tfRGBX4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fShift.r := 4; - fShift.g := 8; - fShift.b := 12; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; -end; - -constructor TfdXBGR4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfXBGR4; - fWithAlpha := tfABGR4; - fWithoutAlpha := tfXBGR4; - fOpenGLFormat := tfXBGR4; - fRGBInverted := tfXRGB4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $0F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; - 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; -end; - -constructor TfdB5G6R5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfB5G6R5; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfB5G6R5; - fOpenGLFormat := tfB5G6R5; - fRGBInverted := tfR5G6B5; - fRange.r := $1F; - fRange.g := $3F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 11; - fglFormat := GL_RGB; - fglInternalFormat := GL_RGB565; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; -end; - -constructor TfdBGR5X1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR5X1; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5X1; - fOpenGLFormat := tfBGR5X1; - fRGBInverted := tfRGB5X1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 1; - fShift.g := 6; - fShift.b := 11; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB5; - fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; -end; - -constructor TfdX1BGR5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfX1BGR5; - fWithAlpha := tfA1BGR5; - fWithoutAlpha := tfX1BGR5; - fOpenGLFormat := tfX1BGR5; - fRGBInverted := tfX1RGB5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; - 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; -end; - -constructor TfdBGR8.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfBGR8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fOpenGLFormat := tfBGR8; - fRGBInverted := tfRGB8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 0; - fShift.g := 8; - fShift.b := 16; - fglFormat := GL_RGB; // reverse byte order to match little endianess - fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -constructor TfdBGRX8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfBGRX8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGRX8; - fOpenGLFormat := tfBGRX8; - fRGBInverted := tfRGBX8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 8; - fShift.g := 16; - fShift.b := 24; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; -end; - -constructor TfdXBGR8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfXBGR8; - fWithAlpha := tfABGR8; - fWithoutAlpha := tfXBGR8; - fOpenGLFormat := tfXBGR8; - fRGBInverted := tfXRGB8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 0; - fShift.g := 8; - fShift.b := 16; - 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; -end; - -constructor TfdBGR10X2.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfBGR10X2; - fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10X2; - fOpenGLFormat := tfBGR10X2; - fRGBInverted := tfRGB10X2; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fShift.r := 2; - fShift.g := 12; - fShift.b := 22; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; -end; - -constructor TfdX2BGR10.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfX2BGR10; - fWithAlpha := tfA2BGR10; - fWithoutAlpha := tfX2BGR10; - fOpenGLFormat := tfX2BGR10; - fRGBInverted := tfX2RGB10; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; - 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; -end; - -constructor TfdBGR16.Create; -begin - inherited Create; - fPixelSize := 6.0; - fFormat := tfBGR16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fOpenGLFormat := tfBGR16; - fRGBInverted := tfRGB16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 0; - fShift.g := 16; - fShift.b := 32; - fglFormat := GL_RGB; // reverse byte order to match little endianess - fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdBGRA4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGRA4; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGRX4; - fOpenGLFormat := tfBGRA4; - fRGBInverted := tfRGBA4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $0F; - fShift.r := 4; - fShift.g := 8; - fShift.b := 12; - fShift.a := 0; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGBA4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; -end; - -constructor TfdABGR4.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfABGR4; - fWithAlpha := tfABGR4; - fWithoutAlpha := tfXBGR4; - fOpenGLFormat := tfABGR4; - fRGBInverted := tfARGB4; - fRange.r := $0F; - fRange.g := $0F; - fRange.b := $0F; - fRange.a := $0F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; - fShift.a := 12; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGBA4; - fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; -end; - -constructor TfdBGR5A1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR5A1; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5X1; - fOpenGLFormat := tfBGR5A1; - fRGBInverted := tfRGB5A1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 1; - fShift.g := 6; - fShift.b := 11; - fShift.a := 0; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB5_A1; - fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; -end; - -constructor TfdA1BGR5.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfA1BGR5; - fWithAlpha := tfA1BGR5; - fWithoutAlpha := tfX1BGR5; - fOpenGLFormat := tfA1BGR5; - fRGBInverted := tfA1RGB5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; - fShift.a := 15; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGB5_A1; - fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; -end; - -constructor TfdBGRA8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfBGRA8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fOpenGLFormat := tfBGRA8; - fRGBInverted := tfRGBA8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 8; - fShift.g := 16; - fShift.b := 24; - fShift.a := 0; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGBA8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; -end; - -constructor TfdABGR8.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfABGR8; - fWithAlpha := tfABGR8; - fWithoutAlpha := tfBGR8; - fOpenGLFormat := tfABGR8; - fRGBInverted := tfARGB8; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fRange.a := $FF; - fShift.r := 0; - fShift.g := 8; - fShift.b := 16; - fShift.a := 24; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGBA8; - fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; -end; - -constructor TfdBGR10A2.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfBGR10A2; - fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10X2; - fOpenGLFormat := tfBGR10A2; - fRGBInverted := tfRGB10A2; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fRange.a := $0003; - fShift.r := 2; - fShift.g := 12; - fShift.b := 22; - fShift.a := 0; - fglFormat := GL_BGRA; - fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; -end; - -constructor TfdA2BGR10.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfA2BGR10; - fWithAlpha := tfA2BGR10; - fWithoutAlpha := tfX2BGR10; - fOpenGLFormat := tfA2BGR10; - fRGBInverted := tfA2RGB10; - fRange.r := $03FF; - fRange.g := $03FF; - fRange.b := $03FF; - fRange.a := $0003; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; - fShift.a := 30; - fglFormat := GL_RGBA; - fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; -end; - -constructor TfdBGRA16.Create; -begin - inherited Create; - fPixelSize := 8.0; - fFormat := tfBGRA16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fOpenGLFormat := tfBGRA16; - fRGBInverted := tfRGBA16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fRange.a := $FFFF; - fShift.r := 16; - fShift.g := 32; - fShift.b := 48; - fShift.a := 0; - fglFormat := GL_RGBA; // reverse byte order to match little endianess - fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdDepth16.Create; -begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfDepth16; - fWithoutAlpha := tfDepth16; - fOpenGLFormat := tfDepth16; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fRange.a := $FFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglInternalFormat := GL_DEPTH_COMPONENT16; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - -constructor TfdDepth24.Create; -begin - inherited Create; - fPixelSize := 3.0; - fFormat := tfDepth24; - fWithoutAlpha := tfDepth24; - fOpenGLFormat := tfDepth24; - fRange.r := $FFFFFF; - fRange.g := $FFFFFF; - fRange.b := $FFFFFF; - fRange.a := $FFFFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglInternalFormat := GL_DEPTH_COMPONENT24; - fglDataFormat := GL_UNSIGNED_INT; -end; - -constructor TfdDepth32.Create; -begin - inherited Create; - fPixelSize := 4.0; - fFormat := tfDepth32; - fWithoutAlpha := tfDepth32; - fOpenGLFormat := tfDepth32; - fRange.r := $FFFFFFFF; - fRange.g := $FFFFFFFF; - fRange.b := $FFFFFFFF; - fRange.a := $FFFFFFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglInternalFormat := GL_DEPTH_COMPONENT32; - fglDataFormat := GL_UNSIGNED_INT; -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; - -constructor TfdS3tcDtx1RGBA.Create; -begin - inherited Create; - fFormat := tfS3tcDtx1RGBA; - fWithAlpha := tfS3tcDtx1RGBA; - fOpenGLFormat := tfS3tcDtx1RGBA; - fUncompressed := tfRGB5A1; - fPixelSize := 0.5; - fIsCompressed := true; - fglFormat := GL_COMPRESSED_RGBA; - fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - fglDataFormat := GL_UNSIGNED_BYTE; -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; - -constructor TfdS3tcDtx3RGBA.Create; -begin - inherited Create; - fFormat := tfS3tcDtx3RGBA; - fWithAlpha := tfS3tcDtx3RGBA; - fOpenGLFormat := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; - fIsCompressed := true; - fglFormat := GL_COMPRESSED_RGBA; - fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - fglDataFormat := GL_UNSIGNED_BYTE; -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; - -constructor TfdS3tcDtx5RGBA.Create; -begin - inherited Create; - fFormat := tfS3tcDtx3RGBA; - fWithAlpha := tfS3tcDtx3RGBA; - fOpenGLFormat := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; - fIsCompressed := true; - fglFormat := GL_COMPRESSED_RGBA; - fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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 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.SetRedMask(const aValue: QWord); -begin - Update(aValue, fRange.r, fShift.r); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord); -begin - Update(aValue, fRange.g, fShift.g); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord); -begin - Update(aValue, fRange.b, fShift.b); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord); -begin - Update(aValue, fRange.a, fShift.a); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out - aShift: Byte); -begin - aShift := 0; - aRange := 0; - if (aMask = 0) then - exit; - while (aMask > 0) and ((aMask and 1) = 0) do begin - inc(aShift); - aMask := aMask shr 1; - end; - aRange := 1; - while (aMask > 0) do begin - aRange := aRange shl 1; - aMask := aMask shr 1; - end; - dec(aRange); - - fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - data: QWord; - s: Integer; -begin - data := - ((aPixel.Data.r and fRange.r) shl fShift.r) or - ((aPixel.Data.g and fRange.g) shl fShift.g) or - ((aPixel.Data.b and fRange.b) shl fShift.b) or - ((aPixel.Data.a and fRange.a) shl fShift.a); - s := Round(fPixelSize); - case s of - 1: aData^ := data; - 2: PWord(aData)^ := data; - 4: PCardinal(aData)^ := data; - 8: PQWord(aData)^ := data; - else - raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); - end; - inc(aData, s); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -var - data: QWord; - s, i: Integer; -begin - s := Round(fPixelSize); - case s of - 1: data := aData^; - 2: data := PWord(aData)^; - 4: data := PCardinal(aData)^; - 8: data := PQWord(aData)^; - else - raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); - end; - for i := 0 to 3 do - aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i]; - inc(aData, s); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TColorTableFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpColorTableFormat.CreateColorTable; -var - i: Integer; -begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmap.Create(UNSUPPORTED_FORMAT); - - if (Format = tfLuminance4) then - SetLength(fColorTable, 16) - else - SetLength(fColorTable, 256); - - case Format of - tfLuminance4: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := 16 * i; - fColorTable[i].g := 16 * i; - fColorTable[i].b := 16 * i; - fColorTable[i].a := 0; - end; - end; - - tfLuminance8: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := i; - fColorTable[i].g := i; - fColorTable[i].b := i; - fColorTable[i].a := 0; - end; - end; - - tfR3G3B2: begin - 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; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - d: Byte; -begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmap.Create(UNSUPPORTED_FORMAT); - - case Format of - tfLuminance4: begin - if (aMapData = nil) then - aData^ := 0; - d := LuminanceWeight(aPixel) and Range.r; - aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData))); - inc(PByte(aMapData), 4); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData); - aMapData := nil; - end; - end; - - tfLuminance8: begin - aData^ := LuminanceWeight(aPixel) and Range.r; - inc(aData); - end; - - tfR3G3B2: begin - aData^ := Round( - ((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)); - inc(aData); - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -var - idx: QWord; - s: Integer; - bits: Byte; - f: Single; -begin - s := Trunc(fPixelSize); - f := fPixelSize - s; - bits := Round(8 * f); - case s of - 0: idx := (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1); - 1: idx := aData^; - 2: idx := PWord(aData)^; - 4: idx := PCardinal(aData)^; - 8: idx := PQWord(aData)^; - else - raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); - end; - if (idx >= Length(fColorTable)) then - raise EglBitmap.CreateFmt('invalid color index: %d', [idx]); - with fColorTable[idx] do begin - aPixel.Data.r := r; - aPixel.Data.g := g; - aPixel.Data.b := b; - aPixel.Data.a := a; - end; - inc(PByte(aMapData), bits); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData, 1); - dec(PByte(aMapData), 8); - end; - inc(aData, s); -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); -begin - with aFuncRec do begin - Dest.Data := Source.Data; - if ({%H-}PtrUInt(Args) and $1 > 0) then begin - Dest.Data.r := Dest.Data.r xor Dest.Range.r; - Dest.Data.g := Dest.Data.g xor Dest.Range.g; - Dest.Data.b := Dest.Data.b xor Dest.Range.b; - end; - if ({%H-}PtrUInt(Args) and $2 > 0) then begin - Dest.Data.a := Dest.Data.a xor Dest.Range.a; - end; - 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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap - PROTECTED/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor; -begin - result := TFormatDescriptor.Get(Format); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFileWidth: Integer; -begin - result := Max(1, Width); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFileHeight: Integer; -begin - result := Max(1, Height); -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.SetFreeDataOnDestroy(const aValue: Boolean); -begin - if fFreeDataOnDestroy = aValue then - exit; - fFreeDataOnDestroy := aValue; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean); -begin - if fDeleteTextureOnFree = aValue then - exit; - fDeleteTextureOnFree := aValue; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat); -begin - if fFormat = aValue then - exit; - if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then - raise EglBitmapUnsupportedFormat.Create(Format); - SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean); -begin - if fFreeDataAfterGenTexture = aValue then - exit; - fFreeDataAfterGenTexture := 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); -var - MaxAnisotropic: Integer; -begin - fAnisotropic := aValue; - if (ID > 0) then begin - if GL_EXT_texture_filter_anisotropic then begin - if fAnisotropic > 0 then begin - Bind(false); - 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; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.CreateID; -begin - if (ID <> 0) then - glDeleteTextures(1, @fID); - glGenTextures(1, @fID); - Bind(false); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean); -begin - // Set Up Parameters - SetWrap(fWrapS, fWrapT, fWrapR); - SetFilter(fFilterMin, fFilterMag); - SetAnisotropic(fAnisotropic); - 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]); - - // 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, GL_TRUE) - else - aBuildWithGlu := true; - end else if (MipMap = mmMipmapGlu) then - aBuildWithGlu := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - s: Single; -begin - if (Data <> aData) then begin - if (Assigned(Data)) then - FreeMem(Data); - fData := aData; - end; - - if not Assigned(fData) then begin - fPixelSize := 0; - fRowSize := 0; - end else 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; - - s := TFormatDescriptor.Get(aFormat).PixelSize; - fFormat := aFormat; - fPixelSize := Ceil(s); - fRowSize := Ceil(s * aWidth); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.FlipHorz: Boolean; -begin - result := false; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.FlipVert: Boolean; -begin - result := false; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap - PUBLIC////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.AfterConstruction; -begin - inherited AfterConstruction; - - fID := 0; - fTarget := 0; - fIsResident := false; - - fMipMap := glBitmapDefaultMipmap; - fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture; - fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; - - glBitmapGetDefaultFilter (fFilterMin, fFilterMag); - glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); - glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.BeforeDestruction; -var - NewData: PByte; -begin - if fFreeDataOnDestroy then begin - NewData := nil; - SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method - end; - if (fID > 0) and fDeleteTextureOnFree then - glDeleteTextures(1, @fID); - inherited BeforeDestruction; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 TglBitmap.LoadFromFile(const aFilename: String); -var - fs: TFileStream; -begin - if not FileExists(aFilename) then - raise EglBitmap.Create('file does not exist: ' + aFilename); - fFilename := aFilename; - fs := TFileStream.Create(fFilename, fmOpenRead); - try - fs.Position := 0; - LoadFromStream(fs); - finally - fs.Free; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 - raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: Pointer); -var - tmpData: PByte; - size: Integer; -begin - size := TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(tmpData, size); - try - FillChar(tmpData^, size, #$FF); - SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - except - if Assigned(tmpData) then - FreeMem(tmpData); - raise; - end; - AddFunc(Self, aFunc, false, aFormat, aArgs); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 TglBitmap.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 TglBitmap.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 TglBitmap.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); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; -begin - result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddFunc(const aSource: TglBitmap; 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.PixelSize <> DestFD.PixelSize) 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 - SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method - 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; - -{$IFDEF GLB_SDL} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean; -var - pSource, pData, pTempData: PByte; - Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; - - 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 - for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(IntFormat); - if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then - break; - end; - if (IntFormat = tfEmpty) then - raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.'); - end; - - TempWidth := aSurface^.w; - TempHeight := aSurface^.h; - RowSize := FormatDesc.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; - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pData) then - FreeMem(pData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin - aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); - - AlphaInterleave := 0; - case Format of - tfLuminance8Alpha8: - AlphaInterleave := 1; - tfBGRA8, tfRGBA8: - 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 TglBitmap.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 TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean; -var - Row: 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 - tfAlpha8, tfLuminance8: begin - aBitmap.PixelFormat := pf8bit; - aBitmap.Palette := CreateGrayPalette; - end; - tfRGB5A1: - aBitmap.PixelFormat := pf15bit; - tfR5G6B5: - aBitmap.PixelFormat := pf16bit; - tfRGB8, tfBGR8: - aBitmap.PixelFormat := pf24bit; - tfRGBA8, tfBGRA8: - aBitmap.PixelFormat := pf32bit; - else - raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); - end; - - pSource := Data; - for Row := 0 to FileHeight -1 do begin - pData := aBitmap.Scanline[Row]; - Move(pSource^, pData^, fRowSize); - Inc(pSource, fRowSize); - if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A) - SwapRGB(pData, FileWidth, Format = tfRGBA8); - end; - result := true; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 := tfLuminance8; - pf15bit: - IntFormat := tfRGB5A1; - pf16bit: - IntFormat := tfR5G6B5; - pf24bit: - IntFormat := tfBGR8; - pf32bit: - IntFormat := tfBGRA8; - 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; - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pData) then - FreeMem(pData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; -var - Row, Col, AlphaInterleave: Integer; - pSource, pDest: PByte; -begin - result := false; - - if Assigned(Data) then begin - if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin - if Assigned(aBitmap) then begin - aBitmap.PixelFormat := pf8bit; - aBitmap.Palette := CreateGrayPalette; - aBitmap.Width := Width; - aBitmap.Height := Height; - - case Format of - tfLuminance8Alpha8: - AlphaInterleave := 1; - tfRGBA8, tfBGRA8: - 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 TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - tex: TglBitmap2D; -begin - tex := TglBitmap2D.Create; - try - tex.AssignFromBitmap(ABitmap); - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; - end; -end; -{$ENDIF} - -{$IFDEF GLB_LAZARUS} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; -var - rid: TRawImageDescription; - FormatDesc: TFormatDescriptor; -begin - 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 (Format in [ - tfAlpha4, tfAlpha8, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance16, - tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then - rid.Format := ricfGray - else - rid.Format := ricfRGBA; - - rid.Width := Width; - rid.Height := Height; - rid.Depth := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask); - rid.BitOrder := riboBitsInOrder; - rid.ByteOrder := riboLSBFirst; - rid.LineOrder := riloTopToBottom; - rid.LineEnd := rileTight; - rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize); - 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; - - Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); - - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; -var - f: TglBitmapFormat; - FormatDesc: TFormatDescriptor; - ImageData: PByte; - ImageSize: Integer; - CanCopy: Boolean; - - procedure CopyConvert; - var - bfFormat: TbmpBitfieldFormat; - pSourceLine, pDestLine: PByte; - pSourceMD, pDestMD: Pointer; - x, y: Integer; - pixel: TglBitmapPixelData; - begin - bfFormat := TbmpBitfieldFormat.Create; - with aImage.DataDescription do begin - bfFormat.RedMask := ((1 shl RedPrec) - 1) shl RedShift; - bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift; - bfFormat.BlueMask := ((1 shl BluePrec) - 1) shl BlueShift; - bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift; - bfFormat.PixelSize := BitsPerPixel / 8; - 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.PixelSize * 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; - for f := High(f) downto Low(f) do begin - FormatDesc := TFormatDescriptor.Get(f); - with aImage.DataDescription do - if FormatDesc.MaskMatch( - (QWord(1 shl RedPrec )-1) shl RedShift, - (QWord(1 shl GreenPrec)-1) shl GreenShift, - (QWord(1 shl BluePrec )-1) shl BlueShift, - (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then - break; - end; - - if (f = tfEmpty) then - exit; - - CanCopy := - (Round(FormatDesc.PixelSize * 8) = 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; - SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method - except - if Assigned(ImageData) then - FreeMem(ImageData); - raise; - end; - - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - tex: TglBitmap2D; -begin - tex := TglBitmap2D.Create; - try - tex.AssignFromLazIntfImage(aImage); - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; - end; -end; -{$ENDIF} - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.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 TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -begin - if TFormatDescriptor.Get(Format).IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); - result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - tex: TglBitmap2D; -begin - tex := TglBitmap2D.Create(aStream); - try - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; 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(aBitmap)); - Assert(Assigned(aBitmap.Data)); - - if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin - result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha); - - SourceFD := TFormatDescriptor.Get(aBitmap.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 - TempHeight := aBitmap.FileHeight; - TempWidth := aBitmap.FileWidth; - - FuncRec.Sender := Self; - FuncRec.Size := Dimension; - FuncRec.Position.Fields := FuncRec.Size.Fields; - - DestData := Data; - DestData2 := Data; - SourceData := aBitmap.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 TglBitmap.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean; -begin - result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.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 TglBitmap.AddAlphaFromValue(const aAlpha: Byte): Boolean; -begin - result := AddAlphaFromValueFloat(aAlpha / $FF); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; -var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.Clone: TglBitmap; -var - Temp: TglBitmap; - TempPtr: PByte; - Size: Integer; -begin - result := nil; - Temp := (ClassType.Create as TglBitmap); - 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.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method - except - if Assigned(TempPtr) then - FreeMem(TempPtr); - raise; - end; - end else begin - TempPtr := nil; - Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method - end; - - // copy properties - Temp.fID := ID; - Temp.fTarget := Target; - Temp.fFormat := Format; - Temp.fMipMap := MipMap; - Temp.fAnisotropic := Anisotropic; - Temp.fBorderColor := fBorderColor; - Temp.fDeleteTextureOnFree := DeleteTextureOnFree; - Temp.fFreeDataAfterGenTexture := FreeDataAfterGenTexture; - Temp.fFilterMin := fFilterMin; - Temp.fFilterMag := fFilterMag; - Temp.fWrapS := fWrapS; - Temp.fWrapT := fWrapT; - Temp.fWrapR := fWrapR; - Temp.fFilename := fFilename; - Temp.fCustomName := fCustomName; - Temp.fCustomNameW := fCustomNameW; - Temp.fCustomData := fCustomData; - - result := Temp; - except - FreeAndNil(Temp); - raise; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean; -var - SourceFD, DestFD: TFormatDescriptor; - SourcePD, DestPD: TglBitmapPixelData; - ShiftData: TShiftData; - - function DataIsIdentical: Boolean; - begin - result := - (SourceFD.RedMask = DestFD.RedMask) and - (SourceFD.GreenMask = DestFD.GreenMask) and - (SourceFD.BlueMask = DestFD.BlueMask) and - (SourceFD.AlphaMask = DestFD.AlphaMask); - end; - - function CanCopyDirect: Boolean; - begin - result := - ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); - end; - - function CanShift: Boolean; - begin - result := - ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); - end; - - function GetShift(aSource, aDest: Cardinal) : ShortInt; - begin - result := 0; - while (aSource > aDest) and (aSource > 0) do begin - inc(result); - aSource := aSource shr 1; - end; - end; - -begin - if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin - SourceFD := TFormatDescriptor.Get(Format); - DestFD := TFormatDescriptor.Get(aFormat); - - if DataIsIdentical then begin - result := true; - Format := aFormat; - exit; - end; - - SourceFD.PreparePixel(SourcePD); - DestFD.PreparePixel (DestPD); - - if CanCopyDirect then - result := AddFunc(Self, glBitmapConvertCopyFunc, false, aFormat) - else if CanShift then begin - ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); - ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); - ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); - ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); - result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); - end else - result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); - end else - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); -begin - if aUseRGB or aUseAlpha then - AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( - ((Byte(aUseAlpha) and 1) shl 1) or - (Byte(aUseRGB) and 1) )); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FreeData; -var - TempPtr: PByte; -begin - TempPtr := nil; - SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte; - const aAlpha: Byte); -begin - FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 TglBitmap.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; - AddFunc(glBitmapFillWithColorFunc, false, @PixelData); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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(false); - glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag); - - if (MipMap = mmNone) or (Target = GL_TEXTURE_RECTANGLE) 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 - GL_CLAMP: - aTarget := GL_CLAMP; - - GL_REPEAT: - aTarget := GL_REPEAT; - - GL_CLAMP_TO_EDGE: begin - if GL_VERSION_1_2 or GL_EXT_texture_edge_clamp then - aTarget := GL_CLAMP_TO_EDGE - else - aTarget := GL_CLAMP; - end; - - 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; - - GL_MIRRORED_REPEAT: begin - if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then - aTarget := GL_MIRRORED_REPEAT - else - raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); - end; - 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(false); - glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS); - glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT); - glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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 - 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'); - CheckAndSetValue(r, 0); - CheckAndSetValue(g, 1); - CheckAndSetValue(b, 2); - CheckAndSetValue(a, 3); - - if (ID > 0) then begin - Bind(false); - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0])); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); -begin - if aEnableTextureUnit then - glEnable(Target); - if (ID > 0) then - glBindTexture(Target, ID); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean); -begin - if aDisableTextureUnit then - glDisable(Target); - glBindTexture(Target, 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create; -begin - if (ClassType = TglBitmap) then - raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); -{$IFDEF GLB_NATIVE_OGL} - glbReadOpenGLExtensions; -{$ENDIF} - inherited Create; - fFormat := glBitmapGetDefaultFormat; - fFreeDataOnDestroy := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aFileName: String); -begin - Create; - LoadFromFile(aFileName); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aStream: TStream); -begin - Create; - LoadFromStream(aStream); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; 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); - SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - except - if Assigned(aData) then - FreeMem(aData); - raise; - end; - end else begin - SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - fFreeDataOnDestroy := false; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); -begin - Create; - LoadFromFunc(aSize, aFunc, aFormat, aArgs); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); -begin - Create; - LoadFromResource(aInstance, aResource, aResType); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); -begin - Create; - LoadFromResourceID(aInstance, aResourceID, aResType); -end; - -{$IFDEF GLB_SUPPORT_PNG_READ} -{$IF DEFINED(GLB_LAZ_PNG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//PNG///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.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 TglBitmap.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 := tfLuminance8; - PNG_COLOR_TYPE_GRAY_ALPHA: - Format := tfLuminance8Alpha8; - PNG_COLOR_TYPE_RGB: - Format := tfRGB8; - PNG_COLOR_TYPE_RGB_ALPHA: - Format := tfRGBA8; - 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 - SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method - - result := true; - except - if Assigned(png_data) then - FreeMem(png_data); - raise; - end; - end; - finally - quit_libPNG; - end; -end; - -{$ELSEIF DEFINED(GLB_PNGIMAGE)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 := tfLuminance8; - COLOR_GRAYSCALEALPHA: - PngFormat := tfLuminance8Alpha8; - COLOR_RGB: - PngFormat := tfBGR8; - COLOR_RGBALPHA: - PngFormat := tfBGRA8; - 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; - - SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method - - 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 TglBitmap.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 TglBitmap.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 - tfAlpha8, tfLuminance8: - ColorType := PNG_COLOR_TYPE_GRAY; - tfLuminance8Alpha8: - ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; - tfBGR8, tfRGB8: - ColorType := PNG_COLOR_TYPE_RGB; - tfBGRA8, tfRGBA8: - 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 [tfBGR8, tfBGRA8] 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 TglBitmap.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 - tfAlpha8, tfLuminance8: begin - ColorType := COLOR_GRAYSCALE; - PixSize := 1; - Alpha := false; - end; - tfLuminance8Alpha8: begin - ColorType := COLOR_GRAYSCALEALPHA; - PixSize := 1; - Alpha := true; - end; - tfBGR8, tfRGB8: begin - ColorType := COLOR_RGB; - PixSize := 3; - Alpha := false; - end; - tfBGRA8, tfRGBA8: 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 [tfRGB8, tfRGBA8] 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 TglBitmap.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 TglBitmap.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 TglBitmap.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 := tfLuminance8; - end; - else - jpeg.out_color_space := JCS_RGB; - IntFormat := tfRGB8; - 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); - - SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - - result := true; - except - if Assigned(pImage) then - FreeMem(pImage); - raise; - end; - end; - finally - quit_libJPEG; - end; -end; - -{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.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 TglBitmap.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 TglBitmap.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 - tfAlpha8, tfLuminance8: begin - jpeg.input_components := 1; - jpeg.in_color_space := JCS_GRAYSCALE; - end; - tfRGB8, tfBGR8: 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 = tfBGR8 then - GetMem(pTemp2, fRowSize) - else - pTemp2 := pTemp; - - try - for Row := 0 to jpeg.image_height -1 do begin - // prepare row - if Format = tfBGR8 then - CopyRow(pTemp2, pTemp) - else - pTemp2 := pTemp; - - // write row - jpeg_write_scanlines(@jpeg, @pTemp2, 1); - inc(pTemp, fRowSize); - end; - finally - // free memory - if Format = tfBGR8 then - FreeMem(pTemp2); - end; - jpeg_finish_compress(@jpeg); - jpeg_destroy_compress(@jpeg); - finally - quit_libJPEG; - end; -end; - -{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 [tfAlpha8, tfLuminance8]) 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} - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//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 TglBitmap.LoadBMP(const aStream: TStream): Boolean; - - ////////////////////////////////////////////////////////////////////////////////////////////////// - function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat; - 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 - aStream.Read(aMask.r, SizeOf(aMask.r)); - aStream.Read(aMask.g, SizeOf(aMask.g)); - aStream.Read(aMask.b, SizeOf(aMask.b)); - aStream.Read(aMask.a, SizeOf(aMask.a)); - 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 := tfLuminance8; - 16: result := tfX1RGB5; - 24: result := tfRGB8; - 32: result := tfXRGB8; - end; - end; - - function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat; - var - i, c: Integer; - ColorTable: TbmpColorTable; - begin - result := nil; - if (aInfo.biBitCount >= 16) then - exit; - aFormat := tfLuminance8; - 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 := tfRGB8; - end; - - result := TbmpColorTableFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.ColorTable := ColorTable; - result.Range := glBitmapColorRec($FF, $FF, $FF, $00); - end; - - ////////////////////////////////////////////////////////////////////////////////////////////////// - function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec; - const aInfo: TBMPInfo): TbmpBitfieldFormat; - var - TmpFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; - begin - result := nil; - if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin - for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(TmpFormat); - if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin - aFormat := FormatDesc.Format; - exit; - end; - end; - - if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then - aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha; - if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then - aFormat := TFormatDescriptor.Get(aFormat).WithAlpha; - - result := TbmpBitfieldFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.RedMask := aMask.r; - result.GreenMask := aMask.g; - result.BlueMask := aMask.b; - result.AlphaMask := aMask.a; - 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: TglBitmapColorRec; - 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.PixelSize); - 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; - SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method - 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 TglBitmap.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 - tfLuminance4: begin - Info.biBitCount := 4; - Header.bfSize := Header.bfSize + 16 * SizeOf(Cardinal); - Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries - Converter := TbmpColorTableFormat.Create; - with (Converter as TbmpColorTableFormat) do begin - PixelSize := 0.5; - Format := Format; - Range := glBitmapColorRec($F, $F, $F, $0); - CreateColorTable; - end; - end; - - tfR3G3B2, tfLuminance8: 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 - PixelSize := 1; - Format := Format; - if (Format = tfR3G3B2) then begin - Range := glBitmapColorRec($7, $7, $3, $0); - Shift := glBitmapShiftRec(0, 3, 6, 0); - end else - Range := glBitmapColorRec($FF, $FF, $FF, $0); - CreateColorTable; - end; - end; - - tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, - tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin - Info.biBitCount := 16; - Info.biCompression := BMP_COMP_BITFIELDS; - end; - - tfBGR8, tfRGB8: begin - Info.biBitCount := 24; - if (Format = tfRGB8) then - Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values - end; - - tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, - tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: 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.RedMask; - GreenMask := FormatDesc.GreenMask; - BlueMask := FormatDesc.BlueMask; - AlphaMask := FormatDesc.AlphaMask; - 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.PixelSize); - 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 TglBitmap.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 := tfLuminance8; - 8: tgaFormat := tfAlpha8; - end; - - 16: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance16; - 8: tgaFormat := tfLuminance8Alpha8; - end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfX1RGB5; - 1: tgaFormat := tfA1RGB5; - 4: tgaFormat := tfARGB4; - end; - - 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfRGB8; - end; - - 32: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 2: tgaFormat := tfA2RGB10; - 8: tgaFormat := tfARGB8; - 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; - - SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(ImageData) then - FreeMem(ImageData); - raise; - end; - finally - aStream.Position := StartPosition; - end; - end - else aStream.Position := StartPosition; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveTGA(const aStream: TStream); -var - Header: TTGAHeader; - LineSize, Size, x, y: Integer; - Pixel: TglBitmapPixelData; - LineBuf, SourceData, DestData: PByte; - SourceMD, DestMD: Pointer; - FormatDesc: TFormatDescriptor; - Converter: TFormatDescriptor; -begin - if not (ftTGA in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); - - //prepare header - FillChar(Header{%H-}, SizeOf(Header), 0); - - //set ImageType - if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8, - tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then - Header.ImageType := TGA_UNCOMPRESSED_GRAY - else - Header.ImageType := TGA_UNCOMPRESSED_RGB; - - //set BitsPerPixel - if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then - Header.Bpp := 8 - else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8, - tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then - Header.Bpp := 16 - else if (Format in [tfBGR8, tfRGB8]) then - Header.Bpp := 24 - else - Header.Bpp := 32; - - //set AlphaBitCount - case Format of - tfRGB5A1, tfBGR5A1: - Header.ImageDesc := 1 and $F; - tfRGB10A2, tfBGR10A2: - Header.ImageDesc := 2 and $F; - tfRGBA4, tfBGRA4: - Header.ImageDesc := 4 and $F; - tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8: - Header.ImageDesc := 8 and $F; - end; - - Header.Width := Width; - Header.Height := Height; - Header.ImageDesc := Header.ImageDesc or $20; //flip y - aStream.Write(Header, SizeOf(Header)); - - // convert RGB(A) to BGR(A) - Converter := nil; - FormatDesc := TFormatDescriptor.Get(Format); - Size := FormatDesc.GetSize(Dimension); - if Format in [tfRGB5X1, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin - if (FormatDesc.RGBInverted = tfEmpty) then - raise EglBitmap.Create('inverted RGB format is empty'); - Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted); - if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or - (Converter.PixelSize <> FormatDesc.PixelSize) then - raise EglBitmap.Create('invalid inverted RGB format'); - end; - - if Assigned(Converter) then begin - LineSize := FormatDesc.GetSize(Width, 1); - GetMem(LineBuf, LineSize); - SourceMD := FormatDesc.CreateMappingData; - DestMD := Converter.CreateMappingData; - try - SourceData := Data; - for y := 0 to Height-1 do begin - DestData := LineBuf; - for x := 0 to Width-1 do begin - FormatDesc.Unmap(SourceData, Pixel, SourceMD); - Converter.Map(Pixel, DestData, DestMD); - end; - aStream.Write(LineBuf^, LineSize); - end; - finally - FreeMem(LineBuf); - FormatDesc.FreeMappingData(SourceMD); - FormatDesc.FreeMappingData(DestMD); - end; - end else - 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 TglBitmap.LoadDDS(const aStream: TStream): Boolean; -var - Header: TDDSHeader; - Converter: TbmpBitfieldFormat; - - function GetDDSFormat: TglBitmapFormat; - var - fd: TFormatDescriptor; - i: Integer; - Range: TglBitmapColorRec; - 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)) > 0) then begin - // prepare masks - if ((dwFlags and DDPF_LUMINANCE) = 0) then begin - Range.r := dwRBitMask; - Range.g := dwGBitMask; - Range.b := dwBBitMask; - end else begin - Range.r := dwRBitMask; - Range.g := dwRBitMask; - Range.b := dwRBitMask; - end; - Range.a := dwABitMask; - - //find matching format - for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - fd := TFormatDescriptor.Get(result); - if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and - (8 * fd.PixelSize = dwRGBBitCount) then - exit; - end; - - //find format with same Range - for i := 0 to 3 do begin - while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do - Range.arr[i] := Range.arr[i] shr 1; - end; - 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 := tfRGBA8 - else - result := tfRGB8; - end; - - Converter := TbmpBitfieldFormat.Create; - Converter.RedMask := dwRBitMask; - Converter.GreenMask := dwGBitMask; - Converter.BlueMask := dwBBitMask; - Converter.AlphaMask := dwABitMask; - Converter.PixelSize := dwRGBBitCount / 8; - 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.PixelSize); - 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.'); - - SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(NewImage) then - FreeMem(NewImage); - raise; - end; - finally - FreeAndNil(Converter); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.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 (Format in [tfAlpha8, tfAlpha16]) then begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; - end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; - end else begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; - Header.PixelFormat.dwGBitMask := FormatDesc.GreenMask; - Header.PixelFormat.dwBBitMask := FormatDesc.BlueMask; - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; - 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; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - pTemp: pByte; - Size: Integer; -begin - if (aHeight > 1) then begin - Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1); - GetMem(pTemp, Size); - try - Move(aData^, pTemp^, Size); - FreeMem(aData); - aData := nil; - except - FreeMem(pTemp); - raise; - end; - end else - pTemp := aData; - inherited SetDataPointer(pTemp, aFormat, aWidth); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap1D.FlipHorz: Boolean; -var - Col: Integer; - pTempDest, pDest, pSource: PByte; -begin - result := inherited FlipHorz; - if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin - pSource := Data; - GetMem(pDest, fRowSize); - try - pTempDest := pDest; - Inc(pTempDest, fRowSize); - for Col := 0 to Width-1 do begin - dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data - Move(pSource^, pTempDest^, fPixelSize); - Inc(pSource, fPixelSize); - end; - SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pDest) then - FreeMem(pDest); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean); -var - FormatDesc: TFormatDescriptor; -begin - // Upload data - FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed then begin - if not Assigned(glCompressedTexImage1D) then - raise EglBitmap.Create('compressed formats not supported by video adapter'); - glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data) - end else if aBuildWithGlu then - gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) - else - glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data); - - // Free Data - if (FreeDataAfterGenTexture) then - FreeData; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean); -var - BuildWithGlu, TexRec: Boolean; - TexSize: Integer; -begin - if Assigned(Data) then begin - // Check Texture Size - if (aTestTextureSize) then begin - glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - - if (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(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; - - CreateId; - SetupParameters(BuildWithGlu); - UploadData(BuildWithGlu); - glAreTexturesResident(1, @fID, @fIsResident); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.AfterConstruction; -begin - inherited; - Target := GL_TEXTURE_1D; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer; -begin - if (aIndex >= Low(fLines)) and (aIndex <= High(fLines)) then - result := fLines[aIndex] - else - result := nil; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - Idx, LineWidth: Integer; -begin - inherited SetDataPointer(aData, aFormat, aWidth, aHeight); - - if not TFormatDescriptor.Get(aFormat).IsCompressed then begin - // Assigning Data - if Assigned(Data) then begin - SetLength(fLines, GetHeight); - LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize); - - for Idx := 0 to GetHeight-1 do begin - fLines[Idx] := Data; - Inc(fLines[Idx], Idx * LineWidth); - end; - end - else SetLength(fLines, 0); - end else begin - SetLength(fLines, 0); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); -var - FormatDesc: TFormatDescriptor; -begin - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - - FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed then begin - if not Assigned(glCompressedTexImage2D) then - raise EglBitmap.Create('compressed formats not supported by video adapter'); - glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) - end else if aBuildWithGlu then begin - gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, - FormatDesc.glFormat, FormatDesc.glDataFormat, Data) - end else begin - glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, - FormatDesc.glFormat, FormatDesc.glDataFormat, Data); - end; - - // Freigeben - if (FreeDataAfterGenTexture) then - FreeData; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.AfterConstruction; -begin - inherited; - Target := GL_TEXTURE_2D; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); -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); - SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method - FlipVert; - except - if Assigned(Temp) then - FreeMem(Temp); - raise; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GetDataFromTexture; -var - Temp: PByte; - TempWidth, TempHeight: Integer; - TempIntFormat: GLint; - IntFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; -begin - 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); - - IntFormat := tfEmpty; - 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); - SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - except - if Assigned(Temp) then - FreeMem(Temp); - raise; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean); -var - BuildWithGlu, PotTex, TexRec: Boolean; - TexSize: Integer; -begin - if Assigned(Data) then begin - // Check Texture Size - if (aTestTextureSize) then begin - glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - - if ((Height > TexSize) or (Width > 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(Height) and IsPowerOfTwo(Width); - 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.'); - end; - - CreateId; - SetupParameters(BuildWithGlu); - UploadData(Target, BuildWithGlu); - glAreTexturesResident(1, @fID, @fIsResident); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.FlipHorz: Boolean; -var - Col, Row: Integer; - TempDestData, DestData, SourceData: PByte; - ImgSize: Integer; -begin - result := inherited FlipHorz; - if Assigned(Data) then begin - SourceData := Data; - ImgSize := Height * fRowSize; - GetMem(DestData, ImgSize); - try - TempDestData := DestData; - Dec(TempDestData, fRowSize + fPixelSize); - for Row := 0 to Height -1 do begin - Inc(TempDestData, fRowSize * 2); - for Col := 0 to Width -1 do begin - Move(SourceData^, TempDestData^, fPixelSize); - Inc(SourceData, fPixelSize); - Dec(TempDestData, fPixelSize); - end; - end; - SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(DestData) then - FreeMem(DestData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.FlipVert: Boolean; -var - Row: Integer; - TempDestData, DestData, SourceData: PByte; -begin - result := inherited FlipVert; - if Assigned(Data) then begin - SourceData := Data; - GetMem(DestData, Height * fRowSize); - try - TempDestData := DestData; - Inc(TempDestData, Width * (Height -1) * fPixelSize); - for Row := 0 to Height -1 do begin - Move(SourceData^, TempDestData^, fRowSize); - Dec(TempDestData, fRowSize); - Inc(SourceData, fRowSize); - end; - SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(DestData) then - FreeMem(DestData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap2D - ToNormalMap/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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 TglBitmap2D.ToNormalMap(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 - AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) - else - AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec); - AddFunc(glBitmapToNormalMapFunc, false, @Rec); - finally - SetLength(Rec.Heights, 0); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmapCubeMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean); -begin - Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.AfterConstruction; -begin - inherited; - - 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.'); - - SetWrap; - Target := GL_TEXTURE_CUBE_MAP; - fGenMode := GL_REFLECTION_MAP; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean); -var - BuildWithGlu: Boolean; - TexSize: Integer; -begin - if (aTestTextureSize) then begin - glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize); - - if (Height > TexSize) or (Width > TexSize) then - raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); - - if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then - raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.'); - end; - - if (ID = 0) then - CreateID; - SetupParameters(BuildWithGlu); - UploadData(aCubeTarget, BuildWithGlu); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean); -begin - inherited Bind (aEnableTextureUnit); - 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; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean); -begin - inherited Unbind(aDisableTextureUnit); - if aDisableTexCoordsGen then begin - glDisable(GL_TEXTURE_GEN_S); - glDisable(GL_TEXTURE_GEN_T); - glDisable(GL_TEXTURE_GEN_R); - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//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; - fGenMode := GL_NORMAL_MAP; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); -var - Rec: TglBitmapNormalMapRec; - SizeRec: TglBitmapPixelPosition; -begin - Rec.HalfSize := aSize div 2; - FreeDataAfterGenTexture := false; - - SizeRec.Fields := [ffX, ffY]; - SizeRec.X := aSize; - SizeRec.Y := aSize; - - // Positive X - Rec.Func := glBitmapNormalMapPosX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); - - // Negative X - Rec.Func := glBitmapNormalMapNegX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); - - // Positive Y - Rec.Func := glBitmapNormalMapPosY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); - - // Negative Y - Rec.Func := glBitmapNormalMapNegY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); - - // Positive Z - Rec.Func := glBitmapNormalMapPosZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); - - // Negative Z - Rec.Func := glBitmapNormalMapNegZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); -end; - - -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); - glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA); - - glBitmapSetDefaultFreeDataAfterGenTexture(true); - glBitmapSetDefaultDeleteTextureOnFree (true); - - TFormatDescriptor.Init; - -{$IFDEF GLB_NATIVE_OGL_DYNAMIC} - OpenGLInitialized := false; - InitOpenGLCS := TCriticalSection.Create; -{$ENDIF} - -finalization - TFormatDescriptor.Finalize; - -{$IFDEF GLB_NATIVE_OGL} - if Assigned(GL_LibHandle) then - glbFreeLibrary(GL_LibHandle); - -{$IFDEF GLB_NATIVE_OGL_DYNAMIC} - if Assigned(GLU_LibHandle) then - glbFreeLibrary(GLU_LibHandle); - FreeAndNil(InitOpenGLCS); -{$ENDIF} -{$ENDIF} - -end. diff --git a/uglcArrayBuffer.pas b/uglcArrayBuffer.pas new file mode 100644 index 0000000..8a65b62 --- /dev/null +++ b/uglcArrayBuffer.pas @@ -0,0 +1,178 @@ +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 + dglOpenGL, 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; + 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; + result := glMapBuffer(GLenum(fTarget), GLenum(aAccess)); + glcCheckAndRaiseError; +end; + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c] +procedure TglcArrayBuffer.UnmapBuffer; +begin + glUnmapBuffer(GLenum(fTarget)); +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 + if not GL_ARB_Vertex_Buffer_Object then + raise EglcArrayBuffer.Create('Create - VertexBuffer: not supported'); + inherited Create; + glGenBuffers(1, @fID); + fDataCount := 0; + fDataSize := 0; + fTarget := aTarget; +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..996ca54 --- /dev/null +++ b/uglcBitmap.pas @@ -0,0 +1,9102 @@ +{*********************************************************** +glBitmap by Steffen Xonna aka Lossy eX (2003-2008) +http://www.opengl24.de/index.php?cat=header&file=glbitmap + +modified by Delphi OpenGL Community (http://delphigl.com/) (2013) + +------------------------------------------------------------ +The contents of this file are used with permission, subject to +the Mozilla Public License Version 1.1 (the "License"); you may +not use this file except in compliance with the License. You may +obtain a copy of the License at +http://www.mozilla.org/MPL/MPL-1.1.html +------------------------------------------------------------ +Version 3.0.1 +------------------------------------------------------------ +History +20-11-2013 +- refactoring of the complete library +21-03-2010 +- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi + then it's your problem if that isn't true. This prevents the unit for incompatibility + with newer versions of Delphi. +- Problems with D2009+ resolved (Thanks noeska and all i forgot) +- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson) +10-08-2008 +- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson) +- Additional Datapointer for functioninterface now has the name CustomData +24-07-2008 +- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson) +- If you load an texture from an file the property Filename will be set to the name of the file +- Three new properties to attach custom data to the Texture objects + - CustomName (free for use string) + - CustomNameW (free for use widestring) + - CustomDataPointer (free for use pointer to attach other objects or complex structures) +27-05-2008 +- RLE TGAs loaded much faster +26-05-2008 +- fixed some problem with reading RLE TGAs. +21-05-2008 +- function clone now only copys data if it's assigned and now it also copies the ID +- it seems that lazarus dont like comments in comments. +01-05-2008 +- It's possible to set the id of the texture +- define GLB_NO_NATIVE_GL deactivated by default +27-04-2008 +- Now supports the following libraries + - SDL and SDL_image + - libPNG + - libJPEG +- Linux compatibillity via free pascal compatibility (delphi sources optional) +- BMPs now loaded manuel +- Large restructuring +- Property DataPtr now has the name Data +- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR +- Unused Depth removed +- Function FreeData to freeing image data added +24-10-2007 +- ImageID flag of TGAs was ignored. (Thanks Zwoetzen) +15-11-2006 +- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER) +- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel +- Function ReadOpenGLExtension is now only intern +29-06-2006 +- pngimage now disabled by default like all other versions. +26-06-2006 +- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi) +22-06-2006 +- Fixed some Problem with Delphi 5 +- Now uses the newest version of pngimage. Makes saving pngs much easier. +22-03-2006 +- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi) +09-03-2006 +- Internal Format ifDepth8 added +- function GrabScreen now supports all uncompressed formats +31-01-2006 +- AddAlphaFromglBitmap implemented +29-12-2005 +- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID) +28-12-2005 +- Width, Height and Depth internal changed to TglBitmapPixelPosition. + property Width, Height, Depth are still existing and new property Dimension are avail +11-12-2005 +- Added native OpenGL Support. Breaking the dglOpenGL "barrier". +19-10-2005 +- Added function GrabScreen to class TglBitmap2D +18-10-2005 +- Added support to Save images +- Added function Clone to Clone Instance +11-10-2005 +- Functions now works with Cardinals for each channel. Up to 32 Bits per channel. + Usefull for Future +- Several speed optimizations +09-10-2005 +- Internal structure change. Loading of TGA, PNG and DDS improved. + Data, format and size will now set directly with SetDataPtr. +- AddFunc now works with all Types of Images and Formats +- Some Funtions moved to Baseclass TglBitmap +06-10-2005 +- Added Support to decompress DXT3 and DXT5 compressed Images. +- Added Mapping to convert data from one format into an other. +05-10-2005 +- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every + supported Input format (supported by GetPixel) into any uncompresed Format +- Added Support to decompress DXT1 compressed Images. +- SwapColors replaced by ConvertTo +04-10-2005 +- Added Support for compressed DDSs +- Added new internal formats (DXT1, DXT3, DXT5) +29-09-2005 +- Parameter Components renamed to InternalFormat +23-09-2005 +- Some AllocMem replaced with GetMem (little speed change) +- better exception handling. Better protection from memory leaks. +22-09-2005 +- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only) +- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5) +07-09-2005 +- Added support for Grayscale textures +- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8) +10-07-2005 +- Added support for GL_VERSION_2_0 +- Added support for GL_EXT_texture_filter_anisotropic +04-07-2005 +- Function FillWithColor fills the Image with one Color +- Function LoadNormalMap added +30-06-2005 +- ToNormalMap allows to Create an NormalMap from the Alphachannel +- ToNormalMap now supports Sobel (nmSobel) function. +29-06-2005 +- support for RLE Compressed RGB TGAs added +28-06-2005 +- Class TglBitmapNormalMap added to support Normalmap generation +- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures. + 3 Filters are supported. (4 Samples, 3x3 and 5x5) +16-06-2005 +- Method LoadCubeMapClass removed +- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures +- virtual abstract method GenTexture in class TglBitmap now is protected +12-06-2005 +- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal +10-06-2005 +- little enhancement for IsPowerOfTwo +- TglBitmap1D.GenTexture now tests NPOT Textures +06-06-2005 +- some little name changes. All properties or function with Texture in name are + now without texture in name. We have allways texture so we dosn't name it. +03-06-2005 +- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or + TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception. +02-06-2005 +- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle +25-04-2005 +- Function Unbind added +- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture. +21-04-2005 +- class TglBitmapCubeMap added (allows to Create Cubemaps) +29-03-2005 +- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/) + To Enable png's use the define pngimage +22-03-2005 +- New Functioninterface added +- Function GetPixel added +27-11-2004 +- Property BuildMipMaps renamed to MipMap +21-11-2004 +- property Name removed. +- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap +22-05-2004 +- property name added. Only used in glForms! +26-11-2003 +- property FreeDataAfterGenTexture is now available as default (default = true) +- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it) +- function MoveMemory replaced with function Move (little speed change) +- several calculations stored in variables (little speed change) +29-09-2003 +- property BuildMipsMaps added (default = true) + if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps +- property FreeDataAfterGenTexture added (default = true) + if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated. +- parameter DisableOtherTextureUnits of Bind removed +- parameter FreeDataAfterGeneration of GenTextures removed +12-09-2003 +- TglBitmap dosn't delete data if class was destroyed (fixed) +09-09-2003 +- Bind now enables TextureUnits (by params) +- GenTextures can leave data (by param) +- LoadTextures now optimal +03-09-2003 +- Performance optimization in AddFunc +- procedure Bind moved to subclasses +- Added new Class TglBitmap1D to support real OpenGL 1D Textures +19-08-2003 +- Texturefilter and texturewrap now also as defaults + Minfilter = GL_LINEAR_MIPMAP_LINEAR + Magfilter = GL_LINEAR + Wrap(str) = GL_CLAMP_TO_EDGE +- Added new format tfCompressed to create a compressed texture. +- propertys IsCompressed, TextureSize and IsResident added + IsCompressed and TextureSize only contains data from level 0 +18-08-2003 +- Added function AddFunc to add PerPixelEffects to Image +- LoadFromFunc now based on AddFunc +- Invert now based on AddFunc +- SwapColors now based on AddFunc +16-08-2003 +- Added function FlipHorz +15-08-2003 +- Added function LaodFromFunc to create images with function +- Added function FlipVert +- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported +29-07-2003 +- Added Alphafunctions to calculate alpha per function +- Added Alpha from ColorKey using alphafunctions +28-07-2003 +- First full functionally Version of glBitmap +- Support for 24Bit and 32Bit TGA Pictures added +25-07-2003 +- begin of programming +***********************************************************} +unit uglcBitmap; + +// Please uncomment the defines below to configure the glBitmap to your preferences. +// If you have configured the unit you can uncomment the warning above. +{.$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// activate to enable build-in OpenGL support with statically linked methods +// use dglOpenGL.pas if not enabled +{.$DEFINE GLB_NATIVE_OGL_STATIC} + +// activate to enable build-in OpenGL support with dynamically linked methods +// use dglOpenGL.pas if not enabled +{.$DEFINE GLB_NATIVE_OGL_DYNAMIC} + + +// 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} + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// PRIVATE: do not change anything! ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// 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} + +// native OpenGL Support +{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + {$DEFINE GLB_NATIVE_OGL} +{$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} + +// native OpenGL +{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'} +{$IFEND} + +// general options +{$EXTENDEDSYNTAX ON} +{$LONGSTRINGS ON} +{$ALIGN ON} +{$IFNDEF FPC} + {$OPTIMIZATION ON} +{$ENDIF} + +interface + +uses + {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} + {$IF DEFINED(GLB_WIN) AND + (DEFINED(GLB_NATIVE_OGL) OR + 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; + +{$IFDEF GLB_NATIVE_OGL} +const + GL_TRUE = 1; + GL_FALSE = 0; + + GL_ZERO = 0; + GL_ONE = 1; + + GL_VERSION = $1F02; + GL_EXTENSIONS = $1F03; + + GL_TEXTURE_1D = $0DE0; + GL_TEXTURE_2D = $0DE1; + GL_TEXTURE_RECTANGLE = $84F5; + + GL_NORMAL_MAP = $8511; + GL_TEXTURE_CUBE_MAP = $8513; + GL_REFLECTION_MAP = $8512; + 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_TEXTURE_WIDTH = $1000; + GL_TEXTURE_HEIGHT = $1001; + GL_TEXTURE_INTERNAL_FORMAT = $1003; + GL_TEXTURE_SWIZZLE_RGBA = $8E46; + + GL_S = $2000; + GL_T = $2001; + GL_R = $2002; + GL_Q = $2003; + + GL_TEXTURE_GEN_S = $0C60; + GL_TEXTURE_GEN_T = $0C61; + GL_TEXTURE_GEN_R = $0C62; + GL_TEXTURE_GEN_Q = $0C63; + + GL_RED = $1903; + GL_GREEN = $1904; + GL_BLUE = $1905; + + GL_ALPHA = $1906; + GL_ALPHA4 = $803B; + GL_ALPHA8 = $803C; + GL_ALPHA12 = $803D; + GL_ALPHA16 = $803E; + + GL_LUMINANCE = $1909; + GL_LUMINANCE4 = $803F; + GL_LUMINANCE8 = $8040; + GL_LUMINANCE12 = $8041; + GL_LUMINANCE16 = $8042; + + GL_LUMINANCE_ALPHA = $190A; + 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_RGB = $1907; + GL_BGR = $80E0; + GL_R3_G3_B2 = $2A10; + GL_RGB4 = $804F; + GL_RGB5 = $8050; + GL_RGB565 = $8D62; + GL_RGB8 = $8051; + GL_RGB10 = $8052; + GL_RGB12 = $8053; + GL_RGB16 = $8054; + + GL_RGBA = $1908; + GL_BGRA = $80E1; + GL_RGBA2 = $8055; + GL_RGBA4 = $8056; + GL_RGB5_A1 = $8057; + GL_RGBA8 = $8058; + GL_RGB10_A2 = $8059; + GL_RGBA12 = $805A; + GL_RGBA16 = $805B; + + GL_DEPTH_COMPONENT = $1902; + GL_DEPTH_COMPONENT16 = $81A5; + GL_DEPTH_COMPONENT24 = $81A6; + GL_DEPTH_COMPONENT32 = $81A7; + + GL_COMPRESSED_RGB = $84ED; + GL_COMPRESSED_RGBA = $84EE; + 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_UNSIGNED_BYTE = $1401; + GL_UNSIGNED_BYTE_3_3_2 = $8032; + GL_UNSIGNED_BYTE_2_3_3_REV = $8362; + + GL_UNSIGNED_SHORT = $1403; + GL_UNSIGNED_SHORT_5_6_5 = $8363; + GL_UNSIGNED_SHORT_4_4_4_4 = $8033; + GL_UNSIGNED_SHORT_5_5_5_1 = $8034; + 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 = $1405; + GL_UNSIGNED_INT_8_8_8_8 = $8035; + GL_UNSIGNED_INT_10_10_10_2 = $8036; + GL_UNSIGNED_INT_8_8_8_8_REV = $8367; + GL_UNSIGNED_INT_2_10_10_10_REV = $8368; + + { Texture Filter } + GL_TEXTURE_MAG_FILTER = $2800; + GL_TEXTURE_MIN_FILTER = $2801; + GL_NEAREST = $2600; + GL_NEAREST_MIPMAP_NEAREST = $2700; + GL_NEAREST_MIPMAP_LINEAR = $2702; + GL_LINEAR = $2601; + GL_LINEAR_MIPMAP_NEAREST = $2701; + GL_LINEAR_MIPMAP_LINEAR = $2703; + + { Texture Wrap } + GL_TEXTURE_WRAP_S = $2802; + GL_TEXTURE_WRAP_T = $2803; + GL_TEXTURE_WRAP_R = $8072; + GL_CLAMP = $2900; + GL_REPEAT = $2901; + GL_CLAMP_TO_EDGE = $812F; + GL_CLAMP_TO_BORDER = $812D; + GL_MIRRORED_REPEAT = $8370; + + { Other } + GL_GENERATE_MIPMAP = $8191; + GL_TEXTURE_BORDER_COLOR = $1004; + GL_MAX_TEXTURE_SIZE = $0D33; + GL_PACK_ALIGNMENT = $0D05; + GL_UNPACK_ALIGNMENT = $0CF5; + + GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; + GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; + GL_TEXTURE_GEN_MODE = $2500; + +{$IF DEFINED(GLB_WIN)} + libglu = 'glu32.dll'; + libopengl = 'opengl32.dll'; +{$ELSEIF DEFINED(GLB_LINUX)} + libglu = 'libGLU.so.1'; + libopengl = 'libGL.so.1'; +{$IFEND} + +type + GLboolean = BYTEBOOL; + GLint = Integer; + GLsizei = Integer; + GLuint = Cardinal; + GLfloat = Single; + GLenum = Cardinal; + + PGLvoid = Pointer; + PGLboolean = ^GLboolean; + PGLint = ^GLint; + PGLuint = ^GLuint; + PGLfloat = ^GLfloat; + + TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +{$IF DEFINED(GLB_WIN)} + TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall; +{$ELSEIF DEFINED(GLB_LINUX)} + TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl; + TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl; +{$IFEND} + +{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + TglEnable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_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 GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)} + procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + function glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; + function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; +{$IFEND} + +var + GL_VERSION_1_2, + GL_VERSION_1_3, + GL_VERSION_1_4, + GL_VERSION_2_0, + GL_VERSION_3_3, + + GL_SGIS_generate_mipmap, + + GL_ARB_texture_border_clamp, + GL_ARB_texture_mirrored_repeat, + GL_ARB_texture_rectangle, + GL_ARB_texture_non_power_of_two, + GL_ARB_texture_swizzle, + GL_ARB_texture_cube_map, + + GL_IBM_texture_mirrored_repeat, + + GL_NV_texture_rectangle, + + GL_EXT_texture_edge_clamp, + GL_EXT_texture_rectangle, + GL_EXT_texture_swizzle, + GL_EXT_texture_cube_map, + GL_EXT_texture_filter_anisotropic: Boolean; + + glCompressedTexImage1D: TglCompressedTexImage1D; + glCompressedTexImage2D: TglCompressedTexImage2D; + glGetCompressedTexImage: TglGetCompressedTexImage; + +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress: TwglGetProcAddress; +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress: TglXGetProcAddress; + glXGetProcAddressARB: TglXGetProcAddress; +{$IFEND} + +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + glEnable: TglEnable; + glDisable: TglDisable; + + glGetString: TglGetString; + glGetIntegerv: TglGetIntegerv; + + glTexParameteri: TglTexParameteri; + glTexParameteriv: TglTexParameteriv; + glTexParameterfv: TglTexParameterfv; + glGetTexParameteriv: TglGetTexParameteriv; + glGetTexParameterfv: TglGetTexParameterfv; + glGetTexLevelParameteriv: TglGetTexLevelParameteriv; + glGetTexLevelParameterfv: TglGetTexLevelParameterfv; + + glTexGeni: TglTexGeni; + glGenTextures: TglGenTextures; + glBindTexture: TglBindTexture; + glDeleteTextures: TglDeleteTextures; + + glAreTexturesResident: TglAreTexturesResident; + glReadPixels: TglReadPixels; + glPixelStorei: TglPixelStorei; + + glTexImage1D: TglTexImage1D; + glTexImage2D: TglTexImage2D; + glGetTexImage: TglGetTexImage; + + gluBuild1DMipmaps: TgluBuild1DMipmaps; + gluBuild2DMipmaps: TgluBuild2DMipmaps; +{$ENDIF} +{$ENDIF} + +type +//////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapFormat = ( + tfEmpty = 0, //must be smallest value! + + tfAlpha4, + tfAlpha8, + tfAlpha16, + + tfLuminance4, + tfLuminance8, + tfLuminance16, + + tfLuminance4Alpha4, + tfLuminance6Alpha2, + tfLuminance8Alpha8, + tfLuminance12Alpha4, + tfLuminance16Alpha16, + + tfR3G3B2, + tfRGBX4, + tfXRGB4, + tfR5G6B5, + tfRGB5X1, + tfX1RGB5, + tfRGB8, + tfRGBX8, + tfXRGB8, + tfRGB10X2, + tfX2RGB10, + tfRGB16, + + tfRGBA4, + tfARGB4, + tfRGB5A1, + tfA1RGB5, + tfRGBA8, + tfARGB8, + tfRGB10A2, + tfA2RGB10, + tfRGBA16, + + tfBGRX4, + tfXBGR4, + tfB5G6R5, + tfBGR5X1, + tfX1BGR5, + tfBGR8, + tfBGRX8, + tfXBGR8, + tfBGR10X2, + tfX2BGR10, + tfBGR16, + + tfBGRA4, + tfABGR4, + tfBGR5A1, + tfA1BGR5, + tfBGRA8, + tfABGR8, + tfBGR10A2, + tfA2BGR10, + tfBGRA16, + + tfDepth16, + tfDepth24, + tfDepth32, + + tfS3tcDtx1RGBA, + tfS3tcDtx3RGBA, + tfS3tcDtx5RGBA + ); + + TglBitmapFileType = ( + {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF} + {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} + ftDDS, + ftTGA, + ftBMP); + TglBitmapFileTypes = set of TglBitmapFileType; + + TglBitmapMipMap = ( + mmNone, + mmMipmap, + mmMipmapGlu); + + TglBitmapNormalMapFunc = ( + nm4Samples, + nmSobel, + nm3x3, + nm5x5); + + //////////////////////////////////////////////////////////////////////////////////////////////////// + EglBitmap = class(Exception); + EglBitmapNotSupported = class(Exception); + EglBitmapSizeToLarge = class(EglBitmap); + EglBitmapNonPowerOfTwo = class(EglBitmap); + EglBitmapUnsupportedFormat = class(EglBitmap) + public + constructor Create(const aFormat: TglBitmapFormat); overload; + constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload; + end; + +//////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapColorRec = packed record + case Integer of + 0: (r, g, b, a: Cardinal); + 1: (arr: array[0..3] of Cardinal); + end; + + TglBitmapPixelData = packed record + Data, Range: TglBitmapColorRec; + Format: TglBitmapFormat; + end; + PglBitmapPixelData = ^TglBitmapPixelData; + +//////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapPixelPositionFields = set of (ffX, ffY); + TglBitmapPixelPosition = record + Fields : TglBitmapPixelPositionFields; + X : Word; + Y : Word; + end; + + TglBitmapFormatDescriptor = class(TObject) + protected + function GetIsCompressed: Boolean; virtual; abstract; + function GetHasRed: Boolean; virtual; abstract; + function GetHasGreen: Boolean; virtual; abstract; + function GetHasBlue: Boolean; virtual; abstract; + function GetHasAlpha: Boolean; virtual; abstract; + + function GetRGBInverted: TglBitmapFormat; virtual; abstract; + function GetWithAlpha: TglBitmapFormat; virtual; abstract; + function GetWithoutAlpha: TglBitmapFormat; virtual; abstract; + function GetOpenGLFormat: TglBitmapFormat; virtual; abstract; + function GetUncompressed: TglBitmapFormat; virtual; abstract; + + function GetglDataFormat: GLenum; virtual; abstract; + function GetglFormat: GLenum; virtual; abstract; + function GetglInternalFormat: GLenum; virtual; abstract; + public + property IsCompressed: Boolean read GetIsCompressed; + property HasRed: Boolean read GetHasRed; + property HasGreen: Boolean read GetHasGreen; + property HasBlue: Boolean read GetHasBlue; + property HasAlpha: Boolean read GetHasAlpha; + + property RGBInverted: TglBitmapFormat read GetRGBInverted; + property WithAlpha: TglBitmapFormat read GetWithAlpha; + property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha; + property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat; + property Uncompressed: TglBitmapFormat read GetUncompressed; + + property glFormat: GLenum read GetglFormat; + property glInternalFormat: GLenum read GetglInternalFormat; + property glDataFormat: GLenum read GetglDataFormat; + public + class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; + end; + +//////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap = class; + TglBitmapFunctionRec = record + Sender: TglBitmap; + Size: TglBitmapPixelPosition; + Position: TglBitmapPixelPosition; + Source: TglBitmapPixelData; + Dest: TglBitmapPixelData; + Args: Pointer; + end; + TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec); + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap = class + private + function GetFormatDesc: TglBitmapFormatDescriptor; + protected + fID: GLuint; + fTarget: GLuint; + fAnisotropic: Integer; + fDeleteTextureOnFree: Boolean; + fFreeDataOnDestroy: Boolean; + fFreeDataAfterGenTexture: Boolean; + fData: PByte; + fIsResident: GLboolean; + fBorderColor: array[0..3] of Single; + + fDimension: TglBitmapPixelPosition; + fMipMap: TglBitmapMipMap; + fFormat: TglBitmapFormat; + + // Mapping + fPixelSize: Integer; + fRowSize: Integer; + + // Filtering + fFilterMin: GLenum; + fFilterMag: GLenum; + + // TexturWarp + fWrapS: GLenum; + fWrapT: GLenum; + fWrapR: GLenum; + + //Swizzle + fSwizzle: array[0..3] of GLenum; + + // CustomData + fFilename: String; + fCustomName: String; + fCustomNameW: WideString; + fCustomData: Pointer; + + //Getter + function GetWidth: Integer; virtual; + function GetHeight: Integer; virtual; + + function GetFileWidth: Integer; virtual; + function GetFileHeight: Integer; virtual; + + //Setter + procedure SetCustomData(const aValue: Pointer); + procedure SetCustomName(const aValue: String); + procedure SetCustomNameW(const aValue: WideString); + procedure SetFreeDataOnDestroy(const aValue: Boolean); + procedure SetDeleteTextureOnFree(const aValue: Boolean); + procedure SetFormat(const aValue: TglBitmapFormat); + procedure SetFreeDataAfterGenTexture(const aValue: Boolean); + procedure SetID(const aValue: Cardinal); + procedure SetMipMap(const aValue: TglBitmapMipMap); + procedure SetTarget(const aValue: Cardinal); + procedure SetAnisotropic(const aValue: Integer); + + procedure CreateID; + procedure SetupParameters(out aBuildWithGlu: Boolean); + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; //be careful, aData could be freed by this method + procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract; + + function FlipHorz: Boolean; virtual; + function FlipVert: Boolean; virtual; + + property Width: Integer read GetWidth; + property Height: Integer read GetHeight; + + property FileWidth: Integer read GetFileWidth; + property FileHeight: Integer read GetFileHeight; + public + //Properties + property ID: Cardinal read fID write SetID; + property Target: Cardinal read fTarget write SetTarget; + property Format: TglBitmapFormat read fFormat write SetFormat; + property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; + property Anisotropic: Integer read fAnisotropic write SetAnisotropic; + + property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; + + property Filename: String read fFilename; + property CustomName: String read fCustomName write SetCustomName; + property CustomNameW: WideString read fCustomNameW write SetCustomNameW; + property CustomData: Pointer read fCustomData write SetCustomData; + + property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; + property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; + property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; + + property Dimension: TglBitmapPixelPosition read fDimension; + property Data: PByte read fData; + property IsResident: GLboolean read fIsResident; + + procedure AfterConstruction; override; + procedure BeforeDestruction; override; + + procedure PrepareResType(var aResource: String; var aResType: PChar); + + //Load + procedure LoadFromFile(const aFilename: String); + procedure LoadFromStream(const aStream: TStream); virtual; + procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; + const aFormat: TglBitmapFormat; const aArgs: Pointer = nil); + procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil); + procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); + + //Save + procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); + procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual; + + //Convert + function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload; + function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; + const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload; + public + //Alpha & Co + {$IFDEF GLB_SDL} + function AssignToSurface(out aSurface: PSDL_Surface): Boolean; + function AssignFromSurface(const aSurface: PSDL_Surface): Boolean; + function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; + function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; + const aArgs: Pointer = nil): Boolean; + {$ENDIF} + + {$IFDEF GLB_DELPHI} + function AssignToBitmap(const aBitmap: TBitmap): Boolean; + function AssignFromBitmap(const aBitmap: TBitmap): Boolean; + function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; + function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; + const aArgs: Pointer = nil): Boolean; + {$ENDIF} + + {$IFDEF GLB_LAZARUS} + function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; + const aArgs: Pointer = nil): Boolean; + {$ENDIF} + + function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; + const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; + const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual; + function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean; + function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean; + function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean; + + function AddAlphaFromValue(const aAlpha: Byte): Boolean; + function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; + function AddAlphaFromValueFloat(const aAlpha: Single): Boolean; + + function RemoveAlpha: Boolean; virtual; + public + //Common + function Clone: TglBitmap; + function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; + procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false); + procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); + procedure FreeData; + + //ColorFill + procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255); + procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF); + procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1); + + //TexParameters + procedure SetFilter(const aMin, aMag: GLenum); + procedure SetWrap( + const S: GLenum = GL_CLAMP_TO_EDGE; + const T: GLenum = GL_CLAMP_TO_EDGE; + const R: GLenum = GL_CLAMP_TO_EDGE); + procedure SetSwizzle(const r, g, b, a: GLenum); + + procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; + procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; + + //Constructors + constructor Create; overload; + constructor Create(const aFileName: String); overload; + constructor Create(const aStream: TStream); overload; + constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; + constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; + constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload; + constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload; + private + {$IFDEF GLB_SUPPORT_PNG_READ} function LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF} + {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF} + + {$IFDEF GLB_SUPPORT_JPEG_READ} function LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF} + {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF} + + function LoadBMP(const aStream: TStream): Boolean; virtual; + procedure SaveBMP(const aStream: TStream); virtual; + + function LoadTGA(const aStream: TStream): Boolean; virtual; + procedure SaveTGA(const aStream: TStream); virtual; + + function LoadDDS(const aStream: TStream): Boolean; virtual; + procedure SaveDDS(const aStream: TStream); virtual; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap1D = class(TglBitmap) + protected + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + procedure UploadData(const aBuildWithGlu: Boolean); + public + property Width; + procedure AfterConstruction; override; + function FlipHorz: Boolean; override; + procedure GenTexture(const aTestTextureSize: Boolean = true); override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap2D = class(TglBitmap) + protected + fLines: array of PByte; + function GetScanline(const aIndex: Integer): Pointer; + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); + public + property Width; + property Height; + property Scanline[const aIndex: Integer]: Pointer read GetScanline; + + procedure AfterConstruction; override; + + procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); + procedure GetDataFromTexture; + procedure GenTexture(const aTestTextureSize: Boolean = true); override; + + function FlipHorz: Boolean; override; + function FlipVert: Boolean; override; + + procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; + const aScale: Single = 2; const aUseAlpha: Boolean = false); + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapCubeMap = class(TglBitmap2D) + protected + fGenMode: Integer; + procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; + public + procedure AfterConstruction; override; + procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); + procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapNormalMap = class(TglBitmapCubeMap) + public + procedure AfterConstruction; override; + procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); + end; + + TglcBitmapFormat = TglBitmapFormat; + TglcBitmap1D = TglBitmap1D; + TglcBitmap2D = TglBitmap2D; + TglcBitmapCubeMap = TglBitmapCubeMap; + TglcBitmapNormalMap = TglBitmapNormalMap; + +const + NULL_SIZE: TglBitmapPixelPosition = (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); + +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); + +function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition; +function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; +function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; + +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; + +{$IFDEF GLB_DELPHI} +function CreateGrayPalette: HPALETTE; +{$ENDIF} + +implementation + +uses + Math, syncobjs, typinfo + {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; + +type +{$IFNDEF fpc} + QWord = System.UInt64; + PQWord = ^QWord; + + PtrInt = Longint; + PtrUInt = DWord; +{$ENDIF} + +//////////////////////////////////////////////////////////////////////////////////////////////////// + TShiftRec = packed record + case Integer of + 0: (r, g, b, a: Byte); + 1: (arr: array[0..3] of Byte); + end; + + TFormatDescriptor = class(TglBitmapFormatDescriptor) + private + function GetRedMask: QWord; + function GetGreenMask: QWord; + function GetBlueMask: QWord; + function GetAlphaMask: QWord; + protected + fFormat: TglBitmapFormat; + fWithAlpha: TglBitmapFormat; + fWithoutAlpha: TglBitmapFormat; + fOpenGLFormat: TglBitmapFormat; + fRGBInverted: TglBitmapFormat; + fUncompressed: TglBitmapFormat; + + fPixelSize: Single; + fIsCompressed: Boolean; + + fRange: TglBitmapColorRec; + fShift: TShiftRec; + + fglFormat: GLenum; + fglInternalFormat: GLenum; + fglDataFormat: GLenum; + + function GetIsCompressed: Boolean; override; + function GetHasRed: Boolean; override; + function GetHasGreen: Boolean; override; + function GetHasBlue: Boolean; override; + function GetHasAlpha: Boolean; override; + + function GetRGBInverted: TglBitmapFormat; override; + function GetWithAlpha: TglBitmapFormat; override; + function GetWithoutAlpha: TglBitmapFormat; override; + function GetOpenGLFormat: TglBitmapFormat; override; + function GetUncompressed: TglBitmapFormat; override; + + function GetglFormat: GLenum; override; + function GetglInternalFormat: GLenum; override; + function GetglDataFormat: GLenum; override; + + function GetComponents: Integer; virtual; + public + property Format: TglBitmapFormat read fFormat; + property Components: Integer read GetComponents; + property PixelSize: Single read fPixelSize; + + property Range: TglBitmapColorRec read fRange; + property Shift: TShiftRec read fShift; + + property RedMask: QWord read GetRedMask; + property GreenMask: QWord read GetGreenMask; + property BlueMask: QWord read GetBlueMask; + property AlphaMask: QWord read GetAlphaMask; + + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; + + function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual; + function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; + + function CreateMappingData: Pointer; virtual; + procedure FreeMappingData(var aMappingData: Pointer); virtual; + + function IsEmpty: Boolean; virtual; + function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): 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 procedure Clear; + class procedure Finalize; + end; + TFormatDescriptorClass = class of TFormatDescriptor; + + TfdEmpty = class(TFormatDescriptor); + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdAlpha_UB1 = 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; + + TfdLuminance_UB1 = 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; + + TfdUniversal_UB1 = 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; + + TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //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; + + TfdRGB_UB3 = 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; + + TfdBGR_UB3 = 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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdAlpha_US1 = 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; + + TfdLuminance_US1 = 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; + + TfdUniversal_US1 = 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; + + TfdDepth_US1 = 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; + + TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //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; + + TfdRGB_US3 = 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; + + TfdBGR_US3 = 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; + + TfdRGBA_US4 = class(TfdRGB_US3) //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; + + TfdARGB_US4 = class(TfdRGB_US3) //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; + + TfdBGRA_US4 = class(TfdBGR_US3) //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; + + TfdABGR_US4 = class(TfdBGR_US3) //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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdUniversal_UI1 = 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; + + TfdDepth_UI1 = 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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdAlpha4 = class(TfdAlpha_UB1) + constructor Create; override; + end; + + TfdAlpha8 = class(TfdAlpha_UB1) + constructor Create; override; + end; + + TfdAlpha16 = class(TfdAlpha_US1) + constructor Create; override; + end; + + TfdLuminance4 = class(TfdLuminance_UB1) + constructor Create; override; + end; + + TfdLuminance8 = class(TfdLuminance_UB1) + constructor Create; override; + end; + + TfdLuminance16 = class(TfdLuminance_US1) + constructor Create; override; + end; + + TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2) + constructor Create; override; + end; + + TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2) + constructor Create; override; + end; + + TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2) + constructor Create; override; + end; + + TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2) + constructor Create; override; + end; + + TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) + constructor Create; override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdR3G3B2 = class(TfdUniversal_UB1) + constructor Create; override; + end; + + TfdRGBX4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdXRGB4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdR5G6B5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdRGB5X1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdX1RGB5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdRGB8 = class(TfdRGB_UB3) + constructor Create; override; + end; + + TfdRGBX8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdXRGB8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGB10X2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdX2RGB10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGB16 = class(TfdRGB_US3) + constructor Create; override; + end; + + TfdRGBA4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdARGB4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdRGB5A1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdA1RGB5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdRGBA8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdARGB8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGB10A2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdA2RGB10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdRGBA16 = class(TfdUniversal_UI1) + constructor Create; override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdBGRX4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdXBGR4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdB5G6R5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGR5X1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdX1BGR5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGR8 = class(TfdBGR_UB3) + constructor Create; override; + end; + + TfdBGRX8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdXBGR8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGR10X2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdX2BGR10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGR16 = class(TfdBGR_US3) + constructor Create; override; + end; + + TfdBGRA4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdABGR4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGR5A1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdA1BGR5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGRA8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdABGR8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGR10A2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdA2BGR10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGRA16 = class(TfdBGRA_US4) + constructor Create; override; + end; + + TfdDepth16 = class(TfdDepth_US1) + constructor Create; override; + end; + + TfdDepth24 = class(TfdDepth_UI1) + constructor Create; override; + end; + + TfdDepth32 = class(TfdDepth_UI1) + constructor Create; 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; + constructor Create; 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; + constructor Create; 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; + constructor Create; override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TbmpBitfieldFormat = class(TFormatDescriptor) + private + procedure SetRedMask (const aValue: QWord); + procedure SetGreenMask(const aValue: QWord); + procedure SetBlueMask (const aValue: QWord); + procedure SetAlphaMask(const aValue: QWord); + + procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); + public + property RedMask: QWord read GetRedMask write SetRedMask; + property GreenMask: QWord read GetGreenMask write SetGreenMask; + property BlueMask: QWord read GetBlueMask write SetBlueMask; + property AlphaMask: QWord read GetAlphaMask write SetAlphaMask; + + property PixelSize: Single read fPixelSize write fPixelSize; + + 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; + public + property PixelSize: Single read fPixelSize write fPixelSize; + property ColorTable: TbmpColorTable read fColorTable write fColorTable; + property Range: TglBitmapColorRec read fRange write fRange; + property Shift: TShiftRec read fShift write fShift; + property Format: TglBitmapFormat read fFormat write fFormat; + + procedure CreateColorTable; + + 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; + + UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.'; + + FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = ( + TfdEmpty, + + TfdAlpha4, + TfdAlpha8, + TfdAlpha16, + + TfdLuminance4, + TfdLuminance8, + TfdLuminance16, + + TfdLuminance4Alpha4, + TfdLuminance6Alpha2, + TfdLuminance8Alpha8, + TfdLuminance12Alpha4, + TfdLuminance16Alpha16, + + TfdR3G3B2, + TfdRGBX4, + TfdXRGB4, + TfdR5G6B5, + TfdRGB5X1, + TfdX1RGB5, + TfdRGB8, + TfdRGBX8, + TfdXRGB8, + TfdRGB10X2, + TfdX2RGB10, + TfdRGB16, + + TfdRGBA4, + TfdARGB4, + TfdRGB5A1, + TfdA1RGB5, + TfdRGBA8, + TfdARGB8, + TfdRGB10A2, + TfdA2RGB10, + TfdRGBA16, + + TfdBGRX4, + TfdXBGR4, + TfdB5G6R5, + TfdBGR5X1, + TfdX1BGR5, + TfdBGR8, + TfdBGRX8, + TfdXBGR8, + TfdBGR10X2, + TfdX2BGR10, + TfdBGR16, + + TfdBGRA4, + TfdABGR4, + TfdBGR5A1, + TfdA1BGR5, + TfdBGRA8, + TfdABGR8, + TfdBGR10A2, + TfdA2BGR10, + TfdBGRA16, + + TfdDepth16, + TfdDepth24, + TfdDepth32, + + 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 glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition; +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 glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; +begin + result.r := r; + result.g := g; + result.b := b; + result.a := a; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): 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 glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec; +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 [ + //4 bbp + tfLuminance4, + + //8bpp + tfR3G3B2, tfLuminance8, + + //16bpp + tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, + + //24bpp + tfBGR8, tfRGB8, + + //32bpp + tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, + tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then + result := result + [ftBMP]; + + if (aFormat in [ + //8 bpp + tfLuminance8, tfAlpha8, + + //16 bpp + tfLuminance16, tfLuminance8Alpha8, + tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4, + + //24 bpp + tfRGB8, tfBGR8, + + //32 bpp + tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then + result := result + [ftTGA]; + + if (aFormat in [ + //8 bpp + tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, + tfR3G3B2, + + //16 bpp + tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, + tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5, + tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5, + + //24 bpp + tfRGB8, tfBGR8, + + //32 bbp + tfLuminance16Alpha16, + tfRGBA8, tfRGB10A2, + tfBGRA8, tfBGR10A2, + + //compressed + tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then + result := result + [ftDDS]; + + {$IFDEF GLB_SUPPORT_PNG_WRITE} + if aFormat in [ + tfAlpha8, tfLuminance8, tfLuminance8Alpha8, + tfRGB8, tfRGBA8, + tfBGR8, tfBGRA8] then + result := result + [ftPNG]; + {$ENDIF} + + {$IFDEF GLB_SUPPORT_JPEG_WRITE} + if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] 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_NATIVE_OGL} +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//OpenGLInitialization/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +var + GL_LibHandle: Pointer = nil; + +function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer; +begin + if not Assigned(aLibHandle) then + aLibHandle := GL_LibHandle; + +{$IF DEFINED(GLB_WIN)} + result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName); + if Assigned(result) then + exit; + + if Assigned(wglGetProcAddress) then + result := wglGetProcAddress(aProcName); +{$ELSEIF DEFINED(GLB_LINUX)} + if Assigned(glXGetProcAddress) then begin + result := glXGetProcAddress(aProcName); + if Assigned(result) then + exit; + end; + + if Assigned(glXGetProcAddressARB) then begin + result := glXGetProcAddressARB(aProcName); + if Assigned(result) then + exit; + end; + + result := dlsym(aLibHandle, aProcName); +{$IFEND} + if not Assigned(result) and aRaiseOnErr then + raise EglBitmap.Create('unable to load procedure form library: ' + aProcName); +end; + +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} +var + GLU_LibHandle: Pointer = nil; + OpenGLInitialized: Boolean; + InitOpenGLCS: TCriticalSection; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glbInitOpenGL; + + //////////////////////////////////////////////////////////////////////////////// + function glbLoadLibrary(const aName: PChar): Pointer; + begin + {$IF DEFINED(GLB_WIN)} + result := {%H-}Pointer(LoadLibrary(aName)); + {$ELSEIF DEFINED(GLB_LINUX)} + result := dlopen(Name, RTLD_LAZY); + {$ELSE} + result := nil; + {$IFEND} + end; + + //////////////////////////////////////////////////////////////////////////////// + function glbFreeLibrary(const aLibHandle: Pointer): Boolean; + begin + result := false; + if not Assigned(aLibHandle) then + exit; + + {$IF DEFINED(GLB_WIN)} + Result := FreeLibrary({%H-}HINST(aLibHandle)); + {$ELSEIF DEFINED(GLB_LINUX)} + Result := dlclose(aLibHandle) = 0; + {$IFEND} + end; + +begin + if Assigned(GL_LibHandle) then + glbFreeLibrary(GL_LibHandle); + + if Assigned(GLU_LibHandle) then + glbFreeLibrary(GLU_LibHandle); + + GL_LibHandle := glbLoadLibrary(libopengl); + if not Assigned(GL_LibHandle) then + raise EglBitmap.Create('unable to load library: ' + libopengl); + + GLU_LibHandle := glbLoadLibrary(libglu); + if not Assigned(GLU_LibHandle) then + raise EglBitmap.Create('unable to load library: ' + libglu); + +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); + glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); +{$IFEND} + + glEnable := glbGetProcAddress('glEnable'); + glDisable := glbGetProcAddress('glDisable'); + glGetString := glbGetProcAddress('glGetString'); + glGetIntegerv := glbGetProcAddress('glGetIntegerv'); + glTexParameteri := glbGetProcAddress('glTexParameteri'); + glTexParameteriv := glbGetProcAddress('glTexParameteriv'); + glTexParameterfv := glbGetProcAddress('glTexParameterfv'); + glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv'); + glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv'); + glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv'); + glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv'); + glTexGeni := glbGetProcAddress('glTexGeni'); + glGenTextures := glbGetProcAddress('glGenTextures'); + glBindTexture := glbGetProcAddress('glBindTexture'); + glDeleteTextures := glbGetProcAddress('glDeleteTextures'); + glAreTexturesResident := glbGetProcAddress('glAreTexturesResident'); + glReadPixels := glbGetProcAddress('glReadPixels'); + glPixelStorei := glbGetProcAddress('glPixelStorei'); + glTexImage1D := glbGetProcAddress('glTexImage1D'); + glTexImage2D := glbGetProcAddress('glTexImage2D'); + glGetTexImage := glbGetProcAddress('glGetTexImage'); + + gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle); + gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle); +end; +{$ENDIF} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glbReadOpenGLExtensions; +var + Buffer: AnsiString; + MajorVersion, MinorVersion: Integer; + + /////////////////////////////////////////////////////////////////////////////////////////// + procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer); + var + Separator: Integer; + begin + aMinor := 0; + aMajor := 0; + + Separator := Pos(AnsiString('.'), aBuffer); + if (Separator > 1) and (Separator < Length(aBuffer)) and + (aBuffer[Separator - 1] in ['0'..'9']) and + (aBuffer[Separator + 1] in ['0'..'9']) then begin + + Dec(Separator); + while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do + Dec(Separator); + + Delete(aBuffer, 1, Separator); + Separator := Pos(AnsiString('.'), aBuffer) + 1; + + while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do + Inc(Separator); + + Delete(aBuffer, Separator, 255); + Separator := Pos(AnsiString('.'), aBuffer); + + aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1)); + aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1)); + end; + end; + + /////////////////////////////////////////////////////////////////////////////////////////// + function CheckExtension(const Extension: AnsiString): Boolean; + var + ExtPos: Integer; + begin + ExtPos := Pos(Extension, Buffer); + result := ExtPos > 0; + if result then + result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']); + end; + + /////////////////////////////////////////////////////////////////////////////////////////// + function CheckVersion(const aMajor, aMinor: Integer): Boolean; + begin + result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor)); + end; + +begin +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + InitOpenGLCS.Enter; + try + if not OpenGLInitialized then begin + glbInitOpenGL; + OpenGLInitialized := true; + end; + finally + InitOpenGLCS.Leave; + end; +{$ENDIF} + + // Version + Buffer := glGetString(GL_VERSION); + TrimVersionString(Buffer, MajorVersion, MinorVersion); + + GL_VERSION_1_2 := CheckVersion(1, 2); + GL_VERSION_1_3 := CheckVersion(1, 3); + GL_VERSION_1_4 := CheckVersion(1, 4); + GL_VERSION_2_0 := CheckVersion(2, 0); + GL_VERSION_3_3 := CheckVersion(3, 3); + + // Extensions + Buffer := glGetString(GL_EXTENSIONS); + GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp'); + GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two'); + GL_ARB_texture_swizzle := CheckExtension('GL_ARB_texture_swizzle'); + GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map'); + GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle'); + GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat'); + GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp'); + GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic'); + GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle'); + GL_EXT_texture_swizzle := CheckExtension('GL_EXT_texture_swizzle'); + GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map'); + GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle'); + GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat'); + GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap'); + + if GL_VERSION_1_3 then begin + glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1D'); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D'); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage'); + end else begin + glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB', nil, false); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB', nil, false); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false); + end; +end; +{$ENDIF} + +{$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 EglBitmapException.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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: GLenum); +begin + aMin := glBitmapDefaultFilterMin; + aMag := glBitmapDefaultFilterMag; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum); +begin + S := glBitmapDefaultWrapS; + T := glBitmapDefaultWrapT; + R := glBitmapDefaultWrapR; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); +begin + r := glDefaultSwizzle[0]; + g := glDefaultSwizzle[1]; + b := glDefaultSwizzle[2]; + a := glDefaultSwizzle[3]; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetRedMask: QWord; +begin + result := fRange.r shl fShift.r; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetGreenMask: QWord; +begin + result := fRange.g shl fShift.g; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetBlueMask: QWord; +begin + result := fRange.b shl fShift.b; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetAlphaMask: QWord; +begin + result := fRange.a shl fShift.a; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetIsCompressed: Boolean; +begin + result := fIsCompressed; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasRed: Boolean; +begin + result := (fRange.r > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasGreen: Boolean; +begin + result := (fRange.g > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasBlue: Boolean; +begin + result := (fRange.b > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetHasAlpha: Boolean; +begin + result := (fRange.a > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetRGBInverted: TglBitmapFormat; +begin + result := fRGBInverted; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetWithAlpha: TglBitmapFormat; +begin + result := fWithAlpha; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat; +begin + result := fWithoutAlpha; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat; +begin + result := fOpenGLFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetUncompressed: TglBitmapFormat; +begin + result := fUncompressed; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglFormat: GLenum; +begin + result := fglFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglInternalFormat: GLenum; +begin + result := fglInternalFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglDataFormat: GLenum; +begin + result := fglDataFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetComponents: Integer; +var + i: Integer; +begin + result := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + inc(result); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): 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 TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; +begin + result := 0; + if (aWidth <= 0) or (aHeight <= 0) then + exit; + result := Ceil(aWidth * aHeight * fPixelSize); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; +begin + result := false; + if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then + raise EglBitmap.Create('FormatCheckFormat - All Masks are 0'); + if (aRedMask <> RedMask) then + exit; + if (aGreenMask <> GreenMask) then + exit; + if (aBlueMask <> BlueMask) then + exit; + if (aAlphaMask <> AlphaMask) then + exit; + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData); +begin + FillChar(aPixel{%H-}, SizeOf(aPixel), 0); + aPixel.Data := fRange; + aPixel.Range := fRange; + aPixel.Format := fFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TFormatDescriptor.Create; +begin + inherited Create; + + fFormat := tfEmpty; + fWithAlpha := tfEmpty; + fWithoutAlpha := tfEmpty; + fOpenGLFormat := tfEmpty; + fRGBInverted := tfEmpty; + fUncompressed := tfEmpty; + + fPixelSize := 0.0; + fIsCompressed := false; + + fglFormat := 0; + fglInternalFormat := 0; + fglDataFormat := 0; + + FillChar(fRange, 0, SizeOf(fRange)); + FillChar(fShift, 0, SizeOf(fShift)); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdAlpha_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + aData^ := aPixel.Data.a; + inc(aData); +end; + +procedure TfdAlpha_UB1.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 TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + aData^ := LuminanceWeight(aPixel); + inc(aData); +end; + +procedure TfdLuminance_UB1.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 TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +var + i: Integer; +begin + aData^ := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + inc(aData); +end; + +procedure TfdUniversal_UB1.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 fRange.arr[i]; + inc(aData); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + inherited Map(aPixel, aData, aMapData); + aData^ := aPixel.Data.a; + inc(aData); +end; + +procedure TfdLuminanceAlpha_UB2.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 TfdRGB_UB3.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 TfdRGB_UB3.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdBGR_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdBGR_UB3.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 TfdBGR_UB3.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdAlpha_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); +end; + +procedure TfdAlpha_US1.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 TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + PWord(aData)^ := LuminanceWeight(aPixel); + inc(aData, 2); +end; + +procedure TfdLuminance_US1.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 TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +var + i: Integer; +begin + PWord(aData)^ := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + inc(aData, 2); +end; + +procedure TfdUniversal_US1.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 fRange.arr[i]; + inc(aData, 2); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + PWord(aData)^ := DepthWeight(aPixel); + inc(aData, 2); +end; + +procedure TfdDepth_US1.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 TfdLuminanceAlpha_US2.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 TfdLuminanceAlpha_US2.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 TfdRGB_US3.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 TfdRGB_US3.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdBGR_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdBGR_US3.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 TfdBGR_US3.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdRGBA_US4.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 TfdRGBA_US4.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdARGB_US4.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 TfdARGB_US4.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdBGRA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdBGRA_US4.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 TfdBGRA_US4.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdABGR_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdABGR_US4.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 TfdABGR_US4.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdUniversal_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +var + i: Integer; +begin + PCardinal(aData)^ := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + inc(aData, 4); +end; + +procedure TfdUniversal_UI1.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 fRange.arr[i]; + inc(aData, 2); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +begin + PCardinal(aData)^ := DepthWeight(aPixel); + inc(aData, 4); +end; + +procedure TfdDepth_UI1.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 := 0; + inc(aData, 4); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TfdAlpha4.Create; +begin + inherited Create; + fPixelSize := 1.0; + fFormat := tfAlpha4; + fWithAlpha := tfAlpha4; + fOpenGLFormat := tfAlpha4; + fRange.a := $FF; + fglFormat := GL_ALPHA; + fglInternalFormat := GL_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdAlpha8.Create; +begin + inherited Create; + fPixelSize := 1.0; + fFormat := tfAlpha8; + fWithAlpha := tfAlpha8; + fOpenGLFormat := tfAlpha8; + fRange.a := $FF; + fglFormat := GL_ALPHA; + fglInternalFormat := GL_ALPHA8; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdAlpha16.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfAlpha16; + fWithAlpha := tfAlpha16; + fOpenGLFormat := tfAlpha16; + fRange.a := $FFFF; + fglFormat := GL_ALPHA; + fglInternalFormat := GL_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdLuminance4.Create; +begin + inherited Create; + fPixelSize := 1.0; + fFormat := tfLuminance4; + fWithAlpha := tfLuminance4Alpha4; + fWithoutAlpha := tfLuminance4; + fOpenGLFormat := tfLuminance4; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fglFormat := GL_LUMINANCE; + fglInternalFormat := GL_LUMINANCE4; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdLuminance8.Create; +begin + inherited Create; + fPixelSize := 1.0; + fFormat := tfLuminance8; + fWithAlpha := tfLuminance8Alpha8; + fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fglFormat := GL_LUMINANCE; + fglInternalFormat := GL_LUMINANCE8; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdLuminance16.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfLuminance16; + fWithAlpha := tfLuminance16Alpha16; + fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fglFormat := GL_LUMINANCE; + fglInternalFormat := GL_LUMINANCE16; + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdLuminance4Alpha4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfLuminance4Alpha4; + fWithAlpha := tfLuminance4Alpha4; + fWithoutAlpha := tfLuminance4; + fOpenGLFormat := tfLuminance4Alpha4; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := GL_LUMINANCE4_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdLuminance6Alpha2.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfLuminance6Alpha2; + fWithAlpha := tfLuminance6Alpha2; + fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance6Alpha2; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := GL_LUMINANCE6_ALPHA2; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdLuminance8Alpha8.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfLuminance8Alpha8; + fWithAlpha := tfLuminance8Alpha8; + fWithoutAlpha := tfLuminance8; + fOpenGLFormat := tfLuminance8Alpha8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 8; + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := GL_LUMINANCE8_ALPHA8; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdLuminance12Alpha4.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfLuminance12Alpha4; + fWithAlpha := tfLuminance12Alpha4; + fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance12Alpha4; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 16; + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := GL_LUMINANCE12_ALPHA4; + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdLuminance16Alpha16.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfLuminance16Alpha16; + fWithAlpha := tfLuminance16Alpha16; + fWithoutAlpha := tfLuminance16; + fOpenGLFormat := tfLuminance16Alpha16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 0; + fShift.g := 0; + fShift.b := 0; + fShift.a := 16; + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := GL_LUMINANCE16_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdR3G3B2.Create; +begin + inherited Create; + fPixelSize := 1.0; + fFormat := tfR3G3B2; + fWithAlpha := tfRGBA4; + fWithoutAlpha := tfR3G3B2; + fOpenGLFormat := tfR3G3B2; + fRGBInverted := tfEmpty; + fRange.r := $07; + fRange.g := $07; + fRange.b := $04; + fShift.r := 5; + fShift.g := 2; + fShift.b := 0; + fglFormat := GL_RGB; + fglInternalFormat := GL_R3_G3_B2; + fglDataFormat := GL_UNSIGNED_BYTE_3_3_2; +end; + +constructor TfdRGBX4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfRGBX4; + fWithAlpha := tfRGBA4; + fWithoutAlpha := tfRGBX4; + fOpenGLFormat := tfRGBX4; + fRGBInverted := tfBGRX4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $00; + fShift.r := 12; + fShift.g := 8; + fShift.b := 4; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdXRGB4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfXRGB4; + fWithAlpha := tfARGB4; + fWithoutAlpha := tfXRGB4; + fOpenGLFormat := tfXRGB4; + fRGBInverted := tfXBGR4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fShift.r := 8; + fShift.g := 4; + fShift.b := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +end; + +constructor TfdR5G6B5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfR5G6B5; + fWithAlpha := tfRGB5A1; + fWithoutAlpha := tfR5G6B5; + fOpenGLFormat := tfR5G6B5; + fRGBInverted := tfB5G6R5; + fRange.r := $1F; + fRange.g := $3F; + fRange.b := $1F; + fShift.r := 11; + fShift.g := 5; + fShift.b := 0; + fglFormat := GL_RGB; + fglInternalFormat := GL_RGB565; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; +end; + +constructor TfdRGB5X1.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfRGB5X1; + fWithAlpha := tfRGB5A1; + fWithoutAlpha := tfRGB5X1; + fOpenGLFormat := tfRGB5X1; + fRGBInverted := tfBGR5X1; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 11; + fShift.g := 6; + fShift.b := 1; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdX1RGB5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfX1RGB5; + fWithAlpha := tfA1RGB5; + fWithoutAlpha := tfX1RGB5; + fOpenGLFormat := tfX1RGB5; + fRGBInverted := tfX1BGR5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 10; + fShift.g := 5; + fShift.b := 0; + 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; +end; + +constructor TfdRGB8.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfRGB8; + fWithAlpha := tfRGBA8; + fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfRGB8; + fRGBInverted := tfBGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + fglFormat := GL_BGR; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdRGBX8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfRGBX8; + fWithAlpha := tfRGBA8; + fWithoutAlpha := tfRGBX8; + fOpenGLFormat := tfRGB8; + fRGBInverted := tfBGRX8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 24; + fShift.g := 16; + fShift.b := 8; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdXRGB8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfXRGB8; + fWithAlpha := tfXRGB8; + fWithoutAlpha := tfXRGB8; + fOpenGLFormat := tfRGB8; + fRGBInverted := tfXBGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + 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; +end; + +constructor TfdRGB10X2.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfRGB10X2; + fWithAlpha := tfRGB10A2; + fWithoutAlpha := tfRGB10X2; + fOpenGLFormat := tfRGB10X2; + fRGBInverted := tfBGR10X2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 22; + fShift.g := 12; + fShift.b := 2; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +end; + +constructor TfdX2RGB10.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfX2RGB10; + fWithAlpha := tfA2RGB10; + fWithoutAlpha := tfX2RGB10; + fOpenGLFormat := tfX2RGB10; + fRGBInverted := tfX2BGR10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 20; + fShift.g := 10; + fShift.b := 0; + 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; +end; + +constructor TfdRGB16.Create; +begin + inherited Create; + fPixelSize := 6.0; + fFormat := tfRGB16; + fWithAlpha := tfRGBA16; + fWithoutAlpha := tfRGB16; + fOpenGLFormat := tfRGB16; + fRGBInverted := tfBGR16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fShift.r := 32; + fShift.g := 16; + fShift.b := 0; + fglFormat := GL_BGR; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdRGBA4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfRGBA4; + fWithAlpha := tfRGBA4; + fWithoutAlpha := tfRGBX4; + fOpenGLFormat := tfRGBA4; + fRGBInverted := tfBGRA4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 12; + fShift.g := 8; + fShift.b := 4; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdARGB4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfARGB4; + fWithAlpha := tfARGB4; + fWithoutAlpha := tfXRGB4; + fOpenGLFormat := tfARGB4; + fRGBInverted := tfABGR4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 8; + fShift.g := 4; + fShift.b := 0; + fShift.a := 12; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +end; + +constructor TfdRGB5A1.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfRGB5A1; + fWithAlpha := tfRGB5A1; + fWithoutAlpha := tfRGB5X1; + fOpenGLFormat := tfRGB5A1; + fRGBInverted := tfBGR5A1; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 11; + fShift.g := 6; + fShift.b := 1; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdA1RGB5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfA1RGB5; + fWithAlpha := tfA1RGB5; + fWithoutAlpha := tfX1RGB5; + fOpenGLFormat := tfA1RGB5; + fRGBInverted := tfA1BGR5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 10; + fShift.g := 5; + fShift.b := 0; + fShift.a := 15; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; +end; + +constructor TfdRGBA8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfRGBA8; + fWithAlpha := tfRGBA8; + fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfRGBA8; + fRGBInverted := tfBGRA8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 24; + fShift.g := 16; + fShift.b := 8; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdARGB8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfARGB8; + fWithAlpha := tfARGB8; + fWithoutAlpha := tfRGB8; + fOpenGLFormat := tfARGB8; + fRGBInverted := tfABGR8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 16; + fShift.g := 8; + fShift.b := 0; + fShift.a := 24; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +end; + +constructor TfdRGB10A2.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfRGB10A2; + fWithAlpha := tfRGB10A2; + fWithoutAlpha := tfRGB10X2; + fOpenGLFormat := tfRGB10A2; + fRGBInverted := tfBGR10A2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 22; + fShift.g := 12; + fShift.b := 2; + fShift.a := 0; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +end; + +constructor TfdA2RGB10.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfA2RGB10; + fWithAlpha := tfA2RGB10; + fWithoutAlpha := tfX2RGB10; + fOpenGLFormat := tfA2RGB10; + fRGBInverted := tfA2BGR10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 20; + fShift.g := 10; + fShift.b := 0; + fShift.a := 30; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; +end; + +constructor TfdRGBA16.Create; +begin + inherited Create; + fPixelSize := 8.0; + fFormat := tfRGBA16; + fWithAlpha := tfRGBA16; + fWithoutAlpha := tfRGB16; + fOpenGLFormat := tfRGBA16; + fRGBInverted := tfBGRA16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 48; + fShift.g := 32; + fShift.b := 16; + fShift.a := 0; + fglFormat := GL_BGRA; // reverse byte order to match little endianess + fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TfdBGRX4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfBGRX4; + fWithAlpha := tfBGRA4; + fWithoutAlpha := tfBGRX4; + fOpenGLFormat := tfBGRX4; + fRGBInverted := tfRGBX4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fShift.r := 4; + fShift.g := 8; + fShift.b := 12; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdXBGR4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfXBGR4; + fWithAlpha := tfABGR4; + fWithoutAlpha := tfXBGR4; + fOpenGLFormat := tfXBGR4; + fRGBInverted := tfXRGB4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 0; + fShift.g := 4; + fShift.b := 8; + 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; +end; + +constructor TfdB5G6R5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfB5G6R5; + fWithAlpha := tfBGR5A1; + fWithoutAlpha := tfB5G6R5; + fOpenGLFormat := tfB5G6R5; + fRGBInverted := tfR5G6B5; + fRange.r := $1F; + fRange.g := $3F; + fRange.b := $1F; + fShift.r := 0; + fShift.g := 5; + fShift.b := 11; + fglFormat := GL_RGB; + fglInternalFormat := GL_RGB565; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; +end; + +constructor TfdBGR5X1.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfBGR5X1; + fWithAlpha := tfBGR5A1; + fWithoutAlpha := tfBGR5X1; + fOpenGLFormat := tfBGR5X1; + fRGBInverted := tfRGB5X1; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 1; + fShift.g := 6; + fShift.b := 11; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdX1BGR5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfX1BGR5; + fWithAlpha := tfA1BGR5; + fWithoutAlpha := tfX1BGR5; + fOpenGLFormat := tfX1BGR5; + fRGBInverted := tfX1RGB5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fShift.r := 0; + fShift.g := 5; + fShift.b := 10; + 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; +end; + +constructor TfdBGR8.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfBGR8; + fWithAlpha := tfBGRA8; + fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfBGR8; + fRGBInverted := tfRGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + fglFormat := GL_RGB; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB8; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +constructor TfdBGRX8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfBGRX8; + fWithAlpha := tfBGRA8; + fWithoutAlpha := tfBGRX8; + fOpenGLFormat := tfBGRX8; + fRGBInverted := tfRGBX8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 8; + fShift.g := 16; + fShift.b := 24; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdXBGR8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfXBGR8; + fWithAlpha := tfABGR8; + fWithoutAlpha := tfXBGR8; + fOpenGLFormat := tfXBGR8; + fRGBInverted := tfXRGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + 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; +end; + +constructor TfdBGR10X2.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfBGR10X2; + fWithAlpha := tfBGR10A2; + fWithoutAlpha := tfBGR10X2; + fOpenGLFormat := tfBGR10X2; + fRGBInverted := tfRGB10X2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 2; + fShift.g := 12; + fShift.b := 22; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +end; + +constructor TfdX2BGR10.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfX2BGR10; + fWithAlpha := tfA2BGR10; + fWithoutAlpha := tfX2BGR10; + fOpenGLFormat := tfX2BGR10; + fRGBInverted := tfX2RGB10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fShift.r := 0; + fShift.g := 10; + fShift.b := 20; + 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; +end; + +constructor TfdBGR16.Create; +begin + inherited Create; + fPixelSize := 6.0; + fFormat := tfBGR16; + fWithAlpha := tfBGRA16; + fWithoutAlpha := tfBGR16; + fOpenGLFormat := tfBGR16; + fRGBInverted := tfRGB16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fShift.r := 0; + fShift.g := 16; + fShift.b := 32; + fglFormat := GL_RGB; // reverse byte order to match little endianess + fglInternalFormat := GL_RGB16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdBGRA4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfBGRA4; + fWithAlpha := tfBGRA4; + fWithoutAlpha := tfBGRX4; + fOpenGLFormat := tfBGRA4; + fRGBInverted := tfRGBA4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 4; + fShift.g := 8; + fShift.b := 12; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +constructor TfdABGR4.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfABGR4; + fWithAlpha := tfABGR4; + fWithoutAlpha := tfXBGR4; + fOpenGLFormat := tfABGR4; + fRGBInverted := tfARGB4; + fRange.r := $0F; + fRange.g := $0F; + fRange.b := $0F; + fRange.a := $0F; + fShift.r := 0; + fShift.g := 4; + fShift.b := 8; + fShift.a := 12; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +end; + +constructor TfdBGR5A1.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfBGR5A1; + fWithAlpha := tfBGR5A1; + fWithoutAlpha := tfBGR5X1; + fOpenGLFormat := tfBGR5A1; + fRGBInverted := tfRGB5A1; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 1; + fShift.g := 6; + fShift.b := 11; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +constructor TfdA1BGR5.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfA1BGR5; + fWithAlpha := tfA1BGR5; + fWithoutAlpha := tfX1BGR5; + fOpenGLFormat := tfA1BGR5; + fRGBInverted := tfA1RGB5; + fRange.r := $1F; + fRange.g := $1F; + fRange.b := $1F; + fRange.a := $01; + fShift.r := 0; + fShift.g := 5; + fShift.b := 10; + fShift.a := 15; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; +end; + +constructor TfdBGRA8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfBGRA8; + fWithAlpha := tfBGRA8; + fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfBGRA8; + fRGBInverted := tfRGBA8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 8; + fShift.g := 16; + fShift.b := 24; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +constructor TfdABGR8.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfABGR8; + fWithAlpha := tfABGR8; + fWithoutAlpha := tfBGR8; + fOpenGLFormat := tfABGR8; + fRGBInverted := tfARGB8; + fRange.r := $FF; + fRange.g := $FF; + fRange.b := $FF; + fRange.a := $FF; + fShift.r := 0; + fShift.g := 8; + fShift.b := 16; + fShift.a := 24; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +end; + +constructor TfdBGR10A2.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfBGR10A2; + fWithAlpha := tfBGR10A2; + fWithoutAlpha := tfBGR10X2; + fOpenGLFormat := tfBGR10A2; + fRGBInverted := tfRGB10A2; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 2; + fShift.g := 12; + fShift.b := 22; + fShift.a := 0; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +end; + +constructor TfdA2BGR10.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfA2BGR10; + fWithAlpha := tfA2BGR10; + fWithoutAlpha := tfX2BGR10; + fOpenGLFormat := tfA2BGR10; + fRGBInverted := tfA2RGB10; + fRange.r := $03FF; + fRange.g := $03FF; + fRange.b := $03FF; + fRange.a := $0003; + fShift.r := 0; + fShift.g := 10; + fShift.b := 20; + fShift.a := 30; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; +end; + +constructor TfdBGRA16.Create; +begin + inherited Create; + fPixelSize := 8.0; + fFormat := tfBGRA16; + fWithAlpha := tfBGRA16; + fWithoutAlpha := tfBGR16; + fOpenGLFormat := tfBGRA16; + fRGBInverted := tfRGBA16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fShift.r := 16; + fShift.g := 32; + fShift.b := 48; + fShift.a := 0; + fglFormat := GL_RGBA; // reverse byte order to match little endianess + fglInternalFormat := GL_RGBA16; // as if u interpret the 3 bytes as unsigned integer + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdDepth16.Create; +begin + inherited Create; + fPixelSize := 2.0; + fFormat := tfDepth16; + fWithoutAlpha := tfDepth16; + fOpenGLFormat := tfDepth16; + fRange.r := $FFFF; + fRange.g := $FFFF; + fRange.b := $FFFF; + fRange.a := $FFFF; + fglFormat := GL_DEPTH_COMPONENT; + fglInternalFormat := GL_DEPTH_COMPONENT16; + fglDataFormat := GL_UNSIGNED_SHORT; +end; + +constructor TfdDepth24.Create; +begin + inherited Create; + fPixelSize := 3.0; + fFormat := tfDepth24; + fWithoutAlpha := tfDepth24; + fOpenGLFormat := tfDepth24; + fRange.r := $FFFFFF; + fRange.g := $FFFFFF; + fRange.b := $FFFFFF; + fRange.a := $FFFFFF; + fglFormat := GL_DEPTH_COMPONENT; + fglInternalFormat := GL_DEPTH_COMPONENT24; + fglDataFormat := GL_UNSIGNED_INT; +end; + +constructor TfdDepth32.Create; +begin + inherited Create; + fPixelSize := 4.0; + fFormat := tfDepth32; + fWithoutAlpha := tfDepth32; + fOpenGLFormat := tfDepth32; + fRange.r := $FFFFFFFF; + fRange.g := $FFFFFFFF; + fRange.b := $FFFFFFFF; + fRange.a := $FFFFFFFF; + fglFormat := GL_DEPTH_COMPONENT; + fglInternalFormat := GL_DEPTH_COMPONENT32; + fglDataFormat := GL_UNSIGNED_INT; +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; + +constructor TfdS3tcDtx1RGBA.Create; +begin + inherited Create; + fFormat := tfS3tcDtx1RGBA; + fWithAlpha := tfS3tcDtx1RGBA; + fOpenGLFormat := tfS3tcDtx1RGBA; + fUncompressed := tfRGB5A1; + fPixelSize := 0.5; + fIsCompressed := true; + fglFormat := GL_COMPRESSED_RGBA; + fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + fglDataFormat := GL_UNSIGNED_BYTE; +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; + +constructor TfdS3tcDtx3RGBA.Create; +begin + inherited Create; + fFormat := tfS3tcDtx3RGBA; + fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; + fUncompressed := tfRGBA8; + fPixelSize := 1.0; + fIsCompressed := true; + fglFormat := GL_COMPRESSED_RGBA; + fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + fglDataFormat := GL_UNSIGNED_BYTE; +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; + +constructor TfdS3tcDtx5RGBA.Create; +begin + inherited Create; + fFormat := tfS3tcDtx3RGBA; + fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; + fUncompressed := tfRGBA8; + fPixelSize := 1.0; + fIsCompressed := true; + fglFormat := GL_COMPRESSED_RGBA; + fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 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.SetRedMask(const aValue: QWord); +begin + Update(aValue, fRange.r, fShift.r); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord); +begin + Update(aValue, fRange.g, fShift.g); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord); +begin + Update(aValue, fRange.b, fShift.b); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord); +begin + Update(aValue, fRange.a, fShift.a); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out + aShift: Byte); +begin + aShift := 0; + aRange := 0; + if (aMask = 0) then + exit; + while (aMask > 0) and ((aMask and 1) = 0) do begin + inc(aShift); + aMask := aMask shr 1; + end; + aRange := 1; + while (aMask > 0) do begin + aRange := aRange shl 1; + aMask := aMask shr 1; + end; + dec(aRange); + + fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +var + data: QWord; + s: Integer; +begin + data := + ((aPixel.Data.r and fRange.r) shl fShift.r) or + ((aPixel.Data.g and fRange.g) shl fShift.g) or + ((aPixel.Data.b and fRange.b) shl fShift.b) or + ((aPixel.Data.a and fRange.a) shl fShift.a); + s := Round(fPixelSize); + case s of + 1: aData^ := data; + 2: PWord(aData)^ := data; + 4: PCardinal(aData)^ := data; + 8: PQWord(aData)^ := data; + else + raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + end; + inc(aData, s); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +var + data: QWord; + s, i: Integer; +begin + s := Round(fPixelSize); + case s of + 1: data := aData^; + 2: data := PWord(aData)^; + 4: data := PCardinal(aData)^; + 8: data := PQWord(aData)^; + else + raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + end; + for i := 0 to 3 do + aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i]; + inc(aData, s); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TColorTableFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.CreateColorTable; +var + i: Integer; +begin + if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then + raise EglBitmap.Create(UNSUPPORTED_FORMAT); + + if (Format = tfLuminance4) then + SetLength(fColorTable, 16) + else + SetLength(fColorTable, 256); + + case Format of + tfLuminance4: begin + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := 16 * i; + fColorTable[i].g := 16 * i; + fColorTable[i].b := 16 * i; + fColorTable[i].a := 0; + end; + end; + + tfLuminance8: begin + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := i; + fColorTable[i].g := i; + fColorTable[i].b := i; + fColorTable[i].a := 0; + end; + end; + + tfR3G3B2: begin + 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; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +var + d: Byte; +begin + if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then + raise EglBitmap.Create(UNSUPPORTED_FORMAT); + + case Format of + tfLuminance4: begin + if (aMapData = nil) then + aData^ := 0; + d := LuminanceWeight(aPixel) and Range.r; + aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData))); + inc(PByte(aMapData), 4); + if ({%H-}PtrUInt(aMapData) >= 8) then begin + inc(aData); + aMapData := nil; + end; + end; + + tfLuminance8: begin + aData^ := LuminanceWeight(aPixel) and Range.r; + inc(aData); + end; + + tfR3G3B2: begin + aData^ := Round( + ((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)); + inc(aData); + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +var + idx: QWord; + s: Integer; + bits: Byte; + f: Single; +begin + s := Trunc(fPixelSize); + f := fPixelSize - s; + bits := Round(8 * f); + case s of + 0: idx := (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1); + 1: idx := aData^; + 2: idx := PWord(aData)^; + 4: idx := PCardinal(aData)^; + 8: idx := PQWord(aData)^; + else + raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); + end; + if (idx >= Length(fColorTable)) then + raise EglBitmap.CreateFmt('invalid color index: %d', [idx]); + with fColorTable[idx] do begin + aPixel.Data.r := r; + aPixel.Data.g := g; + aPixel.Data.b := b; + aPixel.Data.a := a; + end; + inc(PByte(aMapData), bits); + if ({%H-}PtrUInt(aMapData) >= 8) then begin + inc(aData, 1); + dec(PByte(aMapData), 8); + end; + inc(aData, s); +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); +begin + with aFuncRec do begin + Dest.Data := Source.Data; + if ({%H-}PtrUInt(Args) and $1 > 0) then begin + Dest.Data.r := Dest.Data.r xor Dest.Range.r; + Dest.Data.g := Dest.Data.g xor Dest.Range.g; + Dest.Data.b := Dest.Data.b xor Dest.Range.b; + end; + if ({%H-}PtrUInt(Args) and $2 > 0) then begin + Dest.Data.a := Dest.Data.a xor Dest.Range.a; + end; + 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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap - PROTECTED/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor; +begin + result := TFormatDescriptor.Get(Format); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetFileWidth: Integer; +begin + result := Max(1, Width); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetFileHeight: Integer; +begin + result := Max(1, Height); +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.SetFreeDataOnDestroy(const aValue: Boolean); +begin + if fFreeDataOnDestroy = aValue then + exit; + fFreeDataOnDestroy := aValue; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean); +begin + if fDeleteTextureOnFree = aValue then + exit; + fDeleteTextureOnFree := aValue; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat); +begin + if fFormat = aValue then + exit; + if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then + raise EglBitmapUnsupportedFormat.Create(Format); + SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean); +begin + if fFreeDataAfterGenTexture = aValue then + exit; + fFreeDataAfterGenTexture := 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); +var + MaxAnisotropic: Integer; +begin + fAnisotropic := aValue; + if (ID > 0) then begin + if GL_EXT_texture_filter_anisotropic then begin + if fAnisotropic > 0 then begin + Bind(false); + 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; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.CreateID; +begin + if (ID <> 0) then + glDeleteTextures(1, @fID); + glGenTextures(1, @fID); + Bind(false); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean); +begin + // Set Up Parameters + SetWrap(fWrapS, fWrapT, fWrapR); + SetFilter(fFilterMin, fFilterMag); + SetAnisotropic(fAnisotropic); + 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]); + + // 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, GL_TRUE) + else + aBuildWithGlu := true; + end else if (MipMap = mmMipmapGlu) then + aBuildWithGlu := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer; const aHeight: Integer); +var + s: Single; +begin + if (Data <> aData) then begin + if (Assigned(Data)) then + FreeMem(Data); + fData := aData; + end; + + if not Assigned(fData) then begin + fPixelSize := 0; + fRowSize := 0; + end else 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; + + s := TFormatDescriptor.Get(aFormat).PixelSize; + fFormat := aFormat; + fPixelSize := Ceil(s); + fRowSize := Ceil(s * aWidth); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.FlipHorz: Boolean; +begin + result := false; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.FlipVert: Boolean; +begin + result := false; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap - PUBLIC////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.AfterConstruction; +begin + inherited AfterConstruction; + + fID := 0; + fTarget := 0; + fIsResident := false; + + fMipMap := glBitmapDefaultMipmap; + fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture; + fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; + + glBitmapGetDefaultFilter (fFilterMin, fFilterMag); + glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); + glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.BeforeDestruction; +var + NewData: PByte; +begin + if fFreeDataOnDestroy then begin + NewData := nil; + SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method + end; + if (fID > 0) and fDeleteTextureOnFree then + glDeleteTextures(1, @fID); + inherited BeforeDestruction; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 TglBitmap.LoadFromFile(const aFilename: String); +var + fs: TFileStream; +begin + if not FileExists(aFilename) then + raise EglBitmap.Create('file does not exist: ' + aFilename); + fFilename := aFilename; + fs := TFileStream.Create(fFilename, fmOpenRead); + try + fs.Position := 0; + LoadFromStream(fs); + finally + fs.Free; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 + raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; + const aFormat: TglBitmapFormat; const aArgs: Pointer); +var + tmpData: PByte; + size: Integer; +begin + size := TFormatDescriptor.Get(aFormat).GetSize(aSize); + GetMem(tmpData, size); + try + FillChar(tmpData^, size, #$FF); + SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + except + if Assigned(tmpData) then + FreeMem(tmpData); + raise; + end; + AddFunc(Self, aFunc, false, aFormat, aArgs); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 TglBitmap.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 TglBitmap.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 TglBitmap.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); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; +begin + result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddFunc(const aSource: TglBitmap; 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.PixelSize <> DestFD.PixelSize) 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 + SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method + 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; + +{$IFDEF GLB_SDL} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean; +var + pSource, pData, pTempData: PByte; + Row, RowSize, TempWidth, TempHeight: Integer; + IntFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + + 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 + for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin + FormatDesc := TFormatDescriptor.Get(IntFormat); + if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then + break; + end; + if (IntFormat = tfEmpty) then + raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.'); + end; + + TempWidth := aSurface^.w; + TempHeight := aSurface^.h; + RowSize := FormatDesc.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; + SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method + result := true; + except + if Assigned(pData) then + FreeMem(pData); + raise; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin + aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); + + AlphaInterleave := 0; + case Format of + tfLuminance8Alpha8: + AlphaInterleave := 1; + tfBGRA8, tfRGBA8: + 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 TglBitmap.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 TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean; +var + Row: 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 + tfAlpha8, tfLuminance8: begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + end; + tfRGB5A1: + aBitmap.PixelFormat := pf15bit; + tfR5G6B5: + aBitmap.PixelFormat := pf16bit; + tfRGB8, tfBGR8: + aBitmap.PixelFormat := pf24bit; + tfRGBA8, tfBGRA8: + aBitmap.PixelFormat := pf32bit; + else + raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); + end; + + pSource := Data; + for Row := 0 to FileHeight -1 do begin + pData := aBitmap.Scanline[Row]; + Move(pSource^, pData^, fRowSize); + Inc(pSource, fRowSize); + if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, FileWidth, Format = tfRGBA8); + end; + result := true; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 := tfLuminance8; + pf15bit: + IntFormat := tfRGB5A1; + pf16bit: + IntFormat := tfR5G6B5; + pf24bit: + IntFormat := tfBGR8; + pf32bit: + IntFormat := tfBGRA8; + 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; + SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method + result := true; + except + if Assigned(pData) then + FreeMem(pData); + raise; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; +var + Row, Col, AlphaInterleave: Integer; + pSource, pDest: PByte; +begin + result := false; + + if Assigned(Data) then begin + if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin + if Assigned(aBitmap) then begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + aBitmap.Width := Width; + aBitmap.Height := Height; + + case Format of + tfLuminance8Alpha8: + AlphaInterleave := 1; + tfRGBA8, tfBGRA8: + 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 TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + tex: TglBitmap2D; +begin + tex := TglBitmap2D.Create; + try + tex.AssignFromBitmap(ABitmap); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); + finally + tex.Free; + end; +end; +{$ENDIF} + +{$IFDEF GLB_LAZARUS} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; +begin + 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 (Format in [ + tfAlpha4, tfAlpha8, tfAlpha16, + tfLuminance4, tfLuminance8, tfLuminance16, + tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then + rid.Format := ricfGray + else + rid.Format := ricfRGBA; + + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize); + 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; + + Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + f: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + ImageData: PByte; + ImageSize: Integer; + CanCopy: Boolean; + + procedure CopyConvert; + var + bfFormat: TbmpBitfieldFormat; + pSourceLine, pDestLine: PByte; + pSourceMD, pDestMD: Pointer; + x, y: Integer; + pixel: TglBitmapPixelData; + begin + bfFormat := TbmpBitfieldFormat.Create; + with aImage.DataDescription do begin + bfFormat.RedMask := ((1 shl RedPrec) - 1) shl RedShift; + bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift; + bfFormat.BlueMask := ((1 shl BluePrec) - 1) shl BlueShift; + bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift; + bfFormat.PixelSize := BitsPerPixel / 8; + 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.PixelSize * 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; + for f := High(f) downto Low(f) do begin + FormatDesc := TFormatDescriptor.Get(f); + with aImage.DataDescription do + if FormatDesc.MaskMatch( + (QWord(1 shl RedPrec )-1) shl RedShift, + (QWord(1 shl GreenPrec)-1) shl GreenShift, + (QWord(1 shl BluePrec )-1) shl BlueShift, + (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then + break; + end; + + if (f = tfEmpty) then + exit; + + CanCopy := + (Round(FormatDesc.PixelSize * 8) = 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; + SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; + end; + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + tex: TglBitmap2D; +begin + tex := TglBitmap2D.Create; + try + tex.AssignFromLazIntfImage(aImage); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); + finally + tex.Free; + end; +end; +{$ENDIF} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.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 TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +begin + if TFormatDescriptor.Get(Format).IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); + result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + tex: TglBitmap2D; +begin + tex := TglBitmap2D.Create(aStream); + try + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); + finally + tex.Free; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; 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(aBitmap)); + Assert(Assigned(aBitmap.Data)); + + if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin + result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha); + + SourceFD := TFormatDescriptor.Get(aBitmap.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 + TempHeight := aBitmap.FileHeight; + TempWidth := aBitmap.FileWidth; + + FuncRec.Sender := Self; + FuncRec.Size := Dimension; + FuncRec.Position.Fields := FuncRec.Size.Fields; + + DestData := Data; + DestData2 := Data; + SourceData := aBitmap.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 TglBitmap.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean; +begin + result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.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 TglBitmap.AddAlphaFromValue(const aAlpha: Byte): Boolean; +begin + result := AddAlphaFromValueFloat(aAlpha / $FF); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.Clone: TglBitmap; +var + Temp: TglBitmap; + TempPtr: PByte; + Size: Integer; +begin + result := nil; + Temp := (ClassType.Create as TglBitmap); + 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.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method + except + if Assigned(TempPtr) then + FreeMem(TempPtr); + raise; + end; + end else begin + TempPtr := nil; + Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method + end; + + // copy properties + Temp.fID := ID; + Temp.fTarget := Target; + Temp.fFormat := Format; + Temp.fMipMap := MipMap; + Temp.fAnisotropic := Anisotropic; + Temp.fBorderColor := fBorderColor; + Temp.fDeleteTextureOnFree := DeleteTextureOnFree; + Temp.fFreeDataAfterGenTexture := FreeDataAfterGenTexture; + Temp.fFilterMin := fFilterMin; + Temp.fFilterMag := fFilterMag; + Temp.fWrapS := fWrapS; + Temp.fWrapT := fWrapT; + Temp.fWrapR := fWrapR; + Temp.fFilename := fFilename; + Temp.fCustomName := fCustomName; + Temp.fCustomNameW := fCustomNameW; + Temp.fCustomData := fCustomData; + + result := Temp; + except + FreeAndNil(Temp); + raise; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean; +var + SourceFD, DestFD: TFormatDescriptor; + SourcePD, DestPD: TglBitmapPixelData; + ShiftData: TShiftData; + + function DataIsIdentical: Boolean; + begin + result := + (SourceFD.RedMask = DestFD.RedMask) and + (SourceFD.GreenMask = DestFD.GreenMask) and + (SourceFD.BlueMask = DestFD.BlueMask) and + (SourceFD.AlphaMask = DestFD.AlphaMask); + end; + + function CanCopyDirect: Boolean; + begin + result := + ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + end; + + function CanShift: Boolean; + begin + result := + ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + end; + + function GetShift(aSource, aDest: Cardinal) : ShortInt; + begin + result := 0; + while (aSource > aDest) and (aSource > 0) do begin + inc(result); + aSource := aSource shr 1; + end; + end; + +begin + if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin + SourceFD := TFormatDescriptor.Get(Format); + DestFD := TFormatDescriptor.Get(aFormat); + + if DataIsIdentical then begin + result := true; + Format := aFormat; + exit; + end; + + SourceFD.PreparePixel(SourcePD); + DestFD.PreparePixel (DestPD); + + if CanCopyDirect then + result := AddFunc(Self, glBitmapConvertCopyFunc, false, aFormat) + else if CanShift then begin + ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); + ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); + ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); + ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); + result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); + end else + result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); + end else + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); +begin + if aUseRGB or aUseAlpha then + AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( + ((Byte(aUseAlpha) and 1) shl 1) or + (Byte(aUseRGB) and 1) )); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.FreeData; +var + TempPtr: PByte; +begin + TempPtr := nil; + SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte; + const aAlpha: Byte); +begin + FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 TglBitmap.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; + AddFunc(glBitmapFillWithColorFunc, false, @PixelData); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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(false); + glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag); + + if (MipMap = mmNone) or (Target = GL_TEXTURE_RECTANGLE) 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 + GL_CLAMP: + aTarget := GL_CLAMP; + + GL_REPEAT: + aTarget := GL_REPEAT; + + GL_CLAMP_TO_EDGE: begin + if GL_VERSION_1_2 or GL_EXT_texture_edge_clamp then + aTarget := GL_CLAMP_TO_EDGE + else + aTarget := GL_CLAMP; + end; + + 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; + + GL_MIRRORED_REPEAT: begin + if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then + aTarget := GL_MIRRORED_REPEAT + else + raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); + end; + 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(false); + glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS); + glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT); + glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 + 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'); + CheckAndSetValue(r, 0); + CheckAndSetValue(g, 1); + CheckAndSetValue(b, 2); + CheckAndSetValue(a, 3); + + if (ID > 0) then begin + Bind(false); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0])); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); +begin + if aEnableTextureUnit then + glEnable(Target); + if (ID > 0) then + glBindTexture(Target, ID); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean); +begin + if aDisableTextureUnit then + glDisable(Target); + glBindTexture(Target, 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create; +begin + if (ClassType = TglBitmap) then + raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); +{$IFDEF GLB_NATIVE_OGL} + glbReadOpenGLExtensions; +{$ENDIF} + inherited Create; + fFormat := glBitmapGetDefaultFormat; + fFreeDataOnDestroy := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aFileName: String); +begin + Create; + LoadFromFile(aFileName); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aStream: TStream); +begin + Create; + LoadFromStream(aStream); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; 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); + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + except + if Assigned(aData) then + FreeMem(aData); + raise; + end; + end else begin + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + fFreeDataOnDestroy := false; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); +begin + Create; + LoadFromFunc(aSize, aFunc, aFormat, aArgs); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); +begin + Create; + LoadFromResource(aInstance, aResource, aResType); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmap.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); +begin + Create; + LoadFromResourceID(aInstance, aResourceID, aResType); +end; + +{$IFDEF GLB_SUPPORT_PNG_READ} +{$IF DEFINED(GLB_LAZ_PNG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//PNG///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.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 TglBitmap.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 := tfLuminance8; + PNG_COLOR_TYPE_GRAY_ALPHA: + Format := tfLuminance8Alpha8; + PNG_COLOR_TYPE_RGB: + Format := tfRGB8; + PNG_COLOR_TYPE_RGB_ALPHA: + Format := tfRGBA8; + 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 + SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method + + result := true; + except + if Assigned(png_data) then + FreeMem(png_data); + raise; + end; + end; + finally + quit_libPNG; + end; +end; + +{$ELSEIF DEFINED(GLB_PNGIMAGE)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 := tfLuminance8; + COLOR_GRAYSCALEALPHA: + PngFormat := tfLuminance8Alpha8; + COLOR_RGB: + PngFormat := tfBGR8; + COLOR_RGBALPHA: + PngFormat := tfBGRA8; + 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; + + SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method + + 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 TglBitmap.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 TglBitmap.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 + tfAlpha8, tfLuminance8: + ColorType := PNG_COLOR_TYPE_GRAY; + tfLuminance8Alpha8: + ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; + tfBGR8, tfRGB8: + ColorType := PNG_COLOR_TYPE_RGB; + tfBGRA8, tfRGBA8: + 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 [tfBGR8, tfBGRA8] 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 TglBitmap.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 + tfAlpha8, tfLuminance8: begin + ColorType := COLOR_GRAYSCALE; + PixSize := 1; + Alpha := false; + end; + tfLuminance8Alpha8: begin + ColorType := COLOR_GRAYSCALEALPHA; + PixSize := 1; + Alpha := true; + end; + tfBGR8, tfRGB8: begin + ColorType := COLOR_RGB; + PixSize := 3; + Alpha := false; + end; + tfBGRA8, tfRGBA8: 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 [tfRGB8, tfRGBA8] 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 TglBitmap.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 TglBitmap.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 TglBitmap.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 := tfLuminance8; + end; + else + jpeg.out_color_space := JCS_RGB; + IntFormat := tfRGB8; + 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); + + SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method + + result := true; + except + if Assigned(pImage) then + FreeMem(pImage); + raise; + end; + end; + finally + quit_libJPEG; + end; +end; + +{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.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 TglBitmap.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 TglBitmap.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 + tfAlpha8, tfLuminance8: begin + jpeg.input_components := 1; + jpeg.in_color_space := JCS_GRAYSCALE; + end; + tfRGB8, tfBGR8: 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 = tfBGR8 then + GetMem(pTemp2, fRowSize) + else + pTemp2 := pTemp; + + try + for Row := 0 to jpeg.image_height -1 do begin + // prepare row + if Format = tfBGR8 then + CopyRow(pTemp2, pTemp) + else + pTemp2 := pTemp; + + // write row + jpeg_write_scanlines(@jpeg, @pTemp2, 1); + inc(pTemp, fRowSize); + end; + finally + // free memory + if Format = tfBGR8 then + FreeMem(pTemp2); + end; + jpeg_finish_compress(@jpeg); + jpeg_destroy_compress(@jpeg); + finally + quit_libJPEG; + end; +end; + +{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 [tfAlpha8, tfLuminance8]) 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} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//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 TglBitmap.LoadBMP(const aStream: TStream): Boolean; + + ////////////////////////////////////////////////////////////////////////////////////////////////// + function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat; + 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 + aStream.Read(aMask.r, SizeOf(aMask.r)); + aStream.Read(aMask.g, SizeOf(aMask.g)); + aStream.Read(aMask.b, SizeOf(aMask.b)); + aStream.Read(aMask.a, SizeOf(aMask.a)); + 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 := tfLuminance8; + 16: result := tfX1RGB5; + 24: result := tfRGB8; + 32: result := tfXRGB8; + end; + end; + + function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat; + var + i, c: Integer; + ColorTable: TbmpColorTable; + begin + result := nil; + if (aInfo.biBitCount >= 16) then + exit; + aFormat := tfLuminance8; + 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 := tfRGB8; + end; + + result := TbmpColorTableFormat.Create; + result.PixelSize := aInfo.biBitCount / 8; + result.ColorTable := ColorTable; + result.Range := glBitmapColorRec($FF, $FF, $FF, $00); + end; + + ////////////////////////////////////////////////////////////////////////////////////////////////// + function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec; + const aInfo: TBMPInfo): TbmpBitfieldFormat; + var + TmpFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + begin + result := nil; + if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin + for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + FormatDesc := TFormatDescriptor.Get(TmpFormat); + if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin + aFormat := FormatDesc.Format; + exit; + end; + end; + + if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then + aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha; + if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then + aFormat := TFormatDescriptor.Get(aFormat).WithAlpha; + + result := TbmpBitfieldFormat.Create; + result.PixelSize := aInfo.biBitCount / 8; + result.RedMask := aMask.r; + result.GreenMask := aMask.g; + result.BlueMask := aMask.b; + result.AlphaMask := aMask.a; + 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: TglBitmapColorRec; + 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.PixelSize); + 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; + SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method + 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 TglBitmap.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 + tfLuminance4: begin + Info.biBitCount := 4; + Header.bfSize := Header.bfSize + 16 * SizeOf(Cardinal); + Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries + Converter := TbmpColorTableFormat.Create; + with (Converter as TbmpColorTableFormat) do begin + PixelSize := 0.5; + Format := Format; + Range := glBitmapColorRec($F, $F, $F, $0); + CreateColorTable; + end; + end; + + tfR3G3B2, tfLuminance8: 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 + PixelSize := 1; + Format := Format; + if (Format = tfR3G3B2) then begin + Range := glBitmapColorRec($7, $7, $3, $0); + Shift := glBitmapShiftRec(0, 3, 6, 0); + end else + Range := glBitmapColorRec($FF, $FF, $FF, $0); + CreateColorTable; + end; + end; + + tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4, + tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin + Info.biBitCount := 16; + Info.biCompression := BMP_COMP_BITFIELDS; + end; + + tfBGR8, tfRGB8: begin + Info.biBitCount := 24; + if (Format = tfRGB8) then + Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values + end; + + tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8, + tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: 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.RedMask; + GreenMask := FormatDesc.GreenMask; + BlueMask := FormatDesc.BlueMask; + AlphaMask := FormatDesc.AlphaMask; + 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.PixelSize); + 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 TglBitmap.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 := tfLuminance8; + 8: tgaFormat := tfAlpha8; + end; + + 16: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfLuminance16; + 8: tgaFormat := tfLuminance8Alpha8; + end else case (Header.ImageDesc and $F) of + 0: tgaFormat := tfX1RGB5; + 1: tgaFormat := tfA1RGB5; + 4: tgaFormat := tfARGB4; + end; + + 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfRGB8; + end; + + 32: if not IsGrayFormat then case (Header.ImageDesc and $F) of + 2: tgaFormat := tfA2RGB10; + 8: tgaFormat := tfARGB8; + 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; + + SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method + result := true; + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; + end; + finally + aStream.Position := StartPosition; + end; + end + else aStream.Position := StartPosition; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SaveTGA(const aStream: TStream); +var + Header: TTGAHeader; + LineSize, Size, x, y: Integer; + Pixel: TglBitmapPixelData; + LineBuf, SourceData, DestData: PByte; + SourceMD, DestMD: Pointer; + FormatDesc: TFormatDescriptor; + Converter: TFormatDescriptor; +begin + if not (ftTGA in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); + + //prepare header + FillChar(Header{%H-}, SizeOf(Header), 0); + + //set ImageType + if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8, + tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then + Header.ImageType := TGA_UNCOMPRESSED_GRAY + else + Header.ImageType := TGA_UNCOMPRESSED_RGB; + + //set BitsPerPixel + if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then + Header.Bpp := 8 + else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8, + tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then + Header.Bpp := 16 + else if (Format in [tfBGR8, tfRGB8]) then + Header.Bpp := 24 + else + Header.Bpp := 32; + + //set AlphaBitCount + case Format of + tfRGB5A1, tfBGR5A1: + Header.ImageDesc := 1 and $F; + tfRGB10A2, tfBGR10A2: + Header.ImageDesc := 2 and $F; + tfRGBA4, tfBGRA4: + Header.ImageDesc := 4 and $F; + tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8: + Header.ImageDesc := 8 and $F; + end; + + Header.Width := Width; + Header.Height := Height; + Header.ImageDesc := Header.ImageDesc or $20; //flip y + aStream.Write(Header, SizeOf(Header)); + + // convert RGB(A) to BGR(A) + Converter := nil; + FormatDesc := TFormatDescriptor.Get(Format); + Size := FormatDesc.GetSize(Dimension); + if Format in [tfRGB5X1, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin + if (FormatDesc.RGBInverted = tfEmpty) then + raise EglBitmap.Create('inverted RGB format is empty'); + Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted); + if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or + (Converter.PixelSize <> FormatDesc.PixelSize) then + raise EglBitmap.Create('invalid inverted RGB format'); + end; + + if Assigned(Converter) then begin + LineSize := FormatDesc.GetSize(Width, 1); + GetMem(LineBuf, LineSize); + SourceMD := FormatDesc.CreateMappingData; + DestMD := Converter.CreateMappingData; + try + SourceData := Data; + for y := 0 to Height-1 do begin + DestData := LineBuf; + for x := 0 to Width-1 do begin + FormatDesc.Unmap(SourceData, Pixel, SourceMD); + Converter.Map(Pixel, DestData, DestMD); + end; + aStream.Write(LineBuf^, LineSize); + end; + finally + FreeMem(LineBuf); + FormatDesc.FreeMappingData(SourceMD); + FormatDesc.FreeMappingData(DestMD); + end; + end else + 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 TglBitmap.LoadDDS(const aStream: TStream): Boolean; +var + Header: TDDSHeader; + Converter: TbmpBitfieldFormat; + + function GetDDSFormat: TglBitmapFormat; + var + fd: TFormatDescriptor; + i: Integer; + Range: TglBitmapColorRec; + 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)) > 0) then begin + // prepare masks + if ((dwFlags and DDPF_LUMINANCE) = 0) then begin + Range.r := dwRBitMask; + Range.g := dwGBitMask; + Range.b := dwBBitMask; + end else begin + Range.r := dwRBitMask; + Range.g := dwRBitMask; + Range.b := dwRBitMask; + end; + Range.a := dwABitMask; + + //find matching format + for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + fd := TFormatDescriptor.Get(result); + if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and + (8 * fd.PixelSize = dwRGBBitCount) then + exit; + end; + + //find format with same Range + for i := 0 to 3 do begin + while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do + Range.arr[i] := Range.arr[i] shr 1; + end; + 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 := tfRGBA8 + else + result := tfRGB8; + end; + + Converter := TbmpBitfieldFormat.Create; + Converter.RedMask := dwRBitMask; + Converter.GreenMask := dwGBitMask; + Converter.BlueMask := dwBBitMask; + Converter.AlphaMask := dwABitMask; + Converter.PixelSize := dwRGBBitCount / 8; + 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.PixelSize); + 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.'); + + SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method + result := true; + except + if Assigned(NewImage) then + FreeMem(NewImage); + raise; + end; + finally + FreeAndNil(Converter); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.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 (Format in [tfAlpha8, tfAlpha16]) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + end else begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; + Header.PixelFormat.dwGBitMask := FormatDesc.GreenMask; + Header.PixelFormat.dwBBitMask := FormatDesc.BlueMask; + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + 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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer; const aHeight: Integer); +var + pTemp: pByte; + Size: Integer; +begin + if (aHeight > 1) then begin + Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1); + GetMem(pTemp, Size); + try + Move(aData^, pTemp^, Size); + FreeMem(aData); + aData := nil; + except + FreeMem(pTemp); + raise; + end; + end else + pTemp := aData; + inherited SetDataPointer(pTemp, aFormat, aWidth); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap1D.FlipHorz: Boolean; +var + Col: Integer; + pTempDest, pDest, pSource: PByte; +begin + result := inherited FlipHorz; + if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin + pSource := Data; + GetMem(pDest, fRowSize); + try + pTempDest := pDest; + Inc(pTempDest, fRowSize); + for Col := 0 to Width-1 do begin + dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data + Move(pSource^, pTempDest^, fPixelSize); + Inc(pSource, fPixelSize); + end; + SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method + result := true; + except + if Assigned(pDest) then + FreeMem(pDest); + raise; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean); +var + FormatDesc: TFormatDescriptor; +begin + // Upload data + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then begin + if not Assigned(glCompressedTexImage1D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); + glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data) + end else if aBuildWithGlu then + gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) + else + glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data); + + // Free Data + if (FreeDataAfterGenTexture) then + FreeData; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean); +var + BuildWithGlu, TexRec: Boolean; + TexSize: Integer; +begin + if Assigned(Data) then begin + // Check Texture Size + if (aTestTextureSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); + + if (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(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; + + CreateId; + SetupParameters(BuildWithGlu); + UploadData(BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.AfterConstruction; +begin + inherited; + Target := GL_TEXTURE_1D; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer; +begin + if (aIndex >= Low(fLines)) and (aIndex <= High(fLines)) then + result := fLines[aIndex] + else + result := nil; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer; const aHeight: Integer); +var + Idx, LineWidth: Integer; +begin + inherited SetDataPointer(aData, aFormat, aWidth, aHeight); + + if not TFormatDescriptor.Get(aFormat).IsCompressed then begin + // Assigning Data + if Assigned(Data) then begin + SetLength(fLines, GetHeight); + LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize); + + for Idx := 0 to GetHeight-1 do begin + fLines[Idx] := Data; + Inc(fLines[Idx], Idx * LineWidth); + end; + end + else SetLength(fLines, 0); + end else begin + SetLength(fLines, 0); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); +var + FormatDesc: TFormatDescriptor; +begin + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then begin + if not Assigned(glCompressedTexImage2D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); + glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) + end else if aBuildWithGlu then begin + gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, + FormatDesc.glFormat, FormatDesc.glDataFormat, Data) + end else begin + glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, + FormatDesc.glFormat, FormatDesc.glDataFormat, Data); + end; + + // Freigeben + if (FreeDataAfterGenTexture) then + FreeData; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.AfterConstruction; +begin + inherited; + Target := GL_TEXTURE_2D; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); +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); + SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method + FlipVert; + except + if Assigned(Temp) then + FreeMem(Temp); + raise; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.GetDataFromTexture; +var + Temp: PByte; + TempWidth, TempHeight: Integer; + TempIntFormat: GLint; + IntFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; +begin + 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); + + IntFormat := tfEmpty; + 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); + SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method + except + if Assigned(Temp) then + FreeMem(Temp); + raise; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean); +var + BuildWithGlu, PotTex, TexRec: Boolean; + TexSize: Integer; +begin + if Assigned(Data) then begin + // Check Texture Size + if (aTestTextureSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); + + if ((Height > TexSize) or (Width > 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(Height) and IsPowerOfTwo(Width); + 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.'); + end; + + CreateId; + SetupParameters(BuildWithGlu); + UploadData(Target, BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap2D.FlipHorz: Boolean; +var + Col, Row: Integer; + TempDestData, DestData, SourceData: PByte; + ImgSize: Integer; +begin + result := inherited FlipHorz; + if Assigned(Data) then begin + SourceData := Data; + ImgSize := Height * fRowSize; + GetMem(DestData, ImgSize); + try + TempDestData := DestData; + Dec(TempDestData, fRowSize + fPixelSize); + for Row := 0 to Height -1 do begin + Inc(TempDestData, fRowSize * 2); + for Col := 0 to Width -1 do begin + Move(SourceData^, TempDestData^, fPixelSize); + Inc(SourceData, fPixelSize); + Dec(TempDestData, fPixelSize); + end; + end; + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method + result := true; + except + if Assigned(DestData) then + FreeMem(DestData); + raise; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap2D.FlipVert: Boolean; +var + Row: Integer; + TempDestData, DestData, SourceData: PByte; +begin + result := inherited FlipVert; + if Assigned(Data) then begin + SourceData := Data; + GetMem(DestData, Height * fRowSize); + try + TempDestData := DestData; + Inc(TempDestData, Width * (Height -1) * fPixelSize); + for Row := 0 to Height -1 do begin + Move(SourceData^, TempDestData^, fRowSize); + Dec(TempDestData, fRowSize); + Inc(SourceData, fRowSize); + end; + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method + result := true; + except + if Assigned(DestData) then + FreeMem(DestData); + raise; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap2D - ToNormalMap/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 TglBitmap2D.ToNormalMap(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 + AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) + else + AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec); + AddFunc(glBitmapToNormalMapFunc, false, @Rec); + finally + SetLength(Rec.Heights, 0); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapCubeMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean); +begin + Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.AfterConstruction; +begin + inherited; + + 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.'); + + SetWrap; + Target := GL_TEXTURE_CUBE_MAP; + fGenMode := GL_REFLECTION_MAP; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean); +var + BuildWithGlu: Boolean; + TexSize: Integer; +begin + if (aTestTextureSize) then begin + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize); + + if (Height > TexSize) or (Width > TexSize) then + raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); + + if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.'); + end; + + if (ID = 0) then + CreateID; + SetupParameters(BuildWithGlu); + UploadData(aCubeTarget, BuildWithGlu); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean); +begin + inherited Bind (aEnableTextureUnit); + 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; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean); +begin + inherited Unbind(aDisableTextureUnit); + if aDisableTexCoordsGen then begin + glDisable(GL_TEXTURE_GEN_S); + glDisable(GL_TEXTURE_GEN_T); + glDisable(GL_TEXTURE_GEN_R); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//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; + fGenMode := GL_NORMAL_MAP; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); +var + Rec: TglBitmapNormalMapRec; + SizeRec: TglBitmapPixelPosition; +begin + Rec.HalfSize := aSize div 2; + FreeDataAfterGenTexture := false; + + SizeRec.Fields := [ffX, ffY]; + SizeRec.X := aSize; + SizeRec.Y := aSize; + + // Positive X + Rec.Func := glBitmapNormalMapPosX; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); + + // Negative X + Rec.Func := glBitmapNormalMapNegX; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); + + // Positive Y + Rec.Func := glBitmapNormalMapPosY; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); + + // Negative Y + Rec.Func := glBitmapNormalMapNegY; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); + + // Positive Z + Rec.Func := glBitmapNormalMapPosZ; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); + + // Negative Z + Rec.Func := glBitmapNormalMapNegZ; + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); +end; + + +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); + glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA); + + glBitmapSetDefaultFreeDataAfterGenTexture(true); + glBitmapSetDefaultDeleteTextureOnFree (true); + + TFormatDescriptor.Init; + +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + OpenGLInitialized := false; + InitOpenGLCS := TCriticalSection.Create; +{$ENDIF} + +finalization + TFormatDescriptor.Finalize; + +{$IFDEF GLB_NATIVE_OGL} + if Assigned(GL_LibHandle) then + glbFreeLibrary(GL_LibHandle); + +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + if Assigned(GLU_LibHandle) then + glbFreeLibrary(GLU_LibHandle); + FreeAndNil(InitOpenGLCS); +{$ENDIF} +{$ENDIF} + +end. diff --git a/uglcCamera.pas b/uglcCamera.pas new file mode 100644 index 0000000..197f676 --- /dev/null +++ b/uglcCamera.pas @@ -0,0 +1,271 @@ +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 + function GetWidth: Single; + function GetHeight: Single; + function GetFOVAngle: Single; + function GetAspectRatio: Single; + 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; + + 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; + procedure Render; + + constructor Create; + end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglcCamera = class(TglcFrustum) + private + fPosition: TgluMatrix4f; + public + property Position: TgluMatrix4f read fPosition write fPosition; + + 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, dglOpenGL; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglcFrustum/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglcFrustum.GetWidth: Single; +begin + result := (fRight - fLeft); +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; +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; +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; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcFrustum.Activate; +begin + glMatrixMode(GL_PROJECTION); + glLoadIdentity; + if fIsOrthogonal then + glOrtho(fLeft, fRight, fBottom, fTop, fNear, fFar) + else + glFrustum(fLeft, fRight, fBottom, fTop, fNear, fFar); + glMatrixMode(GL_MODELVIEW); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglcFrustum.Create; +begin + inherited Create; + fTop := 0; + fBottom := 0; + fLeft := 0; + fRight := 0; + fNear := 0; + fFar := 0; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglcCamera//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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..6255396 --- /dev/null +++ b/uglcContext.pas @@ -0,0 +1,346 @@ +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 + 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); virtual; overload; + constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); virtual; overload; + 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; + + private class var + fMainContextThreadID: TThreadID; + public + class property MainContextThreadID: TThreadID read fMainContextThreadID; + 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 + {$ENDIF} + {$IFDEF LINUX} + uglcContextGtk2GLX + {$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 + {$IFDEF WINDOWS} + Result:= TglcContextWGL; + {$ENDIF} + {$IFDEF LINUX} + Result:= TglcContextGtk2GLX; + {$ENDIF} +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 + TglcContext.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..76e0614 --- /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); + 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); override; overload; + constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); override; overload; + + 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..b08fba3 --- /dev/null +++ b/uglcFrameBufferObject.pas @@ -0,0 +1,652 @@ +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, dglOpenGl, 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; + private + fID: GLuint; + fOwnsObjects: Boolean; + fWidth: Integer; + fHeight: Integer; + fBuffers: TglcAttachmentContainerList; + + 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, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + 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'); + 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'); + 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; + b: GLboolean; + 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); + glDrawBuffer(GL_NONE); + end else begin + glDrawBuffers(Length(buff), @buff[0]); + glGetBooleanv(GL_DOUBLEBUFFER, @b); + if b then + glReadBuffer(GL_BACK) + else + glReadBuffer(GL_FRONT); + 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 + glPushAttrib(GL_VIEWPORT_BIT); + glViewPort(0, 0, fWidth, fHeight); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//Entbindet das FrameBufferObjekt +procedure TglcFrameBufferObject.Unbind(const aResetViewport: Boolean = true); +begin + if aResetViewport then + glPopAttrib; + 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..fd79ca5 --- /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, dglOpenGL, 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..750e8bc --- /dev/null +++ b/uglcShader.pas @@ -0,0 +1,975 @@ +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, dglOpenGL, uglcTypes, ugluMatrix, uglcContext; + +type +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + EglcShader = class(Exception); + TglcShaderProgram = class; + TglcShaderLogEvent = procedure(aSender: TObject; const aMsg: String) of Object; + TglcShaderObject = class(TObject) + private + fAtachedTo: TglcShaderProgram; + fShaderObj: GLHandle; + fShaderType: TglcShaderType; + fCode: String; + fOnLog: TglcShaderLogEvent; + fAttachedTo: TglcShaderProgram; + + function GetInfoLog(aObj: GLHandle): String; + function GetCompiled: Boolean; + procedure Log(const aMsg: String); + procedure CreateShaderObj; + procedure AttachTo(const aProgram: TglcShaderProgram); + public + property ShaderObj : GLHandle 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; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglcShaderProgram = class(TglcShaderObjectList) + private + fProgramObj: GLHandle; + fOnLog: TglcShaderLogEvent; + fFilename: String; + + function GetUniformLocation(const aName: String; out aPos: glInt): Boolean; + function GetInfoLog(Obj: GLHandle): String; + function GetCompiled: Boolean; + function GetLinked: Boolean; + + procedure CreateProgramObj; + procedure Log(const msg: String); + procedure AttachShaderObj(const aShaderObj: TglcShaderObject); + public + property ProgramObj: glHandle 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; + 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: GLHandle): 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 = 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: GLHandle): 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 = GL_TRUE); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglcShaderProgram.CreateProgramObj; +begin + if (fProgramObj = 0) then begin + if GL_LibHandle = nil then + raise EglcShader.Create('TglShaderProgram.Create - OpenGL not initialized'); + + if not TglcContext.IsAnyContextActive then + raise EglcShader.Create('TglShaderProgram.Create - no valid render context'); + + 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; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 + 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 + 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; + + + { + if Assigned(aStream) then begin + Clear; + fFilename := ''; + reader := TutlStreamReader.Create(aStream); + try + if reader.ReadAnsiString <> GLSL_FILE_HEADER then + raise EglcShader.Create('TglShaderProgram.SaveToStream - incompatible file'); + v := reader.ReadInteger; + + if v >= 100 then begin //version 1.00 + c := reader.ReadInteger; + for i := 0 to c-1 do begin + Add(TglcShaderObject.Create(Cardinal(reader.ReadInteger), fOnLog)); + Last.fCode := reader.ReadAnsiString; + end; + end; + finally + reader.Free; + end; + end else + } +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'; + TglcShaderType.stGeometry: result := 'GL_GEOMETRY_SHADER'; + TglcShaderType.stTessControl: result := 'GL_TESS_CONTROL_SHADER'; + TglcShaderType.stTessEvaluation: result := 'GL_TESS_EVALUATION_SHADER'; + 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. + \ No newline at end of file diff --git a/uglcTypes.pas b/uglcTypes.pas new file mode 100644 index 0000000..95ffb79 --- /dev/null +++ b/uglcTypes.pas @@ -0,0 +1,318 @@ +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 + dglOpenGL, sysutils; + +type + TglcFace = ( + faFront = GL_FRONT, + faBack = GL_BACK, + faBoth = GL_FRONT_AND_BACK); + + TglcPolygonMode = ( + pmPoint = GL_POINT, + pmLine = GL_LINE, + pmFill = GL_FILL); + + 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, + cbAccumBuffer = GL_ACCUM_BUFFER_BIT, + 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 = ( + twClamp = GL_CLAMP, + twRepeat = GL_REPEAT, + twClampToBorder = GL_CLAMP_TO_BORDER, + 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, + fmColorIndex = GL_COLOR_INDEX, + 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, + fmBGR = GL_BGR, + fmBGRA = GL_BGRA, + 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, + 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, + ifRGB8 = GL_RGB8, + ifRGB10 = GL_RGB10, + ifRGB12 = GL_RGB12, + ifRGB16 = GL_RGB16, + ifRGBA2 = GL_RGBA2, + ifRGBA4 = GL_RGBA4, + ifRGB5A1 = GL_RGB5_A1, + ifRGBA8 = GL_RGBA8, + ifRGB10A2 = GL_RGB10_A2, + ifRGBA12 = GL_RGBA12, + ifRGBA16 = GL_RGBA16, + ifDepthComponent16 = GL_DEPTH_COMPONENT16, + ifDepthComponent24 = GL_DEPTH_COMPONENT24, + 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, + ifRGBA32f = GL_RGBA32F, + ifRGB32f = GL_RGB32F, + ifRGBA16F = GL_RGBA16F, + ifRGB16F = GL_RGB16F, + ifDepth24Stencil8 = GL_DEPTH24_STENCIL8, + ifSRGB = GL_SRGB, + ifSRGB8 = GL_SRGB8, + ifSRGBA = GL_SRGB_ALPHA, + ifSRGBA8 = GL_SRGB8_ALPHA8, + ifSLuminanceAlpha = GL_SLUMINANCE_ALPHA, + ifSLuminance8Alpha8 = GL_SLUMINANCE8_ALPHA8, + ifSLuminance = GL_SLUMINANCE, + ifSLuminance8 = GL_SLUMINANCE8, + ifDepth32fStencil8 = GL_DEPTH32F_STENCIL8, + ifStencil1 = GL_STENCIL_INDEX1, + ifStencil4 = GL_STENCIL_INDEX4, + ifStencil8 = GL_STENCIL_INDEX8, + ifStencil16 = GL_STENCIL_INDEX16); + + 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, + stGeometry = GL_GEOMETRY_SHADER, + stTessEvaluation = GL_TESS_EVALUATION_SHADER, + stTessControl = GL_TESS_CONTROL_SHADER); + + 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 glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode); inline; +procedure glcDepthFunc(const aValue: TglcDepthFunc); inline; +procedure glcBlendFunc(const aSource, aDest: TglcBlendFactor); inline; overload; +procedure glcBlendFunc(const aMode: TglcBlendMode); inline; overload; +procedure glcCheckAndRaiseError; + +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 glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode); +begin + glPolygonMode(GLenum(aFace), GLenum(aValue)); +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; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//EOpenGL/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor EOpenGL.Create(const aErrorCode: GLenum); +begin + fErrorCode := aErrorCode; + inherited Create(gluErrorString(fErrorCode)); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor EOpenGL.Create(const aMsg: String; const aErrorCode: GLenum); +begin + fErrorCode := aErrorCode; + inherited Create(aMsg + ': ' + gluErrorString(fErrorCode)) +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..23d4680 --- /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, dglOpenGL; + +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: TVector4f; + sum: Single; + i, j: Integer; + m: array[0..3, 0..3] of TGLFloat; +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. +