DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-editor.git / blob


80c82315c6ae431f2aa01ccaef9857725d511975
[d2df-editor.git] / src / lib / dgl / dglOpenGL.pas
1 {==============================================================================}
2 { }
3 { OpenGL 3.2 - Headertranslation }
4 { Version 3.2.1 }
5 { Date : 15.09.2009 }
6 { }
7 { Works with : }
8 { - Delphi 3 and up }
9 { - FreePascal (1.9.3 and up) }
10 { }
11 {==============================================================================}
12 { }
13 { Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h. }
14 { It also contains some helperfunctions that were inspired by those }
15 { found in Mike Lischke's OpenGL12.pas. }
16 { }
17 { Copyright (C) DGL-OpenGL2-Portteam }
18 { All Rights Reserved }
19 { }
20 { Obtained through: }
21 { Delphi OpenGL Community(DGL) - www.delphigl.com }
22 { }
23 { Converted and maintained by DGL's GL2.0-Team : }
24 { - Sascha Willems - http://www.delphigl.de }
25 { - Steffen Xonna (Lossy eX) - http://www.dev-center.de }
26 { - Lars Middendorf - http://www.3d-seite.de }
27 { Additional input : }
28 { - Martin Waldegger (Mars) - http://www.basegraph.com }
29 { - Benjamin Rosseaux (BeRo) - http://www.0ok.de }
30 { Additional thanks: }
31 { sigsegv (libdl.so) }
32 { }
33 { }
34 {==============================================================================}
35 { You may retrieve the latest version of this file at the Delphi OpenGL }
36 { Community home page, located at http://www.delphigl.com/ }
37 { }
38 { The contents of this file are used with permission, subject to }
39 { the Mozilla Public License Version 1.1 (the "License"); you may }
40 { not use this file except in compliance with the License. You may }
41 { obtain a copy of the License at }
42 { http://www.mozilla.org/MPL/MPL-1.1.html }
43 { }
44 { Software distributed under the License is distributed on an }
45 { "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or }
46 { implied. See the License for the specific language governing }
47 { rights and limitations under the License. }
48 { }
49 {==============================================================================}
50 { History : }
51 { Version 1.0 Initial Release }
52 { Version 1.1 Added PPointer in Tpyessection for compatiblity with Delphi }
53 { versions lower than 7 (SW) }
54 { Added a function named RaiseLastOSError including a comment }
55 { on how to make it run under Delphi versions lower than 7 (SW) }
56 { Added some data types according to the GL-Syntax (SW) }
57 { Version 1.2 Fixed some problems with getting the addresses of some }
58 { Extensions (e.g. glTexImage3D) where the EXT/ARB did work }
59 { but not the core-functions (SW) }
60 { Version 1.3 A second call to ReadimplementationProperties won't }
61 { revert to the default libs anymore (MW) }
62 { Libraries now will be released if necessary (MW) }
63 { Version 1.3a Small fixes for glSlang-functions (SW) }
64 { Version 1.3b Fixed a small bug with GL_ARB_shader_objects, that lead }
65 { lead to that extension not loaded correctly (SW) }
66 { Version 1.3c more GL 1.5 compliance by FOG_COORD_xx and }
67 { ARB less VBO and occlusion query routines (MW) }
68 { Version 1.3d Fixed linebreaks (should now be corrected under D5) (SW) }
69 { Version 1.4 Changed header to correspond to the OpenGL-Shading }
70 { Language specification 1.10 : }
71 { - Added new GL_SAMPLER_*-Constants }
72 { - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB }
73 { - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB }
74 { - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW) }
75 { Version 1.4a Fixed a missing stdcall for glBindAttribLocationARB (SW) }
76 { Version 1.4b Fixed declaration for glUniform*(f/i)vARB (added count) (MW) }
77 { glCompileShaderARB changed from function to procedure (MW) }
78 { Version 1.5 Added support for FreePascal (BR) }
79 { Added type TGLVectorf3/TGLVector3f (SW) }
80 { Version 1.6 Added Extension GL_EXT_framebuffer_object (SX) }
81 { Version 1.7 Added Extension GL_ARB_fragment_program_shadow (SX) }
82 { Added Extension GL_ARB_draw_buffers (SX) }
83 { Added Extension GL_ARB_texture_rectangle (SX) }
84 { Added Extension GL_ARB_color_buffer_float (SX) }
85 { Added Extension GL_ARB_half_float_pixel (SX) }
86 { Added Extension GL_ARB_texture_float (SX) }
87 { Added Extension GL_ARB_pixel_buffer_object (SX) }
88 { Added Extension GL_EXT_depth_bounds_test (SX) }
89 { Added Extension GL_EXT_texture_mirror_clamp (SX) }
90 { Added Extension GL_EXT_blend_equation_separate (SX) }
91 { Added Extension GL_EXT_pixel_buffer_object (SX) }
92 { Added Extension GL_EXT_texture_compression_dxt1 (SX) }
93 { Added Extension GL_NV_fragment_program_option (SX) }
94 { Added Extension GL_NV_fragment_program2 (SX) }
95 { Added Extension GL_NV_vertex_program2_option (SX) }
96 { Added Extension GL_NV_vertex_program3 (SX) }
97 { Version 1.8 Added explicit delegate type definitions (LM) }
98 { Added .Net 1.1 Support (LM) }
99 { Added .Net overloaded functions (LM) }
100 { Added delayed extension loading and stubs (LM) }
101 { Added automatic InitOpenGL call in CreateRenderingContext(LM) }
102 { Added extra Read_* function (LM) }
103 { Version 2.0 fixed some Problem with version string and damn drivers. }
104 { String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX) }
105 { Removed unexisting extension GL_ARB_texture_mirror_repeat(SX) }
106 { Added Extension WGL_ARB_pixel_format_float (SX) }
107 { Added Extension GL_EXT_stencil_clear_tag (SX) }
108 { Added Extension GL_EXT_texture_rectangle (SX) }
109 { Added Extension GL_EXT_texture_edge_clamp (SX) }
110 { Some 1.5 Core Consts added (now completed) (SX) }
111 { gluProject need pointer for not .net (SX) }
112 { gluUnProject need pointer for not .net (SX) }
113 { wglUseFontOutlines* need pointer for not .net (SX) }
114 { wglSwapMultipleBuffers need pointer for not .net (SX) }
115 { Bug with wglGetExtensionsStringEXT removed }
116 { different type for .net (SX) }
117 { Added OpenGL 2.0 Core (SX) }
118 { Version 2.0.1 fixed some problems with glGetActiveAttrib in 2.0 Core (SX) }
119 { fixes some problems with gluProject (SX) }
120 { fixes some problems with gluUnProject (SX) }
121 { fixes some problems with gluTessVertex (SX) }
122 { fixes some problems with gluLoadSamplingMatrices (SX) }
123 { Version 2.1 Removed .NET Support (SX) }
124 { Better support for Linux (SX) }
125 { Better Codeformation (SX) }
126 { Added some more Vector/Matrix types (SX) }
127 { Added OpenGL 2.1 Core (SX) }
128 { Added Extension GL_EXT_packed_depth_stencil (SX) }
129 { Added Extension GL_EXT_texture_sRGB (SX) }
130 { Added Extension GL_EXT_framebuffer_blit (SX) }
131 { Added Extension GL_EXT_framebuffer_multisample (SX) }
132 { Added Extension GL_EXT_timer_query (SX) }
133 { Added Extension GL_EXT_gpu_program_parameters (SX) }
134 { Added Extension GL_EXT_bindable_uniform (SX) }
135 { Added Extension GL_EXT_draw_buffers2 (SX) }
136 { Added Extension GL_EXT_draw_instanced (SX) }
137 { Added Extension GL_EXT_framebuffer_sRGB (SX) }
138 { Added Extension GL_EXT_geometry_shader4 (SX) }
139 { Added Extension GL_EXT_gpu_shader4 (SX) }
140 { Added Extension GL_EXT_packed_float (SX) }
141 { Added Extension GL_EXT_texture_array (SX) }
142 { Added Extension GL_EXT_texture_buffer_object (SX) }
143 { Added Extension GL_EXT_texture_compression_latc (SX) }
144 { Added Extension GL_EXT_texture_compression_rgtc (SX) }
145 { Added Extension GL_EXT_texture_integer (SX) }
146 { Added Extension GL_EXT_texture_shared_exponent (SX) }
147 { Added Extension GL_NV_depth_buffer_float (SX) }
148 { Added Extension GL_NV_fragment_program4 (SX) }
149 { Added Extension GL_NV_framebuffer_multisample_coverage (SX) }
150 { Added Extension GL_NV_geometry_program4 (SX) }
151 { Added Extension GL_NV_gpu_program4 (SX) }
152 { Added Extension GL_NV_parameter_buffer_object (SX) }
153 { Added Extension GL_NV_transform_feedback (SX) }
154 { Added Extension GL_NV_vertex_program4 (SX) }
155 { Version 3.0 fixed some const of GL_EXT_texture_shared_exponent (SX) }
156 { possible better support for mac (SX) }
157 { Added OpenGL 3.0 Core (SX) }
158 { Added Extension GL_ARB_depth_buffer_float (SX) }
159 { Added Extension GL_ARB_draw_instanced (SX) }
160 { Added Extension GL_ARB_framebuffer_object (SX) }
161 { Added Extension GL_ARB_framebuffer_sRGB (SX) }
162 { Added Extension GL_ARB_geometry_shader4 (SX) }
163 { Added Extension GL_ARB_half_float_vertex (SX) }
164 { Added Extension GL_ARB_instanced_arrays (SX) }
165 { Added Extension GL_ARB_map_buffer_range (SX) }
166 { Added Extension GL_ARB_texture_buffer_object (SX) }
167 { Added Extension GL_ARB_texture_compression_rgtc (SX) }
168 { Added Extension GL_ARB_texture_rg (SX) }
169 { Added Extension GL_ARB_vertex_array_object (SX) }
170 { Added Extension GL_NV_conditional_render (SX) }
171 { Added Extension GL_NV_present_video (SX) }
172 { Added Extension GL_EXT_transform_feedback (SX) }
173 { Added Extension GL_EXT_direct_state_access (SX) }
174 { Added Extension GL_EXT_vertex_array_bgra (SX) }
175 { Added Extension GL_EXT_texture_swizzle (SX) }
176 { Added Extension GL_NV_explicit_multisample (SX) }
177 { Added Extension GL_NV_transform_feedback2 (SX) }
178 { Added Extension WGL_ARB_create_context (SX) }
179 { Added Extension WGL_NV_present_video (SX) }
180 { Added Extension WGL_NV_video_out (SX) }
181 { Added Extension WGL_NV_swap_group (SX) }
182 { Added Extension WGL_NV_gpu_affinity (SX) }
183 { Added define DGL_TINY_HEADER to suppress automatic }
184 { function loading (SX) }
185 { glProcedure renamed to dglGetProcAddress and now it's }
186 { visible from outside the unit to custom load functions (SX) }
187 { dglCheckExtension added to check if an extension exists (SX) }
188 { Read_GL_ARB_buffer_object renamed to }
189 { Read_GL_ARB_vertex_buffer_object (SX) }
190 { Version 3.0.1 fixed an problem with fpc (SX) }
191 { Version 3.0.2 fixed an problem with WGL_ARB_create_context (SX) }
192 { Version 3.2 Functions from GL_VERSION_3_0 where updated (SX) }
193 { Functions from GL_ARB_map_buffer_range where updated (SX) }
194 { Functions from GL_NV_present_video where added (SX) }
195 { Added consts of GL_ARB_instanced_arrays (SX) }
196 { Defines to identify Delphi was changed (prevent for }
197 { feature maintenance) (SX) }
198 { Added Extension GL_ATI_meminfo (SX) }
199 { Added Extension GL_AMD_performance_monitor (SX) }
200 { Added Extension GL_AMD_texture_texture4 (SX) }
201 { Added Extension GL_AMD_vertex_shader_tesselator (SX) }
202 { Added Extension GL_EXT_provoking_vertex (SX) }
203 { Added Extension WGL_AMD_gpu_association (SX) }
204 { Added OpenGL 3.1 Core (SX) }
205 { All deprecated stuff can be disabled if you undef the }
206 { define DGL_DEPRECATED (SX) }
207 { Added Extension GL_ARB_uniform_buffer_object (SX) }
208 { Added Extension GL_ARB_compatibility (SX) }
209 { Added Extension GL_ARB_copy_buffer (SX) }
210 { Added Extension GL_ARB_shader_texture_lod (SX) }
211 { Remove function from GL_NV_present_video (SX) }
212 { Added Extension WGL_3DL_stereo_control (SX) }
213 { Added Extension GL_EXT_texture_snorm (SX) }
214 { Added Extension GL_AMD_draw_buffers_blend (SX) }
215 { Added Extension GL_APPLE_texture_range (SX) }
216 { Added Extension GL_APPLE_float_pixels (SX) }
217 { Added Extension GL_APPLE_vertex_program_evaluators (SX) }
218 { Added Extension GL_APPLE_aux_depth_stencil (SX) }
219 { Added Extension GL_APPLE_object_purgeable (SX) }
220 { Added Extension GL_APPLE_row_bytes (SX) }
221 { Added OpenGL 3.2 Core (SX) }
222 { Added Extension GL_ARB_depth_clamp (SX) }
223 { Added Extension GL_ARB_draw_elements_base_vertex (SX) }
224 { Added Extension GL_ARB_fragment_coord_conventions (SX) }
225 { Added Extension GL_ARB_provoking_vertex (SX) }
226 { Added Extension GL_ARB_seamless_cube_map (SX) }
227 { Added Extension GL_ARB_sync (SX) }
228 { Added Extension GL_ARB_texture_multisample (SX) }
229 { Added Extension GL_ARB_vertex_array_bgra (SX) }
230 { Added Extension GL_ARB_draw_buffers_blend (SX) }
231 { Added Extension GL_ARB_sample_shading (SX) }
232 { Added Extension GL_ARB_texture_cube_map_array (SX) }
233 { Added Extension GL_ARB_texture_gather (SX) }
234 { Added Extension GL_ARB_texture_query_lod (SX) }
235 { Added Extension WGL_ARB_create_context_profile (SX) }
236 { Added GLX Core up to Version 1.4 (SX) }
237 { Added Extension GLX_ARB_multisample (SX) }
238 { Added Extension GLX_ARB_fbconfig_float (SX) }
239 { Added Extension GLX_ARB_get_proc_address (SX) }
240 { Added Extension GLX_ARB_create_context (SX) }
241 { Added Extension GLX_ARB_create_context_profile (SX) }
242 { Added Extension GLX_EXT_visual_info (SX) }
243 { Added Extension GLX_EXT_visual_rating (SX) }
244 { Added Extension GLX_EXT_import_context (SX) }
245 { Added Extension GLX_EXT_fbconfig_packed_float (SX) }
246 { Added Extension GLX_EXT_framebuffer_sRGB (SX) }
247 { Added Extension GLX_EXT_texture_from_pixmap (SX) }
248 { Version 3.2.1 Fixed some problems with Delphi < 6 (SX) }
249
250
251 {==============================================================================}
252 { Header based on glext.h rev 54 (2009-08-03) }
253 { This is an important notice for maintaining. Dont remove it. And make sure }
254 { to keep him up to date }
255 {==============================================================================}
256
257
258 {$define DGL_DEPRECATED}
259 {
260 This define defines if the header should use deprecated ARB stuff or not.
261 per Default the Header use deprecated Stuff.
262 }
263
264
265 {.$define DGL_TINY_HEADER}
266 {
267 If you enable the define DGL_TINY_HEADER no function automatically will be loaded if you
268 call ActivateRenderingContext. This may some bit faster and the smart linker can delete
269 all non used functions. This will reduce the filesize of your binary file. But in this
270 case you have to load the functions by yourself. There are two ways to do this.
271
272 1. You can load whole extension by calling the func Read_Extensionname. But if you do
273 this it's possible to load functions you dont use. So you have the same "problem"
274 like before. But it's only an bit smaler.
275 > Read_GL_ARB_multitexture;
276
277 2. You are able to load only the functions you exactly need. In this case you are able
278 to use the variables of the dglOpenGL.pas. So you only need to load the functions
279 and you can use the header like before.
280 To do this you have to created and activated an opengl context and than you can load
281 the needed functions.
282 > ActivateRenderingContext(fDC, fRC);
283 > glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
284 > glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
285
286 So only the function "glActiveTextureARB" and "glMultiTexCoord2fARB" will be loaded.
287
288
289 Please notice that the extension variables won't be loaded if this define is active. But
290 you can call dglCheckExtension to check if any extension exists. You can assign them to
291 the variables of the dglOpenGL.pas so all code they use this will find them.
292
293 > GL_ARB_shading_language_100 := dglCheckExtension('GL_ARB_shading_language_100');
294 }
295
296
297 unit dglOpenGL;
298
299 interface
300
301 // defines to configure freepascal
302 {$IFDEF FPC}
303 {$MODE Delphi}
304
305 {$IFNDEF WINDOWS}
306 {$LINKLIB c}
307 {$ENDIF}
308 {$ENDIF}
309
310 // known delphi versions
311 {$IFNDEF FPC} // if freepascal isnt defined
312 {$IFDEF VER140} // Delphi 6
313 {$DEFINE DELPHI6_AND_DOWN}
314 {$ENDIF}
315
316 {$IFDEF VER130} // Delphi 5
317 {$DEFINE DELPHI6_AND_DOWN}
318 {$ENDIF}
319
320 {$IFDEF VER120} // Delphi 4
321 {$DEFINE DELPHI6_AND_DOWN}
322 {$ENDIF}
323
324 {$IFDEF VER110} // C++ Builder 3
325 {$DEFINE DELPHI6_AND_DOWN}
326 {$ENDIF}
327
328 {$IFDEF VER100} // Delphi 3
329 {$DEFINE DELPHI6_AND_DOWN}
330 {$ENDIF}
331 {$ENDIF}
332
333 // Options for Delphi < 5
334 {$IFDEF DELPHI6_AND_DOWN}
335 {$A+}
336 {$ELSE}
337 {$A4}
338 {$ENDIF}
339
340 // generell options
341 {$H+,O+,X+}
342
343 // detecting Windows
344 {$IFDEF Win32} // Delphi and fpc of 32 Bit Windows
345 {$DEFINE DGL_WIN}
346 {$ENDIF}
347
348 {$IFDEF Win64} // Delphi and fpc of 32 Bit Windows
349 {$DEFINE DGL_WIN}
350 {$ENDIF}
351
352 // detecting Linux
353 {$IFDEF linux} // Linux
354 {$DEFINE DGL_LINUX}
355 {$ENDIF}
356
357 // detecting 64 Bit CPU
358 {$IFDEF CPU64} // fpc on 64 bit cpus
359 {$DEFINE DGL_64BIT} // dgl define for 64 bit
360 {$ENDIF}
361
362
363
364 uses
365 SysUtils
366 {$IFDEF DGL_WIN}, Windows{$ENDIF}
367 {$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF}
368 ;
369
370 type
371 // Needed for Delphi 6 and less (defined in system.pas for Delphi 7)
372 PPointer = ^Pointer;
373 PCardinal = ^Cardinal;
374
375 GLenum = Cardinal;
376 GLboolean = BYTEBOOL;
377 GLbitfield = Cardinal;
378 GLbyte = Shortint;
379 GLshort = SmallInt;
380 GLint = Integer;
381 GLsizei = Integer;
382 GLubyte = Byte;
383 GLushort = Word;
384 GLuint = Cardinal;
385 GLfloat = Single;
386 GLclampf = Single;
387 GLdouble = Double;
388 GLclampd = Double;
389 GLvoid = Pointer;
390 GLint64 = Int64;
391 GLuint64 = {$IFDEF DELPHI6_AND_DOWN} Int64 {$ELSE} UInt64 {$ENDIF};
392
393 TGLenum = GLenum;
394 TGLboolean = GLboolean;
395 TGLbitfield = GLbitfield;
396 TGLbyte = GLbyte;
397 TGLshort = GLshort;
398 TGLint = GLint;
399 TGLsizei = GLsizei;
400 TGLubyte = GLubyte;
401 TGLushort = GLushort;
402 TGLuint = GLuint;
403 TGLfloat = GLfloat;
404 TGLclampf = GLclampf;
405 TGLdouble = GLdouble;
406 TGLclampd = GLclampd;
407 TGLvoid = GLvoid;
408 TGLint64 = GLint64;
409 TGLuint64 = GLuint64;
410
411 PGLboolean = ^GLboolean;
412 PGLbyte = ^GLbyte;
413 PGLshort = ^GLshort;
414 PGLint = ^GLint;
415 PGLsizei = ^GLsizei;
416 PGLubyte = ^GLubyte;
417 PGLushort = ^GLushort;
418 PGLuint = ^GLuint;
419 PGLclampf = ^GLclampf;
420 PGLfloat = ^GLfloat;
421 PGLdouble = ^GLdouble;
422 PGLclampd = ^GLclampd;
423 PGLenum = ^GLenum;
424 PGLvoid = Pointer;
425 PPGLvoid = ^PGLvoid;
426 PGLint64 = ^GLint64;
427
428 // GL_NV_half_float
429 GLhalfNV = WORD;
430 TGLhalfNV = GLhalfNV;
431 PGLhalfNV = ^GLhalfNV;
432
433 // GL_ARB_shader_objects
434 PGLHandleARB = ^GLHandleARB;
435 GLHandleARB = Integer;
436 GLcharARB = AnsiChar;
437 PGLcharARB = PAnsiChar;
438 PPGLcharARB = ^PGLcharARB;
439
440 // GL_VERSION_2_0
441 GLHandle = Integer;
442 PGLchar = PAnsiChar;
443 PPGLchar = ^PGLChar;
444
445 // GL_EXT_timer_query
446 GLint64EXT = Int64;
447 TGLint64EXT = GLint64EXT;
448 PGLint64EXT = ^TGLint64EXT;
449
450 GLuint64EXT = TGLuint64;
451 TGLuint64EXT = GLuint64EXT;
452 PGLuint64EXT = ^TGLuint64EXT;
453
454 // WGL_ARB_pbuffer
455 HPBUFFERARB = THandle;
456
457 // WGL_EXT_pbuffer
458 HPBUFFEREXT = THandle;
459
460 // WGL_NV_present_video
461 PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV;
462 HVIDEOOUTPUTDEVICENV = THandle;
463
464 // WGL_NV_video_out
465 PHPVIDEODEV = ^HPVIDEODEV;
466 HPVIDEODEV = THandle;
467
468 // WGL_NV_gpu_affinity
469 PHPGPUNV = ^HPGPUNV;
470 PHGPUNV = ^HGPUNV;
471
472 HPGPUNV = THandle;
473 HGPUNV = THandle;
474
475 // ARB_sync
476 GLsync = Pointer;
477
478 // GLX
479 {$IFDEF DGL_LINUX}
480 GLXContext = Pointer;
481 GLXContextID = TXID;
482 GLXDrawable = TXID;
483 GLXFBConfig = Pointer;
484 GLXPbuffer = TXID;
485 GLXPixmap = TXID;
486 GLXWindow = TXID;
487
488 Window = TXID;
489 Colormap = TXID;
490 Pixmap = TXID;
491 Font = TXID;
492 {$ENDIF}
493
494 // Datatypes corresponding to GL's types TGL(name)(type)(count)
495 TGLVectorub2 = array[0..1] of TGLubyte;
496 TGLVectori2 = array[0..1] of TGLint;
497 TGLVectorf2 = array[0..1] of TGLfloat;
498 TGLVectord2 = array[0..1] of TGLdouble;
499 TGLVectorp2 = array[0..1] of Pointer;
500
501 TGLVectorub3 = array[0..2] of TGLubyte;
502 TGLVectori3 = array[0..2] of TGLint;
503 TGLVectorf3 = array[0..2] of TGLfloat;
504 TGLVectord3 = array[0..2] of TGLdouble;
505 TGLVectorp3 = array[0..2] of Pointer;
506
507 TGLVectorub4 = array[0..3] of TGLubyte;
508 TGLVectori4 = array[0..3] of TGLint;
509 TGLVectorf4 = array[0..3] of TGLfloat;
510 TGLVectord4 = array[0..3] of TGLdouble;
511 TGLVectorp4 = array[0..3] of Pointer;
512
513 TGLArrayf4 = TGLVectorf4;
514 TGLArrayf3 = TGLVectorf3;
515 TGLArrayd3 = TGLVectord3;
516 TGLArrayi4 = TGLVectori4;
517 TGLArrayp4 = TGLVectorp4;
518
519 TGlMatrixub3 = array[0..2, 0..2] of TGLubyte;
520 TGlMatrixi3 = array[0..2, 0..2] of TGLint;
521 TGLMatrixf3 = array[0..2, 0..2] of TGLfloat;
522 TGLMatrixd3 = array[0..2, 0..2] of TGLdouble;
523
524 TGlMatrixub4 = array[0..3, 0..3] of TGLubyte;
525 TGlMatrixi4 = array[0..3, 0..3] of TGLint;
526 TGLMatrixf4 = array[0..3, 0..3] of TGLfloat;
527 TGLMatrixd4 = array[0..3, 0..3] of TGLdouble;
528
529 TGLVector3f = TGLVectorf3;
530
531 // Datatypes corresponding to OpenGL12.pas for easy porting
532 TVector3d = TGLVectord3;
533
534 TVector4i = TGLVectori4;
535 TVector4f = TGLVectorf4;
536 TVector4p = TGLVectorp4;
537
538 TMatrix4f = TGLMatrixf4;
539 TMatrix4d = TGLMatrixd4;
540
541 PGLMatrixd4 = ^TGLMatrixd4;
542 PVector4i = ^TVector4i;
543
544
545
546 {$IFDEF FPC}
547 TRect = packed record
548 Left, Top, Right, Bottom: Longint;
549 end;
550 {$ENDIF}
551
552
553 PGPU_DEVICE = ^GPU_DEVICE;
554 GPU_DEVICE = record
555 cb: DWORD;
556 DeviceName: array [0..31] of AnsiChar;
557 DeviceString: array [0..127] of AnsiChar;
558 Flags: DWORD;
559 rcVirtualScreen: TRect;
560 end;
561
562
563 type
564 {$IFDEF FPC}
565 {$IFDEF DGL_WIN}
566 PWGLSwap = ^TWGLSwap;
567 {$EXTERNALSYM _WGLSWAP}
568 _WGLSWAP = packed record
569 hdc: HDC;
570 uiFlags: UINT;
571 end;
572
573 TWGLSwap = _WGLSWAP;
574 {$EXTERNALSYM WGLSWAP}
575 WGLSWAP = _WGLSWAP;
576
577 {$ENDIF}
578 {$ENDIF}
579
580 // GLU types
581 TGLUNurbs = record
582 end;
583 TGLUQuadric = record
584 end;
585 TGLUTesselator = record
586 end;
587 PGLUNurbs = ^TGLUNurbs;
588 PGLUQuadric = ^TGLUQuadric;
589 PGLUTesselator = ^TGLUTesselator;
590 // backwards compatibility
591 TGLUNurbsObj = TGLUNurbs;
592 TGLUQuadricObj = TGLUQuadric;
593 TGLUTesselatorObj = TGLUTesselator;
594 TGLUTriangulatorObj = TGLUTesselator;
595 PGLUNurbsObj = PGLUNurbs;
596 PGLUQuadricObj = PGLUQuadric;
597 PGLUTesselatorObj = PGLUTesselator;
598 PGLUTriangulatorObj = PGLUTesselator;
599
600 // GLUQuadricCallback
601 TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
602 // GLUTessCallback
603 TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
604 TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
605 TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
606 TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
607 TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
608 TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
609 TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
610 TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
611 TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
612 TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
613 TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
614 TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
615 // GLUNurbsCallback
616 TGLUNurbsErrorProc = procedure(ErrorCode: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
617
618 var
619 GL_VERSION_1_0,
620 GL_VERSION_1_1,
621 GL_VERSION_1_2,
622 GL_VERSION_1_3,
623 GL_VERSION_1_4,
624 GL_VERSION_1_5,
625 GL_VERSION_2_0,
626 GL_VERSION_2_1,
627 GL_VERSION_3_0,
628 GL_VERSION_3_1,
629 GL_VERSION_3_2,
630 GLU_VERSION_1_1,
631 GLU_VERSION_1_2,
632 GLU_VERSION_1_3,
633 GL_3DFX_multisample,
634 GL_3DFX_tbuffer,
635 GL_3DFX_texture_compression_FXT1,
636 GL_APPLE_client_storage,
637 GL_APPLE_element_array,
638 GL_APPLE_fence,
639 GL_APPLE_specular_vector,
640 GL_APPLE_transform_hint,
641 GL_APPLE_vertex_array_object,
642 GL_APPLE_vertex_array_range,
643 GL_APPLE_ycbcr_422,
644 GL_APPLE_texture_range,
645 GL_APPLE_float_pixels,
646 GL_APPLE_vertex_program_evaluators,
647 GL_APPLE_aux_depth_stencil,
648 GL_APPLE_object_purgeable,
649 GL_APPLE_row_bytes,
650 GL_ARB_depth_texture,
651 GL_ARB_fragment_program,
652 GL_ARB_imaging,
653 GL_ARB_matrix_palette,
654 GL_ARB_multisample,
655 GL_ARB_multitexture,
656 GL_ARB_point_parameters,
657 GL_ARB_shadow,
658 GL_ARB_shadow_ambient,
659 GL_ARB_texture_border_clamp,
660 GL_ARB_texture_compression,
661 GL_ARB_texture_cube_map,
662 GL_ARB_texture_env_add,
663 GL_ARB_texture_env_combine,
664 GL_ARB_texture_env_crossbar,
665 GL_ARB_texture_env_dot3,
666 GL_ARB_texture_mirrored_repeat,
667 GL_ARB_transpose_matrix,
668 GL_ARB_vertex_blend,
669 GL_ARB_vertex_buffer_object,
670 GL_ARB_vertex_program,
671 GL_ARB_window_pos,
672 GL_ARB_shader_objects,
673 GL_ARB_vertex_shader,
674 GL_ARB_fragment_shader,
675 GL_ARB_shading_language_100,
676 GL_ARB_occlusion_query,
677 GL_ARB_texture_non_power_of_two,
678 GL_ARB_point_sprite,
679 GL_ARB_fragment_program_shadow,
680 GL_ARB_draw_buffers,
681 GL_ARB_texture_rectangle,
682 GL_ARB_color_buffer_float,
683 GL_ARB_half_float_pixel,
684 GL_ARB_texture_float,
685 GL_ARB_pixel_buffer_object,
686 GL_ARB_depth_buffer_float,
687 GL_ARB_draw_instanced,
688 GL_ARB_framebuffer_object,
689 GL_ARB_framebuffer_sRGB,
690 GL_ARB_geometry_shader4,
691 GL_ARB_half_float_vertex,
692 GL_ARB_instanced_arrays,
693 GL_ARB_map_buffer_range,
694 GL_ARB_texture_buffer_object,
695 GL_ARB_texture_compression_rgtc,
696 GL_ARB_texture_rg,
697 GL_ARB_vertex_array_object,
698 GL_ARB_uniform_buffer_object,
699 GL_ARB_compatibility,
700 GL_ARB_copy_buffer,
701 GL_ARB_shader_texture_lod,
702 GL_ARB_depth_clamp,
703 GL_ARB_draw_elements_base_vertex,
704 GL_ARB_fragment_coord_conventions,
705 GL_ARB_provoking_vertex,
706 GL_ARB_seamless_cube_map,
707 GL_ARB_sync,
708 GL_ARB_texture_multisample,
709 GL_ARB_vertex_array_bgra,
710 GL_ARB_draw_buffers_blend,
711 GL_ARB_sample_shading,
712 GL_ARB_texture_cube_map_array,
713 GL_ARB_texture_gather,
714 GL_ARB_texture_query_lod,
715 GL_ATI_draw_buffers,
716 GL_ATI_element_array,
717 GL_ATI_envmap_bumpmap,
718 GL_ATI_fragment_shader,
719 GL_ATI_map_object_buffer,
720 GL_ATI_pn_triangles,
721 GL_ATI_separate_stencil,
722 GL_ATI_text_fragment_shader,
723 GL_ATI_texture_env_combine3,
724 GL_ATI_texture_float,
725 GL_ATI_texture_mirror_once,
726 GL_ATI_vertex_array_object,
727 GL_ATI_vertex_attrib_array_object,
728 GL_ATI_vertex_streams,
729 GL_ATI_meminfo,
730 GL_AMD_performance_monitor,
731 GL_AMD_texture_texture4,
732 GL_AMD_vertex_shader_tesselator,
733 GL_AMD_draw_buffers_blend,
734 GL_EXT_422_pixels,
735 GL_EXT_abgr,
736 GL_EXT_bgra,
737 GL_EXT_blend_color,
738 GL_EXT_blend_func_separate,
739 GL_EXT_blend_logic_op,
740 GL_EXT_blend_minmax,
741 GL_EXT_blend_subtract,
742 GL_EXT_clip_volume_hint,
743 GL_EXT_cmyka,
744 GL_EXT_color_matrix,
745 GL_EXT_color_subtable,
746 GL_EXT_compiled_vertex_array,
747 GL_EXT_convolution,
748 GL_EXT_coordinate_frame,
749 GL_EXT_copy_texture,
750 GL_EXT_cull_vertex,
751 GL_EXT_draw_range_elements,
752 GL_EXT_fog_coord,
753 GL_EXT_framebuffer_object,
754 GL_EXT_histogram,
755 GL_EXT_index_array_formats,
756 GL_EXT_index_func,
757 GL_EXT_index_material,
758 GL_EXT_index_texture,
759 GL_EXT_light_texture,
760 GL_EXT_misc_attribute,
761 GL_EXT_multi_draw_arrays,
762 GL_EXT_multisample,
763 GL_EXT_packed_pixels,
764 GL_EXT_paletted_texture,
765 GL_EXT_pixel_transform,
766 GL_EXT_pixel_transform_color_table,
767 GL_EXT_point_parameters,
768 GL_EXT_polygon_offset,
769 GL_EXT_rescale_normal,
770 GL_EXT_secondary_color,
771 GL_EXT_separate_specular_color,
772 GL_EXT_shadow_funcs,
773 GL_EXT_shared_texture_palette,
774 GL_EXT_stencil_two_side,
775 GL_EXT_stencil_wrap,
776 GL_EXT_subtexture,
777 GL_EXT_texture,
778 GL_EXT_texture3D,
779 GL_EXT_texture_compression_s3tc,
780 GL_EXT_texture_cube_map,
781 GL_EXT_texture_edge_clamp,
782 GL_EXT_texture_env_add,
783 GL_EXT_texture_env_combine,
784 GL_EXT_texture_env_dot3,
785 GL_EXT_texture_filter_anisotropic,
786 GL_EXT_texture_lod_bias,
787 GL_EXT_texture_object,
788 GL_EXT_texture_perturb_normal,
789 GL_EXT_texture_rectangle,
790 GL_EXT_vertex_array,
791 GL_EXT_vertex_shader,
792 GL_EXT_vertex_weighting,
793 GL_EXT_depth_bounds_test,
794 GL_EXT_texture_mirror_clamp,
795 GL_EXT_blend_equation_separate,
796 GL_EXT_pixel_buffer_object,
797 GL_EXT_texture_compression_dxt1,
798 GL_EXT_stencil_clear_tag,
799 GL_EXT_packed_depth_stencil,
800 GL_EXT_texture_sRGB,
801 GL_EXT_framebuffer_blit,
802 GL_EXT_framebuffer_multisample,
803 GL_EXT_timer_query,
804 GL_EXT_gpu_program_parameters,
805 GL_EXT_bindable_uniform,
806 GL_EXT_draw_buffers2,
807 GL_EXT_draw_instanced,
808 GL_EXT_framebuffer_sRGB,
809 GL_EXT_geometry_shader4,
810 GL_EXT_gpu_shader4,
811 GL_EXT_packed_float,
812 GL_EXT_texture_array,
813 GL_EXT_texture_buffer_object,
814 GL_EXT_texture_compression_latc,
815 GL_EXT_texture_compression_rgtc,
816 GL_EXT_texture_integer,
817 GL_EXT_texture_shared_exponent,
818 GL_EXT_transform_feedback,
819 GL_EXT_direct_state_access,
820 GL_EXT_vertex_array_bgra,
821 GL_EXT_texture_swizzle,
822 GL_EXT_provoking_vertex,
823 GL_EXT_texture_snorm,
824 GL_FfdMaskSGIX,
825 GL_HP_convolution_border_modes,
826 GL_HP_image_transform,
827 GL_HP_occlusion_test,
828 GL_HP_texture_lighting,
829 GL_IBM_cull_vertex,
830 GL_IBM_multimode_draw_arrays,
831 GL_IBM_rasterpos_clip,
832 GL_IBM_texture_mirrored_repeat,
833 GL_IBM_vertex_array_lists,
834 GL_INGR_blend_func_separate,
835 GL_INGR_color_clamp,
836 GL_INGR_interlace_read,
837 GL_INGR_palette_buffer,
838 GL_INTEL_parallel_arrays,
839 GL_INTEL_texture_scissor,
840 GL_MESA_resize_buffers,
841 GL_MESA_window_pos,
842 GL_NV_blend_square,
843 GL_NV_copy_depth_to_color,
844 GL_NV_depth_clamp,
845 GL_NV_evaluators,
846 GL_NV_fence,
847 GL_NV_float_buffer,
848 GL_NV_fog_distance,
849 GL_NV_fragment_program,
850 GL_NV_half_float,
851 GL_NV_light_max_exponent,
852 GL_NV_multisample_filter_hint,
853 GL_NV_occlusion_query,
854 GL_NV_packed_depth_stencil,
855 GL_NV_pixel_data_range,
856 GL_NV_point_sprite,
857 GL_NV_primitive_restart,
858 GL_NV_register_combiners,
859 GL_NV_register_combiners2,
860 GL_NV_texgen_emboss,
861 GL_NV_texgen_reflection,
862 GL_NV_texture_compression_vtc,
863 GL_NV_texture_env_combine4,
864 GL_NV_texture_expand_normal,
865 GL_NV_texture_rectangle,
866 GL_NV_texture_shader,
867 GL_NV_texture_shader2,
868 GL_NV_texture_shader3,
869 GL_NV_vertex_array_range,
870 GL_NV_vertex_array_range2,
871 GL_NV_vertex_program,
872 GL_NV_vertex_program1_1,
873 GL_NV_vertex_program2,
874 GL_NV_fragment_program_option,
875 GL_NV_fragment_program2,
876 GL_NV_vertex_program2_option,
877 GL_NV_vertex_program3,
878 GL_NV_depth_buffer_float,
879 GL_NV_fragment_program4,
880 GL_NV_framebuffer_multisample_coverage,
881 GL_NV_geometry_program4,
882 GL_NV_gpu_program4,
883 GL_NV_parameter_buffer_object,
884 GL_NV_transform_feedback,
885 GL_NV_vertex_program4,
886 GL_NV_conditional_render,
887 GL_NV_present_video,
888 GL_NV_explicit_multisample,
889 GL_NV_transform_feedback2,
890 GL_OML_interlace,
891 GL_OML_resample,
892 GL_OML_subsample,
893 GL_PGI_misc_hints,
894 GL_PGI_vertex_hints,
895 GL_REND_screen_coordinates,
896 GL_S3_s3tc,
897 GL_SGIS_detail_texture,
898 GL_SGIS_fog_function,
899 GL_SGIS_generate_mipmap,
900 GL_SGIS_multisample,
901 GL_SGIS_pixel_texture,
902 GL_SGIS_point_line_texgen,
903 GL_SGIS_point_parameters,
904 GL_SGIS_sharpen_texture,
905 GL_SGIS_texture4D,
906 GL_SGIS_texture_border_clamp,
907 GL_SGIS_texture_color_mask,
908 GL_SGIS_texture_edge_clamp,
909 GL_SGIS_texture_filter4,
910 GL_SGIS_texture_lod,
911 GL_SGIS_texture_select,
912 GL_SGIX_async,
913 GL_SGIX_async_histogram,
914 GL_SGIX_async_pixel,
915 GL_SGIX_blend_alpha_minmax,
916 GL_SGIX_calligraphic_fragment,
917 GL_SGIX_clipmap,
918 GL_SGIX_convolution_accuracy,
919 GL_SGIX_depth_pass_instrument,
920 GL_SGIX_depth_texture,
921 GL_SGIX_flush_raster,
922 GL_SGIX_fog_offset,
923 GL_SGIX_fog_scale,
924 GL_SGIX_fragment_lighting,
925 GL_SGIX_framezoom,
926 GL_SGIX_igloo_interface,
927 GL_SGIX_impact_pixel_texture,
928 GL_SGIX_instruments,
929 GL_SGIX_interlace,
930 GL_SGIX_ir_instrument1,
931 GL_SGIX_list_priority,
932 GL_SGIX_pixel_texture,
933 GL_SGIX_pixel_tiles,
934 GL_SGIX_polynomial_ffd,
935 GL_SGIX_reference_plane,
936 GL_SGIX_resample,
937 GL_SGIX_scalebias_hint,
938 GL_SGIX_shadow,
939 GL_SGIX_shadow_ambient,
940 GL_SGIX_sprite,
941 GL_SGIX_subsample,
942 GL_SGIX_tag_sample_buffer,
943 GL_SGIX_texture_add_env,
944 GL_SGIX_texture_coordinate_clamp,
945 GL_SGIX_texture_lod_bias,
946 GL_SGIX_texture_multi_buffer,
947 GL_SGIX_texture_scale_bias,
948 GL_SGIX_texture_select,
949 GL_SGIX_vertex_preclip,
950 GL_SGIX_ycrcb,
951 GL_SGIX_ycrcb_subsample,
952 GL_SGIX_ycrcba,
953 GL_SGI_color_matrix,
954 GL_SGI_color_table,
955 GL_SGI_depth_pass_instrument,
956 GL_SGI_texture_color_table,
957 GL_SUNX_constant_data,
958 GL_SUN_convolution_border_modes,
959 GL_SUN_global_alpha,
960 GL_SUN_mesh_array,
961 GL_SUN_slice_accum,
962 GL_SUN_triangle_list,
963 GL_SUN_vertex,
964
965 GL_WIN_phong_shading,
966 GL_WIN_specular_fog,
967 WGL_3DFX_multisample,
968 WGL_ARB_buffer_region,
969 WGL_ARB_extensions_string,
970 WGL_ARB_make_current_read,
971 WGL_ARB_multisample,
972 WGL_ARB_pbuffer,
973 WGL_ARB_pixel_format,
974 WGL_ARB_pixel_format_float,
975 WGL_ARB_render_texture,
976 WGL_ARB_create_context,
977 WGL_ARB_create_context_profile,
978 WGL_ATI_pixel_format_float,
979 WGL_AMD_gpu_association,
980 WGL_EXT_depth_float,
981 WGL_EXT_display_color_table,
982 WGL_EXT_extensions_string,
983 WGL_EXT_make_current_read,
984 WGL_EXT_multisample,
985 WGL_EXT_pbuffer,
986 WGL_EXT_pixel_format,
987 WGL_EXT_swap_control,
988 WGL_I3D_digital_video_control,
989 WGL_I3D_gamma,
990 WGL_I3D_genlock,
991 WGL_I3D_image_buffer,
992 WGL_I3D_swap_frame_lock,
993 WGL_I3D_swap_frame_usage,
994 WGL_NV_float_buffer,
995 WGL_NV_render_depth_texture,
996 WGL_NV_render_texture_rectangle,
997 WGL_NV_vertex_array_range,
998 WGL_NV_present_video,
999 WGL_NV_video_out,
1000 WGL_NV_swap_group,
1001 WGL_NV_gpu_affinity,
1002 WGL_OML_sync_control,
1003 WGL_3DL_stereo_control,
1004 WIN_draw_range_elements,
1005 WIN_swap_hint,
1006
1007 // GLX_VERSION_1_0,
1008 GLX_VERSION_1_3,
1009 GLX_VERSION_1_4,
1010 GLX_ARB_multisample,
1011 GLX_ARB_fbconfig_float,
1012 GLX_ARB_get_proc_address,
1013 GLX_ARB_create_context,
1014 GLX_ARB_create_context_profile,
1015 GLX_EXT_visual_info,
1016 GLX_EXT_visual_rating,
1017 GLX_EXT_import_context,
1018 GLX_EXT_fbconfig_packed_float,
1019 GLX_EXT_framebuffer_sRGB,
1020 GLX_EXT_texture_from_pixmap: Boolean;
1021
1022 const
1023 // GL_VERSION_1_1
1024 { AttribMask }
1025 GL_DEPTH_BUFFER_BIT = $00000100;
1026 GL_STENCIL_BUFFER_BIT = $00000400;
1027 GL_COLOR_BUFFER_BIT = $00004000;
1028 { Boolean }
1029 GL_TRUE = 1;
1030 GL_FALSE = 0;
1031 { BeginMode }
1032 GL_POINTS = $0000;
1033 GL_LINES = $0001;
1034 GL_LINE_LOOP = $0002;
1035 GL_LINE_STRIP = $0003;
1036 GL_TRIANGLES = $0004;
1037 GL_TRIANGLE_STRIP = $0005;
1038 GL_TRIANGLE_FAN = $0006;
1039 { AlphaFunction }
1040 GL_NEVER = $0200;
1041 GL_LESS = $0201;
1042 GL_EQUAL = $0202;
1043 GL_LEQUAL = $0203;
1044 GL_GREATER = $0204;
1045 GL_NOTEQUAL = $0205;
1046 GL_GEQUAL = $0206;
1047 GL_ALWAYS = $0207;
1048 { BlendingFactorDest }
1049 GL_ZERO = 0;
1050 GL_ONE = 1;
1051 GL_SRC_COLOR = $0300;
1052 GL_ONE_MINUS_SRC_COLOR = $0301;
1053 GL_SRC_ALPHA = $0302;
1054 GL_ONE_MINUS_SRC_ALPHA = $0303;
1055 GL_DST_ALPHA = $0304;
1056 GL_ONE_MINUS_DST_ALPHA = $0305;
1057 { BlendingFactorSrc }
1058 GL_DST_COLOR = $0306;
1059 GL_ONE_MINUS_DST_COLOR = $0307;
1060 GL_SRC_ALPHA_SATURATE = $0308;
1061 { DrawBufferMode }
1062 GL_NONE = 0;
1063 GL_FRONT_LEFT = $0400;
1064 GL_FRONT_RIGHT = $0401;
1065 GL_BACK_LEFT = $0402;
1066 GL_BACK_RIGHT = $0403;
1067 GL_FRONT = $0404;
1068 GL_BACK = $0405;
1069 GL_LEFT = $0406;
1070 GL_RIGHT = $0407;
1071 GL_FRONT_AND_BACK = $0408;
1072 { ErrorCode }
1073 GL_NO_ERROR = 0;
1074 GL_INVALID_ENUM = $0500;
1075 GL_INVALID_VALUE = $0501;
1076 GL_INVALID_OPERATION = $0502;
1077 GL_OUT_OF_MEMORY = $0505;
1078 { FrontFaceDirection }
1079 GL_CW = $0900;
1080 GL_CCW = $0901;
1081 { GetPName }
1082 GL_POINT_SIZE = $0B11;
1083 GL_POINT_SIZE_RANGE = $0B12;
1084 GL_POINT_SIZE_GRANULARITY = $0B13;
1085 GL_LINE_SMOOTH = $0B20;
1086 GL_LINE_WIDTH = $0B21;
1087 GL_LINE_WIDTH_RANGE = $0B22;
1088 GL_LINE_WIDTH_GRANULARITY = $0B23;
1089 GL_POLYGON_SMOOTH = $0B41;
1090 GL_CULL_FACE = $0B44;
1091 GL_CULL_FACE_MODE = $0B45;
1092 GL_FRONT_FACE = $0B46;
1093 GL_DEPTH_RANGE = $0B70;
1094 GL_DEPTH_TEST = $0B71;
1095 GL_DEPTH_WRITEMASK = $0B72;
1096 GL_DEPTH_CLEAR_VALUE = $0B73;
1097 GL_DEPTH_FUNC = $0B74;
1098 GL_STENCIL_TEST = $0B90;
1099 GL_STENCIL_CLEAR_VALUE = $0B91;
1100 GL_STENCIL_FUNC = $0B92;
1101 GL_STENCIL_VALUE_MASK = $0B93;
1102 GL_STENCIL_FAIL = $0B94;
1103 GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
1104 GL_STENCIL_PASS_DEPTH_PASS = $0B96;
1105 GL_STENCIL_REF = $0B97;
1106 GL_STENCIL_WRITEMASK = $0B98;
1107 GL_VIEWPORT = $0BA2;
1108 GL_DITHER = $0BD0;
1109 GL_BLEND_DST = $0BE0;
1110 GL_BLEND_SRC = $0BE1;
1111 GL_BLEND = $0BE2;
1112 GL_LOGIC_OP_MODE = $0BF0;
1113 GL_COLOR_LOGIC_OP = $0BF2;
1114 GL_DRAW_BUFFER = $0C01;
1115 GL_READ_BUFFER = $0C02;
1116 GL_SCISSOR_BOX = $0C10;
1117 GL_SCISSOR_TEST = $0C11;
1118 GL_COLOR_CLEAR_VALUE = $0C22;
1119 GL_COLOR_WRITEMASK = $0C23;
1120 GL_DOUBLEBUFFER = $0C32;
1121 GL_STEREO = $0C33;
1122 GL_LINE_SMOOTH_HINT = $0C52;
1123 GL_POLYGON_SMOOTH_HINT = $0C53;
1124 GL_UNPACK_SWAP_BYTES = $0CF0;
1125 GL_UNPACK_LSB_FIRST = $0CF1;
1126 GL_UNPACK_ROW_LENGTH = $0CF2;
1127 GL_UNPACK_SKIP_ROWS = $0CF3;
1128 GL_UNPACK_SKIP_PIXELS = $0CF4;
1129 GL_UNPACK_ALIGNMENT = $0CF5;
1130 GL_PACK_SWAP_BYTES = $0D00;
1131 GL_PACK_LSB_FIRST = $0D01;
1132 GL_PACK_ROW_LENGTH = $0D02;
1133 GL_PACK_SKIP_ROWS = $0D03;
1134 GL_PACK_SKIP_PIXELS = $0D04;
1135 GL_PACK_ALIGNMENT = $0D05;
1136 GL_MAX_TEXTURE_SIZE = $0D33;
1137 GL_MAX_VIEWPORT_DIMS = $0D3A;
1138 GL_SUBPIXEL_BITS = $0D50;
1139 GL_TEXTURE_1D = $0DE0;
1140 GL_TEXTURE_2D = $0DE1;
1141 GL_POLYGON_OFFSET_UNITS = $2A00;
1142 GL_POLYGON_OFFSET_POINT = $2A01;
1143 GL_POLYGON_OFFSET_LINE = $2A02;
1144 GL_POLYGON_OFFSET_FILL = $8037;
1145 GL_POLYGON_OFFSET_FACTOR = $8038;
1146 GL_TEXTURE_BINDING_1D = $8068;
1147 GL_TEXTURE_BINDING_2D = $8069;
1148 { GetTextureParameter }
1149 GL_TEXTURE_WIDTH = $1000;
1150 GL_TEXTURE_HEIGHT = $1001;
1151 GL_TEXTURE_INTERNAL_FORMAT = $1003;
1152 GL_TEXTURE_BORDER_COLOR = $1004;
1153 GL_TEXTURE_BORDER = $1005;
1154 GL_TEXTURE_RED_SIZE = $805C;
1155 GL_TEXTURE_GREEN_SIZE = $805D;
1156 GL_TEXTURE_BLUE_SIZE = $805E;
1157 GL_TEXTURE_ALPHA_SIZE = $805F;
1158 { HintMode }
1159 GL_DONT_CARE = $1100;
1160 GL_FASTEST = $1101;
1161 GL_NICEST = $1102;
1162 { DataType }
1163 GL_BYTE = $1400;
1164 GL_UNSIGNED_BYTE = $1401;
1165 GL_SHORT = $1402;
1166 GL_UNSIGNED_SHORT = $1403;
1167 GL_INT = $1404;
1168 GL_UNSIGNED_INT = $1405;
1169 GL_FLOAT = $1406;
1170 GL_DOUBLE = $140A;
1171 { LogicOp }
1172 GL_CLEAR = $1500;
1173 GL_AND = $1501;
1174 GL_AND_REVERSE = $1502;
1175 GL_COPY = $1503;
1176 GL_AND_INVERTED = $1504;
1177 GL_NOOP = $1505;
1178 GL_XOR = $1506;
1179 GL_OR = $1507;
1180 GL_NOR = $1508;
1181 GL_EQUIV = $1509;
1182 GL_INVERT = $150A;
1183 GL_OR_REVERSE = $150B;
1184 GL_COPY_INVERTED = $150C;
1185 GL_OR_INVERTED = $150D;
1186 GL_NAND = $150E;
1187 GL_SET = $150F;
1188 { MatrixMode (for gl3.h, FBO attachment type) }
1189 GL_TEXTURE = $1702;
1190 { PixelCopyType }
1191 GL_COLOR = $1800;
1192 GL_DEPTH = $1801;
1193 GL_STENCIL = $1802;
1194 { PixelFormat }
1195 GL_STENCIL_INDEX = $1901;
1196 GL_DEPTH_COMPONENT = $1902;
1197 GL_RED = $1903;
1198 GL_GREEN = $1904;
1199 GL_BLUE = $1905;
1200 GL_ALPHA = $1906;
1201 GL_RGB = $1907;
1202 GL_RGBA = $1908;
1203 { PolygonMode }
1204 GL_POINT = $1B00;
1205 GL_LINE = $1B01;
1206 GL_FILL = $1B02;
1207 { StencilOp }
1208 GL_KEEP = $1E00;
1209 GL_REPLACE = $1E01;
1210 GL_INCR = $1E02;
1211 GL_DECR = $1E03;
1212 { StringName }
1213 GL_VENDOR = $1F00;
1214 GL_RENDERER = $1F01;
1215 GL_VERSION = $1F02;
1216 GL_EXTENSIONS = $1F03;
1217 { TextureMagFilter }
1218 GL_NEAREST = $2600;
1219 GL_LINEAR = $2601;
1220 { TextureMinFilter }
1221 GL_NEAREST_MIPMAP_NEAREST = $2700;
1222 GL_LINEAR_MIPMAP_NEAREST = $2701;
1223 GL_NEAREST_MIPMAP_LINEAR = $2702;
1224 GL_LINEAR_MIPMAP_LINEAR = $2703;
1225 { TextureParameterName }
1226 GL_TEXTURE_MAG_FILTER = $2800;
1227 GL_TEXTURE_MIN_FILTER = $2801;
1228 GL_TEXTURE_WRAP_S = $2802;
1229 GL_TEXTURE_WRAP_T = $2803;
1230 { TextureTarget }
1231 GL_PROXY_TEXTURE_1D = $8063;
1232 GL_PROXY_TEXTURE_2D = $8064;
1233 { TextureWrapMode }
1234 GL_REPEAT = $2901;
1235 { PixelInternalFormat }
1236 GL_R3_G3_B2 = $2A10;
1237 GL_RGB4 = $804F;
1238 GL_RGB5 = $8050;
1239 GL_RGB8 = $8051;
1240 GL_RGB10 = $8052;
1241 GL_RGB12 = $8053;
1242 GL_RGB16 = $8054;
1243 GL_RGBA2 = $8055;
1244 GL_RGBA4 = $8056;
1245 GL_RGB5_A1 = $8057;
1246 GL_RGBA8 = $8058;
1247 GL_RGB10_A2 = $8059;
1248 GL_RGBA12 = $805A;
1249 GL_RGBA16 = $805B;
1250 {$ifdef DGL_DEPRECATED}
1251 GL_ACCUM = $0100;
1252 GL_LOAD = $0101;
1253 GL_RETURN = $0102;
1254 GL_MULT = $0103;
1255 GL_ADD = $0104;
1256 GL_CURRENT_BIT = $00000001;
1257 GL_POINT_BIT = $00000002;
1258 GL_LINE_BIT = $00000004;
1259 GL_POLYGON_BIT = $00000008;
1260 GL_POLYGON_STIPPLE_BIT = $00000010;
1261 GL_PIXEL_MODE_BIT = $00000020;
1262 GL_LIGHTING_BIT = $00000040;
1263 GL_FOG_BIT = $00000080;
1264 GL_ACCUM_BUFFER_BIT = $00000200;
1265 GL_VIEWPORT_BIT = $00000800;
1266 GL_TRANSFORM_BIT = $00001000;
1267 GL_ENABLE_BIT = $00002000;
1268 GL_HINT_BIT = $00008000;
1269 GL_EVAL_BIT = $00010000;
1270 GL_LIST_BIT = $00020000;
1271 GL_TEXTURE_BIT = $00040000;
1272 GL_SCISSOR_BIT = $00080000;
1273 GL_ALL_ATTRIB_BITS = $000FFFFF;
1274 GL_QUADS = $0007;
1275 GL_QUAD_STRIP = $0008;
1276 GL_POLYGON = $0009;
1277 GL_CLIP_PLANE0 = $3000;
1278 GL_CLIP_PLANE1 = $3001;
1279 GL_CLIP_PLANE2 = $3002;
1280 GL_CLIP_PLANE3 = $3003;
1281 GL_CLIP_PLANE4 = $3004;
1282 GL_CLIP_PLANE5 = $3005;
1283 GL_2_BYTES = $1407;
1284 GL_3_BYTES = $1408;
1285 GL_4_BYTES = $1409;
1286 GL_AUX0 = $0409;
1287 GL_AUX1 = $040A;
1288 GL_AUX2 = $040B;
1289 GL_AUX3 = $040C;
1290 GL_STACK_OVERFLOW = $0503;
1291 GL_STACK_UNDERFLOW = $0504;
1292 GL_2D = $0600;
1293 GL_3D = $0601;
1294 GL_3D_COLOR = $0602;
1295 GL_3D_COLOR_TEXTURE = $0603;
1296 GL_4D_COLOR_TEXTURE = $0604;
1297 GL_PASS_THROUGH_TOKEN = $0700;
1298 GL_POINT_TOKEN = $0701;
1299 GL_LINE_TOKEN = $0702;
1300 GL_POLYGON_TOKEN = $0703;
1301 GL_BITMAP_TOKEN = $0704;
1302 GL_DRAW_PIXEL_TOKEN = $0705;
1303 GL_COPY_PIXEL_TOKEN = $0706;
1304 GL_LINE_RESET_TOKEN = $0707;
1305 GL_EXP = $0800;
1306 GL_EXP2 = $0801;
1307 GL_COEFF = $0A00;
1308 GL_ORDER = $0A01;
1309 GL_DOMAIN = $0A02;
1310 GL_CURRENT_COLOR = $0B00;
1311 GL_CURRENT_INDEX = $0B01;
1312 GL_CURRENT_NORMAL = $0B02;
1313 GL_CURRENT_TEXTURE_COORDS = $0B03;
1314 GL_CURRENT_RASTER_COLOR = $0B04;
1315 GL_CURRENT_RASTER_INDEX = $0B05;
1316 GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06;
1317 GL_CURRENT_RASTER_POSITION = $0B07;
1318 GL_CURRENT_RASTER_POSITION_VALID = $0B08;
1319 GL_CURRENT_RASTER_DISTANCE = $0B09;
1320 GL_POINT_SMOOTH = $0B10;
1321 GL_LINE_STIPPLE = $0B24;
1322 GL_LINE_STIPPLE_PATTERN = $0B25;
1323 GL_LINE_STIPPLE_REPEAT = $0B26;
1324 GL_LIST_MODE = $0B30;
1325 GL_MAX_LIST_NESTING = $0B31;
1326 GL_LIST_BASE = $0B32;
1327 GL_LIST_INDEX = $0B33;
1328 GL_POLYGON_MODE = $0B40;
1329 GL_POLYGON_STIPPLE = $0B42;
1330 GL_EDGE_FLAG = $0B43;
1331 GL_LIGHTING = $0B50;
1332 GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51;
1333 GL_LIGHT_MODEL_TWO_SIDE = $0B52;
1334 GL_LIGHT_MODEL_AMBIENT = $0B53;
1335 GL_SHADE_MODEL = $0B54;
1336 GL_COLOR_MATERIAL_FACE = $0B55;
1337 GL_COLOR_MATERIAL_PARAMETER = $0B56;
1338 GL_COLOR_MATERIAL = $0B57;
1339 GL_FOG = $0B60;
1340 GL_FOG_INDEX = $0B61;
1341 GL_FOG_DENSITY = $0B62;
1342 GL_FOG_START = $0B63;
1343 GL_FOG_END = $0B64;
1344 GL_FOG_MODE = $0B65;
1345 GL_FOG_COLOR = $0B66;
1346 GL_ACCUM_CLEAR_VALUE = $0B80;
1347 GL_MATRIX_MODE = $0BA0;
1348 GL_NORMALIZE = $0BA1;
1349 GL_MODELVIEW_STACK_DEPTH = $0BA3;
1350 GL_PROJECTION_STACK_DEPTH = $0BA4;
1351 GL_TEXTURE_STACK_DEPTH = $0BA5;
1352 GL_MODELVIEW_MATRIX = $0BA6;
1353 GL_PROJECTION_MATRIX = $0BA7;
1354 GL_TEXTURE_MATRIX = $0BA8;
1355 GL_ATTRIB_STACK_DEPTH = $0BB0;
1356 GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1;
1357 GL_ALPHA_TEST = $0BC0;
1358 GL_ALPHA_TEST_FUNC = $0BC1;
1359 GL_ALPHA_TEST_REF = $0BC2;
1360 GL_INDEX_LOGIC_OP = $0BF1;
1361 GL_AUX_BUFFERS = $0C00;
1362 GL_INDEX_CLEAR_VALUE = $0C20;
1363 GL_INDEX_WRITEMASK = $0C21;
1364 GL_INDEX_MODE = $0C30;
1365 GL_RGBA_MODE = $0C31;
1366 GL_RENDER_MODE = $0C40;
1367 GL_PERSPECTIVE_CORRECTION_HINT = $0C50;
1368 GL_POINT_SMOOTH_HINT = $0C51;
1369 GL_FOG_HINT = $0C54;
1370 GL_TEXTURE_GEN_S = $0C60;
1371 GL_TEXTURE_GEN_T = $0C61;
1372 GL_TEXTURE_GEN_R = $0C62;
1373 GL_TEXTURE_GEN_Q = $0C63;
1374 GL_PIXEL_MAP_I_TO_I = $0C70;
1375 GL_PIXEL_MAP_S_TO_S = $0C71;
1376 GL_PIXEL_MAP_I_TO_R = $0C72;
1377 GL_PIXEL_MAP_I_TO_G = $0C73;
1378 GL_PIXEL_MAP_I_TO_B = $0C74;
1379 GL_PIXEL_MAP_I_TO_A = $0C75;
1380 GL_PIXEL_MAP_R_TO_R = $0C76;
1381 GL_PIXEL_MAP_G_TO_G = $0C77;
1382 GL_PIXEL_MAP_B_TO_B = $0C78;
1383 GL_PIXEL_MAP_A_TO_A = $0C79;
1384 GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0;
1385 GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1;
1386 GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2;
1387 GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3;
1388 GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4;
1389 GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5;
1390 GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6;
1391 GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7;
1392 GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8;
1393 GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9;
1394 GL_MAP_COLOR = $0D10;
1395 GL_MAP_STENCIL = $0D11;
1396 GL_INDEX_SHIFT = $0D12;
1397 GL_INDEX_OFFSET = $0D13;
1398 GL_RED_SCALE = $0D14;
1399 GL_RED_BIAS = $0D15;
1400 GL_ZOOM_X = $0D16;
1401 GL_ZOOM_Y = $0D17;
1402 GL_GREEN_SCALE = $0D18;
1403 GL_GREEN_BIAS = $0D19;
1404 GL_BLUE_SCALE = $0D1A;
1405 GL_BLUE_BIAS = $0D1B;
1406 GL_ALPHA_SCALE = $0D1C;
1407 GL_ALPHA_BIAS = $0D1D;
1408 GL_DEPTH_SCALE = $0D1E;
1409 GL_DEPTH_BIAS = $0D1F;
1410 GL_MAX_EVAL_ORDER = $0D30;
1411 GL_MAX_LIGHTS = $0D31;
1412 GL_MAX_CLIP_PLANES = $0D32;
1413 GL_MAX_PIXEL_MAP_TABLE = $0D34;
1414 GL_MAX_ATTRIB_STACK_DEPTH = $0D35;
1415 GL_MAX_MODELVIEW_STACK_DEPTH = $0D36;
1416 GL_MAX_NAME_STACK_DEPTH = $0D37;
1417 GL_MAX_PROJECTION_STACK_DEPTH = $0D38;
1418 GL_MAX_TEXTURE_STACK_DEPTH = $0D39;
1419 GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B;
1420 GL_INDEX_BITS = $0D51;
1421 GL_RED_BITS = $0D52;
1422 GL_GREEN_BITS = $0D53;
1423 GL_BLUE_BITS = $0D54;
1424 GL_ALPHA_BITS = $0D55;
1425 GL_DEPTH_BITS = $0D56;
1426 GL_STENCIL_BITS = $0D57;
1427 GL_ACCUM_RED_BITS = $0D58;
1428 GL_ACCUM_GREEN_BITS = $0D59;
1429 GL_ACCUM_BLUE_BITS = $0D5A;
1430 GL_ACCUM_ALPHA_BITS = $0D5B;
1431 GL_NAME_STACK_DEPTH = $0D70;
1432 GL_AUTO_NORMAL = $0D80;
1433 GL_MAP1_COLOR_4 = $0D90;
1434 GL_MAP1_INDEX = $0D91;
1435 GL_MAP1_NORMAL = $0D92;
1436 GL_MAP1_TEXTURE_COORD_1 = $0D93;
1437 GL_MAP1_TEXTURE_COORD_2 = $0D94;
1438 GL_MAP1_TEXTURE_COORD_3 = $0D95;
1439 GL_MAP1_TEXTURE_COORD_4 = $0D96;
1440 GL_MAP1_VERTEX_3 = $0D97;
1441 GL_MAP1_VERTEX_4 = $0D98;
1442 GL_MAP2_COLOR_4 = $0DB0;
1443 GL_MAP2_INDEX = $0DB1;
1444 GL_MAP2_NORMAL = $0DB2;
1445 GL_MAP2_TEXTURE_COORD_1 = $0DB3;
1446 GL_MAP2_TEXTURE_COORD_2 = $0DB4;
1447 GL_MAP2_TEXTURE_COORD_3 = $0DB5;
1448 GL_MAP2_TEXTURE_COORD_4 = $0DB6;
1449 GL_MAP2_VERTEX_3 = $0DB7;
1450 GL_MAP2_VERTEX_4 = $0DB8;
1451 GL_MAP1_GRID_DOMAIN = $0DD0;
1452 GL_MAP1_GRID_SEGMENTS = $0DD1;
1453 GL_MAP2_GRID_DOMAIN = $0DD2;
1454 GL_MAP2_GRID_SEGMENTS = $0DD3;
1455 GL_FEEDBACK_BUFFER_POINTER = $0DF0;
1456 GL_FEEDBACK_BUFFER_SIZE = $0DF1;
1457 GL_FEEDBACK_BUFFER_TYPE = $0DF2;
1458 GL_SELECTION_BUFFER_POINTER = $0DF3;
1459 GL_SELECTION_BUFFER_SIZE = $0DF4;
1460 GL_LIGHT0 = $4000;
1461 GL_LIGHT1 = $4001;
1462 GL_LIGHT2 = $4002;
1463 GL_LIGHT3 = $4003;
1464 GL_LIGHT4 = $4004;
1465 GL_LIGHT5 = $4005;
1466 GL_LIGHT6 = $4006;
1467 GL_LIGHT7 = $4007;
1468 GL_AMBIENT = $1200;
1469 GL_DIFFUSE = $1201;
1470 GL_SPECULAR = $1202;
1471 GL_POSITION = $1203;
1472 GL_SPOT_DIRECTION = $1204;
1473 GL_SPOT_EXPONENT = $1205;
1474 GL_SPOT_CUTOFF = $1206;
1475 GL_CONSTANT_ATTENUATION = $1207;
1476 GL_LINEAR_ATTENUATION = $1208;
1477 GL_QUADRATIC_ATTENUATION = $1209;
1478 GL_COMPILE = $1300;
1479 GL_COMPILE_AND_EXECUTE = $1301;
1480 GL_EMISSION = $1600;
1481 GL_SHININESS = $1601;
1482 GL_AMBIENT_AND_DIFFUSE = $1602;
1483 GL_COLOR_INDEXES = $1603;
1484 GL_MODELVIEW = $1700;
1485 GL_PROJECTION = $1701;
1486 GL_COLOR_INDEX = $1900;
1487 GL_LUMINANCE = $1909;
1488 GL_LUMINANCE_ALPHA = $190A;
1489 GL_BITMAP = $1A00;
1490 GL_RENDER = $1C00;
1491 GL_FEEDBACK = $1C01;
1492 GL_SELECT = $1C02;
1493 GL_FLAT = $1D00;
1494 GL_SMOOTH = $1D01;
1495 GL_S = $2000;
1496 GL_T = $2001;
1497 GL_R = $2002;
1498 GL_Q = $2003;
1499 GL_MODULATE = $2100;
1500 GL_DECAL = $2101;
1501 GL_TEXTURE_ENV_MODE = $2200;
1502 GL_TEXTURE_ENV_COLOR = $2201;
1503 GL_TEXTURE_ENV = $2300;
1504 GL_EYE_LINEAR = $2400;
1505 GL_OBJECT_LINEAR = $2401;
1506 GL_SPHERE_MAP = $2402;
1507 GL_TEXTURE_GEN_MODE = $2500;
1508 GL_OBJECT_PLANE = $2501;
1509 GL_EYE_PLANE = $2502;
1510 GL_CLAMP = $2900;
1511 GL_CLIENT_PIXEL_STORE_BIT = $00000001;
1512 GL_CLIENT_VERTEX_ARRAY_BIT = $00000002;
1513 GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF;
1514 GL_ALPHA4 = $803B;
1515 GL_ALPHA8 = $803C;
1516 GL_ALPHA12 = $803D;
1517 GL_ALPHA16 = $803E;
1518 GL_LUMINANCE4 = $803F;
1519 GL_LUMINANCE8 = $8040;
1520 GL_LUMINANCE12 = $8041;
1521 GL_LUMINANCE16 = $8042;
1522 GL_LUMINANCE4_ALPHA4 = $8043;
1523 GL_LUMINANCE6_ALPHA2 = $8044;
1524 GL_LUMINANCE8_ALPHA8 = $8045;
1525 GL_LUMINANCE12_ALPHA4 = $8046;
1526 GL_LUMINANCE12_ALPHA12 = $8047;
1527 GL_LUMINANCE16_ALPHA16 = $8048;
1528 GL_INTENSITY = $8049;
1529 GL_INTENSITY4 = $804A;
1530 GL_INTENSITY8 = $804B;
1531 GL_INTENSITY12 = $804C;
1532 GL_INTENSITY16 = $804D;
1533 GL_TEXTURE_LUMINANCE_SIZE = $8060;
1534 GL_TEXTURE_INTENSITY_SIZE = $8061;
1535 GL_TEXTURE_PRIORITY = $8066;
1536 GL_TEXTURE_RESIDENT = $8067;
1537 GL_VERTEX_ARRAY = $8074;
1538 GL_NORMAL_ARRAY = $8075;
1539 GL_COLOR_ARRAY = $8076;
1540 GL_INDEX_ARRAY = $8077;
1541 GL_TEXTURE_COORD_ARRAY = $8078;
1542 GL_EDGE_FLAG_ARRAY = $8079;
1543 GL_VERTEX_ARRAY_SIZE = $807A;
1544 GL_VERTEX_ARRAY_TYPE = $807B;
1545 GL_VERTEX_ARRAY_STRIDE = $807C;
1546 GL_NORMAL_ARRAY_TYPE = $807E;
1547 GL_NORMAL_ARRAY_STRIDE = $807F;
1548 GL_COLOR_ARRAY_SIZE = $8081;
1549 GL_COLOR_ARRAY_TYPE = $8082;
1550 GL_COLOR_ARRAY_STRIDE = $8083;
1551 GL_INDEX_ARRAY_TYPE = $8085;
1552 GL_INDEX_ARRAY_STRIDE = $8086;
1553 GL_TEXTURE_COORD_ARRAY_SIZE = $8088;
1554 GL_TEXTURE_COORD_ARRAY_TYPE = $8089;
1555 GL_TEXTURE_COORD_ARRAY_STRIDE = $808A;
1556 GL_EDGE_FLAG_ARRAY_STRIDE = $808C;
1557 GL_VERTEX_ARRAY_POINTER = $808E;
1558 GL_NORMAL_ARRAY_POINTER = $808F;
1559 GL_COLOR_ARRAY_POINTER = $8090;
1560 GL_INDEX_ARRAY_POINTER = $8091;
1561 GL_TEXTURE_COORD_ARRAY_POINTER = $8092;
1562 GL_EDGE_FLAG_ARRAY_POINTER = $8093;
1563 GL_V2F = $2A20;
1564 GL_V3F = $2A21;
1565 GL_C4UB_V2F = $2A22;
1566 GL_C4UB_V3F = $2A23;
1567 GL_C3F_V3F = $2A24;
1568 GL_N3F_V3F = $2A25;
1569 GL_C4F_N3F_V3F = $2A26;
1570 GL_T2F_V3F = $2A27;
1571 GL_T4F_V4F = $2A28;
1572 GL_T2F_C4UB_V3F = $2A29;
1573 GL_T2F_C3F_V3F = $2A2A;
1574 GL_T2F_N3F_V3F = $2A2B;
1575 GL_T2F_C4F_N3F_V3F = $2A2C;
1576 GL_T4F_C4F_N3F_V4F = $2A2D;
1577 GL_COLOR_TABLE_FORMAT_EXT = $80D8;
1578 GL_COLOR_TABLE_WIDTH_EXT = $80D9;
1579 GL_COLOR_TABLE_RED_SIZE_EXT = $80DA;
1580 GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB;
1581 GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC;
1582 GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD;
1583 GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE;
1584 GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF;
1585 GL_LOGIC_OP = GL_INDEX_LOGIC_OP;
1586 GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT;
1587 {$endif}
1588
1589 // GL_VERSION_1_2
1590 GL_UNSIGNED_BYTE_3_3_2 = $8032;
1591 GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
1592 GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
1593 GL_UNSIGNED_INT_8_8_8_8 = $8035;
1594 GL_UNSIGNED_INT_10_10_10_2 = $8036;
1595 GL_TEXTURE_BINDING_3D = $806A;
1596 GL_PACK_SKIP_IMAGES = $806B;
1597 GL_PACK_IMAGE_HEIGHT = $806C;
1598 GL_UNPACK_SKIP_IMAGES = $806D;
1599 GL_UNPACK_IMAGE_HEIGHT = $806E;
1600 GL_TEXTURE_3D = $806F;
1601 GL_PROXY_TEXTURE_3D = $8070;
1602 GL_TEXTURE_DEPTH = $8071;
1603 GL_TEXTURE_WRAP_R = $8072;
1604 GL_MAX_3D_TEXTURE_SIZE = $8073;
1605 GL_UNSIGNED_BYTE_2_3_3_REV = $8362;
1606 GL_UNSIGNED_SHORT_5_6_5 = $8363;
1607 GL_UNSIGNED_SHORT_5_6_5_REV = $8364;
1608 GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365;
1609 GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366;
1610 GL_UNSIGNED_INT_8_8_8_8_REV = $8367;
1611 GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
1612 GL_BGR = $80E0;
1613 GL_BGRA = $80E1;
1614 GL_MAX_ELEMENTS_VERTICES = $80E8;
1615 GL_MAX_ELEMENTS_INDICES = $80E9;
1616 GL_CLAMP_TO_EDGE = $812F;
1617 GL_TEXTURE_MIN_LOD = $813A;
1618 GL_TEXTURE_MAX_LOD = $813B;
1619 GL_TEXTURE_BASE_LEVEL = $813C;
1620 GL_TEXTURE_MAX_LEVEL = $813D;
1621 GL_SMOOTH_POINT_SIZE_RANGE = $0B12;
1622 GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13;
1623 GL_SMOOTH_LINE_WIDTH_RANGE = $0B22;
1624 GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23;
1625 GL_ALIASED_LINE_WIDTH_RANGE = $846E;
1626 {$ifdef DGL_DEPRECATED}
1627 GL_RESCALE_NORMAL = $803A;
1628 GL_LIGHT_MODEL_COLOR_CONTROL = $81F8;
1629 GL_SINGLE_COLOR = $81F9;
1630 GL_SEPARATE_SPECULAR_COLOR = $81FA;
1631 GL_ALIASED_POINT_SIZE_RANGE = $846D;
1632 {$endif}
1633
1634 // GL_VERSION_1_3
1635 GL_TEXTURE0 = $84C0;
1636 GL_TEXTURE1 = $84C1;
1637 GL_TEXTURE2 = $84C2;
1638 GL_TEXTURE3 = $84C3;
1639 GL_TEXTURE4 = $84C4;
1640 GL_TEXTURE5 = $84C5;
1641 GL_TEXTURE6 = $84C6;
1642 GL_TEXTURE7 = $84C7;
1643 GL_TEXTURE8 = $84C8;
1644 GL_TEXTURE9 = $84C9;
1645 GL_TEXTURE10 = $84CA;
1646 GL_TEXTURE11 = $84CB;
1647 GL_TEXTURE12 = $84CC;
1648 GL_TEXTURE13 = $84CD;
1649 GL_TEXTURE14 = $84CE;
1650 GL_TEXTURE15 = $84CF;
1651 GL_TEXTURE16 = $84D0;
1652 GL_TEXTURE17 = $84D1;
1653 GL_TEXTURE18 = $84D2;
1654 GL_TEXTURE19 = $84D3;
1655 GL_TEXTURE20 = $84D4;
1656 GL_TEXTURE21 = $84D5;
1657 GL_TEXTURE22 = $84D6;
1658 GL_TEXTURE23 = $84D7;
1659 GL_TEXTURE24 = $84D8;
1660 GL_TEXTURE25 = $84D9;
1661 GL_TEXTURE26 = $84DA;
1662 GL_TEXTURE27 = $84DB;
1663 GL_TEXTURE28 = $84DC;
1664 GL_TEXTURE29 = $84DD;
1665 GL_TEXTURE30 = $84DE;
1666 GL_TEXTURE31 = $84DF;
1667 GL_ACTIVE_TEXTURE = $84E0;
1668 GL_MULTISAMPLE = $809D;
1669 GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
1670 GL_SAMPLE_ALPHA_TO_ONE = $809F;
1671 GL_SAMPLE_COVERAGE = $80A0;
1672 GL_SAMPLE_BUFFERS = $80A8;
1673 GL_SAMPLES = $80A9;
1674 GL_SAMPLE_COVERAGE_VALUE = $80AA;
1675 GL_SAMPLE_COVERAGE_INVERT = $80AB;
1676 GL_TEXTURE_CUBE_MAP = $8513;
1677 GL_TEXTURE_BINDING_CUBE_MAP = $8514;
1678 GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
1679 GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
1680 GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
1681 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
1682 GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
1683 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
1684 GL_PROXY_TEXTURE_CUBE_MAP = $851B;
1685 GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
1686 GL_COMPRESSED_RGB = $84ED;
1687 GL_COMPRESSED_RGBA = $84EE;
1688 GL_TEXTURE_COMPRESSION_HINT = $84EF;
1689 GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0;
1690 GL_TEXTURE_COMPRESSED = $86A1;
1691 GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
1692 GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
1693 GL_CLAMP_TO_BORDER = $812D;
1694 {$ifdef DGL_DEPRECATED}
1695 GL_CLIENT_ACTIVE_TEXTURE = $84E1;
1696 GL_MAX_TEXTURE_UNITS = $84E2;
1697 GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3;
1698 GL_TRANSPOSE_PROJECTION_MATRIX = $84E4;
1699 GL_TRANSPOSE_TEXTURE_MATRIX = $84E5;
1700 GL_TRANSPOSE_COLOR_MATRIX = $84E6;
1701 GL_MULTISAMPLE_BIT = $20000000;
1702 GL_NORMAL_MAP = $8511;
1703 GL_REFLECTION_MAP = $8512;
1704 GL_COMPRESSED_ALPHA = $84E9;
1705 GL_COMPRESSED_LUMINANCE = $84EA;
1706 GL_COMPRESSED_LUMINANCE_ALPHA = $84EB;
1707 GL_COMPRESSED_INTENSITY = $84EC;
1708 GL_COMBINE = $8570;
1709 GL_COMBINE_RGB = $8571;
1710 GL_COMBINE_ALPHA = $8572;
1711 GL_SOURCE0_RGB = $8580;
1712 GL_SOURCE1_RGB = $8581;
1713 GL_SOURCE2_RGB = $8582;
1714 GL_SOURCE0_ALPHA = $8588;
1715 GL_SOURCE1_ALPHA = $8589;
1716 GL_SOURCE2_ALPHA = $858A;
1717 GL_OPERAND0_RGB = $8590;
1718 GL_OPERAND1_RGB = $8591;
1719 GL_OPERAND2_RGB = $8592;
1720 GL_OPERAND0_ALPHA = $8598;
1721 GL_OPERAND1_ALPHA = $8599;
1722 GL_OPERAND2_ALPHA = $859A;
1723 GL_RGB_SCALE = $8573;
1724 GL_ADD_SIGNED = $8574;
1725 GL_INTERPOLATE = $8575;
1726 GL_SUBTRACT = $84E7;
1727 GL_CONSTANT = $8576;
1728 GL_PRIMARY_COLOR = $8577;
1729 GL_PREVIOUS = $8578;
1730 GL_DOT3_RGB = $86AE;
1731 GL_DOT3_RGBA = $86AF;
1732 {$endif}
1733
1734 // GL_VERSION_1_4
1735 GL_BLEND_DST_RGB = $80C8;
1736 GL_BLEND_SRC_RGB = $80C9;
1737 GL_BLEND_DST_ALPHA = $80CA;
1738 GL_BLEND_SRC_ALPHA = $80CB;
1739 GL_POINT_FADE_THRESHOLD_SIZE = $8128;
1740 GL_DEPTH_COMPONENT16 = $81A5;
1741 GL_DEPTH_COMPONENT24 = $81A6;
1742 GL_DEPTH_COMPONENT32 = $81A7;
1743 GL_MIRRORED_REPEAT = $8370;
1744 GL_MAX_TEXTURE_LOD_BIAS = $84FD;
1745 GL_TEXTURE_LOD_BIAS = $8501;
1746 GL_INCR_WRAP = $8507;
1747 GL_DECR_WRAP = $8508;
1748 GL_TEXTURE_DEPTH_SIZE = $884A;
1749 GL_TEXTURE_COMPARE_MODE = $884C;
1750 GL_TEXTURE_COMPARE_FUNC = $884D;
1751 {$ifdef DGL_DEPRECATED}
1752 GL_POINT_SIZE_MIN = $8126;
1753 GL_POINT_SIZE_MAX = $8127;
1754 GL_POINT_DISTANCE_ATTENUATION = $8129;
1755 GL_GENERATE_MIPMAP = $8191;
1756 GL_GENERATE_MIPMAP_HINT = $8192;
1757 GL_FOG_COORDINATE_SOURCE = $8450;
1758 GL_FOG_COORDINATE = $8451;
1759 GL_FRAGMENT_DEPTH = $8452;
1760 GL_CURRENT_FOG_COORDINATE = $8453;
1761 GL_FOG_COORDINATE_ARRAY_TYPE = $8454;
1762 GL_FOG_COORDINATE_ARRAY_STRIDE = $8455;
1763 GL_FOG_COORDINATE_ARRAY_POINTER = $8456;
1764 GL_FOG_COORDINATE_ARRAY = $8457;
1765 GL_COLOR_SUM = $8458;
1766 GL_CURRENT_SECONDARY_COLOR = $8459;
1767 GL_SECONDARY_COLOR_ARRAY_SIZE = $845A;
1768 GL_SECONDARY_COLOR_ARRAY_TYPE = $845B;
1769 GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C;
1770 GL_SECONDARY_COLOR_ARRAY_POINTER = $845D;
1771 GL_SECONDARY_COLOR_ARRAY = $845E;
1772 GL_TEXTURE_FILTER_CONTROL = $8500;
1773 GL_DEPTH_TEXTURE_MODE = $884B;
1774 GL_COMPARE_R_TO_TEXTURE = $884E;
1775 {$endif}
1776
1777 // GL_VERSION_1_5
1778 GL_BUFFER_SIZE = $8764;
1779 GL_BUFFER_USAGE = $8765;
1780 GL_QUERY_COUNTER_BITS = $8864;
1781 GL_CURRENT_QUERY = $8865;
1782 GL_QUERY_RESULT = $8866;
1783 GL_QUERY_RESULT_AVAILABLE = $8867;
1784 GL_ARRAY_BUFFER = $8892;
1785 GL_ELEMENT_ARRAY_BUFFER = $8893;
1786 GL_ARRAY_BUFFER_BINDING = $8894;
1787 GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
1788 GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;
1789 GL_READ_ONLY = $88B8;
1790 GL_WRITE_ONLY = $88B9;
1791 GL_READ_WRITE = $88BA;
1792 GL_BUFFER_ACCESS = $88BB;
1793 GL_BUFFER_MAPPED = $88BC;
1794 GL_BUFFER_MAP_POINTER = $88BD;
1795 GL_STREAM_DRAW = $88E0;
1796 GL_STREAM_READ = $88E1;
1797 GL_STREAM_COPY = $88E2;
1798 GL_STATIC_DRAW = $88E4;
1799 GL_STATIC_READ = $88E5;
1800 GL_STATIC_COPY = $88E6;
1801 GL_DYNAMIC_DRAW = $88E8;
1802 GL_DYNAMIC_READ = $88E9;
1803 GL_DYNAMIC_COPY = $88EA;
1804 GL_SAMPLES_PASSED = $8914;
1805 {$ifdef DGL_DEPRECATED}
1806 GL_VERTEX_ARRAY_BUFFER_BINDING = $8896;
1807 GL_NORMAL_ARRAY_BUFFER_BINDING = $8897;
1808 GL_COLOR_ARRAY_BUFFER_BINDING = $8898;
1809 GL_INDEX_ARRAY_BUFFER_BINDING = $8899;
1810 GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A;
1811 GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B;
1812 GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C;
1813 GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D;
1814 GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E;
1815 GL_FOG_COORD_SRC = $8450;
1816 GL_FOG_COORD = $8451;
1817 GL_CURRENT_FOG_COORD = $8453;
1818 GL_FOG_COORD_ARRAY_TYPE = $8454;
1819 GL_FOG_COORD_ARRAY_STRIDE = $8455;
1820 GL_FOG_COORD_ARRAY_POINTER = $8456;
1821 GL_FOG_COORD_ARRAY = $8457;
1822 GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D;
1823 GL_SRC0_RGB = $8580;
1824 GL_SRC1_RGB = $8581;
1825 GL_SRC2_RGB = $8582;
1826 GL_SRC0_ALPHA = $8588;
1827 GL_SRC1_ALPHA = $8589;
1828 GL_SRC2_ALPHA = $858A;
1829 {$endif}
1830
1831 // GL_VERSION_2_0
1832 GL_BLEND_EQUATION_RGB = $8009;
1833 GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;
1834 GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;
1835 GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;
1836 GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;
1837 GL_CURRENT_VERTEX_ATTRIB = $8626;
1838 GL_VERTEX_PROGRAM_POINT_SIZE = $8642;
1839 GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;
1840 GL_STENCIL_BACK_FUNC = $8800;
1841 GL_STENCIL_BACK_FAIL = $8801;
1842 GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;
1843 GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;
1844 GL_MAX_DRAW_BUFFERS = $8824;
1845 GL_DRAW_BUFFER0 = $8825;
1846 GL_DRAW_BUFFER1 = $8826;
1847 GL_DRAW_BUFFER2 = $8827;
1848 GL_DRAW_BUFFER3 = $8828;
1849 GL_DRAW_BUFFER4 = $8829;
1850 GL_DRAW_BUFFER5 = $882A;
1851 GL_DRAW_BUFFER6 = $882B;
1852 GL_DRAW_BUFFER7 = $882C;
1853 GL_DRAW_BUFFER8 = $882D;
1854 GL_DRAW_BUFFER9 = $882E;
1855 GL_DRAW_BUFFER10 = $882F;
1856 GL_DRAW_BUFFER11 = $8830;
1857 GL_DRAW_BUFFER12 = $8831;
1858 GL_DRAW_BUFFER13 = $8832;
1859 GL_DRAW_BUFFER14 = $8833;
1860 GL_DRAW_BUFFER15 = $8834;
1861 GL_BLEND_EQUATION_ALPHA = $883D;
1862 GL_MAX_VERTEX_ATTRIBS = $8869;
1863 GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;
1864 GL_MAX_TEXTURE_IMAGE_UNITS = $8872;
1865 GL_FRAGMENT_SHADER = $8B30;
1866 GL_VERTEX_SHADER = $8B31;
1867 GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;
1868 GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;
1869 GL_MAX_VARYING_FLOATS = $8B4B;
1870 GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;
1871 GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;
1872 GL_SHADER_TYPE = $8B4F;
1873 GL_FLOAT_VEC2 = $8B50;
1874 GL_FLOAT_VEC3 = $8B51;
1875 GL_FLOAT_VEC4 = $8B52;
1876 GL_INT_VEC2 = $8B53;
1877 GL_INT_VEC3 = $8B54;
1878 GL_INT_VEC4 = $8B55;
1879 GL_BOOL = $8B56;
1880 GL_BOOL_VEC2 = $8B57;
1881 GL_BOOL_VEC3 = $8B58;
1882 GL_BOOL_VEC4 = $8B59;
1883 GL_FLOAT_MAT2 = $8B5A;
1884 GL_FLOAT_MAT3 = $8B5B;
1885 GL_FLOAT_MAT4 = $8B5C;
1886 GL_SAMPLER_1D = $8B5D;
1887 GL_SAMPLER_2D = $8B5E;
1888 GL_SAMPLER_3D = $8B5F;
1889 GL_SAMPLER_CUBE = $8B60;
1890 GL_SAMPLER_1D_SHADOW = $8B61;
1891 GL_SAMPLER_2D_SHADOW = $8B62;
1892 GL_DELETE_STATUS = $8B80;
1893 GL_COMPILE_STATUS = $8B81;
1894 GL_LINK_STATUS = $8B82;
1895 GL_VALIDATE_STATUS = $8B83;
1896 GL_INFO_LOG_LENGTH = $8B84;
1897 GL_ATTACHED_SHADERS = $8B85;
1898 GL_ACTIVE_UNIFORMS = $8B86;
1899 GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;
1900 GL_SHADER_SOURCE_LENGTH = $8B88;
1901 GL_ACTIVE_ATTRIBUTES = $8B89;
1902 GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;
1903 GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;
1904 GL_SHADING_LANGUAGE_VERSION = $8B8C;
1905 GL_CURRENT_PROGRAM = $8B8D;
1906 GL_POINT_SPRITE_COORD_ORIGIN = $8CA0;
1907 GL_LOWER_LEFT = $8CA1;
1908 GL_UPPER_LEFT = $8CA2;
1909 GL_STENCIL_BACK_REF = $8CA3;
1910 GL_STENCIL_BACK_VALUE_MASK = $8CA4;
1911 GL_STENCIL_BACK_WRITEMASK = $8CA5;
1912 {$ifdef DGL_DEPRECATED}
1913 GL_VERTEX_PROGRAM_TWO_SIDE = $8643;
1914 GL_POINT_SPRITE = $8861;
1915 GL_COORD_REPLACE = $8862;
1916 GL_MAX_TEXTURE_COORDS = $8871;
1917 {$endif}
1918
1919 // GL_VERSION_2_1
1920 GL_PIXEL_PACK_BUFFER = $88EB;
1921 GL_PIXEL_UNPACK_BUFFER = $88EC;
1922 GL_PIXEL_PACK_BUFFER_BINDING = $88ED;
1923 GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF;
1924 GL_FLOAT_MAT2x3 = $8B65;
1925 GL_FLOAT_MAT2x4 = $8B66;
1926 GL_FLOAT_MAT3x2 = $8B67;
1927 GL_FLOAT_MAT3x4 = $8B68;
1928 GL_FLOAT_MAT4x2 = $8B69;
1929 GL_FLOAT_MAT4x3 = $8B6A;
1930 GL_SRGB = $8C40;
1931 GL_SRGB8 = $8C41;
1932 GL_SRGB_ALPHA = $8C42;
1933 GL_SRGB8_ALPHA8 = $8C43;
1934 GL_COMPRESSED_SRGB = $8C48;
1935 GL_COMPRESSED_SRGB_ALPHA = $8C49;
1936 {$ifdef DGL_DEPRECATED}
1937 GL_CURRENT_RASTER_SECONDARY_COLOR = $845F;
1938 GL_SLUMINANCE_ALPHA = $8C44;
1939 GL_SLUMINANCE8_ALPHA8 = $8C45;
1940 GL_SLUMINANCE = $8C46;
1941 GL_SLUMINANCE8 = $8C47;
1942 GL_COMPRESSED_SLUMINANCE = $8C4A;
1943 GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B;
1944 {$endif}
1945
1946 // GL_VERSION_3_0
1947 GL_COMPARE_REF_TO_TEXTURE = $884E;
1948 GL_CLIP_DISTANCE0 = $3000;
1949 GL_CLIP_DISTANCE1 = $3001;
1950 GL_CLIP_DISTANCE2 = $3002;
1951 GL_CLIP_DISTANCE3 = $3003;
1952 GL_CLIP_DISTANCE4 = $3004;
1953 GL_CLIP_DISTANCE5 = $3005;
1954 GL_CLIP_DISTANCE6 = $3006;
1955 GL_CLIP_DISTANCE7 = $3007;
1956 GL_MAX_CLIP_DISTANCES = $0D32;
1957 GL_MAJOR_VERSION = $821B;
1958 GL_MINOR_VERSION = $821C;
1959 GL_NUM_EXTENSIONS = $821D;
1960 GL_CONTEXT_FLAGS = $821E;
1961 GL_DEPTH_BUFFER = $8223;
1962 GL_STENCIL_BUFFER = $8224;
1963 GL_COMPRESSED_RED = $8225;
1964 GL_COMPRESSED_RG = $8226;
1965 GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001;
1966 GL_RGBA32F = $8814;
1967 GL_RGB32F = $8815;
1968 GL_RGBA16F = $881A;
1969 GL_RGB16F = $881B;
1970 GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD;
1971 GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF;
1972 GL_MIN_PROGRAM_TEXEL_OFFSET = $8904;
1973 GL_MAX_PROGRAM_TEXEL_OFFSET = $8905;
1974 GL_CLAMP_READ_COLOR = $891C;
1975 GL_FIXED_ONLY = $891D;
1976 GL_MAX_VARYING_COMPONENTS = $8B4B;
1977 GL_TEXTURE_1D_ARRAY = $8C18;
1978 GL_PROXY_TEXTURE_1D_ARRAY = $8C19;
1979 GL_TEXTURE_2D_ARRAY = $8C1A;
1980 GL_PROXY_TEXTURE_2D_ARRAY = $8C1B;
1981 GL_TEXTURE_BINDING_1D_ARRAY = $8C1C;
1982 GL_TEXTURE_BINDING_2D_ARRAY = $8C1D;
1983 GL_R11F_G11F_B10F = $8C3A;
1984 GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B;
1985 GL_RGB9_E5 = $8C3D;
1986 GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E;
1987 GL_TEXTURE_SHARED_SIZE = $8C3F;
1988 GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76;
1989 GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F;
1990 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80;
1991 GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83;
1992 GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84;
1993 GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85;
1994 GL_PRIMITIVES_GENERATED = $8C87;
1995 GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88;
1996 GL_RASTERIZER_DISCARD = $8C89;
1997 GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A;
1998 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B;
1999 GL_INTERLEAVED_ATTRIBS = $8C8C;
2000 GL_SEPARATE_ATTRIBS = $8C8D;
2001 GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E;
2002 GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F;
2003 GL_RGBA32UI = $8D70;
2004 GL_RGB32UI = $8D71;
2005 GL_RGBA16UI = $8D76;
2006 GL_RGB16UI = $8D77;
2007 GL_RGBA8UI = $8D7C;
2008 GL_RGB8UI = $8D7D;
2009 GL_RGBA32I = $8D82;
2010 GL_RGB32I = $8D83;
2011 GL_RGBA16I = $8D88;
2012 GL_RGB16I = $8D89;
2013 GL_RGBA8I = $8D8E;
2014 GL_RGB8I = $8D8F;
2015 GL_RED_INTEGER = $8D94;
2016 GL_GREEN_INTEGER = $8D95;
2017 GL_BLUE_INTEGER = $8D96;
2018 GL_RGB_INTEGER = $8D98;
2019 GL_RGBA_INTEGER = $8D99;
2020 GL_BGR_INTEGER = $8D9A;
2021 GL_BGRA_INTEGER = $8D9B;
2022 GL_SAMPLER_1D_ARRAY = $8DC0;
2023 GL_SAMPLER_2D_ARRAY = $8DC1;
2024 GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3;
2025 GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4;
2026 GL_SAMPLER_CUBE_SHADOW = $8DC5;
2027 GL_UNSIGNED_INT_VEC2 = $8DC6;
2028 GL_UNSIGNED_INT_VEC3 = $8DC7;
2029 GL_UNSIGNED_INT_VEC4 = $8DC8;
2030 GL_INT_SAMPLER_1D = $8DC9;
2031 GL_INT_SAMPLER_2D = $8DCA;
2032 GL_INT_SAMPLER_3D = $8DCB;
2033 GL_INT_SAMPLER_CUBE = $8DCC;
2034 GL_INT_SAMPLER_1D_ARRAY = $8DCE;
2035 GL_INT_SAMPLER_2D_ARRAY = $8DCF;
2036 GL_UNSIGNED_INT_SAMPLER_1D = $8DD1;
2037 GL_UNSIGNED_INT_SAMPLER_2D = $8DD2;
2038 GL_UNSIGNED_INT_SAMPLER_3D = $8DD3;
2039 GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4;
2040 GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6;
2041 GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7;
2042 GL_QUERY_WAIT = $8E13;
2043 GL_QUERY_NO_WAIT = $8E14;
2044 GL_QUERY_BY_REGION_WAIT = $8E15;
2045 GL_QUERY_BY_REGION_NO_WAIT = $8E16;
2046 GL_BUFFER_ACCESS_FLAGS = $911F;
2047 GL_BUFFER_MAP_LENGTH = $9120;
2048 GL_BUFFER_MAP_OFFSET = $9121;
2049 { Reuse tokens from ARB_depth_buffer_float }
2050 { reuse GL_DEPTH_COMPONENT32F }
2051 { reuse GL_DEPTH32F_STENCIL8 }
2052 { reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV }
2053 { Reuse tokens from ARB_framebuffer_object }
2054 { reuse GL_INVALID_FRAMEBUFFER_OPERATION }
2055 { reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING }
2056 { reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE }
2057 { reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE }
2058 { reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE }
2059 { reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE }
2060 { reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE }
2061 { reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE }
2062 { reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE }
2063 { reuse GL_FRAMEBUFFER_DEFAULT }
2064 { reuse GL_FRAMEBUFFER_UNDEFINED }
2065 { reuse GL_DEPTH_STENCIL_ATTACHMENT }
2066 { reuse GL_INDEX }
2067 { reuse GL_MAX_RENDERBUFFER_SIZE }
2068 { reuse GL_DEPTH_STENCIL }
2069 { reuse GL_UNSIGNED_INT_24_8 }
2070 { reuse GL_DEPTH24_STENCIL8 }
2071 { reuse GL_TEXTURE_STENCIL_SIZE }
2072 { reuse GL_TEXTURE_RED_TYPE }
2073 { reuse GL_TEXTURE_GREEN_TYPE }
2074 { reuse GL_TEXTURE_BLUE_TYPE }
2075 { reuse GL_TEXTURE_ALPHA_TYPE }
2076 { reuse GL_TEXTURE_DEPTH_TYPE }
2077 { reuse GL_UNSIGNED_NORMALIZED }
2078 { reuse GL_FRAMEBUFFER_BINDING }
2079 { reuse GL_DRAW_FRAMEBUFFER_BINDING }
2080 { reuse GL_RENDERBUFFER_BINDING }
2081 { reuse GL_READ_FRAMEBUFFER }
2082 { reuse GL_DRAW_FRAMEBUFFER }
2083 { reuse GL_READ_FRAMEBUFFER_BINDING }
2084 { reuse GL_RENDERBUFFER_SAMPLES }
2085 { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE }
2086 { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME }
2087 { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL }
2088 { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE }
2089 { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
2090 { reuse GL_FRAMEBUFFER_COMPLETE }
2091 { reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT }
2092 { reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT }
2093 { reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER }
2094 { reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER }
2095 { reuse GL_FRAMEBUFFER_UNSUPPORTED }
2096 { reuse GL_MAX_COLOR_ATTACHMENTS }
2097 { reuse GL_COLOR_ATTACHMENT0 }
2098 { reuse GL_COLOR_ATTACHMENT1 }
2099 { reuse GL_COLOR_ATTACHMENT2 }
2100 { reuse GL_COLOR_ATTACHMENT3 }
2101 { reuse GL_COLOR_ATTACHMENT4 }
2102 { reuse GL_COLOR_ATTACHMENT5 }
2103 { reuse GL_COLOR_ATTACHMENT6 }
2104 { reuse GL_COLOR_ATTACHMENT7 }
2105 { reuse GL_COLOR_ATTACHMENT8 }
2106 { reuse GL_COLOR_ATTACHMENT9 }
2107 { reuse GL_COLOR_ATTACHMENT10 }
2108 { reuse GL_COLOR_ATTACHMENT11 }
2109 { reuse GL_COLOR_ATTACHMENT12 }
2110 { reuse GL_COLOR_ATTACHMENT13 }
2111 { reuse GL_COLOR_ATTACHMENT14 }
2112 { reuse GL_COLOR_ATTACHMENT15 }
2113 { reuse GL_DEPTH_ATTACHMENT }
2114 { reuse GL_STENCIL_ATTACHMENT }
2115 { reuse GL_FRAMEBUFFER }
2116 { reuse GL_RENDERBUFFER }
2117 { reuse GL_RENDERBUFFER_WIDTH }
2118 { reuse GL_RENDERBUFFER_HEIGHT }
2119 { reuse GL_RENDERBUFFER_INTERNAL_FORMAT }
2120 { reuse GL_STENCIL_INDEX1 }
2121 { reuse GL_STENCIL_INDEX4 }
2122 { reuse GL_STENCIL_INDEX8 }
2123 { reuse GL_STENCIL_INDEX16 }
2124 { reuse GL_RENDERBUFFER_RED_SIZE }
2125 { reuse GL_RENDERBUFFER_GREEN_SIZE }
2126 { reuse GL_RENDERBUFFER_BLUE_SIZE }
2127 { reuse GL_RENDERBUFFER_ALPHA_SIZE }
2128 { reuse GL_RENDERBUFFER_DEPTH_SIZE }
2129 { reuse GL_RENDERBUFFER_STENCIL_SIZE }
2130 { reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE }
2131 { reuse GL_MAX_SAMPLES }
2132 { Reuse tokens from ARB_framebuffer_sRGB }
2133 { reuse GL_FRAMEBUFFER_SRGB }
2134 { Reuse tokens from ARB_half_float_vertex }
2135 { reuse GL_HALF_FLOAT }
2136 { Reuse tokens from ARB_map_buffer_range }
2137 { reuse GL_MAP_READ_BIT }
2138 { reuse GL_MAP_WRITE_BIT }
2139 { reuse GL_MAP_INVALIDATE_RANGE_BIT }
2140 { reuse GL_MAP_INVALIDATE_BUFFER_BIT }
2141 { reuse GL_MAP_FLUSH_EXPLICIT_BIT }
2142 { reuse GL_MAP_UNSYNCHRONIZED_BIT }
2143 { Reuse tokens from ARB_texture_compression_rgtc }
2144 { reuse GL_COMPRESSED_RED_RGTC1 }
2145 { reuse GL_COMPRESSED_SIGNED_RED_RGTC1 }
2146 { reuse GL_COMPRESSED_RG_RGTC2 }
2147 { reuse GL_COMPRESSED_SIGNED_RG_RGTC2 }
2148 { Reuse tokens from ARB_texture_rg }
2149 { reuse GL_RG }
2150 { reuse GL_RG_INTEGER }
2151 { reuse GL_R8 }
2152 { reuse GL_R16 }
2153 { reuse GL_RG8 }
2154 { reuse GL_RG16 }
2155 { reuse GL_R16F }
2156 { reuse GL_R32F }
2157 { reuse GL_RG16F }
2158 { reuse GL_RG32F }
2159 { reuse GL_R8I }
2160 { reuse GL_R8UI }
2161 { reuse GL_R16I }
2162 { reuse GL_R16UI }
2163 { reuse GL_R32I }
2164 { reuse GL_R32UI }
2165 { reuse GL_RG8I }
2166 { reuse GL_RG8UI }
2167 { reuse GL_RG16I }
2168 { reuse GL_RG16UI }
2169 { reuse GL_RG32I }
2170 { reuse GL_RG32UI }
2171 { Reuse tokens from ARB_vertex_array_object }
2172 { reuse GL_VERTEX_ARRAY_BINDING }
2173 {$ifdef DGL_DEPRECATED}
2174 GL_CLAMP_VERTEX_COLOR = $891A;
2175 GL_CLAMP_FRAGMENT_COLOR = $891B;
2176 GL_ALPHA_INTEGER = $8D97;
2177 { Reuse tokens from ARB_framebuffer_object }
2178 { reuse GL_TEXTURE_LUMINANCE_TYPE }
2179 { reuse GL_TEXTURE_INTENSITY_TYPE }
2180 {$endif}
2181
2182 // GL_VERSION_3_1
2183 GL_SAMPLER_2D_RECT = $8B63;
2184 GL_SAMPLER_2D_RECT_SHADOW = $8B64;
2185 GL_SAMPLER_BUFFER = $8DC2;
2186 GL_INT_SAMPLER_2D_RECT = $8DCD;
2187 GL_INT_SAMPLER_BUFFER = $8DD0;
2188 GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5;
2189 GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8;
2190 GL_TEXTURE_BUFFER = $8C2A;
2191 GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B;
2192 GL_TEXTURE_BINDING_BUFFER = $8C2C;
2193 GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D;
2194 GL_TEXTURE_BUFFER_FORMAT = $8C2E;
2195 GL_TEXTURE_RECTANGLE = $84F5;
2196 GL_TEXTURE_BINDING_RECTANGLE = $84F6;
2197 GL_PROXY_TEXTURE_RECTANGLE = $84F7;
2198 GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8;
2199 GL_RED_SNORM = $8F90;
2200 GL_RG_SNORM = $8F91;
2201 GL_RGB_SNORM = $8F92;
2202 GL_RGBA_SNORM = $8F93;
2203 GL_R8_SNORM = $8F94;
2204 GL_RG8_SNORM = $8F95;
2205 GL_RGB8_SNORM = $8F96;
2206 GL_RGBA8_SNORM = $8F97;
2207 GL_R16_SNORM = $8F98;
2208 GL_RG16_SNORM = $8F99;
2209 GL_RGB16_SNORM = $8F9A;
2210 GL_RGBA16_SNORM = $8F9B;
2211 GL_SIGNED_NORMALIZED = $8F9C;
2212 GL_PRIMITIVE_RESTART = $8F9D;
2213 GL_PRIMITIVE_RESTART_INDEX = $8F9E;
2214 { Reuse tokens from ARB_copy_buffer }
2215 { reuse GL_COPY_READ_BUFFER }
2216 { reuse GL_COPY_WRITE_BUFFER }
2217 { Would reuse tokens from ARB_draw_instanced, but it has none }
2218 { Reuse tokens from ARB_uniform_buffer_object }
2219 { reuse GL_UNIFORM_BUFFER }
2220 { reuse GL_UNIFORM_BUFFER_BINDING }
2221 { reuse GL_UNIFORM_BUFFER_START }
2222 { reuse GL_UNIFORM_BUFFER_SIZE }
2223 { reuse GL_MAX_VERTEX_UNIFORM_BLOCKS }
2224 { reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS }
2225 { reuse GL_MAX_COMBINED_UNIFORM_BLOCKS }
2226 { reuse GL_MAX_UNIFORM_BUFFER_BINDINGS }
2227 { reuse GL_MAX_UNIFORM_BLOCK_SIZE }
2228 { reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS }
2229 { reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS }
2230 { reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT }
2231 { reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH }
2232 { reuse GL_ACTIVE_UNIFORM_BLOCKS }
2233 { reuse GL_UNIFORM_TYPE }
2234 { reuse GL_UNIFORM_SIZE }
2235 { reuse GL_UNIFORM_NAME_LENGTH }
2236 { reuse GL_UNIFORM_BLOCK_INDEX }
2237 { reuse GL_UNIFORM_OFFSET }
2238 { reuse GL_UNIFORM_ARRAY_STRIDE }
2239 { reuse GL_UNIFORM_MATRIX_STRIDE }
2240 { reuse GL_UNIFORM_IS_ROW_MAJOR }
2241 { reuse GL_UNIFORM_BLOCK_BINDING }
2242 { reuse GL_UNIFORM_BLOCK_DATA_SIZE }
2243 { reuse GL_UNIFORM_BLOCK_NAME_LENGTH }
2244 { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS }
2245 { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES }
2246 { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER }
2247 { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER }
2248 { reuse GL_INVALID_INDEX }
2249
2250 // GL_VERSION_3_2
2251 GL_CONTEXT_CORE_PROFILE_BIT = $00000001;
2252 GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002;
2253 GL_LINES_ADJACENCY = $000A;
2254 GL_LINE_STRIP_ADJACENCY = $000B;
2255 GL_TRIANGLES_ADJACENCY = $000C;
2256 GL_TRIANGLE_STRIP_ADJACENCY = $000D;
2257 GL_PROGRAM_POINT_SIZE = $8642;
2258 GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29;
2259 GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7;
2260 GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8;
2261 GL_GEOMETRY_SHADER = $8DD9;
2262 GL_GEOMETRY_VERTICES_OUT = $8916;
2263 GL_GEOMETRY_INPUT_TYPE = $8917;
2264 GL_GEOMETRY_OUTPUT_TYPE = $8918;
2265 GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF;
2266 GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0;
2267 GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1;
2268 GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122;
2269 GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123;
2270 GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124;
2271 GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125;
2272 GL_CONTEXT_PROFILE_MASK = $9126;
2273 { reuse GL_MAX_VARYING_COMPONENTS }
2274 { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
2275 { Reuse tokens from ARB_depth_clamp }
2276 { reuse GL_DEPTH_CLAMP }
2277 { Would reuse tokens from ARB_draw_elements_base_vertex, but it has none }
2278 { Would reuse tokens from ARB_fragment_coord_conventions, but it has none }
2279 { Reuse tokens from ARB_provoking_vertex }
2280 { reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION }
2281 { reuse GL_FIRST_VERTEX_CONVENTION }
2282 { reuse GL_LAST_VERTEX_CONVENTION }
2283 { reuse GL_PROVOKING_VERTEX }
2284 { Reuse tokens from ARB_seamless_cube_map }
2285 { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS }
2286 { Reuse tokens from ARB_sync }
2287 { reuse GL_MAX_SERVER_WAIT_TIMEOUT }
2288 { reuse GL_OBJECT_TYPE }
2289 { reuse GL_SYNC_CONDITION }
2290 { reuse GL_SYNC_STATUS }
2291 { reuse GL_SYNC_FLAGS }
2292 { reuse GL_SYNC_FENCE }
2293 { reuse GL_SYNC_GPU_COMMANDS_COMPLETE }
2294 { reuse GL_UNSIGNALED }
2295 { reuse GL_SIGNALED }
2296 { reuse GL_ALREADY_SIGNALED }
2297 { reuse GL_TIMEOUT_EXPIRED }
2298 { reuse GL_CONDITION_SATISFIED }
2299 { reuse GL_WAIT_FAILED }
2300 { reuse GL_TIMEOUT_IGNORED }
2301 { reuse GL_SYNC_FLUSH_COMMANDS_BIT }
2302 { reuse GL_TIMEOUT_IGNORED }
2303 { Reuse tokens from ARB_texture_multisample }
2304 { reuse GL_SAMPLE_POSITION }
2305 { reuse GL_SAMPLE_MASK }
2306 { reuse GL_SAMPLE_MASK_VALUE }
2307 { reuse GL_MAX_SAMPLE_MASK_WORDS }
2308 { reuse GL_TEXTURE_2D_MULTISAMPLE }
2309 { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE }
2310 { reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY }
2311 { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY }
2312 { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE }
2313 { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY }
2314 { reuse GL_TEXTURE_SAMPLES }
2315 { reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS }
2316 { reuse GL_SAMPLER_2D_MULTISAMPLE }
2317 { reuse GL_INT_SAMPLER_2D_MULTISAMPLE }
2318 { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE }
2319 { reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY }
2320 { reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
2321 { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
2322 { reuse GL_MAX_COLOR_TEXTURE_SAMPLES }
2323 { reuse GL_MAX_DEPTH_TEXTURE_SAMPLES }
2324 { reuse GL_MAX_INTEGER_SAMPLES }
2325 { Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core }
2326
2327 // GL_3DFX_multisample
2328 GL_MULTISAMPLE_3DFX = $86B2;
2329 GL_SAMPLE_BUFFERS_3DFX = $86B3;
2330 GL_SAMPLES_3DFX = $86B4;
2331 GL_MULTISAMPLE_BIT_3DFX = $20000000;
2332
2333 // GL_3DFX_texture_compression_FXT1
2334 GL_COMPRESSED_RGB_FXT1_3DFX = $86B0;
2335 GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1;
2336
2337 // GL_APPLE_client_storage
2338 GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2;
2339
2340 // GL_APPLE_element_array
2341 GL_ELEMENT_ARRAY_APPLE = $8768;
2342 GL_ELEMENT_ARRAY_TYPE_APPLE = $8769;
2343 GL_ELEMENT_ARRAY_POINTER_APPLE = $876A;
2344
2345 // GL_APPLE_fence
2346 GL_DRAW_PIXELS_APPLE = $8A0A;
2347 GL_FENCE_APPLE = $8A0B;
2348
2349 // GL_APPLE_specular_vector
2350 GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0;
2351
2352 // GL_APPLE_transform_hint
2353 GL_TRANSFORM_HINT_APPLE = $85B1;
2354
2355 // GL_APPLE_vertex_array_object
2356 GL_VERTEX_ARRAY_BINDING_APPLE = $85B5;
2357
2358 // GL_APPLE_vertex_array_range
2359 GL_VERTEX_ARRAY_RANGE_APPLE = $851D;
2360 GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E;
2361 GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F;
2362 GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521;
2363 GL_STORAGE_CACHED_APPLE = $85BE;
2364 GL_STORAGE_SHARED_APPLE = $85BF;
2365
2366 // GL_APPLE_ycbcr_422
2367 GL_YCBCR_422_APPLE = $85B9;
2368 GL_UNSIGNED_SHORT_8_8_APPLE = $85BA;
2369 GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB;
2370
2371 // GL_APPLE_texture_range
2372 GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7;
2373 GL_TEXTURE_RANGE_POINTER_APPLE = $85B8;
2374 GL_TEXTURE_STORAGE_HINT_APPLE = $85BC;
2375 GL_STORAGE_PRIVATE_APPLE = $85BD;
2376 { reuse GL_STORAGE_CACHED_APPLE }
2377 { reuse GL_STORAGE_SHARED_APPLE }
2378
2379 // GL_APPLE_float_pixels
2380 GL_HALF_APPLE = $140B;
2381 GL_RGBA_FLOAT32_APPLE = $8814;
2382 GL_RGB_FLOAT32_APPLE = $8815;
2383 GL_ALPHA_FLOAT32_APPLE = $8816;
2384 GL_INTENSITY_FLOAT32_APPLE = $8817;
2385 GL_LUMINANCE_FLOAT32_APPLE = $8818;
2386 GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819;
2387 GL_RGBA_FLOAT16_APPLE = $881A;
2388 GL_RGB_FLOAT16_APPLE = $881B;
2389 GL_ALPHA_FLOAT16_APPLE = $881C;
2390 GL_INTENSITY_FLOAT16_APPLE = $881D;
2391 GL_LUMINANCE_FLOAT16_APPLE = $881E;
2392 GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F;
2393 GL_COLOR_FLOAT_APPLE = $8A0F;
2394
2395 // GL_APPLE_vertex_program_evaluators
2396 GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00;
2397 GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01;
2398 GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02;
2399 GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03;
2400 GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04;
2401 GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05;
2402 GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06;
2403 GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07;
2404 GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08;
2405 GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09;
2406
2407 // GL_APPLE_aux_depth_stencil
2408 GL_AUX_DEPTH_STENCIL_APPLE = $8A14;
2409
2410 // GL_APPLE_object_purgeable
2411 GL_BUFFER_OBJECT_APPLE = $85B3;
2412 GL_RELEASED_APPLE = $8A19;
2413 GL_VOLATILE_APPLE = $8A1A;
2414 GL_RETAINED_APPLE = $8A1B;
2415 GL_UNDEFINED_APPLE = $8A1C;
2416 GL_PURGEABLE_APPLE = $8A1D;
2417
2418 // GL_APPLE_row_bytes
2419 GL_PACK_ROW_BYTES_APPLE = $8A15;
2420 GL_UNPACK_ROW_BYTES_APPLE = $8A16;
2421
2422
2423 // GL_ARB_depth_texture
2424 GL_DEPTH_COMPONENT16_ARB = $81A5;
2425 GL_DEPTH_COMPONENT24_ARB = $81A6;
2426 GL_DEPTH_COMPONENT32_ARB = $81A7;
2427 GL_TEXTURE_DEPTH_SIZE_ARB = $884A;
2428 GL_DEPTH_TEXTURE_MODE_ARB = $884B;
2429
2430 // GL_ARB_fragment_program
2431 GL_FRAGMENT_PROGRAM_ARB = $8804;
2432 GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805;
2433 GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806;
2434 GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807;
2435 GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808;
2436 GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809;
2437 GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A;
2438 GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B;
2439 GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C;
2440 GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D;
2441 GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E;
2442 GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F;
2443 GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810;
2444 GL_MAX_TEXTURE_COORDS_ARB = $8871;
2445 GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872;
2446
2447 // GL_ARB_imaging
2448 GL_CONSTANT_COLOR_ARB = $8001;
2449 GL_ONE_MINUS_CONSTANT_COLOR = $8002;
2450 GL_CONSTANT_ALPHA = $8003;
2451 GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
2452 GL_BLEND_COLOR = $8005;
2453 GL_FUNC_ADD = $8006;
2454 GL_MIN = $8007;
2455 GL_MAX = $8008;
2456 GL_BLEND_EQUATION = $8009;
2457 GL_FUNC_SUBTRACT = $800A;
2458 GL_FUNC_REVERSE_SUBTRACT = $800B;
2459 {$ifdef DGL_DEPRECATED}
2460 GL_CONVOLUTION_1D = $8010;
2461 GL_CONVOLUTION_2D = $8011;
2462 GL_SEPARABLE_2D = $8012;
2463 GL_CONVOLUTION_BORDER_MODE = $8013;
2464 GL_CONVOLUTION_FILTER_SCALE = $8014;
2465 GL_CONVOLUTION_FILTER_BIAS = $8015;
2466 GL_REDUCE = $8016;
2467 GL_CONVOLUTION_FORMAT = $8017;
2468 GL_CONVOLUTION_WIDTH = $8018;
2469 GL_CONVOLUTION_HEIGHT = $8019;
2470 GL_MAX_CONVOLUTION_WIDTH = $801A;
2471 GL_MAX_CONVOLUTION_HEIGHT = $801B;
2472 GL_POST_CONVOLUTION_RED_SCALE = $801C;
2473 GL_POST_CONVOLUTION_GREEN_SCALE = $801D;
2474 GL_POST_CONVOLUTION_BLUE_SCALE = $801E;
2475 GL_POST_CONVOLUTION_ALPHA_SCALE = $801F;
2476 GL_POST_CONVOLUTION_RED_BIAS = $8020;
2477 GL_POST_CONVOLUTION_GREEN_BIAS = $8021;
2478 GL_POST_CONVOLUTION_BLUE_BIAS = $8022;
2479 GL_POST_CONVOLUTION_ALPHA_BIAS = $8023;
2480 GL_HISTOGRAM = $8024;
2481 GL_PROXY_HISTOGRAM = $8025;
2482 GL_HISTOGRAM_WIDTH = $8026;
2483 GL_HISTOGRAM_FORMAT = $8027;
2484 GL_HISTOGRAM_RED_SIZE = $8028;
2485 GL_HISTOGRAM_GREEN_SIZE = $8029;
2486 GL_HISTOGRAM_BLUE_SIZE = $802A;
2487 GL_HISTOGRAM_ALPHA_SIZE = $802B;
2488 GL_HISTOGRAM_LUMINANCE_SIZE = $802C;
2489 GL_HISTOGRAM_SINK = $802D;
2490 GL_MINMAX = $802E;
2491 GL_MINMAX_FORMAT = $802F;
2492 GL_MINMAX_SINK = $8030;
2493 GL_TABLE_TOO_LARGE = $8031;
2494 GL_COLOR_MATRIX = $80B1;
2495 GL_COLOR_MATRIX_STACK_DEPTH = $80B2;
2496 GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3;
2497 GL_POST_COLOR_MATRIX_RED_SCALE = $80B4;
2498 GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5;
2499 GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6;
2500 GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7;
2501 GL_POST_COLOR_MATRIX_RED_BIAS = $80B8;
2502 GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9;
2503 GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA;
2504 GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB;
2505 GL_COLOR_TABLE = $80D0;
2506 GL_POST_CONVOLUTION_COLOR_TABLE = $80D1;
2507 GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2;
2508 GL_PROXY_COLOR_TABLE = $80D3;
2509 GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4;
2510 GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5;
2511 GL_COLOR_TABLE_SCALE = $80D6;
2512 GL_COLOR_TABLE_BIAS = $80D7;
2513 GL_COLOR_TABLE_FORMAT = $80D8;
2514 GL_COLOR_TABLE_WIDTH = $80D9;
2515 GL_COLOR_TABLE_RED_SIZE = $80DA;
2516 GL_COLOR_TABLE_GREEN_SIZE = $80DB;
2517 GL_COLOR_TABLE_BLUE_SIZE = $80DC;
2518 GL_COLOR_TABLE_ALPHA_SIZE = $80DD;
2519 GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE;
2520 GL_COLOR_TABLE_INTENSITY_SIZE = $80DF;
2521 GL_CONSTANT_BORDER = $8151;
2522 GL_REPLICATE_BORDER = $8153;
2523 GL_CONVOLUTION_BORDER_COLOR = $8154;
2524 {$endif}
2525
2526 // GL_ARB_matrix_palette
2527 GL_MATRIX_PALETTE_ARB = $8840;
2528 GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841;
2529 GL_MAX_PALETTE_MATRICES_ARB = $8842;
2530 GL_CURRENT_PALETTE_MATRIX_ARB = $8843;
2531 GL_MATRIX_INDEX_ARRAY_ARB = $8844;
2532 GL_CURRENT_MATRIX_INDEX_ARB = $8845;
2533 GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846;
2534 GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847;
2535 GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848;
2536 GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849;
2537
2538 // GL_ARB_multisample
2539 GL_MULTISAMPLE_ARB = $809D;
2540 GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E;
2541 GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F;
2542 GL_SAMPLE_COVERAGE_ARB = $80A0;
2543 GL_SAMPLE_BUFFERS_ARB = $80A8;
2544 GL_SAMPLES_ARB = $80A9;
2545 GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA;
2546 GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB;
2547 GL_MULTISAMPLE_BIT_ARB = $20000000;
2548
2549 // GL_ARB_multitexture
2550 GL_TEXTURE0_ARB = $84C0;
2551 GL_TEXTURE1_ARB = $84C1;
2552 GL_TEXTURE2_ARB = $84C2;
2553 GL_TEXTURE3_ARB = $84C3;
2554 GL_TEXTURE4_ARB = $84C4;
2555 GL_TEXTURE5_ARB = $84C5;
2556 GL_TEXTURE6_ARB = $84C6;
2557 GL_TEXTURE7_ARB = $84C7;
2558 GL_TEXTURE8_ARB = $84C8;
2559 GL_TEXTURE9_ARB = $84C9;
2560 GL_TEXTURE10_ARB = $84CA;
2561 GL_TEXTURE11_ARB = $84CB;
2562 GL_TEXTURE12_ARB = $84CC;
2563 GL_TEXTURE13_ARB = $84CD;
2564 GL_TEXTURE14_ARB = $84CE;
2565 GL_TEXTURE15_ARB = $84CF;
2566 GL_TEXTURE16_ARB = $84D0;
2567 GL_TEXTURE17_ARB = $84D1;
2568 GL_TEXTURE18_ARB = $84D2;
2569 GL_TEXTURE19_ARB = $84D3;
2570 GL_TEXTURE20_ARB = $84D4;
2571 GL_TEXTURE21_ARB = $84D5;
2572 GL_TEXTURE22_ARB = $84D6;
2573 GL_TEXTURE23_ARB = $84D7;
2574 GL_TEXTURE24_ARB = $84D8;
2575 GL_TEXTURE25_ARB = $84D9;
2576 GL_TEXTURE26_ARB = $84DA;
2577 GL_TEXTURE27_ARB = $84DB;
2578 GL_TEXTURE28_ARB = $84DC;
2579 GL_TEXTURE29_ARB = $84DD;
2580 GL_TEXTURE30_ARB = $84DE;
2581 GL_TEXTURE31_ARB = $84DF;
2582 GL_ACTIVE_TEXTURE_ARB = $84E0;
2583 GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1;
2584 GL_MAX_TEXTURE_UNITS_ARB = $84E2;
2585
2586 // GL_ARB_point_parameters
2587 GL_POINT_SIZE_MIN_ARB = $8126;
2588 GL_POINT_SIZE_MAX_ARB = $8127;
2589 GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128;
2590 GL_POINT_DISTANCE_ATTENUATION_ARB = $8129;
2591
2592 // GL_ARB_shadow
2593 GL_TEXTURE_COMPARE_MODE_ARB = $884C;
2594 GL_TEXTURE_COMPARE_FUNC_ARB = $884D;
2595 GL_COMPARE_R_TO_TEXTURE_ARB = $884E;
2596
2597 // GL_ARB_shadow_ambient
2598 GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF;
2599
2600 // GL_ARB_texture_border_clamp
2601 GL_CLAMP_TO_BORDER_ARB = $812D;
2602
2603 // GL_ARB_texture_compression
2604 GL_COMPRESSED_ALPHA_ARB = $84E9;
2605 GL_COMPRESSED_LUMINANCE_ARB = $84EA;
2606 GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB;
2607 GL_COMPRESSED_INTENSITY_ARB = $84EC;
2608 GL_COMPRESSED_RGB_ARB = $84ED;
2609 GL_COMPRESSED_RGBA_ARB = $84EE;
2610 GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF;
2611 GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0;
2612 GL_TEXTURE_COMPRESSED_ARB = $86A1;
2613 GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2;
2614 GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3;
2615
2616 // GL_ARB_texture_cube_map
2617 GL_NORMAL_MAP_ARB = $8511;
2618 GL_REFLECTION_MAP_ARB = $8512;
2619 GL_TEXTURE_CUBE_MAP_ARB = $8513;
2620 GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514;
2621 GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515;
2622 GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516;
2623 GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517;
2624 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518;
2625 GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519;
2626 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A;
2627 GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B;
2628 GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C;
2629
2630 // GL_ARB_texture_env_combine
2631 GL_COMBINE_ARB = $8570;
2632 GL_COMBINE_RGB_ARB = $8571;
2633 GL_COMBINE_ALPHA_ARB = $8572;
2634 GL_SOURCE0_RGB_ARB = $8580;
2635 GL_SOURCE1_RGB_ARB = $8581;
2636 GL_SOURCE2_RGB_ARB = $8582;
2637 GL_SOURCE0_ALPHA_ARB = $8588;
2638 GL_SOURCE1_ALPHA_ARB = $8589;
2639 GL_SOURCE2_ALPHA_ARB = $858A;
2640 GL_OPERAND0_RGB_ARB = $8590;
2641 GL_OPERAND1_RGB_ARB = $8591;
2642 GL_OPERAND2_RGB_ARB = $8592;
2643 GL_OPERAND0_ALPHA_ARB = $8598;
2644 GL_OPERAND1_ALPHA_ARB = $8599;
2645 GL_OPERAND2_ALPHA_ARB = $859A;
2646 GL_RGB_SCALE_ARB = $8573;
2647 GL_ADD_SIGNED_ARB = $8574;
2648 GL_INTERPOLATE_ARB = $8575;
2649 GL_SUBTRACT_ARB = $84E7;
2650 GL_CONSTANT_ARB = $8576;
2651 GL_PRIMARY_COLOR_ARB = $8577;
2652 GL_PREVIOUS_ARB = $8578;
2653
2654 // GL_ARB_texture_env_dot3
2655 GL_DOT3_RGB_ARB = $86AE;
2656 GL_DOT3_RGBA_ARB = $86AF;
2657
2658 // GL_ARB_texture_mirrored_repeat
2659 GL_MIRRORED_REPEAT_ARB = $8370;
2660
2661 // GL_ARB_transpose_matrix
2662 GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3;
2663 GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4;
2664 GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5;
2665 GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6;
2666
2667 // GL_ARB_vertex_blend
2668 GL_MAX_VERTEX_UNITS_ARB = $86A4;
2669 GL_ACTIVE_VERTEX_UNITS_ARB = $86A5;
2670 GL_WEIGHT_SUM_UNITY_ARB = $86A6;
2671 GL_VERTEX_BLEND_ARB = $86A7;
2672 GL_CURRENT_WEIGHT_ARB = $86A8;
2673 GL_WEIGHT_ARRAY_TYPE_ARB = $86A9;
2674 GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA;
2675 GL_WEIGHT_ARRAY_SIZE_ARB = $86AB;
2676 GL_WEIGHT_ARRAY_POINTER_ARB = $86AC;
2677 GL_WEIGHT_ARRAY_ARB = $86AD;
2678 GL_MODELVIEW0_ARB = $1700;
2679 GL_MODELVIEW1_ARB = $850A;
2680 GL_MODELVIEW2_ARB = $8722;
2681 GL_MODELVIEW3_ARB = $8723;
2682 GL_MODELVIEW4_ARB = $8724;
2683 GL_MODELVIEW5_ARB = $8725;
2684 GL_MODELVIEW6_ARB = $8726;
2685 GL_MODELVIEW7_ARB = $8727;
2686 GL_MODELVIEW8_ARB = $8728;
2687 GL_MODELVIEW9_ARB = $8729;
2688 GL_MODELVIEW10_ARB = $872A;
2689 GL_MODELVIEW11_ARB = $872B;
2690 GL_MODELVIEW12_ARB = $872C;
2691 GL_MODELVIEW13_ARB = $872D;
2692 GL_MODELVIEW14_ARB = $872E;
2693 GL_MODELVIEW15_ARB = $872F;
2694 GL_MODELVIEW16_ARB = $8730;
2695 GL_MODELVIEW17_ARB = $8731;
2696 GL_MODELVIEW18_ARB = $8732;
2697 GL_MODELVIEW19_ARB = $8733;
2698 GL_MODELVIEW20_ARB = $8734;
2699 GL_MODELVIEW21_ARB = $8735;
2700 GL_MODELVIEW22_ARB = $8736;
2701 GL_MODELVIEW23_ARB = $8737;
2702 GL_MODELVIEW24_ARB = $8738;
2703 GL_MODELVIEW25_ARB = $8739;
2704 GL_MODELVIEW26_ARB = $873A;
2705 GL_MODELVIEW27_ARB = $873B;
2706 GL_MODELVIEW28_ARB = $873C;
2707 GL_MODELVIEW29_ARB = $873D;
2708 GL_MODELVIEW30_ARB = $873E;
2709 GL_MODELVIEW31_ARB = $873F;
2710
2711 // GL_ARB_vertex_buffer_object
2712 GL_BUFFER_SIZE_ARB = $8764;
2713 GL_BUFFER_USAGE_ARB = $8765;
2714 GL_ARRAY_BUFFER_ARB = $8892;
2715 GL_ELEMENT_ARRAY_BUFFER_ARB = $8893;
2716 GL_ARRAY_BUFFER_BINDING_ARB = $8894;
2717 GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895;
2718 GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896;
2719 GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897;
2720 GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898;
2721 GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899;
2722 GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A;
2723 GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B;
2724 GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C;
2725 GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D;
2726 GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E;
2727 GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F;
2728 GL_READ_ONLY_ARB = $88B8;
2729 GL_WRITE_ONLY_ARB = $88B9;
2730 GL_READ_WRITE_ARB = $88BA;
2731 GL_BUFFER_ACCESS_ARB = $88BB;
2732 GL_BUFFER_MAPPED_ARB = $88BC;
2733 GL_BUFFER_MAP_POINTER_ARB = $88BD;
2734 GL_STREAM_DRAW_ARB = $88E0;
2735 GL_STREAM_READ_ARB = $88E1;
2736 GL_STREAM_COPY_ARB = $88E2;
2737 GL_STATIC_DRAW_ARB = $88E4;
2738 GL_STATIC_READ_ARB = $88E5;
2739 GL_STATIC_COPY_ARB = $88E6;
2740 GL_DYNAMIC_DRAW_ARB = $88E8;
2741 GL_DYNAMIC_READ_ARB = $88E9;
2742 GL_DYNAMIC_COPY_ARB = $88EA;
2743
2744 // GL_ARB_vertex_program
2745 GL_COLOR_SUM_ARB = $8458;
2746 GL_VERTEX_PROGRAM_ARB = $8620;
2747 GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622;
2748 GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623;
2749 GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624;
2750 GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625;
2751 GL_CURRENT_VERTEX_ATTRIB_ARB = $8626;
2752 GL_PROGRAM_LENGTH_ARB = $8627;
2753 GL_PROGRAM_STRING_ARB = $8628;
2754 GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E;
2755 GL_MAX_PROGRAM_MATRICES_ARB = $862F;
2756 GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640;
2757 GL_CURRENT_MATRIX_ARB = $8641;
2758 GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642;
2759 GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643;
2760 GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645;
2761 GL_PROGRAM_ERROR_POSITION_ARB = $864B;
2762 GL_PROGRAM_BINDING_ARB = $8677;
2763 GL_MAX_VERTEX_ATTRIBS_ARB = $8869;
2764 GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A;
2765 GL_PROGRAM_ERROR_STRING_ARB = $8874;
2766 GL_PROGRAM_FORMAT_ASCII_ARB = $8875;
2767 GL_PROGRAM_FORMAT_ARB = $8876;
2768 GL_PROGRAM_INSTRUCTIONS_ARB = $88A0;
2769 GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1;
2770 GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2;
2771 GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3;
2772 GL_PROGRAM_TEMPORARIES_ARB = $88A4;
2773 GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5;
2774 GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6;
2775 GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7;
2776 GL_PROGRAM_PARAMETERS_ARB = $88A8;
2777 GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9;
2778 GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA;
2779 GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB;
2780 GL_PROGRAM_ATTRIBS_ARB = $88AC;
2781 GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD;
2782 GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE;
2783 GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF;
2784 GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0;
2785 GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1;
2786 GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2;
2787 GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3;
2788 GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4;
2789 GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5;
2790 GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6;
2791 GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7;
2792 GL_MATRIX0_ARB = $88C0;
2793 GL_MATRIX1_ARB = $88C1;
2794 GL_MATRIX2_ARB = $88C2;
2795 GL_MATRIX3_ARB = $88C3;
2796 GL_MATRIX4_ARB = $88C4;
2797 GL_MATRIX5_ARB = $88C5;
2798 GL_MATRIX6_ARB = $88C6;
2799 GL_MATRIX7_ARB = $88C7;
2800 GL_MATRIX8_ARB = $88C8;
2801 GL_MATRIX9_ARB = $88C9;
2802 GL_MATRIX10_ARB = $88CA;
2803 GL_MATRIX11_ARB = $88CB;
2804 GL_MATRIX12_ARB = $88CC;
2805 GL_MATRIX13_ARB = $88CD;
2806 GL_MATRIX14_ARB = $88CE;
2807 GL_MATRIX15_ARB = $88CF;
2808 GL_MATRIX16_ARB = $88D0;
2809 GL_MATRIX17_ARB = $88D1;
2810 GL_MATRIX18_ARB = $88D2;
2811 GL_MATRIX19_ARB = $88D3;
2812 GL_MATRIX20_ARB = $88D4;
2813 GL_MATRIX21_ARB = $88D5;
2814 GL_MATRIX22_ARB = $88D6;
2815 GL_MATRIX23_ARB = $88D7;
2816 GL_MATRIX24_ARB = $88D8;
2817 GL_MATRIX25_ARB = $88D9;
2818 GL_MATRIX26_ARB = $88DA;
2819 GL_MATRIX27_ARB = $88DB;
2820 GL_MATRIX28_ARB = $88DC;
2821 GL_MATRIX29_ARB = $88DD;
2822 GL_MATRIX30_ARB = $88DE;
2823 GL_MATRIX31_ARB = $88DF;
2824
2825 // GL_ARB_draw_buffers
2826 GL_MAX_DRAW_BUFFERS_ARB = $8824;
2827 GL_DRAW_BUFFER0_ARB = $8825;
2828 GL_DRAW_BUFFER1_ARB = $8826;
2829 GL_DRAW_BUFFER2_ARB = $8827;
2830 GL_DRAW_BUFFER3_ARB = $8828;
2831 GL_DRAW_BUFFER4_ARB = $8829;
2832 GL_DRAW_BUFFER5_ARB = $882A;
2833 GL_DRAW_BUFFER6_ARB = $882B;
2834 GL_DRAW_BUFFER7_ARB = $882C;
2835 GL_DRAW_BUFFER8_ARB = $882D;
2836 GL_DRAW_BUFFER9_ARB = $882E;
2837 GL_DRAW_BUFFER10_ARB = $882F;
2838 GL_DRAW_BUFFER11_ARB = $8830;
2839 GL_DRAW_BUFFER12_ARB = $8831;
2840 GL_DRAW_BUFFER13_ARB = $8832;
2841 GL_DRAW_BUFFER14_ARB = $8833;
2842 GL_DRAW_BUFFER15_ARB = $8834;
2843
2844 // GL_ARB_texture_rectangle
2845 GL_TEXTURE_RECTANGLE_ARB = $84F5;
2846 GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6;
2847 GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7;
2848 GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8;
2849
2850 // GL_ARB_color_buffer_float
2851 GL_RGBA_FLOAT_MODE_ARB = $8820;
2852 GL_CLAMP_VERTEX_COLOR_ARB = $891A;
2853 GL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
2854 GL_CLAMP_READ_COLOR_ARB = $891C;
2855 GL_FIXED_ONLY_ARB = $891D;
2856 WGL_TYPE_RGBA_FLOAT_ARB = $21A0;
2857 GLX_RGBA_FLOAT_TYPE = $20B9;
2858 GLX_RGBA_FLOAT_BIT = $00000004;
2859
2860 // GL_ARB_half_float_pixel
2861 GL_HALF_FLOAT_ARB = $140B;
2862
2863 // GL_ARB_texture_float
2864 GL_TEXTURE_RED_TYPE_ARB = $8C10;
2865 GL_TEXTURE_GREEN_TYPE_ARB = $8C11;
2866 GL_TEXTURE_BLUE_TYPE_ARB = $8C12;
2867 GL_TEXTURE_ALPHA_TYPE_ARB = $8C13;
2868 GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14;
2869 GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15;
2870 GL_TEXTURE_DEPTH_TYPE_ARB = $8C16;
2871 GL_UNSIGNED_NORMALIZED_ARB = $8C17;
2872 GL_RGBA32F_ARB = $8814;
2873 GL_RGB32F_ARB = $8815;
2874 GL_ALPHA32F_ARB = $8816;
2875 GL_INTENSITY32F_ARB = $8817;
2876 GL_LUMINANCE32F_ARB = $8818;
2877 GL_LUMINANCE_ALPHA32F_ARB = $8819;
2878 GL_RGBA16F_ARB = $881A;
2879 GL_RGB16F_ARB = $881B;
2880 GL_ALPHA16F_ARB = $881C;
2881 GL_INTENSITY16F_ARB = $881D;
2882 GL_LUMINANCE16F_ARB = $881E;
2883 GL_LUMINANCE_ALPHA16F_ARB = $881F;
2884
2885 // GL_ARB_pixel_buffer_object
2886 GL_PIXEL_PACK_BUFFER_ARB = $88EB;
2887 GL_PIXEL_UNPACK_BUFFER_ARB = $88EC;
2888 GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED;
2889 GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF;
2890
2891 // GL_ARB_depth_buffer_float
2892 GL_DEPTH_COMPONENT32F = $8CAC;
2893 GL_DEPTH32F_STENCIL8 = $8CAD;
2894 GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD;
2895
2896 // GL_ARB_framebuffer_object
2897 GL_INVALID_FRAMEBUFFER_OPERATION = $0506;
2898 GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210;
2899 GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211;
2900 GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212;
2901 GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213;
2902 GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214;
2903 GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215;
2904 GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216;
2905 GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217;
2906 GL_FRAMEBUFFER_DEFAULT = $8218;
2907 GL_FRAMEBUFFER_UNDEFINED = $8219;
2908 GL_DEPTH_STENCIL_ATTACHMENT = $821A;
2909 GL_MAX_RENDERBUFFER_SIZE = $84E8;
2910 GL_DEPTH_STENCIL = $84F9;
2911 GL_UNSIGNED_INT_24_8 = $84FA;
2912 GL_DEPTH24_STENCIL8 = $88F0;
2913 GL_TEXTURE_STENCIL_SIZE = $88F1;
2914 GL_TEXTURE_RED_TYPE = $8C10;
2915 GL_TEXTURE_GREEN_TYPE = $8C11;
2916 GL_TEXTURE_BLUE_TYPE = $8C12;
2917 GL_TEXTURE_ALPHA_TYPE = $8C13;
2918 GL_TEXTURE_DEPTH_TYPE = $8C16;
2919 GL_UNSIGNED_NORMALIZED = $8C17;
2920 GL_FRAMEBUFFER_BINDING = $8CA6;
2921 GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING;
2922 GL_RENDERBUFFER_BINDING = $8CA7;
2923 GL_READ_FRAMEBUFFER = $8CA8;
2924 GL_DRAW_FRAMEBUFFER = $8CA9;
2925 GL_READ_FRAMEBUFFER_BINDING = $8CAA;
2926 GL_RENDERBUFFER_SAMPLES = $8CAB;
2927 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0;
2928 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1;
2929 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2;
2930 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3;
2931 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4;
2932 GL_FRAMEBUFFER_COMPLETE = $8CD5;
2933 GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6;
2934 GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7;
2935 GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB;
2936 GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC;
2937 GL_FRAMEBUFFER_UNSUPPORTED = $8CDD;
2938 GL_MAX_COLOR_ATTACHMENTS = $8CDF;
2939 GL_COLOR_ATTACHMENT0 = $8CE0;
2940 GL_COLOR_ATTACHMENT1 = $8CE1;
2941 GL_COLOR_ATTACHMENT2 = $8CE2;
2942 GL_COLOR_ATTACHMENT3 = $8CE3;
2943 GL_COLOR_ATTACHMENT4 = $8CE4;
2944 GL_COLOR_ATTACHMENT5 = $8CE5;
2945 GL_COLOR_ATTACHMENT6 = $8CE6;
2946 GL_COLOR_ATTACHMENT7 = $8CE7;
2947 GL_COLOR_ATTACHMENT8 = $8CE8;
2948 GL_COLOR_ATTACHMENT9 = $8CE9;
2949 GL_COLOR_ATTACHMENT10 = $8CEA;
2950 GL_COLOR_ATTACHMENT11 = $8CEB;
2951 GL_COLOR_ATTACHMENT12 = $8CEC;
2952 GL_COLOR_ATTACHMENT13 = $8CED;
2953 GL_COLOR_ATTACHMENT14 = $8CEE;
2954 GL_COLOR_ATTACHMENT15 = $8CEF;
2955 GL_DEPTH_ATTACHMENT = $8D00;
2956 GL_STENCIL_ATTACHMENT = $8D20;
2957 GL_FRAMEBUFFER = $8D40;
2958 GL_RENDERBUFFER = $8D41;
2959 GL_RENDERBUFFER_WIDTH = $8D42;
2960 GL_RENDERBUFFER_HEIGHT = $8D43;
2961 GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44;
2962 GL_STENCIL_INDEX1 = $8D46;
2963 GL_STENCIL_INDEX4 = $8D47;
2964 GL_STENCIL_INDEX8 = $8D48;
2965 GL_STENCIL_INDEX16 = $8D49;
2966 GL_RENDERBUFFER_RED_SIZE = $8D50;
2967 GL_RENDERBUFFER_GREEN_SIZE = $8D51;
2968 GL_RENDERBUFFER_BLUE_SIZE = $8D52;
2969 GL_RENDERBUFFER_ALPHA_SIZE = $8D53;
2970 GL_RENDERBUFFER_DEPTH_SIZE = $8D54;
2971 GL_RENDERBUFFER_STENCIL_SIZE = $8D55;
2972 GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56;
2973 GL_MAX_SAMPLES = $8D57;
2974 {$ifdef DGL_DEPRECATED}
2975 GL_INDEX = $8222;
2976 GL_TEXTURE_LUMINANCE_TYPE = $8C14;
2977 GL_TEXTURE_INTENSITY_TYPE = $8C15;
2978 {$endif}
2979
2980 // GL_ARB_framebuffer_sRGB
2981 GL_FRAMEBUFFER_SRGB = $8DB9;
2982
2983 // GL_ARB_geometry_shader4
2984 GL_LINES_ADJACENCY_ARB = $000A;
2985 GL_LINE_STRIP_ADJACENCY_ARB = $000B;
2986 GL_TRIANGLES_ADJACENCY_ARB = $000C;
2987 GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D;
2988 GL_PROGRAM_POINT_SIZE_ARB = $8642;
2989 GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29;
2990 GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7;
2991 GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8;
2992 GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9;
2993 GL_GEOMETRY_SHADER_ARB = $8DD9;
2994 GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA;
2995 GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB;
2996 GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC;
2997 GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD;
2998 GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE;
2999 GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF;
3000 GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0;
3001 GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1;
3002 { reuse GL_MAX_VARYING_COMPONENTS }
3003 { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
3004
3005 // GL_ARB_half_float_vertex
3006 GL_HALF_FLOAT = $140B;
3007
3008 // GL_ARB_instanced_arrays
3009 GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE;
3010
3011 // GL_ARB_map_buffer_range
3012 GL_MAP_READ_BIT = $0001;
3013 GL_MAP_WRITE_BIT = $0002;
3014 GL_MAP_INVALIDATE_RANGE_BIT = $0004;
3015 GL_MAP_INVALIDATE_BUFFER_BIT = $0008;
3016 GL_MAP_FLUSH_EXPLICIT_BIT = $0010;
3017 GL_MAP_UNSYNCHRONIZED_BIT = $0020;
3018
3019 // GL_ARB_texture_buffer_object
3020 GL_TEXTURE_BUFFER_ARB = $8C2A;
3021 GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B;
3022 GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C;
3023 GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D;
3024 GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E;
3025
3026 // GL_ARB_texture_compression_rgtc
3027 GL_COMPRESSED_RED_RGTC1 = $8DBB;
3028 GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC;
3029 GL_COMPRESSED_RG_RGTC2 = $8DBD;
3030 GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE;
3031
3032 // GL_ARB_texture_rg
3033 GL_RG = $8227;
3034 GL_RG_INTEGER = $8228;
3035 GL_R8 = $8229;
3036 GL_R16 = $822A;
3037 GL_RG8 = $822B;
3038 GL_RG16 = $822C;
3039 GL_R16F = $822D;
3040 GL_R32F = $822E;
3041 GL_RG16F = $822F;
3042 GL_RG32F = $8230;
3043 GL_R8I = $8231;
3044 GL_R8UI = $8232;
3045 GL_R16I = $8233;
3046 GL_R16UI = $8234;
3047 GL_R32I = $8235;
3048 GL_R32UI = $8236;
3049 GL_RG8I = $8237;
3050 GL_RG8UI = $8238;
3051 GL_RG16I = $8239;
3052 GL_RG16UI = $823A;
3053 GL_RG32I = $823B;
3054 GL_RG32UI = $823C;
3055
3056 // GL_ARB_vertex_array_object
3057 GL_VERTEX_ARRAY_BINDING = $85B5;
3058
3059 // GL_ARB_uniform_buffer_object
3060 GL_UNIFORM_BUFFER = $8A11;
3061 GL_UNIFORM_BUFFER_BINDING = $8A28;
3062 GL_UNIFORM_BUFFER_START = $8A29;
3063 GL_UNIFORM_BUFFER_SIZE = $8A2A;
3064 GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B;
3065 GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C;
3066 GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D;
3067 GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E;
3068 GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F;
3069 GL_MAX_UNIFORM_BLOCK_SIZE = $8A30;
3070 GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31;
3071 GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32;
3072 GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33;
3073 GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34;
3074 GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35;
3075 GL_ACTIVE_UNIFORM_BLOCKS = $8A36;
3076 GL_UNIFORM_TYPE = $8A37;
3077 GL_UNIFORM_SIZE = $8A38;
3078 GL_UNIFORM_NAME_LENGTH = $8A39;
3079 GL_UNIFORM_BLOCK_INDEX = $8A3A;
3080 GL_UNIFORM_OFFSET = $8A3B;
3081 GL_UNIFORM_ARRAY_STRIDE = $8A3C;
3082 GL_UNIFORM_MATRIX_STRIDE = $8A3D;
3083 GL_UNIFORM_IS_ROW_MAJOR = $8A3E;
3084 GL_UNIFORM_BLOCK_BINDING = $8A3F;
3085 GL_UNIFORM_BLOCK_DATA_SIZE = $8A40;
3086 GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41;
3087 GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42;
3088 GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43;
3089 GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44;
3090 GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = $8A45;
3091 GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46;
3092 GL_INVALID_INDEX = $FFFFFFFF;
3093
3094 // GL_ARB_compatibility
3095 { ARB_compatibility just defines tokens from core 3.0 }
3096
3097 // GL_ARB_copy_buffer
3098 GL_COPY_READ_BUFFER = $8F36;
3099 GL_COPY_WRITE_BUFFER = $8F37;
3100
3101 // GL_ARB_depth_clamp
3102 GL_DEPTH_CLAMP = $864F;
3103
3104 // GL_ARB_provoking_vertex
3105 GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C;
3106 GL_FIRST_VERTEX_CONVENTION = $8E4D;
3107 GL_LAST_VERTEX_CONVENTION = $8E4E;
3108 GL_PROVOKING_VERTEX = $8E4F;
3109
3110 // GL_ARB_seamless_cube_map
3111 GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F;
3112
3113 // GL_ARB_sync
3114 GL_MAX_SERVER_WAIT_TIMEOUT = $9111;
3115 GL_OBJECT_TYPE = $9112;
3116 GL_SYNC_CONDITION = $9113;
3117 GL_SYNC_STATUS = $9114;
3118 GL_SYNC_FLAGS = $9115;
3119 GL_SYNC_FENCE = $9116;
3120 GL_SYNC_GPU_COMMANDS_COMPLETE = $9117;
3121 GL_UNSIGNALED = $9118;
3122 GL_SIGNALED = $9119;
3123 GL_ALREADY_SIGNALED = $911A;
3124 GL_TIMEOUT_EXPIRED = $911B;
3125 GL_CONDITION_SATISFIED = $911C;
3126 GL_WAIT_FAILED = $911D;
3127 GL_SYNC_FLUSH_COMMANDS_BIT = $00000001;
3128 GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF;
3129
3130 // GL_ARB_texture_multisample
3131 GL_SAMPLE_POSITION = $8E50;
3132 GL_SAMPLE_MASK = $8E51;
3133 GL_SAMPLE_MASK_VALUE = $8E52;
3134 GL_MAX_SAMPLE_MASK_WORDS = $8E59;
3135 GL_TEXTURE_2D_MULTISAMPLE = $9100;
3136 GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101;
3137 GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102;
3138 GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103;
3139 GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104;
3140 GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105;
3141 GL_TEXTURE_SAMPLES = $9106;
3142 GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107;
3143 GL_SAMPLER_2D_MULTISAMPLE = $9108;
3144 GL_INT_SAMPLER_2D_MULTISAMPLE = $9109;
3145 GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A;
3146 GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B;
3147 GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C;
3148 GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D;
3149 GL_MAX_COLOR_TEXTURE_SAMPLES = $910E;
3150 GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F;
3151 GL_MAX_INTEGER_SAMPLES = $9110;
3152
3153 // GL_ARB_vertex_array_bgra
3154 { reuse GL_BGRA }
3155
3156 // GL_ARB_sample_shading
3157 GL_SAMPLE_SHADING = $8C36;
3158 GL_MIN_SAMPLE_SHADING_VALUE = $8C37;
3159
3160 // GL_ARB_texture_cube_map_array
3161 GL_TEXTURE_CUBE_MAP_ARRAY = $9009;
3162 GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A;
3163 GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B;
3164 GL_SAMPLER_CUBE_MAP_ARRAY = $900C;
3165 GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D;
3166 GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E;
3167 GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F;
3168
3169 // GL_ARB_texture_gather
3170 GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E;
3171 GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F;
3172 GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS = $8F9F;
3173
3174 // GL_ATI_draw_buffers
3175 GL_MAX_DRAW_BUFFERS_ATI = $8824;
3176 GL_DRAW_BUFFER0_ATI = $8825;
3177 GL_DRAW_BUFFER1_ATI = $8826;
3178 GL_DRAW_BUFFER2_ATI = $8827;
3179 GL_DRAW_BUFFER3_ATI = $8828;
3180 GL_DRAW_BUFFER4_ATI = $8829;
3181 GL_DRAW_BUFFER5_ATI = $882A;
3182 GL_DRAW_BUFFER6_ATI = $882B;
3183 GL_DRAW_BUFFER7_ATI = $882C;
3184 GL_DRAW_BUFFER8_ATI = $882D;
3185 GL_DRAW_BUFFER9_ATI = $882E;
3186 GL_DRAW_BUFFER10_ATI = $882F;
3187 GL_DRAW_BUFFER11_ATI = $8830;
3188 GL_DRAW_BUFFER12_ATI = $8831;
3189 GL_DRAW_BUFFER13_ATI = $8832;
3190 GL_DRAW_BUFFER14_ATI = $8833;
3191 GL_DRAW_BUFFER15_ATI = $8834;
3192
3193 // GL_ATI_element_array
3194 GL_ELEMENT_ARRAY_ATI = $8768;
3195 GL_ELEMENT_ARRAY_TYPE_ATI = $8769;
3196 GL_ELEMENT_ARRAY_POINTER_ATI = $876A;
3197
3198 // GL_ATI_envmap_bumpmap
3199 GL_BUMP_ROT_MATRIX_ATI = $8775;
3200 GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776;
3201 GL_BUMP_NUM_TEX_UNITS_ATI = $8777;
3202 GL_BUMP_TEX_UNITS_ATI = $8778;
3203 GL_DUDV_ATI = $8779;
3204 GL_DU8DV8_ATI = $877A;
3205 GL_BUMP_ENVMAP_ATI = $877B;
3206 GL_BUMP_TARGET_ATI = $877C;
3207
3208 // GL_ATI_fragment_shader
3209 GL_FRAGMENT_SHADER_ATI = $8920;
3210 GL_REG_0_ATI = $8921;
3211 GL_REG_1_ATI = $8922;
3212 GL_REG_2_ATI = $8923;
3213 GL_REG_3_ATI = $8924;
3214 GL_REG_4_ATI = $8925;
3215 GL_REG_5_ATI = $8926;
3216 GL_REG_6_ATI = $8927;
3217 GL_REG_7_ATI = $8928;
3218 GL_REG_8_ATI = $8929;
3219 GL_REG_9_ATI = $892A;
3220 GL_REG_10_ATI = $892B;
3221 GL_REG_11_ATI = $892C;
3222 GL_REG_12_ATI = $892D;
3223 GL_REG_13_ATI = $892E;
3224 GL_REG_14_ATI = $892F;
3225 GL_REG_15_ATI = $8930;
3226 GL_REG_16_ATI = $8931;
3227 GL_REG_17_ATI = $8932;
3228 GL_REG_18_ATI = $8933;
3229 GL_REG_19_ATI = $8934;
3230 GL_REG_20_ATI = $8935;
3231 GL_REG_21_ATI = $8936;
3232 GL_REG_22_ATI = $8937;
3233 GL_REG_23_ATI = $8938;
3234 GL_REG_24_ATI = $8939;
3235 GL_REG_25_ATI = $893A;
3236 GL_REG_26_ATI = $893B;
3237 GL_REG_27_ATI = $893C;
3238 GL_REG_28_ATI = $893D;
3239 GL_REG_29_ATI = $893E;
3240 GL_REG_30_ATI = $893F;
3241 GL_REG_31_ATI = $8940;
3242 GL_CON_0_ATI = $8941;
3243 GL_CON_1_ATI = $8942;
3244 GL_CON_2_ATI = $8943;
3245 GL_CON_3_ATI = $8944;
3246 GL_CON_4_ATI = $8945;
3247 GL_CON_5_ATI = $8946;
3248 GL_CON_6_ATI = $8947;
3249 GL_CON_7_ATI = $8948;
3250 GL_CON_8_ATI = $8949;
3251 GL_CON_9_ATI = $894A;
3252 GL_CON_10_ATI = $894B;
3253 GL_CON_11_ATI = $894C;
3254 GL_CON_12_ATI = $894D;
3255 GL_CON_13_ATI = $894E;
3256 GL_CON_14_ATI = $894F;
3257 GL_CON_15_ATI = $8950;
3258 GL_CON_16_ATI = $8951;
3259 GL_CON_17_ATI = $8952;
3260 GL_CON_18_ATI = $8953;
3261 GL_CON_19_ATI = $8954;
3262 GL_CON_20_ATI = $8955;
3263 GL_CON_21_ATI = $8956;
3264 GL_CON_22_ATI = $8957;
3265 GL_CON_23_ATI = $8958;
3266 GL_CON_24_ATI = $8959;
3267 GL_CON_25_ATI = $895A;
3268 GL_CON_26_ATI = $895B;
3269 GL_CON_27_ATI = $895C;
3270 GL_CON_28_ATI = $895D;
3271 GL_CON_29_ATI = $895E;
3272 GL_CON_30_ATI = $895F;
3273 GL_CON_31_ATI = $8960;
3274 GL_MOV_ATI = $8961;
3275 GL_ADD_ATI = $8963;
3276 GL_MUL_ATI = $8964;
3277 GL_SUB_ATI = $8965;
3278 GL_DOT3_ATI = $8966;
3279 GL_DOT4_ATI = $8967;
3280 GL_MAD_ATI = $8968;
3281 GL_LERP_ATI = $8969;
3282 GL_CND_ATI = $896A;
3283 GL_CND0_ATI = $896B;
3284 GL_DOT2_ADD_ATI = $896C;
3285 GL_SECONDARY_INTERPOLATOR_ATI = $896D;
3286 GL_NUM_FRAGMENT_REGISTERS_ATI = $896E;
3287 GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F;
3288 GL_NUM_PASSES_ATI = $8970;
3289 GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971;
3290 GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972;
3291 GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973;
3292 GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974;
3293 GL_COLOR_ALPHA_PAIRING_ATI = $8975;
3294 GL_SWIZZLE_STR_ATI = $8976;
3295 GL_SWIZZLE_STQ_ATI = $8977;
3296 GL_SWIZZLE_STR_DR_ATI = $8978;
3297 GL_SWIZZLE_STQ_DQ_ATI = $8979;
3298 GL_SWIZZLE_STRQ_ATI = $897A;
3299 GL_SWIZZLE_STRQ_DQ_ATI = $897B;
3300 GL_RED_BIT_ATI = $00000001;
3301 GL_GREEN_BIT_ATI = $00000002;
3302 GL_BLUE_BIT_ATI = $00000004;
3303 GL_2X_BIT_ATI = $00000001;
3304 GL_4X_BIT_ATI = $00000002;
3305 GL_8X_BIT_ATI = $00000004;
3306 GL_HALF_BIT_ATI = $00000008;
3307 GL_QUARTER_BIT_ATI = $00000010;
3308 GL_EIGHTH_BIT_ATI = $00000020;
3309 GL_SATURATE_BIT_ATI = $00000040;
3310 GL_COMP_BIT_ATI = $00000002;
3311 GL_NEGATE_BIT_ATI = $00000004;
3312 GL_BIAS_BIT_ATI = $00000008;
3313
3314 // GL_ATI_pn_triangles
3315 GL_PN_TRIANGLES_ATI = $87F0;
3316 GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1;
3317 GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2;
3318 GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3;
3319 GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4;
3320 GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5;
3321 GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6;
3322 GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7;
3323 GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8;
3324
3325 // GL_ATI_separate_stencil
3326 GL_STENCIL_BACK_FUNC_ATI = $8800;
3327 GL_STENCIL_BACK_FAIL_ATI = $8801;
3328 GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802;
3329 GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803;
3330
3331 // GL_ATI_text_fragment_shader
3332 GL_TEXT_FRAGMENT_SHADER_ATI = $8200;
3333
3334 // GL_ATI_texture_env_combine3
3335 GL_MODULATE_ADD_ATI = $8744;
3336 GL_MODULATE_SIGNED_ADD_ATI = $8745;
3337 GL_MODULATE_SUBTRACT_ATI = $8746;
3338
3339 // GL_ATI_texture_float
3340 GL_RGBA_FLOAT32_ATI = $8814;
3341 GL_RGB_FLOAT32_ATI = $8815;
3342 GL_ALPHA_FLOAT32_ATI = $8816;
3343 GL_INTENSITY_FLOAT32_ATI = $8817;
3344 GL_LUMINANCE_FLOAT32_ATI = $8818;
3345 GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819;
3346 GL_RGBA_FLOAT16_ATI = $881A;
3347 GL_RGB_FLOAT16_ATI = $881B;
3348 GL_ALPHA_FLOAT16_ATI = $881C;
3349 GL_INTENSITY_FLOAT16_ATI = $881D;
3350 GL_LUMINANCE_FLOAT16_ATI = $881E;
3351 GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F;
3352
3353 // GL_ATI_texture_mirror_once
3354 GL_MIRROR_CLAMP_ATI = $8742;
3355 GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743;
3356
3357 // GL_ATI_vertex_array_object
3358 GL_STATIC_ATI = $8760;
3359 GL_DYNAMIC_ATI = $8761;
3360 GL_PRESERVE_ATI = $8762;
3361 GL_DISCARD_ATI = $8763;
3362 GL_OBJECT_BUFFER_SIZE_ATI = $8764;
3363 GL_OBJECT_BUFFER_USAGE_ATI = $8765;
3364 GL_ARRAY_OBJECT_BUFFER_ATI = $8766;
3365 GL_ARRAY_OBJECT_OFFSET_ATI = $8767;
3366
3367 // GL_ATI_vertex_streams
3368 GL_MAX_VERTEX_STREAMS_ATI = $876B;
3369 GL_VERTEX_STREAM0_ATI = $876C;
3370 GL_VERTEX_STREAM1_ATI = $876D;
3371 GL_VERTEX_STREAM2_ATI = $876E;
3372 GL_VERTEX_STREAM3_ATI = $876F;
3373 GL_VERTEX_STREAM4_ATI = $8770;
3374 GL_VERTEX_STREAM5_ATI = $8771;
3375 GL_VERTEX_STREAM6_ATI = $8772;
3376 GL_VERTEX_STREAM7_ATI = $8773;
3377 GL_VERTEX_SOURCE_ATI = $8774;
3378
3379 // GL_ATI_meminfo
3380 GL_VBO_FREE_MEMORY_ATI = $87FB;
3381 GL_TEXTURE_FREE_MEMORY_ATI = $87FC;
3382 GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD;
3383
3384 // GL_AMD_performance_monitor
3385 GL_COUNTER_TYPE_AMD = $8BC0;
3386 GL_COUNTER_RANGE_AMD = $8BC1;
3387 GL_UNSIGNED_INT64_AMD = $8BC2;
3388 GL_PERCENTAGE_AMD = $8BC3;
3389 GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4;
3390 GL_PERFMON_RESULT_SIZE_AMD = $8BC5;
3391 GL_PERFMON_RESULT_AMD = $8BC6;
3392
3393 // GL_AMD_vertex_shader_tesselator
3394 GL_SAMPLER_BUFFER_AMD = $9001;
3395 GL_INT_SAMPLER_BUFFER_AMD = $9002;
3396 GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003;
3397 GL_TESSELLATION_MODE_AMD = $9004;
3398 GL_TESSELLATION_FACTOR_AMD = $9005;
3399 GL_DISCRETE_AMD = $9006;
3400 GL_CONTINUOUS_AMD = $9007;
3401
3402 // GL_EXT_422_pixels
3403 GL_422_EXT = $80CC;
3404 GL_422_REV_EXT = $80CD;
3405 GL_422_AVERAGE_EXT = $80CE;
3406 GL_422_REV_AVERAGE_EXT = $80CF;
3407
3408 // GL_EXT_abgr
3409 GL_ABGR_EXT = $8000;
3410
3411 // GL_EXT_bgra
3412 GL_BGR_EXT = $80E0;
3413 GL_BGRA_EXT = $80E1;
3414
3415 // GL_EXT_blend_color
3416 GL_CONSTANT_COLOR_EXT = $8001;
3417 GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002;
3418 GL_CONSTANT_ALPHA_EXT = $8003;
3419 GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004;
3420 GL_BLEND_COLOR_EXT = $8005;
3421
3422 // GL_EXT_blend_func_separate
3423 GL_BLEND_DST_RGB_EXT = $80C8;
3424 GL_BLEND_SRC_RGB_EXT = $80C9;
3425 GL_BLEND_DST_ALPHA_EXT = $80CA;
3426 GL_BLEND_SRC_ALPHA_EXT = $80CB;
3427
3428 // GL_EXT_blend_minmax
3429 GL_FUNC_ADD_EXT = $8006;
3430 GL_MIN_EXT = $8007;
3431 GL_MAX_EXT = $8008;
3432 GL_BLEND_EQUATION_EXT = $8009;
3433
3434 // GL_EXT_blend_subtract
3435 GL_FUNC_SUBTRACT_EXT = $800A;
3436 GL_FUNC_REVERSE_SUBTRACT_EXT = $800B;
3437
3438 // GL_EXT_clip_volume_hint
3439 GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0;
3440
3441 // GL_EXT_cmyka
3442 GL_CMYK_EXT = $800C;
3443 GL_CMYKA_EXT = $800D;
3444 GL_PACK_CMYK_HINT_EXT = $800E;
3445 GL_UNPACK_CMYK_HINT_EXT = $800F;
3446
3447 // GL_EXT_compiled_vertex_array
3448 GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8;
3449 GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9;
3450
3451 // GL_EXT_convolution
3452 GL_CONVOLUTION_1D_EXT = $8010;
3453 GL_CONVOLUTION_2D_EXT = $8011;
3454 GL_SEPARABLE_2D_EXT = $8012;
3455 GL_CONVOLUTION_BORDER_MODE_EXT = $8013;
3456 GL_CONVOLUTION_FILTER_SCALE_EXT = $8014;
3457 GL_CONVOLUTION_FILTER_BIAS_EXT = $8015;
3458 GL_REDUCE_EXT = $8016;
3459 GL_CONVOLUTION_FORMAT_EXT = $8017;
3460 GL_CONVOLUTION_WIDTH_EXT = $8018;
3461 GL_CONVOLUTION_HEIGHT_EXT = $8019;
3462 GL_MAX_CONVOLUTION_WIDTH_EXT = $801A;
3463 GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B;
3464 GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C;
3465 GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D;
3466 GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E;
3467 GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F;
3468 GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020;
3469 GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021;
3470 GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022;
3471 GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023;
3472
3473 // GL_EXT_coordinate_frame
3474 GL_TANGENT_ARRAY_EXT = $8439;
3475 GL_BINORMAL_ARRAY_EXT = $843A;
3476 GL_CURRENT_TANGENT_EXT = $843B;
3477 GL_CURRENT_BINORMAL_EXT = $843C;
3478 GL_TANGENT_ARRAY_TYPE_EXT = $843E;
3479 GL_TANGENT_ARRAY_STRIDE_EXT = $843F;
3480 GL_BINORMAL_ARRAY_TYPE_EXT = $8440;
3481 GL_BINORMAL_ARRAY_STRIDE_EXT = $8441;
3482 GL_TANGENT_ARRAY_POINTER_EXT = $8442;
3483 GL_BINORMAL_ARRAY_POINTER_EXT = $8443;
3484 GL_MAP1_TANGENT_EXT = $8444;
3485 GL_MAP2_TANGENT_EXT = $8445;
3486 GL_MAP1_BINORMAL_EXT = $8446;
3487 GL_MAP2_BINORMAL_EXT = $8447;
3488
3489 // GL_EXT_cull_vertex
3490 GL_CULL_VERTEX_EXT = $81AA;
3491 GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB;
3492 GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC;
3493
3494 // GL_EXT_draw_range_elements
3495 GL_MAX_ELEMENTS_VERTICES_EXT = $80E8;
3496 GL_MAX_ELEMENTS_INDICES_EXT = $80E9;
3497
3498 // GL_EXT_fog_coord
3499 GL_FOG_COORDINATE_SOURCE_EXT = $8450;
3500 GL_FOG_COORDINATE_EXT = $8451;
3501 GL_FRAGMENT_DEPTH_EXT = $8452;
3502 GL_CURRENT_FOG_COORDINATE_EXT = $8453;
3503 GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454;
3504 GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455;
3505 GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456;
3506 GL_FOG_COORDINATE_ARRAY_EXT = $8457;
3507
3508 // GL_EXT_framebuffer_object
3509 GL_FRAMEBUFFER_EXT = $8D40;
3510 GL_RENDERBUFFER_EXT = $8D41;
3511 GL_STENCIL_INDEX_EXT = $8D45;
3512 GL_STENCIL_INDEX1_EXT = $8D46;
3513 GL_STENCIL_INDEX4_EXT = $8D47;
3514 GL_STENCIL_INDEX8_EXT = $8D48;
3515 GL_STENCIL_INDEX16_EXT = $8D49;
3516 GL_RENDERBUFFER_WIDTH_EXT = $8D42;
3517 GL_RENDERBUFFER_HEIGHT_EXT = $8D43;
3518 GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44;
3519 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0;
3520 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1;
3521 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2;
3522 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3;
3523 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4;
3524 GL_COLOR_ATTACHMENT0_EXT = $8CE0;
3525 GL_COLOR_ATTACHMENT1_EXT = $8CE1;
3526 GL_COLOR_ATTACHMENT2_EXT = $8CE2;
3527 GL_COLOR_ATTACHMENT3_EXT = $8CE3;
3528 GL_COLOR_ATTACHMENT4_EXT = $8CE4;
3529 GL_COLOR_ATTACHMENT5_EXT = $8CE5;
3530 GL_COLOR_ATTACHMENT6_EXT = $8CE6;
3531 GL_COLOR_ATTACHMENT7_EXT = $8CE7;
3532 GL_COLOR_ATTACHMENT8_EXT = $8CE8;
3533 GL_COLOR_ATTACHMENT9_EXT = $8CE9;
3534 GL_COLOR_ATTACHMENT10_EXT = $8CEA;
3535 GL_COLOR_ATTACHMENT11_EXT = $8CEB;
3536 GL_COLOR_ATTACHMENT12_EXT = $8CEC;
3537 GL_COLOR_ATTACHMENT13_EXT = $8CED;
3538 GL_COLOR_ATTACHMENT14_EXT = $8CEE;
3539 GL_COLOR_ATTACHMENT15_EXT = $8CEF;
3540 GL_DEPTH_ATTACHMENT_EXT = $8D00;
3541 GL_STENCIL_ATTACHMENT_EXT = $8D20;
3542 GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5;
3543 GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6;
3544 GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7;
3545 GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8;
3546 GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9;
3547 GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA;
3548 GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB;
3549 GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC;
3550 GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD;
3551 GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE;
3552 GL_FRAMEBUFFER_BINDING_EXT = $8CA6;
3553 GL_RENDERBUFFER_BINDING_EXT = $8CA7;
3554 GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF;
3555 GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8;
3556 GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506;
3557
3558 // GL_EXT_histogram
3559 GL_HISTOGRAM_EXT = $8024;
3560 GL_PROXY_HISTOGRAM_EXT = $8025;
3561 GL_HISTOGRAM_WIDTH_EXT = $8026;
3562 GL_HISTOGRAM_FORMAT_EXT = $8027;
3563 GL_HISTOGRAM_RED_SIZE_EXT = $8028;
3564 GL_HISTOGRAM_GREEN_SIZE_EXT = $8029;
3565 GL_HISTOGRAM_BLUE_SIZE_EXT = $802A;
3566 GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B;
3567 GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C;
3568 GL_HISTOGRAM_SINK_EXT = $802D;
3569 GL_MINMAX_EXT = $802E;
3570 GL_MINMAX_FORMAT_EXT = $802F;
3571 GL_MINMAX_SINK_EXT = $8030;
3572 GL_TABLE_TOO_LARGE_EXT = $8031;
3573
3574 // GL_EXT_index_array_formats
3575 GL_IUI_V2F_EXT = $81AD;
3576 GL_IUI_V3F_EXT = $81AE;
3577 GL_IUI_N3F_V2F_EXT = $81AF;
3578 GL_IUI_N3F_V3F_EXT = $81B0;
3579 GL_T2F_IUI_V2F_EXT = $81B1;
3580 GL_T2F_IUI_V3F_EXT = $81B2;
3581 GL_T2F_IUI_N3F_V2F_EXT = $81B3;
3582 GL_T2F_IUI_N3F_V3F_EXT = $81B4;
3583
3584 // GL_EXT_index_func
3585 GL_INDEX_TEST_EXT = $81B5;
3586 GL_INDEX_TEST_FUNC_EXT = $81B6;
3587 GL_INDEX_TEST_REF_EXT = $81B7;
3588
3589 // GL_EXT_index_material
3590 GL_INDEX_MATERIAL_EXT = $81B8;
3591 GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9;
3592 GL_INDEX_MATERIAL_FACE_EXT = $81BA;
3593
3594 // GL_EXT_light_texture
3595 GL_FRAGMENT_MATERIAL_EXT = $8349;
3596 GL_FRAGMENT_NORMAL_EXT = $834A;
3597 GL_FRAGMENT_COLOR_EXT = $834C;
3598 GL_ATTENUATION_EXT = $834D;
3599 GL_SHADOW_ATTENUATION_EXT = $834E;
3600 GL_TEXTURE_APPLICATION_MODE_EXT = $834F;
3601 GL_TEXTURE_LIGHT_EXT = $8350;
3602 GL_TEXTURE_MATERIAL_FACE_EXT = $8351;
3603 GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352;
3604
3605 // GL_EXT_multisample
3606 GL_MULTISAMPLE_EXT = $809D;
3607 GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E;
3608 GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F;
3609 GL_SAMPLE_MASK_EXT = $80A0;
3610 GL_1PASS_EXT = $80A1;
3611 GL_2PASS_0_EXT = $80A2;
3612 GL_2PASS_1_EXT = $80A3;
3613 GL_4PASS_0_EXT = $80A4;
3614 GL_4PASS_1_EXT = $80A5;
3615 GL_4PASS_2_EXT = $80A6;
3616 GL_4PASS_3_EXT = $80A7;
3617 GL_SAMPLE_BUFFERS_EXT = $80A8;
3618 GL_SAMPLES_EXT = $80A9;
3619 GL_SAMPLE_MASK_VALUE_EXT = $80AA;
3620 GL_SAMPLE_MASK_INVERT_EXT = $80AB;
3621 GL_SAMPLE_PATTERN_EXT = $80AC;
3622 GL_MULTISAMPLE_BIT_EXT = $20000000;
3623
3624 // GL_EXT_packed_pixels
3625 GL_UNSIGNED_BYTE_3_3_2_EXT = $8032;
3626 GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033;
3627 GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034;
3628 GL_UNSIGNED_INT_8_8_8_8_EXT = $8035;
3629 GL_UNSIGNED_INT_10_10_10_2_EXT = $8036;
3630
3631 // GL_EXT_paletted_texture
3632 GL_COLOR_INDEX1_EXT = $80E2;
3633 GL_COLOR_INDEX2_EXT = $80E3;
3634 GL_COLOR_INDEX4_EXT = $80E4;
3635 GL_COLOR_INDEX8_EXT = $80E5;
3636 GL_COLOR_INDEX12_EXT = $80E6;
3637 GL_COLOR_INDEX16_EXT = $80E7;
3638 GL_TEXTURE_INDEX_SIZE_EXT = $80ED;
3639
3640 // GL_EXT_pixel_transform
3641 GL_PIXEL_TRANSFORM_2D_EXT = $8330;
3642 GL_PIXEL_MAG_FILTER_EXT = $8331;
3643 GL_PIXEL_MIN_FILTER_EXT = $8332;
3644 GL_PIXEL_CUBIC_WEIGHT_EXT = $8333;
3645 GL_CUBIC_EXT = $8334;
3646 GL_AVERAGE_EXT = $8335;
3647 GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336;
3648 GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337;
3649 GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338;
3650
3651 // GL_EXT_point_parameters
3652 GL_POINT_SIZE_MIN_EXT = $8126;
3653 GL_POINT_SIZE_MAX_EXT = $8127;
3654 GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128;
3655 GL_DISTANCE_ATTENUATION_EXT = $8129;
3656
3657 // GL_EXT_polygon_offset
3658 GL_POLYGON_OFFSET_EXT = $8037;
3659 GL_POLYGON_OFFSET_FACTOR_EXT = $8038;
3660 GL_POLYGON_OFFSET_BIAS_EXT = $8039;
3661
3662 // GL_EXT_rescale_normal
3663 GL_RESCALE_NORMAL_EXT = $803A;
3664
3665 // GL_EXT_secondary_color
3666 GL_COLOR_SUM_EXT = $8458;
3667 GL_CURRENT_SECONDARY_COLOR_EXT = $8459;
3668 GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A;
3669 GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B;
3670 GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C;
3671 GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D;
3672 GL_SECONDARY_COLOR_ARRAY_EXT = $845E;
3673
3674 // GL_EXT_separate_specular_color
3675 GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8;
3676 GL_SINGLE_COLOR_EXT = $81F9;
3677 GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA;
3678
3679 // GL_EXT_shared_texture_palette
3680 GL_SHARED_TEXTURE_PALETTE_EXT = $81FB;
3681
3682 // GL_EXT_stencil_two_side
3683 GL_STENCIL_TEST_TWO_SIDE_EXT = $8910;
3684 GL_ACTIVE_STENCIL_FACE_EXT = $8911;
3685
3686 // GL_EXT_stencil_wrap
3687 GL_INCR_WRAP_EXT = $8507;
3688 GL_DECR_WRAP_EXT = $8508;
3689
3690 // GL_EXT_texture
3691 GL_ALPHA4_EXT = $803B;
3692 GL_ALPHA8_EXT = $803C;
3693 GL_ALPHA12_EXT = $803D;
3694 GL_ALPHA16_EXT = $803E;
3695 GL_LUMINANCE4_EXT = $803F;
3696 GL_LUMINANCE8_EXT = $8040;
3697 GL_LUMINANCE12_EXT = $8041;
3698 GL_LUMINANCE16_EXT = $8042;
3699 GL_LUMINANCE4_ALPHA4_EXT = $8043;
3700 GL_LUMINANCE6_ALPHA2_EXT = $8044;
3701 GL_LUMINANCE8_ALPHA8_EXT = $8045;
3702 GL_LUMINANCE12_ALPHA4_EXT = $8046;
3703 GL_LUMINANCE12_ALPHA12_EXT = $8047;
3704 GL_LUMINANCE16_ALPHA16_EXT = $8048;
3705 GL_INTENSITY_EXT = $8049;
3706 GL_INTENSITY4_EXT = $804A;
3707 GL_INTENSITY8_EXT = $804B;
3708 GL_INTENSITY12_EXT = $804C;
3709 GL_INTENSITY16_EXT = $804D;
3710 GL_RGB2_EXT = $804E;
3711 GL_RGB4_EXT = $804F;
3712 GL_RGB5_EXT = $8050;
3713 GL_RGB8_EXT = $8051;
3714 GL_RGB10_EXT = $8052;
3715 GL_RGB12_EXT = $8053;
3716 GL_RGB16_EXT = $8054;
3717 GL_RGBA2_EXT = $8055;
3718 GL_RGBA4_EXT = $8056;
3719 GL_RGB5_A1_EXT = $8057;
3720 GL_RGBA8_EXT = $8058;
3721 GL_RGB10_A2_EXT = $8059;
3722 GL_RGBA12_EXT = $805A;
3723 GL_RGBA16_EXT = $805B;
3724 GL_TEXTURE_RED_SIZE_EXT = $805C;
3725 GL_TEXTURE_GREEN_SIZE_EXT = $805D;
3726 GL_TEXTURE_BLUE_SIZE_EXT = $805E;
3727 GL_TEXTURE_ALPHA_SIZE_EXT = $805F;
3728 GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060;
3729 GL_TEXTURE_INTENSITY_SIZE_EXT = $8061;
3730 GL_REPLACE_EXT = $8062;
3731 GL_PROXY_TEXTURE_1D_EXT = $8063;
3732 GL_PROXY_TEXTURE_2D_EXT = $8064;
3733 GL_TEXTURE_TOO_LARGE_EXT = $8065;
3734
3735 // GL_EXT_texture3D
3736 GL_PACK_SKIP_IMAGES_EXT = $806B;
3737 GL_PACK_IMAGE_HEIGHT_EXT = $806C;
3738 GL_UNPACK_SKIP_IMAGES_EXT = $806D;
3739 GL_UNPACK_IMAGE_HEIGHT_EXT = $806E;
3740 GL_TEXTURE_3D_EXT = $806F;
3741 GL_PROXY_TEXTURE_3D_EXT = $8070;
3742 GL_TEXTURE_DEPTH_EXT = $8071;
3743 GL_TEXTURE_WRAP_R_EXT = $8072;
3744 GL_MAX_3D_TEXTURE_SIZE_EXT = $8073;
3745
3746 // GL_EXT_texture_compression_s3tc
3747 GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
3748 GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
3749 GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
3750 GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
3751
3752 // GL_EXT_texture_cube_map
3753 GL_NORMAL_MAP_EXT = $8511;
3754 GL_REFLECTION_MAP_EXT = $8512;
3755 GL_TEXTURE_CUBE_MAP_EXT = $8513;
3756 GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514;
3757 GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515;
3758 GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516;
3759 GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517;
3760 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518;
3761 GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519;
3762 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A;
3763 GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B;
3764 GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C;
3765
3766 // GL_EXT_texture_edge_clamp
3767 GL_CLAMP_TO_EDGE_EXT = $812F;
3768
3769 // GL_EXT_texture_env_combine
3770 GL_COMBINE_EXT = $8570;
3771 GL_COMBINE_RGB_EXT = $8571;
3772 GL_COMBINE_ALPHA_EXT = $8572;
3773 GL_RGB_SCALE_EXT = $8573;
3774 GL_ADD_SIGNED_EXT = $8574;
3775 GL_INTERPOLATE_EXT = $8575;
3776 GL_CONSTANT_EXT = $8576;
3777 GL_PRIMARY_COLOR_EXT = $8577;
3778 GL_PREVIOUS_EXT = $8578;
3779 GL_SOURCE0_RGB_EXT = $8580;
3780 GL_SOURCE1_RGB_EXT = $8581;
3781 GL_SOURCE2_RGB_EXT = $8582;
3782 GL_SOURCE0_ALPHA_EXT = $8588;
3783 GL_SOURCE1_ALPHA_EXT = $8589;
3784 GL_SOURCE2_ALPHA_EXT = $858A;
3785 GL_OPERAND0_RGB_EXT = $8590;
3786 GL_OPERAND1_RGB_EXT = $8591;
3787 GL_OPERAND2_RGB_EXT = $8592;
3788 GL_OPERAND0_ALPHA_EXT = $8598;
3789 GL_OPERAND1_ALPHA_EXT = $8599;
3790 GL_OPERAND2_ALPHA_EXT = $859A;
3791
3792 // GL_EXT_texture_env_dot3
3793 GL_DOT3_RGB_EXT = $8740;
3794 GL_DOT3_RGBA_EXT = $8741;
3795
3796 // GL_EXT_texture_filter_anisotropic
3797 GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
3798 GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
3799
3800 // GL_EXT_texture_lod_bias
3801 GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD;
3802 GL_TEXTURE_FILTER_CONTROL_EXT = $8500;
3803 GL_TEXTURE_LOD_BIAS_EXT = $8501;
3804
3805 // GL_EXT_texture_object
3806 GL_TEXTURE_PRIORITY_EXT = $8066;
3807 GL_TEXTURE_RESIDENT_EXT = $8067;
3808 GL_TEXTURE_1D_BINDING_EXT = $8068;
3809 GL_TEXTURE_2D_BINDING_EXT = $8069;
3810 GL_TEXTURE_3D_BINDING_EXT = $806A;
3811
3812 // GL_EXT_texture_perturb_normal
3813 GL_PERTURB_EXT = $85AE;
3814 GL_TEXTURE_NORMAL_EXT = $85AF;
3815
3816 // GL_EXT_texture_rectangle
3817 GL_TEXTURE_RECTANGLE_EXT = $84F5;
3818 GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6;
3819 GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7;
3820 GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8;
3821
3822 // GL_EXT_vertex_array
3823 GL_VERTEX_ARRAY_EXT = $8074;
3824 GL_NORMAL_ARRAY_EXT = $8075;
3825 GL_COLOR_ARRAY_EXT = $8076;
3826 GL_INDEX_ARRAY_EXT = $8077;
3827 GL_TEXTURE_COORD_ARRAY_EXT = $8078;
3828 GL_EDGE_FLAG_ARRAY_EXT = $8079;
3829 GL_VERTEX_ARRAY_SIZE_EXT = $807A;
3830 GL_VERTEX_ARRAY_TYPE_EXT = $807B;
3831 GL_VERTEX_ARRAY_STRIDE_EXT = $807C;
3832 GL_VERTEX_ARRAY_COUNT_EXT = $807D;
3833 GL_NORMAL_ARRAY_TYPE_EXT = $807E;
3834 GL_NORMAL_ARRAY_STRIDE_EXT = $807F;
3835 GL_NORMAL_ARRAY_COUNT_EXT = $8080;
3836 GL_COLOR_ARRAY_SIZE_EXT = $8081;
3837 GL_COLOR_ARRAY_TYPE_EXT = $8082;
3838 GL_COLOR_ARRAY_STRIDE_EXT = $8083;
3839 GL_COLOR_ARRAY_COUNT_EXT = $8084;
3840 GL_INDEX_ARRAY_TYPE_EXT = $8085;
3841 GL_INDEX_ARRAY_STRIDE_EXT = $8086;
3842 GL_INDEX_ARRAY_COUNT_EXT = $8087;
3843 GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088;
3844 GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089;
3845 GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A;
3846 GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B;
3847 GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C;
3848 GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D;
3849 GL_VERTEX_ARRAY_POINTER_EXT = $808E;
3850 GL_NORMAL_ARRAY_POINTER_EXT = $808F;
3851 GL_COLOR_ARRAY_POINTER_EXT = $8090;
3852 GL_INDEX_ARRAY_POINTER_EXT = $8091;
3853 GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092;
3854 GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093;
3855
3856 // GL_EXT_vertex_shader
3857 GL_VERTEX_SHADER_EXT = $8780;
3858 GL_VERTEX_SHADER_BINDING_EXT = $8781;
3859 GL_OP_INDEX_EXT = $8782;
3860 GL_OP_NEGATE_EXT = $8783;
3861 GL_OP_DOT3_EXT = $8784;
3862 GL_OP_DOT4_EXT = $8785;
3863 GL_OP_MUL_EXT = $8786;
3864 GL_OP_ADD_EXT = $8787;
3865 GL_OP_MADD_EXT = $8788;
3866 GL_OP_FRAC_EXT = $8789;
3867 GL_OP_MAX_EXT = $878A;
3868 GL_OP_MIN_EXT = $878B;
3869 GL_OP_SET_GE_EXT = $878C;
3870 GL_OP_SET_LT_EXT = $878D;
3871 GL_OP_CLAMP_EXT = $878E;
3872 GL_OP_FLOOR_EXT = $878F;
3873 GL_OP_ROUND_EXT = $8790;
3874 GL_OP_EXP_BASE_2_EXT = $8791;
3875 GL_OP_LOG_BASE_2_EXT = $8792;
3876 GL_OP_POWER_EXT = $8793;
3877 GL_OP_RECIP_EXT = $8794;
3878 GL_OP_RECIP_SQRT_EXT = $8795;
3879 GL_OP_SUB_EXT = $8796;
3880 GL_OP_CROSS_PRODUCT_EXT = $8797;
3881 GL_OP_MULTIPLY_MATRIX_EXT = $8798;
3882 GL_OP_MOV_EXT = $8799;
3883 GL_OUTPUT_VERTEX_EXT = $879A;
3884 GL_OUTPUT_COLOR0_EXT = $879B;
3885 GL_OUTPUT_COLOR1_EXT = $879C;
3886 GL_OUTPUT_TEXTURE_COORD0_EXT = $879D;
3887 GL_OUTPUT_TEXTURE_COORD1_EXT = $879E;
3888 GL_OUTPUT_TEXTURE_COORD2_EXT = $879F;
3889 GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0;
3890 GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1;
3891 GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2;
3892 GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3;
3893 GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4;
3894 GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5;
3895 GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6;
3896 GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7;
3897 GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8;
3898 GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9;
3899 GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA;
3900 GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB;
3901 GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC;
3902 GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD;
3903 GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE;
3904 GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF;
3905 GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0;
3906 GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1;
3907 GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2;
3908 GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3;
3909 GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4;
3910 GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5;
3911 GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6;
3912 GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7;
3913 GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8;
3914 GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9;
3915 GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA;
3916 GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB;
3917 GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC;
3918 GL_OUTPUT_FOG_EXT = $87BD;
3919 GL_SCALAR_EXT = $87BE;
3920 GL_VECTOR_EXT = $87BF;
3921 GL_MATRIX_EXT = $87C0;
3922 GL_VARIANT_EXT = $87C1;
3923 GL_INVARIANT_EXT = $87C2;
3924 GL_LOCAL_CONSTANT_EXT = $87C3;
3925 GL_LOCAL_EXT = $87C4;
3926 GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5;
3927 GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6;
3928 GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7;
3929 GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8;
3930 GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9;
3931 GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA;
3932 GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB;
3933 GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC;
3934 GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD;
3935 GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE;
3936 GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF;
3937 GL_VERTEX_SHADER_VARIANTS_EXT = $87D0;
3938 GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1;
3939 GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2;
3940 GL_VERTEX_SHADER_LOCALS_EXT = $87D3;
3941 GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4;
3942 GL_X_EXT = $87D5;
3943 GL_Y_EXT = $87D6;
3944 GL_Z_EXT = $87D7;
3945 GL_W_EXT = $87D8;
3946 GL_NEGATIVE_X_EXT = $87D9;
3947 GL_NEGATIVE_Y_EXT = $87DA;
3948 GL_NEGATIVE_Z_EXT = $87DB;
3949 GL_NEGATIVE_W_EXT = $87DC;
3950 GL_ZERO_EXT = $87DD;
3951 GL_ONE_EXT = $87DE;
3952 GL_NEGATIVE_ONE_EXT = $87DF;
3953 GL_NORMALIZED_RANGE_EXT = $87E0;
3954 GL_FULL_RANGE_EXT = $87E1;
3955 GL_CURRENT_VERTEX_EXT = $87E2;
3956 GL_MVP_MATRIX_EXT = $87E3;
3957 GL_VARIANT_VALUE_EXT = $87E4;
3958 GL_VARIANT_DATATYPE_EXT = $87E5;
3959 GL_VARIANT_ARRAY_STRIDE_EXT = $87E6;
3960 GL_VARIANT_ARRAY_TYPE_EXT = $87E7;
3961 GL_VARIANT_ARRAY_EXT = $87E8;
3962 GL_VARIANT_ARRAY_POINTER_EXT = $87E9;
3963 GL_INVARIANT_VALUE_EXT = $87EA;
3964 GL_INVARIANT_DATATYPE_EXT = $87EB;
3965 GL_LOCAL_CONSTANT_VALUE_EXT = $87EC;
3966 GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED;
3967
3968 // GL_EXT_vertex_weighting
3969 GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3;
3970 GL_MODELVIEW1_STACK_DEPTH_EXT = $8502;
3971 GL_MODELVIEW0_MATRIX_EXT = $0BA6;
3972 GL_MODELVIEW1_MATRIX_EXT = $8506;
3973 GL_VERTEX_WEIGHTING_EXT = $8509;
3974 GL_MODELVIEW0_EXT = $1700;
3975 GL_MODELVIEW1_EXT = $850A;
3976 GL_CURRENT_VERTEX_WEIGHT_EXT = $850B;
3977 GL_VERTEX_WEIGHT_ARRAY_EXT = $850C;
3978 GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D;
3979 GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E;
3980 GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F;
3981 GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510;
3982
3983 // GL_EXT_depth_bounds_test
3984 GL_DEPTH_BOUNDS_TEST_EXT = $8890;
3985 GL_DEPTH_BOUNDS_EXT = $8891;
3986
3987 // GL_EXT_texture_mirror_clamp
3988 GL_MIRROR_CLAMP_EXT = $8742;
3989 GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743;
3990 GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912;
3991
3992 // GL_EXT_blend_equation_separate
3993 GL_BLEND_EQUATION_RGB_EXT = $8009;
3994 GL_BLEND_EQUATION_ALPHA_EXT = $883D;
3995
3996 // GL_EXT_pixel_buffer_object
3997 GL_PIXEL_PACK_BUFFER_EXT = $88EB;
3998 GL_PIXEL_UNPACK_BUFFER_EXT = $88EC;
3999 GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED;
4000 GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF;
4001
4002 // GL_EXT_stencil_clear_tag
4003 GL_STENCIL_TAG_BITS_EXT = $88F2;
4004 GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3;
4005
4006 // GL_EXT_packed_depth_stencil
4007 GL_DEPTH_STENCIL_EXT = $84F9;
4008 GL_UNSIGNED_INT_24_8_EXT = $84FA;
4009 GL_DEPTH24_STENCIL8_EXT = $88F0;
4010 GL_TEXTURE_STENCIL_SIZE_EXT = $88F1;
4011
4012 // GL_EXT_texture_sRGB
4013 GL_SRGB_EXT = $8C40;
4014 GL_SRGB8_EXT = $8C41;
4015 GL_SRGB_ALPHA_EXT = $8C42;
4016 GL_SRGB8_ALPHA8_EXT = $8C43;
4017 GL_SLUMINANCE_ALPHA_EXT = $8C44;
4018 GL_SLUMINANCE8_ALPHA8_EXT = $8C45;
4019 GL_SLUMINANCE_EXT = $8C46;
4020 GL_SLUMINANCE8_EXT = $8C47;
4021 GL_COMPRESSED_SRGB_EXT = $8C48;
4022 GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49;
4023 GL_COMPRESSED_SLUMINANCE_EXT = $8C4A;
4024 GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B;
4025 GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C;
4026 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D;
4027 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E;
4028 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F;
4029
4030 // GL_EXT_framebuffer_blit
4031 GL_READ_FRAMEBUFFER_EXT = $8CA8;
4032 GL_DRAW_FRAMEBUFFER_EXT = $8CA9;
4033 GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT;
4034 GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA;
4035
4036 // GL_EXT_framebuffer_multisample
4037 GL_RENDERBUFFER_SAMPLES_EXT = $8CAB;
4038 GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56;
4039 GL_MAX_SAMPLES_EXT = $8D57;
4040
4041 // GL_EXT_timer_query
4042 GL_TIME_ELAPSED_EXT = $88BF;
4043
4044 // GL_EXT_bindable_uniform
4045 GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2;
4046 GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3;
4047 GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4;
4048 GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED;
4049 GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF;
4050
4051 // GL_EXT_framebuffer_sRGB
4052 GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
4053 WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9;
4054 GL_FRAMEBUFFER_SRGB_EXT = $8DB9;
4055 GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA;
4056
4057 // GL_EXT_geometry_shader4
4058 GL_GEOMETRY_SHADER_EXT = $8DD9;
4059 GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA;
4060 GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB;
4061 GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC;
4062 GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29;
4063 GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD;
4064 GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE;
4065 GL_MAX_VARYING_COMPONENTS_EXT = $8B4B;
4066 GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF;
4067 GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0;
4068 GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1;
4069 GL_LINES_ADJACENCY_EXT = $A;
4070 GL_LINE_STRIP_ADJACENCY_EXT = $B;
4071 GL_TRIANGLES_ADJACENCY_EXT = $C;
4072 GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D;
4073 GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8;
4074 GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9;
4075 GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7;
4076 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4;
4077 GL_PROGRAM_POINT_SIZE_EXT = $8642;
4078
4079 // GL_EXT_gpu_shader4
4080 GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD;
4081 GL_SAMPLER_1D_ARRAY_EXT = $8DC0;
4082 GL_SAMPLER_2D_ARRAY_EXT = $8DC1;
4083 GL_SAMPLER_BUFFER_EXT = $8DC2;
4084 GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3;
4085 GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4;
4086 GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5;
4087 GL_UNSIGNED_INT_VEC2_EXT = $8DC6;
4088 GL_UNSIGNED_INT_VEC3_EXT = $8DC7;
4089 GL_UNSIGNED_INT_VEC4_EXT = $8DC8;
4090 GL_INT_SAMPLER_1D_EXT = $8DC9;
4091 GL_INT_SAMPLER_2D_EXT = $8DCA;
4092 GL_INT_SAMPLER_3D_EXT = $8DCB;
4093 GL_INT_SAMPLER_CUBE_EXT = $8DCC;
4094 GL_INT_SAMPLER_2D_RECT_EXT = $8DCD;
4095 GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE;
4096 GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF;
4097 GL_INT_SAMPLER_BUFFER_EXT = $8DD0;
4098 GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1;
4099 GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2;
4100 GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3;
4101 GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4;
4102 GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5;
4103 GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6;
4104 GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7;
4105 GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8;
4106 GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904;
4107 GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905;
4108
4109 // GL_EXT_packed_float
4110 GL_R11F_G11F_B10F_EXT = $8C3A;
4111 GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B;
4112 RGBA_SIGNED_COMPONENTS_EXT = $8C3C;
4113 WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8;
4114 GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
4115 GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
4116
4117 // GL_EXT_texture_array
4118 GL_TEXTURE_1D_ARRAY_EXT = $8C18;
4119 GL_TEXTURE_2D_ARRAY_EXT = $8C1A;
4120 GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B;
4121 GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19;
4122 GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C;
4123 GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D;
4124 GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF;
4125 GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E;
4126
4127 // GL_EXT_texture_buffer_object
4128 GL_TEXTURE_BUFFER_EXT = $8C2A;
4129 GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B;
4130 GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C;
4131 GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D;
4132 GL_TEXTURE_BUFFER_FORMAT_EXT = $8C2E;
4133
4134 // GL_EXT_texture_compression_latc
4135 GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70;
4136 GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71;
4137 GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72;
4138 GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73;
4139
4140 // GL_EXT_texture_compression_rgtc
4141 GL_COMPRESSED_RED_RGTC1_EXT = $8DBB;
4142 GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC;
4143 GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD;
4144 GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE;
4145
4146 // GL_EXT_texture_integer
4147 GL_RGBA_INTEGER_MODE_EXT = $8D9E;
4148 GL_RGBA32UI_EXT = $8D70;
4149 GL_RGB32UI_EXT = $8D71;
4150 GL_ALPHA32UI_EXT = $8D72;
4151 GL_INTENSITY32UI_EXT = $8D73;
4152 GL_LUMINANCE32UI_EXT = $8D74;
4153 GL_LUMINANCE_ALPHA32UI_EXT = $8D75;
4154 GL_RGBA16UI_EXT = $8D76;
4155 GL_RGB16UI_EXT = $8D77;
4156 GL_ALPHA16UI_EXT = $8D78;
4157 GL_INTENSITY16UI_EXT = $8D79;
4158 GL_LUMINANCE16UI_EXT = $8D7A;
4159 GL_LUMINANCE_ALPHA16UI_EXT = $8D7B;
4160 GL_RGBA8UI_EXT = $8D7C;
4161 GL_RGB8UI_EXT = $8D7D;
4162 GL_ALPHA8UI_EXT = $8D7E;
4163 GL_INTENSITY8UI_EXT = $8D7F;
4164 GL_LUMINANCE8UI_EXT = $8D80;
4165 GL_LUMINANCE_ALPHA8UI_EXT = $8D81;
4166 GL_RGBA32I_EXT = $8D82;
4167 GL_RGB32I_EXT = $8D83;
4168 GL_ALPHA32I_EXT = $8D84;
4169 GL_INTENSITY32I_EXT = $8D85;
4170 GL_LUMINANCE32I_EXT = $8D86;
4171 GL_LUMINANCE_ALPHA32I_EXT = $8D87;
4172 GL_RGBA16I_EXT = $8D88;
4173 GL_RGB16I_EXT = $8D89;
4174 GL_ALPHA16I_EXT = $8D8A;
4175 GL_INTENSITY16I_EXT = $8D8B;
4176 GL_LUMINANCE16I_EXT = $8D8C;
4177 GL_LUMINANCE_ALPHA16I_EXT = $8D8D;
4178 GL_RGBA8I_EXT = $8D8E;
4179 GL_RGB8I_EXT = $8D8F;
4180 GL_ALPHA8I_EXT = $8D90;
4181 GL_INTENSITY8I_EXT = $8D91;
4182 GL_LUMINANCE8I_EXT = $8D92;
4183 GL_LUMINANCE_ALPHA8I_EXT = $8D93;
4184 GL_RED_INTEGER_EXT = $8D94;
4185 GL_GREEN_INTEGER_EXT = $8D95;
4186 GL_BLUE_INTEGER_EXT = $8D96;
4187 GL_ALPHA_INTEGER_EXT = $8D97;
4188 GL_RGB_INTEGER_EXT = $8D98;
4189 GL_RGBA_INTEGER_EXT = $8D99;
4190 GL_BGR_INTEGER_EXT = $8D9A;
4191 GL_BGRA_INTEGER_EXT = $8D9B;
4192 GL_LUMINANCE_INTEGER_EXT = $8D9C;
4193 GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D;
4194
4195 // GL_EXT_texture_shared_exponent
4196 GL_RGB9_E5_EXT = $8C3D;
4197 GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E;
4198 GL_TEXTURE_SHARED_SIZE_EXT = $8C3F;
4199
4200 // GL_EXT_transform_feedback
4201 GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E;
4202 GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84;
4203 GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85;
4204 GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F;
4205 GL_INTERLEAVED_ATTRIBS_EXT = $8C8C;
4206 GL_SEPARATE_ATTRIBS_EXT = $8C8D;
4207 GL_PRIMITIVES_GENERATED_EXT = $8C87;
4208 GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88;
4209 GL_RASTERIZER_DISCARD_EXT = $8C89;
4210 GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A;
4211 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B;
4212 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80;
4213 GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83;
4214 GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F;
4215 GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76;
4216
4217 // GL_EXT_direct_state_access
4218 GL_PROGRAM_MATRIX_EXT = $8E2D;
4219 GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E;
4220 GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F;
4221
4222 // GL_EXT_texture_swizzle
4223 GL_TEXTURE_SWIZZLE_R_EXT = $8E42;
4224 GL_TEXTURE_SWIZZLE_G_EXT = $8E43;
4225 GL_TEXTURE_SWIZZLE_B_EXT = $8E44;
4226 GL_TEXTURE_SWIZZLE_A_EXT = $8E45;
4227 GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46;
4228
4229 // GL_EXT_provoking_vertex
4230 GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C;
4231 GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D;
4232 GL_LAST_VERTEX_CONVENTION_EXT = $8E4E;
4233 GL_PROVOKING_VERTEX_EXT = $8E4F;
4234
4235 // GL_EXT_texture_snorm
4236 GL_ALPHA_SNORM = $9010;
4237 GL_LUMINANCE_SNORM = $9011;
4238 GL_LUMINANCE_ALPHA_SNORM = $9012;
4239 GL_INTENSITY_SNORM = $9013;
4240 GL_ALPHA8_SNORM = $9014;
4241 GL_LUMINANCE8_SNORM = $9015;
4242 GL_LUMINANCE8_ALPHA8_SNORM = $9016;
4243 GL_INTENSITY8_SNORM = $9017;
4244 GL_ALPHA16_SNORM = $9018;
4245 GL_LUMINANCE16_SNORM = $9019;
4246 GL_LUMINANCE16_ALPHA16_SNORM = $901A;
4247 GL_INTENSITY16_SNORM = $901B;
4248 { reuse GL_R_SNORM }
4249 { reuse GL_RG_SNORM }
4250 { reuse GL_RGB_SNORM }
4251 { reuse GL_RGBA_SNORM }
4252 { reuse GL_R8_SNORM }
4253 { reuse GL_RG8_SNORM }
4254 { reuse GL_RGB8_SNORM }
4255 { reuse GL_RGBA8_SNORM }
4256 { reuse GL_R16_SNORM }
4257 { reuse GL_RG16_SNORM }
4258 { reuse GL_RGB16_SNORM }
4259 { reuse GL_RGBA16_SNORM }
4260 { reuse GL_SIGNED_NORMALIZED }
4261
4262 // GL_FfdMaskSGIX
4263 GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001;
4264 GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002;
4265
4266 // GL_HP_convolution_border_modes
4267 GL_IGNORE_BORDER_HP = $8150;
4268 GL_CONSTANT_BORDER_HP = $8151;
4269 GL_REPLICATE_BORDER_HP = $8153;
4270 GL_CONVOLUTION_BORDER_COLOR_HP = $8154;
4271
4272 // GL_HP_image_transform
4273 GL_IMAGE_SCALE_X_HP = $8155;
4274 GL_IMAGE_SCALE_Y_HP = $8156;
4275 GL_IMAGE_TRANSLATE_X_HP = $8157;
4276 GL_IMAGE_TRANSLATE_Y_HP = $8158;
4277 GL_IMAGE_ROTATE_ANGLE_HP = $8159;
4278 GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A;
4279 GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B;
4280 GL_IMAGE_MAG_FILTER_HP = $815C;
4281 GL_IMAGE_MIN_FILTER_HP = $815D;
4282 GL_IMAGE_CUBIC_WEIGHT_HP = $815E;
4283 GL_CUBIC_HP = $815F;
4284 GL_AVERAGE_HP = $8160;
4285 GL_IMAGE_TRANSFORM_2D_HP = $8161;
4286 GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162;
4287 GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163;
4288
4289 // GL_HP_occlusion_test
4290 GL_OCCLUSION_TEST_HP = $8165;
4291 GL_OCCLUSION_TEST_RESULT_HP = $8166;
4292
4293 // GL_HP_texture_lighting
4294 GL_TEXTURE_LIGHTING_MODE_HP = $8167;
4295 GL_TEXTURE_POST_SPECULAR_HP = $8168;
4296 GL_TEXTURE_PRE_SPECULAR_HP = $8169;
4297
4298 // GL_IBM_cull_vertex
4299 GL_CULL_VERTEX_IBM = 103050;
4300
4301 // GL_IBM_rasterpos_clip
4302 GL_RASTER_POSITION_UNCLIPPED_IBM = $19262;
4303
4304 // GL_IBM_texture_mirrored_repeat
4305 GL_MIRRORED_REPEAT_IBM = $8370;
4306
4307 // GL_IBM_vertex_array_lists
4308 GL_VERTEX_ARRAY_LIST_IBM = 103070;
4309 GL_NORMAL_ARRAY_LIST_IBM = 103071;
4310 GL_COLOR_ARRAY_LIST_IBM = 103072;
4311 GL_INDEX_ARRAY_LIST_IBM = 103073;
4312 GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074;
4313 GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075;
4314 GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076;
4315 GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077;
4316 GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080;
4317 GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081;
4318 GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082;
4319 GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083;
4320 GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084;
4321 GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085;
4322 GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086;
4323 GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087;
4324
4325 // GL_INGR_color_clamp
4326 GL_RED_MIN_CLAMP_INGR = $8560;
4327 GL_GREEN_MIN_CLAMP_INGR = $8561;
4328 GL_BLUE_MIN_CLAMP_INGR = $8562;
4329 GL_ALPHA_MIN_CLAMP_INGR = $8563;
4330 GL_RED_MAX_CLAMP_INGR = $8564;
4331 GL_GREEN_MAX_CLAMP_INGR = $8565;
4332 GL_BLUE_MAX_CLAMP_INGR = $8566;
4333 GL_ALPHA_MAX_CLAMP_INGR = $8567;
4334
4335 // GL_INGR_interlace_read
4336 GL_INTERLACE_READ_INGR = $8568;
4337
4338 // GL_INTEL_parallel_arrays
4339 GL_PARALLEL_ARRAYS_INTEL = $83F4;
4340 GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5;
4341 GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6;
4342 GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7;
4343 GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8;
4344
4345 // GL_NV_copy_depth_to_color
4346 GL_DEPTH_STENCIL_TO_RGBA_NV = $886E;
4347 GL_DEPTH_STENCIL_TO_BGRA_NV = $886F;
4348
4349 // GL_NV_depth_clamp
4350 GL_DEPTH_CLAMP_NV = $864F;
4351
4352 // GL_NV_evaluators
4353 GL_EVAL_2D_NV = $86C0;
4354 GL_EVAL_TRIANGULAR_2D_NV = $86C1;
4355 GL_MAP_TESSELLATION_NV = $86C2;
4356 GL_MAP_ATTRIB_U_ORDER_NV = $86C3;
4357 GL_MAP_ATTRIB_V_ORDER_NV = $86C4;
4358 GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5;
4359 GL_EVAL_VERTEX_ATTRIB0_NV = $86C6;
4360 GL_EVAL_VERTEX_ATTRIB1_NV = $86C7;
4361 GL_EVAL_VERTEX_ATTRIB2_NV = $86C8;
4362 GL_EVAL_VERTEX_ATTRIB3_NV = $86C9;
4363 GL_EVAL_VERTEX_ATTRIB4_NV = $86CA;
4364 GL_EVAL_VERTEX_ATTRIB5_NV = $86CB;
4365 GL_EVAL_VERTEX_ATTRIB6_NV = $86CC;
4366 GL_EVAL_VERTEX_ATTRIB7_NV = $86CD;
4367 GL_EVAL_VERTEX_ATTRIB8_NV = $86CE;
4368 GL_EVAL_VERTEX_ATTRIB9_NV = $86CF;
4369 GL_EVAL_VERTEX_ATTRIB10_NV = $86D0;
4370 GL_EVAL_VERTEX_ATTRIB11_NV = $86D1;
4371 GL_EVAL_VERTEX_ATTRIB12_NV = $86D2;
4372 GL_EVAL_VERTEX_ATTRIB13_NV = $86D3;
4373 GL_EVAL_VERTEX_ATTRIB14_NV = $86D4;
4374 GL_EVAL_VERTEX_ATTRIB15_NV = $86D5;
4375 GL_MAX_MAP_TESSELLATION_NV = $86D6;
4376 GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7;
4377
4378 // GL_NV_fence
4379 GL_ALL_COMPLETED_NV = $84F2;
4380 GL_FENCE_STATUS_NV = $84F3;
4381 GL_FENCE_CONDITION_NV = $84F4;
4382
4383 // GL_NV_float_buffer
4384 GL_FLOAT_R_NV = $8880;
4385 GL_FLOAT_RG_NV = $8881;
4386 GL_FLOAT_RGB_NV = $8882;
4387 GL_FLOAT_RGBA_NV = $8883;
4388 GL_FLOAT_R16_NV = $8884;
4389 GL_FLOAT_R32_NV = $8885;
4390 GL_FLOAT_RG16_NV = $8886;
4391 GL_FLOAT_RG32_NV = $8887;
4392 GL_FLOAT_RGB16_NV = $8888;
4393 GL_FLOAT_RGB32_NV = $8889;
4394 GL_FLOAT_RGBA16_NV = $888A;
4395 GL_FLOAT_RGBA32_NV = $888B;
4396 GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C;
4397 GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D;
4398 GL_FLOAT_RGBA_MODE_NV = $888E;
4399
4400 // GL_NV_fog_distance
4401 GL_FOG_DISTANCE_MODE_NV = $855A;
4402 GL_EYE_RADIAL_NV = $855B;
4403 GL_EYE_PLANE_ABSOLUTE_NV = $855C;
4404
4405 // GL_NV_fragment_program
4406 GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868;
4407 GL_FRAGMENT_PROGRAM_NV = $8870;
4408 GL_MAX_TEXTURE_COORDS_NV = $8871;
4409 GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872;
4410 GL_FRAGMENT_PROGRAM_BINDING_NV = $8873;
4411 GL_PROGRAM_ERROR_STRING_NV = $8874;
4412
4413 // GL_NV_half_float
4414 GL_HALF_FLOAT_NV = $140B;
4415
4416 // GL_NV_light_max_exponent
4417 GL_MAX_SHININESS_NV = $8504;
4418 GL_MAX_SPOT_EXPONENT_NV = $8505;
4419
4420 // GL_NV_multisample_filter_hint
4421 GL_MULTISAMPLE_FILTER_HINT_NV = $8534;
4422
4423 // GL_NV_occlusion_query
4424 GL_PIXEL_COUNTER_BITS_NV = $8864;
4425 GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865;
4426 GL_PIXEL_COUNT_NV = $8866;
4427 GL_PIXEL_COUNT_AVAILABLE_NV = $8867;
4428
4429 // GL_NV_packed_depth_stencil
4430 GL_DEPTH_STENCIL_NV = $84F9;
4431 GL_UNSIGNED_INT_24_8_NV = $84FA;
4432
4433 // GL_NV_pixel_data_range
4434 GL_WRITE_PIXEL_DATA_RANGE_NV = $8878;
4435 GL_READ_PIXEL_DATA_RANGE_NV = $8879;
4436 GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A;
4437 GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B;
4438 GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C;
4439 GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D;
4440
4441 // GL_NV_point_sprite
4442 GL_POINT_SPRITE_NV = $8861;
4443 GL_COORD_REPLACE_NV = $8862;
4444 GL_POINT_SPRITE_R_MODE_NV = $8863;
4445
4446 // GL_NV_primitive_restart
4447 GL_PRIMITIVE_RESTART_NV = $8558;
4448 GL_PRIMITIVE_RESTART_INDEX_NV = $8559;
4449
4450 // GL_NV_register_combiners
4451 GL_REGISTER_COMBINERS_NV = $8522;
4452 GL_VARIABLE_A_NV = $8523;
4453 GL_VARIABLE_B_NV = $8524;
4454 GL_VARIABLE_C_NV = $8525;
4455 GL_VARIABLE_D_NV = $8526;
4456 GL_VARIABLE_E_NV = $8527;
4457 GL_VARIABLE_F_NV = $8528;
4458 GL_VARIABLE_G_NV = $8529;
4459 GL_CONSTANT_COLOR0_NV = $852A;
4460 GL_CONSTANT_COLOR1_NV = $852B;
4461 GL_PRIMARY_COLOR_NV = $852C;
4462 GL_SECONDARY_COLOR_NV = $852D;
4463 GL_SPARE0_NV = $852E;
4464 GL_SPARE1_NV = $852F;
4465 GL_DISCARD_NV = $8530;
4466 GL_E_TIMES_F_NV = $8531;
4467 GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532;
4468 GL_UNSIGNED_IDENTITY_NV = $8536;
4469 GL_UNSIGNED_INVERT_NV = $8537;
4470 GL_EXPAND_NORMAL_NV = $8538;
4471 GL_EXPAND_NEGATE_NV = $8539;
4472 GL_HALF_BIAS_NORMAL_NV = $853A;
4473 GL_HALF_BIAS_NEGATE_NV = $853B;
4474 GL_SIGNED_IDENTITY_NV = $853C;
4475 GL_SIGNED_NEGATE_NV = $853D;
4476 GL_SCALE_BY_TWO_NV = $853E;
4477 GL_SCALE_BY_FOUR_NV = $853F;
4478 GL_SCALE_BY_ONE_HALF_NV = $8540;
4479 GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541;
4480 GL_COMBINER_INPUT_NV = $8542;
4481 GL_COMBINER_MAPPING_NV = $8543;
4482 GL_COMBINER_COMPONENT_USAGE_NV = $8544;
4483 GL_COMBINER_AB_DOT_PRODUCT_NV = $8545;
4484 GL_COMBINER_CD_DOT_PRODUCT_NV = $8546;
4485 GL_COMBINER_MUX_SUM_NV = $8547;
4486 GL_COMBINER_SCALE_NV = $8548;
4487 GL_COMBINER_BIAS_NV = $8549;
4488 GL_COMBINER_AB_OUTPUT_NV = $854A;
4489 GL_COMBINER_CD_OUTPUT_NV = $854B;
4490 GL_COMBINER_SUM_OUTPUT_NV = $854C;
4491 GL_MAX_GENERAL_COMBINERS_NV = $854D;
4492 GL_NUM_GENERAL_COMBINERS_NV = $854E;
4493 GL_COLOR_SUM_CLAMP_NV = $854F;
4494 GL_COMBINER0_NV = $8550;
4495 GL_COMBINER1_NV = $8551;
4496 GL_COMBINER2_NV = $8552;
4497 GL_COMBINER3_NV = $8553;
4498 GL_COMBINER4_NV = $8554;
4499 GL_COMBINER5_NV = $8555;
4500 GL_COMBINER6_NV = $8556;
4501 GL_COMBINER7_NV = $8557;
4502
4503 // GL_NV_register_combiners2
4504 GL_PER_STAGE_CONSTANTS_NV = $8535;
4505
4506 // GL_NV_texgen_emboss
4507 GL_EMBOSS_LIGHT_NV = $855D;
4508 GL_EMBOSS_CONSTANT_NV = $855E;
4509 GL_EMBOSS_MAP_NV = $855F;
4510
4511 // GL_NV_texgen_reflection
4512 GL_NORMAL_MAP_NV = $8511;
4513 GL_REFLECTION_MAP_NV = $8512;
4514
4515 // GL_NV_texture_env_combine4
4516 GL_COMBINE4_NV = $8503;
4517 GL_SOURCE3_RGB_NV = $8583;
4518 GL_SOURCE3_ALPHA_NV = $858B;
4519 GL_OPERAND3_RGB_NV = $8593;
4520 GL_OPERAND3_ALPHA_NV = $859B;
4521
4522 // GL_NV_texture_expand_normal
4523 GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F;
4524
4525 // GL_NV_texture_rectangle
4526 GL_TEXTURE_RECTANGLE_NV = $84F5;
4527 GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6;
4528 GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7;
4529 GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8;
4530
4531 // GL_NV_texture_shader
4532 GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C;
4533 GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D;
4534 GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E;
4535 GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9;
4536 GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA;
4537 GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB;
4538 GL_DSDT_MAG_INTENSITY_NV = $86DC;
4539 GL_SHADER_CONSISTENT_NV = $86DD;
4540 GL_TEXTURE_SHADER_NV = $86DE;
4541 GL_SHADER_OPERATION_NV = $86DF;
4542 GL_CULL_MODES_NV = $86E0;
4543 GL_OFFSET_TEXTURE_MATRIX_NV = $86E1;
4544 GL_OFFSET_TEXTURE_SCALE_NV = $86E2;
4545 GL_OFFSET_TEXTURE_BIAS_NV = $86E3;
4546 GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV;
4547 GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV;
4548 GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV;
4549 GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4;
4550 GL_CONST_EYE_NV = $86E5;
4551 GL_PASS_THROUGH_NV = $86E6;
4552 GL_CULL_FRAGMENT_NV = $86E7;
4553 GL_OFFSET_TEXTURE_2D_NV = $86E8;
4554 GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9;
4555 GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA;
4556 GL_DOT_PRODUCT_NV = $86EC;
4557 GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED;
4558 GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE;
4559 GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0;
4560 GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1;
4561 GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2;
4562 GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3;
4563 GL_HILO_NV = $86F4;
4564 GL_DSDT_NV = $86F5;
4565 GL_DSDT_MAG_NV = $86F6;
4566 GL_DSDT_MAG_VIB_NV = $86F7;
4567 GL_HILO16_NV = $86F8;
4568 GL_SIGNED_HILO_NV = $86F9;
4569 GL_SIGNED_HILO16_NV = $86FA;
4570 GL_SIGNED_RGBA_NV = $86FB;
4571 GL_SIGNED_RGBA8_NV = $86FC;
4572 GL_SIGNED_RGB_NV = $86FE;
4573 GL_SIGNED_RGB8_NV = $86FF;
4574 GL_SIGNED_LUMINANCE_NV = $8701;
4575 GL_SIGNED_LUMINANCE8_NV = $8702;
4576 GL_SIGNED_LUMINANCE_ALPHA_NV = $8703;
4577 GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704;
4578 GL_SIGNED_ALPHA_NV = $8705;
4579 GL_SIGNED_ALPHA8_NV = $8706;
4580 GL_SIGNED_INTENSITY_NV = $8707;
4581 GL_SIGNED_INTENSITY8_NV = $8708;
4582 GL_DSDT8_NV = $8709;
4583 GL_DSDT8_MAG8_NV = $870A;
4584 GL_DSDT8_MAG8_INTENSITY8_NV = $870B;
4585 GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C;
4586 GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D;
4587 GL_HI_SCALE_NV = $870E;
4588 GL_LO_SCALE_NV = $870F;
4589 GL_DS_SCALE_NV = $8710;
4590 GL_DT_SCALE_NV = $8711;
4591 GL_MAGNITUDE_SCALE_NV = $8712;
4592 GL_VIBRANCE_SCALE_NV = $8713;
4593 GL_HI_BIAS_NV = $8714;
4594 GL_LO_BIAS_NV = $8715;
4595 GL_DS_BIAS_NV = $8716;
4596 GL_DT_BIAS_NV = $8717;
4597 GL_MAGNITUDE_BIAS_NV = $8718;
4598 GL_VIBRANCE_BIAS_NV = $8719;
4599 GL_TEXTURE_BORDER_VALUES_NV = $871A;
4600 GL_TEXTURE_HI_SIZE_NV = $871B;
4601 GL_TEXTURE_LO_SIZE_NV = $871C;
4602 GL_TEXTURE_DS_SIZE_NV = $871D;
4603 GL_TEXTURE_DT_SIZE_NV = $871E;
4604 GL_TEXTURE_MAG_SIZE_NV = $871F;
4605
4606 // GL_NV_texture_shader2
4607 GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF;
4608
4609 // GL_NV_texture_shader3
4610 GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850;
4611 GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851;
4612 GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852;
4613 GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853;
4614 GL_OFFSET_HILO_TEXTURE_2D_NV = $8854;
4615 GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855;
4616 GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856;
4617 GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857;
4618 GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858;
4619 GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859;
4620 GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A;
4621 GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B;
4622 GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C;
4623 GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D;
4624 GL_HILO8_NV = $885E;
4625 GL_SIGNED_HILO8_NV = $885F;
4626 GL_FORCE_BLUE_TO_ONE_NV = $8860;
4627
4628 // GL_NV_vertex_array_range
4629 GL_VERTEX_ARRAY_RANGE_NV = $851D;
4630 GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E;
4631 GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F;
4632 GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520;
4633 GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521;
4634
4635 // GL_NV_vertex_array_range2
4636 GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533;
4637
4638 // GL_NV_vertex_program
4639 GL_VERTEX_PROGRAM_NV = $8620;
4640 GL_VERTEX_STATE_PROGRAM_NV = $8621;
4641 GL_ATTRIB_ARRAY_SIZE_NV = $8623;
4642 GL_ATTRIB_ARRAY_STRIDE_NV = $8624;
4643 GL_ATTRIB_ARRAY_TYPE_NV = $8625;
4644 GL_CURRENT_ATTRIB_NV = $8626;
4645 GL_PROGRAM_LENGTH_NV = $8627;
4646 GL_PROGRAM_STRING_NV = $8628;
4647 GL_MODELVIEW_PROJECTION_NV = $8629;
4648 GL_IDENTITY_NV = $862A;
4649 GL_INVERSE_NV = $862B;
4650 GL_TRANSPOSE_NV = $862C;
4651 GL_INVERSE_TRANSPOSE_NV = $862D;
4652 GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E;
4653 GL_MAX_TRACK_MATRICES_NV = $862F;
4654 GL_MATRIX0_NV = $8630;
4655 GL_MATRIX1_NV = $8631;
4656 GL_MATRIX2_NV = $8632;
4657 GL_MATRIX3_NV = $8633;
4658 GL_MATRIX4_NV = $8634;
4659 GL_MATRIX5_NV = $8635;
4660 GL_MATRIX6_NV = $8636;
4661 GL_MATRIX7_NV = $8637;
4662 GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640;
4663 GL_CURRENT_MATRIX_NV = $8641;
4664 GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642;
4665 GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643;
4666 GL_PROGRAM_PARAMETER_NV = $8644;
4667 GL_ATTRIB_ARRAY_POINTER_NV = $8645;
4668 GL_PROGRAM_TARGET_NV = $8646;
4669 GL_PROGRAM_RESIDENT_NV = $8647;
4670 GL_TRACK_MATRIX_NV = $8648;
4671 GL_TRACK_MATRIX_TRANSFORM_NV = $8649;
4672 GL_VERTEX_PROGRAM_BINDING_NV = $864A;
4673 GL_PROGRAM_ERROR_POSITION_NV = $864B;
4674 GL_VERTEX_ATTRIB_ARRAY0_NV = $8650;
4675 GL_VERTEX_ATTRIB_ARRAY1_NV = $8651;
4676 GL_VERTEX_ATTRIB_ARRAY2_NV = $8652;
4677 GL_VERTEX_ATTRIB_ARRAY3_NV = $8653;
4678 GL_VERTEX_ATTRIB_ARRAY4_NV = $8654;
4679 GL_VERTEX_ATTRIB_ARRAY5_NV = $8655;
4680 GL_VERTEX_ATTRIB_ARRAY6_NV = $8656;
4681 GL_VERTEX_ATTRIB_ARRAY7_NV = $8657;
4682 GL_VERTEX_ATTRIB_ARRAY8_NV = $8658;
4683 GL_VERTEX_ATTRIB_ARRAY9_NV = $8659;
4684 GL_VERTEX_ATTRIB_ARRAY10_NV = $865A;
4685 GL_VERTEX_ATTRIB_ARRAY11_NV = $865B;
4686 GL_VERTEX_ATTRIB_ARRAY12_NV = $865C;
4687 GL_VERTEX_ATTRIB_ARRAY13_NV = $865D;
4688 GL_VERTEX_ATTRIB_ARRAY14_NV = $865E;
4689 GL_VERTEX_ATTRIB_ARRAY15_NV = $865F;
4690 GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660;
4691 GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661;
4692 GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662;
4693 GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663;
4694 GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664;
4695 GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665;
4696 GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666;
4697 GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667;
4698 GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668;
4699 GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669;
4700 GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A;
4701 GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B;
4702 GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C;
4703 GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D;
4704 GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E;
4705 GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F;
4706 GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670;
4707 GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671;
4708 GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672;
4709 GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673;
4710 GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674;
4711 GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675;
4712 GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676;
4713 GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677;
4714 GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678;
4715 GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679;
4716 GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A;
4717 GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B;
4718 GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C;
4719 GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D;
4720 GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E;
4721 GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F;
4722
4723 // GL_NV_fragment_program2 and GL_NV_vertex_program2_option
4724 GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4;
4725 GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5;
4726
4727 // GL_NV_fragment_program2
4728 GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6;
4729 GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7;
4730 GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8;
4731
4732 // GL_NV_vertex_program3
4733 MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
4734
4735 // GL_NV_depth_buffer_float
4736 GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD;
4737 GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF;
4738
4739 // GL_NV_framebuffer_multisample_coverage
4740 GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB;
4741 GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10;
4742
4743 // GL_NV_geometry_program4
4744 GL_GEOMETRY_PROGRAM_NV = $8C26;
4745 GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27;
4746 GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28;
4747
4748 // GL_NV_gpu_program4
4749 GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906;
4750 GL_PROGRAM_RESULT_COMPONENTS_NV = $8907;
4751 GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908;
4752 GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909;
4753 GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5;
4754 GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6;
4755
4756 // GL_NV_parameter_buffer_object
4757 GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0;
4758 GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1;
4759 GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2;
4760 GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3;
4761 GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4;
4762
4763 // GL_NV_transform_feedback
4764 GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E;
4765 GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84;
4766 GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85;
4767 GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86;
4768 GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F;
4769 GL_INTERLEAVED_ATTRIBS_NV = $8C8C;
4770 GL_SEPARATE_ATTRIBS_NV = $8C8D;
4771 GL_PRIMITIVES_GENERATED_NV = $8C87;
4772 GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88;
4773 GL_RASTERIZER_DISCARD_NV = $8C89;
4774 GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A;
4775 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B;
4776 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80;
4777 GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E;
4778 GL_ACTIVE_VARYINGS_NV = $8C81;
4779 GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82;
4780 GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83;
4781 GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F;
4782 GL_BACK_PRIMARY_COLOR_NV = $8C77;
4783 GL_BACK_SECONDARY_COLOR_NV = $8C78;
4784 GL_TEXTURE_COORD_NV = $8C79;
4785 GL_CLIP_DISTANCE_NV = $8C7A;
4786 GL_VERTEX_ID_NV = $8C7B;
4787 GL_PRIMITIVE_ID_NV = $8C7C;
4788 GL_GENERIC_ATTRIB_NV = $8C7D;
4789
4790 // GL_NV_conditional_render
4791 GL_QUERY_WAIT_NV = $8E13;
4792 GL_QUERY_NO_WAIT_NV = $8E14;
4793 GL_QUERY_BY_REGION_WAIT_NV = $8E15;
4794 GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16;
4795
4796 // GL_NV_present_video
4797 GL_FRAME_NV = $8E26;
4798 GL_FIELDS_NV = $8E27;
4799 GL_CURRENT_TIME_NV = $8E28;
4800 GL_NUM_FILL_STREAMS_NV = $8E29;
4801 GL_PRESENT_TIME_NV = $8E2A;
4802 GL_PRESENT_DURATION_NV = $8E2B;
4803
4804 // GL_NV_explicit_multisample
4805 GL_SAMPLE_POSITION_NV = $8E50;
4806 GL_SAMPLE_MASK_NV = $8E51;
4807 GL_SAMPLE_MASK_VALUE_NV = $8E52;
4808 GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53;
4809 GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54;
4810 GL_TEXTURE_RENDERBUFFER_NV = $8E55;
4811 GL_SAMPLER_RENDERBUFFER_NV = $8E56;
4812 GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57;
4813 GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58;
4814 GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59;
4815
4816 // GL_NV_transform_feedback2
4817 GL_TRANSFORM_FEEDBACK_NV = $8E22;
4818 GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23;
4819 GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24;
4820 GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25;
4821
4822 // GL_OML_interlace
4823 GL_INTERLACE_OML = $8980;
4824 GL_INTERLACE_READ_OML = $8981;
4825
4826 // GL_OML_resample
4827 GL_PACK_RESAMPLE_OML = $8984;
4828 GL_UNPACK_RESAMPLE_OML = $8985;
4829 GL_RESAMPLE_REPLICATE_OML = $8986;
4830 GL_RESAMPLE_ZERO_FILL_OML = $8987;
4831 GL_RESAMPLE_AVERAGE_OML = $8988;
4832 GL_RESAMPLE_DECIMATE_OML = $8989;
4833
4834 // GL_OML_subsample
4835 GL_FORMAT_SUBSAMPLE_24_24_OML = $8982;
4836 GL_FORMAT_SUBSAMPLE_244_244_OML = $8983;
4837
4838 // GL_PGI_misc_hints
4839 GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8;
4840 GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD;
4841 GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE;
4842 GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202;
4843 GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203;
4844 GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204;
4845 GL_ALWAYS_FAST_HINT_PGI = $1A20C;
4846 GL_ALWAYS_SOFT_HINT_PGI = $1A20D;
4847 GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E;
4848 GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F;
4849 GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210;
4850 GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211;
4851 GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216;
4852 GL_STRICT_LIGHTING_HINT_PGI = $1A217;
4853 GL_STRICT_SCISSOR_HINT_PGI = $1A218;
4854 GL_FULL_STIPPLE_HINT_PGI = $1A219;
4855 GL_CLIP_NEAR_HINT_PGI = $1A220;
4856 GL_CLIP_FAR_HINT_PGI = $1A221;
4857 GL_WIDE_LINE_HINT_PGI = $1A222;
4858 GL_BACK_NORMALS_HINT_PGI = $1A223;
4859
4860 // GL_PGI_vertex_hints
4861 GL_VERTEX_DATA_HINT_PGI = $1A22A;
4862 GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B;
4863 GL_MATERIAL_SIDE_HINT_PGI = $1A22C;
4864 GL_MAX_VERTEX_HINT_PGI = $1A22D;
4865 GL_COLOR3_BIT_PGI = $00010000;
4866 GL_COLOR4_BIT_PGI = $00020000;
4867 GL_EDGEFLAG_BIT_PGI = $00040000;
4868 GL_INDEX_BIT_PGI = $00080000;
4869 GL_MAT_AMBIENT_BIT_PGI = $00100000;
4870 GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000;
4871 GL_MAT_DIFFUSE_BIT_PGI = $00400000;
4872 GL_MAT_EMISSION_BIT_PGI = $00800000;
4873 GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000;
4874 GL_MAT_SHININESS_BIT_PGI = $02000000;
4875 GL_MAT_SPECULAR_BIT_PGI = $04000000;
4876 GL_NORMAL_BIT_PGI = $08000000;
4877 GL_TEXCOORD1_BIT_PGI = $10000000;
4878 GL_TEXCOORD2_BIT_PGI = $20000000;
4879 GL_TEXCOORD3_BIT_PGI = $40000000;
4880 GL_TEXCOORD4_BIT_PGI = $80000000;
4881 GL_VERTEX23_BIT_PGI = $00000004;
4882 GL_VERTEX4_BIT_PGI = $00000008;
4883
4884 // GL_REND_screen_coordinates
4885 GL_SCREEN_COORDINATES_REND = $8490;
4886 GL_INVERTED_SCREEN_W_REND = $8491;
4887
4888 // GL_S3_s3tc
4889 GL_RGB_S3TC = $83A0;
4890 GL_RGB4_S3TC = $83A1;
4891 GL_RGBA_S3TC = $83A2;
4892 GL_RGBA4_S3TC = $83A3;
4893
4894 // GL_SGIS_detail_texture
4895 GL_DETAIL_TEXTURE_2D_SGIS = $8095;
4896 GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096;
4897 GL_LINEAR_DETAIL_SGIS = $8097;
4898 GL_LINEAR_DETAIL_ALPHA_SGIS = $8098;
4899 GL_LINEAR_DETAIL_COLOR_SGIS = $8099;
4900 GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A;
4901 GL_DETAIL_TEXTURE_MODE_SGIS = $809B;
4902 GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C;
4903
4904 // GL_SGIS_fog_function
4905 GL_FOG_FUNC_SGIS = $812A;
4906 GL_FOG_FUNC_POINTS_SGIS = $812B;
4907 GL_MAX_FOG_FUNC_POINTS_SGIS = $812C;
4908
4909 // GL_SGIS_generate_mipmap
4910 GL_GENERATE_MIPMAP_SGIS = $8191;
4911 GL_GENERATE_MIPMAP_HINT_SGIS = $8192;
4912
4913 // GL_SGIS_multisample
4914 GL_MULTISAMPLE_SGIS = $809D;
4915 GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E;
4916 GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F;
4917 GL_SAMPLE_MASK_SGIS = $80A0;
4918 GL_1PASS_SGIS = $80A1;
4919 GL_2PASS_0_SGIS = $80A2;
4920 GL_2PASS_1_SGIS = $80A3;
4921 GL_4PASS_0_SGIS = $80A4;
4922 GL_4PASS_1_SGIS = $80A5;
4923 GL_4PASS_2_SGIS = $80A6;
4924 GL_4PASS_3_SGIS = $80A7;
4925 GL_SAMPLE_BUFFERS_SGIS = $80A8;
4926 GL_SAMPLES_SGIS = $80A9;
4927 GL_SAMPLE_MASK_VALUE_SGIS = $80AA;
4928 GL_SAMPLE_MASK_INVERT_SGIS = $80AB;
4929 GL_SAMPLE_PATTERN_SGIS = $80AC;
4930
4931 // GL_SGIS_pixel_texture
4932 GL_PIXEL_TEXTURE_SGIS = $8353;
4933 GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354;
4934 GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355;
4935 GL_PIXEL_GROUP_COLOR_SGIS = $8356;
4936
4937 // GL_SGIS_point_line_texgen
4938 GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0;
4939 GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1;
4940 GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2;
4941 GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3;
4942 GL_EYE_POINT_SGIS = $81F4;
4943 GL_OBJECT_POINT_SGIS = $81F5;
4944 GL_EYE_LINE_SGIS = $81F6;
4945 GL_OBJECT_LINE_SGIS = $81F7;
4946
4947 // GL_SGIS_point_parameters
4948 GL_POINT_SIZE_MIN_SGIS = $8126;
4949 GL_POINT_SIZE_MAX_SGIS = $8127;
4950 GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128;
4951 GL_DISTANCE_ATTENUATION_SGIS = $8129;
4952
4953 // GL_SGIS_sharpen_texture
4954 GL_LINEAR_SHARPEN_SGIS = $80AD;
4955 GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE;
4956 GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF;
4957 GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0;
4958
4959 // GL_SGIS_texture4D
4960 GL_PACK_SKIP_VOLUMES_SGIS = $8130;
4961 GL_PACK_IMAGE_DEPTH_SGIS = $8131;
4962 GL_UNPACK_SKIP_VOLUMES_SGIS = $8132;
4963 GL_UNPACK_IMAGE_DEPTH_SGIS = $8133;
4964 GL_TEXTURE_4D_SGIS = $8134;
4965 GL_PROXY_TEXTURE_4D_SGIS = $8135;
4966 GL_TEXTURE_4DSIZE_SGIS = $8136;
4967 GL_TEXTURE_WRAP_Q_SGIS = $8137;
4968 GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138;
4969 GL_TEXTURE_4D_BINDING_SGIS = $814F;
4970
4971 // GL_SGIS_texture_color_mask
4972 GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;
4973
4974 // GL_SGIS_texture_edge_clamp
4975 GL_CLAMP_TO_EDGE_SGIS = $812F;
4976
4977 // GL_SGIS_texture_filter4
4978 GL_FILTER4_SGIS = $8146;
4979 GL_TEXTURE_FILTER4_SIZE_SGIS = $8147;
4980
4981 // GL_SGIS_texture_lod
4982 GL_TEXTURE_MIN_LOD_SGIS = $813A;
4983 GL_TEXTURE_MAX_LOD_SGIS = $813B;
4984 GL_TEXTURE_BASE_LEVEL_SGIS = $813C;
4985 GL_TEXTURE_MAX_LEVEL_SGIS = $813D;
4986
4987 // GL_SGIS_texture_select
4988 GL_DUAL_ALPHA4_SGIS = $8110;
4989 GL_DUAL_ALPHA8_SGIS = $8111;
4990 GL_DUAL_ALPHA12_SGIS = $8112;
4991 GL_DUAL_ALPHA16_SGIS = $8113;
4992 GL_DUAL_LUMINANCE4_SGIS = $8114;
4993 GL_DUAL_LUMINANCE8_SGIS = $8115;
4994 GL_DUAL_LUMINANCE12_SGIS = $8116;
4995 GL_DUAL_LUMINANCE16_SGIS = $8117;
4996 GL_DUAL_INTENSITY4_SGIS = $8118;
4997 GL_DUAL_INTENSITY8_SGIS = $8119;
4998 GL_DUAL_INTENSITY12_SGIS = $811A;
4999 GL_DUAL_INTENSITY16_SGIS = $811B;
5000 GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C;
5001 GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D;
5002 GL_QUAD_ALPHA4_SGIS = $811E;
5003 GL_QUAD_ALPHA8_SGIS = $811F;
5004 GL_QUAD_LUMINANCE4_SGIS = $8120;
5005 GL_QUAD_LUMINANCE8_SGIS = $8121;
5006 GL_QUAD_INTENSITY4_SGIS = $8122;
5007 GL_QUAD_INTENSITY8_SGIS = $8123;
5008 GL_DUAL_TEXTURE_SELECT_SGIS = $8124;
5009 GL_QUAD_TEXTURE_SELECT_SGIS = $8125;
5010
5011 // GL_SGIX_async
5012 GL_ASYNC_MARKER_SGIX = $8329;
5013
5014 // GL_SGIX_async_histogram
5015 GL_ASYNC_HISTOGRAM_SGIX = $832C;
5016 GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D;
5017
5018 // GL_SGIX_async_pixel
5019 GL_ASYNC_TEX_IMAGE_SGIX = $835C;
5020 GL_ASYNC_DRAW_PIXELS_SGIX = $835D;
5021 GL_ASYNC_READ_PIXELS_SGIX = $835E;
5022 GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F;
5023 GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360;
5024 GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361;
5025
5026 // GL_SGIX_blend_alpha_minmax
5027 GL_ALPHA_MIN_SGIX = $8320;
5028 GL_ALPHA_MAX_SGIX = $8321;
5029
5030 // GL_SGIX_calligraphic_fragment
5031 GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183;
5032
5033 // GL_SGIX_clipmap
5034 GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170;
5035 GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171;
5036 GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172;
5037 GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173;
5038 GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174;
5039 GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175;
5040 GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176;
5041 GL_MAX_CLIPMAP_DEPTH_SGIX = $8177;
5042 GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178;
5043 GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D;
5044 GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E;
5045 GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F;
5046
5047 // GL_SGIX_convolution_accuracy
5048 GL_CONVOLUTION_HINT_SGIX = $8316;
5049
5050 // GL_SGIX_depth_texture
5051 GL_DEPTH_COMPONENT16_SGIX = $81A5;
5052 GL_DEPTH_COMPONENT24_SGIX = $81A6;
5053 GL_DEPTH_COMPONENT32_SGIX = $81A7;
5054
5055 // GL_SGIX_fog_offset
5056 GL_FOG_OFFSET_SGIX = $8198;
5057 GL_FOG_OFFSET_VALUE_SGIX = $8199;
5058
5059 // GL_SGIX_fog_scale
5060 GL_FOG_SCALE_SGIX = $81FC;
5061 GL_FOG_SCALE_VALUE_SGIX = $81FD;
5062
5063 // GL_SGIX_fragment_lighting
5064 GL_FRAGMENT_LIGHTING_SGIX = $8400;
5065 GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401;
5066 GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402;
5067 GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403;
5068 GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404;
5069 GL_MAX_ACTIVE_LIGHTS_SGIX = $8405;
5070 GL_CURRENT_RASTER_NORMAL_SGIX = $8406;
5071 GL_LIGHT_ENV_MODE_SGIX = $8407;
5072 GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408;
5073 GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409;
5074 GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A;
5075 GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B;
5076 GL_FRAGMENT_LIGHT0_SGIX = $840C;
5077 GL_FRAGMENT_LIGHT1_SGIX = $840D;
5078 GL_FRAGMENT_LIGHT2_SGIX = $840E;
5079 GL_FRAGMENT_LIGHT3_SGIX = $840F;
5080 GL_FRAGMENT_LIGHT4_SGIX = $8410;
5081 GL_FRAGMENT_LIGHT5_SGIX = $8411;
5082 GL_FRAGMENT_LIGHT6_SGIX = $8412;
5083 GL_FRAGMENT_LIGHT7_SGIX = $8413;
5084
5085 // GL_SGIX_framezoom
5086 GL_FRAMEZOOM_SGIX = $818B;
5087 GL_FRAMEZOOM_FACTOR_SGIX = $818C;
5088 GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D;
5089
5090 // GL_SGIX_impact_pixel_texture
5091 GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184;
5092 GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185;
5093 GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186;
5094 GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187;
5095 GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188;
5096 GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189;
5097 GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A;
5098
5099 // GL_SGIX_instruments
5100 GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180;
5101 GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181;
5102
5103 // GL_SGIX_interlace
5104 GL_INTERLACE_SGIX = $8094;
5105
5106 // GL_SGIX_ir_instrument1
5107 GL_IR_INSTRUMENT1_SGIX = $817F;
5108
5109 // GL_SGIX_list_priority
5110 GL_LIST_PRIORITY_SGIX = $8182;
5111
5112 // GL_SGIX_pixel_texture
5113 GL_PIXEL_TEX_GEN_SGIX = $8139;
5114 GL_PIXEL_TEX_GEN_MODE_SGIX = $832B;
5115
5116 // GL_SGIX_pixel_tiles
5117 GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E;
5118 GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F;
5119 GL_PIXEL_TILE_WIDTH_SGIX = $8140;
5120 GL_PIXEL_TILE_HEIGHT_SGIX = $8141;
5121 GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142;
5122 GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143;
5123 GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144;
5124 GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145;
5125
5126 // GL_SGIX_polynomial_ffd
5127 GL_GEOMETRY_DEFORMATION_SGIX = $8194;
5128 GL_TEXTURE_DEFORMATION_SGIX = $8195;
5129 GL_DEFORMATIONS_MASK_SGIX = $8196;
5130 GL_MAX_DEFORMATION_ORDER_SGIX = $8197;
5131
5132 // GL_SGIX_reference_plane
5133 GL_REFERENCE_PLANE_SGIX = $817D;
5134 GL_REFERENCE_PLANE_EQUATION_SGIX = $817E;
5135
5136 // GL_SGIX_resample
5137 GL_PACK_RESAMPLE_SGIX = $842C;
5138 GL_UNPACK_RESAMPLE_SGIX = $842D;
5139 GL_RESAMPLE_REPLICATE_SGIX = $842E;
5140 GL_RESAMPLE_ZERO_FILL_SGIX = $842F;
5141 GL_RESAMPLE_DECIMATE_SGIX = $8430;
5142
5143 // GL_SGIX_scalebias_hint
5144 GL_SCALEBIAS_HINT_SGIX = $8322;
5145
5146 // GL_SGIX_shadow
5147 GL_TEXTURE_COMPARE_SGIX = $819A;
5148 GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B;
5149 GL_TEXTURE_LEQUAL_R_SGIX = $819C;
5150 GL_TEXTURE_GEQUAL_R_SGIX = $819D;
5151
5152 // GL_SGIX_shadow_ambient
5153 GL_SHADOW_AMBIENT_SGIX = $80BF;
5154
5155 // GL_SGIX_sprite
5156 GL_SPRITE_SGIX = $8148;
5157 GL_SPRITE_MODE_SGIX = $8149;
5158 GL_SPRITE_AXIS_SGIX = $814A;
5159 GL_SPRITE_TRANSLATION_SGIX = $814B;
5160 GL_SPRITE_AXIAL_SGIX = $814C;
5161 GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D;
5162 GL_SPRITE_EYE_ALIGNED_SGIX = $814E;
5163
5164 // GL_SGIX_subsample
5165 GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0;
5166 GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1;
5167 GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2;
5168 GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3;
5169 GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4;
5170
5171 // GL_SGIX_texture_add_env
5172 GL_TEXTURE_ENV_BIAS_SGIX = $80BE;
5173
5174 // GL_SGIX_texture_coordinate_clamp
5175 GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369;
5176 GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A;
5177 GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B;
5178
5179 // GL_SGIX_texture_lod_bias
5180 GL_TEXTURE_LOD_BIAS_S_SGIX = $818E;
5181 GL_TEXTURE_LOD_BIAS_T_SGIX = $818F;
5182 GL_TEXTURE_LOD_BIAS_R_SGIX = $8190;
5183
5184 // GL_SGIX_texture_multi_buffer
5185 GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E;
5186
5187 // GL_SGIX_texture_scale_bias
5188 GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179;
5189 GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A;
5190 GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B;
5191 GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C;
5192
5193 // GL_SGIX_vertex_preclip
5194 GL_VERTEX_PRECLIP_SGIX = $83EE;
5195 GL_VERTEX_PRECLIP_HINT_SGIX = $83EF;
5196
5197 // GL_SGIX_ycrcb
5198 GL_YCRCB_422_SGIX = $81BB;
5199 GL_YCRCB_444_SGIX = $81BC;
5200
5201 // GL_SGIX_ycrcba
5202 GL_YCRCB_SGIX = $8318;
5203 GL_YCRCBA_SGIX = $8319;
5204
5205 // GL_SGI_color_matrix
5206 GL_COLOR_MATRIX_SGI = $80B1;
5207 GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2;
5208 GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3;
5209 GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4;
5210 GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5;
5211 GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6;
5212 GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7;
5213 GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8;
5214 GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9;
5215 GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA;
5216 GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB;
5217
5218 // GL_SGI_color_table
5219 GL_COLOR_TABLE_SGI = $80D0;
5220 GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1;
5221 GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2;
5222 GL_PROXY_COLOR_TABLE_SGI = $80D3;
5223 GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4;
5224 GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5;
5225 GL_COLOR_TABLE_SCALE_SGI = $80D6;
5226 GL_COLOR_TABLE_BIAS_SGI = $80D7;
5227 GL_COLOR_TABLE_FORMAT_SGI = $80D8;
5228 GL_COLOR_TABLE_WIDTH_SGI = $80D9;
5229 GL_COLOR_TABLE_RED_SIZE_SGI = $80DA;
5230 GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB;
5231 GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC;
5232 GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD;
5233 GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE;
5234 GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF;
5235
5236 // GL_SGI_depth_pass_instrument
5237 GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310;
5238 GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311;
5239 GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312;
5240
5241 // GL_SGI_texture_color_table
5242 GL_TEXTURE_COLOR_TABLE_SGI = $80BC;
5243 GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD;
5244
5245 // GL_SUNX_constant_data
5246 GL_UNPACK_CONSTANT_DATA_SUNX = $81D5;
5247 GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6;
5248
5249 // GL_SUN_convolution_border_modes
5250 GL_WRAP_BORDER_SUN = $81D4;
5251
5252 // GL_SUN_global_alpha
5253 GL_GLOBAL_ALPHA_SUN = $81D9;
5254 GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA;
5255
5256 // GL_SUN_mesh_array
5257 GL_QUAD_MESH_SUN = $8614;
5258 GL_TRIANGLE_MESH_SUN = $8615;
5259
5260 // GL_SUN_slice_accum
5261 GL_SLICE_ACCUM_SUN = $85CC;
5262
5263 // GL_SUN_triangle_list
5264 GL_RESTART_SUN = $0001;
5265 GL_REPLACE_MIDDLE_SUN = $0002;
5266 GL_REPLACE_OLDEST_SUN = $0003;
5267 GL_TRIANGLE_LIST_SUN = $81D7;
5268 GL_REPLACEMENT_CODE_SUN = $81D8;
5269 GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0;
5270 GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1;
5271 GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2;
5272 GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3;
5273 GL_R1UI_V3F_SUN = $85C4;
5274 GL_R1UI_C4UB_V3F_SUN = $85C5;
5275 GL_R1UI_C3F_V3F_SUN = $85C6;
5276 GL_R1UI_N3F_V3F_SUN = $85C7;
5277 GL_R1UI_C4F_N3F_V3F_SUN = $85C8;
5278 GL_R1UI_T2F_V3F_SUN = $85C9;
5279 GL_R1UI_T2F_N3F_V3F_SUN = $85CA;
5280 GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB;
5281
5282 // GL_WIN_phong_shading
5283 GL_PHONG_WIN = $80EA;
5284 GL_PHONG_HINT_WIN = $80EB;
5285
5286 // GL_WIN_specular_fog
5287 GL_FOG_SPECULAR_TEXTURE_WIN = $80EC;
5288
5289 // GL_ARB_vertex_shader
5290 GL_VERTEX_SHADER_ARB = $8B31;
5291 GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A;
5292 GL_MAX_VARYING_FLOATS_ARB = $8B4B;
5293 GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
5294 GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D;
5295 GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89;
5296 GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A;
5297
5298 // GL_ARB_fragment_shader
5299 GL_FRAGMENT_SHADER_ARB = $8B30;
5300 GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4
5301 GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4
5302
5303 // GL_ARB_occlusion_query
5304 GL_SAMPLES_PASSED_ARB = $8914;
5305 GL_QUERY_COUNTER_BITS_ARB = $8864;
5306 GL_CURRENT_QUERY_ARB = $8865;
5307 GL_QUERY_RESULT_ARB = $8866;
5308 GL_QUERY_RESULT_AVAILABLE_ARB = $8867;
5309
5310 // GL_ARB_point_sprite
5311 GL_POINT_SPRITE_ARB = $8861;
5312 GL_COORD_REPLACE_ARB = $8862;
5313
5314 // GL_ARB_shading_language_100
5315 GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4
5316
5317 // GL_ARB_shader_objects
5318 GL_PROGRAM_OBJECT_ARB = $8B40;
5319
5320 GL_OBJECT_TYPE_ARB = $8B4E;
5321 GL_OBJECT_SUBTYPE_ARB = $8B4F;
5322 GL_OBJECT_DELETE_STATUS_ARB = $8B80;
5323 GL_OBJECT_COMPILE_STATUS_ARB = $8B81;
5324 GL_OBJECT_LINK_STATUS_ARB = $8B82;
5325 GL_OBJECT_VALIDATE_STATUS_ARB = $8B83;
5326 GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84;
5327 GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85;
5328 GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86;
5329 GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87;
5330 GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88;
5331
5332 GL_SHADER_OBJECT_ARB = $8B48;
5333
5334 GL_FLOAT_VEC2_ARB = $8B50;
5335 GL_FLOAT_VEC3_ARB = $8B51;
5336 GL_FLOAT_VEC4_ARB = $8B52;
5337 GL_INT_VEC2_ARB = $8B53;
5338 GL_INT_VEC3_ARB = $8B54;
5339 GL_INT_VEC4_ARB = $8B55;
5340 GL_BOOL_ARB = $8B56;
5341 GL_BOOL_VEC2_ARB = $8B57;
5342 GL_BOOL_VEC3_ARB = $8B58;
5343 GL_BOOL_VEC4_ARB = $8B59;
5344 GL_FLOAT_MAT2_ARB = $8B5A;
5345 GL_FLOAT_MAT3_ARB = $8B5B;
5346 GL_FLOAT_MAT4_ARB = $8B5C;
5347 GL_SAMPLER_1D_ARB = $8B5D;
5348 GL_SAMPLER_2D_ARB = $8B5E;
5349 GL_SAMPLER_3D_ARB = $8B5F;
5350 GL_SAMPLER_CUBE_ARB = $8B60;
5351 GL_SAMPLER_1D_SHADOW_ARB = $8B61;
5352 GL_SAMPLER_2D_SHADOW_ARB = $8B62;
5353 GL_SAMPLER_2D_RECT_ARB = $8B63;
5354 GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64;
5355
5356 // WGL_3DFX_multisample
5357 WGL_SAMPLE_BUFFERS_3DFX = $2060;
5358 WGL_SAMPLES_3DFX = $2061;
5359
5360 // WGL_ARB_buffer_region
5361 WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001;
5362 WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002;
5363 WGL_DEPTH_BUFFER_BIT_ARB = $00000004;
5364 WGL_STENCIL_BUFFER_BIT_ARB = $00000008;
5365
5366 // WGL_ARB_make_current_read
5367 ERROR_INVALID_PIXEL_TYPE_ARB = $2043;
5368 ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054;
5369
5370 // WGL_ARB_multisample
5371 WGL_SAMPLE_BUFFERS_ARB = $2041;
5372 WGL_SAMPLES_ARB = $2042;
5373
5374 // WGL_ARB_pbuffer
5375 WGL_DRAW_TO_PBUFFER_ARB = $202D;
5376 WGL_MAX_PBUFFER_PIXELS_ARB = $202E;
5377 WGL_MAX_PBUFFER_WIDTH_ARB = $202F;
5378 WGL_MAX_PBUFFER_HEIGHT_ARB = $2030;
5379 WGL_PBUFFER_LARGEST_ARB = $2033;
5380 WGL_PBUFFER_WIDTH_ARB = $2034;
5381 WGL_PBUFFER_HEIGHT_ARB = $2035;
5382 WGL_PBUFFER_LOST_ARB = $2036;
5383
5384 // WGL_ARB_pixel_format
5385 WGL_NUMBER_PIXEL_FORMATS_ARB = $2000;
5386 WGL_DRAW_TO_WINDOW_ARB = $2001;
5387 WGL_DRAW_TO_BITMAP_ARB = $2002;
5388 WGL_ACCELERATION_ARB = $2003;
5389 WGL_NEED_PALETTE_ARB = $2004;
5390 WGL_NEED_SYSTEM_PALETTE_ARB = $2005;
5391 WGL_SWAP_LAYER_BUFFERS_ARB = $2006;
5392 WGL_SWAP_METHOD_ARB = $2007;
5393 WGL_NUMBER_OVERLAYS_ARB = $2008;
5394 WGL_NUMBER_UNDERLAYS_ARB = $2009;
5395 WGL_TRANSPARENT_ARB = $200A;
5396 WGL_TRANSPARENT_RED_VALUE_ARB = $2037;
5397 WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038;
5398 WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039;
5399 WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A;
5400 WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B;
5401 WGL_SHARE_DEPTH_ARB = $200C;
5402 WGL_SHARE_STENCIL_ARB = $200D;
5403 WGL_SHARE_ACCUM_ARB = $200E;
5404 WGL_SUPPORT_GDI_ARB = $200F;
5405 WGL_SUPPORT_OPENGL_ARB = $2010;
5406 WGL_DOUBLE_BUFFER_ARB = $2011;
5407 WGL_STEREO_ARB = $2012;
5408 WGL_PIXEL_TYPE_ARB = $2013;
5409 WGL_COLOR_BITS_ARB = $2014;
5410 WGL_RED_BITS_ARB = $2015;
5411 WGL_RED_SHIFT_ARB = $2016;
5412 WGL_GREEN_BITS_ARB = $2017;
5413 WGL_GREEN_SHIFT_ARB = $2018;
5414 WGL_BLUE_BITS_ARB = $2019;
5415 WGL_BLUE_SHIFT_ARB = $201A;
5416 WGL_ALPHA_BITS_ARB = $201B;
5417 WGL_ALPHA_SHIFT_ARB = $201C;
5418 WGL_ACCUM_BITS_ARB = $201D;
5419 WGL_ACCUM_RED_BITS_ARB = $201E;
5420 WGL_ACCUM_GREEN_BITS_ARB = $201F;
5421 WGL_ACCUM_BLUE_BITS_ARB = $2020;
5422 WGL_ACCUM_ALPHA_BITS_ARB = $2021;
5423 WGL_DEPTH_BITS_ARB = $2022;
5424 WGL_STENCIL_BITS_ARB = $2023;
5425 WGL_AUX_BUFFERS_ARB = $2024;
5426 WGL_NO_ACCELERATION_ARB = $2025;
5427 WGL_GENERIC_ACCELERATION_ARB = $2026;
5428 WGL_FULL_ACCELERATION_ARB = $2027;
5429 WGL_SWAP_EXCHANGE_ARB = $2028;
5430 WGL_SWAP_COPY_ARB = $2029;
5431 WGL_SWAP_UNDEFINED_ARB = $202A;
5432 WGL_TYPE_RGBA_ARB = $202B;
5433 WGL_TYPE_COLORINDEX_ARB = $202C;
5434
5435 // WGL_ARB_pixel_format_float
5436 WGL_RGBA_FLOAT_MODE_ARB = $8820;
5437 WGL_CLAMP_VERTEX_COLOR_ARB = $891A;
5438 WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
5439 WGL_CLAMP_READ_COLOR_ARB = $891C;
5440 WGL_FIXED_ONLY_ARB = $891D;
5441
5442 // WGL_ARB_render_texture
5443 WGL_BIND_TO_TEXTURE_RGB_ARB = $2070;
5444 WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071;
5445 WGL_TEXTURE_FORMAT_ARB = $2072;
5446 WGL_TEXTURE_TARGET_ARB = $2073;
5447 WGL_MIPMAP_TEXTURE_ARB = $2074;
5448 WGL_TEXTURE_RGB_ARB = $2075;
5449 WGL_TEXTURE_RGBA_ARB = $2076;
5450 WGL_NO_TEXTURE_ARB = $2077;
5451 WGL_TEXTURE_CUBE_MAP_ARB = $2078;
5452 WGL_TEXTURE_1D_ARB = $2079;
5453 WGL_TEXTURE_2D_ARB = $207A;
5454 WGL_MIPMAP_LEVEL_ARB = $207B;
5455 WGL_CUBE_MAP_FACE_ARB = $207C;
5456 WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D;
5457 WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E;
5458 WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F;
5459 WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080;
5460 WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081;
5461 WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082;
5462 WGL_FRONT_LEFT_ARB = $2083;
5463 WGL_FRONT_RIGHT_ARB = $2084;
5464 WGL_BACK_LEFT_ARB = $2085;
5465 WGL_BACK_RIGHT_ARB = $2086;
5466 WGL_AUX0_ARB = $2087;
5467 WGL_AUX1_ARB = $2088;
5468 WGL_AUX2_ARB = $2089;
5469 WGL_AUX3_ARB = $208A;
5470 WGL_AUX4_ARB = $208B;
5471 WGL_AUX5_ARB = $208C;
5472 WGL_AUX6_ARB = $208D;
5473 WGL_AUX7_ARB = $208E;
5474 WGL_AUX8_ARB = $208F;
5475 WGL_AUX9_ARB = $2090;
5476
5477 // WGL_ARB_create_context
5478 WGL_CONTEXT_DEBUG_BIT_ARB = $00000001;
5479 WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
5480 WGL_CONTEXT_MAJOR_VERSION_ARB = $2091;
5481 WGL_CONTEXT_MINOR_VERSION_ARB = $2092;
5482 WGL_CONTEXT_LAYER_PLANE_ARB = $2093;
5483 WGL_CONTEXT_FLAGS_ARB = $2094;
5484 ERROR_INVALID_VERSION_ARB = $2095;
5485
5486 // WGL_ARB_create_context_profile
5487 WGL_CONTEXT_PROFILE_MASK_ARB = $9126;
5488 WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
5489 WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
5490 ERROR_INVALID_PROFILE_ARB = $2096;
5491
5492 // WGL_ATI_pixel_format_float
5493 WGL_TYPE_RGBA_FLOAT_ATI = $21A0;
5494 GL_TYPE_RGBA_FLOAT_ATI = $8820;
5495 GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835;
5496
5497 // WGL_AMD_gpu_association
5498 WGL_GPU_VENDOR_AMD = $1F00;
5499 WGL_GPU_RENDERER_STRING_AMD = $1F01;
5500 WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02;
5501 WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2;
5502 WGL_GPU_RAM_AMD = $21A3;
5503 WGL_GPU_CLOCK_AMD = $21A4;
5504 WGL_GPU_NUM_PIPES_AMD = $21A5;
5505 WGL_GPU_NUM_SIMD_AMD = $21A6;
5506 WGL_GPU_NUM_RB_AMD = $21A7;
5507 WGL_GPU_NUM_SPI_AMD = $21A8;
5508
5509 // WGL_EXT_depth_float
5510 WGL_DEPTH_FLOAT_EXT = $2040;
5511
5512 // WGL_EXT_make_current_read
5513 ERROR_INVALID_PIXEL_TYPE_EXT = $2043;
5514
5515 // WGL_EXT_multisample
5516 WGL_SAMPLE_BUFFERS_EXT = $2041;
5517 WGL_SAMPLES_EXT = $2042;
5518
5519 // WGL_EXT_pbuffer
5520 WGL_DRAW_TO_PBUFFER_EXT = $202D;
5521 WGL_MAX_PBUFFER_PIXELS_EXT = $202E;
5522 WGL_MAX_PBUFFER_WIDTH_EXT = $202F;
5523 WGL_MAX_PBUFFER_HEIGHT_EXT = $2030;
5524 WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031;
5525 WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032;
5526 WGL_PBUFFER_LARGEST_EXT = $2033;
5527 WGL_PBUFFER_WIDTH_EXT = $2034;
5528 WGL_PBUFFER_HEIGHT_EXT = $2035;
5529
5530 // WGL_EXT_pixel_format
5531 WGL_NUMBER_PIXEL_FORMATS_EXT = $2000;
5532 WGL_DRAW_TO_WINDOW_EXT = $2001;
5533 WGL_DRAW_TO_BITMAP_EXT = $2002;
5534 WGL_ACCELERATION_EXT = $2003;
5535 WGL_NEED_PALETTE_EXT = $2004;
5536 WGL_NEED_SYSTEM_PALETTE_EXT = $2005;
5537 WGL_SWAP_LAYER_BUFFERS_EXT = $2006;
5538 WGL_SWAP_METHOD_EXT = $2007;
5539 WGL_NUMBER_OVERLAYS_EXT = $2008;
5540 WGL_NUMBER_UNDERLAYS_EXT = $2009;
5541 WGL_TRANSPARENT_EXT = $200A;
5542 WGL_TRANSPARENT_VALUE_EXT = $200B;
5543 WGL_SHARE_DEPTH_EXT = $200C;
5544 WGL_SHARE_STENCIL_EXT = $200D;
5545 WGL_SHARE_ACCUM_EXT = $200E;
5546 WGL_SUPPORT_GDI_EXT = $200F;
5547 WGL_SUPPORT_OPENGL_EXT = $2010;
5548 WGL_DOUBLE_BUFFER_EXT = $2011;
5549 WGL_STEREO_EXT = $2012;
5550 WGL_PIXEL_TYPE_EXT = $2013;
5551 WGL_COLOR_BITS_EXT = $2014;
5552 WGL_RED_BITS_EXT = $2015;
5553 WGL_RED_SHIFT_EXT = $2016;
5554 WGL_GREEN_BITS_EXT = $2017;
5555 WGL_GREEN_SHIFT_EXT = $2018;
5556 WGL_BLUE_BITS_EXT = $2019;
5557 WGL_BLUE_SHIFT_EXT = $201A;
5558 WGL_ALPHA_BITS_EXT = $201B;
5559 WGL_ALPHA_SHIFT_EXT = $201C;
5560 WGL_ACCUM_BITS_EXT = $201D;
5561 WGL_ACCUM_RED_BITS_EXT = $201E;
5562 WGL_ACCUM_GREEN_BITS_EXT = $201F;
5563 WGL_ACCUM_BLUE_BITS_EXT = $2020;
5564 WGL_ACCUM_ALPHA_BITS_EXT = $2021;
5565 WGL_DEPTH_BITS_EXT = $2022;
5566 WGL_STENCIL_BITS_EXT = $2023;
5567 WGL_AUX_BUFFERS_EXT = $2024;
5568 WGL_NO_ACCELERATION_EXT = $2025;
5569 WGL_GENERIC_ACCELERATION_EXT = $2026;
5570 WGL_FULL_ACCELERATION_EXT = $2027;
5571 WGL_SWAP_EXCHANGE_EXT = $2028;
5572 WGL_SWAP_COPY_EXT = $2029;
5573 WGL_SWAP_UNDEFINED_EXT = $202A;
5574 WGL_TYPE_RGBA_EXT = $202B;
5575 WGL_TYPE_COLORINDEX_EXT = $202C;
5576
5577 // WGL_I3D_digital_video_control
5578 WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050;
5579 WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051;
5580 WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052;
5581 WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053;
5582
5583 // WGL_I3D_gamma
5584 WGL_GAMMA_TABLE_SIZE_I3D = $204E;
5585 WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F;
5586
5587 // WGL_I3D_genlock
5588 WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044;
5589 WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045;
5590 WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046;
5591 WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047;
5592 WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048;
5593 WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049;
5594 WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A;
5595 WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B;
5596 WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C;
5597
5598 // WGL_I3D_image_buffer
5599 WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001;
5600 WGL_IMAGE_BUFFER_LOCK_I3D = $00000002;
5601
5602 // WGL_NV_float_buffer
5603 WGL_FLOAT_COMPONENTS_NV = $20B0;
5604 WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1;
5605 WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2;
5606 WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3;
5607 WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4;
5608 WGL_TEXTURE_FLOAT_R_NV = $20B5;
5609 WGL_TEXTURE_FLOAT_RG_NV = $20B6;
5610 WGL_TEXTURE_FLOAT_RGB_NV = $20B7;
5611 WGL_TEXTURE_FLOAT_RGBA_NV = $20B8;
5612
5613 // WGL_NV_render_depth_texture
5614 WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3;
5615 WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4;
5616 WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5;
5617 WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6;
5618 WGL_DEPTH_COMPONENT_NV = $20A7;
5619
5620 // WGL_NV_render_texture_rectangle
5621 WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;
5622 WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1;
5623 WGL_TEXTURE_RECTANGLE_NV = $20A2;
5624
5625 // WGL_NV_present_video
5626 WGL_NUM_VIDEO_SLOTS_NV = $20F0;
5627
5628 // WGL_NV_video_out
5629 WGL_BIND_TO_VIDEO_RGB_NV = $20C0;
5630 WGL_BIND_TO_VIDEO_RGBA_NV = $20C1;
5631 WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2;
5632 WGL_VIDEO_OUT_COLOR_NV = $20C3;
5633 WGL_VIDEO_OUT_ALPHA_NV = $20C4;
5634 WGL_VIDEO_OUT_DEPTH_NV = $20C5;
5635 WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6;
5636 WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7;
5637 WGL_VIDEO_OUT_FRAME = $20C8;
5638 WGL_VIDEO_OUT_FIELD_1 = $20C9;
5639 WGL_VIDEO_OUT_FIELD_2 = $20CA;
5640 WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB;
5641 WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC;
5642
5643 // WGL_NV_gpu_affinity
5644 WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0;
5645 WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1;
5646
5647 // WIN_draw_range_elements
5648 GL_MAX_ELEMENTS_VERTICES_WIN = $80E8;
5649 GL_MAX_ELEMENTS_INDICES_WIN = $80E9;
5650
5651 // GLX 1.1 and later:
5652 GLX_VENDOR = 1;
5653 GLX_VERSION = 2;
5654 GLX_EXTENSIONS = 3;
5655
5656 GLX_USE_GL = 1;
5657 GLX_BUFFER_SIZE = 2;
5658 GLX_LEVEL = 3;
5659 GLX_RGBA = 4;
5660 GLX_DOUBLEBUFFER = 5;
5661 GLX_STEREO = 6;
5662 GLX_AUX_BUFFERS = 7;
5663 GLX_RED_SIZE = 8;
5664 GLX_GREEN_SIZE = 9;
5665 GLX_BLUE_SIZE = 10;
5666 GLX_ALPHA_SIZE = 11;
5667 GLX_DEPTH_SIZE = 12;
5668 GLX_STENCIL_SIZE = 13;
5669 GLX_ACCUM_RED_SIZE = 14;
5670 GLX_ACCUM_GREEN_SIZE = 15;
5671 GLX_ACCUM_BLUE_SIZE = 16;
5672 GLX_ACCUM_ALPHA_SIZE = 17;
5673
5674 // GLX_VERSION_1_3
5675 GLX_WINDOW_BIT = $00000001;
5676 GLX_PIXMAP_BIT = $00000002;
5677 GLX_PBUFFER_BIT = $00000004;
5678 GLX_RGBA_BIT = $00000001;
5679 GLX_COLOR_INDEX_BIT = $00000002;
5680 GLX_PBUFFER_CLOBBER_MASK = $08000000;
5681 GLX_FRONT_LEFT_BUFFER_BIT = $00000001;
5682 GLX_FRONT_RIGHT_BUFFER_BIT = $00000002;
5683 GLX_BACK_LEFT_BUFFER_BIT = $00000004;
5684 GLX_BACK_RIGHT_BUFFER_BIT = $00000008;
5685 GLX_AUX_BUFFERS_BIT = $00000010;
5686 GLX_DEPTH_BUFFER_BIT = $00000020;
5687 GLX_STENCIL_BUFFER_BIT = $00000040;
5688 GLX_ACCUM_BUFFER_BIT = $00000080;
5689 GLX_CONFIG_CAVEAT = $20;
5690 GLX_X_VISUAL_TYPE = $22;
5691 GLX_TRANSPARENT_TYPE = $23;
5692 GLX_TRANSPARENT_INDEX_VALUE = $24;
5693 GLX_TRANSPARENT_RED_VALUE = $25;
5694 GLX_TRANSPARENT_GREEN_VALUE = $26;
5695 GLX_TRANSPARENT_BLUE_VALUE = $27;
5696 GLX_TRANSPARENT_ALPHA_VALUE = $28;
5697 GLX_DONT_CARE = $FFFFFFFF;
5698 GLX_NONE = $8000;
5699 GLX_SLOW_CONFIG = $8001;
5700 GLX_TRUE_COLOR = $8002;
5701 GLX_DIRECT_COLOR = $8003;
5702 GLX_PSEUDO_COLOR = $8004;
5703 GLX_STATIC_COLOR = $8005;
5704 GLX_GRAY_SCALE = $8006;
5705 GLX_STATIC_GRAY = $8007;
5706 GLX_TRANSPARENT_RGB = $8008;
5707 GLX_TRANSPARENT_INDEX = $8009;
5708 GLX_VISUAL_ID = $800B;
5709 GLX_SCREEN = $800C;
5710 GLX_NON_CONFORMANT_CONFIG = $800D;
5711 GLX_DRAWABLE_TYPE = $8010;
5712 GLX_RENDER_TYPE = $8011;
5713 GLX_X_RENDERABLE = $8012;
5714 GLX_FBCONFIG_ID = $8013;
5715 GLX_RGBA_TYPE = $8014;
5716 GLX_COLOR_INDEX_TYPE = $8015;
5717 GLX_MAX_PBUFFER_WIDTH = $8016;
5718 GLX_MAX_PBUFFER_HEIGHT = $8017;
5719 GLX_MAX_PBUFFER_PIXELS = $8018;
5720 GLX_PRESERVED_CONTENTS = $801B;
5721 GLX_LARGEST_PBUFFER = $801C;
5722 GLX_WIDTH = $801D;
5723 GLX_HEIGHT = $801E;
5724 GLX_EVENT_MASK = $801F;
5725 GLX_DAMAGED = $8020;
5726 GLX_SAVED = $8021;
5727 GLX_WINDOW = $8022;
5728 GLX_PBUFFER = $8023;
5729 GLX_PBUFFER_HEIGHT = $8040;
5730 GLX_PBUFFER_WIDTH = $8041;
5731
5732 // GLX_VERSION_1_4
5733 GLX_SAMPLE_BUFFERS = 100000;
5734 GLX_SAMPLES = 100001;
5735
5736 // GLX_ARB_multisample
5737 GLX_SAMPLE_BUFFERS_ARB = 100000;
5738 GLX_SAMPLES_ARB = 100001;
5739
5740 // GLX_ARB_fbconfig_float
5741 GLX_RGBA_FLOAT_TYPE_ARB = $20B9;
5742 GLX_RGBA_FLOAT_BIT_ARB = $00000004;
5743
5744 // GLX_ARB_create_context
5745 GLX_CONTEXT_DEBUG_BIT_ARB = $00000001;
5746 GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
5747 GLX_CONTEXT_MAJOR_VERSION_ARB = $2091;
5748 GLX_CONTEXT_MINOR_VERSION_ARB = $2092;
5749 GLX_CONTEXT_FLAGS_ARB = $2094;
5750
5751 // GLX_ARB_create_context_profile
5752 GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
5753 GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
5754 GLX_CONTEXT_PROFILE_MASK_ARB = $9126;
5755
5756 // GLX_EXT_visual_info
5757 GLX_X_VISUAL_TYPE_EXT = $22;
5758 GLX_TRANSPARENT_TYPE_EXT = $23;
5759 GLX_TRANSPARENT_INDEX_VALUE_EXT = $24;
5760 GLX_TRANSPARENT_RED_VALUE_EXT = $25;
5761 GLX_TRANSPARENT_GREEN_VALUE_EXT = $26;
5762 GLX_TRANSPARENT_BLUE_VALUE_EXT = $27;
5763 GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28;
5764 GLX_NONE_EXT = $8000;
5765 GLX_TRUE_COLOR_EXT = $8002;
5766 GLX_DIRECT_COLOR_EXT = $8003;
5767 GLX_PSEUDO_COLOR_EXT = $8004;
5768 GLX_STATIC_COLOR_EXT = $8005;
5769 GLX_GRAY_SCALE_EXT = $8006;
5770 GLX_STATIC_GRAY_EXT = $8007;
5771 GLX_TRANSPARENT_RGB_EXT = $8008;
5772 GLX_TRANSPARENT_INDEX_EXT = $8009;
5773
5774 // GLX_EXT_visual_rating
5775 GLX_VISUAL_CAVEAT_EXT = $20;
5776 GLX_SLOW_VISUAL_EXT = $8001;
5777 GLX_NON_CONFORMANT_VISUAL_EXT = $800D;
5778 (* reuse GLX_NONE_EXT *)
5779
5780 // GLX_EXT_import_context
5781 GLX_SHARE_CONTEXT_EXT = $800A;
5782 GLX_VISUAL_ID_EXT = $800B;
5783 GLX_SCREEN_EXT = $800C;
5784
5785 // GLX_EXT_fbconfig_packed_float
5786 // GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
5787 // GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
5788
5789 // GLX_EXT_framebuffer_sRGB
5790 // GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
5791
5792 // GLX_EXT_texture_from_pixmap
5793 GLX_TEXTURE_1D_BIT_EXT = $00000001;
5794 GLX_TEXTURE_2D_BIT_EXT = $00000002;
5795 GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004;
5796 GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0;
5797 GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1;
5798 GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2;
5799 GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3;
5800 GLX_Y_INVERTED_EXT = $20D4;
5801 GLX_TEXTURE_FORMAT_EXT = $20D5;
5802 GLX_TEXTURE_TARGET_EXT = $20D6;
5803 GLX_MIPMAP_TEXTURE_EXT = $20D7;
5804 GLX_TEXTURE_FORMAT_NONE_EXT = $20D8;
5805 GLX_TEXTURE_FORMAT_RGB_EXT = $20D9;
5806 GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA;
5807 GLX_TEXTURE_1D_EXT = $20DB;
5808 GLX_TEXTURE_2D_EXT = $20DC;
5809 GLX_TEXTURE_RECTANGLE_EXT = $20DD;
5810 GLX_FRONT_LEFT_EXT = $20DE;
5811 GLX_FRONT_RIGHT_EXT = $20DF;
5812 GLX_BACK_LEFT_EXT = $20E0;
5813 GLX_BACK_RIGHT_EXT = $20E1;
5814 GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT;
5815 GLX_BACK_EXT = GLX_BACK_LEFT_EXT;
5816 GLX_AUX0_EXT = $20E2;
5817 GLX_AUX1_EXT = $20E3;
5818 GLX_AUX2_EXT = $20E4;
5819 GLX_AUX3_EXT = $20E5;
5820 GLX_AUX4_EXT = $20E6;
5821 GLX_AUX5_EXT = $20E7;
5822 GLX_AUX6_EXT = $20E8;
5823 GLX_AUX7_EXT = $20E9;
5824 GLX_AUX8_EXT = $20EA;
5825 GLX_AUX9_EXT = $20EB;
5826
5827
5828 // GLU
5829 GLU_INVALID_ENUM = 100900;
5830 GLU_INVALID_VALUE = 100901;
5831 GLU_OUT_OF_MEMORY = 100902;
5832 GLU_INCOMPATIBLE_GL_VERSION = 100903;
5833 GLU_VERSION = 100800;
5834 GLU_EXTENSIONS = 100801;
5835 GLU_TRUE = GL_TRUE;
5836 GLU_FALSE = GL_FALSE;
5837 GLU_SMOOTH = 100000;
5838 GLU_FLAT = 100001;
5839 GLU_NONE = 100002;
5840 GLU_POINT = 100010;
5841 GLU_LINE = 100011;
5842 GLU_FILL = 100012;
5843 GLU_SILHOUETTE = 100013;
5844 GLU_OUTSIDE = 100020;
5845 GLU_INSIDE = 100021;
5846 GLU_TESS_MAX_COORD = 1.0E150;
5847 GLU_TESS_WINDING_RULE = 100140;
5848 GLU_TESS_BOUNDARY_ONLY = 100141;
5849 GLU_TESS_TOLERANCE = 100142;
5850 GLU_TESS_WINDING_ODD = 100130;
5851 GLU_TESS_WINDING_NONZERO = 100131;
5852 GLU_TESS_WINDING_POSITIVE = 100132;
5853 GLU_TESS_WINDING_NEGATIVE = 100133;
5854 GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
5855 GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc
5856 GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc
5857 GLU_TESS_END = 100102; // TGLUTessEndProc
5858 GLU_TESS_ERROR = 100103; // TGLUTessErrorProc
5859 GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc
5860 GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc
5861 GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc
5862 GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc
5863 GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc
5864 GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc
5865 GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc
5866 GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc
5867 GLU_TESS_ERROR1 = 100151;
5868 GLU_TESS_ERROR2 = 100152;
5869 GLU_TESS_ERROR3 = 100153;
5870 GLU_TESS_ERROR4 = 100154;
5871 GLU_TESS_ERROR5 = 100155;
5872 GLU_TESS_ERROR6 = 100156;
5873 GLU_TESS_ERROR7 = 100157;
5874 GLU_TESS_ERROR8 = 100158;
5875 GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1;
5876 GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2;
5877 GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3;
5878 GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4;
5879 GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5;
5880 GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6;
5881 GLU_AUTO_LOAD_MATRIX = 100200;
5882 GLU_CULLING = 100201;
5883 GLU_SAMPLING_TOLERANCE = 100203;
5884 GLU_DISPLAY_MODE = 100204;
5885 GLU_PARAMETRIC_TOLERANCE = 100202;
5886 GLU_SAMPLING_METHOD = 100205;
5887 GLU_U_STEP = 100206;
5888 GLU_V_STEP = 100207;
5889 GLU_PATH_LENGTH = 100215;
5890 GLU_PARAMETRIC_ERROR = 100216;
5891 GLU_DOMAIN_DISTANCE = 100217;
5892 GLU_MAP1_TRIM_2 = 100210;
5893 GLU_MAP1_TRIM_3 = 100211;
5894 GLU_OUTLINE_POLYGON = 100240;
5895 GLU_OUTLINE_PATCH = 100241;
5896 GLU_NURBS_ERROR1 = 100251;
5897 GLU_NURBS_ERROR2 = 100252;
5898 GLU_NURBS_ERROR3 = 100253;
5899 GLU_NURBS_ERROR4 = 100254;
5900 GLU_NURBS_ERROR5 = 100255;
5901 GLU_NURBS_ERROR6 = 100256;
5902 GLU_NURBS_ERROR7 = 100257;
5903 GLU_NURBS_ERROR8 = 100258;
5904 GLU_NURBS_ERROR9 = 100259;
5905 GLU_NURBS_ERROR10 = 100260;
5906 GLU_NURBS_ERROR11 = 100261;
5907 GLU_NURBS_ERROR12 = 100262;
5908 GLU_NURBS_ERROR13 = 100263;
5909 GLU_NURBS_ERROR14 = 100264;
5910 GLU_NURBS_ERROR15 = 100265;
5911 GLU_NURBS_ERROR16 = 100266;
5912 GLU_NURBS_ERROR17 = 100267;
5913 GLU_NURBS_ERROR18 = 100268;
5914 GLU_NURBS_ERROR19 = 100269;
5915 GLU_NURBS_ERROR20 = 100270;
5916 GLU_NURBS_ERROR21 = 100271;
5917 GLU_NURBS_ERROR22 = 100272;
5918 GLU_NURBS_ERROR23 = 100273;
5919 GLU_NURBS_ERROR24 = 100274;
5920 GLU_NURBS_ERROR25 = 100275;
5921 GLU_NURBS_ERROR26 = 100276;
5922 GLU_NURBS_ERROR27 = 100277;
5923 GLU_NURBS_ERROR28 = 100278;
5924 GLU_NURBS_ERROR29 = 100279;
5925 GLU_NURBS_ERROR30 = 100280;
5926 GLU_NURBS_ERROR31 = 100281;
5927 GLU_NURBS_ERROR32 = 100282;
5928 GLU_NURBS_ERROR33 = 100283;
5929 GLU_NURBS_ERROR34 = 100284;
5930 GLU_NURBS_ERROR35 = 100285;
5931 GLU_NURBS_ERROR36 = 100286;
5932 GLU_NURBS_ERROR37 = 100287;
5933 GLU_CW = 100120;
5934 GLU_CCW = 100121;
5935 GLU_INTERIOR = 100122;
5936 GLU_EXTERIOR = 100123;
5937 GLU_UNKNOWN = 100124;
5938 GLU_BEGIN = GLU_TESS_BEGIN;
5939 GLU_VERTEX = GLU_TESS_VERTEX;
5940 GLU_END = GLU_TESS_END;
5941 GLU_ERROR = GLU_TESS_ERROR;
5942 GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG;
5943
5944 type
5945 // GL_VERSION_1_0
5946 TglCullFace = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5947 TglFrontFace = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5948 TglHint = procedure(target: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5949 TglLineWidth = procedure(width: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5950 TglPointSize = procedure(size: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5951 TglPolygonMode = procedure(face: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5952 TglScissor = procedure(x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5953 TglTexParameterf = procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5954 TglTexParameterfv = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5955 TglTexParameteri = procedure(target: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5956 TglTexParameteriv = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5957 TglTexImage1D = procedure(target: TGLenum; level: TGLint; internalformat: TGLint; width: TGLsizei; border: TGLint; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5958 TglTexImage2D = procedure(target: TGLenum; level: TGLint; internalformat: TGLint; width: TGLsizei; height: TGLsizei; border: TGLint; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5959 TglDrawBuffer = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5960 TglClear = procedure(mask: TGLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5961 TglClearColor = procedure(red: TGLclampf; green: TGLclampf; blue: TGLclampf; alpha: TGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5962 TglClearStencil = procedure(s: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5963 TglClearDepth = procedure(depth: TGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5964 TglStencilMask = procedure(mask: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5965 TglColorMask = procedure(red: TGLboolean; green: TGLboolean; blue: TGLboolean; alpha: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5966 TglDepthMask = procedure(flag: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5967 TglDisable = procedure(cap: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5968 TglEnable = procedure(cap: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5969 TglFinish = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5970 TglFlush = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5971 TglBlendFunc = procedure(sfactor: TGLenum; dfactor: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5972 TglLogicOp = procedure(opcode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5973 TglStencilFunc = procedure(func: TGLenum; ref: TGLint; mask: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5974 TglStencilOp = procedure(fail: TGLenum; zfail: TGLenum; zpass: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5975 TglDepthFunc = procedure(func: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5976 TglPixelStoref = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5977 TglPixelStorei = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5978 TglReadBuffer = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5979 TglReadPixels = procedure(x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5980 TglGetBooleanv = procedure(pname: TGLenum; params: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5981 TglGetDoublev = procedure(pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5982 TglGetError = function(): TGLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5983 TglGetFloatv = procedure(pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5984 TglGetIntegerv = procedure(pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5985 TglGetString = function(name: TGLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5986 TglGetTexImage = procedure(target: TGLenum; level: TGLint; format: TGLenum; _type: TGLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5987 TglGetTexParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5988 TglGetTexParameterfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5989 TglGetTexLevelParameterfv = procedure(target: TGLenum; level: TGLint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5990 TglGetTexLevelParameteriv = procedure(target: TGLenum; level: TGLint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5991 TglIsEnabled = function(cap: TGLenum): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5992 TglDepthRange = procedure(zNear: TGLclampd; zFar: TGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5993 TglViewport = procedure(x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5994
5995 // GL_VERSION_1_1
5996 TglDrawArrays = procedure(mode: TGLenum; first: TGLint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5997 TglDrawElements = procedure(mode: TGLenum; count: TGLsizei; _type: TGLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5998 TglGetPointerv = procedure(pname: TGLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
5999 TglPolygonOffset = procedure(factor: TGLfloat; units: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6000 TglCopyTexImage1D = procedure(target: TGLenum; level: TGLint; internalFormat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; border: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6001 TglCopyTexImage2D = procedure(target: TGLenum; level: TGLint; internalFormat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei; border: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6002 TglCopyTexSubImage1D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6003 TglCopyTexSubImage2D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6004 TglTexSubImage1D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; width: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6005 TglTexSubImage2D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6006 TglBindTexture = procedure(target: TGLenum; texture: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6007 TglDeleteTextures = procedure(n: TGLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6008 TglGenTextures = procedure(n: TGLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6009
6010 {$ifdef DGL_DEPRECATED}
6011 TglAccum = procedure(op: TGLenum; value: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6012 TglAlphaFunc = procedure(func: TGLenum; ref: TGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6013 TglAreTexturesResident = function(n: TGLsizei; const textures: PGLuint; residences: PGLboolean): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6014 TglArrayElement = procedure(i: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6015 TglBegin = procedure(mode: TGLenum); {$IFNDEF CLR}{$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}{$ENDIF}
6016 TglBitmap = procedure(width: TGLsizei; height: TGLsizei; xorig: TGLfloat; yorig: TGLfloat; xmove: TGLfloat; ymove: TGLfloat; const bitmap: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6017 TglCallList = procedure(list: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6018 TglCallLists = procedure(n: TGLsizei; _type: TGLenum; const lists: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6019 TglClearAccum = procedure(red: TGLfloat; green: TGLfloat; blue: TGLfloat; alpha: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6020 TglClearIndex = procedure(c: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6021 TglClipPlane = procedure(plane: TGLenum; const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6022 TglColor3b = procedure(red: TGLbyte; green: TGLbyte; blue: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6023 TglColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6024 TglColor3d = procedure(red: TGLdouble; green: TGLdouble; blue: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6025 TglColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6026 TglColor3f = procedure(red: TGLfloat; green: TGLfloat; blue: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6027 TglColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6028 TglColor3i = procedure(red: TGLint; green: TGLint; blue: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6029 TglColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6030 TglColor3s = procedure(red: TGLshort; green: TGLshort; blue: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6031 TglColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6032 TglColor3ub = procedure(red: TGLubyte; green: TGLubyte; blue: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6033 TglColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6034 TglColor3ui = procedure(red: TGLuint; green: TGLuint; blue: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6035 TglColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6036 TglColor3us = procedure(red: TGLushort; green: TGLushort; blue: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6037 TglColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6038 TglColor4b = procedure(red: TGLbyte; green: TGLbyte; blue: TGLbyte; alpha: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6039 TglColor4bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6040 TglColor4d = procedure(red: TGLdouble; green: TGLdouble; blue: TGLdouble; alpha: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6041 TglColor4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6042 TglColor4f = procedure(red: TGLfloat; green: TGLfloat; blue: TGLfloat; alpha: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6043 TglColor4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6044 TglColor4i = procedure(red: TGLint; green: TGLint; blue: TGLint; alpha: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6045 TglColor4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6046 TglColor4s = procedure(red: TGLshort; green: TGLshort; blue: TGLshort; alpha: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6047 TglColor4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6048 TglColor4ub = procedure(red: TGLubyte; green: TGLubyte; blue: TGLubyte; alpha: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6049 TglColor4ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6050 TglColor4ui = procedure(red: TGLuint; green: TGLuint; blue: TGLuint; alpha: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6051 TglColor4uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6052 TglColor4us = procedure(red: TGLushort; green: TGLushort; blue: TGLushort; alpha: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6053 TglColor4usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6054 TglColorMaterial = procedure(face: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6055 TglColorPointer = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6056 TglCopyPixels = procedure(x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei; _type: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6057 TglDeleteLists = procedure(list: TGLuint; range: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6058 TglDisableClientState = procedure(_array: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6059 TglDrawPixels = procedure(width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6060 TglEdgeFlag = procedure(flag: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6061 TglEdgeFlagPointer = procedure(stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6062 TglEdgeFlagv = procedure(const flag: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6063 TglEnableClientState = procedure(_array: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6064 TglEnd = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6065 TglEndList = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6066 TglEvalCoord1d = procedure(u: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6067 TglEvalCoord1dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6068 TglEvalCoord1f = procedure(u: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6069 TglEvalCoord1fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6070 TglEvalCoord2d = procedure(u: TGLdouble; v: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6071 TglEvalCoord2dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6072 TglEvalCoord2f = procedure(u: TGLfloat; v: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6073 TglEvalCoord2fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6074 TglEvalMesh1 = procedure(mode: TGLenum; i1: TGLint; i2: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6075 TglEvalMesh2 = procedure(mode: TGLenum; i1: TGLint; i2: TGLint; j1: TGLint; j2: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6076 TglEvalPoint1 = procedure(i: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6077 TglEvalPoint2 = procedure(i: TGLint; j: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6078 TglFeedbackBuffer = procedure(size: TGLsizei; _type: TGLenum; buffer: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6079 TglFogf = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6080 TglFogfv = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6081 TglFogi = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6082 TglFogiv = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6083 TglFrustum = procedure(left: TGLdouble; right: TGLdouble; bottom: TGLdouble; top: TGLdouble; zNear: TGLdouble; zFar: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6084 TglGenLists = function(range: TGLsizei): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6085 TglGetClipPlane = procedure(plane: TGLenum; equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6086 TglGetLightfv = procedure(light: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6087 TglGetLightiv = procedure(light: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6088 TglGetMapdv = procedure(target: TGLenum; query: TGLenum; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6089 TglGetMapfv = procedure(target: TGLenum; query: TGLenum; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6090 TglGetMapiv = procedure(target: TGLenum; query: TGLenum; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6091 TglGetMaterialfv = procedure(face: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6092 TglGetMaterialiv = procedure(face: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6093 TglGetPixelMapfv = procedure(map: TGLenum; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6094 TglGetPixelMapuiv = procedure(map: TGLenum; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6095 TglGetPixelMapusv = procedure(map: TGLenum; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6096 TglGetPolygonStipple = procedure(mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6097 TglGetTexEnvfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6098 TglGetTexEnviv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6099 TglGetTexGendv = procedure(coord: TGLenum; pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6100 TglGetTexGenfv = procedure(coord: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6101 TglGetTexGeniv = procedure(coord: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6102 TglIndexMask = procedure(mask: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6103 TglIndexPointer = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6104 TglIndexd = procedure(c: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6105 TglIndexdv = procedure(const c: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6106 TglIndexf = procedure(c: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6107 TglIndexfv = procedure(const c: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6108 TglIndexi = procedure(c: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6109 TglIndexiv = procedure(const c: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6110 TglIndexs = procedure(c: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6111 TglIndexsv = procedure(const c: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6112 TglIndexub = procedure(c: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6113 TglIndexubv = procedure(const c: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6114 TglInitNames = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6115 TglInterleavedArrays = procedure(format: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6116 TglIsList = function(list: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6117 TglIsTexture = function(texture: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6118 TglLightModelf = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6119 TglLightModelfv = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6120 TglLightModeli = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6121 TglLightModeliv = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6122 TglLightf = procedure(light: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6123 TglLightfv = procedure(light: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6124 TglLighti = procedure(light: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6125 TglLightiv = procedure(light: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6126 TglLineStipple = procedure(factor: TGLint; pattern: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6127 TglListBase = procedure(base: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6128 TglLoadIdentity = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6129 TglLoadMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6130 TglLoadMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6131 TglLoadName = procedure(name: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6132 TglMap1d = procedure(target: TGLenum; u1: TGLdouble; u2: TGLdouble; stride: TGLint; order: TGLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6133 TglMap1f = procedure(target: TGLenum; u1: TGLfloat; u2: TGLfloat; stride: TGLint; order: TGLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6134 TglMap2d = procedure(target: TGLenum; u1: TGLdouble; u2: TGLdouble; ustride: TGLint; uorder: TGLint; v1: TGLdouble; v2: TGLdouble; vstride: TGLint; vorder: TGLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6135 TglMap2f = procedure(target: TGLenum; u1: TGLfloat; u2: TGLfloat; ustride: TGLint; uorder: TGLint; v1: TGLfloat; v2: TGLfloat; vstride: TGLint; vorder: TGLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6136 TglMapGrid1d = procedure(un: TGLint; u1: TGLdouble; u2: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6137 TglMapGrid1f = procedure(un: TGLint; u1: TGLfloat; u2: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6138 TglMapGrid2d = procedure(un: TGLint; u1: TGLdouble; u2: TGLdouble; vn: TGLint; v1: TGLdouble; v2: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6139 TglMapGrid2f = procedure(un: TGLint; u1: TGLfloat; u2: TGLfloat; vn: TGLint; v1: TGLfloat; v2: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6140 TglMaterialf = procedure(face: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6141 TglMaterialfv = procedure(face: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6142 TglMateriali = procedure(face: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6143 TglMaterialiv = procedure(face: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6144 TglMatrixMode = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6145 TglMultMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6146 TglMultMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6147 TglNewList = procedure(list: TGLuint; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6148 TglNormal3b = procedure(nx: TGLbyte; ny: TGLbyte; nz: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6149 TglNormal3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6150 TglNormal3d = procedure(nx: TGLdouble; ny: TGLdouble; nz: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6151 TglNormal3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6152 TglNormal3f = procedure(nx: TGLfloat; ny: TGLfloat; nz: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6153 TglNormal3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6154 TglNormal3i = procedure(nx: TGLint; ny: TGLint; nz: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6155 TglNormal3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6156 TglNormal3s = procedure(nx: TGLshort; ny: TGLshort; nz: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6157 TglNormal3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6158 TglNormalPointer = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6159 TglOrtho = procedure(left: TGLdouble; right: TGLdouble; bottom: TGLdouble; top: TGLdouble; zNear: TGLdouble; zFar: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6160 TglPassThrough = procedure(token: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6161 TglPixelMapfv = procedure(map: TGLenum; mapsize: TGLsizei; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6162 TglPixelMapuiv = procedure(map: TGLenum; mapsize: TGLsizei; const values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6163 TglPixelMapusv = procedure(map: TGLenum; mapsize: TGLsizei; const values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6164 TglPixelTransferf = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6165 TglPixelTransferi = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6166 TglPixelZoom = procedure(xfactor: TGLfloat; yfactor: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6167 TglPolygonStipple = procedure(const mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6168 TglPopAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6169 TglPopClientAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6170 TglPopMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6171 TglPopName = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6172 TglPrioritizeTextures = procedure(n: TGLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6173 TglPushAttrib = procedure(mask: TGLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6174 TglPushClientAttrib = procedure(mask: TGLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6175 TglPushMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6176 TglPushName = procedure(name: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6177 TglRasterPos2d = procedure(x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6178 TglRasterPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6179 TglRasterPos2f = procedure(x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6180 TglRasterPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6181 TglRasterPos2i = procedure(x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6182 TglRasterPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6183 TglRasterPos2s = procedure(x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6184 TglRasterPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6185 TglRasterPos3d = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6186 TglRasterPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6187 TglRasterPos3f = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6188 TglRasterPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6189 TglRasterPos3i = procedure(x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6190 TglRasterPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6191 TglRasterPos3s = procedure(x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6192 TglRasterPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6193 TglRasterPos4d = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6194 TglRasterPos4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6195 TglRasterPos4f = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6196 TglRasterPos4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6197 TglRasterPos4i = procedure(x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6198 TglRasterPos4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6199 TglRasterPos4s = procedure(x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6200 TglRasterPos4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6201 TglRectd = procedure(x1: TGLdouble; y1: TGLdouble; x2: TGLdouble; y2: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6202 TglRectdv = procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6203 TglRectf = procedure(x1: TGLfloat; y1: TGLfloat; x2: TGLfloat; y2: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6204 TglRectfv = procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6205 TglRecti = procedure(x1: TGLint; y1: TGLint; x2: TGLint; y2: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6206 TglRectiv = procedure(const v1: PGLint; const v2: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6207 TglRects = procedure(x1: TGLshort; y1: TGLshort; x2: TGLshort; y2: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6208 TglRectsv = procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6209 TglRenderMode = function(mode: TGLenum): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6210 TglRotated = procedure(angle: TGLdouble; x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6211 TglRotatef = procedure(angle: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6212 TglScaled = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6213 TglScalef = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6214 TglSelectBuffer = procedure(size: TGLsizei; buffer: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6215 TglShadeModel = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6216 TglTexCoord1d = procedure(s: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6217 TglTexCoord1dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6218 TglTexCoord1f = procedure(s: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6219 TglTexCoord1fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6220 TglTexCoord1i = procedure(s: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6221 TglTexCoord1iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6222 TglTexCoord1s = procedure(s: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6223 TglTexCoord1sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6224 TglTexCoord2d = procedure(s: TGLdouble; t: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6225 TglTexCoord2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6226 TglTexCoord2f = procedure(s: TGLfloat; t: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6227 TglTexCoord2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6228 TglTexCoord2i = procedure(s: TGLint; t: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6229 TglTexCoord2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6230 TglTexCoord2s = procedure(s: TGLshort; t: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6231 TglTexCoord2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6232 TglTexCoord3d = procedure(s: TGLdouble; t: TGLdouble; r: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6233 TglTexCoord3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6234 TglTexCoord3f = procedure(s: TGLfloat; t: TGLfloat; r: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6235 TglTexCoord3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6236 TglTexCoord3i = procedure(s: TGLint; t: TGLint; r: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6237 TglTexCoord3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6238 TglTexCoord3s = procedure(s: TGLshort; t: TGLshort; r: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6239 TglTexCoord3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6240 TglTexCoord4d = procedure(s: TGLdouble; t: TGLdouble; r: TGLdouble; q: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6241 TglTexCoord4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6242 TglTexCoord4f = procedure(s: TGLfloat; t: TGLfloat; r: TGLfloat; q: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6243 TglTexCoord4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6244 TglTexCoord4i = procedure(s: TGLint; t: TGLint; r: TGLint; q: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6245 TglTexCoord4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6246 TglTexCoord4s = procedure(s: TGLshort; t: TGLshort; r: TGLshort; q: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6247 TglTexCoord4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6248 TglTexCoordPointer = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6249 TglTexEnvf = procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6250 TglTexEnvfv = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6251 TglTexEnvi = procedure(target: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6252 TglTexEnviv = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6253 TglTexGend = procedure(coord: TGLenum; pname: TGLenum; param: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6254 TglTexGendv = procedure(coord: TGLenum; pname: TGLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6255 TglTexGenf = procedure(coord: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6256 TglTexGenfv = procedure(coord: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6257 TglTexGeni = procedure(coord: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6258 TglTexGeniv = procedure(coord: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6259
6260
6261 TglTranslated = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6262 TglTranslatef = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6263 TglVertex2d = procedure(x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6264 TglVertex2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6265 TglVertex2f = procedure(x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6266 TglVertex2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6267 TglVertex2i = procedure(x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6268 TglVertex2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6269 TglVertex2s = procedure(x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6270 TglVertex2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6271 TglVertex3d = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6272 TglVertex3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6273 TglVertex3f = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6274 TglVertex3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6275 TglVertex3i = procedure(x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6276 TglVertex3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6277 TglVertex3s = procedure(x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6278 TglVertex3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6279 TglVertex4d = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6280 TglVertex4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6281 TglVertex4f = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6282 TglVertex4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6283 TglVertex4i = procedure(x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6284 TglVertex4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6285 TglVertex4s = procedure(x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6286 TglVertex4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6287 TglVertexPointer = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6288 {$endif}
6289
6290 // GL_VERSION_1_2
6291 TglBlendColor = procedure(red: TGLclampf; green: TGLclampf; blue: TGLclampf; alpha: TGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6292 TglBlendEquation = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6293 TglDrawRangeElements = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; count: TGLsizei; _type: TGLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6294 TglTexImage3D = procedure(target: TGLenum; level: TGLint; internalformat: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; border: TGLint; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6295 TglTexSubImage3D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6296 TglCopyTexSubImage3D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6297 {$ifdef DGL_DEPRECATED}
6298 TglColorTable = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; format: TGLenum; _type: TGLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6299 TglColorTableParameterfv = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6300 TglColorTableParameteriv = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6301 TglCopyColorTable = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6302 TglGetColorTable = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6303 TglGetColorTableParameterfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6304 TglGetColorTableParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6305 TglColorSubTable = procedure(target: TGLenum; start: TGLsizei; count: TGLsizei; format: TGLenum; _type: TGLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6306 TglCopyColorSubTable = procedure(target: TGLenum; start: TGLsizei; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6307 TglConvolutionFilter1D = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; format: TGLenum; _type: TGLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6308 TglConvolutionFilter2D = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6309 TglConvolutionParameterf = procedure(target: TGLenum; pname: TGLenum; params: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6310 TglConvolutionParameterfv = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6311 TglConvolutionParameteri = procedure(target: TGLenum; pname: TGLenum; params: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6312 TglConvolutionParameteriv = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6313 TglCopyConvolutionFilter1D = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6314 TglCopyConvolutionFilter2D = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6315 TglGetConvolutionFilter = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6316 TglGetConvolutionParameterfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6317 TglGetConvolutionParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6318 TglGetSeparableFilter = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6319 TglSeparableFilter2D = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6320 TglGetHistogram = procedure(target: TGLenum; reset: TGLboolean; format: TGLenum; _type: TGLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6321 TglGetHistogramParameterfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6322 TglGetHistogramParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6323 TglGetMinmax = procedure(target: TGLenum; reset: TGLboolean; format: TGLenum; _type: TGLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6324 TglGetMinmaxParameterfv = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6325 TglGetMinmaxParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6326 TglHistogram = procedure(target: TGLenum; width: TGLsizei; internalformat: TGLenum; sink: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6327 TglMinmax = procedure(target: TGLenum; internalformat: TGLenum; sink: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6328 TglResetHistogram = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6329 TglResetMinmax = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6330 {$endif}
6331
6332 // GL_VERSION_1_3
6333 TglActiveTexture = procedure(texture: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6334 TglSampleCoverage = procedure(value: TGLclampf; invert: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6335 TglCompressedTexImage3D = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; depth: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6336 TglCompressedTexImage2D = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6337 TglCompressedTexImage1D = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6338 TglCompressedTexSubImage3D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6339 TglCompressedTexSubImage2D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; width: TGLsizei; height: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6340 TglCompressedTexSubImage1D = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; width: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6341 TglGetCompressedTexImage = procedure(target: TGLenum; level: TGLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6342 {$ifdef DGL_DEPRECATED}
6343 TglClientActiveTexture = procedure(texture: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6344 TglMultiTexCoord1d = procedure(target: TGLenum; s: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6345 TglMultiTexCoord1dv = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6346 TglMultiTexCoord1f = procedure(target: TGLenum; s: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6347 TglMultiTexCoord1fv = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6348 TglMultiTexCoord1i = procedure(target: TGLenum; s: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6349 TglMultiTexCoord1iv = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6350 TglMultiTexCoord1s = procedure(target: TGLenum; s: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6351 TglMultiTexCoord1sv = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6352 TglMultiTexCoord2d = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6353 TglMultiTexCoord2dv = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6354 TglMultiTexCoord2f = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6355 TglMultiTexCoord2fv = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6356 TglMultiTexCoord2i = procedure(target: TGLenum; s: TGLint; t: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6357 TglMultiTexCoord2iv = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6358 TglMultiTexCoord2s = procedure(target: TGLenum; s: TGLshort; t: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6359 TglMultiTexCoord2sv = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6360 TglMultiTexCoord3d = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble; r: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6361 TglMultiTexCoord3dv = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6362 TglMultiTexCoord3f = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat; r: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6363 TglMultiTexCoord3fv = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6364 TglMultiTexCoord3i = procedure(target: TGLenum; s: TGLint; t: TGLint; r: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6365 TglMultiTexCoord3iv = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6366 TglMultiTexCoord3s = procedure(target: TGLenum; s: TGLshort; t: TGLshort; r: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6367 TglMultiTexCoord3sv = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6368 TglMultiTexCoord4d = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble; r: TGLdouble; q: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6369 TglMultiTexCoord4dv = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6370 TglMultiTexCoord4f = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat; r: TGLfloat; q: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6371 TglMultiTexCoord4fv = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6372 TglMultiTexCoord4i = procedure(target: TGLenum; s: TGLint; t: TGLint; r: TGLint; q: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6373 TglMultiTexCoord4iv = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6374 TglMultiTexCoord4s = procedure(target: TGLenum; s: TGLshort; t: TGLshort; r: TGLshort; q: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6375 TglMultiTexCoord4sv = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6376 TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6377 TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6378 TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6379 TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6380 {$endif}
6381
6382 // GL_VERSION_1_4
6383 TglBlendFuncSeparate = procedure(sfactorRGB: TGLenum; dfactorRGB: TGLenum; sfactorAlpha: TGLenum; dfactorAlpha: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6384 TglMultiDrawArrays = procedure(mode: TGLenum; first: PGLint; count: PGLsizei; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6385 TglMultiDrawElements = procedure(mode: TGLenum; const count: PGLsizei; _type: TGLenum; const indices: PGLvoid; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6386 TglPointParameterf = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6387 TglPointParameterfv = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6388 TglPointParameteri = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6389 TglPointParameteriv = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6390 {$ifdef DGL_DEPRECATED}
6391 TglFogCoordf = procedure(coord: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6392 TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6393 TglFogCoordd = procedure(coord: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6394 TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6395 TglFogCoordPointer = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6396 TglSecondaryColor3b = procedure(red: TGLbyte; green: TGLbyte; blue: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6397 TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6398 TglSecondaryColor3d = procedure(red: TGLdouble; green: TGLdouble; blue: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6399 TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6400 TglSecondaryColor3f = procedure(red: TGLfloat; green: TGLfloat; blue: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6401 TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6402 TglSecondaryColor3i = procedure(red: TGLint; green: TGLint; blue: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6403 TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6404 TglSecondaryColor3s = procedure(red: TGLshort; green: TGLshort; blue: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6405 TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6406 TglSecondaryColor3ub = procedure(red: TGLubyte; green: TGLubyte; blue: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6407 TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6408 TglSecondaryColor3ui = procedure(red: TGLuint; green: TGLuint; blue: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6409 TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6410 TglSecondaryColor3us = procedure(red: TGLushort; green: TGLushort; blue: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6411 TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6412 TglSecondaryColorPointer = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6413 TglWindowPos2d = procedure(x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6414 TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6415 TglWindowPos2f = procedure(x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6416 TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6417 TglWindowPos2i = procedure(x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6418 TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6419 TglWindowPos2s = procedure(x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6420 TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6421 TglWindowPos3d = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6422 TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6423 TglWindowPos3f = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6424 TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6425 TglWindowPos3i = procedure(x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6426 TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6427 TglWindowPos3s = procedure(x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6428 TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6429 {$endif}
6430
6431 // GL_VERSION_1_5
6432 TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6433 TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6434 TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6435 TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6436 TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6437 TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6438 TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6439 TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6440 TglBindBuffer = procedure(target: TGLenum; buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6441 TglDeleteBuffers = procedure(n: TGLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6442 TglGenBuffers = procedure(n: TGLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6443 TglIsBuffer = function(buffer: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6444 TglBufferData = procedure(target: TGLenum; size: TGLsizei; const data: PGLvoid; usage: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6445 TglBufferSubData = procedure(target: TGLenum; offset: TGLsizei; size: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6446 TglGetBufferSubData = procedure(target: TGLenum; offset: TGLsizei; size: TGLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6447 TglMapBuffer = function(target: TGLenum; access: TGLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6448 TglUnmapBuffer = function(target: TGLenum): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6449 TglGetBufferParameteriv = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6450 TglGetBufferPointerv = procedure(target: TGLenum; pname: TGLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6451
6452 // GL_VERSION_2_0
6453 TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6454 TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6455 TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6456 TglStencilFuncSeparate = procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6457 TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6458 TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6459 TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6460 TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6461 TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6462 TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6463 TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6464 TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6465 TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6466 TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6467 TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6468 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}
6469 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}
6470 TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6471 TglGetAttribLocation = function(programObj: GLhandle; char: string): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6472 TglGetProgramiv = procedure(programObj: GLhandle; pname: TGLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6473 TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; var length: GLint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6474 TglGetShaderiv = procedure(shaderObj: GLhandle; pname: TGLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6475 TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; var length: glint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6476 TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6477 TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6478 TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6479 TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6480 TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6481 TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6482 TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6483 TglIsProgram = function(programObj: GLhandle) : TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6484 TglIsShader = function(shaderObj: GLhandle) : TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6485 TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6486 TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6487 TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6488 TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6489 TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6490 TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6491 TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6492 TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6493 TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6494 TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6495 TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6496 TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6497 TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6498 TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6499 TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6500 TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6501 TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6502 TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6503 TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6504 TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6505 TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6506 TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6507 TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6508 TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6509 TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6510 TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6511 TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6512 TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6513 TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6514 TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6515 TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6516 TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6517 TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6518 TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6519 TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6520 TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6521 TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6522 TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6523 TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6524 TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6525 TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6526 TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6527 TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6528 TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6529 TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6530 TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6531 TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6532 TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6533 TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6534 TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6535 TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6536 TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6537 TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6538 TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6539 TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6540 TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6541 TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6542 TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6543 TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6544 TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6545
6546 // GL_VERSION_2_1
6547 TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6548 TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6549 TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6550 TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6551 TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6552 TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6553
6554 // GL_VERSION_3_0
6555 { OpenGL 3.0 also reuses entry points from these extensions: }
6556 { ARB_framebuffer_object }
6557 { ARB_map_buffer_range }
6558 { ARB_vertex_array_object }
6559 TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6560 TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6561 TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6562 TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6563 TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6564 TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6565 TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6566 TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6567 TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLsizei; size: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6568 TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6569 TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6570 TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6571 TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6572 TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6573 TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6574 TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6575 TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6576 TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6577 TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6578 TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6579 TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6580 TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6581 TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6582 TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6583 TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6584 TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6585 TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6586 TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6587 TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6588 TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6589 TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6590 TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6591 TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6592 TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6593 TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6594 TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6595 TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6596 TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6597 TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6598 TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6599 TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6600 TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6601 TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6602 TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6603 TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6604 TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6605 TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6606 TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6607 TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6608 TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6609 TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6610 TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6611 TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6612 TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6613 TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6614 TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6615 TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6616 TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6617
6618 // GL_VERSION_3_1
6619 { OpenGL 3.1 also reuses entry points from these extensions: }
6620 { ARB_copy_buffer }
6621 { ARB_uniform_buffer_object }
6622 TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6623 TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6624 TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6625 TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6626
6627 // GL_VERSION_3_2
6628 { OpenGL 3.2 also reuses entry points from these extensions: }
6629 { ARB_draw_elements_base_vertex }
6630 { ARB_provoking_vertex }
6631 { ARB_sync }
6632 { ARB_texture_multisample }
6633 TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6634 TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6635 TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6636 TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6637 TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6638
6639 // GL_3DFX_tbuffer
6640 TglTbufferMask3DFX = procedure(mask: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6641
6642 // GL_APPLE_element_array
6643 TglElementPointerAPPLE = procedure(_type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6644 TglDrawElementArrayAPPLE = procedure(mode: TGLenum; first: TGLint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6645 TglDrawRangeElementArrayAPPLE = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; first: TGLint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6646 TglMultiDrawElementArrayAPPLE = procedure(mode: TGLenum; const first: PGLint; const count: PGLsizei; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6647 TglMultiDrawRangeElementArrayAPPLE = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; const first: PGLint; const count: PGLsizei; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6648
6649 // GL_APPLE_fence
6650 TglGenFencesAPPLE = procedure(n: TGLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6651 TglDeleteFencesAPPLE = procedure(n: TGLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6652 TglSetFenceAPPLE = procedure(fence: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6653 TglIsFenceAPPLE = function(fence: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6654 TglTestFenceAPPLE = function(fence: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6655 TglFinishFenceAPPLE = procedure(fence: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6656 TglTestObjectAPPLE = function(_object: TGLenum; name: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6657 TglFinishObjectAPPLE = procedure(_object: TGLenum; name: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6658
6659 // GL_APPLE_vertex_array_object
6660 TglBindVertexArrayAPPLE = procedure(_array: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6661 TglDeleteVertexArraysAPPLE = procedure(n: TGLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6662 TglGenVertexArraysAPPLE = procedure(n: TGLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6663 TglIsVertexArrayAPPLE = function(_array: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6664
6665 // GL_APPLE_vertex_array_range
6666 TglVertexArrayRangeAPPLE = procedure(length: TGLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6667 TglFlushVertexArrayRangeAPPLE = procedure(length: TGLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6668 TglVertexArrayParameteriAPPLE = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6669
6670 // GL_APPLE_texture_range
6671 TglTextureRangeAPPLE = procedure(target: GLenum; length: GLsizei; const Pointer_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6672 TglGetTexParameterPointervAPPLE = procedure(target: GLenum; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6673
6674 // GL_APPLE_vertex_program_evaluators
6675 TglEnableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6676 TglDisableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6677 TglIsVertexAttribEnabledAPPLE = function(index_: GLuint; pname: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6678 TglMapVertexAttrib1dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6679 TglMapVertexAttrib1fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6680 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}
6681 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}
6682
6683 // GL_APPLE_object_purgeable
6684 TglObjectPurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6685 TglObjectUnpurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6686 TglGetObjectParameterivAPPLE = procedure(objectType: GLenum; name: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6687
6688 // GL_ARB_matrix_palette
6689 TglCurrentPaletteMatrixARB = procedure(index: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6690 TglMatrixIndexubvARB = procedure(size: TGLint; const indices: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6691 TglMatrixIndexusvARB = procedure(size: TGLint; const indices: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6692 TglMatrixIndexuivARB = procedure(size: TGLint; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6693 TglMatrixIndexPointerARB = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6694
6695 // GL_ARB_multisample
6696 TglSampleCoverageARB = procedure(value: TGLclampf; invert: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6697
6698 // GL_ARB_multitexture
6699 TglActiveTextureARB = procedure(texture: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6700 TglClientActiveTextureARB = procedure(texture: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6701 TglMultiTexCoord1dARB = procedure(target: TGLenum; s: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6702 TglMultiTexCoord1dvARB = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6703 TglMultiTexCoord1fARB = procedure(target: TGLenum; s: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6704 TglMultiTexCoord1fvARB = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6705 TglMultiTexCoord1iARB = procedure(target: TGLenum; s: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6706 TglMultiTexCoord1ivARB = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6707 TglMultiTexCoord1sARB = procedure(target: TGLenum; s: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6708 TglMultiTexCoord1svARB = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6709 TglMultiTexCoord2dARB = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6710 TglMultiTexCoord2dvARB = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6711 TglMultiTexCoord2fARB = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6712 TglMultiTexCoord2fvARB = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6713 TglMultiTexCoord2iARB = procedure(target: TGLenum; s: TGLint; t: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6714 TglMultiTexCoord2ivARB = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6715 TglMultiTexCoord2sARB = procedure(target: TGLenum; s: TGLshort; t: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6716 TglMultiTexCoord2svARB = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6717 TglMultiTexCoord3dARB = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble; r: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6718 TglMultiTexCoord3dvARB = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6719 TglMultiTexCoord3fARB = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat; r: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6720 TglMultiTexCoord3fvARB = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6721 TglMultiTexCoord3iARB = procedure(target: TGLenum; s: TGLint; t: TGLint; r: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6722 TglMultiTexCoord3ivARB = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6723 TglMultiTexCoord3sARB = procedure(target: TGLenum; s: TGLshort; t: TGLshort; r: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6724 TglMultiTexCoord3svARB = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6725 TglMultiTexCoord4dARB = procedure(target: TGLenum; s: TGLdouble; t: TGLdouble; r: TGLdouble; q: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6726 TglMultiTexCoord4dvARB = procedure(target: TGLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6727 TglMultiTexCoord4fARB = procedure(target: TGLenum; s: TGLfloat; t: TGLfloat; r: TGLfloat; q: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6728 TglMultiTexCoord4fvARB = procedure(target: TGLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6729 TglMultiTexCoord4iARB = procedure(target: TGLenum; s: TGLint; t: TGLint; r: TGLint; q: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6730 TglMultiTexCoord4ivARB = procedure(target: TGLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6731 TglMultiTexCoord4sARB = procedure(target: TGLenum; s: TGLshort; t: TGLshort; r: TGLshort; q: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6732 TglMultiTexCoord4svARB = procedure(target: TGLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6733
6734 // GL_ARB_point_parameters
6735 TglPointParameterfARB = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6736 TglPointParameterfvARB = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6737
6738 // GL_ARB_texture_compression
6739 TglCompressedTexImage3DARB = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; depth: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6740 TglCompressedTexImage2DARB = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6741 TglCompressedTexImage1DARB = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; border: TGLint; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6742 TglCompressedTexSubImage3DARB = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6743 TglCompressedTexSubImage2DARB = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; width: TGLsizei; height: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6744 TglCompressedTexSubImage1DARB = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; width: TGLsizei; format: TGLenum; imageSize: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6745 TglGetCompressedTexImageARB = procedure(target: TGLenum; level: TGLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6746
6747 // GL_ARB_transpose_matrix
6748 TglLoadTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6749 TglLoadTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6750 TglMultTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6751 TglMultTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6752
6753 // GL_ARB_vertex_blend
6754 TglWeightbvARB = procedure(size: TGLint; const weights: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6755 TglWeightsvARB = procedure(size: TGLint; const weights: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6756 TglWeightivARB = procedure(size: TGLint; const weights: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6757 TglWeightfvARB = procedure(size: TGLint; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6758 TglWeightdvARB = procedure(size: TGLint; const weights: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6759 TglWeightubvARB = procedure(size: TGLint; const weights: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6760 TglWeightusvARB = procedure(size: TGLint; const weights: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6761 TglWeightuivARB = procedure(size: TGLint; const weights: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6762 TglWeightPointerARB = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6763 TglVertexBlendARB = procedure(count: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6764
6765 // GL_ARB_vertex_buffer_object
6766 TglBindBufferARB = procedure(target: TGLenum; buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6767 TglDeleteBuffersARB = procedure(n: TGLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6768 TglGenBuffersARB = procedure(n: TGLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6769 TglIsBufferARB = function(buffer: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6770 TglBufferDataARB = procedure(target: TGLenum; size: TGLsizei; const data: PGLvoid; usage: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6771 TglBufferSubDataARB = procedure(target: TGLenum; offset: TGLsizei; size: TGLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6772 TglGetBufferSubDataARB = procedure(target: TGLenum; offset: TGLsizei; size: TGLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6773 TglMapBufferARB = function(target: TGLenum; access: TGLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6774 TglUnmapBufferARB = function(target: TGLenum): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6775 TglGetBufferParameterivARB = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6776 TglGetBufferPointervARB = procedure(target: TGLenum; pname: TGLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6777
6778 // GL_ARB_vertex_program
6779 TglVertexAttrib1dARB = procedure(index: TGLuint; x: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6780 TglVertexAttrib1dvARB = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6781 TglVertexAttrib1fARB = procedure(index: TGLuint; x: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6782 TglVertexAttrib1fvARB = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6783 TglVertexAttrib1sARB = procedure(index: TGLuint; x: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6784 TglVertexAttrib1svARB = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6785 TglVertexAttrib2dARB = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6786 TglVertexAttrib2dvARB = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6787 TglVertexAttrib2fARB = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6788 TglVertexAttrib2fvARB = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6789 TglVertexAttrib2sARB = procedure(index: TGLuint; x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6790 TglVertexAttrib2svARB = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6791 TglVertexAttrib3dARB = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6792 TglVertexAttrib3dvARB = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6793 TglVertexAttrib3fARB = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6794 TglVertexAttrib3fvARB = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6795 TglVertexAttrib3sARB = procedure(index: TGLuint; x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6796 TglVertexAttrib3svARB = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6797 TglVertexAttrib4NbvARB = procedure(index: TGLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6798 TglVertexAttrib4NivARB = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6799 TglVertexAttrib4NsvARB = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6800 TglVertexAttrib4NubARB = procedure(index: TGLuint; x: TGLubyte; y: TGLubyte; z: TGLubyte; w: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6801 TglVertexAttrib4NubvARB = procedure(index: TGLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6802 TglVertexAttrib4NuivARB = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6803 TglVertexAttrib4NusvARB = procedure(index: TGLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6804 TglVertexAttrib4bvARB = procedure(index: TGLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6805 TglVertexAttrib4dARB = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6806 TglVertexAttrib4dvARB = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6807 TglVertexAttrib4fARB = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6808 TglVertexAttrib4fvARB = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6809 TglVertexAttrib4ivARB = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6810 TglVertexAttrib4sARB = procedure(index: TGLuint; x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6811 TglVertexAttrib4svARB = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6812 TglVertexAttrib4ubvARB = procedure(index: TGLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6813 TglVertexAttrib4uivARB = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6814 TglVertexAttrib4usvARB = procedure(index: TGLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6815 TglVertexAttribPointerARB = procedure(index: TGLuint; size: TGLint; _type: TGLenum; normalized: TGLboolean; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6816 TglEnableVertexAttribArrayARB = procedure(index: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6817 TglDisableVertexAttribArrayARB = procedure(index: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6818 TglProgramStringARB = procedure(target: TGLenum; format: TGLenum; len: TGLsizei; const _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6819 TglBindProgramARB = procedure(target: TGLenum; _program: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6820 TglDeleteProgramsARB = procedure(n: TGLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6821 TglGenProgramsARB = procedure(n: TGLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6822 TglProgramEnvParameter4dARB = procedure(target: TGLenum; index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6823 TglProgramEnvParameter4dvARB = procedure(target: TGLenum; index: TGLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6824 TglProgramEnvParameter4fARB = procedure(target: TGLenum; index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6825 TglProgramEnvParameter4fvARB = procedure(target: TGLenum; index: TGLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6826 TglProgramLocalParameter4dARB = procedure(target: TGLenum; index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6827 TglProgramLocalParameter4dvARB = procedure(target: TGLenum; index: TGLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6828 TglProgramLocalParameter4fARB = procedure(target: TGLenum; index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6829 TglProgramLocalParameter4fvARB = procedure(target: TGLenum; index: TGLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6830 TglGetProgramEnvParameterdvARB = procedure(target: TGLenum; index: TGLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6831 TglGetProgramEnvParameterfvARB = procedure(target: TGLenum; index: TGLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6832 TglGetProgramLocalParameterdvARB = procedure(target: TGLenum; index: TGLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6833 TglGetProgramLocalParameterfvARB = procedure(target: TGLenum; index: TGLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6834 TglGetProgramivARB = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6835 TglGetProgramStringARB = procedure(target: TGLenum; pname: TGLenum; _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6836 TglGetVertexAttribdvARB = procedure(index: TGLuint; pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6837 TglGetVertexAttribfvARB = procedure(index: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6838 TglGetVertexAttribivARB = procedure(index: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6839 TglGetVertexAttribPointervARB = procedure(index: TGLuint; pname: TGLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6840 TglIsProgramARB = function(_program: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6841
6842 // GL_ARB_window_pos
6843 TglWindowPos2dARB = procedure(x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6844 TglWindowPos2dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6845 TglWindowPos2fARB = procedure(x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6846 TglWindowPos2fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6847 TglWindowPos2iARB = procedure(x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6848 TglWindowPos2ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6849 TglWindowPos2sARB = procedure(x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6850 TglWindowPos2svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6851 TglWindowPos3dARB = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6852 TglWindowPos3dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6853 TglWindowPos3fARB = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6854 TglWindowPos3fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6855 TglWindowPos3iARB = procedure(x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6856 TglWindowPos3ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6857 TglWindowPos3sARB = procedure(x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6858 TglWindowPos3svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6859
6860 // GL_ARB_draw_buffers
6861 TglDrawBuffersARB = procedure(n: TGLsizei; bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6862
6863 // GL_ARB_color_buffer_float
6864 TglClampColorARB = procedure(target: TGLenum; clamp: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6865
6866 // GL_ARB_vertex_shader
6867 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}
6868 TglGetAttribLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6869 TglBindAttribLocationARB = procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6870
6871 // GL_ARB_shader_objects
6872 TglDeleteObjectARB = procedure(Obj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6873 TglGetHandleARB = function(pname: GlEnum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6874 TglDetachObjectARB = procedure(container, attached: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6875 TglCreateShaderObjectARB = function(shaderType: glenum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6876 TglShaderSourceARB = procedure(shaderObj: GLHandleARB; count: glsizei; _string: PPGLCharARB; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6877 TglCompileShaderARB = procedure(shaderObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6878 TglCreateProgramObjectARB = function: GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6879 TglAttachObjectARB = procedure(programObj, shaderObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6880 TglLinkProgramARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6881 TglUseProgramObjectARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6882 TglValidateProgramARB = procedure(programObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6883 TglUniform1fARB = procedure(location: glint; v0: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6884 TglUniform2fARB = procedure(location: glint; v0, v1: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6885 TglUniform3fARB = procedure(location: glint; v0, v1, v2: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6886 TglUniform4fARB = procedure(location: glint; v0, v1, v2, v3: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6887 TglUniform1iARB = procedure(location: glint; v0: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6888 TglUniform2iARB = procedure(location: glint; v0, v1: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6889 TglUniform3iARB = procedure(location: glint; v0, v1, v2: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6890 TglUniform4iARB = procedure(location: glint; v0, v1, v2, v3: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6891 TglUniform1fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6892 TglUniform2fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6893 TglUniform3fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6894 TglUniform4fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6895 TglUniform1ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6896 TglUniform2ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6897 TglUniform3ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6898 TglUniform4ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6899 TglUniformMatrix2fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6900 TglUniformMatrix3fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6901 TglUniformMatrix4fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6902 TglGetObjectParameterfvARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6903 TglGetObjectParameterivARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6904 TglGetInfoLogARB = procedure(shaderObj: GLHandleARB; maxLength: glsizei; var length: glint; infoLog: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6905 TglGetAttachedObjectsARB = procedure(programobj: GLhandleARB; maxCount: GLsizei; var count: GLsizei; objects: PGLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6906 TglGetUniformLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6907 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}
6908 TglGetUniformfvARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6909 TglGetUniformivARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6910 TglGetShaderSourceARB = procedure(shader: GLhandleARB; maxLength: GLsizei; var length: GLsizei; source: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6911
6912 // GL_ARB_Occlusion_Query
6913 TglGenQueriesARB = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6914 TglDeleteQueriesARB = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6915 TglIsQueryARB = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6916 TglBeginQueryARB = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6917 TglEndQueryARB = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6918 TglGetQueryivARB = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6919 TglGetQueryObjectivARB = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6920 TglGetQueryObjectuivARB = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6921
6922 // GL_ARB_draw_instanced
6923 TglDrawArraysInstancedARB = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6924 TglDrawElementsInstancedARB = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6925
6926 // GL_ARB_framebuffer_object
6927 TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6928 TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6929 TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6930 TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6931 TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6932 TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6933 TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6934 TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6935 TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6936 TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6937 TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6938 TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6939 TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6940 TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6941 TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6942 TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6943 TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6944 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}
6945 TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6946 TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6947
6948 // GL_ARB_geometry_shader4
6949 TglProgramParameteriARB = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6950 TglFramebufferTextureARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6951 TglFramebufferTextureLayerARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6952 TglFramebufferTextureFaceARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6953
6954 // GL_ARB_instanced_arrays
6955 TglVertexAttribDivisorARB = procedure(index_: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6956
6957 // GL_ARB_map_buffer_range
6958 TglMapBufferRange = function(target: GLenum; offset: GLsizei; length: GLsizei; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6959 TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLsizei; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6960
6961 // GL_ARB_texture_buffer_object
6962 TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6963
6964 // GL_ARB_vertex_array_object
6965 TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6966 TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6967 TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6968 TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6969
6970 // GL_ARB_uniform_buffer_object
6971 TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6972 TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6973 TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6974 TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6975 TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6976 TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6977 TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6978
6979 // GL_ARB_copy_buffer
6980 TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLint; writeOffset: GLint; size: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6981
6982 // GL_ARB_draw_elements_base_vertex
6983 TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6984 TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6985 TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6986 TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6987
6988 // GL_ARB_provoking_vertex
6989 TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6990
6991 // GL_ARB_sync
6992 TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6993 TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6994 TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6995 TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6996 TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6997 TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6998 TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
6999
7000 // GL_ARB_texture_multisample
7001 TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7002 TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7003 TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7004 TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7005
7006 // GL_ARB_draw_buffers_blend
7007 TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7008 TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7009 TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7010 TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7011
7012 // GL_ARB_sample_shading
7013 TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7014
7015 // GL_ATI_draw_buffers
7016 TglDrawBuffersATI = procedure(n: TGLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7017
7018 // GL_ATI_element_array
7019 TglElementPointerATI = procedure(_type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7020 TglDrawElementArrayATI = procedure(mode: TGLenum; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7021 TglDrawRangeElementArrayATI = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7022
7023 // GL_ATI_envmap_bumpmap
7024 TglTexBumpParameterivATI = procedure(pname: TGLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7025 TglTexBumpParameterfvATI = procedure(pname: TGLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7026 TglGetTexBumpParameterivATI = procedure(pname: TGLenum; param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7027 TglGetTexBumpParameterfvATI = procedure(pname: TGLenum; param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7028
7029 // GL_ATI_fragment_shader
7030 TglGenFragmentShadersATI = function(range: TGLuint): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7031 TglBindFragmentShaderATI = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7032 TglDeleteFragmentShaderATI = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7033 TglBeginFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7034 TglEndFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7035 TglPassTexCoordATI = procedure(dst: TGLuint; coord: TGLuint; swizzle: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7036 TglSampleMapATI = procedure(dst: TGLuint; interp: TGLuint; swizzle: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7037 TglColorFragmentOp1ATI = procedure(op: TGLenum; dst: TGLuint; dstMask: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7038 TglColorFragmentOp2ATI = procedure(op: TGLenum; dst: TGLuint; dstMask: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint; arg2: TGLuint; arg2Rep: TGLuint; arg2Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7039 TglColorFragmentOp3ATI = procedure(op: TGLenum; dst: TGLuint; dstMask: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint; arg2: TGLuint; arg2Rep: TGLuint; arg2Mod: TGLuint; arg3: TGLuint; arg3Rep: TGLuint; arg3Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7040 TglAlphaFragmentOp1ATI = procedure(op: TGLenum; dst: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7041 TglAlphaFragmentOp2ATI = procedure(op: TGLenum; dst: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint; arg2: TGLuint; arg2Rep: TGLuint; arg2Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7042 TglAlphaFragmentOp3ATI = procedure(op: TGLenum; dst: TGLuint; dstMod: TGLuint; arg1: TGLuint; arg1Rep: TGLuint; arg1Mod: TGLuint; arg2: TGLuint; arg2Rep: TGLuint; arg2Mod: TGLuint; arg3: TGLuint; arg3Rep: TGLuint; arg3Mod: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7043 TglSetFragmentShaderConstantATI = procedure(dst: TGLuint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7044
7045 // GL_ATI_map_object_buffer
7046 TglMapObjectBufferATI = function(buffer: TGLuint): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7047 TglUnmapObjectBufferATI = procedure(buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7048
7049 // GL_ATI_pn_triangles
7050 TglPNTrianglesiATI = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7051 TglPNTrianglesfATI = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7052
7053 // GL_ATI_separate_stencil
7054 TglStencilOpSeparateATI = procedure(face: TGLenum; sfail: TGLenum; dpfail: TGLenum; dppass: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7055 TglStencilFuncSeparateATI = procedure(frontfunc: TGLenum; backfunc: TGLenum; ref: TGLint; mask: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7056
7057 // GL_ATI_vertex_array_object
7058 TglNewObjectBufferATI = function(size: TGLsizei; const _pointer: PGLvoid; usage: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7059 TglIsObjectBufferATI = function(buffer: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7060 TglUpdateObjectBufferATI = procedure(buffer: TGLuint; offset: TGLuint; size: TGLsizei; const _pointer: PGLvoid; preserve: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7061 TglGetObjectBufferfvATI = procedure(buffer: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7062 TglGetObjectBufferivATI = procedure(buffer: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7063 TglFreeObjectBufferATI = procedure(buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7064 TglArrayObjectATI = procedure(_array: TGLenum; size: TGLint; _type: TGLenum; stride: TGLsizei; buffer: TGLuint; offset: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7065 TglGetArrayObjectfvATI = procedure(_array: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7066 TglGetArrayObjectivATI = procedure(_array: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7067 TglVariantArrayObjectATI = procedure(id: TGLuint; _type: TGLenum; stride: TGLsizei; buffer: TGLuint; offset: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7068 TglGetVariantArrayObjectfvATI = procedure(id: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7069 TglGetVariantArrayObjectivATI = procedure(id: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7070
7071 // GL_ATI_vertex_attrib_array_object
7072 TglVertexAttribArrayObjectATI = procedure(index: TGLuint; size: TGLint; _type: TGLenum; normalized: TGLboolean; stride: TGLsizei; buffer: TGLuint; offset: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7073 TglGetVertexAttribArrayObjectfvATI = procedure(index: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7074 TglGetVertexAttribArrayObjectivATI = procedure(index: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7075
7076 // GL_ATI_vertex_streams
7077 TglVertexStream1sATI = procedure(stream: TGLenum; x: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7078 TglVertexStream1svATI = procedure(stream: TGLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7079 TglVertexStream1iATI = procedure(stream: TGLenum; x: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7080 TglVertexStream1ivATI = procedure(stream: TGLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7081 TglVertexStream1fATI = procedure(stream: TGLenum; x: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7082 TglVertexStream1fvATI = procedure(stream: TGLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7083 TglVertexStream1dATI = procedure(stream: TGLenum; x: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7084 TglVertexStream1dvATI = procedure(stream: TGLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7085 TglVertexStream2sATI = procedure(stream: TGLenum; x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7086 TglVertexStream2svATI = procedure(stream: TGLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7087 TglVertexStream2iATI = procedure(stream: TGLenum; x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7088 TglVertexStream2ivATI = procedure(stream: TGLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7089 TglVertexStream2fATI = procedure(stream: TGLenum; x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7090 TglVertexStream2fvATI = procedure(stream: TGLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7091 TglVertexStream2dATI = procedure(stream: TGLenum; x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7092 TglVertexStream2dvATI = procedure(stream: TGLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7093 TglVertexStream3sATI = procedure(stream: TGLenum; x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7094 TglVertexStream3svATI = procedure(stream: TGLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7095 TglVertexStream3iATI = procedure(stream: TGLenum; x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7096 TglVertexStream3ivATI = procedure(stream: TGLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7097 TglVertexStream3fATI = procedure(stream: TGLenum; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7098 TglVertexStream3fvATI = procedure(stream: TGLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7099 TglVertexStream3dATI = procedure(stream: TGLenum; x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7100 TglVertexStream3dvATI = procedure(stream: TGLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7101 TglVertexStream4sATI = procedure(stream: TGLenum; x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7102 TglVertexStream4svATI = procedure(stream: TGLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7103 TglVertexStream4iATI = procedure(stream: TGLenum; x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7104 TglVertexStream4ivATI = procedure(stream: TGLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7105 TglVertexStream4fATI = procedure(stream: TGLenum; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7106 TglVertexStream4fvATI = procedure(stream: TGLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7107 TglVertexStream4dATI = procedure(stream: TGLenum; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7108 TglVertexStream4dvATI = procedure(stream: TGLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7109 TglNormalStream3bATI = procedure(stream: TGLenum; nx: TGLbyte; ny: TGLbyte; nz: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7110 TglNormalStream3bvATI = procedure(stream: TGLenum; const coords: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7111 TglNormalStream3sATI = procedure(stream: TGLenum; nx: TGLshort; ny: TGLshort; nz: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7112 TglNormalStream3svATI = procedure(stream: TGLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7113 TglNormalStream3iATI = procedure(stream: TGLenum; nx: TGLint; ny: TGLint; nz: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7114 TglNormalStream3ivATI = procedure(stream: TGLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7115 TglNormalStream3fATI = procedure(stream: TGLenum; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7116 TglNormalStream3fvATI = procedure(stream: TGLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7117 TglNormalStream3dATI = procedure(stream: TGLenum; nx: TGLdouble; ny: TGLdouble; nz: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7118 TglNormalStream3dvATI = procedure(stream: TGLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7119 TglClientActiveVertexStreamATI = procedure(stream: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7120 TglVertexBlendEnviATI = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7121 TglVertexBlendEnvfATI = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7122
7123 // GL_AMD_performance_monitor
7124 TglGetPerfMonitorGroupsAMD = procedure(numGroups: PGLint; groupsSize: GLsizei; groups: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7125 TglGetPerfMonitorCountersAMD = procedure(group: GLuint; numCounters: PGLint; maxActiveCouters: PGLint; counterSize: GLsizei; counters: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7126 TglGetPerfMonitorGroupStringAMD = procedure(group: GLuint; bufSize: GLsizei; length: PGLsizei; groupString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7127 TglGetPerfMonitorCounterStringAMD = procedure(group: GLuint; counter: GLuint; bufSize: GLsizei; length: PGLsizei; counterString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7128 TglGetPerfMonitorCounterInfoAMD = procedure(group: GLuint; counter: GLuint; pname: GLenum; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7129 TglGenPerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7130 TglDeletePerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7131 TglSelectPerfMonitorCountersAMD = procedure(monitor: GLuint; enable: GLboolean; group: GLuint; numCounters: GLint; counterList: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7132 TglBeginPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7133 TglEndPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7134 TglGetPerfMonitorCounterDataAMD = procedure(monitor: GLuint; pname: GLenum; dataSize: GLsizei; data: PGLuint; bytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7135
7136 // GL_AMD_vertex_shader_tesselator
7137 TglTessellationFactorAMD = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7138 TglTessellationModeAMD = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7139
7140
7141 // GL_EXT_blend_color
7142 TglBlendColorEXT = procedure(red: TGLclampf; green: TGLclampf; blue: TGLclampf; alpha: TGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7143
7144 // GL_EXT_blend_func_separate
7145 TglBlendFuncSeparateEXT = procedure(sfactorRGB: TGLenum; dfactorRGB: TGLenum; sfactorAlpha: TGLenum; dfactorAlpha: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7146
7147 // GL_EXT_blend_minmax
7148 TglBlendEquationEXT = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7149
7150 // GL_EXT_color_subtable
7151 TglColorSubTableEXT = procedure(target: TGLenum; start: TGLsizei; count: TGLsizei; format: TGLenum; _type: TGLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7152 TglCopyColorSubTableEXT = procedure(target: TGLenum; start: TGLsizei; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7153
7154 // GL_EXT_compiled_vertex_array
7155 TglLockArraysEXT = procedure(first: TGLint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7156 TglUnlockArraysEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7157
7158 // GL_EXT_convolution
7159 TglConvolutionFilter1DEXT = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; format: TGLenum; _type: TGLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7160 TglConvolutionFilter2DEXT = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7161 TglConvolutionParameterfEXT = procedure(target: TGLenum; pname: TGLenum; params: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7162 TglConvolutionParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7163 TglConvolutionParameteriEXT = procedure(target: TGLenum; pname: TGLenum; params: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7164 TglConvolutionParameterivEXT = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7165 TglCopyConvolutionFilter1DEXT = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7166 TglCopyConvolutionFilter2DEXT = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7167 TglGetConvolutionFilterEXT = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7168 TglGetConvolutionParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7169 TglGetConvolutionParameterivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7170 TglGetSeparableFilterEXT = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7171 TglSeparableFilter2DEXT = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7172
7173 // GL_EXT_coordinate_frame
7174 TglTangent3bEXT = procedure(tx: TGLbyte; ty: TGLbyte; tz: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7175 TglTangent3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7176 TglTangent3dEXT = procedure(tx: TGLdouble; ty: TGLdouble; tz: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7177 TglTangent3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7178 TglTangent3fEXT = procedure(tx: TGLfloat; ty: TGLfloat; tz: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7179 TglTangent3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7180 TglTangent3iEXT = procedure(tx: TGLint; ty: TGLint; tz: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7181 TglTangent3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7182 TglTangent3sEXT = procedure(tx: TGLshort; ty: TGLshort; tz: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7183 TglTangent3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7184 TglBinormal3bEXT = procedure(bx: TGLbyte; by: TGLbyte; bz: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7185 TglBinormal3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7186 TglBinormal3dEXT = procedure(bx: TGLdouble; by: TGLdouble; bz: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7187 TglBinormal3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7188 TglBinormal3fEXT = procedure(bx: TGLfloat; by: TGLfloat; bz: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7189 TglBinormal3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7190 TglBinormal3iEXT = procedure(bx: TGLint; by: TGLint; bz: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7191 TglBinormal3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7192 TglBinormal3sEXT = procedure(bx: TGLshort; by: TGLshort; bz: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7193 TglBinormal3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7194 TglTangentPointerEXT = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7195 TglBinormalPointerEXT = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7196
7197 // GL_EXT_copy_texture
7198 TglCopyTexImage1DEXT = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; border: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7199 TglCopyTexImage2DEXT = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei; border: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7200 TglCopyTexSubImage1DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7201 TglCopyTexSubImage2DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7202 TglCopyTexSubImage3DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7203
7204 // GL_EXT_cull_vertex
7205 TglCullParameterdvEXT = procedure(pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7206 TglCullParameterfvEXT = procedure(pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7207
7208 // GL_EXT_draw_range_elements
7209 TglDrawRangeElementsEXT = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; count: TGLsizei; _type: TGLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7210
7211 // GL_EXT_fog_coord
7212 TglFogCoordfEXT = procedure(coord: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7213 TglFogCoordfvEXT = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7214 TglFogCoorddEXT = procedure(coord: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7215 TglFogCoorddvEXT = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7216 TglFogCoordPointerEXT = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7217
7218 // GL_EXT_framebuffer_object
7219 TglIsRenderbufferEXT = function(renderbuffer: TGLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7220 TglBindRenderbufferEXT = procedure(target: TGLenum; renderbuffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7221 TglDeleteRenderbuffersEXT = procedure(n: TGLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7222 TglGenRenderbuffersEXT = procedure(n: TGLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7223 TglRenderbufferStorageEXT = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7224 TglGetRenderbufferParameterivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7225 TglIsFramebufferEXT = function(framebuffer: TGLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7226 TglBindFramebufferEXT = procedure(target: TGLenum; framebuffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7227 TglDeleteFramebuffersEXT = procedure(n: TGLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7228 TglGenFramebuffersEXT = procedure(n: TGLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7229 TglCheckFramebufferStatusEXT = function(target: TGLenum): TGLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7230 TglFramebufferTexture1DEXT = procedure(target: TGLenum; attachment: TGLenum; textarget: TGLenum; texture: TGLuint; level: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7231 TglFramebufferTexture2DEXT = procedure(target: TGLenum; attachment: TGLenum; textarget: TGLenum; texture: TGLuint; level: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7232 TglFramebufferTexture3DEXT = procedure(target: TGLenum; attachment: TGLenum; textarget: TGLenum; texture: TGLuint; level: TGLint; zoffset: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7233 TglFramebufferRenderbufferEXT = procedure(target: TGLenum; attachment: TGLenum; renderbuffertarget: TGLenum; renderbuffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7234 TglGetFramebufferAttachmentParameterivEXT = procedure(target: TGLenum; attachment: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7235 TglGenerateMipmapEXT = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7236
7237 // GL_EXT_histogram
7238 TglGetHistogramEXT = procedure(target: TGLenum; reset: TGLboolean; format: TGLenum; _type: TGLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7239 TglGetHistogramParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7240 TglGetHistogramParameterivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7241 TglGetMinmaxEXT = procedure(target: TGLenum; reset: TGLboolean; format: TGLenum; _type: TGLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7242 TglGetMinmaxParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7243 TglGetMinmaxParameterivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7244 TglHistogramEXT = procedure(target: TGLenum; width: TGLsizei; internalformat: TGLenum; sink: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7245 TglMinmaxEXT = procedure(target: TGLenum; internalformat: TGLenum; sink: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7246 TglResetHistogramEXT = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7247 TglResetMinmaxEXT = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7248
7249 // GL_EXT_index_func
7250 TglIndexFuncEXT = procedure(func: TGLenum; ref: TGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7251
7252 // GL_EXT_index_material
7253 TglIndexMaterialEXT = procedure(face: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7254
7255 // GL_EXT_light_texture
7256 TglApplyTextureEXT = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7257 TglTextureLightEXT = procedure(pname: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7258 TglTextureMaterialEXT = procedure(face: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7259
7260 // GL_EXT_multi_draw_arrays
7261 TglMultiDrawArraysEXT = procedure(mode: TGLenum; first: PGLint; count: PGLsizei; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7262 TglMultiDrawElementsEXT = procedure(mode: TGLenum; const count: PGLsizei; _type: TGLenum; const indices: PGLvoid; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7263
7264 // GL_EXT_multisample
7265 TglSampleMaskEXT = procedure(value: TGLclampf; invert: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7266 TglSamplePatternEXT = procedure(pattern: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7267
7268 // GL_EXT_paletted_texture
7269 TglColorTableEXT = procedure(target: TGLenum; internalFormat: TGLenum; width: TGLsizei; format: TGLenum; _type: TGLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7270 TglGetColorTableEXT = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7271 TglGetColorTableParameterivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7272 TglGetColorTableParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7273
7274 // GL_EXT_pixel_transform
7275 TglPixelTransformParameteriEXT = procedure(target: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7276 TglPixelTransformParameterfEXT = procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7277 TglPixelTransformParameterivEXT = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7278 TglPixelTransformParameterfvEXT = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7279
7280 // GL_EXT_point_parameters
7281 TglPointParameterfEXT = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7282 TglPointParameterfvEXT = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7283
7284 // GL_EXT_polygon_offset
7285 TglPolygonOffsetEXT = procedure(factor: TGLfloat; bias: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7286
7287 // GL_EXT_secondary_color
7288 TglSecondaryColor3bEXT = procedure(red: TGLbyte; green: TGLbyte; blue: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7289 TglSecondaryColor3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7290 TglSecondaryColor3dEXT = procedure(red: TGLdouble; green: TGLdouble; blue: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7291 TglSecondaryColor3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7292 TglSecondaryColor3fEXT = procedure(red: TGLfloat; green: TGLfloat; blue: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7293 TglSecondaryColor3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7294 TglSecondaryColor3iEXT = procedure(red: TGLint; green: TGLint; blue: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7295 TglSecondaryColor3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7296 TglSecondaryColor3sEXT = procedure(red: TGLshort; green: TGLshort; blue: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7297 TglSecondaryColor3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7298 TglSecondaryColor3ubEXT = procedure(red: TGLubyte; green: TGLubyte; blue: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7299 TglSecondaryColor3ubvEXT = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7300 TglSecondaryColor3uiEXT = procedure(red: TGLuint; green: TGLuint; blue: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7301 TglSecondaryColor3uivEXT = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7302 TglSecondaryColor3usEXT = procedure(red: TGLushort; green: TGLushort; blue: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7303 TglSecondaryColor3usvEXT = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7304 TglSecondaryColorPointerEXT = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7305
7306 // GL_EXT_stencil_two_side
7307 TglActiveStencilFaceEXT = procedure(face: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7308
7309 // GL_EXT_subtexture
7310 TglTexSubImage1DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; width: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7311 TglTexSubImage2DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; width: TGLsizei; height: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7312
7313 // GL_EXT_texture3D
7314 TglTexImage3DEXT = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; depth: TGLsizei; border: TGLint; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7315 TglTexSubImage3DEXT = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7316
7317 // GL_EXT_texture_object
7318 TglAreTexturesResidentEXT = function(n: TGLsizei; const textures: PGLuint; residences: PGLboolean): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7319 TglBindTextureEXT = procedure(target: TGLenum; texture: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7320 TglDeleteTexturesEXT = procedure(n: TGLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7321 TglGenTexturesEXT = procedure(n: TGLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7322 TglIsTextureEXT = function(texture: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7323 TglPrioritizeTexturesEXT = procedure(n: TGLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7324
7325 // GL_EXT_texture_perturb_normal
7326 TglTextureNormalEXT = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7327
7328 // GL_EXT_vertex_array
7329 TglArrayElementEXT = procedure(i: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7330 TglColorPointerEXT = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; count: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7331 TglDrawArraysEXT = procedure(mode: TGLenum; first: TGLint; count: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7332 TglEdgeFlagPointerEXT = procedure(stride: TGLsizei; count: TGLsizei; const _pointer: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7333 TglGetPointervEXT = procedure(pname: TGLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7334 TglIndexPointerEXT = procedure(_type: TGLenum; stride: TGLsizei; count: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7335 TglNormalPointerEXT = procedure(_type: TGLenum; stride: TGLsizei; count: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7336 TglTexCoordPointerEXT = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; count: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7337 TglVertexPointerEXT = procedure(size: TGLint; _type: TGLenum; stride: TGLsizei; count: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7338
7339 // GL_EXT_vertex_shader
7340 TglBeginVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7341 TglEndVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7342 TglBindVertexShaderEXT = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7343 TglGenVertexShadersEXT = function(range: TGLuint): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7344 TglDeleteVertexShaderEXT = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7345 TglShaderOp1EXT = procedure(op: TGLenum; res: TGLuint; arg1: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7346 TglShaderOp2EXT = procedure(op: TGLenum; res: TGLuint; arg1: TGLuint; arg2: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7347 TglShaderOp3EXT = procedure(op: TGLenum; res: TGLuint; arg1: TGLuint; arg2: TGLuint; arg3: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7348 TglSwizzleEXT = procedure(res: TGLuint; _in: TGLuint; outX: TGLenum; outY: TGLenum; outZ: TGLenum; outW: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7349 TglWriteMaskEXT = procedure(res: TGLuint; _in: TGLuint; outX: TGLenum; outY: TGLenum; outZ: TGLenum; outW: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7350 TglInsertComponentEXT = procedure(res: TGLuint; src: TGLuint; num: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7351 TglExtractComponentEXT = procedure(res: TGLuint; src: TGLuint; num: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7352 TglGenSymbolsEXT = function(datatype: TGLenum; storagetype: TGLenum; range: TGLenum; components: TGLuint): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7353 TglSetInvariantEXT = procedure(id: TGLuint; _type: TGLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7354 TglSetLocalConstantEXT = procedure(id: TGLuint; _type: TGLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7355 TglVariantbvEXT = procedure(id: TGLuint; const addr: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7356 TglVariantsvEXT = procedure(id: TGLuint; const addr: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7357 TglVariantivEXT = procedure(id: TGLuint; const addr: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7358 TglVariantfvEXT = procedure(id: TGLuint; const addr: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7359 TglVariantdvEXT = procedure(id: TGLuint; const addr: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7360 TglVariantubvEXT = procedure(id: TGLuint; const addr: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7361 TglVariantusvEXT = procedure(id: TGLuint; const addr: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7362 TglVariantuivEXT = procedure(id: TGLuint; const addr: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7363 TglVariantPointerEXT = procedure(id: TGLuint; _type: TGLenum; stride: TGLuint; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7364 TglEnableVariantClientStateEXT = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7365 TglDisableVariantClientStateEXT = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7366 TglBindLightParameterEXT = function(light: TGLenum; value: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7367 TglBindMaterialParameterEXT = function(face: TGLenum; value: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7368 TglBindTexGenParameterEXT = function(_unit: TGLenum; coord: TGLenum; value: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7369 TglBindTextureUnitParameterEXT = function(_unit: TGLenum; value: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7370 TglBindParameterEXT = function(value: TGLenum): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7371 TglIsVariantEnabledEXT = function(id: TGLuint; cap: TGLenum): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7372 TglGetVariantBooleanvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7373 TglGetVariantIntegervEXT = procedure(id: TGLuint; value: TGLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7374 TglGetVariantFloatvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7375 TglGetVariantPointervEXT = procedure(id: TGLuint; value: TGLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7376 TglGetInvariantBooleanvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7377 TglGetInvariantIntegervEXT = procedure(id: TGLuint; value: TGLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7378 TglGetInvariantFloatvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7379 TglGetLocalConstantBooleanvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7380 TglGetLocalConstantIntegervEXT = procedure(id: TGLuint; value: TGLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7381 TglGetLocalConstantFloatvEXT = procedure(id: TGLuint; value: TGLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7382
7383 // GL_EXT_vertex_weighting
7384 TglVertexWeightfEXT = procedure(weight: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7385 TglVertexWeightfvEXT = procedure(const weight: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7386 TglVertexWeightPointerEXT = procedure(size: TGLsizei; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7387
7388 // GL_EXT_stencil_clear_tag
7389 TglStencilClearTagEXT = procedure(stencilTagBits: TGLsizei; stencilClearTag: Tgluint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7390
7391 // GL_EXT_framebuffer_blit
7392 TglBlitFramebufferEXT = procedure(srcX0: TGLint; srcY0: TGLint; srcX1: TGLint; srcY1: TGLint; dstX0: TGLint; dstY0: TGLint; dstX1: TGLint; dstY1: TGLint; mask: TGLbitfield; filter: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7393
7394 // GL_EXT_framebuffer_multisample
7395 TglRenderbufferStorageMultisampleEXT = procedure(target: TGLenum; samples: TGLsizei; internalformat: TGLenum; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7396
7397 // GL_EXT_timer_query
7398 TglGetQueryObjecti64vEXT = procedure(id: TGLuint; pname: TGLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7399 TglGetQueryObjectui64vEXT = procedure(id: TGLuint; pname: TGLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7400
7401 // GL_EXT_gpu_program_parameters
7402 TglProgramEnvParameters4fvEXT = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7403 TglProgramLocalParameters4fvEXT = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7404
7405 // GL_EXT_bindable_uniform
7406 TglUniformBufferEXT = procedure(_program: TGLuint; location: TGLint; buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7407 TglGetUniformBufferSizeEXT = function(_program: TGLuint; location: TGLint): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7408 TglGetUniformOffsetEXT = function(_program: TGLuint; location: TGLint): PGLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7409
7410 // GL_EXT_draw_buffers2
7411 TglColorMaskIndexedEXT = procedure(buf: TGLuint; r: TGLboolean; g: TGLboolean; b: TGLboolean; a: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7412 TglGetBooleanIndexedvEXT = procedure(value: TGLenum; index: TGLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7413 TglGetIntegerIndexedvEXT = procedure(value: TGLenum; index: TGLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7414 TglEnableIndexedEXT = procedure(target: TGLenum; index: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7415 TglDisableIndexedEXT = procedure(target: TGLenum; index: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7416 TglIsEnabledIndexedEXT = function(target: TGLenum; index: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7417
7418 // GL_EXT_draw_instanced
7419 TglDrawArraysInstancedEXT = procedure(mode: TGLenum; first: TGLint; count: TGLsizei; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7420 TglDrawElementsInstancedEXT = procedure(mode: TGLenum; count: TGLsizei; _type: TGLenum; const indices: Pointer; primcount: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7421
7422 // GL_EXT_geometry_shader4
7423 TglProgramParameteriEXT = procedure (_program: TGLuint; pname: TGLenum; value: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7424 TglFramebufferTextureEXT = procedure(target: TGLenum; attachment: TGLenum; texture: TGLuint; level: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7425 // TglFramebufferTextureLayerEXT = procedure(target: TGLenum; attachment: TGLenum; texture: TGLuint; level: TGLint; layer: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7426 TglFramebufferTextureFaceEXT = procedure(target: TGLenum; attachment: TGLenum; texture: TGLuint; level: TGLint; face: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7427
7428 // GL_EXT_gpu_shader4
7429 TglVertexAttribI1iEXT = procedure(index: TGLuint; x: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7430 TglVertexAttribI2iEXT = procedure(index: TGLuint; x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7431 TglVertexAttribI3iEXT = procedure(index: TGLuint; x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7432 TglVertexAttribI4iEXT = procedure(index: TGLuint; x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7433 TglVertexAttribI1uiEXT = procedure(index: TGLuint; x: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7434 TglVertexAttribI2uiEXT = procedure(index: TGLuint; x: TGLuint; y: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7435 TglVertexAttribI3uiEXT = procedure(index: TGLuint; x: TGLuint; y: TGLuint; z: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7436 TglVertexAttribI4uiEXT = procedure(index: TGLuint; x: TGLuint; y: TGLuint; z: TGLuint; w: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7437 TglVertexAttribI1ivEXT = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7438 TglVertexAttribI2ivEXT = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7439 TglVertexAttribI3ivEXT = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7440 TglVertexAttribI4ivEXT = procedure(index: TGLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7441 TglVertexAttribI1uivEXT = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7442 TglVertexAttribI2uivEXT = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7443 TglVertexAttribI3uivEXT = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7444 TglVertexAttribI4uivEXT = procedure(index: TGLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7445 TglVertexAttribI4bvEXT = procedure(index: TGLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7446 TglVertexAttribI4svEXT = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7447 TglVertexAttribI4ubvEXT = procedure(index: TGLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7448 TglVertexAttribI4usvEXT = procedure(index: TGLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7449 TglVertexAttribIPointerEXT = procedure(index: TGLuint; size: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7450 TglGetVertexAttribIivEXT = procedure(index: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7451 TglGetVertexAttribIuivEXT = procedure(index: TGLuint; pname: TGLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7452 TglUniform1uiEXT = procedure(location: TGLint; v0: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7453 TglUniform2uiEXT = procedure(location: TGLint; v0: TGLuint; v1: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7454 TglUniform3uiEXT = procedure(location: TGLint; v0: TGLuint; v1: TGLuint; v2: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7455 TglUniform4uiEXT = procedure(location: TGLint; v0: TGLuint; v1: TGLuint; v2: TGLuint; v3: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7456 TglUniform1uivEXT = procedure(location: TGLint; count: TGLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7457 TglUniform2uivEXT = procedure(location: TGLint; count: TGLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7458 TglUniform3uivEXT = procedure(location: TGLint; count: TGLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7459 TglUniform4uivEXT = procedure(location: TGLint; count: TGLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7460 TglGetUniformuivEXT = procedure(_program: TGLuint; location: TGLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7461 TglBindFragDataLocationEXT = procedure(_program: TGLuint; colorNumber: TGLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7462 TglGetFragDataLocationEXT = function(_program: TGLuint; const name: PGLchar): TGLint;
7463
7464 // GL_EXT_texture_array
7465 TglFramebufferTextureLayerEXT = procedure(target: TGLenum; attachment: TGLenum; texture: TGLuint; level: TGLint; layer: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7466
7467 // GL_EXT_texture_buffer_object
7468 TglTexBufferEXT = procedure(target: TGLenum; internalformat: TGLenum; buffer: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7469
7470 // GL_EXT_texture_integer
7471 TglClearColorIiEXT = procedure(r: TGLint; g: TGLint; b: TGLint; a: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7472 TglClearColorIuiEXT = procedure(r: TGLuint; g: TGLuint; b: TGLuint; a: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7473 TglTexParameterIivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7474 TglTexParameterIuivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7475 TglGetTexParameterIivEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7476 TglGetTexParameterIiuvEXT = procedure(target: TGLenum; pname: TGLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7477
7478 // GL_HP_image_transform
7479 TglImageTransformParameteriHP = procedure(target: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7480 TglImageTransformParameterfHP = procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7481 TglImageTransformParameterivHP = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7482 TglImageTransformParameterfvHP = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7483 TglGetImageTransformParameterivHP = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7484 TglGetImageTransformParameterfvHP = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7485
7486 // GL_EXT_depth_bounds_test
7487 TglDepthBoundsEXT = procedure(zmin: TGLclampd; zmax: TGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7488
7489 // GL_EXT_blend_equation_separate
7490 TglBlendEquationSeparateEXT = procedure(modeRGB: TGLenum; modeAlpha: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7491
7492 // GL_EXT_transform_feedback
7493 TglBeginTransformFeedbackEXT = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7494 TglEndTransformFeedbackEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7495 TglBindBufferRangeEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLsizei; size: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7496 TglBindBufferOffsetEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7497 TglBindBufferBaseEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7498 TglTransformFeedbackVaryingsEXT = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7499 TglGetTransformFeedbackVaryingEXT = procedure(program_: GLuint; index_: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7500
7501 // GL_EXT_direct_state_access
7502 TglClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7503 TglPushClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7504 TglMatrixLoadfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7505 TglMatrixLoaddEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7506 TglMatrixMultfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7507 TglMatrixMultdEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7508 TglMatrixLoadIdentityEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7509 TglMatrixRotatefEXT = procedure(mode: GLenum; angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7510 TglMatrixRotatedEXT = procedure(mode: GLenum; angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7511 TglMatrixScalefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7512 TglMatrixScaledEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7513 TglMatrixTranslatefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7514 TglMatrixTranslatedEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7515 TglMatrixFrustumEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7516 TglMatrixOrthoEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7517 TglMatrixPopEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7518 TglMatrixPushEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7519 TglMatrixLoadTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7520 TglMatrixLoadTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7521 TglMatrixMultTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7522 TglMatrixMultTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7523 TglTextureParameterfEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7524 TglTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7525 TglTextureParameteriEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7526 TglTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7527 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}
7528 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}
7529 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}
7530 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}
7531 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}
7532 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}
7533 TglCopyTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7534 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}
7535 TglGetTextureImageEXT = procedure(texture: GLuint; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7536 TglGetTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7537 TglGetTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7538 TglGetTextureLevelParameterfvEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7539 TglGetTextureLevelParameterivEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7540 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}
7541 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}
7542 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}
7543 TglMultiTexParameterfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7544 TglMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7545 TglMultiTexParameteriEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7546 TglMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7547 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}
7548 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}
7549 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}
7550 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}
7551 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}
7552 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}
7553 TglCopyMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7554 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}
7555 TglGetMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7556 TglGetMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7557 TglGetMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7558 TglGetMultiTexLevelParameterfvEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7559 TglGetMultiTexLevelParameterivEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7560 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}
7561 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}
7562 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}
7563 TglBindMultiTextureEXT = procedure(texunit: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7564 TglEnableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7565 TglDisableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7566 TglMultiTexCoordPointerEXT = procedure(texunit: GLenum; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7567 TglMultiTexEnvfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7568 TglMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7569 TglMultiTexEnviEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7570 TglMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7571 TglMultiTexGendEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7572 TglMultiTexGendvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7573 TglMultiTexGenfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7574 TglMultiTexGenfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7575 TglMultiTexGeniEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7576 TglMultiTexGenivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7577 TglGetMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7578 TglGetMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7579 TglGetMultiTexGendvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7580 TglGetMultiTexGenfvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7581 TglGetMultiTexGenivEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7582 TglGetFloatIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7583 TglGetDoubleIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7584 TglGetPointerIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7585 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}
7586 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}
7587 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}
7588 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}
7589 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}
7590 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}
7591 TglGetCompressedTextureImageEXT = procedure(texture: GLuint; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7592 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}
7593 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}
7594 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}
7595 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}
7596 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}
7597 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}
7598 TglGetCompressedMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7599 TglNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; format: GLenum; len: GLsizei; const string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7600 TglNamedProgramLocalParameter4dEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7601 TglNamedProgramLocalParameter4dvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7602 TglNamedProgramLocalParameter4fEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7603 TglNamedProgramLocalParameter4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7604 TglGetNamedProgramLocalParameterdvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7605 TglGetNamedProgramLocalParameterfvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7606 TglGetNamedProgramivEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7607 TglGetNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7608 TglNamedProgramLocalParameters4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7609 TglNamedProgramLocalParameterI4iEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7610 TglNamedProgramLocalParameterI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7611 TglNamedProgramLocalParametersI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7612 TglNamedProgramLocalParameterI4uiEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7613 TglNamedProgramLocalParameterI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7614 TglNamedProgramLocalParametersI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7615 TglGetNamedProgramLocalParameterIivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7616 TglGetNamedProgramLocalParameterIuivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7617 TglTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7618 TglTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7619 TglGetTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7620 TglGetTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7621 TglMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7622 TglMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7623 TglGetMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7624 TglGetMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7625 TglProgramUniform1fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7626 TglProgramUniform2fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7627 TglProgramUniform3fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7628 TglProgramUniform4fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7629 TglProgramUniform1iEXT = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7630 TglProgramUniform2iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7631 TglProgramUniform3iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7632 TglProgramUniform4iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7633 TglProgramUniform1fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7634 TglProgramUniform2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7635 TglProgramUniform3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7636 TglProgramUniform4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7637 TglProgramUniform1ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7638 TglProgramUniform2ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7639 TglProgramUniform3ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7640 TglProgramUniform4ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7641 TglProgramUniformMatrix2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7642 TglProgramUniformMatrix3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7643 TglProgramUniformMatrix4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7644 TglProgramUniformMatrix2x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7645 TglProgramUniformMatrix3x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7646 TglProgramUniformMatrix2x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7647 TglProgramUniformMatrix4x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7648 TglProgramUniformMatrix3x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7649 TglProgramUniformMatrix4x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7650 TglProgramUniform1uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7651 TglProgramUniform2uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7652 TglProgramUniform3uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7653 TglProgramUniform4uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7654 TglProgramUniform1uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7655 TglProgramUniform2uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7656 TglProgramUniform3uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7657 TglProgramUniform4uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7658 TglNamedBufferDataEXT = procedure(buffer: GLuint; size: GLsizei; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7659 TglNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLsizei; size: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7660 TglMapNamedBufferEXT = function(buffer: GLuint; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7661 TglUnmapNamedBufferEXT = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7662 TglGetNamedBufferParameterivEXT = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7663 TglGetNamedBufferPointervEXT = procedure(buffer: GLuint; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7664 TglGetNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLsizei; size: GLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7665 TglTextureBufferEXT = procedure(texture: GLuint; target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7666 TglMultiTexBufferEXT = procedure(texunit: GLenum; target: GLenum; interformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7667 TglNamedRenderbufferStorageEXT = procedure(renderbuffer: GLuint; interformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7668 TglGetNamedRenderbufferParameterivEXT = procedure(renderbuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7669 TglCheckNamedFramebufferStatusEXT = function(framebuffer: GLuint; target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7670 TglNamedFramebufferTexture1DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7671 TglNamedFramebufferTexture2DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7672 TglNamedFramebufferTexture3DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7673 TglNamedFramebufferRenderbufferEXT = procedure(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7674 TglGetNamedFramebufferAttachmentParameterivEXT = procedure(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7675 TglGenerateTextureMipmapEXT = procedure(texture: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7676 TglGenerateMultiTexMipmapEXT = procedure(texunit: GLenum; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7677 TglFramebufferDrawBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7678 TglFramebufferDrawBuffersEXT = procedure(framebuffer: GLuint; n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7679 TglFramebufferReadBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7680 TglGetFramebufferParameterivEXT = procedure(framebuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7681 TglNamedRenderbufferStorageMultisampleEXT = procedure(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7682 TglNamedRenderbufferStorageMultisampleCoverageEXT = procedure(renderbuffer: GLuint; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7683 TglNamedFramebufferTextureEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7684 TglNamedFramebufferTextureLayerEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7685 TglNamedFramebufferTextureFaceEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7686 TglTextureRenderbufferEXT = procedure(texture: GLuint; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7687 TglMultiTexRenderbufferEXT = procedure(texunit: GLenum; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7688
7689 // GL_IBM_multimode_draw_arrays
7690 TglMultiModeDrawArraysIBM = procedure(mode: TGLenum; const first: PGLint; const count: PGLsizei; primcount: TGLsizei; modestride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7691 TglMultiModeDrawElementsIBM = procedure(const mode: PGLenum; const count: PGLsizei; _type: TGLenum; const indices: PGLvoid; primcount: TGLsizei; modestride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7692
7693 // GL_IBM_vertex_array_lists
7694 TglColorPointerListIBM = procedure(size: TGLint; _type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7695 TglSecondaryColorPointerListIBM = procedure(size: TGLint; _type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7696 TglEdgeFlagPointerListIBM = procedure(stride: TGLint; const _pointer: PGLboolean; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7697 TglFogCoordPointerListIBM = procedure(_type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7698 TglIndexPointerListIBM = procedure(_type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7699 TglNormalPointerListIBM = procedure(_type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7700 TglTexCoordPointerListIBM = procedure(size: TGLint; _type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7701 TglVertexPointerListIBM = procedure(size: TGLint; _type: TGLenum; stride: TGLint; const _pointer: PGLvoid; ptrstride: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7702
7703 // GL_INGR_blend_func_separate
7704 TglBlendFuncSeparateINGR = procedure(sfactorRGB: TGLenum; dfactorRGB: TGLenum; sfactorAlpha: TGLenum; dfactorAlpha: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7705
7706 // GL_INTEL_parallel_arrays
7707 TglVertexPointervINTEL = procedure(size: TGLint; _type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7708 TglNormalPointervINTEL = procedure(_type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7709 TglColorPointervINTEL = procedure(size: TGLint; _type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7710 TglTexCoordPointervINTEL = procedure(size: TGLint; _type: TGLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7711
7712 // GL_MESA_resize_buffers
7713 TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7714
7715 // GL_MESA_window_pos
7716 TglWindowPos2dMESA = procedure(x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7717 TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7718 TglWindowPos2fMESA = procedure(x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7719 TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7720 TglWindowPos2iMESA = procedure(x: TGLint; y: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7721 TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7722 TglWindowPos2sMESA = procedure(x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7723 TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7724 TglWindowPos3dMESA = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7725 TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7726 TglWindowPos3fMESA = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7727 TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7728 TglWindowPos3iMESA = procedure(x: TGLint; y: TGLint; z: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7729 TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7730 TglWindowPos3sMESA = procedure(x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7731 TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7732 TglWindowPos4dMESA = procedure(x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7733 TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7734 TglWindowPos4fMESA = procedure(x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7735 TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7736 TglWindowPos4iMESA = procedure(x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7737 TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7738 TglWindowPos4sMESA = procedure(x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7739 TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7740
7741 // GL_NV_evaluators
7742 TglMapControlPointsNV = procedure(target: TGLenum; index: TGLuint; _type: TGLenum; ustride: TGLsizei; vstride: TGLsizei; uorder: TGLint; vorder: TGLint; _packed: TGLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7743 TglMapParameterivNV = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7744 TglMapParameterfvNV = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7745 TglGetMapControlPointsNV = procedure(target: TGLenum; index: TGLuint; _type: TGLenum; ustride: TGLsizei; vstride: TGLsizei; _packed: TGLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7746 TglGetMapParameterivNV = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7747 TglGetMapParameterfvNV = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7748 TglGetMapAttribParameterivNV = procedure(target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7749 TglGetMapAttribParameterfvNV = procedure(target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7750 TglEvalMapsNV = procedure(target: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7751
7752 // GL_NV_fence
7753 TglDeleteFencesNV = procedure(n: TGLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7754 TglGenFencesNV = procedure(n: TGLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7755 TglIsFenceNV = function(fence: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7756 TglTestFenceNV = function(fence: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7757 TglGetFenceivNV = procedure(fence: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7758 TglFinishFenceNV = procedure(fence: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7759 TglSetFenceNV = procedure(fence: TGLuint; condition: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7760
7761 // GL_NV_fragment_program
7762 TglProgramNamedParameter4fNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7763 TglProgramNamedParameter4dNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7764 TglProgramNamedParameter4fvNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7765 TglProgramNamedParameter4dvNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7766 TglGetProgramNamedParameterfvNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7767 TglGetProgramNamedParameterdvNV = procedure(id: TGLuint; len: TGLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7768
7769 // GL_NV_half_float
7770 TglVertex2hNV = procedure(x: TGLhalfNV; y: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7771 TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7772 TglVertex3hNV = procedure(x: TGLhalfNV; y: TGLhalfNV; z: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7773 TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7774 TglVertex4hNV = procedure(x: TGLhalfNV; y: TGLhalfNV; z: TGLhalfNV; w: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7775 TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7776 TglNormal3hNV = procedure(nx: TGLhalfNV; ny: TGLhalfNV; nz: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7777 TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7778 TglColor3hNV = procedure(red: TGLhalfNV; green: TGLhalfNV; blue: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7779 TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7780 TglColor4hNV = procedure(red: TGLhalfNV; green: TGLhalfNV; blue: TGLhalfNV; alpha: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7781 TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7782 TglTexCoord1hNV = procedure(s: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7783 TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7784 TglTexCoord2hNV = procedure(s: TGLhalfNV; t: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7785 TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7786 TglTexCoord3hNV = procedure(s: TGLhalfNV; t: TGLhalfNV; r: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7787 TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7788 TglTexCoord4hNV = procedure(s: TGLhalfNV; t: TGLhalfNV; r: TGLhalfNV; q: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7789 TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7790 TglMultiTexCoord1hNV = procedure(target: TGLenum; s: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7791 TglMultiTexCoord1hvNV = procedure(target: TGLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7792 TglMultiTexCoord2hNV = procedure(target: TGLenum; s: TGLhalfNV; t: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7793 TglMultiTexCoord2hvNV = procedure(target: TGLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7794 TglMultiTexCoord3hNV = procedure(target: TGLenum; s: TGLhalfNV; t: TGLhalfNV; r: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7795 TglMultiTexCoord3hvNV = procedure(target: TGLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7796 TglMultiTexCoord4hNV = procedure(target: TGLenum; s: TGLhalfNV; t: TGLhalfNV; r: TGLhalfNV; q: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7797 TglMultiTexCoord4hvNV = procedure(target: TGLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7798 TglFogCoordhNV = procedure(fog: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7799 TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7800 TglSecondaryColor3hNV = procedure(red: TGLhalfNV; green: TGLhalfNV; blue: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7801 TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7802 TglVertexWeighthNV = procedure(weight: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7803 TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7804 TglVertexAttrib1hNV = procedure(index: TGLuint; x: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7805 TglVertexAttrib1hvNV = procedure(index: TGLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7806 TglVertexAttrib2hNV = procedure(index: TGLuint; x: TGLhalfNV; y: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7807 TglVertexAttrib2hvNV = procedure(index: TGLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7808 TglVertexAttrib3hNV = procedure(index: TGLuint; x: TGLhalfNV; y: TGLhalfNV; z: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7809 TglVertexAttrib3hvNV = procedure(index: TGLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7810 TglVertexAttrib4hNV = procedure(index: TGLuint; x: TGLhalfNV; y: TGLhalfNV; z: TGLhalfNV; w: TGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7811 TglVertexAttrib4hvNV = procedure(index: TGLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7812 TglVertexAttribs1hvNV = procedure(index: TGLuint; n: TGLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7813 TglVertexAttribs2hvNV = procedure(index: TGLuint; n: TGLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7814 TglVertexAttribs3hvNV = procedure(index: TGLuint; n: TGLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7815 TglVertexAttribs4hvNV = procedure(index: TGLuint; n: TGLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7816
7817 // GL_NV_occlusion_query
7818 TglGenOcclusionQueriesNV = procedure(n: TGLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7819 TglDeleteOcclusionQueriesNV = procedure(n: TGLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7820 TglIsOcclusionQueryNV = function(id: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7821 TglBeginOcclusionQueryNV = procedure(id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7822 TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7823 TglGetOcclusionQueryivNV = procedure(id: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7824 TglGetOcclusionQueryuivNV = procedure(id: TGLuint; pname: TGLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7825
7826 // GL_NV_pixel_data_range
7827 TglPixelDataRangeNV = procedure(target: TGLenum; length: TGLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7828 TglFlushPixelDataRangeNV = procedure(target: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7829
7830 // GL_NV_point_sprite
7831 TglPointParameteriNV = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7832 TglPointParameterivNV = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7833
7834 // GL_NV_primitive_restart
7835 TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7836 TglPrimitiveRestartIndexNV = procedure(index: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7837
7838 // GL_NV_register_combiners
7839 TglCombinerParameterfvNV = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7840 TglCombinerParameterfNV = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7841 TglCombinerParameterivNV = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7842 TglCombinerParameteriNV = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7843 TglCombinerInputNV = procedure(stage: TGLenum; portion: TGLenum; variable: TGLenum; input: TGLenum; mapping: TGLenum; componentUsage: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7844 TglCombinerOutputNV = procedure(stage: TGLenum; portion: TGLenum; abOutput: TGLenum; cdOutput: TGLenum; sumOutput: TGLenum; scale: TGLenum; bias: TGLenum; abDotProduct: TGLboolean; cdDotProduct: TGLboolean; muxSum: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7845 TglFinalCombinerInputNV = procedure(variable: TGLenum; input: TGLenum; mapping: TGLenum; componentUsage: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7846 TglGetCombinerInputParameterfvNV = procedure(stage: TGLenum; portion: TGLenum; variable: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7847 TglGetCombinerInputParameterivNV = procedure(stage: TGLenum; portion: TGLenum; variable: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7848 TglGetCombinerOutputParameterfvNV = procedure(stage: TGLenum; portion: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7849 TglGetCombinerOutputParameterivNV = procedure(stage: TGLenum; portion: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7850 TglGetFinalCombinerInputParameterfvNV = procedure(variable: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7851 TglGetFinalCombinerInputParameterivNV = procedure(variable: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7852
7853 // GL_NV_register_combiners2
7854 TglCombinerStageParameterfvNV = procedure(stage: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7855 TglGetCombinerStageParameterfvNV = procedure(stage: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7856
7857 // GL_NV_vertex_array_range
7858 TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7859 TglVertexArrayRangeNV = procedure(length: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7860
7861 // GL_NV_vertex_program
7862 TglAreProgramsResidentNV = function(n: TGLsizei; const programs: PGLuint; residences: PGLboolean): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7863 TglBindProgramNV = procedure(target: TGLenum; id: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7864 TglDeleteProgramsNV = procedure(n: TGLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7865 TglExecuteProgramNV = procedure(target: TGLenum; id: TGLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7866 TglGenProgramsNV = procedure(n: TGLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7867 TglGetProgramParameterdvNV = procedure(target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7868 TglGetProgramParameterfvNV = procedure(target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7869 TglGetProgramivNV = procedure(id: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7870 TglGetProgramStringNV = procedure(id: TGLuint; pname: TGLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7871 TglGetTrackMatrixivNV = procedure(target: TGLenum; address: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7872 TglGetVertexAttribdvNV = procedure(index: TGLuint; pname: TGLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7873 TglGetVertexAttribfvNV = procedure(index: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7874 TglGetVertexAttribivNV = procedure(index: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7875 TglGetVertexAttribPointervNV = procedure(index: TGLuint; pname: TGLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7876 TglIsProgramNV = function(id: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7877 TglLoadProgramNV = procedure(target: TGLenum; id: TGLuint; len: TGLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7878 TglProgramParameter4dNV = procedure(target: TGLenum; index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7879 TglProgramParameter4dvNV = procedure(target: TGLenum; index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7880 TglProgramParameter4fNV = procedure(target: TGLenum; index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7881 TglProgramParameter4fvNV = procedure(target: TGLenum; index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7882 TglProgramParameters4dvNV = procedure(target: TGLenum; index: TGLuint; count: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7883 TglProgramParameters4fvNV = procedure(target: TGLenum; index: TGLuint; count: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7884 TglRequestResidentProgramsNV = procedure(n: TGLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7885 TglTrackMatrixNV = procedure(target: TGLenum; address: TGLuint; matrix: TGLenum; transform: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7886 TglVertexAttribPointerNV = procedure(index: TGLuint; fsize: TGLint; _type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7887 TglVertexAttrib1dNV = procedure(index: TGLuint; x: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7888 TglVertexAttrib1dvNV = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7889 TglVertexAttrib1fNV = procedure(index: TGLuint; x: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7890 TglVertexAttrib1fvNV = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7891 TglVertexAttrib1sNV = procedure(index: TGLuint; x: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7892 TglVertexAttrib1svNV = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7893 TglVertexAttrib2dNV = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7894 TglVertexAttrib2dvNV = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7895 TglVertexAttrib2fNV = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7896 TglVertexAttrib2fvNV = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7897 TglVertexAttrib2sNV = procedure(index: TGLuint; x: TGLshort; y: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7898 TglVertexAttrib2svNV = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7899 TglVertexAttrib3dNV = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7900 TglVertexAttrib3dvNV = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7901 TglVertexAttrib3fNV = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7902 TglVertexAttrib3fvNV = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7903 TglVertexAttrib3sNV = procedure(index: TGLuint; x: TGLshort; y: TGLshort; z: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7904 TglVertexAttrib3svNV = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7905 TglVertexAttrib4dNV = procedure(index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7906 TglVertexAttrib4dvNV = procedure(index: TGLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7907 TglVertexAttrib4fNV = procedure(index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7908 TglVertexAttrib4fvNV = procedure(index: TGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7909 TglVertexAttrib4sNV = procedure(index: TGLuint; x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7910 TglVertexAttrib4svNV = procedure(index: TGLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7911 TglVertexAttrib4ubNV = procedure(index: TGLuint; x: TGLubyte; y: TGLubyte; z: TGLubyte; w: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7912 TglVertexAttrib4ubvNV = procedure(index: TGLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7913 TglVertexAttribs1dvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7914 TglVertexAttribs1fvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7915 TglVertexAttribs1svNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7916 TglVertexAttribs2dvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7917 TglVertexAttribs2fvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7918 TglVertexAttribs2svNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7919 TglVertexAttribs3dvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7920 TglVertexAttribs3fvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7921 TglVertexAttribs3svNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7922 TglVertexAttribs4dvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7923 TglVertexAttribs4fvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7924 TglVertexAttribs4svNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7925 TglVertexAttribs4ubvNV = procedure(index: TGLuint; count: TGLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7926
7927 // GL_NV_depth_buffer_float
7928 TglDepthRangedNV = procedure(n: TGLdouble; f: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7929 TglClearDepthdNV = procedure(d: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7930 TglDepthBoundsdNV = procedure(zmin: TGLdouble; zmax: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7931
7932 // GL_NV_framebuffer_multisample_coverage
7933 TglRenderbufferStorageMultsampleCoverageNV = procedure(target: TGLenum; coverageSamples: TGLsizei; colorSamples: TGLsizei; internalformat: TGLenum; width: TGLsizei; height: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7934
7935 // GL_NV_geometry_program4
7936 TglProgramVertexLimitNV = procedure(target: TGLenum; limit: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7937
7938 // GL_NV_gpu_program4
7939 TglProgramLocalParameterI4iNV = procedure(target: TGLenum; index: TGLuint; x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7940 TglProgramLocalParameterI4ivNV = procedure(target: TGLenum; index: TGLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7941 TglProgramLocalParametersI4ivNV = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7942 TglProgramLocalParameterI4uiNV = procedure(target: TGLenum; index: TGLuint; x: TGLuint; y: TGLuint; z: TGLuint; w: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7943 TglProgramLocalParameterI4uivNV = procedure(target: TGLenum; index: TGLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7944 TglProgramLocalParametersI4uivNV = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7945 TglProgramEnvParameterI4iNV = procedure(target: TGLenum; index: TGLuint; x: TGLint; y: TGLint; z: TGLint; w: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7946 TglProgramEnvParameterI4ivNV = procedure(target: TGLenum; index: TGLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7947 TglProgramEnvParametersI4ivNV = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7948 TglProgramEnvParameterI4uiNV = procedure(target: TGLenum; index: TGLuint; x: TGLuint; y: TGLuint; z: TGLuint; w: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7949 TglProgramEnvParameterI4uivNV = procedure(target: TGLenum; index: TGLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7950 TglProgramEnvParametersI4uivNV = procedure(target: TGLenum; index: TGLuint; count: TGLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7951 TglGetProgramLocalParameterIivNV = procedure(target: TGLenum; index: TGLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7952 TglGetProgramLocalParameterIuivNV = procedure(target: TGLenum; index: TGLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7953 TglGetProgramEnvParameterIivNV = procedure(target: TGLenum; index: TGLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7954 TglGetProgramEnvParameterIuivNV = procedure(target: TGLenum; index: TGLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7955
7956 // GL_NV_parameter_buffer_object
7957 TglProgramBufferParametersfvNV = procedure(target: TGLenum; buffer: TGLuint; index: TGLuint; count: TGLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7958 TglProgramBufferParametersIivNV = procedure(target: TGLenum; buffer: TGLuint; index: TGLuint; count: TGLsizei; const params: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7959 TglProgramBufferParametersIuivNV = procedure(target: TGLenum; buffer: TGLuint; index: TGLuint; count: TGLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7960
7961 // GL_NV_transform_feedback
7962 TglBeginTransformFeedbackNV = procedure(primitiveMode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7963 TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7964 TglTransformFeedbackAttribsNV = procedure(count: TGLsizei; const attribs: TGLint; bufferMode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7965 TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLint; size: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7966 TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7967 TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7968 TglTransformFeedbackVaryingsNV = procedure(program_: TGLuint; count: TGLsizei; const varyings: PPGLchar; bufferMode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7969 TglActiveVaryingNV = procedure(program_: TGLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7970 TglGetVaryingLocationNV = function(program_: TGLuint; const name: PGLchar): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7971 TglGetActiveVaryingNV = procedure(program_: TGLuint; index: TGLuint; bufSize: TGLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7972 TglGetTransformFeedbackVaryingNV = procedure(program_: TGLuint; index: TGLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7973
7974 // GL_NV_conditional_render
7975 TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7976 TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7977
7978 // GL_NV_present_video
7979 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}
7980 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}
7981 TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7982 TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7983 TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7984 TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7985 // TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7986
7987 // GL_NV_explicit_multisample
7988 TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7989 TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7990 TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7991
7992 // GL_NV_transform_feedback2
7993 TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7994 TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7995 TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7996 TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7997 TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7998 TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
7999 TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8000
8001 // GL_PGI_misc_hints
8002 TglHintPGI = procedure(target: TGLenum; mode: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8003
8004 // GL_SGIS_detail_texture
8005 TglDetailTexFuncSGIS = procedure(target: TGLenum; n: TGLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8006 TglGetDetailTexFuncSGIS = procedure(target: TGLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8007
8008 // GL_SGIS_fog_function
8009 TglFogFuncSGIS = procedure(n: TGLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8010 TglGetFogFuncSGIS = procedure(points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8011
8012 // GL_SGIS_multisample
8013 TglSampleMaskSGIS = procedure(value: TGLclampf; invert: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8014 TglSamplePatternSGIS = procedure(pattern: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8015
8016 // GL_SGIS_pixel_texture
8017 TglPixelTexGenParameteriSGIS = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8018 TglPixelTexGenParameterivSGIS = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8019 TglPixelTexGenParameterfSGIS = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8020 TglPixelTexGenParameterfvSGIS = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8021 TglGetPixelTexGenParameterivSGIS = procedure(pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8022 TglGetPixelTexGenParameterfvSGIS = procedure(pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8023
8024 // GL_SGIS_point_parameters
8025 TglPointParameterfSGIS = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8026 TglPointParameterfvSGIS = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8027
8028 // GL_SGIS_sharpen_texture
8029 TglSharpenTexFuncSGIS = procedure(target: TGLenum; n: TGLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8030 TglGetSharpenTexFuncSGIS = procedure(target: TGLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8031
8032 // GL_SGIS_texture4D
8033 TglTexImage4DSGIS = procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width: TGLsizei; height: TGLsizei; depth: TGLsizei; size4d: TGLsizei; border: TGLint; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8034 TglTexSubImage4DSGIS = procedure(target: TGLenum; level: TGLint; xoffset: TGLint; yoffset: TGLint; zoffset: TGLint; woffset: TGLint; width: TGLsizei; height: TGLsizei; depth: TGLsizei; size4d: TGLsizei; format: TGLenum; _type: TGLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8035
8036 // GL_SGIS_texture_color_mask
8037 TglTextureColorMaskSGIS = procedure(red: TGLboolean; green: TGLboolean; blue: TGLboolean; alpha: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8038
8039 // GL_SGIS_texture_filter4
8040 TglGetTexFilterFuncSGIS = procedure(target: TGLenum; filter: TGLenum; weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8041 TglTexFilterFuncSGIS = procedure(target: TGLenum; filter: TGLenum; n: TGLsizei; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8042
8043 // GL_SGIX_async
8044 TglAsyncMarkerSGIX = procedure(marker: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8045 TglFinishAsyncSGIX = function(markerp: PGLuint): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8046 TglPollAsyncSGIX = function(markerp: PGLuint): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8047 TglGenAsyncMarkersSGIX = function(range: TGLsizei): TGLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8048 TglDeleteAsyncMarkersSGIX = procedure(marker: TGLuint; range: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8049 TglIsAsyncMarkerSGIX = function(marker: TGLuint): TGLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8050
8051 // GL_SGIX_flush_raster
8052 TglFlushRasterSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8053
8054 // GL_SGIX_fragment_lighting
8055 TglFragmentColorMaterialSGIX = procedure(face: TGLenum; mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8056 TglFragmentLightfSGIX = procedure(light: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8057 TglFragmentLightfvSGIX = procedure(light: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8058 TglFragmentLightiSGIX = procedure(light: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8059 TglFragmentLightivSGIX = procedure(light: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8060 TglFragmentLightModelfSGIX = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8061 TglFragmentLightModelfvSGIX = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8062 TglFragmentLightModeliSGIX = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8063 TglFragmentLightModelivSGIX = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8064 TglFragmentMaterialfSGIX = procedure(face: TGLenum; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8065 TglFragmentMaterialfvSGIX = procedure(face: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8066 TglFragmentMaterialiSGIX = procedure(face: TGLenum; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8067 TglFragmentMaterialivSGIX = procedure(face: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8068 TglGetFragmentLightfvSGIX = procedure(light: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8069 TglGetFragmentLightivSGIX = procedure(light: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8070 TglGetFragmentMaterialfvSGIX = procedure(face: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8071 TglGetFragmentMaterialivSGIX = procedure(face: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8072 TglLightEnviSGIX = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8073
8074 // GL_SGIX_framezoom
8075 TglFrameZoomSGIX = procedure(factor: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8076
8077 // GL_SGIX_igloo_interface
8078 TglIglooInterfaceSGIX = procedure(pname: TGLenum; const params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8079
8080 // GL_SGIX_instruments
8081 TglGetInstrumentsSGIX = function(): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8082 TglInstrumentsBufferSGIX = procedure(size: TGLsizei; buffer: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8083 TglPollInstrumentsSGIX = function(marker_p: PGLint): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8084 TglReadInstrumentsSGIX = procedure(marker: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8085 TglStartInstrumentsSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8086 TglStopInstrumentsSGIX = procedure(marker: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8087
8088 // GL_SGIX_list_priority
8089 TglGetListParameterfvSGIX = procedure(list: TGLuint; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8090 TglGetListParameterivSGIX = procedure(list: TGLuint; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8091 TglListParameterfSGIX = procedure(list: TGLuint; pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8092 TglListParameterfvSGIX = procedure(list: TGLuint; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8093 TglListParameteriSGIX = procedure(list: TGLuint; pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8094 TglListParameterivSGIX = procedure(list: TGLuint; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8095
8096 // GL_SGIX_pixel_texture
8097 TglPixelTexGenSGIX = procedure(mode: TGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8098
8099 // GL_SGIX_polynomial_ffd
8100 TglDeformationMap3dSGIX = procedure(target: TGLenum; u1: TGLdouble; u2: TGLdouble; ustride: TGLint; uorder: TGLint; v1: TGLdouble; v2: TGLdouble; vstride: TGLint; vorder: TGLint; w1: TGLdouble; w2: TGLdouble; wstride: TGLint; worder: TGLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8101 TglDeformationMap3fSGIX = procedure(target: TGLenum; u1: TGLfloat; u2: TGLfloat; ustride: TGLint; uorder: TGLint; v1: TGLfloat; v2: TGLfloat; vstride: TGLint; vorder: TGLint; w1: TGLfloat; w2: TGLfloat; wstride: TGLint; worder: TGLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8102 TglDeformSGIX = procedure(mask: TGLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8103 TglLoadIdentityDeformationMapSGIX = procedure(mask: TGLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8104
8105 // GL_SGIX_reference_plane
8106 TglReferencePlaneSGIX = procedure(const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8107
8108 // GL_SGIX_sprite
8109 TglSpriteParameterfSGIX = procedure(pname: TGLenum; param: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8110 TglSpriteParameterfvSGIX = procedure(pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8111 TglSpriteParameteriSGIX = procedure(pname: TGLenum; param: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8112 TglSpriteParameterivSGIX = procedure(pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8113
8114 // GL_SGIX_tag_sample_buffer
8115 TglTagSampleBufferSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8116
8117 // GL_SGI_color_table
8118 TglColorTableSGI = procedure(target: TGLenum; internalformat: TGLenum; width: TGLsizei; format: TGLenum; _type: TGLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8119 TglColorTableParameterfvSGI = procedure(target: TGLenum; pname: TGLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8120 TglColorTableParameterivSGI = procedure(target: TGLenum; pname: TGLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8121 TglCopyColorTableSGI = procedure(target: TGLenum; internalformat: TGLenum; x: TGLint; y: TGLint; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8122 TglGetColorTableSGI = procedure(target: TGLenum; format: TGLenum; _type: TGLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8123 TglGetColorTableParameterfvSGI = procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8124 TglGetColorTableParameterivSGI = procedure(target: TGLenum; pname: TGLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8125
8126 // GL_SUNX_constant_data
8127 TglFinishTextureSUNX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8128
8129 // GL_SUN_global_alpha
8130 TglGlobalAlphaFactorbSUN = procedure(factor: TGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8131 TglGlobalAlphaFactorsSUN = procedure(factor: TGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8132 TglGlobalAlphaFactoriSUN = procedure(factor: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8133 TglGlobalAlphaFactorfSUN = procedure(factor: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8134 TglGlobalAlphaFactordSUN = procedure(factor: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8135 TglGlobalAlphaFactorubSUN = procedure(factor: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8136 TglGlobalAlphaFactorusSUN = procedure(factor: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8137 TglGlobalAlphaFactoruiSUN = procedure(factor: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8138
8139 // GL_SUN_mesh_array
8140 TglDrawMeshArraysSUN = procedure(mode: TGLenum; first: TGLint; count: TGLsizei; width: TGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8141
8142 // GL_SUN_triangle_list
8143 TglReplacementCodeuiSUN = procedure(code: TGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8144 TglReplacementCodeusSUN = procedure(code: TGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8145 TglReplacementCodeubSUN = procedure(code: TGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8146 TglReplacementCodeuivSUN = procedure(const code: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8147 TglReplacementCodeusvSUN = procedure(const code: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8148 TglReplacementCodeubvSUN = procedure(const code: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8149 TglReplacementCodePointerSUN = procedure(_type: TGLenum; stride: TGLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8150
8151 // GL_SUN_vertex
8152 TglColor4ubVertex2fSUN = procedure(r: TGLubyte; g: TGLubyte; b: TGLubyte; a: TGLubyte; x: TGLfloat; y: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8153 TglColor4ubVertex2fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8154 TglColor4ubVertex3fSUN = procedure(r: TGLubyte; g: TGLubyte; b: TGLubyte; a: TGLubyte; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8155 TglColor4ubVertex3fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8156 TglColor3fVertex3fSUN = procedure(r: TGLfloat; g: TGLfloat; b: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8157 TglColor3fVertex3fvSUN = procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8158 TglNormal3fVertex3fSUN = procedure(nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8159 TglNormal3fVertex3fvSUN = procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8160 TglColor4fNormal3fVertex3fSUN = procedure(r: TGLfloat; g: TGLfloat; b: TGLfloat; a: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8161 TglColor4fNormal3fVertex3fvSUN = procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8162 TglTexCoord2fVertex3fSUN = procedure(s: TGLfloat; t: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8163 TglTexCoord2fVertex3fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8164 TglTexCoord4fVertex4fSUN = procedure(s: TGLfloat; t: TGLfloat; p: TGLfloat; q: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8165 TglTexCoord4fVertex4fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8166 TglTexCoord2fColor4ubVertex3fSUN = procedure(s: TGLfloat; t: TGLfloat; r: TGLubyte; g: TGLubyte; b: TGLubyte; a: TGLubyte; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8167 TglTexCoord2fColor4ubVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8168 TglTexCoord2fColor3fVertex3fSUN = procedure(s: TGLfloat; t: TGLfloat; r: TGLfloat; g: TGLfloat; b: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8169 TglTexCoord2fColor3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8170 TglTexCoord2fNormal3fVertex3fSUN = procedure(s: TGLfloat; t: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8171 TglTexCoord2fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8172 TglTexCoord2fColor4fNormal3fVertex3fSUN = procedure(s: TGLfloat; t: TGLfloat; r: TGLfloat; g: TGLfloat; b: TGLfloat; a: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8173 TglTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8174 TglTexCoord4fColor4fNormal3fVertex4fSUN = procedure(s: TGLfloat; t: TGLfloat; p: TGLfloat; q: TGLfloat; r: TGLfloat; g: TGLfloat; b: TGLfloat; a: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8175 TglTexCoord4fColor4fNormal3fVertex4fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8176 TglReplacementCodeuiVertex3fSUN = procedure(rc: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8177 TglReplacementCodeuiVertex3fvSUN = procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8178 TglReplacementCodeuiColor4ubVertex3fSUN = procedure(rc: TGLuint; r: TGLubyte; g: TGLubyte; b: TGLubyte; a: TGLubyte; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8179 TglReplacementCodeuiColor4ubVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8180 TglReplacementCodeuiColor3fVertex3fSUN = procedure(rc: TGLuint; r: TGLfloat; g: TGLfloat; b: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8181 TglReplacementCodeuiColor3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8182 TglReplacementCodeuiNormal3fVertex3fSUN = procedure(rc: TGLuint; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8183 TglReplacementCodeuiNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8184 TglReplacementCodeuiColor4fNormal3fVertex3fSUN = procedure(rc: TGLuint; r: TGLfloat; g: TGLfloat; b: TGLfloat; a: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8185 TglReplacementCodeuiColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8186 TglReplacementCodeuiTexCoord2fVertex3fSUN = procedure(rc: TGLuint; s: TGLfloat; t: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8187 TglReplacementCodeuiTexCoord2fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8188 TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = procedure(rc: TGLuint; s: TGLfloat; t: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8189 TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8190 TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = procedure(rc: TGLuint; s: TGLfloat; t: TGLfloat; r: TGLfloat; g: TGLfloat; b: TGLfloat; a: TGLfloat; nx: TGLfloat; ny: TGLfloat; nz: TGLfloat; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8191 TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8192
8193 // window support functions
8194 {$IFDEF DGL_WIN}
8195 TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall;
8196 TwglCopyContext = function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;
8197 TwglCreateContext = function(DC: HDC): HGLRC; stdcall;
8198 TwglCreateLayerContext = function(p1: HDC; p2: Integer): HGLRC; stdcall;
8199 TwglDeleteContext = function(p1: HGLRC): BOOL; stdcall;
8200 TwglDescribeLayerPlane = function(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall;
8201 TwglGetCurrentContext = function: HGLRC; stdcall;
8202 TwglGetCurrentDC = function: HDC; stdcall;
8203 TwglGetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
8204 TwglMakeCurrent = function(DC: HDC; p2: HGLRC): BOOL; stdcall;
8205 TwglRealizeLayerPalette = function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;
8206 TwglSetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
8207 TwglShareLists = function(p1, p2: HGLRC): BOOL; stdcall;
8208 TwglSwapLayerBuffers = function(p1: HDC; p2: Cardinal): BOOL; stdcall;
8209 TwglSwapMultipleBuffers = function(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall;
8210 TwglUseFontBitmapsA = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
8211 TwglUseFontBitmapsW = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
8212 TwglUseFontBitmaps = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
8213
8214 TwglUseFontOutlinesA = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
8215 TwglUseFontOutlinesW = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
8216 TwglUseFontOutlines = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
8217
8218
8219 // WGL_ARB_buffer_region
8220 TwglCreateBufferRegionARB = function(hDC: HDC; iLayerPlane: TGLint; uType: TGLuint): THandle; stdcall;
8221 TwglDeleteBufferRegionARB = procedure(hRegion: THandle); stdcall;
8222 TwglSaveBufferRegionARB = function(hRegion: THandle; x: TGLint; y: TGLint; width: TGLint; height: TGLint): Boolean; stdcall;
8223 TwglRestoreBufferRegionARB = function(hRegion: THandle; x: TGLint; y: TGLint; width: TGLint; height: TGLint; xSrc: TGLint; ySrc: TGLint): Boolean; stdcall;
8224
8225 // WGL_ARB_extensions_string
8226 TwglGetExtensionsStringARB = function(hdc: HDC): PAnsiChar; stdcall;
8227
8228 // WGL_ARB_make_current_read
8229 TwglMakeContextCurrentARB = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
8230 TwglGetCurrentReadDCARB = function(): HDC; stdcall;
8231
8232 // WGL_ARB_pbuffer
8233 TwglCreatePbufferARB = function(hDC: HDC; iPixelFormat: TGLint; iWidth: TGLint; iHeight: TGLint; const piAttribList: PGLint): HPBUFFERARB; stdcall;
8234 TwglGetPbufferDCARB = function(hPbuffer: HPBUFFERARB): HDC; stdcall;
8235 TwglReleasePbufferDCARB = function(hPbuffer: HPBUFFERARB; hDC: HDC): TGLint; stdcall;
8236 TwglDestroyPbufferARB = function(hPbuffer: HPBUFFERARB): Boolean; stdcall;
8237 TwglQueryPbufferARB = function(hPbuffer: HPBUFFERARB; iAttribute: TGLint; piValue: PGLint): Boolean; stdcall;
8238
8239 // WGL_ARB_pixel_format
8240 TwglGetPixelFormatAttribivARB = function(hdc: HDC; iPixelFormat: TGLint; iLayerPlane: TGLint; nAttributes: TGLuint; const piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
8241 TwglGetPixelFormatAttribfvARB = function(hdc: HDC; iPixelFormat: TGLint; iLayerPlane: TGLint; nAttributes: TGLuint; const piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
8242 TwglChoosePixelFormatARB = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: TGLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; stdcall;
8243
8244 // WGL_ARB_color_buffer_float
8245 TwglClampColorARB = procedure(target: TGLenum; clamp: TGLenum); stdcall;
8246
8247 // WGL_ARB_render_texture
8248 TwglBindTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: TGLint): Boolean; stdcall;
8249 TwglReleaseTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: TGLint): Boolean; stdcall;
8250 TwglSetPbufferAttribARB = function(hPbuffer: HPBUFFERARB; const piAttribList: PGLint): Boolean; stdcall;
8251
8252 // WGL_ARB_create_context
8253 TwglCreateContextAttribsARB = function(hDC: HDC; hShareContext: HGLRC; const attribList: PGLint): HGLRC; stdcall;
8254
8255 // WGL_AMD_gpu_association
8256 TwglGetGPUIDsAMD = function(maxCount: Cardinal; ids: PCardinal): Cardinal; stdcall;
8257 TwglGetGPUInfoAMD = function(id: Cardinal; property_: Integer; dataType: GLenum; size: Cardinal; data: Pointer): Integer; stdcall;
8258 TwglGetContextGPUIDAMD = function(hglrc: HGLRC): Cardinal; stdcall;
8259 TwglCreateAssociatedContextAMD = function(id: Cardinal): HGLRC; stdcall;
8260 TwglCreateAssociatedContextAttribsAMD = function(id: Cardinal; hShareContext: HGLRC; const attribList: PInteger): HGLRC; stdcall;
8261 TwglDeleteAssociatedContextAMD = function(hglrc: HGLRC): Boolean; stdcall;
8262 TwglMakeAssociatedContextCurrentAMD = function(hglrc: HGLRC): Boolean; stdcall;
8263 TwglGetCurrentAssociatedContextAMD = function(): HGLRC; stdcall;
8264 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;
8265
8266 // WGL_EXT_display_color_table
8267 TwglCreateDisplayColorTableEXT = function(id: TGLushort): TGLboolean; stdcall;
8268 TwglLoadDisplayColorTableEXT = function(const table: PGLushort; length: TGLuint): TGLboolean; stdcall;
8269 TwglBindDisplayColorTableEXT = function(id: TGLushort): TGLboolean; stdcall;
8270 TwglDestroyDisplayColorTableEXT = procedure(id: TGLushort); stdcall;
8271
8272 // WGL_EXT_extensions_string
8273 TwglGetExtensionsStringEXT = function(): PAnsiChar; stdcall;
8274
8275 // WGL_EXT_make_current_read
8276 TwglMakeContextCurrentEXT = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
8277 TwglGetCurrentReadDCEXT = function(): HDC; stdcall;
8278
8279 // WGL_EXT_pbuffer
8280 TwglCreatePbufferEXT = function(hDC: HDC; iPixelFormat: TGLint; iWidth: TGLint; iHeight: TGLint; const piAttribList: PGLint): HPBUFFEREXT; stdcall;
8281 TwglGetPbufferDCEXT = function(hPbuffer: HPBUFFEREXT): HDC; stdcall;
8282 TwglReleasePbufferDCEXT = function(hPbuffer: HPBUFFEREXT; hDC: HDC): TGLint; stdcall;
8283 TwglDestroyPbufferEXT = function(hPbuffer: HPBUFFEREXT): Boolean; stdcall;
8284 TwglQueryPbufferEXT = function(hPbuffer: HPBUFFEREXT; iAttribute: TGLint; piValue: PGLint): Boolean; stdcall;
8285
8286 // WGL_EXT_pixel_format
8287 TwglGetPixelFormatAttribivEXT = function(hdc: HDC; iPixelFormat: TGLint; iLayerPlane: TGLint; nAttributes: TGLuint; piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
8288 TwglGetPixelFormatAttribfvEXT = function(hdc: HDC; iPixelFormat: TGLint; iLayerPlane: TGLint; nAttributes: TGLuint; piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
8289 TwglChoosePixelFormatEXT = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: TGLuint; piFormats: PGLint; nNumFormats: PGLuint): Boolean; stdcall;
8290
8291 // WGL_EXT_swap_control
8292 TwglSwapIntervalEXT = function(interval: TGLint): Boolean; stdcall;
8293 TwglGetSwapIntervalEXT = function(): TGLint; stdcall;
8294
8295 // WGL_I3D_digital_video_control
8296 TwglGetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: TGLint; piValue: PGLint): Boolean; stdcall;
8297 TwglSetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: TGLint; const piValue: PGLint): Boolean; stdcall;
8298
8299 // WGL_I3D_gamma
8300 TwglGetGammaTableParametersI3D = function(hDC: HDC; iAttribute: TGLint; piValue: PGLint): Boolean; stdcall;
8301 TwglSetGammaTableParametersI3D = function(hDC: HDC; iAttribute: TGLint; const piValue: PGLint): Boolean; stdcall;
8302 TwglGetGammaTableI3D = function(hDC: HDC; iEntries: TGLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): Boolean; stdcall;
8303 TwglSetGammaTableI3D = function(hDC: HDC; iEntries: TGLint; const puRed: PGLushort; const puGreen: PGLushort; const puBlue: PGLushort): Boolean; stdcall;
8304
8305 // WGL_I3D_genlock
8306 TwglEnableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
8307 TwglDisableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
8308 TwglIsEnabledGenlockI3D = function(hDC: HDC; pFlag: Boolean): Boolean; stdcall;
8309 TwglGenlockSourceI3D = function(hDC: HDC; uSource: TGLuint): Boolean; stdcall;
8310 TwglGetGenlockSourceI3D = function(hDC: HDC; uSource: PGLuint): Boolean; stdcall;
8311 TwglGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: TGLuint): Boolean; stdcall;
8312 TwglGetGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: PGLuint): Boolean; stdcall;
8313 TwglGenlockSampleRateI3D = function(hDC: HDC; uRate: TGLuint): Boolean; stdcall;
8314 TwglGetGenlockSampleRateI3D = function(hDC: HDC; uRate: PGLuint): Boolean; stdcall;
8315 TwglGenlockSourceDelayI3D = function(hDC: HDC; uDelay: TGLuint): Boolean; stdcall;
8316 TwglGetGenlockSourceDelayI3D = function(hDC: HDC; uDelay: PGLuint): Boolean; stdcall;
8317 TwglQueryGenlockMaxSourceDelayI3D = function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): Boolean; stdcall;
8318
8319 // WGL_I3D_image_buffer
8320 TwglCreateImageBufferI3D = function(hDC: HDC; dwSize: TGLuint; uFlags: TGLuint): TGLvoid; stdcall;
8321 TwglDestroyImageBufferI3D = function(hDC: HDC; pAddress: TGLvoid): Boolean; stdcall;
8322 TwglAssociateImageBufferEventsI3D = function(hDC: HDC; const pEvent: THandle; const pAddress: PGLvoid; const pSize: PGLuint; count: TGLuint): Boolean; stdcall;
8323 TwglReleaseImageBufferEventsI3D = function(hDC: HDC; const pAddress: PGLvoid; count: TGLuint): Boolean; stdcall;
8324
8325 // WGL_I3D_swap_frame_lock
8326 TwglEnableFrameLockI3D = function(): Boolean; stdcall;
8327 TwglDisableFrameLockI3D = function(): Boolean; stdcall;
8328 TwglIsEnabledFrameLockI3D = function(pFlag: Boolean): Boolean; stdcall;
8329 TwglQueryFrameLockMasterI3D = function(pFlag: Boolean): Boolean; stdcall;
8330
8331 // WGL_I3D_swap_frame_usage
8332 TwglGetFrameUsageI3D = function(pUsage: PGLfloat): Boolean; stdcall;
8333 TwglBeginFrameTrackingI3D = function(): Boolean; stdcall;
8334 TwglEndFrameTrackingI3D = function(): Boolean; stdcall;
8335 TwglQueryFrameTrackingI3D = function(pFrameCount: PGLuint; pMissedFrames: PGLuint; pLastMissedUsage: PGLfloat): Boolean; stdcall;
8336
8337 // WGL_NV_vertex_array_range
8338 TwglAllocateMemoryNV = procedure(size: TGLsizei; readfreq: TGLfloat; writefreq: TGLfloat; priority: TGLfloat); stdcall;
8339 TwglFreeMemoryNV = procedure(_pointer: Pointer); stdcall;
8340
8341 // WGL_NV_present_video
8342 TwglEnumerateVideoDevicesNV = function(hdc: HDC; phDeviceList: PHVIDEOOUTPUTDEVICENV): Integer; stdcall;
8343 TwglBindVideoDeviceNV = function(hd: HDC; uVideoSlot: Cardinal; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: PInteger): Boolean; stdcall;
8344 TwglQueryCurrentContextNV = function(iAttribute: Integer; piValue: PInteger): Boolean; stdcall;
8345
8346 // WGL_NV_video_out
8347 TwglGetVideoDeviceNV = function(hDC: HDC; numDevices: Integer; hVideoDevice: PHPVIDEODEV): Boolean; stdcall;
8348 TwglReleaseVideoDeviceNV = function(hVideoDevice: HPVIDEODEV): Boolean; stdcall;
8349 TwglBindVideoImageNV = function(hVideoDevice: HPVIDEODEV; hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
8350 TwglReleaseVideoImageNV = function(hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
8351 TwglSendPbufferToVideoNV = function(hPbuffer: HPBUFFERARB; iBufferType: Integer; pulCounterPbuffer: PCardinal; bBlock: Boolean): Boolean; stdcall;
8352 TwglGetVideoInfoNV = function(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: PCardinal; pulCounterOutputVideo: PCardinal): Boolean; stdcall;
8353
8354 // WGL_NV_swap_group
8355 TwglJoinSwapGroupNV = function(hDC: HDC; group: GLuint): Boolean; stdcall;
8356 TwglBindSwapBarrierNV = function(group: GLuint; barrier: GLuint): Boolean; stdcall;
8357 TwglQuerySwapGroupNV = function(hDC: HDC; group: PGLuint; barrier: PGLuint): Boolean; stdcall;
8358 TwglQueryMaxSwapGroupsNV = function(hDC: HDC; mxGroups: PGLuint; maxBarriers: PGLuint): Boolean; stdcall;
8359 TwglQueryFrameCountNV = function(hDC: HDC; count: PGLuint): Boolean; stdcall;
8360 TwglResetFrameCountNV = function(hDC: HDC): Boolean; stdcall;
8361
8362 // WGL_NV_gpu_affinity
8363 TwglEnumGpusNV = function(iGpuIndex: Cardinal; phGpu: PHGPUNV): Boolean; stdcall;
8364 TwglEnumGpuDevicesNV = function(hGpu: HGPUNV; iDeviceIndex: Cardinal; lpGpuDevice: PGPU_DEVICE): Boolean; stdcall;
8365 TwglCreateAffinityDCNV = function(const phGpuList: PHGPUNV): HDC; stdcall;
8366 TwglEnumGpusFromAffinityDCNV = function(hAffinityDC: HDC; iGpuIndex: Cardinal; hGpu: PHGPUNV): Boolean; stdcall;
8367 TwglDeleteDCNV = function(hDC: HDC): Boolean; stdcall;
8368
8369 // WGL_OML_sync_control
8370 TwglGetSyncValuesOML = function(hdc: HDC; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
8371 TwglGetMscRateOML = function(hdc: HDC; numerator: PGLint; denominator: PGLint): Boolean; stdcall;
8372 TwglSwapBuffersMscOML = function(hdc: HDC; target_msc: TGLint64; divisor: TGLint64; remainder: TGLint64): TGLint64; stdcall;
8373 TwglSwapLayerBuffersMscOML = function(hdc: HDC; fuPlanes: TGLint; target_msc: TGLint64; divisor: TGLint64; remainder: TGLint64): TGLint64; stdcall;
8374 TwglWaitForMscOML = function(hdc: HDC; target_msc: TGLint64; divisor: TGLint64; remainder: TGLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
8375 TwglWaitForSbcOML = function(hdc: HDC; target_sbc: TGLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
8376
8377 // WGL_3DL_stereo_control
8378 TwglSetStereoEmitterState3DL = function(hDC: HDC; uState: UINT): Boolean; stdcall;
8379
8380 // WIN_draw_range_elements
8381 TglDrawRangeElementsWIN = procedure(mode: TGLenum; start: TGLuint; _end: TGLuint; count: TGLsizei; _type: TGLenum; const indices: PGLvoid); stdcall;
8382
8383 // WIN_swap_hint
8384 TglAddSwapHintRectWIN = procedure(x: TGLint; y: TGLint; width: TGLsizei; height: TGLsizei); stdcall;
8385 {$ENDIF}
8386
8387 {$IFDEF DGL_LINUX}
8388 TglXChooseVisual = function(dpy: PDisplay; screen: GLint; attribList: PGLint): PXVisualInfo; cdecl;
8389 TglXCopyContext = procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: GLuint); cdecl;
8390 TglXCreateContext = function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: GLboolean): GLXContext; cdecl;
8391 TglXCreateGLXPixmap = function(dpy: PDisplay; vis: PXVisualInfo; pixmap: Pixmap): GLXPixmap cdecl;
8392 TglXDestroyContext = procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
8393 TglXDestroyGLXPixmap = procedure(dpy : PDisplay; pix: GLXPixmap); cdecl;
8394 TglXGetConfig = function(dpy : PDisplay; vis: PXVisualInfo; attrib: GLint; value: PGLint): GLint; cdecl;
8395 TglXGetCurrentContext = function: GLXContext cdecl;
8396 TglXGetCurrentDrawable = function: GLXDrawable cdecl;
8397 TglXIsDirect = function(dpy: PDisplay; ctx: GLXContext): glboolean; cdecl;
8398 TglXMakeCurrent = function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): GLboolean cdecl;
8399 TglXQueryExtension = function(dpy: PDisplay; errorBase: PGLint; eventBase: PGLint): GLboolean; cdecl;
8400 TglXQueryVersion = function(dpy: PDisplay; major: PGLint; minor: PGLint): GLboolean cdecl;
8401 TglXSwapBuffers = procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
8402 TglXUseXFont = procedure(font: Font; first: GLint; count: GLint; listBase: GLint); cdecl;
8403 TglXWaitGL = procedure; cdecl;
8404 TglXWaitX = procedure; cdecl;
8405
8406 TglXGetClientString = function(dpy: PDisplay; name: GLint): PGLchar; cdecl;
8407 TglXQueryServerString = function(dpy: PDisplay; screen: GLint; name: GLint): PGLchar; cdecl;
8408 TglXQueryExtensionsString = function(dpy: PDisplay; screen: GLint): PGLchar; cdecl;
8409
8410 // GLX_VERSION_1_3
8411 TglXGetFBConfigs = function(dpy: PDisplay; screen: GLint; nelements: PGLint): GLXFBConfig; cdecl;
8412 TglXChooseFBConfig = function(dpy: PDisplay; screen: GLint; attrib_list: PGLint; nelements: PGLint): GLXFBConfig; cdecl;
8413 TglXGetFBConfigAttrib = function(dpy: PDisplay; config: GLXFBConfig; attribute: GLint; value: PGLint): glint; cdecl;
8414 TglXGetVisualFromFBConfig = function(dpy: PDisplay; config: GLXFBConfig) : PXVisualInfo;
8415 TglXCreateWindow = function(dpy: PDisplay; config: GLXFBConfig; win: Window; attrib_list: PGLint): GLXWindow; cdecl;
8416 TglXDestroyWindow = procedure(dpy: PDisplay; win: GLXWindow); cdecl;
8417 TglXCreatePixmap = function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attrib_list: PGLint): GLXPixmap; cdecl;
8418
8419 TglXDestroyPixmap = procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
8420 TglXCreatePbuffer = function(dpy: PDisplay; config: GLXFBConfig; attrib_list: PGLint): GLXPbuffer; cdecl;
8421 TglXDestroyPbuffer = procedure(dpy: PDisplay; pbuf: GLXPbuffer); cdecl;
8422 TglXQueryDrawable = procedure(dpy: PDisplay; draw: GLXDrawable; attribute: GLint; value: PGLuint); cdecl;
8423 TglXCreateNewContext = function(dpy: PDisplay; config: GLXFBConfig; render_type: GLint; share_list: GLXContext; direct: GLboolean): GLXContext cdecl;
8424 TglXMakeContextCurrent = function(display: PDisplay; draw: GLXDrawable; read_: GLXDrawable; ctx: GLXContext): GLboolean; cdecl;
8425 TglXGetCurrentReadDrawable = function: GLXDrawable; cdecl;
8426 TglXGetCurreentDisplay = function: PDisplay;
8427
8428 TglXQueryContext = function(dpy: PDisplay; ctx: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
8429 TglXSelectEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: GLuint); cdecl;
8430 TglXGetSelectedEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: PGLuint); cdecl;
8431
8432 // GLX_VERSION_1_4
8433 TglXGetProcAddress = function(const name: PAnsiChar): pointer; cdecl;
8434
8435 // GLX_ARB_get_proc_address
8436 TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
8437
8438 // GLX_ARB_create_context
8439 TglXCreateContextAttribsARB = function(dpy: PDisplay; config: GLXFBConfig; share_context: GLXContext; direct: GLboolean; const attrib_list: PGLint): GLXContext; cdecl;
8440
8441 // GLX_EXT_import_context
8442 TglXGetCurrentDisplayEXT = function: PDisplay; cdecl;
8443 TglXQueryContextInfoEXT = function(dpy: PDisplay; context: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
8444 TglXGetContextIDEXT = function(const context: GLXContext): GLXContextID; cdecl;
8445 TglXImportContextEXT = function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl;
8446 TglXFreeContextEXT = procedure(dpy: PDisplay; context: GLXContext); cdecl;
8447
8448 // GLX_EXT_texture_from_pixmap
8449 TglXBindTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint; const attrib_list: PGLint); cdecl;
8450 TglXReleaseTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint); cdecl;
8451 {$ENDIF}
8452
8453 // GL utility functions and procedures
8454 TgluErrorString = function(errCode: TGLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8455 TgluGetString = function(name: TGLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8456 TgluOrtho2D = procedure(left, right, bottom, top: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8457 TgluPerspective = procedure(fovy, aspect, zNear, zFar: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8458 TgluPickMatrix = procedure(x, y, width, height: TGLdouble; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8459 TgluLookAt = procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8460 TgluProject = function(objx, objy, obyz: GLdouble; modelMatrix: PGLdouble; projMatrix: PGLdouble; viewport: PGLint; var winx, winy, winz: GLDouble): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8461 TgluUnProject = function(winx, winy, winz: GLdouble; modelMatrix: PGLdouble; projMatrix: PGLdouble; viewport: PGLint; var objx, objy, objz: GLdouble): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8462 TgluScaleImage = function(format: TGLEnum; widthin, heightin: TGLint; typein: TGLEnum; datain: Pointer; widthout, heightout: TGLint; typeout: TGLEnum; const dataout: Pointer): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8463 TgluBuild1DMipmaps = function(target: TGLEnum; components, width: TGLint; format, atype: TGLEnum; const data: Pointer): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8464 TgluBuild2DMipmaps = function(target: TGLEnum; components, width, height: TGLint; format, atype: TGLEnum; const Data: Pointer): TGLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8465 TgluNewQuadric = function: PGLUquadric; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8466 TgluDeleteQuadric = procedure(state: PGLUquadric); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8467 TgluQuadricNormals = procedure(quadObject: PGLUquadric; normals: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8468 TgluQuadricTexture = procedure(quadObject: PGLUquadric; textureCoords: TGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8469 TgluQuadricOrientation = procedure(quadObject: PGLUquadric; orientation: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8470 TgluQuadricDrawStyle = procedure(quadObject: PGLUquadric; drawStyle: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8471 TgluCylinder = procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: TGLdouble; slices, stacks: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8472 TgluDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8473 TgluPartialDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint; startAngle, sweepAngle: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8474 TgluSphere = procedure(quadObject: PGLUquadric; radius: TGLdouble; slices, stacks: TGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8475 TgluQuadricCallback = procedure(quadObject: PGLUquadric; which: TGLEnum; fn: TGLUQuadricErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8476 TgluNewTess = function: PGLUtesselator; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8477 TgluDeleteTess = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8478 TgluTessBeginPolygon = procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8479 TgluTessBeginContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8480 TgluTessVertex = procedure(tess: PGLUtesselator; const coords: TGLArrayd3; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8481 TgluTessEndContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8482 TgluTessEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8483 TgluTessProperty = procedure(tess: PGLUtesselator; which: TGLEnum; value: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8484 TgluTessNormal = procedure(tess: PGLUtesselator; x, y, z: TGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8485 TgluTessCallback = procedure(tess: PGLUtesselator; which: TGLEnum; fn: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8486 TgluGetTessProperty = procedure(tess: PGLUtesselator; which: TGLEnum; value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8487 TgluNewNurbsRenderer = function: PGLUnurbs; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8488 TgluDeleteNurbsRenderer = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8489 TgluBeginSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8490 TgluBeginCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8491 TgluEndCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8492 TgluEndSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8493 TgluBeginTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8494 TgluEndTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8495 TgluPwlCurve = procedure(nobj: PGLUnurbs; count: TGLint; points: PGLfloat; stride: TGLint; atype: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8496 TgluNurbsCurve = procedure(nobj: PGLUnurbs; nknots: TGLint; knot: PGLfloat; stride: TGLint; ctlarray: PGLfloat; order: TGLint; atype: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8497 TgluNurbsSurface = procedure(nobj: PGLUnurbs; sknot_count: TGLint; sknot: PGLfloat; tknot_count: TGLint; tknot: PGLfloat; s_stride, t_stride: TGLint; ctlarray: PGLfloat; sorder, torder: TGLint; atype: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8498 TgluLoadSamplingMatrices = procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: TGLMatrixf4; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8499 TgluNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: TGLEnum; value: TGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8500 TgluGetNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: TGLEnum; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8501 TgluNurbsCallback = procedure(nobj: PGLUnurbs; which: TGLEnum; fn: TGLUNurbsErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8502 TgluBeginPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8503 TgluNextContour = procedure(tess: PGLUtesselator; atype: TGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8504 TgluEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
8505
8506 var
8507 // GL_VERSION_1_0
8508 glCullFace: TglCullFace;
8509 glFrontFace: TglFrontFace;
8510 glHint: TglHint;
8511 glLineWidth: TglLineWidth;
8512 glPointSize: TglPointSize;
8513 glPolygonMode: TglPolygonMode;
8514 glScissor: TglScissor;
8515 glTexParameterf: TglTexParameterf;
8516 glTexParameterfv: TglTexParameterfv;
8517 glTexParameteri: TglTexParameteri;
8518 glTexParameteriv: TglTexParameteriv;
8519 glTexImage1D: TglTexImage1D;
8520 glTexImage2D: TglTexImage2D;
8521 glDrawBuffer: TglDrawBuffer;
8522 glClear: TglClear;
8523 glClearColor: TglClearColor;
8524 glClearStencil: TglClearStencil;
8525 glClearDepth: TglClearDepth;
8526 glStencilMask: TglStencilMask;
8527 glColorMask: TglColorMask;
8528 glDepthMask: TglDepthMask;
8529 glDisable: TglDisable;
8530 glEnable: TglEnable;
8531 glFinish: TglFinish;
8532 glFlush: TglFlush;
8533 glBlendFunc: TglBlendFunc;
8534 glLogicOp: TglLogicOp;
8535 glStencilFunc: TglStencilFunc;
8536 glStencilOp: TglStencilOp;
8537 glDepthFunc: TglDepthFunc;
8538 glPixelStoref: TglPixelStoref;
8539 glPixelStorei: TglPixelStorei;
8540 glReadBuffer: TglReadBuffer;
8541 glReadPixels: TglReadPixels;
8542 glGetBooleanv: TglGetBooleanv;
8543 glGetDoublev: TglGetDoublev;
8544 glGetError: TglGetError;
8545 glGetFloatv: TglGetFloatv;
8546 glGetIntegerv: TglGetIntegerv;
8547 glGetString: TglGetString;
8548 glGetTexImage: TglGetTexImage;
8549 glGetTexParameteriv: TglGetTexParameteriv;
8550 glGetTexParameterfv: TglGetTexParameterfv;
8551 glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
8552 glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
8553 glIsEnabled: TglIsEnabled;
8554 glDepthRange: TglDepthRange;
8555 glViewport: TglViewport;
8556
8557 // GL_VERSION_1_1
8558 glDrawArrays: TglDrawArrays;
8559 glDrawElements: TglDrawElements;
8560 glGetPointerv: TglGetPointerv;
8561 glPolygonOffset: TglPolygonOffset;
8562 glCopyTexImage1D: TglCopyTexImage1D;
8563 glCopyTexImage2D: TglCopyTexImage2D;
8564 glCopyTexSubImage1D: TglCopyTexSubImage1D;
8565 glCopyTexSubImage2D: TglCopyTexSubImage2D;
8566 glTexSubImage1D: TglTexSubImage1D;
8567 glTexSubImage2D: TglTexSubImage2D;
8568 glBindTexture: TglBindTexture;
8569 glDeleteTextures: TglDeleteTextures;
8570 glGenTextures: TglGenTextures;
8571 {$ifdef DGL_DEPRECATED}
8572 glAccum: TglAccum;
8573 glAlphaFunc: TglAlphaFunc;
8574 glAreTexturesResident: TglAreTexturesResident;
8575 glArrayElement: TglArrayElement;
8576 glBegin: TglBegin;
8577 glBitmap: TglBitmap;
8578 glCallList: TglCallList;
8579 glCallLists: TglCallLists;
8580 glClearAccum: TglClearAccum;
8581 glClearIndex: TglClearIndex;
8582 glClipPlane: TglClipPlane;
8583 glColor3b: TglColor3b;
8584 glColor3bv: TglColor3bv;
8585 glColor3d: TglColor3d;
8586 glColor3dv: TglColor3dv;
8587 glColor3f: TglColor3f;
8588 glColor3fv: TglColor3fv;
8589 glColor3i: TglColor3i;
8590 glColor3iv: TglColor3iv;
8591 glColor3s: TglColor3s;
8592 glColor3sv: TglColor3sv;
8593 glColor3ub: TglColor3ub;
8594 glColor3ubv: TglColor3ubv;
8595 glColor3ui: TglColor3ui;
8596 glColor3uiv: TglColor3uiv;
8597 glColor3us: TglColor3us;
8598 glColor3usv: TglColor3usv;
8599 glColor4b: TglColor4b;
8600 glColor4bv: TglColor4bv;
8601 glColor4d: TglColor4d;
8602 glColor4dv: TglColor4dv;
8603 glColor4f: TglColor4f;
8604 glColor4fv: TglColor4fv;
8605 glColor4i: TglColor4i;
8606 glColor4iv: TglColor4iv;
8607 glColor4s: TglColor4s;
8608 glColor4sv: TglColor4sv;
8609 glColor4ub: TglColor4ub;
8610 glColor4ubv: TglColor4ubv;
8611 glColor4ui: TglColor4ui;
8612 glColor4uiv: TglColor4uiv;
8613 glColor4us: TglColor4us;
8614 glColor4usv: TglColor4usv;
8615 glColorMaterial: TglColorMaterial;
8616 glColorPointer: TglColorPointer;
8617 glCopyPixels: TglCopyPixels;
8618 glDeleteLists: TglDeleteLists;
8619 glDisableClientState: TglDisableClientState;
8620 glDrawPixels: TglDrawPixels;
8621 glEdgeFlag: TglEdgeFlag;
8622 glEdgeFlagPointer: TglEdgeFlagPointer;
8623 glEdgeFlagv: TglEdgeFlagv;
8624 glEnableClientState: TglEnableClientState;
8625 glEnd: TglEnd;
8626 glEndList: TglEndList;
8627 glEvalCoord1d: TglEvalCoord1d;
8628 glEvalCoord1dv: TglEvalCoord1dv;
8629 glEvalCoord1f: TglEvalCoord1f;
8630 glEvalCoord1fv: TglEvalCoord1fv;
8631 glEvalCoord2d: TglEvalCoord2d;
8632 glEvalCoord2dv: TglEvalCoord2dv;
8633 glEvalCoord2f: TglEvalCoord2f;
8634 glEvalCoord2fv: TglEvalCoord2fv;
8635 glEvalMesh1: TglEvalMesh1;
8636 glEvalMesh2: TglEvalMesh2;
8637 glEvalPoint1: TglEvalPoint1;
8638 glEvalPoint2: TglEvalPoint2;
8639 glFeedbackBuffer: TglFeedbackBuffer;
8640 glFogf: TglFogf;
8641 glFogfv: TglFogfv;
8642 glFogi: TglFogi;
8643 glFogiv: TglFogiv;
8644 glFrustum: TglFrustum;
8645 glGenLists: TglGenLists;
8646 glGetClipPlane: TglGetClipPlane;
8647 glGetLightfv: TglGetLightfv;
8648 glGetLightiv: TglGetLightiv;
8649 glGetMapdv: TglGetMapdv;
8650 glGetMapfv: TglGetMapfv;
8651 glGetMapiv: TglGetMapiv;
8652 glGetMaterialfv: TglGetMaterialfv;
8653 glGetMaterialiv: TglGetMaterialiv;
8654 glGetPixelMapfv: TglGetPixelMapfv;
8655 glGetPixelMapuiv: TglGetPixelMapuiv;
8656 glGetPixelMapusv: TglGetPixelMapusv;
8657 glGetPolygonStipple: TglGetPolygonStipple;
8658 glGetTexEnvfv: TglGetTexEnvfv;
8659 glGetTexEnviv: TglGetTexEnviv;
8660 glGetTexGendv: TglGetTexGendv;
8661 glGetTexGenfv: TglGetTexGenfv;
8662 glGetTexGeniv: TglGetTexGeniv;
8663 glIndexMask: TglIndexMask;
8664 glIndexPointer: TglIndexPointer;
8665 glIndexd: TglIndexd;
8666 glIndexdv: TglIndexdv;
8667 glIndexf: TglIndexf;
8668 glIndexfv: TglIndexfv;
8669 glIndexi: TglIndexi;
8670 glIndexiv: TglIndexiv;
8671 glIndexs: TglIndexs;
8672 glIndexsv: TglIndexsv;
8673 glIndexub: TglIndexub;
8674 glIndexubv: TglIndexubv;
8675 glInitNames: TglInitNames;
8676 glInterleavedArrays: TglInterleavedArrays;
8677 glIsList: TglIsList;
8678 glIsTexture: TglIsTexture;
8679 glLightModelf: TglLightModelf;
8680 glLightModelfv: TglLightModelfv;
8681 glLightModeli: TglLightModeli;
8682 glLightModeliv: TglLightModeliv;
8683 glLightf: TglLightf;
8684 glLightfv: TglLightfv;
8685 glLighti: TglLighti;
8686 glLightiv: TglLightiv;
8687 glLineStipple: TglLineStipple;
8688 glListBase: TglListBase;
8689 glLoadIdentity: TglLoadIdentity;
8690 glLoadMatrixd: TglLoadMatrixd;
8691 glLoadMatrixf: TglLoadMatrixf;
8692 glLoadName: TglLoadName;
8693 glMap1d: TglMap1d;
8694 glMap1f: TglMap1f;
8695 glMap2d: TglMap2d;
8696 glMap2f: TglMap2f;
8697 glMapGrid1d: TglMapGrid1d;
8698 glMapGrid1f: TglMapGrid1f;
8699 glMapGrid2d: TglMapGrid2d;
8700 glMapGrid2f: TglMapGrid2f;
8701 glMaterialf: TglMaterialf;
8702 glMaterialfv: TglMaterialfv;
8703 glMateriali: TglMateriali;
8704 glMaterialiv: TglMaterialiv;
8705 glMatrixMode: TglMatrixMode;
8706 glMultMatrixd: TglMultMatrixd;
8707 glMultMatrixf: TglMultMatrixf;
8708 glNewList: TglNewList;
8709 glNormal3b: TglNormal3b;
8710 glNormal3bv: TglNormal3bv;
8711 glNormal3d: TglNormal3d;
8712 glNormal3dv: TglNormal3dv;
8713 glNormal3f: TglNormal3f;
8714 glNormal3fv: TglNormal3fv;
8715 glNormal3i: TglNormal3i;
8716 glNormal3iv: TglNormal3iv;
8717 glNormal3s: TglNormal3s;
8718 glNormal3sv: TglNormal3sv;
8719 glNormalPointer: TglNormalPointer;
8720 glOrtho: TglOrtho;
8721 glPassThrough: TglPassThrough;
8722 glPixelMapfv: TglPixelMapfv;
8723 glPixelMapuiv: TglPixelMapuiv;
8724 glPixelMapusv: TglPixelMapusv;
8725 glPixelTransferf: TglPixelTransferf;
8726 glPixelTransferi: TglPixelTransferi;
8727 glPixelZoom: TglPixelZoom;
8728 glPolygonStipple: TglPolygonStipple;
8729 glPopAttrib: TglPopAttrib;
8730 glPopClientAttrib: TglPopClientAttrib;
8731 glPopMatrix: TglPopMatrix;
8732 glPopName: TglPopName;
8733 glPrioritizeTextures: TglPrioritizeTextures;
8734 glPushAttrib: TglPushAttrib;
8735 glPushClientAttrib: TglPushClientAttrib;
8736 glPushMatrix: TglPushMatrix;
8737 glPushName: TglPushName;
8738 glRasterPos2d: TglRasterPos2d;
8739 glRasterPos2dv: TglRasterPos2dv;
8740 glRasterPos2f: TglRasterPos2f;
8741 glRasterPos2fv: TglRasterPos2fv;
8742 glRasterPos2i: TglRasterPos2i;
8743 glRasterPos2iv: TglRasterPos2iv;
8744 glRasterPos2s: TglRasterPos2s;
8745 glRasterPos2sv: TglRasterPos2sv;
8746 glRasterPos3d: TglRasterPos3d;
8747 glRasterPos3dv: TglRasterPos3dv;
8748 glRasterPos3f: TglRasterPos3f;
8749 glRasterPos3fv: TglRasterPos3fv;
8750 glRasterPos3i: TglRasterPos3i;
8751 glRasterPos3iv: TglRasterPos3iv;
8752 glRasterPos3s: TglRasterPos3s;
8753 glRasterPos3sv: TglRasterPos3sv;
8754 glRasterPos4d: TglRasterPos4d;
8755 glRasterPos4dv: TglRasterPos4dv;
8756 glRasterPos4f: TglRasterPos4f;
8757 glRasterPos4fv: TglRasterPos4fv;
8758 glRasterPos4i: TglRasterPos4i;
8759 glRasterPos4iv: TglRasterPos4iv;
8760 glRasterPos4s: TglRasterPos4s;
8761 glRasterPos4sv: TglRasterPos4sv;
8762 glRectd: TglRectd;
8763 glRectdv: TglRectdv;
8764 glRectf: TglRectf;
8765 glRectfv: TglRectfv;
8766 glRecti: TglRecti;
8767 glRectiv: TglRectiv;
8768 glRects: TglRects;
8769 glRectsv: TglRectsv;
8770 glRenderMode: TglRenderMode;
8771 glRotated: TglRotated;
8772 glRotatef: TglRotatef;
8773 glScaled: TglScaled;
8774 glScalef: TglScalef;
8775 glSelectBuffer: TglSelectBuffer;
8776 glShadeModel: TglShadeModel;
8777 glTexCoord1d: TglTexCoord1d;
8778 glTexCoord1dv: TglTexCoord1dv;
8779 glTexCoord1f: TglTexCoord1f;
8780 glTexCoord1fv: TglTexCoord1fv;
8781 glTexCoord1i: TglTexCoord1i;
8782 glTexCoord1iv: TglTexCoord1iv;
8783 glTexCoord1s: TglTexCoord1s;
8784 glTexCoord1sv: TglTexCoord1sv;
8785 glTexCoord2d: TglTexCoord2d;
8786 glTexCoord2dv: TglTexCoord2dv;
8787 glTexCoord2f: TglTexCoord2f;
8788 glTexCoord2fv: TglTexCoord2fv;
8789 glTexCoord2i: TglTexCoord2i;
8790 glTexCoord2iv: TglTexCoord2iv;
8791 glTexCoord2s: TglTexCoord2s;
8792 glTexCoord2sv: TglTexCoord2sv;
8793 glTexCoord3d: TglTexCoord3d;
8794 glTexCoord3dv: TglTexCoord3dv;
8795 glTexCoord3f: TglTexCoord3f;
8796 glTexCoord3fv: TglTexCoord3fv;
8797 glTexCoord3i: TglTexCoord3i;
8798 glTexCoord3iv: TglTexCoord3iv;
8799 glTexCoord3s: TglTexCoord3s;
8800 glTexCoord3sv: TglTexCoord3sv;
8801 glTexCoord4d: TglTexCoord4d;
8802 glTexCoord4dv: TglTexCoord4dv;
8803 glTexCoord4f: TglTexCoord4f;
8804 glTexCoord4fv: TglTexCoord4fv;
8805 glTexCoord4i: TglTexCoord4i;
8806 glTexCoord4iv: TglTexCoord4iv;
8807 glTexCoord4s: TglTexCoord4s;
8808 glTexCoord4sv: TglTexCoord4sv;
8809 glTexCoordPointer: TglTexCoordPointer;
8810 glTexEnvf: TglTexEnvf;
8811 glTexEnvfv: TglTexEnvfv;
8812 glTexEnvi: TglTexEnvi;
8813 glTexEnviv: TglTexEnviv;
8814 glTexGend: TglTexGend;
8815 glTexGendv: TglTexGendv;
8816 glTexGenf: TglTexGenf;
8817 glTexGenfv: TglTexGenfv;
8818 glTexGeni: TglTexGeni;
8819 glTexGeniv: TglTexGeniv;
8820 glTranslated: TglTranslated;
8821 glTranslatef: TglTranslatef;
8822 glVertex2d: TglVertex2d;
8823 glVertex2dv: TglVertex2dv;
8824 glVertex2f: TglVertex2f;
8825 glVertex2fv: TglVertex2fv;
8826 glVertex2i: TglVertex2i;
8827 glVertex2iv: TglVertex2iv;
8828 glVertex2s: TglVertex2s;
8829 glVertex2sv: TglVertex2sv;
8830 glVertex3d: TglVertex3d;
8831 glVertex3dv: TglVertex3dv;
8832 glVertex3f: TglVertex3f;
8833 glVertex3fv: TglVertex3fv;
8834 glVertex3i: TglVertex3i;
8835 glVertex3iv: TglVertex3iv;
8836 glVertex3s: TglVertex3s;
8837 glVertex3sv: TglVertex3sv;
8838 glVertex4d: TglVertex4d;
8839 glVertex4dv: TglVertex4dv;
8840 glVertex4f: TglVertex4f;
8841 glVertex4fv: TglVertex4fv;
8842 glVertex4i: TglVertex4i;
8843 glVertex4iv: TglVertex4iv;
8844 glVertex4s: TglVertex4s;
8845 glVertex4sv: TglVertex4sv;
8846 glVertexPointer: TglVertexPointer;
8847 {$endif}
8848
8849 // GL_VERSION_1_2
8850 glBlendColor: TglBlendColor;
8851 glBlendEquation: TglBlendEquation;
8852 glDrawRangeElements: TglDrawRangeElements;
8853 glTexImage3D: TglTexImage3D;
8854 glTexSubImage3D: TglTexSubImage3D;
8855 glCopyTexSubImage3D: TglCopyTexSubImage3D;
8856 {$ifdef DGL_DEPRECATED}
8857 glColorTable: TglColorTable;
8858 glColorTableParameterfv: TglColorTableParameterfv;
8859 glColorTableParameteriv: TglColorTableParameteriv;
8860 glCopyColorTable: TglCopyColorTable;
8861 glGetColorTable: TglGetColorTable;
8862 glGetColorTableParameterfv: TglGetColorTableParameterfv;
8863 glGetColorTableParameteriv: TglGetColorTableParameteriv;
8864 glColorSubTable: TglColorSubTable;
8865 glCopyColorSubTable: TglCopyColorSubTable;
8866 glConvolutionFilter1D: TglConvolutionFilter1D;
8867 glConvolutionFilter2D: TglConvolutionFilter2D;
8868 glConvolutionParameterf: TglConvolutionParameterf;
8869 glConvolutionParameterfv: TglConvolutionParameterfv;
8870 glConvolutionParameteri: TglConvolutionParameteri;
8871 glConvolutionParameteriv: TglConvolutionParameteriv;
8872 glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D;
8873 glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D;
8874 glGetConvolutionFilter: TglGetConvolutionFilter;
8875 glGetConvolutionParameterfv: TglGetConvolutionParameterfv;
8876 glGetConvolutionParameteriv: TglGetConvolutionParameteriv;
8877 glGetSeparableFilter: TglGetSeparableFilter;
8878 glSeparableFilter2D: TglSeparableFilter2D;
8879 glGetHistogram: TglGetHistogram;
8880 glGetHistogramParameterfv: TglGetHistogramParameterfv;
8881 glGetHistogramParameteriv: TglGetHistogramParameteriv;
8882 glGetMinmax: TglGetMinmax;
8883 glGetMinmaxParameterfv: TglGetMinmaxParameterfv;
8884 glGetMinmaxParameteriv: TglGetMinmaxParameteriv;
8885 glHistogram: TglHistogram;
8886 glMinmax: TglMinmax;
8887 glResetHistogram: TglResetHistogram;
8888 glResetMinmax: TglResetMinmax;
8889 {$endif}
8890
8891 // GL_VERSION_1_3
8892 glActiveTexture: TglActiveTexture;
8893 glSampleCoverage: TglSampleCoverage;
8894 glCompressedTexImage3D: TglCompressedTexImage3D;
8895 glCompressedTexImage2D: TglCompressedTexImage2D;
8896 glCompressedTexImage1D: TglCompressedTexImage1D;
8897 glCompressedTexSubImage3D: TglCompressedTexSubImage3D;
8898 glCompressedTexSubImage2D: TglCompressedTexSubImage2D;
8899 glCompressedTexSubImage1D: TglCompressedTexSubImage1D;
8900 glGetCompressedTexImage: TglGetCompressedTexImage;
8901 {$ifdef DGL_DEPRECATED}
8902 glClientActiveTexture: TglClientActiveTexture;
8903 glMultiTexCoord1d: TglMultiTexCoord1d;
8904 glMultiTexCoord1dv: TglMultiTexCoord1dv;
8905 glMultiTexCoord1f: TglMultiTexCoord1f;
8906 glMultiTexCoord1fv: TglMultiTexCoord1fv;
8907 glMultiTexCoord1i: TglMultiTexCoord1i;
8908 glMultiTexCoord1iv: TglMultiTexCoord1iv;
8909 glMultiTexCoord1s: TglMultiTexCoord1s;
8910 glMultiTexCoord1sv: TglMultiTexCoord1sv;
8911 glMultiTexCoord2d: TglMultiTexCoord2d;
8912 glMultiTexCoord2dv: TglMultiTexCoord2dv;
8913 glMultiTexCoord2f: TglMultiTexCoord2f;
8914 glMultiTexCoord2fv: TglMultiTexCoord2fv;
8915 glMultiTexCoord2i: TglMultiTexCoord2i;
8916 glMultiTexCoord2iv: TglMultiTexCoord2iv;
8917 glMultiTexCoord2s: TglMultiTexCoord2s;
8918 glMultiTexCoord2sv: TglMultiTexCoord2sv;
8919 glMultiTexCoord3d: TglMultiTexCoord3d;
8920 glMultiTexCoord3dv: TglMultiTexCoord3dv;
8921 glMultiTexCoord3f: TglMultiTexCoord3f;
8922 glMultiTexCoord3fv: TglMultiTexCoord3fv;
8923 glMultiTexCoord3i: TglMultiTexCoord3i;
8924 glMultiTexCoord3iv: TglMultiTexCoord3iv;
8925 glMultiTexCoord3s: TglMultiTexCoord3s;
8926 glMultiTexCoord3sv: TglMultiTexCoord3sv;
8927 glMultiTexCoord4d: TglMultiTexCoord4d;
8928 glMultiTexCoord4dv: TglMultiTexCoord4dv;
8929 glMultiTexCoord4f: TglMultiTexCoord4f;
8930 glMultiTexCoord4fv: TglMultiTexCoord4fv;
8931 glMultiTexCoord4i: TglMultiTexCoord4i;
8932 glMultiTexCoord4iv: TglMultiTexCoord4iv;
8933 glMultiTexCoord4s: TglMultiTexCoord4s;
8934 glMultiTexCoord4sv: TglMultiTexCoord4sv;
8935 glLoadTransposeMatrixf: TglLoadTransposeMatrixf;
8936 glLoadTransposeMatrixd: TglLoadTransposeMatrixd;
8937 glMultTransposeMatrixf: TglMultTransposeMatrixf;
8938 glMultTransposeMatrixd: TglMultTransposeMatrixd;
8939 {$endif}
8940
8941 // GL_VERSION_1_4
8942 glBlendFuncSeparate: TglBlendFuncSeparate;
8943 glMultiDrawArrays: TglMultiDrawArrays;
8944 glMultiDrawElements: TglMultiDrawElements;
8945 glPointParameterf: TglPointParameterf;
8946 glPointParameterfv: TglPointParameterfv;
8947 glPointParameteri: TglPointParameteri;
8948 glPointParameteriv: TglPointParameteriv;
8949 {$ifdef DGL_DEPRECATED}
8950 glFogCoordf: TglFogCoordf;
8951 glFogCoordfv: TglFogCoordfv;
8952 glFogCoordd: TglFogCoordd;
8953 glFogCoorddv: TglFogCoorddv;
8954 glFogCoordPointer: TglFogCoordPointer;
8955 glSecondaryColor3b: TglSecondaryColor3b;
8956 glSecondaryColor3bv: TglSecondaryColor3bv;
8957 glSecondaryColor3d: TglSecondaryColor3d;
8958 glSecondaryColor3dv: TglSecondaryColor3dv;
8959 glSecondaryColor3f: TglSecondaryColor3f;
8960 glSecondaryColor3fv: TglSecondaryColor3fv;
8961 glSecondaryColor3i: TglSecondaryColor3i;
8962 glSecondaryColor3iv: TglSecondaryColor3iv;
8963 glSecondaryColor3s: TglSecondaryColor3s;
8964 glSecondaryColor3sv: TglSecondaryColor3sv;
8965 glSecondaryColor3ub: TglSecondaryColor3ub;
8966 glSecondaryColor3ubv: TglSecondaryColor3ubv;
8967 glSecondaryColor3ui: TglSecondaryColor3ui;
8968 glSecondaryColor3uiv: TglSecondaryColor3uiv;
8969 glSecondaryColor3us: TglSecondaryColor3us;
8970 glSecondaryColor3usv: TglSecondaryColor3usv;
8971 glSecondaryColorPointer: TglSecondaryColorPointer;
8972 glWindowPos2d: TglWindowPos2d;
8973 glWindowPos2dv: TglWindowPos2dv;
8974 glWindowPos2f: TglWindowPos2f;
8975 glWindowPos2fv: TglWindowPos2fv;
8976 glWindowPos2i: TglWindowPos2i;
8977 glWindowPos2iv: TglWindowPos2iv;
8978 glWindowPos2s: TglWindowPos2s;
8979 glWindowPos2sv: TglWindowPos2sv;
8980 glWindowPos3d: TglWindowPos3d;
8981 glWindowPos3dv: TglWindowPos3dv;
8982 glWindowPos3f: TglWindowPos3f;
8983 glWindowPos3fv: TglWindowPos3fv;
8984 glWindowPos3i: TglWindowPos3i;
8985 glWindowPos3iv: TglWindowPos3iv;
8986 glWindowPos3s: TglWindowPos3s;
8987 glWindowPos3sv: TglWindowPos3sv;
8988 {$endif}
8989
8990 // GL_VERSION_1_5
8991 glGenQueries: TglGenQueries;
8992 glDeleteQueries: TglDeleteQueries;
8993 glIsQuery: TglIsQuery;
8994 glBeginQuery: TglBeginQuery;
8995 glEndQuery: TglEndQuery;
8996 glGetQueryiv: TglGetQueryiv;
8997 glGetQueryObjectiv: TglGetQueryObjectiv;
8998 glGetQueryObjectuiv: TglGetQueryObjectuiv;
8999 glBindBuffer: TglBindBuffer;
9000 glDeleteBuffers: TglDeleteBuffers;
9001 glGenBuffers: TglGenBuffers;
9002 glIsBuffer: TglIsBuffer;
9003 glBufferData: TglBufferData;
9004 glBufferSubData: TglBufferSubData;
9005 glGetBufferSubData: TglGetBufferSubData;
9006 glMapBuffer: TglMapBuffer;
9007 glUnmapBuffer: TglUnmapBuffer;
9008 glGetBufferParameteriv: TglGetBufferParameteriv;
9009 glGetBufferPointerv: TglGetBufferPointerv;
9010
9011 // GL_VERSION_2_0
9012 glBlendEquationSeparate: TglBlendEquationSeparate;
9013 glDrawBuffers: TglDrawBuffers;
9014 glStencilOpSeparate: TglStencilOpSeparate;
9015 glStencilFuncSeparate: TglStencilFuncSeparate;
9016 glStencilMaskSeparate: TglStencilMaskSeparate;
9017 glAttachShader: TglAttachShader;
9018 glBindAttribLocation: TglBindAttribLocation;
9019 glCompileShader: TglCompileShader;
9020 glCreateProgram: TglCreateProgram;
9021 glCreateShader: TglCreateShader;
9022 glDeleteProgram: TglDeleteProgram;
9023 glDeleteShader: TglDeleteShader;
9024 glDetachShader: TglDetachShader;
9025 glDisableVertexAttribArray: TglDisableVertexAttribArray;
9026 glEnableVertexAttribArray: TglEnableVertexAttribArray;
9027 glGetActiveAttrib: TglGetActiveAttrib;
9028 glGetActiveUniform: TglGetActiveUniform;
9029 glGetAttachedShaders: TglGetAttachedShaders;
9030 glGetAttribLocation: TglGetAttribLocation;
9031 glGetProgramiv: TglGetProgramiv;
9032 glGetProgramInfoLog: TglGetProgramInfoLog;
9033 glGetShaderiv: TglGetShaderiv;
9034 glGetShaderInfoLog: TglGetShaderInfoLog;
9035 glGetShaderSource: TglGetShaderSource;
9036 glGetUniformLocation: TglGetUniformLocation;
9037 glGetUniformfv: TglGetUniformfv;
9038 glGetUniformiv: TglGetUniformiv;
9039 glGetVertexAttribfv: TglGetVertexAttribfv;
9040 glGetVertexAttribiv: TglGetVertexAttribiv;
9041 glGetVertexAttribPointerv: TglGetVertexAttribPointerv;
9042 glIsProgram: TglIsProgram;
9043 glIsShader: TglIsShader;
9044 glLinkProgram: TglLinkProgram;
9045 glShaderSource: TglShaderSource;
9046 glUseProgram: TglUseProgram;
9047 glUniform1f: TglUniform1f;
9048 glUniform2f: TglUniform2f;
9049 glUniform3f: TglUniform3f;
9050 glUniform4f: TglUniform4f;
9051 glUniform1i: TglUniform1i;
9052 glUniform2i: TglUniform2i;
9053 glUniform3i: TglUniform3i;
9054 glUniform4i: TglUniform4i;
9055 glUniform1fv: TglUniform1fv;
9056 glUniform2fv: TglUniform2fv;
9057 glUniform3fv: TglUniform3fv;
9058 glUniform4fv: TglUniform4fv;
9059 glUniform1iv: TglUniform1iv;
9060 glUniform2iv: TglUniform2iv;
9061 glUniform3iv: TglUniform3iv;
9062 glUniform4iv: TglUniform4iv;
9063 glUniformMatrix2fv: TglUniformMatrix2fv;
9064 glUniformMatrix3fv: TglUniformMatrix3fv;
9065 glUniformMatrix4fv: TglUniformMatrix4fv;
9066 glValidateProgram: TglValidateProgram;
9067 glVertexAttrib1d: TglVertexAttrib1d;
9068 glVertexAttrib1dv: TglVertexAttrib1dv;
9069 glVertexAttrib1f: TglVertexAttrib1f;
9070 glVertexAttrib1fv: TglVertexAttrib1fv;
9071 glVertexAttrib1s: TglVertexAttrib1s;
9072 glVertexAttrib1sv: TglVertexAttrib1sv;
9073 glVertexAttrib2d: TglVertexAttrib2d;
9074 glVertexAttrib2dv: TglVertexAttrib2dv;
9075 glVertexAttrib2f: TglVertexAttrib2f;
9076 glVertexAttrib2fv: TglVertexAttrib2fv;
9077 glVertexAttrib2s: TglVertexAttrib2s;
9078 glVertexAttrib2sv: TglVertexAttrib2sv;
9079 glVertexAttrib3d: TglVertexAttrib3d;
9080 glVertexAttrib3dv: TglVertexAttrib3dv;
9081 glVertexAttrib3f: TglVertexAttrib3f;
9082 glVertexAttrib3fv: TglVertexAttrib3fv;
9083 glVertexAttrib3s: TglVertexAttrib3s;
9084 glVertexAttrib3sv: TglVertexAttrib3sv;
9085 glVertexAttrib4Nbv: TglVertexAttrib4Nbv;
9086 glVertexAttrib4Niv: TglVertexAttrib4Niv;
9087 glVertexAttrib4Nsv: TglVertexAttrib4Nsv;
9088 glVertexAttrib4Nub: TglVertexAttrib4Nub;
9089 glVertexAttrib4Nubv: TglVertexAttrib4Nubv;
9090 glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv;
9091 glVertexAttrib4Nusv: TglVertexAttrib4Nusv;
9092 glVertexAttrib4bv: TglVertexAttrib4bv;
9093 glVertexAttrib4d: TglVertexAttrib4d;
9094 glVertexAttrib4dv: TglVertexAttrib4dv;
9095 glVertexAttrib4f: TglVertexAttrib4f;
9096 glVertexAttrib4fv: TglVertexAttrib4fv;
9097 glVertexAttrib4iv: TglVertexAttrib4iv;
9098 glVertexAttrib4s: TglVertexAttrib4s;
9099 glVertexAttrib4sv: TglVertexAttrib4sv;
9100 glVertexAttrib4ubv: TglVertexAttrib4ubv;
9101 glVertexAttrib4uiv: TglVertexAttrib4uiv;
9102 glVertexAttrib4usv: TglVertexAttrib4usv;
9103 glVertexAttribPointer: TglVertexAttribPointer;
9104
9105 // GL_VERSION_2_1
9106 glUniformMatrix2x3fv: TglUniformMatrix2x3fv;
9107 glUniformMatrix3x2fv: TglUniformMatrix3x2fv;
9108 glUniformMatrix2x4fv: TglUniformMatrix2x4fv;
9109 glUniformMatrix4x2fv: TglUniformMatrix4x2fv;
9110 glUniformMatrix3x4fv: TglUniformMatrix3x4fv;
9111 glUniformMatrix4x3fv: TglUniformMatrix4x3fv;
9112
9113 // GL_VERSION_3_0
9114 glColorMaski: TglColorMaski;
9115 glGetBooleani_v: TglGetBooleani_v;
9116 glGetIntegeri_v: TglGetIntegeri_v;
9117 glEnablei: TglEnablei;
9118 glDisablei: TglDisablei;
9119 glIsEnabledi: TglIsEnabledi;
9120 glBeginTransformFeedback: TglBeginTransformFeedback;
9121 glEndTransformFeedback: TglEndTransformFeedback;
9122 glBindBufferRange: TglBindBufferRange;
9123 glBindBufferBase: TglBindBufferBase;
9124 glTransformFeedbackVaryings: TglTransformFeedbackVaryings;
9125 glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying;
9126 glClampColor: TglClampColor;
9127 glBeginConditionalRender: TglBeginConditionalRender;
9128 glEndConditionalRender: TglEndConditionalRender;
9129 glVertexAttribI1i: TglVertexAttribI1i;
9130 glVertexAttribI2i: TglVertexAttribI2i;
9131 glVertexAttribI3i: TglVertexAttribI3i;
9132 glVertexAttribI4i: TglVertexAttribI4i;
9133 glVertexAttribI1ui: TglVertexAttribI1ui;
9134 glVertexAttribI2ui: TglVertexAttribI2ui;
9135 glVertexAttribI3ui: TglVertexAttribI3ui;
9136 glVertexAttribI4ui: TglVertexAttribI4ui;
9137 glVertexAttribI1iv: TglVertexAttribI1iv;
9138 glVertexAttribI2iv: TglVertexAttribI2iv;
9139 glVertexAttribI3iv: TglVertexAttribI3iv;
9140 glVertexAttribI4iv: TglVertexAttribI4iv;
9141 glVertexAttribI1uiv: TglVertexAttribI1uiv;
9142 glVertexAttribI2uiv: TglVertexAttribI2uiv;
9143 glVertexAttribI3uiv: TglVertexAttribI3uiv;
9144 glVertexAttribI4uiv: TglVertexAttribI4uiv;
9145 glVertexAttribI4bv: TglVertexAttribI4bv;
9146 glVertexAttribI4sv: TglVertexAttribI4sv;
9147 glVertexAttribI4ubv: TglVertexAttribI4ubv;
9148 glVertexAttribI4usv: TglVertexAttribI4usv;
9149 glVertexAttribIPointer: TglVertexAttribIPointer;
9150 glGetVertexAttribIiv: TglGetVertexAttribIiv;
9151 glGetVertexAttribIuiv: TglGetVertexAttribIuiv;
9152 glGetUniformuiv: TglGetUniformuiv;
9153 glBindFragDataLocation: TglBindFragDataLocation;
9154 glGetFragDataLocation: TglGetFragDataLocation;
9155 glUniform1ui: TglUniform1ui;
9156 glUniform2ui: TglUniform2ui;
9157 glUniform3ui: TglUniform3ui;
9158 glUniform4ui: TglUniform4ui;
9159 glUniform1uiv: TglUniform1uiv;
9160 glUniform2uiv: TglUniform2uiv;
9161 glUniform3uiv: TglUniform3uiv;
9162 glUniform4uiv: TglUniform4uiv;
9163 glTexParameterIiv: TglTexParameterIiv;
9164 glTexParameterIuiv: TglTexParameterIuiv;
9165 glGetTexParameterIiv: TglGetTexParameterIiv;
9166 glGetTexParameterIuiv: TglGetTexParameterIuiv;
9167 glClearBufferiv: TglClearBufferiv;
9168 glClearBufferuiv: TglClearBufferuiv;
9169 glClearBufferfv: TglClearBufferfv;
9170 glClearBufferfi: TglClearBufferfi;
9171 glGetStringi: TglGetStringi;
9172
9173 // GL_VERSION_3_1
9174 glDrawArraysInstanced: TglDrawArraysInstanced;
9175 glDrawElementsInstanced: TglDrawElementsInstanced;
9176 glTexBuffer: TglTexBuffer;
9177 glPrimitiveRestartIndex: TglPrimitiveRestartIndex;
9178
9179 // GL_VERSION_3_2
9180 { OpenGL 3.2 also reuses entry points from these extensions: }
9181 { ARB_draw_elements_base_vertex }
9182 { ARB_provoking_vertex }
9183 { ARB_sync }
9184 { ARB_texture_multisample }
9185 glGetInteger64i_v: TglGetInteger64i_v;
9186 glGetBufferParameteri64v: TglGetBufferParameteri64v;
9187 glProgramParameteri: TglProgramParameteri;
9188 glFramebufferTexture: TglFramebufferTexture;
9189 glFramebufferTextureFace: TglFramebufferTextureFace;
9190
9191 // GL_3DFX_tbuffer
9192 glTbufferMask3DFX: TglTbufferMask3DFX;
9193
9194 // GL_APPLE_element_array
9195 glElementPointerAPPLE: TglElementPointerAPPLE;
9196 glDrawElementArrayAPPLE: TglDrawElementArrayAPPLE;
9197 glDrawRangeElementArrayAPPLE: TglDrawRangeElementArrayAPPLE;
9198 glMultiDrawElementArrayAPPLE: TglMultiDrawElementArrayAPPLE;
9199 glMultiDrawRangeElementArrayAPPLE: TglMultiDrawRangeElementArrayAPPLE;
9200
9201 // GL_APPLE_fence
9202 glGenFencesAPPLE: TglGenFencesAPPLE;
9203 glDeleteFencesAPPLE: TglDeleteFencesAPPLE;
9204 glSetFenceAPPLE: TglSetFenceAPPLE;
9205 glIsFenceAPPLE: TglIsFenceAPPLE;
9206 glTestFenceAPPLE: TglTestFenceAPPLE;
9207 glFinishFenceAPPLE: TglFinishFenceAPPLE;
9208 glTestObjectAPPLE: TglTestObjectAPPLE;
9209 glFinishObjectAPPLE: TglFinishObjectAPPLE;
9210
9211 // GL_APPLE_vertex_array_object
9212 glBindVertexArrayAPPLE: TglBindVertexArrayAPPLE;
9213 glDeleteVertexArraysAPPLE: TglDeleteVertexArraysAPPLE;
9214 glGenVertexArraysAPPLE: TglGenVertexArraysAPPLE;
9215 glIsVertexArrayAPPLE: TglIsVertexArrayAPPLE;
9216
9217 // GL_APPLE_vertex_array_range
9218 glVertexArrayRangeAPPLE: TglVertexArrayRangeAPPLE;
9219 glFlushVertexArrayRangeAPPLE: TglFlushVertexArrayRangeAPPLE;
9220 glVertexArrayParameteriAPPLE: TglVertexArrayParameteriAPPLE;
9221
9222 // GL_APPLE_texture_range
9223 glTextureRangeAPPLE: TglTextureRangeAPPLE;
9224 glGetTexParameterPointervAPPLE: TglGetTexParameterPointervAPPLE;
9225
9226 // GL_APPLE_vertex_program_evaluators
9227 glEnableVertexAttribAPPLE: TglEnableVertexAttribAPPLE;
9228 glDisableVertexAttribAPPLE: TglDisableVertexAttribAPPLE;
9229 glIsVertexAttribEnabledAPPLE: TglIsVertexAttribEnabledAPPLE;
9230 glMapVertexAttrib1dAPPLE: TglMapVertexAttrib1dAPPLE;
9231 glMapVertexAttrib1fAPPLE: TglMapVertexAttrib1fAPPLE;
9232 glMapVertexAttrib2dAPPLE: TglMapVertexAttrib2dAPPLE;
9233 glMapVertexAttrib2fAPPLE: TglMapVertexAttrib2fAPPLE;
9234
9235 // GL_APPLE_object_purgeable
9236 glObjectPurgeableAPPLE: TglObjectPurgeableAPPLE;
9237 glObjectUnpurgeableAPPLE: TglObjectUnpurgeableAPPLE;
9238 glGetObjectParameterivAPPLE: TglGetObjectParameterivAPPLE;
9239
9240 // GL_ARB_matrix_palette
9241 glCurrentPaletteMatrixARB: TglCurrentPaletteMatrixARB;
9242 glMatrixIndexubvARB: TglMatrixIndexubvARB;
9243 glMatrixIndexusvARB: TglMatrixIndexusvARB;
9244 glMatrixIndexuivARB: TglMatrixIndexuivARB;
9245 glMatrixIndexPointerARB: TglMatrixIndexPointerARB;
9246
9247 // GL_ARB_multisample
9248 glSampleCoverageARB: TglSampleCoverageARB;
9249
9250 // GL_ARB_multitexture
9251 glActiveTextureARB: TglActiveTextureARB;
9252 glClientActiveTextureARB: TglClientActiveTextureARB;
9253 glMultiTexCoord1dARB: TglMultiTexCoord1dARB;
9254 glMultiTexCoord1dvARB: TglMultiTexCoord1dvARB;
9255 glMultiTexCoord1fARB: TglMultiTexCoord1fARB;
9256 glMultiTexCoord1fvARB: TglMultiTexCoord1fvARB;
9257 glMultiTexCoord1iARB: TglMultiTexCoord1iARB;
9258 glMultiTexCoord1ivARB: TglMultiTexCoord1ivARB;
9259 glMultiTexCoord1sARB: TglMultiTexCoord1sARB;
9260 glMultiTexCoord1svARB: TglMultiTexCoord1svARB;
9261 glMultiTexCoord2dARB: TglMultiTexCoord2dARB;
9262 glMultiTexCoord2dvARB: TglMultiTexCoord2dvARB;
9263 glMultiTexCoord2fARB: TglMultiTexCoord2fARB;
9264 glMultiTexCoord2fvARB: TglMultiTexCoord2fvARB;
9265 glMultiTexCoord2iARB: TglMultiTexCoord2iARB;
9266 glMultiTexCoord2ivARB: TglMultiTexCoord2ivARB;
9267 glMultiTexCoord2sARB: TglMultiTexCoord2sARB;
9268 glMultiTexCoord2svARB: TglMultiTexCoord2svARB;
9269 glMultiTexCoord3dARB: TglMultiTexCoord3dARB;
9270 glMultiTexCoord3dvARB: TglMultiTexCoord3dvARB;
9271 glMultiTexCoord3fARB: TglMultiTexCoord3fARB;
9272 glMultiTexCoord3fvARB: TglMultiTexCoord3fvARB;
9273 glMultiTexCoord3iARB: TglMultiTexCoord3iARB;
9274 glMultiTexCoord3ivARB: TglMultiTexCoord3ivARB;
9275 glMultiTexCoord3sARB: TglMultiTexCoord3sARB;
9276 glMultiTexCoord3svARB: TglMultiTexCoord3svARB;
9277 glMultiTexCoord4dARB: TglMultiTexCoord4dARB;
9278 glMultiTexCoord4dvARB: TglMultiTexCoord4dvARB;
9279 glMultiTexCoord4fARB: TglMultiTexCoord4fARB;
9280 glMultiTexCoord4fvARB: TglMultiTexCoord4fvARB;
9281 glMultiTexCoord4iARB: TglMultiTexCoord4iARB;
9282 glMultiTexCoord4ivARB: TglMultiTexCoord4ivARB;
9283 glMultiTexCoord4sARB: TglMultiTexCoord4sARB;
9284 glMultiTexCoord4svARB: TglMultiTexCoord4svARB;
9285
9286 // GL_ARB_point_parameters
9287 glPointParameterfARB: TglPointParameterfARB;
9288 glPointParameterfvARB: TglPointParameterfvARB;
9289
9290 // GL_ARB_texture_compression
9291 glCompressedTexImage3DARB: TglCompressedTexImage3DARB;
9292 glCompressedTexImage2DARB: TglCompressedTexImage2DARB;
9293 glCompressedTexImage1DARB: TglCompressedTexImage1DARB;
9294 glCompressedTexSubImage3DARB: TglCompressedTexSubImage3DARB;
9295 glCompressedTexSubImage2DARB: TglCompressedTexSubImage2DARB;
9296 glCompressedTexSubImage1DARB: TglCompressedTexSubImage1DARB;
9297 glGetCompressedTexImageARB: TglGetCompressedTexImageARB;
9298
9299 // GL_ARB_transpose_matrix
9300 glLoadTransposeMatrixfARB: TglLoadTransposeMatrixfARB;
9301 glLoadTransposeMatrixdARB: TglLoadTransposeMatrixdARB;
9302 glMultTransposeMatrixfARB: TglMultTransposeMatrixfARB;
9303 glMultTransposeMatrixdARB: TglMultTransposeMatrixdARB;
9304
9305 // GL_ARB_vertex_blend
9306 glWeightbvARB: TglWeightbvARB;
9307 glWeightsvARB: TglWeightsvARB;
9308 glWeightivARB: TglWeightivARB;
9309 glWeightfvARB: TglWeightfvARB;
9310 glWeightdvARB: TglWeightdvARB;
9311 glWeightubvARB: TglWeightubvARB;
9312 glWeightusvARB: TglWeightusvARB;
9313 glWeightuivARB: TglWeightuivARB;
9314 glWeightPointerARB: TglWeightPointerARB;
9315 glVertexBlendARB: TglVertexBlendARB;
9316
9317 // GL_ARB_vertex_buffer_object
9318 glBindBufferARB: TglBindBufferARB;
9319 glDeleteBuffersARB: TglDeleteBuffersARB;
9320 glGenBuffersARB: TglGenBuffersARB;
9321 glIsBufferARB: TglIsBufferARB;
9322 glBufferDataARB: TglBufferDataARB;
9323 glBufferSubDataARB: TglBufferSubData;
9324 glGetBufferSubDataARB: TglGetBufferSubDataARB;
9325 glMapBufferARB: TglMapBufferARB;
9326 glUnmapBufferARB: TglUnmapBufferARB;
9327 glGetBufferParameterivARB: TglGetBufferParameterivARB;
9328 glGetBufferPointervARB: TglGetBufferPointervARB;
9329
9330 // GL_ARB_vertex_program
9331 glVertexAttrib1dARB: TglVertexAttrib1dARB;
9332 glVertexAttrib1dvARB: TglVertexAttrib1dvARB;
9333 glVertexAttrib1fARB: TglVertexAttrib1fARB;
9334 glVertexAttrib1fvARB: TglVertexAttrib1fvARB;
9335 glVertexAttrib1sARB: TglVertexAttrib1sARB;
9336 glVertexAttrib1svARB: TglVertexAttrib1svARB;
9337 glVertexAttrib2dARB: TglVertexAttrib2dARB;
9338 glVertexAttrib2dvARB: TglVertexAttrib2dvARB;
9339 glVertexAttrib2fARB: TglVertexAttrib2fARB;
9340 glVertexAttrib2fvARB: TglVertexAttrib2fvARB;
9341 glVertexAttrib2sARB: TglVertexAttrib2sARB;
9342 glVertexAttrib2svARB: TglVertexAttrib2svARB;
9343 glVertexAttrib3dARB: TglVertexAttrib3dARB;
9344 glVertexAttrib3dvARB: TglVertexAttrib3dvARB;
9345 glVertexAttrib3fARB: TglVertexAttrib3fARB;
9346 glVertexAttrib3fvARB: TglVertexAttrib3fvARB;
9347 glVertexAttrib3sARB: TglVertexAttrib3sARB;
9348 glVertexAttrib3svARB: TglVertexAttrib3svARB;
9349 glVertexAttrib4NbvARB: TglVertexAttrib4NbvARB;
9350 glVertexAttrib4NivARB: TglVertexAttrib4NivARB;
9351 glVertexAttrib4NsvARB: TglVertexAttrib4NsvARB;
9352 glVertexAttrib4NubARB: TglVertexAttrib4NubARB;
9353 glVertexAttrib4NubvARB: TglVertexAttrib4NubvARB;
9354 glVertexAttrib4NuivARB: TglVertexAttrib4NuivARB;
9355 glVertexAttrib4NusvARB: TglVertexAttrib4NusvARB;
9356 glVertexAttrib4bvARB: TglVertexAttrib4bvARB;
9357 glVertexAttrib4dARB: TglVertexAttrib4dARB;
9358 glVertexAttrib4dvARB: TglVertexAttrib4dvARB;
9359 glVertexAttrib4fARB: TglVertexAttrib4fARB;
9360 glVertexAttrib4fvARB: TglVertexAttrib4fvARB;
9361 glVertexAttrib4ivARB: TglVertexAttrib4ivARB;
9362 glVertexAttrib4sARB: TglVertexAttrib4sARB;
9363 glVertexAttrib4svARB: TglVertexAttrib4svARB;
9364 glVertexAttrib4ubvARB: TglVertexAttrib4ubvARB;
9365 glVertexAttrib4uivARB: TglVertexAttrib4uivARB;
9366 glVertexAttrib4usvARB: TglVertexAttrib4usvARB;
9367 glVertexAttribPointerARB: TglVertexAttribPointerARB;
9368 glEnableVertexAttribArrayARB: TglEnableVertexAttribArrayARB;
9369 glDisableVertexAttribArrayARB: TglDisableVertexAttribArrayARB;
9370 glProgramStringARB: TglProgramStringARB;
9371 glBindProgramARB: TglBindProgramARB;
9372 glDeleteProgramsARB: TglDeleteProgramsARB;
9373 glGenProgramsARB: TglGenProgramsARB;
9374
9375 glProgramEnvParameter4dARB: TglProgramEnvParameter4dARB;
9376 glProgramEnvParameter4dvARB: TglProgramEnvParameter4dvARB;
9377 glProgramEnvParameter4fARB: TglProgramEnvParameter4fARB;
9378 glProgramEnvParameter4fvARB: TglProgramEnvParameter4fvARB;
9379 glProgramLocalParameter4dARB: TglProgramLocalParameter4dARB;
9380 glProgramLocalParameter4dvARB: TglProgramLocalParameter4dvARB;
9381 glProgramLocalParameter4fARB: TglProgramLocalParameter4fARB;
9382 glProgramLocalParameter4fvARB: TglProgramLocalParameter4fvARB;
9383 glGetProgramEnvParameterdvARB: TglGetProgramEnvParameterdvARB;
9384 glGetProgramEnvParameterfvARB: TglGetProgramEnvParameterfvARB;
9385 glGetProgramLocalParameterdvARB: TglGetProgramLocalParameterdvARB;
9386 glGetProgramLocalParameterfvARB: TglGetProgramLocalParameterfvARB;
9387 glGetProgramivARB: TglGetProgramivARB;
9388 glGetProgramStringARB: TglGetProgramStringARB;
9389 glGetVertexAttribdvARB: TglGetVertexAttribdvARB;
9390 glGetVertexAttribfvARB: TglGetVertexAttribfvARB;
9391 glGetVertexAttribivARB: TglGetVertexAttribivARB;
9392 glGetVertexAttribPointervARB: TglGetVertexAttribPointervARB;
9393 glIsProgramARB: TglIsProgramARB;
9394
9395 // GL_ARB_window_pos
9396 glWindowPos2dARB: TglWindowPos2dARB;
9397 glWindowPos2dvARB: TglWindowPos2dvARB;
9398 glWindowPos2fARB: TglWindowPos2fARB;
9399 glWindowPos2fvARB: TglWindowPos2fvARB;
9400 glWindowPos2iARB: TglWindowPos2iARB;
9401 glWindowPos2ivARB: TglWindowPos2ivARB;
9402 glWindowPos2sARB: TglWindowPos2sARB;
9403 glWindowPos2svARB: TglWindowPos2svARB;
9404 glWindowPos3dARB: TglWindowPos3dARB;
9405 glWindowPos3dvARB: TglWindowPos3dvARB;
9406 glWindowPos3fARB: TglWindowPos3fARB;
9407 glWindowPos3fvARB: TglWindowPos3fvARB;
9408 glWindowPos3iARB: TglWindowPos3iARB;
9409 glWindowPos3ivARB: TglWindowPos3ivARB;
9410 glWindowPos3sARB: TglWindowPos3sARB;
9411 glWindowPos3svARB: TglWindowPos3svARB;
9412
9413 // GL_ARB_draw_buffers
9414 glDrawBuffersARB: TglDrawBuffersARB;
9415
9416 // GL_ARB_color_buffer_float
9417 glClampColorARB: TglClampColorARB;
9418
9419 // GL_ARB_vertex_shader
9420 glGetActiveAttribARB: TglGetActiveAttribARB;
9421 glGetAttribLocationARB: TglGetAttribLocationARB;
9422 glBindAttribLocationARB: TglBindAttribLocationARB;
9423
9424 // GL_ARB_shader_objects
9425 glDeleteObjectARB: TglDeleteObjectARB;
9426 glGetHandleARB: TglGetHandleARB;
9427 glDetachObjectARB: TglDetachObjectARB;
9428 glCreateShaderObjectARB: TglCreateShaderObjectARB;
9429 glShaderSourceARB: TglShaderSourceARB;
9430 glCompileShaderARB: TglCompileShaderARB;
9431 glCreateProgramObjectARB: TglCreateProgramObjectARB;
9432 glAttachObjectARB: TglAttachObjectARB;
9433 glLinkProgramARB: TglLinkProgramARB;
9434 glUseProgramObjectARB: TglUseProgramObjectARB;
9435 glValidateProgramARB: TglValidateProgramARB;
9436 glUniform1fARB: TglUniform1fARB;
9437 glUniform2fARB: TglUniform2fARB;
9438 glUniform3fARB: TglUniform3fARB;
9439 glUniform4fARB: TglUniform4fARB;
9440 glUniform1iARB: TglUniform1iARB;
9441 glUniform2iARB: TglUniform2iARB;
9442 glUniform3iARB: TglUniform3iARB;
9443 glUniform4iARB: TglUniform4iARB;
9444 glUniform1fvARB: TglUniform1fvARB;
9445 glUniform2fvARB: TglUniform2fvARB;
9446 glUniform3fvARB: TglUniform3fvARB;
9447 glUniform4fvARB: TglUniform4fvARB;
9448 glUniform1ivARB: TglUniform1ivARB;
9449 glUniform2ivARB: TglUniform2ivARB;
9450 glUniform3ivARB: TglUniform3ivARB;
9451 glUniform4ivARB: TglUniform4ivARB;
9452 glUniformMatrix2fvARB: TglUniformMatrix2fvARB;
9453 glUniformMatrix3fvARB: TglUniformMatrix3fvARB;
9454 glUniformMatrix4fvARB: TglUniformMatrix4fvARB;
9455 glGetObjectParameterfvARB: TglGetObjectParameterfvARB;
9456 glGetObjectParameterivARB: TglGetObjectParameterivARB;
9457 glGetInfoLogARB: TglGetInfoLogARB;
9458 glGetAttachedObjectsARB: TglGetAttachedObjectsARB;
9459 glGetUniformLocationARB: TglGetUniformLocationARB;
9460 glGetActiveUniformARB: TglGetActiveUniformARB;
9461 glGetUniformfvARB: TglGetUniformfvARB;
9462 glGetUniformivARB: TglGetUniformivARB;
9463 glGetShaderSourceARB: TglGetShaderSourceARB;
9464
9465 // GL_ARB_Occlusion_Query
9466 glGenQueriesARB: TglGenQueriesARB;
9467 glDeleteQueriesARB: TglDeleteQueriesARB;
9468 glIsQueryARB: TglIsQueryARB;
9469 glBeginQueryARB: TglBeginQueryARB;
9470 glEndQueryARB: TglEndQueryARB;
9471 glGetQueryivARB: TglGetQueryivARB;
9472 glGetQueryObjectivARB: TglGetQueryObjectivARB;
9473 glGetQueryObjectuivARB: TglGetQueryObjectuivARB;
9474
9475 // GL_ARB_draw_instanced
9476 glDrawArraysInstancedARB: TglDrawArraysInstancedARB;
9477 glDrawElementsInstancedARB: TglDrawElementsInstancedARB;
9478
9479 // GL_ARB_framebuffer_object
9480 glIsRenderbuffer: TglIsRenderbuffer;
9481 glBindRenderbuffer: TglBindRenderbuffer;
9482 glDeleteRenderbuffers: TglDeleteRenderbuffers;
9483 glGenRenderbuffers: TglGenRenderbuffers;
9484 glRenderbufferStorage: TglRenderbufferStorage;
9485 glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv;
9486 glIsFramebuffer: TglIsFramebuffer;
9487 glBindFramebuffer: TglBindFramebuffer;
9488 glDeleteFramebuffers: TglDeleteFramebuffers;
9489 glGenFramebuffers: TglGenFramebuffers;
9490 glCheckFramebufferStatus: TglCheckFramebufferStatus;
9491 glFramebufferTexture1D: TglFramebufferTexture1D;
9492 glFramebufferTexture2D: TglFramebufferTexture2D;
9493 glFramebufferTexture3D: TglFramebufferTexture3D;
9494 glFramebufferRenderbuffer: TglFramebufferRenderbuffer;
9495 glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv;
9496 glGenerateMipmap: TglGenerateMipmap;
9497 glBlitFramebuffer: TglBlitFramebuffer;
9498 glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample;
9499 glFramebufferTextureLayer: TglFramebufferTextureLayer;
9500
9501 // GL_ARB_geometry_shader4
9502 glProgramParameteriARB: TglProgramParameteriARB;
9503 glFramebufferTextureARB: TglFramebufferTextureARB;
9504 glFramebufferTextureLayerARB: TglFramebufferTextureLayerARB;
9505 glFramebufferTextureFaceARB: TglFramebufferTextureFaceARB;
9506
9507 // GL_ARB_instanced_arrays
9508 glVertexAttribDivisorARB: TglVertexAttribDivisorARB;
9509
9510 // GL_ARB_map_buffer_range
9511 glMapBufferRange: TglMapBufferRange;
9512 glFlushMappedBufferRange: TglFlushMappedBufferRange;
9513
9514 // GL_ARB_texture_buffer_object
9515 glTexBufferARB: TglTexBufferARB;
9516
9517 // GL_ARB_vertex_array_object
9518 glBindVertexArray: TglBindVertexArray;
9519 glDeleteVertexArrays: TglDeleteVertexArrays;
9520 glGenVertexArrays: TglGenVertexArrays;
9521 glIsVertexArray: TglIsVertexArray;
9522
9523 // GL_ARB_uniform_buffer_object
9524 glGetUniformIndices: TglGetUniformIndices;
9525 glGetActiveUniformsiv: TglGetActiveUniformsiv;
9526 glGetActiveUniformName: TglGetActiveUniformName;
9527 glGetUniformBlockIndex: TglGetUniformBlockIndex;
9528 glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv;
9529 glGetActiveUniformBlockName: TglGetActiveUniformBlockName;
9530 glUniformBlockBinding: TglUniformBlockBinding;
9531
9532 // GL_ARB_copy_buffer
9533 glCopyBufferSubData: TglCopyBufferSubData;
9534
9535 // GL_ARB_draw_elements_base_vertex
9536 glDrawElementsBaseVertex: TglDrawElementsBaseVertex;
9537 glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex;
9538 glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex;
9539 glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex;
9540
9541 // GL_ARB_provoking_vertex
9542 glProvokingVertex: TglProvokingVertex;
9543
9544 // GL_ARB_sync
9545 glFenceSync: TglFenceSync;
9546 glIsSync: TglIsSync;
9547 glDeleteSync: TglDeleteSync;
9548 glClientWaitSync: TglClientWaitSync;
9549 glWaitSync: TglWaitSync;
9550 glGetInteger64v: TglGetInteger64v;
9551 glGetSynciv: TglGetSynciv;
9552
9553 // GL_ARB_texture_multisample
9554 glTexImage2DMultisample: TglTexImage2DMultisample;
9555 glTexImage3DMultisample: TglTexImage3DMultisample;
9556 glGetMultisamplefv: TglGetMultisamplefv;
9557 glSampleMaski: TglSampleMaski;
9558
9559 // GL_ARB_draw_buffers_blend
9560 glBlendEquationi: TglBlendEquationi;
9561 glBlendEquationSeparatei: TglBlendEquationSeparatei;
9562 glBlendFunci: TglBlendFunci;
9563 glBlendFuncSeparatei: TglBlendFuncSeparatei;
9564
9565 // GL_ARB_sample_shading
9566 glMinSampleShading: TglMinSampleShading;
9567
9568 // GL_ATI_draw_buffers
9569 glDrawBuffersATI: TglDrawBuffersATI;
9570
9571 // GL_ATI_element_array
9572 glElementPointerATI: TglElementPointerATI;
9573 glDrawElementArrayATI: TglDrawElementArrayATI;
9574 glDrawRangeElementArrayATI: TglDrawRangeElementArrayATI;
9575
9576 // GL_ATI_envmap_bumpmap
9577 glTexBumpParameterivATI: TglTexBumpParameterivATI;
9578 glTexBumpParameterfvATI: TglTexBumpParameterfvATI;
9579 glGetTexBumpParameterivATI: TglGetTexBumpParameterivATI;
9580 glGetTexBumpParameterfvATI: TglGetTexBumpParameterfvATI;
9581
9582 // GL_ATI_fragment_shader
9583 glGenFragmentShadersATI: TglGenFragmentShadersATI;
9584 glBindFragmentShaderATI: TglBindFragmentShaderATI;
9585 glDeleteFragmentShaderATI: TglDeleteFragmentShaderATI;
9586 glBeginFragmentShaderATI: TglBeginFragmentShaderATI;
9587 glEndFragmentShaderATI: TglEndFragmentShaderATI;
9588 glPassTexCoordATI: TglPassTexCoordATI;
9589 glSampleMapATI: TglSampleMapATI;
9590 glColorFragmentOp1ATI: TglColorFragmentOp1ATI;
9591 glColorFragmentOp2ATI: TglColorFragmentOp2ATI;
9592 glColorFragmentOp3ATI: TglColorFragmentOp3ATI;
9593 glAlphaFragmentOp1ATI: TglAlphaFragmentOp1ATI;
9594 glAlphaFragmentOp2ATI: TglAlphaFragmentOp2ATI;
9595 glAlphaFragmentOp3ATI: TglAlphaFragmentOp3ATI;
9596 glSetFragmentShaderConstantATI: TglSetFragmentShaderConstantATI;
9597
9598 // GL_ATI_map_object_buffer
9599 glMapObjectBufferATI: TglMapObjectBufferATI;
9600 glUnmapObjectBufferATI: TglUnmapObjectBufferATI;
9601
9602 // GL_ATI_pn_triangles
9603 glPNTrianglesiATI: TglPNTrianglesiATI;
9604 glPNTrianglesfATI: TglPNTrianglesfATI;
9605
9606 // GL_ATI_separate_stencil
9607 glStencilOpSeparateATI: TglStencilOpSeparateATI;
9608 glStencilFuncSeparateATI: TglStencilFuncSeparateATI;
9609
9610 // GL_ATI_vertex_array_object
9611 glNewObjectBufferATI: TglNewObjectBufferATI;
9612 glIsObjectBufferATI: TglIsObjectBufferATI;
9613 glUpdateObjectBufferATI: TglUpdateObjectBufferATI;
9614 glGetObjectBufferfvATI: TglGetObjectBufferfvATI;
9615 glGetObjectBufferivATI: TglGetObjectBufferivATI;
9616 glFreeObjectBufferATI: TglFreeObjectBufferATI;
9617 glArrayObjectATI: TglArrayObjectATI;
9618 glGetArrayObjectfvATI: TglGetArrayObjectfvATI;
9619 glGetArrayObjectivATI: TglGetArrayObjectivATI;
9620 glVariantArrayObjectATI: TglVariantArrayObjectATI;
9621 glGetVariantArrayObjectfvATI: TglGetVariantArrayObjectfvATI;
9622 glGetVariantArrayObjectivATI: TglGetVariantArrayObjectivATI;
9623 glVertexAttribArrayObjectATI: TglVertexAttribArrayObjectATI;
9624 glGetVertexAttribArrayObjectfvATI: TglGetVertexAttribArrayObjectfvATI;
9625 glGetVertexAttribArrayObjectivATI: TglGetVertexAttribArrayObjectivATI;
9626
9627 // GL_ATI_vertex_streams
9628 glVertexStream1sATI: TglVertexStream1sATI;
9629 glVertexStream1svATI: TglVertexStream1svATI;
9630 glVertexStream1iATI: TglVertexStream1iATI;
9631 glVertexStream1ivATI: TglVertexStream1ivATI;
9632 glVertexStream1fATI: TglVertexStream1fATI;
9633 glVertexStream1fvATI: TglVertexStream1fvATI;
9634 glVertexStream1dATI: TglVertexStream1dATI;
9635 glVertexStream1dvATI: TglVertexStream1dvATI;
9636 glVertexStream2sATI: TglVertexStream2sATI;
9637 glVertexStream2svATI: TglVertexStream2svATI;
9638 glVertexStream2iATI: TglVertexStream2iATI;
9639 glVertexStream2ivATI: TglVertexStream2ivATI;
9640 glVertexStream2fATI: TglVertexStream2fATI;
9641 glVertexStream2fvATI: TglVertexStream2fvATI;
9642 glVertexStream2dATI: TglVertexStream2dATI;
9643 glVertexStream2dvATI: TglVertexStream2dvATI;
9644 glVertexStream3sATI: TglVertexStream3sATI;
9645 glVertexStream3svATI: TglVertexStream3svATI;
9646 glVertexStream3iATI: TglVertexStream3iATI;
9647 glVertexStream3ivATI: TglVertexStream3ivATI;
9648 glVertexStream3fATI: TglVertexStream3fATI;
9649 glVertexStream3fvATI: TglVertexStream3fvATI;
9650 glVertexStream3dATI: TglVertexStream3dATI;
9651 glVertexStream3dvATI: TglVertexStream3dvATI;
9652 glVertexStream4sATI: TglVertexStream4sATI;
9653 glVertexStream4svATI: TglVertexStream4svATI;
9654 glVertexStream4iATI: TglVertexStream4iATI;
9655 glVertexStream4ivATI: TglVertexStream4ivATI;
9656 glVertexStream4fATI: TglVertexStream4fATI;
9657 glVertexStream4fvATI: TglVertexStream4fvATI;
9658 glVertexStream4dATI: TglVertexStream4dATI;
9659 glVertexStream4dvATI: TglVertexStream4dvATI;
9660 glNormalStream3bATI: TglNormalStream3bATI;
9661 glNormalStream3bvATI: TglNormalStream3bvATI;
9662 glNormalStream3sATI: TglNormalStream3sATI;
9663 glNormalStream3svATI: TglNormalStream3svATI;
9664 glNormalStream3iATI: TglNormalStream3iATI;
9665 glNormalStream3ivATI: TglNormalStream3ivATI;
9666 glNormalStream3fATI: TglNormalStream3fATI;
9667 glNormalStream3fvATI: TglNormalStream3fvATI;
9668 glNormalStream3dATI: TglNormalStream3dATI;
9669 glNormalStream3dvATI: TglNormalStream3dvATI;
9670 glClientActiveVertexStreamATI: TglClientActiveVertexStreamATI;
9671 glVertexBlendEnviATI: TglVertexBlendEnviATI;
9672 glVertexBlendEnvfATI: TglVertexBlendEnvfATI;
9673
9674 // GL_AMD_performance_monitor
9675 glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD;
9676 glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD;
9677 glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD;
9678 glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD;
9679 glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD;
9680 glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD;
9681 glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD;
9682 glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD;
9683 glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD;
9684 glEndPerfMonitorAMD: TglEndPerfMonitorAMD;
9685 glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD;
9686
9687 // GL_EXT_blend_color
9688 glBlendColorEXT: TglBlendColorEXT;
9689
9690 // GL_EXT_blend_func_separate
9691 glBlendFuncSeparateEXT: TglBlendFuncSeparateEXT;
9692
9693 // GL_EXT_blend_minmax
9694 glBlendEquationEXT: TglBlendEquationEXT;
9695
9696 // GL_EXT_color_subtable
9697 glColorSubTableEXT: TglColorSubTableEXT;
9698 glCopyColorSubTableEXT: TglCopyColorSubTableEXT;
9699
9700 // GL_EXT_compiled_vertex_array
9701 glLockArraysEXT: TglLockArraysEXT;
9702 glUnlockArraysEXT: TglUnlockArraysEXT;
9703
9704 // GL_EXT_convolution
9705 glConvolutionFilter1DEXT: TglConvolutionFilter1DEXT;
9706 glConvolutionFilter2DEXT: TglConvolutionFilter2DEXT;
9707 glConvolutionParameterfEXT: TglConvolutionParameterfEXT;
9708 glConvolutionParameterfvEXT: TglConvolutionParameterfvEXT;
9709 glConvolutionParameteriEXT: TglConvolutionParameteriEXT;
9710 glConvolutionParameterivEXT: TglConvolutionParameterivEXT;
9711 glCopyConvolutionFilter1DEXT: TglCopyConvolutionFilter1DEXT;
9712 glCopyConvolutionFilter2DEXT: TglCopyConvolutionFilter2DEXT;
9713 glGetConvolutionFilterEXT: TglGetConvolutionFilterEXT;
9714 glGetConvolutionParameterfvEXT: TglGetConvolutionParameterfvEXT;
9715 glGetConvolutionParameterivEXT: TglGetConvolutionParameterivEXT;
9716 glGetSeparableFilterEXT: TglGetSeparableFilterEXT;
9717 glSeparableFilter2DEXT: TglSeparableFilter2DEXT;
9718
9719 // GL_EXT_coordinate_frame
9720 glTangent3bEXT: TglTangent3bEXT;
9721 glTangent3bvEXT: TglTangent3bvEXT;
9722 glTangent3dEXT: TglTangent3dEXT;
9723 glTangent3dvEXT: TglTangent3dvEXT;
9724 glTangent3fEXT: TglTangent3fEXT;
9725 glTangent3fvEXT: TglTangent3fvEXT;
9726 glTangent3iEXT: TglTangent3iEXT;
9727 glTangent3ivEXT: TglTangent3ivEXT;
9728 glTangent3sEXT: TglTangent3sEXT;
9729 glTangent3svEXT: TglTangent3svEXT;
9730 glBinormal3bEXT: TglBinormal3bEXT;
9731 glBinormal3bvEXT: TglBinormal3bvEXT;
9732 glBinormal3dEXT: TglBinormal3dEXT;
9733 glBinormal3dvEXT: TglBinormal3dvEXT;
9734 glBinormal3fEXT: TglBinormal3fEXT;
9735 glBinormal3fvEXT: TglBinormal3fvEXT;
9736 glBinormal3iEXT: TglBinormal3iEXT;
9737 glBinormal3ivEXT: TglBinormal3ivEXT;
9738 glBinormal3sEXT: TglBinormal3sEXT;
9739 glBinormal3svEXT: TglBinormal3svEXT;
9740 glTangentPointerEXT: TglTangentPointerEXT;
9741 glBinormalPointerEXT: TglBinormalPointerEXT;
9742
9743 // GL_EXT_copy_texture
9744 glCopyTexImage1DEXT: TglCopyTexImage1DEXT;
9745 glCopyTexImage2DEXT: TglCopyTexImage2DEXT;
9746 glCopyTexSubImage1DEXT: TglCopyTexSubImage1DEXT;
9747 glCopyTexSubImage2DEXT: TglCopyTexSubImage2DEXT;
9748 glCopyTexSubImage3DEXT: TglCopyTexSubImage3DEXT;
9749
9750 // GL_EXT_cull_vertex
9751 glCullParameterdvEXT: TglCullParameterdvEXT;
9752 glCullParameterfvEXT: TglCullParameterfvEXT;
9753
9754 // GL_EXT_draw_range_elements
9755 glDrawRangeElementsEXT: TglDrawRangeElementsEXT;
9756
9757 // GL_EXT_fog_coord
9758 glFogCoordfEXT: TglFogCoordfEXT;
9759 glFogCoordfvEXT: TglFogCoordfvEXT;
9760 glFogCoorddEXT: TglFogCoorddEXT;
9761 glFogCoorddvEXT: TglFogCoorddvEXT;
9762 glFogCoordPointerEXT: TglFogCoordPointerEXT;
9763
9764 // GL_EXT_framebuffer_object
9765 glIsRenderbufferEXT: TglIsRenderbufferEXT;
9766 glBindRenderbufferEXT: TglBindRenderbufferEXT;
9767 glDeleteRenderbuffersEXT: TglDeleteRenderbuffersEXT;
9768 glGenRenderbuffersEXT: TglGenRenderbuffersEXT;
9769 glRenderbufferStorageEXT: TglRenderbufferStorageEXT;
9770 glGetRenderbufferParameterivEXT: TglGetRenderbufferParameterivEXT;
9771 glIsFramebufferEXT: TglIsFramebufferEXT;
9772 glBindFramebufferEXT: TglBindFramebufferEXT;
9773 glDeleteFramebuffersEXT: TglDeleteFramebuffersEXT;
9774 glGenFramebuffersEXT: TglGenFramebuffersEXT;
9775 glCheckFramebufferStatusEXT: TglCheckFramebufferStatusEXT;
9776 glFramebufferTexture1DEXT: TglFramebufferTexture1DEXT;
9777 glFramebufferTexture2DEXT: TglFramebufferTexture2DEXT;
9778 glFramebufferTexture3DEXT: TglFramebufferTexture3DEXT;
9779 glFramebufferRenderbufferEXT: TglFramebufferRenderbufferEXT;
9780 glGetFramebufferAttachmentParameterivEXT: TglGetFramebufferAttachmentParameterivEXT;
9781 glGenerateMipmapEXT: TglGenerateMipmapEXT;
9782
9783 // GL_EXT_histogram
9784 glGetHistogramEXT: TglGetHistogramEXT;
9785 glGetHistogramParameterfvEXT: TglGetHistogramParameterfvEXT;
9786 glGetHistogramParameterivEXT: TglGetHistogramParameterivEXT;
9787 glGetMinmaxEXT: TglGetMinmaxEXT;
9788 glGetMinmaxParameterfvEXT: TglGetMinmaxParameterfvEXT;
9789 glGetMinmaxParameterivEXT: TglGetMinmaxParameterivEXT;
9790 glHistogramEXT: TglHistogramEXT;
9791 glMinmaxEXT: TglMinmaxEXT;
9792 glResetHistogramEXT: TglResetHistogramEXT;
9793 glResetMinmaxEXT: TglResetMinmaxEXT;
9794
9795 // GL_EXT_index_func
9796 glIndexFuncEXT: TglIndexFuncEXT;
9797
9798 // GL_EXT_index_material
9799 glIndexMaterialEXT: TglIndexMaterialEXT;
9800
9801 // GL_EXT_light_texture
9802 glApplyTextureEXT: TglApplyTextureEXT;
9803 glTextureLightEXT: TglTextureLightEXT;
9804 glTextureMaterialEXT: TglTextureMaterialEXT;
9805
9806 // GL_EXT_multi_draw_arrays
9807 glMultiDrawArraysEXT: TglMultiDrawArraysEXT;
9808 glMultiDrawElementsEXT: TglMultiDrawElementsEXT;
9809
9810 // GL_EXT_multisample
9811 glSampleMaskEXT: TglSampleMaskEXT;
9812 glSamplePatternEXT: TglSamplePatternEXT;
9813
9814 // GL_EXT_paletted_texture
9815 glColorTableEXT: TglColorTableEXT;
9816 glGetColorTableEXT: TglGetColorTableEXT;
9817 glGetColorTableParameterivEXT: TglGetColorTableParameterivEXT;
9818 glGetColorTableParameterfvEXT: TglGetColorTableParameterfvEXT;
9819
9820 // GL_EXT_pixel_transform
9821 glPixelTransformParameteriEXT: TglPixelTransformParameteriEXT;
9822 glPixelTransformParameterfEXT: TglPixelTransformParameterfEXT;
9823 glPixelTransformParameterivEXT: TglPixelTransformParameterivEXT;
9824 glPixelTransformParameterfvEXT: TglPixelTransformParameterfvEXT;
9825
9826 // GL_EXT_point_parameters
9827 glPointParameterfEXT: TglPointParameterfEXT;
9828 glPointParameterfvEXT: TglPointParameterfvEXT;
9829
9830 // GL_EXT_polygon_offset
9831 glPolygonOffsetEXT: TglPolygonOffsetEXT;
9832
9833 // GL_EXT_secondary_color
9834 glSecondaryColor3bEXT: TglSecondaryColor3bEXT;
9835 glSecondaryColor3bvEXT: TglSecondaryColor3bvEXT;
9836 glSecondaryColor3dEXT: TglSecondaryColor3dEXT;
9837 glSecondaryColor3dvEXT: TglSecondaryColor3dvEXT;
9838 glSecondaryColor3fEXT: TglSecondaryColor3fEXT;
9839 glSecondaryColor3fvEXT: TglSecondaryColor3fvEXT;
9840 glSecondaryColor3iEXT: TglSecondaryColor3iEXT;
9841 glSecondaryColor3ivEXT: TglSecondaryColor3ivEXT;
9842 glSecondaryColor3sEXT: TglSecondaryColor3sEXT;
9843 glSecondaryColor3svEXT: TglSecondaryColor3svEXT;
9844 glSecondaryColor3ubEXT: TglSecondaryColor3ubEXT;
9845 glSecondaryColor3ubvEXT: TglSecondaryColor3ubvEXT;
9846 glSecondaryColor3uiEXT: TglSecondaryColor3uiEXT;
9847 glSecondaryColor3uivEXT: TglSecondaryColor3uivEXT;
9848 glSecondaryColor3usEXT: TglSecondaryColor3usEXT;
9849 glSecondaryColor3usvEXT: TglSecondaryColor3usvEXT;
9850 glSecondaryColorPointerEXT: TglSecondaryColorPointerEXT;
9851
9852 // GL_EXT_stencil_two_side
9853 glActiveStencilFaceEXT: TglActiveStencilFaceEXT;
9854
9855 // GL_EXT_subtexture
9856 glTexSubImage1DEXT: TglTexSubImage1DEXT;
9857 glTexSubImage2DEXT: TglTexSubImage2DEXT;
9858
9859 // GL_EXT_texture3D
9860 glTexImage3DEXT: TglTexImage3DEXT;
9861 glTexSubImage3DEXT: TglTexSubImage3DEXT;
9862
9863 // GL_EXT_texture_object
9864 glAreTexturesResidentEXT: TglAreTexturesResidentEXT;
9865 glBindTextureEXT: TglBindTextureEXT;
9866 glDeleteTexturesEXT: TglDeleteTexturesEXT;
9867 glGenTexturesEXT: TglGenTexturesEXT;
9868 glIsTextureEXT: TglIsTextureEXT;
9869 glPrioritizeTexturesEXT: TglPrioritizeTexturesEXT;
9870
9871 // GL_EXT_texture_perturb_normal
9872 glTextureNormalEXT: TglTextureNormalEXT;
9873
9874 // GL_EXT_vertex_array
9875 glArrayElementEXT: TglArrayElementEXT;
9876 glColorPointerEXT: TglColorPointerEXT;
9877 glDrawArraysEXT: TglDrawArraysEXT;
9878 glEdgeFlagPointerEXT: TglEdgeFlagPointerEXT;
9879 glGetPointervEXT: TglGetPointervEXT;
9880 glIndexPointerEXT: TglIndexPointerEXT;
9881 glNormalPointerEXT: TglNormalPointerEXT;
9882 glTexCoordPointerEXT: TglTexCoordPointerEXT;
9883 glVertexPointerEXT: TglVertexPointerEXT;
9884
9885 // GL_EXT_vertex_shader
9886 glBeginVertexShaderEXT: TglBeginVertexShaderEXT;
9887 glEndVertexShaderEXT: TglEndVertexShaderEXT;
9888 glBindVertexShaderEXT: TglBindVertexShaderEXT;
9889 glGenVertexShadersEXT: TglGenVertexShadersEXT;
9890 glDeleteVertexShaderEXT: TglDeleteVertexShaderEXT;
9891 glShaderOp1EXT: TglShaderOp1EXT;
9892 glShaderOp2EXT: TglShaderOp2EXT;
9893 glShaderOp3EXT: TglShaderOp3EXT;
9894 glSwizzleEXT: TglSwizzleEXT;
9895 glWriteMaskEXT: TglWriteMaskEXT;
9896 glInsertComponentEXT: TglInsertComponentEXT;
9897 glExtractComponentEXT: TglExtractComponentEXT;
9898 glGenSymbolsEXT: TglGenSymbolsEXT;
9899 glSetInvariantEXT: TglSetInvariantEXT;
9900 glSetLocalConstantEXT: TglSetLocalConstantEXT;
9901 glVariantbvEXT: TglVariantbvEXT;
9902 glVariantsvEXT: TglVariantsvEXT;
9903 glVariantivEXT: TglVariantivEXT;
9904 glVariantfvEXT: TglVariantfvEXT;
9905 glVariantdvEXT: TglVariantdvEXT;
9906 glVariantubvEXT: TglVariantubvEXT;
9907 glVariantusvEXT: TglVariantusvEXT;
9908 glVariantuivEXT: TglVariantuivEXT;
9909 glVariantPointerEXT: TglVariantPointerEXT;
9910 glEnableVariantClientStateEXT: TglEnableVariantClientStateEXT;
9911 glDisableVariantClientStateEXT: TglDisableVariantClientStateEXT;
9912 glBindLightParameterEXT: TglBindLightParameterEXT;
9913 glBindMaterialParameterEXT: TglBindMaterialParameterEXT;
9914 glBindTexGenParameterEXT: TglBindTexGenParameterEXT;
9915 glBindTextureUnitParameterEXT: TglBindTextureUnitParameterEXT;
9916 glBindParameterEXT: TglBindParameterEXT;
9917 glIsVariantEnabledEXT: TglIsVariantEnabledEXT;
9918 glGetVariantBooleanvEXT: TglGetVariantBooleanvEXT;
9919 glGetVariantIntegervEXT: TglGetVariantIntegervEXT;
9920 glGetVariantFloatvEXT: TglGetVariantFloatvEXT;
9921 glGetVariantPointervEXT: TglGetVariantPointervEXT;
9922 glGetInvariantBooleanvEXT: TglGetInvariantBooleanvEXT;
9923 glGetInvariantIntegervEXT: TglGetInvariantIntegervEXT;
9924 glGetInvariantFloatvEXT: TglGetInvariantFloatvEXT;
9925 glGetLocalConstantBooleanvEXT: TglGetLocalConstantBooleanvEXT;
9926 glGetLocalConstantIntegervEXT: TglGetLocalConstantIntegervEXT;
9927 glGetLocalConstantFloatvEXT: TglGetLocalConstantFloatvEXT;
9928
9929 // GL_EXT_vertex_weighting
9930 glVertexWeightfEXT: TglVertexWeightfEXT;
9931 glVertexWeightfvEXT: TglVertexWeightfvEXT;
9932 glVertexWeightPointerEXT: TglVertexWeightPointerEXT;
9933
9934 // GL_EXT_stencil_clear_tag
9935 glStencilClearTagEXT: TglStencilClearTagEXT;
9936
9937 // GL_EXT_framebuffer_blit
9938 glBlitFramebufferEXT: TglBlitFramebufferEXT;
9939
9940 // GL_EXT_framebuffer_multisample
9941 glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT;
9942
9943 // GL_EXT_timer_query
9944 glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT;
9945 glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT;
9946
9947 // GL_EXT_gpu_program_parameters
9948 glProgramEnvParameters4fvEXT: TglProgramEnvParameters4fvEXT;
9949 glProgramLocalParameters4fvEXT: TglProgramLocalParameters4fvEXT;
9950
9951 // GL_EXT_bindable_uniform
9952 glUniformBufferEXT: TglUniformBufferEXT;
9953 glGetUniformBufferSizeEXT: TglGetUniformBufferSizeEXT;
9954 glGetUniformOffsetEXT: TglGetUniformOffsetEXT;
9955
9956 // GL_EXT_draw_buffers2
9957 glColorMaskIndexedEXT: TglColorMaskIndexedEXT;
9958 glGetBooleanIndexedvEXT: TglGetBooleanIndexedvEXT;
9959 glGetIntegerIndexedvEXT: TglGetIntegerIndexedvEXT;
9960 glEnableIndexedEXT: TglEnableIndexedEXT;
9961 glDisableIndexedEXT: TglDisableIndexedEXT;
9962 glIsEnabledIndexedEXT: TglIsEnabledIndexedEXT;
9963
9964 // GL_EXT_draw_instanced
9965 glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT;
9966 glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT;
9967
9968 // GL_EXT_geometry_shader4
9969 glProgramParameteriEXT: TglProgramParameteriEXT;
9970 glFramebufferTextureEXT: TglFramebufferTextureEXT;
9971 // glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
9972 glFramebufferTextureFaceEXT: TglFramebufferTextureFaceEXT;
9973
9974 // GL_EXT_gpu_shader4
9975 glVertexAttribI1iEXT: TglVertexAttribI1iEXT;
9976 glVertexAttribI2iEXT: TglVertexAttribI2iEXT;
9977 glVertexAttribI3iEXT: TglVertexAttribI3iEXT;
9978 glVertexAttribI4iEXT: TglVertexAttribI4iEXT;
9979 glVertexAttribI1uiEXT: TglVertexAttribI1uiEXT;
9980 glVertexAttribI2uiEXT: TglVertexAttribI2uiEXT;
9981 glVertexAttribI3uiEXT: TglVertexAttribI3uiEXT;
9982 glVertexAttribI4uiEXT: TglVertexAttribI4uiEXT;
9983 glVertexAttribI1ivEXT: TglVertexAttribI1ivEXT;
9984 glVertexAttribI2ivEXT: TglVertexAttribI2ivEXT;
9985 glVertexAttribI3ivEXT: TglVertexAttribI3ivEXT;
9986 glVertexAttribI4ivEXT: TglVertexAttribI4ivEXT;
9987 glVertexAttribI1uivEXT: TglVertexAttribI1uivEXT;
9988 glVertexAttribI2uivEXT: TglVertexAttribI2uivEXT;
9989 glVertexAttribI3uivEXT: TglVertexAttribI3uivEXT;
9990 glVertexAttribI4uivEXT: TglVertexAttribI4uivEXT;
9991 glVertexAttribI4bvEXT:TglVertexAttribI4bvEXT ;
9992 glVertexAttribI4svEXT: TglVertexAttribI4svEXT;
9993 glVertexAttribI4ubvEXT: TglVertexAttribI4ubvEXT;
9994 glVertexAttribI4usvEXT: TglVertexAttribI4usvEXT;
9995 glVertexAttribIPointerEXT: TglVertexAttribIPointerEXT;
9996 glGetVertexAttribIivEXT: TglGetVertexAttribIivEXT;
9997 glGetVertexAttribIuivEXT: TglGetVertexAttribIuivEXT;
9998 glUniform1uiEXT: TglUniform1uiEXT;
9999 glUniform2uiEXT: TglUniform2uiEXT;
10000 glUniform3uiEXT: TglUniform3uiEXT;
10001 glUniform4uiEXT: TglUniform4uiEXT;
10002 glUniform1uivEXT: TglUniform1uivEXT;
10003 glUniform2uivEXT: TglUniform2uivEXT;
10004 glUniform3uivEXT: TglUniform3uivEXT;
10005 glUniform4uivEXT: TglUniform4uivEXT;
10006 glGetUniformuivEXT: TglGetUniformuivEXT;
10007 glBindFragDataLocationEXT: TglBindFragDataLocationEXT;
10008 glGetFragDataLocationEXT: TglGetFragDataLocationEXT;
10009
10010 // GL_EXT_texture_array
10011 glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
10012
10013 // GL_EXT_texture_buffer_object
10014 glTexBufferEXT: TglTexBufferEXT;
10015
10016 // GL_EXT_texture_integer
10017 glClearColorIiEXT: TglClearColorIiEXT;
10018 glClearColorIuiEXT: TglClearColorIuiEXT;
10019 glTexParameterIivEXT: TglTexParameterIivEXT;
10020 glTexParameterIuivEXT: TglTexParameterIuivEXT;
10021 glGetTexParameterIivEXT: TglGetTexParameterIivEXT;
10022 glGetTexParameterIiuvEXT: TglGetTexParameterIiuvEXT;
10023
10024 // GL_EXT_transform_feedback
10025 glBeginTransformFeedbackEXT: TglBeginTransformFeedbackEXT;
10026 glEndTransformFeedbackEXT: TglEndTransformFeedbackEXT;
10027 glBindBufferRangeEXT: TglBindBufferRangeEXT;
10028 glBindBufferOffsetEXT: TglBindBufferOffsetEXT;
10029 glBindBufferBaseEXT: TglBindBufferBaseEXT;
10030 glTransformFeedbackVaryingsEXT: TglTransformFeedbackVaryingsEXT;
10031 glGetTransformFeedbackVaryingEXT: TglGetTransformFeedbackVaryingEXT;
10032
10033 // GL_EXT_direct_state_access
10034 glClientAttribDefaultEXT: TglClientAttribDefaultEXT;
10035 glPushClientAttribDefaultEXT: TglPushClientAttribDefaultEXT;
10036 glMatrixLoadfEXT: TglMatrixLoadfEXT;
10037 glMatrixLoaddEXT: TglMatrixLoaddEXT;
10038 glMatrixMultfEXT: TglMatrixMultfEXT;
10039 glMatrixMultdEXT: TglMatrixMultdEXT;
10040 glMatrixLoadIdentityEXT: TglMatrixLoadIdentityEXT;
10041 glMatrixRotatefEXT: TglMatrixRotatefEXT;
10042 glMatrixRotatedEXT: TglMatrixRotatedEXT;
10043 glMatrixScalefEXT: TglMatrixScalefEXT;
10044 glMatrixScaledEXT: TglMatrixScaledEXT;
10045 glMatrixTranslatefEXT: TglMatrixTranslatefEXT;
10046 glMatrixTranslatedEXT: TglMatrixTranslatedEXT;
10047 glMatrixFrustumEXT: TglMatrixFrustumEXT;
10048 glMatrixOrthoEXT: TglMatrixOrthoEXT;
10049 glMatrixPopEXT: TglMatrixPopEXT;
10050 glMatrixPushEXT: TglMatrixPushEXT;
10051 glMatrixLoadTransposefEXT: TglMatrixLoadTransposefEXT;
10052 glMatrixLoadTransposedEXT: TglMatrixLoadTransposedEXT;
10053 glMatrixMultTransposefEXT: TglMatrixMultTransposefEXT;
10054 glMatrixMultTransposedEXT: TglMatrixMultTransposedEXT;
10055 glTextureParameterfEXT: TglTextureParameterfEXT;
10056 glTextureParameterfvEXT: TglTextureParameterfvEXT;
10057 glTextureParameteriEXT: TglTextureParameteriEXT;
10058 glTextureParameterivEXT: TglTextureParameterivEXT;
10059 glTextureImage1DEXT: TglTextureImage1DEXT;
10060 glTextureImage2DEXT: TglTextureImage2DEXT;
10061 glTextureSubImage1DEXT: TglTextureSubImage1DEXT;
10062 glTextureSubImage2DEXT: TglTextureSubImage2DEXT;
10063 glCopyTextureImage1DEXT: TglCopyTextureImage1DEXT;
10064 glCopyTextureImage2DEXT: TglCopyTextureImage2DEXT;
10065 glCopyTextureSubImage1DEXT: TglCopyTextureSubImage1DEXT;
10066 glCopyTextureSubImage2DEXT: TglCopyTextureSubImage2DEXT;
10067 glGetTextureImageEXT: TglGetTextureImageEXT;
10068 glGetTextureParameterfvEXT: TglGetTextureParameterfvEXT;
10069 glGetTextureParameterivEXT: TglGetTextureParameterivEXT;
10070 glGetTextureLevelParameterfvEXT: TglGetTextureLevelParameterfvEXT;
10071 glGetTextureLevelParameterivEXT: TglGetTextureLevelParameterivEXT;
10072 glTextureImage3DEXT: TglTextureImage3DEXT;
10073 glTextureSubImage3DEXT: TglTextureSubImage3DEXT;
10074 glCopyTextureSubImage3DEXT: TglCopyTextureSubImage3DEXT;
10075 glMultiTexParameterfEXT: TglMultiTexParameterfEXT;
10076 glMultiTexParameterfvEXT: TglMultiTexParameterfvEXT;
10077 glMultiTexParameteriEXT: TglMultiTexParameteriEXT;
10078 glMultiTexParameterivEXT: TglMultiTexParameterivEXT;
10079 glMultiTexImage1DEXT: TglMultiTexImage1DEXT;
10080 glMultiTexImage2DEXT: TglMultiTexImage2DEXT;
10081 glMultiTexSubImage1DEXT: TglMultiTexSubImage1DEXT;
10082 glMultiTexSubImage2DEXT: TglMultiTexSubImage2DEXT;
10083 glCopyMultiTexImage1DEXT: TglCopyMultiTexImage1DEXT;
10084 glCopyMultiTexImage2DEXT: TglCopyMultiTexImage2DEXT;
10085 glCopyMultiTexSubImage1DEXT: TglCopyMultiTexSubImage1DEXT;
10086 glCopyMultiTexSubImage2DEXT: TglCopyMultiTexSubImage2DEXT;
10087 glGetMultiTexImageEXT: TglGetMultiTexImageEXT;
10088 glGetMultiTexParameterfvEXT: TglGetMultiTexParameterfvEXT;
10089 glGetMultiTexParameterivEXT: TglGetMultiTexParameterivEXT;
10090 glGetMultiTexLevelParameterfvEXT: TglGetMultiTexLevelParameterfvEXT;
10091 glGetMultiTexLevelParameterivEXT: TglGetMultiTexLevelParameterivEXT;
10092 glMultiTexImage3DEXT: TglMultiTexImage3DEXT;
10093 glMultiTexSubImage3DEXT: TglMultiTexSubImage3DEXT;
10094 glCopyMultiTexSubImage3DEXT: TglCopyMultiTexSubImage3DEXT;
10095 glBindMultiTextureEXT: TglBindMultiTextureEXT;
10096 glEnableClientStateIndexedEXT: TglEnableClientStateIndexedEXT;
10097 glDisableClientStateIndexedEXT: TglDisableClientStateIndexedEXT;
10098 glMultiTexCoordPointerEXT: TglMultiTexCoordPointerEXT;
10099 glMultiTexEnvfEXT: TglMultiTexEnvfEXT;
10100 glMultiTexEnvfvEXT: TglMultiTexEnvfvEXT;
10101 glMultiTexEnviEXT: TglMultiTexEnviEXT;
10102 glMultiTexEnvivEXT: TglMultiTexEnvivEXT;
10103 glMultiTexGendEXT: TglMultiTexGendEXT;
10104 glMultiTexGendvEXT: TglMultiTexGendvEXT;
10105 glMultiTexGenfEXT: TglMultiTexGenfEXT;
10106 glMultiTexGenfvEXT: TglMultiTexGenfvEXT;
10107 glMultiTexGeniEXT: TglMultiTexGeniEXT;
10108 glMultiTexGenivEXT: TglMultiTexGenivEXT;
10109 glGetMultiTexEnvfvEXT: TglGetMultiTexEnvfvEXT;
10110 glGetMultiTexEnvivEXT: TglGetMultiTexEnvivEXT;
10111 glGetMultiTexGendvEXT: TglGetMultiTexGendvEXT;
10112 glGetMultiTexGenfvEXT: TglGetMultiTexGenfvEXT;
10113 glGetMultiTexGenivEXT: TglGetMultiTexGenivEXT;
10114 glGetFloatIndexedvEXT: TglGetFloatIndexedvEXT;
10115 glGetDoubleIndexedvEXT: TglGetDoubleIndexedvEXT;
10116 glGetPointerIndexedvEXT: TglGetPointerIndexedvEXT;
10117 glCompressedTextureImage3DEXT: TglCompressedTextureImage3DEXT;
10118 glCompressedTextureImage2DEXT: TglCompressedTextureImage2DEXT;
10119 glCompressedTextureImage1DEXT: TglCompressedTextureImage1DEXT;
10120 glCompressedTextureSubImage3DEXT: TglCompressedTextureSubImage3DEXT;
10121 glCompressedTextureSubImage2DEXT: TglCompressedTextureSubImage2DEXT;
10122 glCompressedTextureSubImage1DEXT: TglCompressedTextureSubImage1DEXT;
10123 glGetCompressedTextureImageEXT: TglGetCompressedTextureImageEXT;
10124 glCompressedMultiTexImage3DEXT: TglCompressedMultiTexImage3DEXT;
10125 glCompressedMultiTexImage2DEXT: TglCompressedMultiTexImage2DEXT;
10126 glCompressedMultiTexImage1DEXT: TglCompressedMultiTexImage1DEXT;
10127 glCompressedMultiTexSubImage3DEXT: TglCompressedMultiTexSubImage3DEXT;
10128 glCompressedMultiTexSubImage2DEXT: TglCompressedMultiTexSubImage2DEXT;
10129 glCompressedMultiTexSubImage1DEXT: TglCompressedMultiTexSubImage1DEXT;
10130 glGetCompressedMultiTexImageEXT: TglGetCompressedMultiTexImageEXT;
10131 glNamedProgramStringEXT: TglNamedProgramStringEXT;
10132 glNamedProgramLocalParameter4dEXT: TglNamedProgramLocalParameter4dEXT;
10133 glNamedProgramLocalParameter4dvEXT: TglNamedProgramLocalParameter4dvEXT;
10134 glNamedProgramLocalParameter4fEXT: TglNamedProgramLocalParameter4fEXT;
10135 glNamedProgramLocalParameter4fvEXT: TglNamedProgramLocalParameter4fvEXT;
10136 glGetNamedProgramLocalParameterdvEXT: TglGetNamedProgramLocalParameterdvEXT;
10137 glGetNamedProgramLocalParameterfvEXT: TglGetNamedProgramLocalParameterfvEXT;
10138 glGetNamedProgramivEXT: TglGetNamedProgramivEXT;
10139 glGetNamedProgramStringEXT: TglGetNamedProgramStringEXT;
10140 glNamedProgramLocalParameters4fvEXT: TglNamedProgramLocalParameters4fvEXT;
10141 glNamedProgramLocalParameterI4iEXT: TglNamedProgramLocalParameterI4iEXT;
10142 glNamedProgramLocalParameterI4ivEXT: TglNamedProgramLocalParameterI4ivEXT;
10143 glNamedProgramLocalParametersI4ivEXT: TglNamedProgramLocalParametersI4ivEXT;
10144 glNamedProgramLocalParameterI4uiEXT: TglNamedProgramLocalParameterI4uiEXT;
10145 glNamedProgramLocalParameterI4uivEXT: TglNamedProgramLocalParameterI4uivEXT;
10146 glNamedProgramLocalParametersI4uivEXT: TglNamedProgramLocalParametersI4uivEXT;
10147 glGetNamedProgramLocalParameterIivEXT: TglGetNamedProgramLocalParameterIivEXT;
10148 glGetNamedProgramLocalParameterIuivEXT: TglGetNamedProgramLocalParameterIuivEXT;
10149 glTextureParameterIivEXT: TglTextureParameterIivEXT;
10150 glTextureParameterIuivEXT: TglTextureParameterIuivEXT;
10151 glGetTextureParameterIivEXT: TglGetTextureParameterIivEXT;
10152 glGetTextureParameterIuivEXT: TglGetTextureParameterIuivEXT;
10153 glMultiTexParameterIivEXT: TglMultiTexParameterIivEXT;
10154 glMultiTexParameterIuivEXT: TglMultiTexParameterIuivEXT;
10155 glGetMultiTexParameterIivEXT: TglGetMultiTexParameterIivEXT;
10156 glGetMultiTexParameterIuivEXT: TglGetMultiTexParameterIuivEXT;
10157 glProgramUniform1fEXT: TglProgramUniform1fEXT;
10158 glProgramUniform2fEXT: TglProgramUniform2fEXT;
10159 glProgramUniform3fEXT: TglProgramUniform3fEXT;
10160 glProgramUniform4fEXT: TglProgramUniform4fEXT;
10161 glProgramUniform1iEXT: TglProgramUniform1iEXT;
10162 glProgramUniform2iEXT: TglProgramUniform2iEXT;
10163 glProgramUniform3iEXT: TglProgramUniform3iEXT;
10164 glProgramUniform4iEXT: TglProgramUniform4iEXT;
10165 glProgramUniform1fvEXT: TglProgramUniform1fvEXT;
10166 glProgramUniform2fvEXT: TglProgramUniform2fvEXT;
10167 glProgramUniform3fvEXT: TglProgramUniform3fvEXT;
10168 glProgramUniform4fvEXT: TglProgramUniform4fvEXT;
10169 glProgramUniform1ivEXT: TglProgramUniform1ivEXT;
10170 glProgramUniform2ivEXT: TglProgramUniform2ivEXT;
10171 glProgramUniform3ivEXT: TglProgramUniform3ivEXT;
10172 glProgramUniform4ivEXT: TglProgramUniform4ivEXT;
10173 glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT;
10174 glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT;
10175 glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT;
10176 glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT;
10177 glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT;
10178 glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT;
10179 glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT;
10180 glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT;
10181 glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT;
10182 glProgramUniform1uiEXT: TglProgramUniform1uiEXT;
10183 glProgramUniform2uiEXT: TglProgramUniform2uiEXT;
10184 glProgramUniform3uiEXT: TglProgramUniform3uiEXT;
10185 glProgramUniform4uiEXT: TglProgramUniform4uiEXT;
10186 glProgramUniform1uivEXT: TglProgramUniform1uivEXT;
10187 glProgramUniform2uivEXT: TglProgramUniform2uivEXT;
10188 glProgramUniform3uivEXT: TglProgramUniform3uivEXT;
10189 glProgramUniform4uivEXT: TglProgramUniform4uivEXT;
10190 glNamedBufferDataEXT: TglNamedBufferDataEXT;
10191 glNamedBufferSubDataEXT: TglNamedBufferSubDataEXT;
10192 glMapNamedBufferEXT: TglMapNamedBufferEXT;
10193 glUnmapNamedBufferEXT: TglUnmapNamedBufferEXT;
10194 glGetNamedBufferParameterivEXT: TglGetNamedBufferParameterivEXT;
10195 glGetNamedBufferPointervEXT: TglGetNamedBufferPointervEXT;
10196 glGetNamedBufferSubDataEXT: TglGetNamedBufferSubDataEXT;
10197 glTextureBufferEXT: TglTextureBufferEXT;
10198 glMultiTexBufferEXT: TglMultiTexBufferEXT;
10199 glNamedRenderbufferStorageEXT: TglNamedRenderbufferStorageEXT;
10200 glGetNamedRenderbufferParameterivEXT: TglGetNamedRenderbufferParameterivEXT;
10201 glCheckNamedFramebufferStatusEXT: TglCheckNamedFramebufferStatusEXT;
10202 glNamedFramebufferTexture1DEXT: TglNamedFramebufferTexture1DEXT;
10203 glNamedFramebufferTexture2DEXT: TglNamedFramebufferTexture2DEXT;
10204 glNamedFramebufferTexture3DEXT: TglNamedFramebufferTexture3DEXT;
10205 glNamedFramebufferRenderbufferEXT: TglNamedFramebufferRenderbufferEXT;
10206 glGetNamedFramebufferAttachmentParameterivEXT: TglGetNamedFramebufferAttachmentParameterivEXT;
10207 glGenerateTextureMipmapEXT: TglGenerateTextureMipmapEXT;
10208 glGenerateMultiTexMipmapEXT: TglGenerateMultiTexMipmapEXT;
10209 glFramebufferDrawBufferEXT: TglFramebufferDrawBufferEXT;
10210 glFramebufferDrawBuffersEXT: TglFramebufferDrawBuffersEXT;
10211 glFramebufferReadBufferEXT: TglFramebufferReadBufferEXT;
10212 glGetFramebufferParameterivEXT: TglGetFramebufferParameterivEXT;
10213 glNamedRenderbufferStorageMultisampleEXT: TglNamedRenderbufferStorageMultisampleEXT;
10214 glNamedRenderbufferStorageMultisampleCoverageEXT: TglNamedRenderbufferStorageMultisampleCoverageEXT;
10215 glNamedFramebufferTextureEXT: TglNamedFramebufferTextureEXT;
10216 glNamedFramebufferTextureLayerEXT: TglNamedFramebufferTextureLayerEXT;
10217 glNamedFramebufferTextureFaceEXT: TglNamedFramebufferTextureFaceEXT;
10218 glTextureRenderbufferEXT: TglTextureRenderbufferEXT;
10219 glMultiTexRenderbufferEXT: TglMultiTexRenderbufferEXT;
10220
10221 // GL_HP_image_transform
10222 glImageTransformParameteriHP: TglImageTransformParameteriHP;
10223 glImageTransformParameterfHP: TglImageTransformParameterfHP;
10224 glImageTransformParameterivHP: TglImageTransformParameterivHP;
10225 glImageTransformParameterfvHP: TglImageTransformParameterfvHP;
10226 glGetImageTransformParameterivHP: TglGetImageTransformParameterivHP;
10227 glGetImageTransformParameterfvHP: TglGetImageTransformParameterfvHP;
10228
10229 // GL_EXT_depth_bounds_test
10230 glDepthBoundsEXT: TglDepthBoundsEXT;
10231
10232 // GL_EXT_blend_equation_separate
10233 glBlendEquationSeparateEXT: TglBlendEquationSeparateEXT;
10234
10235 // GL_IBM_multimode_draw_arrays
10236 glMultiModeDrawArraysIBM: TglMultiModeDrawArraysIBM;
10237 glMultiModeDrawElementsIBM: TglMultiModeDrawElementsIBM;
10238
10239 // GL_IBM_vertex_array_lists
10240 glColorPointerListIBM: TglColorPointerListIBM;
10241 glSecondaryColorPointerListIBM: TglSecondaryColorPointerListIBM;
10242 glEdgeFlagPointerListIBM: TglEdgeFlagPointerListIBM;
10243 glFogCoordPointerListIBM: TglFogCoordPointerListIBM;
10244 glIndexPointerListIBM: TglIndexPointerListIBM;
10245 glNormalPointerListIBM: TglNormalPointerListIBM;
10246 glTexCoordPointerListIBM: TglTexCoordPointerListIBM;
10247 glVertexPointerListIBM: TglVertexPointerListIBM;
10248
10249 // GL_INGR_blend_func_separate
10250 glBlendFuncSeparateINGR: TglBlendFuncSeparateINGR;
10251
10252 // GL_INTEL_parallel_arrays
10253 glVertexPointervINTEL: TglVertexPointervINTEL;
10254 glNormalPointervINTEL: TglNormalPointervINTEL;
10255 glColorPointervINTEL: TglColorPointervINTEL;
10256 glTexCoordPointervINTEL: TglTexCoordPointervINTEL;
10257
10258 // GL_MESA_resize_buffers
10259 glResizeBuffersMESA: TglResizeBuffersMESA;
10260
10261 // GL_MESA_window_pos
10262 glWindowPos2dMESA: TglWindowPos2dMESA;
10263 glWindowPos2dvMESA: TglWindowPos2dvMESA;
10264 glWindowPos2fMESA: TglWindowPos2fMESA;
10265 glWindowPos2fvMESA: TglWindowPos2fvMESA;
10266 glWindowPos2iMESA: TglWindowPos2iMESA;
10267 glWindowPos2ivMESA: TglWindowPos2ivMESA;
10268 glWindowPos2sMESA: TglWindowPos2sMESA;
10269 glWindowPos2svMESA: TglWindowPos2svMESA;
10270 glWindowPos3dMESA: TglWindowPos3dMESA;
10271 glWindowPos3dvMESA: TglWindowPos3dvMESA;
10272 glWindowPos3fMESA: TglWindowPos3fMESA;
10273 glWindowPos3fvMESA: TglWindowPos3fvMESA;
10274 glWindowPos3iMESA: TglWindowPos3iMESA;
10275 glWindowPos3ivMESA: TglWindowPos3ivMESA;
10276 glWindowPos3sMESA: TglWindowPos3sMESA;
10277 glWindowPos3svMESA: TglWindowPos3svMESA;
10278 glWindowPos4dMESA: TglWindowPos4dMESA;
10279 glWindowPos4dvMESA: TglWindowPos4dvMESA;
10280 glWindowPos4fMESA: TglWindowPos4fMESA;
10281 glWindowPos4fvMESA: TglWindowPos4fvMESA;
10282 glWindowPos4iMESA: TglWindowPos4iMESA;
10283 glWindowPos4ivMESA: TglWindowPos4ivMESA;
10284 glWindowPos4sMESA: TglWindowPos4sMESA;
10285 glWindowPos4svMESA: TglWindowPos4svMESA;
10286
10287 // GL_NV_evaluators
10288 glMapControlPointsNV: TglMapControlPointsNV;
10289 glMapParameterivNV: TglMapParameterivNV;
10290 glMapParameterfvNV: TglMapParameterfvNV;
10291 glGetMapControlPointsNV: TglGetMapControlPointsNV;
10292 glGetMapParameterivNV: TglGetMapParameterivNV;
10293 glGetMapParameterfvNV: TglGetMapParameterfvNV;
10294 glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV;
10295 glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV;
10296 glEvalMapsNV: TglEvalMapsNV;
10297
10298 // GL_NV_fence
10299 glDeleteFencesNV: TglDeleteFencesNV;
10300 glGenFencesNV: TglGenFencesNV;
10301 glIsFenceNV: TglIsFenceNV;
10302 glTestFenceNV: TglTestFenceNV;
10303 glGetFenceivNV: TglGetFenceivNV;
10304 glFinishFenceNV: TglFinishFenceNV;
10305 glSetFenceNV: TglSetFenceNV;
10306
10307 // GL_NV_fragment_program
10308 glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV;
10309 glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV;
10310 glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV;
10311 glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV;
10312 glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV;
10313 glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV;
10314
10315 // GL_NV_half_float
10316 glVertex2hNV: TglVertex2hNV;
10317 glVertex2hvNV: TglVertex2hvNV;
10318 glVertex3hNV: TglVertex3hNV;
10319 glVertex3hvNV: TglVertex3hvNV;
10320 glVertex4hNV: TglVertex4hNV;
10321 glVertex4hvNV: TglVertex4hvNV;
10322 glNormal3hNV: TglNormal3hNV;
10323 glNormal3hvNV: TglNormal3hvNV;
10324 glColor3hNV: TglColor3hNV;
10325 glColor3hvNV: TglColor3hvNV;
10326 glColor4hNV: TglColor4hNV;
10327 glColor4hvNV: TglColor4hvNV;
10328 glTexCoord1hNV: TglTexCoord1hNV;
10329 glTexCoord1hvNV: TglTexCoord1hvNV;
10330 glTexCoord2hNV: TglTexCoord2hNV;
10331 glTexCoord2hvNV: TglTexCoord2hvNV;
10332 glTexCoord3hNV: TglTexCoord3hNV;
10333 glTexCoord3hvNV: TglTexCoord3hvNV;
10334 glTexCoord4hNV: TglTexCoord4hNV;
10335 glTexCoord4hvNV: TglTexCoord4hvNV;
10336 glMultiTexCoord1hNV: TglMultiTexCoord1hNV;
10337 glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV;
10338 glMultiTexCoord2hNV: TglMultiTexCoord2hNV;
10339 glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV;
10340 glMultiTexCoord3hNV: TglMultiTexCoord3hNV;
10341 glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV;
10342 glMultiTexCoord4hNV: TglMultiTexCoord4hNV;
10343 glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV;
10344 glFogCoordhNV: TglFogCoordhNV;
10345 glFogCoordhvNV: TglFogCoordhvNV;
10346 glSecondaryColor3hNV: TglSecondaryColor3hNV;
10347 glSecondaryColor3hvNV: TglSecondaryColor3hvNV;
10348 glVertexWeighthNV: TglVertexWeighthNV;
10349 glVertexWeighthvNV: TglVertexWeighthvNV;
10350 glVertexAttrib1hNV: TglVertexAttrib1hNV;
10351 glVertexAttrib1hvNV: TglVertexAttrib1hvNV;
10352 glVertexAttrib2hNV: TglVertexAttrib2hNV;
10353 glVertexAttrib2hvNV: TglVertexAttrib2hvNV;
10354 glVertexAttrib3hNV: TglVertexAttrib3hNV;
10355 glVertexAttrib3hvNV: TglVertexAttrib3hvNV;
10356 glVertexAttrib4hNV: TglVertexAttrib4hNV;
10357 glVertexAttrib4hvNV: TglVertexAttrib4hvNV;
10358 glVertexAttribs1hvNV: TglVertexAttribs1hvNV;
10359 glVertexAttribs2hvNV: TglVertexAttribs2hvNV;
10360 glVertexAttribs3hvNV: TglVertexAttribs3hvNV;
10361 glVertexAttribs4hvNV: TglVertexAttribs4hvNV;
10362
10363 // GL_NV_occlusion_query
10364 glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV;
10365 glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV;
10366 glIsOcclusionQueryNV: TglIsOcclusionQueryNV;
10367 glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV;
10368 glEndOcclusionQueryNV: TglEndOcclusionQueryNV;
10369 glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV;
10370 glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV;
10371
10372 // GL_NV_pixel_data_range
10373 glPixelDataRangeNV: TglPixelDataRangeNV;
10374 glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV;
10375
10376 // GL_NV_point_sprite
10377 glPointParameteriNV: TglPointParameteriNV;
10378 glPointParameterivNV: TglPointParameterivNV;
10379
10380 // GL_NV_primitive_restart
10381 glPrimitiveRestartNV: TglPrimitiveRestartNV;
10382 glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV;
10383
10384 // GL_NV_register_combiners
10385 glCombinerParameterfvNV: TglCombinerParameterfvNV;
10386 glCombinerParameterfNV: TglCombinerParameterfNV;
10387 glCombinerParameterivNV: TglCombinerParameterivNV;
10388 glCombinerParameteriNV: TglCombinerParameteriNV;
10389 glCombinerInputNV: TglCombinerInputNV;
10390 glCombinerOutputNV: TglCombinerOutputNV;
10391 glFinalCombinerInputNV: TglFinalCombinerInputNV;
10392 glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV;
10393 glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV;
10394 glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV;
10395 glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV;
10396 glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV;
10397 glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV;
10398
10399 // GL_NV_register_combiners2
10400 glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV;
10401 glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV;
10402
10403 // GL_NV_vertex_array_range
10404 glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV;
10405 glVertexArrayRangeNV: TglVertexArrayRangeNV;
10406
10407 // GL_NV_vertex_program
10408 glAreProgramsResidentNV: TglAreProgramsResidentNV;
10409 glBindProgramNV: TglBindProgramNV;
10410 glDeleteProgramsNV: TglDeleteProgramsNV;
10411 glExecuteProgramNV: TglExecuteProgramNV;
10412 glGenProgramsNV: TglGenProgramsNV;
10413 glGetProgramParameterdvNV: TglGetProgramParameterdvNV;
10414 glGetProgramParameterfvNV: TglGetProgramParameterfvNV;
10415 glGetProgramivNV: TglGetProgramivNV;
10416 glGetProgramStringNV: TglGetProgramStringNV;
10417 glGetTrackMatrixivNV: TglGetTrackMatrixivNV;
10418 glGetVertexAttribdvNV: TglGetVertexAttribdvNV;
10419 glGetVertexAttribfvNV: TglGetVertexAttribfvNV;
10420 glGetVertexAttribivNV: TglGetVertexAttribivNV;
10421 glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV;
10422 glIsProgramNV: TglIsProgramNV;
10423 glLoadProgramNV: TglLoadProgramNV;
10424 glProgramParameter4dNV: TglProgramParameter4dNV;
10425 glProgramParameter4dvNV: TglProgramParameter4dvNV;
10426 glProgramParameter4fNV: TglProgramParameter4fNV;
10427 glProgramParameter4fvNV: TglProgramParameter4fvNV;
10428 glProgramParameters4dvNV: TglProgramParameters4dvNV;
10429 glProgramParameters4fvNV: TglProgramParameters4fvNV;
10430 glRequestResidentProgramsNV: TglRequestResidentProgramsNV;
10431 glTrackMatrixNV: TglTrackMatrixNV;
10432 glVertexAttribPointerNV: TglVertexAttribPointerNV;
10433 glVertexAttrib1dNV: TglVertexAttrib1dNV;
10434 glVertexAttrib1dvNV: TglVertexAttrib1dvNV;
10435 glVertexAttrib1fNV: TglVertexAttrib1fNV;
10436 glVertexAttrib1fvNV: TglVertexAttrib1fvNV;
10437 glVertexAttrib1sNV: TglVertexAttrib1sNV;
10438 glVertexAttrib1svNV: TglVertexAttrib1svNV;
10439 glVertexAttrib2dNV: TglVertexAttrib2dNV;
10440 glVertexAttrib2dvNV: TglVertexAttrib2dvNV;
10441 glVertexAttrib2fNV: TglVertexAttrib2fNV;
10442 glVertexAttrib2fvNV: TglVertexAttrib2fvNV;
10443 glVertexAttrib2sNV: TglVertexAttrib2sNV;
10444 glVertexAttrib2svNV: TglVertexAttrib2svNV;
10445 glVertexAttrib3dNV: TglVertexAttrib3dNV;
10446 glVertexAttrib3dvNV: TglVertexAttrib3dvNV;
10447 glVertexAttrib3fNV: TglVertexAttrib3fNV;
10448 glVertexAttrib3fvNV: TglVertexAttrib3fvNV;
10449 glVertexAttrib3sNV: TglVertexAttrib3sNV;
10450 glVertexAttrib3svNV: TglVertexAttrib3svNV;
10451 glVertexAttrib4dNV: TglVertexAttrib4dNV;
10452 glVertexAttrib4dvNV: TglVertexAttrib4dvNV;
10453 glVertexAttrib4fNV: TglVertexAttrib4fNV;
10454 glVertexAttrib4fvNV: TglVertexAttrib4fvNV;
10455 glVertexAttrib4sNV: TglVertexAttrib4sNV;
10456 glVertexAttrib4svNV: TglVertexAttrib4svNV;
10457 glVertexAttrib4ubNV: TglVertexAttrib4ubNV;
10458 glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV;
10459 glVertexAttribs1dvNV: TglVertexAttribs1dvNV;
10460 glVertexAttribs1fvNV: TglVertexAttribs1fvNV;
10461 glVertexAttribs1svNV: TglVertexAttribs1svNV;
10462 glVertexAttribs2dvNV: TglVertexAttribs2dvNV;
10463 glVertexAttribs2fvNV: TglVertexAttribs2fvNV;
10464 glVertexAttribs2svNV: TglVertexAttribs2svNV;
10465 glVertexAttribs3dvNV: TglVertexAttribs3dvNV;
10466 glVertexAttribs3fvNV: TglVertexAttribs3fvNV;
10467 glVertexAttribs3svNV: TglVertexAttribs3svNV;
10468 glVertexAttribs4dvNV: TglVertexAttribs4dvNV;
10469 glVertexAttribs4fvNV: TglVertexAttribs4fvNV;
10470 glVertexAttribs4svNV: TglVertexAttribs4svNV;
10471 glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV;
10472
10473 // GL_NV_depth_buffer_float
10474 glDepthRangedNV: TglDepthRangedNV;
10475 glClearDepthdNV: TglClearDepthdNV;
10476 glDepthBoundsdNV: TglDepthBoundsdNV;
10477
10478 // GL_NV_framebuffer_multisample_coverage
10479 glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV;
10480
10481 // GL_NV_geometry_program4
10482 glProgramVertexLimitNV: TglProgramVertexLimitNV;
10483
10484 // GL_NV_gpu_program4
10485 glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV;
10486 glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV;
10487 glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV;
10488 glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV;
10489 glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV;
10490 glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV;
10491 glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV;
10492 glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV;
10493 glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV;
10494 glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV;
10495 glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV;
10496 glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV;
10497 glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV;
10498 glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV;
10499 glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV;
10500 glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV;
10501
10502 // GL_NV_parameter_buffer_object
10503 glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV;
10504 glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV;
10505 glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV;
10506
10507 // GL_NV_transform_feedback
10508 glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV;
10509 glEndTransformFeedbackNV: TglEndTransformFeedbackNV;
10510 glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV;
10511 glBindBufferRangeNV: TglBindBufferRangeNV;
10512 glBindBufferOffsetNV: TglBindBufferOffsetNV;
10513 glBindBufferBaseNV: TglBindBufferBaseNV;
10514 glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV;
10515 glActiveVaryingNV: TglActiveVaryingNV;
10516 glGetVaryingLocationNV: TglGetVaryingLocationNV;
10517 glGetActiveVaryingNV: TglGetActiveVaryingNV;
10518 glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV;
10519
10520 // GL_NV_conditional_render
10521 glBeginConditionalRenderNV: TglBeginConditionalRenderNV;
10522 glEndConditionalRenderNV: TglEndConditionalRenderNV;
10523
10524 // GL_NV_present_video
10525 glPresentFrameKeyedNV: TglPresentFrameKeyedNV;
10526 glPresentFrameDualFillNV: TglPresentFrameDualFillNV;
10527 glGetVideoivNV: TglGetVideoivNV;
10528 glGetVideouivNV: TglGetVideouivNV;
10529 glGetVideoi64vNV: TglGetVideoi64vNV;
10530 glGetVideoui64vNV: TglGetVideoui64vNV;
10531 // glVideoParameterivNV: TglVideoParameterivNV;
10532
10533 // GL_NV_explicit_multisample
10534 glGetMultisamplefvNV: TglGetMultisamplefvNV;
10535 glSampleMaskIndexedNV: TglSampleMaskIndexedNV;
10536 glTexRenderbufferNV: TglTexRenderbufferNV;
10537
10538 // GL_NV_transform_feedback2
10539 glBindTransformFeedbackNV: TglBindTransformFeedbackNV;
10540 glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV;
10541 glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV;
10542 glIsTransformFeedbackNV: TglIsTransformFeedbackNV;
10543 glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV;
10544 glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV;
10545 glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV;
10546
10547 // GL_PGI_misc_hints
10548 glHintPGI: TglHintPGI;
10549
10550 // GL_SGIS_detail_texture
10551 glDetailTexFuncSGIS: TglDetailTexFuncSGIS;
10552 glGetDetailTexFuncSGIS: TglGetDetailTexFuncSGIS;
10553
10554 // GL_SGIS_fog_function
10555 glFogFuncSGIS: TglFogFuncSGIS;
10556 glGetFogFuncSGIS: TglGetFogFuncSGIS;
10557
10558 // GL_SGIS_multisample
10559 glSampleMaskSGIS: TglSampleMaskSGIS;
10560 glSamplePatternSGIS: TglSamplePatternSGIS;
10561
10562 // GL_SGIS_pixel_texture
10563 glPixelTexGenParameteriSGIS: TglPixelTexGenParameteriSGIS;
10564 glPixelTexGenParameterivSGIS: TglPixelTexGenParameterivSGIS;
10565 glPixelTexGenParameterfSGIS: TglPixelTexGenParameterfSGIS;
10566 glPixelTexGenParameterfvSGIS: TglPixelTexGenParameterfvSGIS;
10567 glGetPixelTexGenParameterivSGIS: TglGetPixelTexGenParameterivSGIS;
10568 glGetPixelTexGenParameterfvSGIS: TglGetPixelTexGenParameterfvSGIS;
10569
10570 // GL_SGIS_point_parameters
10571 glPointParameterfSGIS: TglPointParameterfSGIS;
10572 glPointParameterfvSGIS: TglPointParameterfvSGIS;
10573
10574 // GL_SGIS_sharpen_texture
10575 glSharpenTexFuncSGIS: TglSharpenTexFuncSGIS;
10576 glGetSharpenTexFuncSGIS: TglGetSharpenTexFuncSGIS;
10577
10578 // GL_SGIS_texture4D
10579 glTexImage4DSGIS: TglTexImage4DSGIS;
10580 glTexSubImage4DSGIS: TglTexSubImage4DSGIS;
10581
10582 // GL_SGIS_texture_color_mask
10583 glTextureColorMaskSGIS: TglTextureColorMaskSGIS;
10584
10585 // GL_SGIS_texture_filter4
10586 glGetTexFilterFuncSGIS: TglGetTexFilterFuncSGIS;
10587 glTexFilterFuncSGIS: TglTexFilterFuncSGIS;
10588
10589 // GL_SGIX_async
10590 glAsyncMarkerSGIX: TglAsyncMarkerSGIX;
10591 glFinishAsyncSGIX: TglFinishAsyncSGIX;
10592 glPollAsyncSGIX: TglPollAsyncSGIX;
10593 glGenAsyncMarkersSGIX: TglGenAsyncMarkersSGIX;
10594 glDeleteAsyncMarkersSGIX: TglDeleteAsyncMarkersSGIX;
10595 glIsAsyncMarkerSGIX: TglIsAsyncMarkerSGIX;
10596
10597 // GL_SGIX_flush_raster
10598 glFlushRasterSGIX: TglFlushRasterSGIX;
10599
10600 // GL_SGIX_fragment_lighting
10601 glFragmentColorMaterialSGIX: TglFragmentColorMaterialSGIX;
10602 glFragmentLightfSGIX: TglFragmentLightfSGIX;
10603 glFragmentLightfvSGIX: TglFragmentLightfvSGIX;
10604 glFragmentLightiSGIX: TglFragmentLightiSGIX;
10605 glFragmentLightivSGIX: TglFragmentLightivSGIX;
10606 glFragmentLightModelfSGIX: TglFragmentLightModelfSGIX;
10607 glFragmentLightModelfvSGIX: TglFragmentLightModelfvSGIX;
10608 glFragmentLightModeliSGIX: TglFragmentLightModeliSGIX;
10609 glFragmentLightModelivSGIX: TglFragmentLightModelivSGIX;
10610 glFragmentMaterialfSGIX: TglFragmentMaterialfSGIX;
10611 glFragmentMaterialfvSGIX: TglFragmentMaterialfvSGIX;
10612 glFragmentMaterialiSGIX: TglFragmentMaterialiSGIX;
10613 glFragmentMaterialivSGIX: TglFragmentMaterialivSGIX;
10614 glGetFragmentLightfvSGIX: TglGetFragmentLightfvSGIX;
10615 glGetFragmentLightivSGIX: TglGetFragmentLightivSGIX;
10616 glGetFragmentMaterialfvSGIX: TglGetFragmentMaterialfvSGIX;
10617 glGetFragmentMaterialivSGIX: TglGetFragmentMaterialivSGIX;
10618 glLightEnviSGIX: TglLightEnviSGIX;
10619
10620 // GL_SGIX_framezoom
10621 glFrameZoomSGIX: TglFrameZoomSGIX;
10622
10623 // GL_SGIX_igloo_interface
10624 glIglooInterfaceSGIX: TglIglooInterfaceSGIX;
10625
10626 // GL_SGIX_instruments
10627 glGetInstrumentsSGIX: TglGetInstrumentsSGIX;
10628 glInstrumentsBufferSGIX: TglInstrumentsBufferSGIX;
10629 glPollInstrumentsSGIX: TglPollInstrumentsSGIX;
10630 glReadInstrumentsSGIX: TglReadInstrumentsSGIX;
10631 glStartInstrumentsSGIX: TglStartInstrumentsSGIX;
10632 glStopInstrumentsSGIX: TglStopInstrumentsSGIX;
10633
10634 // GL_SGIX_list_priority
10635 glGetListParameterfvSGIX: TglGetListParameterfvSGIX;
10636 glGetListParameterivSGIX: TglGetListParameterivSGIX;
10637 glListParameterfSGIX: TglListParameterfSGIX;
10638 glListParameterfvSGIX: TglListParameterfvSGIX;
10639 glListParameteriSGIX: TglListParameteriSGIX;
10640 glListParameterivSGIX: TglListParameterivSGIX;
10641
10642 // GL_SGIX_pixel_texture
10643 glPixelTexGenSGIX: TglPixelTexGenSGIX;
10644
10645 // GL_SGIX_polynomial_ffd
10646 glDeformationMap3dSGIX: TglDeformationMap3dSGIX;
10647 glDeformationMap3fSGIX: TglDeformationMap3fSGIX;
10648 glDeformSGIX: TglDeformSGIX;
10649 glLoadIdentityDeformationMapSGIX: TglLoadIdentityDeformationMapSGIX;
10650
10651 // GL_SGIX_reference_plane
10652 glReferencePlaneSGIX: TglReferencePlaneSGIX;
10653
10654 // GL_SGIX_sprite
10655 glSpriteParameterfSGIX: TglSpriteParameterfSGIX;
10656 glSpriteParameterfvSGIX: TglSpriteParameterfvSGIX;
10657 glSpriteParameteriSGIX: TglSpriteParameteriSGIX;
10658 glSpriteParameterivSGIX: TglSpriteParameterivSGIX;
10659
10660 // GL_SGIX_tag_sample_buffer
10661 glTagSampleBufferSGIX: TglTagSampleBufferSGIX;
10662
10663 // GL_SGI_color_table
10664 glColorTableSGI: TglColorTableSGI;
10665 glColorTableParameterfvSGI: TglColorTableParameterfvSGI;
10666 glColorTableParameterivSGI: TglColorTableParameterivSGI;
10667 glCopyColorTableSGI: TglCopyColorTableSGI;
10668 glGetColorTableSGI: TglGetColorTableSGI;
10669 glGetColorTableParameterfvSGI: TglGetColorTableParameterfvSGI;
10670 glGetColorTableParameterivSGI: TglGetColorTableParameterivSGI;
10671
10672 // GL_SUNX_constant_data
10673 glFinishTextureSUNX: TglFinishTextureSUNX;
10674
10675 // GL_SUN_global_alpha
10676 glGlobalAlphaFactorbSUN: TglGlobalAlphaFactorbSUN;
10677 glGlobalAlphaFactorsSUN: TglGlobalAlphaFactorsSUN;
10678 glGlobalAlphaFactoriSUN: TglGlobalAlphaFactoriSUN;
10679 glGlobalAlphaFactorfSUN: TglGlobalAlphaFactorfSUN;
10680 glGlobalAlphaFactordSUN: TglGlobalAlphaFactordSUN;
10681 glGlobalAlphaFactorubSUN: TglGlobalAlphaFactorubSUN;
10682 glGlobalAlphaFactorusSUN: TglGlobalAlphaFactorusSUN;
10683 glGlobalAlphaFactoruiSUN: TglGlobalAlphaFactoruiSUN;
10684
10685 // GL_SUN_mesh_array
10686 glDrawMeshArraysSUN: TglDrawMeshArraysSUN;
10687
10688 // GL_SUN_triangle_list
10689 glReplacementCodeuiSUN: TglReplacementCodeuiSUN;
10690 glReplacementCodeusSUN: TglReplacementCodeusSUN;
10691 glReplacementCodeubSUN: TglReplacementCodeubSUN;
10692 glReplacementCodeuivSUN: TglReplacementCodeuivSUN;
10693 glReplacementCodeusvSUN: TglReplacementCodeusvSUN;
10694 glReplacementCodeubvSUN: TglReplacementCodeubvSUN;
10695 glReplacementCodePointerSUN: TglReplacementCodePointerSUN;
10696
10697 // GL_SUN_vertex
10698 glColor4ubVertex2fSUN: TglColor4ubVertex2fSUN;
10699 glColor4ubVertex2fvSUN: TglColor4ubVertex2fvSUN;
10700 glColor4ubVertex3fSUN: TglColor4ubVertex3fSUN;
10701 glColor4ubVertex3fvSUN: TglColor4ubVertex3fvSUN;
10702 glColor3fVertex3fSUN: TglColor3fVertex3fSUN;
10703 glColor3fVertex3fvSUN: TglColor3fVertex3fvSUN;
10704 glNormal3fVertex3fSUN: TglNormal3fVertex3fSUN;
10705 glNormal3fVertex3fvSUN: TglNormal3fVertex3fvSUN;
10706 glColor4fNormal3fVertex3fSUN: TglColor4fNormal3fVertex3fSUN;
10707 glColor4fNormal3fVertex3fvSUN: TglColor4fNormal3fVertex3fvSUN;
10708 glTexCoord2fVertex3fSUN: TglTexCoord2fVertex3fSUN;
10709 glTexCoord2fVertex3fvSUN: TglTexCoord2fVertex3fvSUN;
10710 glTexCoord4fVertex4fSUN: TglTexCoord4fVertex4fSUN;
10711 glTexCoord4fVertex4fvSUN: TglTexCoord4fVertex4fvSUN;
10712 glTexCoord2fColor4ubVertex3fSUN: TglTexCoord2fColor4ubVertex3fSUN;
10713 glTexCoord2fColor4ubVertex3fvSUN: TglTexCoord2fColor4ubVertex3fvSUN;
10714 glTexCoord2fColor3fVertex3fSUN: TglTexCoord2fColor3fVertex3fSUN;
10715 glTexCoord2fColor3fVertex3fvSUN: TglTexCoord2fColor3fVertex3fvSUN;
10716 glTexCoord2fNormal3fVertex3fSUN: TglTexCoord2fNormal3fVertex3fSUN;
10717 glTexCoord2fNormal3fVertex3fvSUN: TglTexCoord2fNormal3fVertex3fvSUN;
10718 glTexCoord2fColor4fNormal3fVertex3fSUN: TglTexCoord2fColor4fNormal3fVertex3fSUN;
10719 glTexCoord2fColor4fNormal3fVertex3fvSUN: TglTexCoord2fColor4fNormal3fVertex3fvSUN;
10720 glTexCoord4fColor4fNormal3fVertex4fSUN: TglTexCoord4fColor4fNormal3fVertex4fSUN;
10721 glTexCoord4fColor4fNormal3fVertex4fvSUN: TglTexCoord4fColor4fNormal3fVertex4fvSUN;
10722 glReplacementCodeuiVertex3fSUN: TglReplacementCodeuiVertex3fSUN;
10723 glReplacementCodeuiVertex3fvSUN: TglReplacementCodeuiVertex3fvSUN;
10724 glReplacementCodeuiColor4ubVertex3fSUN: TglReplacementCodeuiColor4ubVertex3fSUN;
10725 glReplacementCodeuiColor4ubVertex3fvSUN: TglReplacementCodeuiColor4ubVertex3fvSUN;
10726 glReplacementCodeuiColor3fVertex3fSUN: TglReplacementCodeuiColor3fVertex3fSUN;
10727 glReplacementCodeuiColor3fVertex3fvSUN: TglReplacementCodeuiColor3fVertex3fvSUN;
10728 glReplacementCodeuiNormal3fVertex3fSUN: TglReplacementCodeuiNormal3fVertex3fSUN;
10729 glReplacementCodeuiNormal3fVertex3fvSUN: TglReplacementCodeuiNormal3fVertex3fvSUN;
10730 glReplacementCodeuiColor4fNormal3fVertex3fSUN: TglReplacementCodeuiColor4fNormal3fVertex3fSUN;
10731 glReplacementCodeuiColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiColor4fNormal3fVertex3fvSUN;
10732 glReplacementCodeuiTexCoord2fVertex3fSUN: TglReplacementCodeuiTexCoord2fVertex3fSUN;
10733 glReplacementCodeuiTexCoord2fVertex3fvSUN: TglReplacementCodeuiTexCoord2fVertex3fvSUN;
10734 glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
10735 glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
10736 glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
10737 glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
10738
10739 {$IFDEF DGL_WIN}
10740 wglGetProcAddress: TwglGetProcAddress;
10741 wglCopyContext: TwglCopyContext;
10742 wglCreateContext: TwglCreateContext;
10743 wglCreateLayerContext: TwglCreateLayerContext;
10744 wglDeleteContext: TwglDeleteContext;
10745 wglDescribeLayerPlane: TwglDescribeLayerPlane;
10746 wglGetCurrentContext: TwglGetCurrentContext;
10747 wglGetCurrentDC: TwglGetCurrentDC;
10748 wglGetLayerPaletteEntries: TwglGetLayerPaletteEntries;
10749 wglMakeCurrent: TwglMakeCurrent;
10750 wglRealizeLayerPalette: TwglRealizeLayerPalette;
10751 wglSetLayerPaletteEntries: TwglSetLayerPaletteEntries;
10752 wglShareLists: TwglShareLists;
10753 wglSwapLayerBuffers: TwglSwapLayerBuffers;
10754 wglSwapMultipleBuffers: TwglSwapMultipleBuffers;
10755 wglUseFontBitmapsA: TwglUseFontBitmapsA;
10756 wglUseFontOutlinesA: TwglUseFontOutlinesA;
10757 wglUseFontBitmapsW: TwglUseFontBitmapsW;
10758 wglUseFontOutlinesW: TwglUseFontOutlinesW;
10759 wglUseFontBitmaps: TwglUseFontBitmaps;
10760 wglUseFontOutlines: TwglUseFontOutlines;
10761
10762 // WGL_ARB_buffer_region
10763 wglCreateBufferRegionARB: TwglCreateBufferRegionARB;
10764 wglDeleteBufferRegionARB: TwglDeleteBufferRegionARB;
10765 wglSaveBufferRegionARB: TwglSaveBufferRegionARB;
10766 wglRestoreBufferRegionARB: TwglRestoreBufferRegionARB;
10767
10768 // WGL_ARB_extensions_string
10769 wglGetExtensionsStringARB: TwglGetExtensionsStringARB;
10770
10771 // WGL_ARB_make_current_read
10772 wglMakeContextCurrentARB: TwglMakeContextCurrentARB;
10773 wglGetCurrentReadDCARB: TwglGetCurrentReadDCARB;
10774
10775 // WGL_ARB_pbuffer
10776 wglCreatePbufferARB: TwglCreatePbufferARB;
10777 wglGetPbufferDCARB: TwglGetPbufferDCARB;
10778 wglReleasePbufferDCARB: TwglReleasePbufferDCARB;
10779 wglDestroyPbufferARB: TwglDestroyPbufferARB;
10780 wglQueryPbufferARB: TwglQueryPbufferARB;
10781
10782 // WGL_ARB_pixel_format
10783 wglGetPixelFormatAttribivARB: TwglGetPixelFormatAttribivARB;
10784 wglGetPixelFormatAttribfvARB: TwglGetPixelFormatAttribfvARB;
10785 wglChoosePixelFormatARB: TwglChoosePixelFormatARB;
10786 // WGL_ARB_color_buffer_float
10787 wglClampColorARB: TwglClampColorARB;
10788
10789 // WGL_ARB_render_texture
10790 wglBindTexImageARB: TwglBindTexImageARB;
10791 wglReleaseTexImageARB: TwglReleaseTexImageARB;
10792 wglSetPbufferAttribARB: TwglSetPbufferAttribARB;
10793
10794 // WGL_ARB_create_context
10795 wglCreateContextAttribsARB: TwglCreateContextAttribsARB;
10796
10797 // WGL_AMD_gpu_association
10798 wglGetGPUIDsAMD: TwglGetGPUIDsAMD;
10799 wglGetGPUInfoAMD: TwglGetGPUInfoAMD;
10800 wglGetContextGPUIDAMD: TwglGetContextGPUIDAMD;
10801 wglCreateAssociatedContextAMD: TwglCreateAssociatedContextAMD;
10802 wglCreateAssociatedContextAttribsAMD: TwglCreateAssociatedContextAttribsAMD;
10803 wglDeleteAssociatedContextAMD: TwglDeleteAssociatedContextAMD;
10804 wglMakeAssociatedContextCurrentAMD: TwglMakeAssociatedContextCurrentAMD;
10805 wglGetCurrentAssociatedContextAMD: TwglGetCurrentAssociatedContextAMD;
10806 wglBlitContextFramebufferAMD: TwglBlitContextFramebufferAMD;
10807
10808 // WGL_EXT_display_color_table
10809 wglCreateDisplayColorTableEXT: TwglCreateDisplayColorTableEXT;
10810 wglLoadDisplayColorTableEXT: TwglLoadDisplayColorTableEXT;
10811 wglBindDisplayColorTableEXT: TwglBindDisplayColorTableEXT;
10812 wglDestroyDisplayColorTableEXT: TwglDestroyDisplayColorTableEXT;
10813
10814 // WGL_EXT_extensions_string
10815 wglGetExtensionsStringEXT: TwglGetExtensionsStringEXT;
10816
10817 // WGL_EXT_make_current_read
10818 wglMakeContextCurrentEXT: TwglMakeContextCurrentEXT;
10819 wglGetCurrentReadDCEXT: TwglGetCurrentReadDCEXT;
10820
10821 // WGL_EXT_pbuffer
10822 wglCreatePbufferEXT: TwglCreatePbufferEXT;
10823 wglGetPbufferDCEXT: TwglGetPbufferDCEXT;
10824 wglReleasePbufferDCEXT: TwglReleasePbufferDCEXT;
10825 wglDestroyPbufferEXT: TwglDestroyPbufferEXT;
10826 wglQueryPbufferEXT: TwglQueryPbufferEXT;
10827
10828 // WGL_EXT_pixel_format
10829 wglGetPixelFormatAttribivEXT: TwglGetPixelFormatAttribivEXT;
10830 wglGetPixelFormatAttribfvEXT: TwglGetPixelFormatAttribfvEXT;
10831 wglChoosePixelFormatEXT: TwglChoosePixelFormatEXT;
10832
10833 // WGL_EXT_swap_control
10834 wglSwapIntervalEXT: TwglSwapIntervalEXT;
10835 wglGetSwapIntervalEXT: TwglGetSwapIntervalEXT;
10836
10837 // WGL_I3D_digital_video_control
10838 wglGetDigitalVideoParametersI3D: TwglGetDigitalVideoParametersI3D;
10839 wglSetDigitalVideoParametersI3D: TwglSetDigitalVideoParametersI3D;
10840
10841 // WGL_I3D_gamma
10842 wglGetGammaTableParametersI3D: TwglGetGammaTableParametersI3D;
10843 wglSetGammaTableParametersI3D: TwglSetGammaTableParametersI3D;
10844 wglGetGammaTableI3D: TwglGetGammaTableI3D;
10845 wglSetGammaTableI3D: TwglSetGammaTableI3D;
10846
10847 // WGL_I3D_genlock
10848 wglEnableGenlockI3D: TwglEnableGenlockI3D;
10849 wglDisableGenlockI3D: TwglDisableGenlockI3D;
10850 wglIsEnabledGenlockI3D: TwglIsEnabledGenlockI3D;
10851 wglGenlockSourceI3D: TwglGenlockSourceI3D;
10852 wglGetGenlockSourceI3D: TwglGetGenlockSourceI3D;
10853 wglGenlockSourceEdgeI3D: TwglGenlockSourceEdgeI3D;
10854 wglGetGenlockSourceEdgeI3D: TwglGetGenlockSourceEdgeI3D;
10855 wglGenlockSampleRateI3D: TwglGenlockSampleRateI3D;
10856 wglGetGenlockSampleRateI3D: TwglGetGenlockSampleRateI3D;
10857 wglGenlockSourceDelayI3D: TwglGenlockSourceDelayI3D;
10858 wglGetGenlockSourceDelayI3D: TwglGetGenlockSourceDelayI3D;
10859 wglQueryGenlockMaxSourceDelayI3D: TwglQueryGenlockMaxSourceDelayI3D;
10860
10861 // WGL_I3D_image_buffer
10862 wglCreateImageBufferI3D: TwglCreateImageBufferI3D;
10863 wglDestroyImageBufferI3D: TwglDestroyImageBufferI3D;
10864 wglAssociateImageBufferEventsI3D: TwglAssociateImageBufferEventsI3D;
10865 wglReleaseImageBufferEventsI3D: TwglReleaseImageBufferEventsI3D;
10866
10867 // WGL_I3D_swap_frame_lock
10868 wglEnableFrameLockI3D: TwglEnableFrameLockI3D;
10869 wglDisableFrameLockI3D: TwglDisableFrameLockI3D;
10870 wglIsEnabledFrameLockI3D: TwglIsEnabledFrameLockI3D;
10871 wglQueryFrameLockMasterI3D: TwglQueryFrameLockMasterI3D;
10872
10873 // WGL_I3D_swap_frame_usage
10874 wglGetFrameUsageI3D: TwglGetFrameUsageI3D;
10875 wglBeginFrameTrackingI3D: TwglBeginFrameTrackingI3D;
10876 wglEndFrameTrackingI3D: TwglEndFrameTrackingI3D;
10877 wglQueryFrameTrackingI3D: TwglQueryFrameTrackingI3D;
10878
10879 // WGL_NV_vertex_array_range
10880 wglAllocateMemoryNV: TwglAllocateMemoryNV;
10881 wglFreeMemoryNV: TwglFreeMemoryNV;
10882
10883 // WGL_NV_present_video
10884 wglEnumerateVideoDevicesNV: TwglEnumerateVideoDevicesNV;
10885 wglBindVideoDeviceNV: TwglBindVideoDeviceNV;
10886 wglQueryCurrentContextNV: TwglQueryCurrentContextNV;
10887
10888 // WGL_NV_video_out
10889 wglGetVideoDeviceNV: TwglGetVideoDeviceNV;
10890 wglReleaseVideoDeviceNV: TwglReleaseVideoDeviceNV;
10891 wglBindVideoImageNV: TwglBindVideoImageNV;
10892 wglReleaseVideoImageNV: TwglReleaseVideoImageNV;
10893 wglSendPbufferToVideoNV: TwglSendPbufferToVideoNV;
10894 wglGetVideoInfoNV: TwglGetVideoInfoNV;
10895
10896 // WGL_NV_swap_group
10897 wglJoinSwapGroupNV: TwglJoinSwapGroupNV;
10898 wglBindSwapBarrierNV: TwglBindSwapBarrierNV;
10899 wglQuerySwapGroupNV: TwglQuerySwapGroupNV;
10900 wglQueryMaxSwapGroupsNV: TwglQueryMaxSwapGroupsNV;
10901 wglQueryFrameCountNV: TwglQueryFrameCountNV;
10902 wglResetFrameCountNV: TwglResetFrameCountNV;
10903
10904 // WGL_NV_gpu_affinity
10905 wglEnumGpusNV: TwglEnumGpusNV;
10906 wglEnumGpuDevicesNV: TwglEnumGpuDevicesNV;
10907 wglCreateAffinityDCNV: TwglCreateAffinityDCNV;
10908 wglEnumGpusFromAffinityDCNV: TwglEnumGpusFromAffinityDCNV;
10909 wglDeleteDCNV: TwglDeleteDCNV;
10910
10911 // WGL_OML_sync_control
10912 wglGetSyncValuesOML: TwglGetSyncValuesOML;
10913 wglGetMscRateOML: TwglGetMscRateOML;
10914 wglSwapBuffersMscOML: TwglSwapBuffersMscOML;
10915 wglSwapLayerBuffersMscOML: TwglSwapLayerBuffersMscOML;
10916 wglWaitForMscOML: TwglWaitForMscOML;
10917 wglWaitForSbcOML: TwglWaitForSbcOML;
10918
10919 // WGL_3DL_stereo_control
10920 wglSetStereoEmitterState3DL: TwglSetStereoEmitterState3DL;
10921
10922 // WIN_draw_range_elements
10923 glDrawRangeElementsWIN: TglDrawRangeElementsWIN;
10924
10925 // WIN_swap_hint
10926 glAddSwapHintRectWIN: TglAddSwapHintRectWIN;
10927 {$ENDIF}
10928
10929 {$IFDEF DGL_LINUX}
10930 glXChooseVisual: TglXChooseVisual;
10931 glXCopyContext: TglXCopyContext;
10932 glXCreateContext: TglXCreateContext;
10933 glXCreateGLXPixmap: TglXCreateGLXPixmap;
10934 glXDestroyContext: TglXDestroyContext;
10935 glXDestroyGLXPixmap: TglXDestroyGLXPixmap;
10936 glXGetConfig: TglXGetConfig;
10937 glXGetCurrentContext: TglXGetCurrentContext;
10938 glXGetCurrentDrawable: TglXGetCurrentDrawable;
10939 glXIsDirect: TglXIsDirect;
10940 glXMakeCurrent: TglXMakeCurrent;
10941 glXQueryExtension: TglXQueryExtension;
10942 glXQueryVersion: TglXQueryVersion;
10943 glXSwapBuffers: TglXSwapBuffers;
10944 glXUseXFont: TglXUseXFont;
10945 glXWaitGL: TglXWaitGL;
10946 glXWaitX: TglXWaitX;
10947
10948 glXGetClientString: TglXGetClientString;
10949 glXQueryServerString: TglXQueryServerString;
10950 glXQueryExtensionsString: TglXQueryExtensionsString;
10951
10952 // GLX_VERSION_1_3
10953 glXGetFBConfigs: TglXGetFBConfigs;
10954 glXChooseFBConfig: TglXChooseFBConfig;
10955 glXGetFBConfigAttrib: TglXGetFBConfigAttrib;
10956 glXGetVisualFromFBConfig: TglXGetVisualFromFBConfig;
10957 glXCreateWindow: TglXCreateWindow;
10958 glXDestroyWindow: TglXDestroyWindow;
10959 glXCreatePixmap: TglXCreatePixmap;
10960
10961 glXDestroyPixmap: TglXDestroyPixmap;
10962 glXCreatePbuffer: TglXCreatePbuffer;
10963 glXDestroyPbuffer: TglXDestroyPbuffer;
10964 glXQueryDrawable: TglXQueryDrawable;
10965 glXCreateNewContext: TglXCreateNewContext;
10966 glXMakeContextCurrent: TglXMakeContextCurrent;
10967 glXGetCurrentReadDrawable: TglXGetCurrentReadDrawable;
10968 glXGetCurreentDisplay: TglXGetCurreentDisplay;
10969
10970 glXQueryContext: TglXQueryContext;
10971 glXSelectEvent: TglXSelectEvent;
10972 glXGetSelectedEvent: TglXGetSelectedEvent;
10973
10974 // GLX_VERSION_1_4
10975 glXGetProcAddress: TglXGetProcAddress;
10976
10977 // GLX_ARB_get_proc_address
10978 glXGetProcAddressARB: TglXGetProcAddressARB;
10979
10980 // GLX_ARB_create_context
10981 glXCreateContextAttribsARB: TglXCreateContextAttribsARB;
10982
10983 // GLX_EXT_import_context
10984 glXGetCurrentDisplayEXT: TglXGetCurrentDisplayEXT;
10985 glXQueryContextInfoEXT: TglXQueryContextInfoEXT;
10986 glXGetContextIDEXT: TglXGetContextIDEXT;
10987 glXImportContextEXT: TglXImportContextEXT;
10988 glXFreeContextEXT: TglXFreeContextEXT;
10989
10990 // GLX_EXT_texture_from_pixmap
10991 glXBindTexImageEXT: TglXBindTexImageEXT;
10992 glXReleaseTexImageEXT: TglXReleaseTexImageEXT;
10993 {$ENDIF}
10994
10995 // GL utility functions and procedures
10996 gluErrorString: TgluErrorString;
10997 gluGetString: TgluGetString;
10998 gluOrtho2D: TgluOrtho2D;
10999 gluPerspective: TgluPerspective;
11000 gluPickMatrix: TgluPickMatrix;
11001 gluLookAt: TgluLookAt;
11002 gluProject: TgluProject;
11003 gluUnProject: TgluUnProject;
11004 gluScaleImage: TgluScaleImage;
11005 gluBuild1DMipmaps: TgluBuild1DMipmaps;
11006 gluBuild2DMipmaps: TgluBuild2DMipmaps;
11007 gluNewQuadric: TgluNewQuadric;
11008 gluDeleteQuadric: TgluDeleteQuadric;
11009 gluQuadricNormals: TgluQuadricNormals;
11010 gluQuadricTexture: TgluQuadricTexture;
11011 gluQuadricOrientation: TgluQuadricOrientation;
11012 gluQuadricDrawStyle: TgluQuadricDrawStyle;
11013 gluCylinder: TgluCylinder;
11014 gluDisk: TgluDisk;
11015 gluPartialDisk: TgluPartialDisk;
11016 gluSphere: TgluSphere;
11017 gluQuadricCallback: TgluQuadricCallback;
11018 gluNewTess: TgluNewTess;
11019 gluDeleteTess: TgluDeleteTess;
11020 gluTessBeginPolygon: TgluTessBeginPolygon;
11021 gluTessBeginContour: TgluTessBeginContour;
11022 gluTessVertex: TgluTessVertex;
11023 gluTessEndContour: TgluTessEndContour;
11024 gluTessEndPolygon: TgluTessEndPolygon;
11025 gluTessProperty: TgluTessProperty;
11026 gluTessNormal: TgluTessNormal;
11027 gluTessCallback: TgluTessCallback;
11028 gluGetTessProperty: TgluGetTessProperty;
11029 gluNewNurbsRenderer: TgluNewNurbsRenderer;
11030 gluDeleteNurbsRenderer: TgluDeleteNurbsRenderer;
11031 gluBeginSurface: TgluBeginSurface;
11032 gluBeginCurve: TgluBeginCurve;
11033 gluEndCurve: TgluEndCurve;
11034 gluEndSurface: TgluEndSurface;
11035 gluBeginTrim: TgluBeginTrim;
11036 gluEndTrim: TgluEndTrim;
11037 gluPwlCurve: TgluPwlCurve;
11038 gluNurbsCurve: TgluNurbsCurve;
11039 gluNurbsSurface: TgluNurbsSurface;
11040 gluLoadSamplingMatrices: TgluLoadSamplingMatrices;
11041 gluNurbsProperty: TgluNurbsProperty;
11042 gluGetNurbsProperty: TgluGetNurbsProperty;
11043 gluNurbsCallback: TgluNurbsCallback;
11044 gluBeginPolygon: TgluBeginPolygon;
11045 gluNextContour: TgluNextContour;
11046 gluEndPolygon: TgluEndPolygon;
11047
11048
11049 type
11050 TRCOptions = set of (opDoubleBuffered, opGDI, opStereo);
11051
11052 var
11053 GL_LibHandle: Pointer = nil;
11054 GLU_LibHandle: Pointer = nil;
11055
11056 LastPixelFormat: Integer;
11057 ExtensionsRead: Boolean;
11058 ImplementationRead: Boolean;
11059
11060
11061 const
11062 {$IFDEF DGL_WIN}
11063 OPENGL_LIBNAME = 'OpenGL32.dll';
11064 GLU_LIBNAME = 'GLU32.dll';
11065 {$ELSE}
11066 {$IFDEF darwin}
11067 OPENGL_LIBNAME = 'libGL.dylib';
11068 GLU_LIBNAME = 'libGLU.dylib';
11069 {$ELSE}
11070 OPENGL_LIBNAME = 'libGL.so.1';
11071 GLU_LIBNAME = 'libGLU.so.1';
11072 {$ENDIF}
11073 {$ENDIF}
11074
11075 function InitOpenGL(LibName: String = OPENGL_LIBNAME; GLULibName: String = GLU_LIBNAME): Boolean;
11076
11077 function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil): Pointer;
11078 function dglCheckExtension(Extension: AnsiString): Boolean;
11079
11080 procedure ReadExtensions;
11081 procedure ReadImplementationProperties;
11082
11083 // =============================================================================
11084 // Helper-Functions
11085 // =============================================================================
11086 {$IFDEF DGL_WIN}
11087 function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
11088 procedure DestroyRenderingContext(RC: HGLRC);
11089
11090 procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
11091 procedure DeactivateRenderingContext;
11092 {$ENDIF}
11093
11094
11095 procedure ReadOpenGLCore;
11096 procedure Read_GL_3DFX_tbuffer;
11097 procedure Read_GL_APPLE_element_array;
11098 procedure Read_GL_APPLE_fence;
11099 procedure Read_GL_APPLE_vertex_array_object;
11100 procedure Read_GL_APPLE_vertex_array_range;
11101 procedure Read_GL_APPLE_texture_range;
11102 procedure Read_GL_APPLE_vertex_program_evaluators;
11103 procedure Read_GL_APPLE_object_purgeable;
11104 procedure Read_GL_ARB_matrix_palette;
11105 procedure Read_GL_ARB_multitexture;
11106 procedure Read_GL_ARB_point_parameters;
11107 procedure Read_GL_ARB_texture_compression;
11108 procedure Read_GL_ARB_transpose_matrix;
11109 procedure Read_GL_ARB_vertex_blend;
11110 procedure Read_GL_ARB_vertex_buffer_object;
11111 procedure Read_GL_ARB_vertex_program;
11112 procedure Read_GL_ARB_window_pos;
11113 procedure Read_GL_ARB_color_buffer_float;
11114 procedure Read_GL_ARB_Shader_Objects;
11115 procedure Read_GL_ARB_occlusion_query;
11116 procedure Read_GL_ARB_draw_instanced;
11117 procedure Read_GL_ARB_framebuffer_object;
11118 procedure Read_GL_ARB_geometry_shader4;
11119 procedure Read_GL_ARB_instanced_arrays;
11120 procedure Read_GL_ARB_map_buffer_range;
11121 procedure Read_GL_ARB_texture_buffer_object;
11122 procedure Read_GL_ARB_vertex_array_object;
11123 procedure Read_GL_ARB_uniform_buffer_object;
11124 procedure Read_GL_ARB_copy_buffer;
11125 procedure Read_GL_ARB_draw_elements_base_vertex;
11126 procedure Read_GL_ARB_provoking_vertex;
11127 procedure Read_GL_ARB_sync;
11128 procedure Read_GL_ARB_texture_multisample;
11129 procedure Read_GL_ARB_draw_buffers_blend;
11130 procedure Read_GL_ARB_sample_shading;
11131 procedure Read_GL_ATI_draw_buffers;
11132 procedure Read_GL_ATI_element_array;
11133 procedure Read_GL_ATI_envmap_bumpmap;
11134 procedure Read_GL_ATI_fragment_shader;
11135 procedure Read_GL_ATI_map_object_buffer;
11136 procedure Read_GL_ATI_pn_triangles;
11137 procedure Read_GL_ATI_separate_stencil;
11138 procedure Read_GL_ATI_vertex_array_object;
11139 procedure Read_GL_ATI_vertex_attrib_array_object;
11140 procedure Read_GL_ATI_vertex_streams;
11141 procedure Read_GL_AMD_performance_monitor;
11142 procedure Read_GL_EXT_blend_color;
11143 procedure Read_GL_EXT_blend_func_separate;
11144 procedure Read_GL_EXT_blend_minmax;
11145 procedure Read_GL_EXT_color_subtable;
11146 procedure Read_GL_EXT_compiled_vertex_array;
11147 procedure Read_GL_EXT_convolution;
11148 procedure Read_GL_EXT_coordinate_frame;
11149 procedure Read_GL_EXT_copy_texture;
11150 procedure Read_GL_EXT_cull_vertex;
11151 procedure Read_GL_EXT_draw_range_elements;
11152 procedure Read_GL_EXT_fog_coord;
11153 procedure Read_GL_EXT_framebuffer_object;
11154 procedure Read_GL_EXT_histogram;
11155 procedure Read_GL_EXT_index_func;
11156 procedure Read_GL_EXT_index_material;
11157 procedure Read_GL_EXT_multi_draw_arrays;
11158 procedure Read_GL_EXT_multisample;
11159 procedure Read_GL_EXT_paletted_texture;
11160 procedure Read_GL_EXT_pixel_transform;
11161 procedure Read_GL_EXT_point_parameters;
11162 procedure Read_GL_EXT_polygon_offset;
11163 procedure Read_GL_EXT_secondary_color;
11164 procedure Read_GL_EXT_stencil_two_side;
11165 procedure Read_GL_EXT_subtexture;
11166 procedure Read_GL_EXT_texture3D;
11167 procedure Read_GL_EXT_texture_object;
11168 procedure Read_GL_EXT_texture_perturb_normal;
11169 procedure Read_GL_EXT_vertex_array;
11170 procedure Read_GL_EXT_vertex_shader;
11171 procedure Read_GL_EXT_vertex_weighting;
11172 procedure Read_GL_EXT_depth_bounds_test;
11173 procedure Read_GL_EXT_blend_equation_separate;
11174 procedure Read_GL_EXT_stencil_clear_tag;
11175 procedure Read_GL_EXT_framebuffer_blit;
11176 procedure Read_GL_EXT_framebuffer_multisample;
11177 procedure Read_GL_EXT_timer_query;
11178 procedure Read_GL_EXT_gpu_program_parameters;
11179 procedure Read_GL_EXT_bindable_uniform;
11180 procedure Read_GL_EXT_draw_buffers2;
11181 procedure Read_GL_EXT_draw_instanced;
11182 procedure Read_GL_EXT_geometry_shader4;
11183 procedure Read_GL_EXT_gpu_shader4;
11184 procedure Read_GL_EXT_texture_array;
11185 procedure Read_GL_EXT_texture_buffer_object;
11186 procedure Read_GL_EXT_texture_integer;
11187 procedure Read_GL_EXT_transform_feedback;
11188 procedure Read_GL_EXT_direct_state_access;
11189 procedure Read_GL_HP_image_transform;
11190 procedure Read_GL_IBM_multimode_draw_arrays;
11191 procedure Read_GL_IBM_vertex_array_lists;
11192 procedure Read_GL_INGR_blend_func_separate;
11193 procedure Read_GL_INTEL_parallel_arrays;
11194 procedure Read_GL_MESA_resize_buffers;
11195 procedure Read_GL_MESA_window_pos;
11196 procedure Read_GL_NV_evaluators;
11197 procedure Read_GL_NV_fence;
11198 procedure Read_GL_NV_fragment_program;
11199 procedure Read_GL_NV_half_float;
11200 procedure Read_GL_NV_occlusion_query;
11201 procedure Read_GL_NV_pixel_data_range;
11202 procedure Read_GL_NV_point_sprite;
11203 procedure Read_GL_NV_primitive_restart;
11204 procedure Read_GL_NV_register_combiners;
11205 procedure Read_GL_NV_register_combiners2;
11206 procedure Read_GL_NV_vertex_array_range;
11207 procedure Read_GL_NV_vertex_program;
11208 procedure Read_GL_NV_depth_buffer_float;
11209 procedure Read_GL_NV_framebuffer_multisample_coverage;
11210 procedure Read_GL_NV_geometry_program4;
11211 procedure Read_GL_NV_gpu_program4;
11212 procedure Read_GL_NV_parameter_buffer_object;
11213 procedure Read_GL_NV_transform_feedback;
11214 procedure Read_GL_NV_conditional_render;
11215 procedure Read_GL_NV_present_video;
11216 procedure Read_GL_NV_explicit_multisample;
11217 procedure Read_GL_NV_transform_feedback2;
11218 procedure Read_GL_PGI_misc_hints;
11219 procedure Read_GL_SGIS_detail_texture;
11220 procedure Read_GL_SGIS_fog_function;
11221 procedure Read_GL_SGIS_multisample;
11222 procedure Read_GL_SGIS_pixel_texture;
11223 procedure Read_GL_SGIS_point_parameters;
11224 procedure Read_GL_SGIS_sharpen_texture;
11225 procedure Read_GL_SGIS_texture4D;
11226 procedure Read_GL_SGIS_texture_color_mask;
11227 procedure Read_GL_SGIS_texture_filter4;
11228 procedure Read_GL_SGIX_async;
11229 procedure Read_GL_SGIX_flush_raster;
11230 procedure Read_GL_SGIX_fragment_lighting;
11231 procedure Read_GL_SGIX_framezoom;
11232 procedure Read_GL_SGIX_igloo_interface;
11233 procedure Read_GL_SGIX_instruments;
11234 procedure Read_GL_SGIX_list_priority;
11235 procedure Read_GL_SGIX_pixel_texture;
11236 procedure Read_GL_SGIX_polynomial_ffd;
11237 procedure Read_GL_SGIX_reference_plane;
11238 procedure Read_GL_SGIX_sprite;
11239 procedure Read_GL_SGIX_tag_sample_buffer;
11240 procedure Read_GL_SGI_color_table;
11241 procedure Read_GL_SUNX_constant_data;
11242 procedure Read_GL_SUN_global_alpha;
11243 procedure Read_GL_SUN_mesh_array;
11244 procedure Read_GL_SUN_triangle_list;
11245 procedure Read_GL_SUN_vertex;
11246
11247 {$IFDEF DGL_WIN}
11248 procedure Read_WGL_ARB_buffer_region;
11249 procedure Read_WGL_ARB_extensions_string;
11250 procedure Read_WGL_ARB_make_current_read;
11251 procedure Read_WGL_ARB_pbuffer;
11252 procedure Read_WGL_ARB_pixel_format;
11253 procedure Read_WGL_ARB_pixel_format_float;
11254 procedure Read_WGL_ARB_render_texture;
11255 procedure Read_WGL_ARB_create_context;
11256 procedure Read_WGL_AMD_gpu_association;
11257 procedure Read_WGL_EXT_display_color_table;
11258 procedure Read_WGL_EXT_extensions_string;
11259 procedure Read_WGL_EXT_make_current_read;
11260 procedure Read_WGL_EXT_pbuffer;
11261 procedure Read_WGL_EXT_pixel_format;
11262 procedure Read_WGL_EXT_swap_control;
11263 procedure Read_WGL_I3D_digital_video_control;
11264 procedure Read_WGL_I3D_gamma;
11265 procedure Read_WGL_I3D_genlock;
11266 procedure Read_WGL_I3D_image_buffer;
11267 procedure Read_WGL_I3D_swap_frame_lock;
11268 procedure Read_WGL_I3D_swap_frame_usage;
11269 procedure Read_WGL_NV_vertex_array_range;
11270 procedure Read_WGL_NV_present_video;
11271 procedure Read_WGL_NV_video_out;
11272 procedure Read_WGL_NV_swap_group;
11273 procedure Read_WGL_NV_gpu_affinity;
11274 procedure Read_WGL_OML_sync_control;
11275 procedure Read_WGL_3DL_stereo_control;
11276
11277 procedure Read_WIN_draw_range_elements;
11278 procedure Read_WIN_swap_hint;
11279 {$ENDIF}
11280
11281
11282 implementation
11283
11284
11285 {$IFDEF DGL_LINUX}
11286 const
11287 RTLD_LAZY = $001;
11288 RTLD_NOW = $002;
11289 RTLD_BINDING_MASK = $003;
11290
11291 // Seems to work on Debian / Fedora
11292 LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF};
11293
11294 function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen';
11295 function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose';
11296
11297 function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym';
11298 {$ENDIF}
11299
11300
11301 function dglLoadLibrary(Name: PChar): Pointer;
11302 begin
11303 {$IFDEF DGL_WIN}
11304 Result := Pointer(LoadLibrary(Name));
11305 {$ENDIF}
11306
11307 {$IFDEF DGL_LINUX}
11308 Result := dlopen(Name, RTLD_LAZY);
11309 {$ENDIF}
11310 end;
11311
11312
11313 function dglFreeLibrary(LibHandle: Pointer): Boolean;
11314 begin
11315 if LibHandle = nil then
11316 Result := False
11317 else
11318 {$IFDEF DGL_WIN}
11319 Result := FreeLibrary(HMODULE(LibHandle));
11320 {$ENDIF}
11321
11322 {$IFDEF DGL_LINUX}
11323 Result := dlclose(LibHandle) = 0;
11324 {$ENDIF}
11325 end;
11326
11327
11328 function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil): Pointer;
11329 begin
11330 if LibHandle = nil then
11331 LibHandle := GL_LibHandle;
11332
11333 {$IFDEF DGL_WIN}
11334 Result := GetProcAddress(HMODULE(LibHandle), ProcName);
11335 {$ENDIF}
11336
11337 {$IFDEF DGL_LINUX}
11338 Result := dlsym(LibHandle, ProcName);
11339 {$ENDIF}
11340
11341 if result <> nil then
11342 exit;
11343
11344 {$IFDEF DGL_WIN}
11345 if Addr(wglGetProcAddress) <> nil then
11346 Result := wglGetProcAddress(ProcName);
11347 {$ENDIF}
11348
11349 {$IFDEF DGL_LINUX}
11350 if Addr(glXGetProcAddress) <> nil then
11351 Result := glXGetProcAddress(ProcName);
11352
11353 if result <> nil then
11354 exit;
11355
11356 if Addr(glXGetProcAddressARB) <> nil then
11357 Result := glXGetProcAddressARB(ProcName);
11358 {$ENDIF}
11359 end;
11360
11361
11362 function Int_GetExtensionString: AnsiString;
11363 begin
11364 // generel extension string
11365 if not Assigned(@glGetString) then
11366 glGetString := dglGetProcAddress('glGetString');
11367
11368 if Assigned(@glGetString) then
11369 Result := glGetString(GL_EXTENSIONS)
11370 else
11371 Result := '';
11372
11373 if (GL_LibHandle <> nil) then begin
11374 {$IFDEF DGL_WIN}
11375 // wglGetExtensionsStringEXT
11376 if not Assigned(@wglGetExtensionsStringEXT) then
11377 wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
11378
11379 if Assigned(@wglGetExtensionsStringEXT) then
11380 Result := Result + #32 + wglGetExtensionsStringEXT;
11381
11382 // wglGetExtensionsStringARB
11383 if not Assigned(@wglGetExtensionsStringARB) then
11384 wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
11385
11386 if Assigned(@wglGetExtensionsStringARB) then
11387 Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC);
11388 {$ENDIF}
11389 end;
11390
11391 Result := #32 + Result + #32;
11392 end;
11393
11394
11395 function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean;
11396 begin
11397 Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0;
11398 end;
11399
11400
11401 function dglCheckExtension(Extension: AnsiString): Boolean;
11402 var
11403 Extensions: AnsiString;
11404 begin
11405 Extensions := Int_GetExtensionString;
11406 Result := Int_CheckExtension(Extensions, Extension);
11407 end;
11408
11409
11410
11411 function InitOpenGL(LibName: String; GLULibName: String): Boolean;
11412 begin
11413 Result := False;
11414
11415 // free opened libraries
11416 if GL_LibHandle <> nil then
11417 dglFreeLibrary(GL_LibHandle);
11418
11419 if GLU_LibHandle <> nil then
11420 dglFreeLibrary(GLU_LibHandle);
11421
11422 // load library
11423 GL_LibHandle := dglLoadLibrary(PChar(LibName));
11424 GLU_LibHandle := dglLoadLibrary(PChar(GLULibName));
11425
11426 // load GL functions
11427 if (GL_LibHandle <> nil) then begin
11428 {$IFDEF DGL_WIN}
11429 wglCopyContext := dglGetProcAddress('wglCopyContext');
11430 wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext');
11431 wglCreateContext := dglGetProcAddress('wglCreateContext');
11432 wglDeleteContext := dglGetProcAddress('wglDeleteContext');
11433 wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane');
11434 wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext');
11435 wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC');
11436 wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries');
11437 wglGetProcAddress := dglGetProcAddress('wglGetProcAddress');
11438 wglMakeCurrent := dglGetProcAddress('wglMakeCurrent');
11439 wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette');
11440 wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries');
11441 wglShareLists := dglGetProcAddress('wglShareLists');
11442 wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers');
11443 wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers');
11444 wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA');
11445 wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA');
11446 wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW');
11447 wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW');
11448 wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA');
11449 wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA');
11450 {$ENDIF}
11451
11452 {$IFDEF DGL_LINUX}
11453 glXChooseVisual := dglGetProcAddress('glXChooseVisual');
11454 glXCopyContext := dglGetProcAddress('glXCopyContext');
11455 glXCreateContext := dglGetProcAddress('glXCreateContext');
11456 glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap');
11457 glXDestroyContext := dglGetProcAddress('glXDestroyContext');
11458 glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap');
11459 glXGetConfig := dglGetProcAddress('glXGetConfig');
11460 glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext');
11461 glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable');
11462 glXIsDirect := dglGetProcAddress('glXIsDirect');
11463 glXMakeCurrent := dglGetProcAddress('glXMakeCurrent');
11464 glXQueryExtension := dglGetProcAddress('glXQueryExtension');
11465 glXQueryVersion := dglGetProcAddress('glXQueryVersion');
11466 glXSwapBuffers := dglGetProcAddress('glXSwapBuffers');
11467 glXUseXFont := dglGetProcAddress('glXUseXFont');
11468 glXWaitGL := dglGetProcAddress('glXWaitGL');
11469 glXWaitX := dglGetProcAddress('glXWaitX');
11470
11471 glXGetClientString := dglGetProcAddress('glXGetClientString');
11472 glXQueryServerString := dglGetProcAddress('glXQueryServerString');
11473 glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString');
11474
11475 // GLX_VERSION_1_3
11476 glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs');
11477 glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig');
11478 glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib');
11479 glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig');
11480 glXCreateWindow := dglGetProcAddress('glXCreateWindow');
11481 glXDestroyWindow := dglGetProcAddress('glXDestroyWindow');
11482 glXCreatePixmap := dglGetProcAddress('glXCreatePixmap');
11483
11484 glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap');
11485 glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer');
11486 glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer');
11487 glXQueryDrawable := dglGetProcAddress('glXQueryDrawable');
11488 glXCreateNewContext := dglGetProcAddress('glXCreateNewContext');
11489 glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent');
11490 glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable');
11491 glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay');
11492
11493 glXQueryContext := dglGetProcAddress('glXQueryContext');
11494 glXSelectEvent := dglGetProcAddress('glXSelectEvent');
11495 glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent');
11496
11497 // GLX_VERSION_1_4
11498 glXGetProcAddress := dglGetProcAddress('glXGetProcAddress');
11499
11500 // GLX_ARB_get_proc_address
11501 glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB');
11502
11503 // GLX_ARB_create_context
11504 glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB');
11505
11506 // GLX_EXT_import_context
11507 glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT');
11508 glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT');
11509 glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT');
11510 glXImportContextEXT := dglGetProcAddress('glXImportContextEXT');
11511 glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT');
11512
11513 // GLX_EXT_texture_from_pixmap
11514 glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT');
11515 glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT');
11516 {$ENDIF}
11517
11518 Result := True;
11519 end;
11520
11521 // load GLU functions
11522 if GLU_LibHandle <> nil then begin
11523 // GLU ========================================================================
11524 gluBeginCurve := dglGetProcAddress('gluBeginCurve', GLU_LibHandle);
11525 gluBeginPolygon := dglGetProcAddress('gluBeginPolygon', GLU_LibHandle);
11526 gluBeginSurface := dglGetProcAddress('gluBeginSurface', GLU_LibHandle);
11527 gluBeginTrim := dglGetProcAddress('gluBeginTrim', GLU_LibHandle);
11528 gluBuild1DMipmaps := dglGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle);
11529 gluBuild2DMipmaps := dglGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle);
11530 gluCylinder := dglGetProcAddress('gluCylinder', GLU_LibHandle);
11531 gluDeleteNurbsRenderer := dglGetProcAddress('gluDeleteNurbsRenderer', GLU_LibHandle);
11532 gluDeleteQuadric := dglGetProcAddress('gluDeleteQuadric', GLU_LibHandle);
11533 gluDeleteTess := dglGetProcAddress('gluDeleteTess', GLU_LibHandle);
11534 gluDisk := dglGetProcAddress('gluDisk', GLU_LibHandle);
11535 gluEndCurve := dglGetProcAddress('gluEndCurve', GLU_LibHandle);
11536 gluEndPolygon := dglGetProcAddress('gluEndPolygon', GLU_LibHandle);
11537 gluEndSurface := dglGetProcAddress('gluEndSurface', GLU_LibHandle);
11538 gluEndTrim := dglGetProcAddress('gluEndTrim', GLU_LibHandle);
11539 gluErrorString := dglGetProcAddress('gluErrorString', GLU_LibHandle);
11540 gluGetNurbsProperty := dglGetProcAddress('gluGetNurbsProperty', GLU_LibHandle);
11541 gluGetString := dglGetProcAddress('gluGetString', GLU_LibHandle);
11542 gluGetTessProperty := dglGetProcAddress('gluGetTessProperty', GLU_LibHandle);
11543 gluLoadSamplingMatrices := dglGetProcAddress('gluLoadSamplingMatrices', GLU_LibHandle);
11544 gluLookAt := dglGetProcAddress('gluLookAt', GLU_LibHandle);
11545 gluNewNurbsRenderer := dglGetProcAddress('gluNewNurbsRenderer', GLU_LibHandle);
11546 gluNewQuadric := dglGetProcAddress('gluNewQuadric', GLU_LibHandle);
11547 gluNewTess := dglGetProcAddress('gluNewTess', GLU_LibHandle);
11548 gluNextContour := dglGetProcAddress('gluNextContour', GLU_LibHandle);
11549 gluNurbsCallback := dglGetProcAddress('gluNurbsCallback', GLU_LibHandle);
11550 gluNurbsCurve := dglGetProcAddress('gluNurbsCurve', GLU_LibHandle);
11551 gluNurbsProperty := dglGetProcAddress('gluNurbsProperty', GLU_LibHandle);
11552 gluNurbsSurface := dglGetProcAddress('gluNurbsSurface', GLU_LibHandle);
11553 gluOrtho2D := dglGetProcAddress('gluOrtho2D', GLU_LibHandle);
11554 gluPartialDisk := dglGetProcAddress('gluPartialDisk', GLU_LibHandle);
11555 gluPerspective := dglGetProcAddress('gluPerspective', GLU_LibHandle);
11556 gluPickMatrix := dglGetProcAddress('gluPickMatrix', GLU_LibHandle);
11557 gluProject := dglGetProcAddress('gluProject', GLU_LibHandle);
11558 gluPwlCurve := dglGetProcAddress('gluPwlCurve', GLU_LibHandle);
11559 gluQuadricCallback := dglGetProcAddress('gluQuadricCallback', GLU_LibHandle);
11560 gluQuadricDrawStyle := dglGetProcAddress('gluQuadricDrawStyle', GLU_LibHandle);
11561 gluQuadricNormals := dglGetProcAddress('gluQuadricNormals', GLU_LibHandle);
11562 gluQuadricOrientation := dglGetProcAddress('gluQuadricOrientation', GLU_LibHandle);
11563 gluQuadricTexture := dglGetProcAddress('gluQuadricTexture', GLU_LibHandle);
11564 gluScaleImage := dglGetProcAddress('gluScaleImage', GLU_LibHandle);
11565 gluSphere := dglGetProcAddress('gluSphere', GLU_LibHandle);
11566 gluTessBeginContour := dglGetProcAddress('gluTessBeginContour', GLU_LibHandle);
11567 gluTessBeginPolygon := dglGetProcAddress('gluTessBeginPolygon', GLU_LibHandle);
11568 gluTessCallback := dglGetProcAddress('gluTessCallback', GLU_LibHandle);
11569 gluTessEndContour := dglGetProcAddress('gluTessEndContour', GLU_LibHandle);
11570 gluTessEndPolygon := dglGetProcAddress('gluTessEndPolygon', GLU_LibHandle);
11571 gluTessNormal := dglGetProcAddress('gluTessNormal', GLU_LibHandle);
11572 gluTessProperty := dglGetProcAddress('gluTessProperty', GLU_LibHandle);
11573 gluTessVertex := dglGetProcAddress('gluTessVertex', GLU_LibHandle);
11574 gluUnProject := dglGetProcAddress('gluUnProject', GLU_LibHandle);
11575 end;
11576 end;
11577
11578 procedure ReadOpenGLCore;
11579 begin
11580 // GL_VERSION_1_0
11581 glCullFace := dglGetProcAddress('glCullFace');
11582 glFrontFace := dglGetProcAddress('glFrontFace');
11583 glHint := dglGetProcAddress('glHint');
11584 glLineWidth := dglGetProcAddress('glLineWidth');
11585 glPointSize := dglGetProcAddress('glPointSize');
11586 glPolygonMode := dglGetProcAddress('glPolygonMode');
11587 glScissor := dglGetProcAddress('glScissor');
11588 glTexParameterf := dglGetProcAddress('glTexParameterf');
11589 glTexParameterfv := dglGetProcAddress('glTexParameterfv');
11590 glTexParameteri := dglGetProcAddress('glTexParameteri');
11591 glTexParameteriv := dglGetProcAddress('glTexParameteriv');
11592 glTexImage1D := dglGetProcAddress('glTexImage1D');
11593 glTexImage2D := dglGetProcAddress('glTexImage2D');
11594 glDrawBuffer := dglGetProcAddress('glDrawBuffer');
11595 glClear := dglGetProcAddress('glClear');
11596 glClearColor := dglGetProcAddress('glClearColor');
11597 glClearStencil := dglGetProcAddress('glClearStencil');
11598 glClearDepth := dglGetProcAddress('glClearDepth');
11599 glStencilMask := dglGetProcAddress('glStencilMask');
11600 glColorMask := dglGetProcAddress('glColorMask');
11601 glDepthMask := dglGetProcAddress('glDepthMask');
11602 glDisable := dglGetProcAddress('glDisable');
11603 glEnable := dglGetProcAddress('glEnable');
11604 glFinish := dglGetProcAddress('glFinish');
11605 glFlush := dglGetProcAddress('glFlush');
11606 glBlendFunc := dglGetProcAddress('glBlendFunc');
11607 glLogicOp := dglGetProcAddress('glLogicOp');
11608 glStencilFunc := dglGetProcAddress('glStencilFunc');
11609 glStencilOp := dglGetProcAddress('glStencilOp');
11610 glDepthFunc := dglGetProcAddress('glDepthFunc');
11611 glPixelStoref := dglGetProcAddress('glPixelStoref');
11612 glPixelStorei := dglGetProcAddress('glPixelStorei');
11613 glReadBuffer := dglGetProcAddress('glReadBuffer');
11614 glReadPixels := dglGetProcAddress('glReadPixels');
11615 glGetBooleanv := dglGetProcAddress('glGetBooleanv');
11616 glGetDoublev := dglGetProcAddress('glGetDoublev');
11617 glGetError := dglGetProcAddress('glGetError');
11618 glGetFloatv := dglGetProcAddress('glGetFloatv');
11619 glGetIntegerv := dglGetProcAddress('glGetIntegerv');
11620 glGetString := dglGetProcAddress('glGetString');
11621 glGetTexImage := dglGetProcAddress('glGetTexImage');
11622 glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv');
11623 glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv');
11624 glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv');
11625 glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv');
11626 glIsEnabled := dglGetProcAddress('glIsEnabled');
11627 glDepthRange := dglGetProcAddress('glDepthRange');
11628 glViewport := dglGetProcAddress('glViewport');
11629
11630 // GL_VERSION_1_1
11631 glDrawArrays := dglGetProcAddress('glDrawArrays');
11632 glDrawElements := dglGetProcAddress('glDrawElements');
11633 glGetPointerv := dglGetProcAddress('glGetPointerv');
11634 glPolygonOffset := dglGetProcAddress('glPolygonOffset');
11635 glCopyTexImage1D := dglGetProcAddress('glCopyTexImage1D');
11636 glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D');
11637 glCopyTexSubImage1D := dglGetProcAddress('glCopyTexSubImage1D');
11638 glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D');
11639 glTexSubImage1D := dglGetProcAddress('glTexSubImage1D');
11640 glTexSubImage2D := dglGetProcAddress('glTexSubImage2D');
11641 glBindTexture := dglGetProcAddress('glBindTexture');
11642 glDeleteTextures := dglGetProcAddress('glDeleteTextures');
11643 glGenTextures := dglGetProcAddress('glGenTextures');
11644
11645 {$ifdef DGL_DEPRECATED}
11646 glAccum := dglGetProcAddress('glAccum');
11647 glAlphaFunc := dglGetProcAddress('glAlphaFunc');
11648 glAreTexturesResident := dglGetProcAddress('glAreTexturesResident');
11649 glArrayElement := dglGetProcAddress('glArrayElement');
11650 glBegin := dglGetProcAddress('glBegin');
11651 glBitmap := dglGetProcAddress('glBitmap');
11652 glCallList := dglGetProcAddress('glCallList');
11653 glCallLists := dglGetProcAddress('glCallLists');
11654 glClearAccum := dglGetProcAddress('glClearAccum');
11655 glClearIndex := dglGetProcAddress('glClearIndex');
11656 glClipPlane := dglGetProcAddress('glClipPlane');
11657 glColor3b := dglGetProcAddress('glColor3b');
11658 glColor3bv := dglGetProcAddress('glColor3bv');
11659 glColor3d := dglGetProcAddress('glColor3d');
11660 glColor3dv := dglGetProcAddress('glColor3dv');
11661 glColor3f := dglGetProcAddress('glColor3f');
11662 glColor3fv := dglGetProcAddress('glColor3fv');
11663 glColor3i := dglGetProcAddress('glColor3i');
11664 glColor3iv := dglGetProcAddress('glColor3iv');
11665 glColor3s := dglGetProcAddress('glColor3s');
11666 glColor3sv := dglGetProcAddress('glColor3sv');
11667 glColor3ub := dglGetProcAddress('glColor3ub');
11668 glColor3ubv := dglGetProcAddress('glColor3ubv');
11669 glColor3ui := dglGetProcAddress('glColor3ui');
11670 glColor3uiv := dglGetProcAddress('glColor3uiv');
11671 glColor3us := dglGetProcAddress('glColor3us');
11672 glColor3usv := dglGetProcAddress('glColor3usv');
11673 glColor4b := dglGetProcAddress('glColor4b');
11674 glColor4bv := dglGetProcAddress('glColor4bv');
11675 glColor4d := dglGetProcAddress('glColor4d');
11676 glColor4dv := dglGetProcAddress('glColor4dv');
11677 glColor4f := dglGetProcAddress('glColor4f');
11678 glColor4fv := dglGetProcAddress('glColor4fv');
11679 glColor4i := dglGetProcAddress('glColor4i');
11680 glColor4iv := dglGetProcAddress('glColor4iv');
11681 glColor4s := dglGetProcAddress('glColor4s');
11682 glColor4sv := dglGetProcAddress('glColor4sv');
11683 glColor4ub := dglGetProcAddress('glColor4ub');
11684 glColor4ubv := dglGetProcAddress('glColor4ubv');
11685 glColor4ui := dglGetProcAddress('glColor4ui');
11686 glColor4uiv := dglGetProcAddress('glColor4uiv');
11687 glColor4us := dglGetProcAddress('glColor4us');
11688 glColor4usv := dglGetProcAddress('glColor4usv');
11689 glColorMaterial := dglGetProcAddress('glColorMaterial');
11690 glColorPointer := dglGetProcAddress('glColorPointer');
11691 glCopyPixels := dglGetProcAddress('glCopyPixels');
11692 glDeleteLists := dglGetProcAddress('glDeleteLists');
11693 glDisableClientState := dglGetProcAddress('glDisableClientState');
11694 glDrawPixels := dglGetProcAddress('glDrawPixels');
11695 glEdgeFlag := dglGetProcAddress('glEdgeFlag');
11696 glEdgeFlagPointer := dglGetProcAddress('glEdgeFlagPointer');
11697 glEdgeFlagv := dglGetProcAddress('glEdgeFlagv');
11698 glEnableClientState := dglGetProcAddress('glEnableClientState');
11699 glEnd := dglGetProcAddress('glEnd');
11700 glEndList := dglGetProcAddress('glEndList');
11701 glEvalCoord1d := dglGetProcAddress('glEvalCoord1d');
11702 glEvalCoord1dv := dglGetProcAddress('glEvalCoord1dv');
11703 glEvalCoord1f := dglGetProcAddress('glEvalCoord1f');
11704 glEvalCoord1fv := dglGetProcAddress('glEvalCoord1fv');
11705 glEvalCoord2d := dglGetProcAddress('glEvalCoord2d');
11706 glEvalCoord2dv := dglGetProcAddress('glEvalCoord2dv');
11707 glEvalCoord2f := dglGetProcAddress('glEvalCoord2f');
11708 glEvalCoord2fv := dglGetProcAddress('glEvalCoord2fv');
11709 glEvalMesh1 := dglGetProcAddress('glEvalMesh1');
11710 glEvalMesh2 := dglGetProcAddress('glEvalMesh2');
11711 glEvalPoint1 := dglGetProcAddress('glEvalPoint1');
11712 glEvalPoint2 := dglGetProcAddress('glEvalPoint2');
11713 glFeedbackBuffer := dglGetProcAddress('glFeedbackBuffer');
11714 glFogf := dglGetProcAddress('glFogf');
11715 glFogfv := dglGetProcAddress('glFogfv');
11716 glFogi := dglGetProcAddress('glFogi');
11717 glFogiv := dglGetProcAddress('glFogiv');
11718 glFrustum := dglGetProcAddress('glFrustum');
11719 glGenLists := dglGetProcAddress('glGenLists');
11720 glGetClipPlane := dglGetProcAddress('glGetClipPlane');
11721 glGetLightfv := dglGetProcAddress('glGetLightfv');
11722 glGetLightiv := dglGetProcAddress('glGetLightiv');
11723 glGetMapdv := dglGetProcAddress('glGetMapdv');
11724 glGetMapfv := dglGetProcAddress('glGetMapfv');
11725 glGetMapiv := dglGetProcAddress('glGetMapiv');
11726 glGetMaterialfv := dglGetProcAddress('glGetMaterialfv');
11727 glGetMaterialiv := dglGetProcAddress('glGetMaterialiv');
11728 glGetPixelMapfv := dglGetProcAddress('glGetPixelMapfv');
11729 glGetPixelMapuiv := dglGetProcAddress('glGetPixelMapuiv');
11730 glGetPixelMapusv := dglGetProcAddress('glGetPixelMapusv');
11731 glGetPolygonStipple := dglGetProcAddress('glGetPolygonStipple');
11732 glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv');
11733 glGetTexEnviv := dglGetProcAddress('glGetTexEnviv');
11734 glGetTexGendv := dglGetProcAddress('glGetTexGendv');
11735 glGetTexGenfv := dglGetProcAddress('glGetTexGenfv');
11736 glGetTexGeniv := dglGetProcAddress('glGetTexGeniv');
11737 glIndexMask := dglGetProcAddress('glIndexMask');
11738 glIndexPointer := dglGetProcAddress('glIndexPointer');
11739 glIndexd := dglGetProcAddress('glIndexd');
11740 glIndexdv := dglGetProcAddress('glIndexdv');
11741 glIndexf := dglGetProcAddress('glIndexf');
11742 glIndexfv := dglGetProcAddress('glIndexfv');
11743 glIndexi := dglGetProcAddress('glIndexi');
11744 glIndexiv := dglGetProcAddress('glIndexiv');
11745 glIndexs := dglGetProcAddress('glIndexs');
11746 glIndexsv := dglGetProcAddress('glIndexsv');
11747 glIndexub := dglGetProcAddress('glIndexub');
11748 glIndexubv := dglGetProcAddress('glIndexubv');
11749 glInitNames := dglGetProcAddress('glInitNames');
11750 glInterleavedArrays := dglGetProcAddress('glInterleavedArrays');
11751 glIsList := dglGetProcAddress('glIsList');
11752 glIsTexture := dglGetProcAddress('glIsTexture');
11753 glLightModelf := dglGetProcAddress('glLightModelf');
11754 glLightModelfv := dglGetProcAddress('glLightModelfv');
11755 glLightModeli := dglGetProcAddress('glLightModeli');
11756 glLightModeliv := dglGetProcAddress('glLightModeliv');
11757 glLightf := dglGetProcAddress('glLightf');
11758 glLightfv := dglGetProcAddress('glLightfv');
11759 glLighti := dglGetProcAddress('glLighti');
11760 glLightiv := dglGetProcAddress('glLightiv');
11761 glLineStipple := dglGetProcAddress('glLineStipple');
11762 glListBase := dglGetProcAddress('glListBase');
11763 glLoadIdentity := dglGetProcAddress('glLoadIdentity');
11764 glLoadMatrixd := dglGetProcAddress('glLoadMatrixd');
11765 glLoadMatrixf := dglGetProcAddress('glLoadMatrixf');
11766 glLoadName := dglGetProcAddress('glLoadName');
11767 glMap1d := dglGetProcAddress('glMap1d');
11768 glMap1f := dglGetProcAddress('glMap1f');
11769 glMap2d := dglGetProcAddress('glMap2d');
11770 glMap2f := dglGetProcAddress('glMap2f');
11771 glMapGrid1d := dglGetProcAddress('glMapGrid1d');
11772 glMapGrid1f := dglGetProcAddress('glMapGrid1f');
11773 glMapGrid2d := dglGetProcAddress('glMapGrid2d');
11774 glMapGrid2f := dglGetProcAddress('glMapGrid2f');
11775 glMaterialf := dglGetProcAddress('glMaterialf');
11776 glMaterialfv := dglGetProcAddress('glMaterialfv');
11777 glMateriali := dglGetProcAddress('glMateriali');
11778 glMaterialiv := dglGetProcAddress('glMaterialiv');
11779 glMatrixMode := dglGetProcAddress('glMatrixMode');
11780 glMultMatrixd := dglGetProcAddress('glMultMatrixd');
11781 glMultMatrixf := dglGetProcAddress('glMultMatrixf');
11782 glNewList := dglGetProcAddress('glNewList');
11783 glNormal3b := dglGetProcAddress('glNormal3b');
11784 glNormal3bv := dglGetProcAddress('glNormal3bv');
11785 glNormal3d := dglGetProcAddress('glNormal3d');
11786 glNormal3dv := dglGetProcAddress('glNormal3dv');
11787 glNormal3f := dglGetProcAddress('glNormal3f');
11788 glNormal3fv := dglGetProcAddress('glNormal3fv');
11789 glNormal3i := dglGetProcAddress('glNormal3i');
11790 glNormal3iv := dglGetProcAddress('glNormal3iv');
11791 glNormal3s := dglGetProcAddress('glNormal3s');
11792 glNormal3sv := dglGetProcAddress('glNormal3sv');
11793 glNormalPointer := dglGetProcAddress('glNormalPointer');
11794 glOrtho := dglGetProcAddress('glOrtho');
11795 glPassThrough := dglGetProcAddress('glPassThrough');
11796 glPixelMapfv := dglGetProcAddress('glPixelMapfv');
11797 glPixelMapuiv := dglGetProcAddress('glPixelMapuiv');
11798 glPixelMapusv := dglGetProcAddress('glPixelMapusv');
11799 glPixelTransferf := dglGetProcAddress('glPixelTransferf');
11800 glPixelTransferi := dglGetProcAddress('glPixelTransferi');
11801 glPixelZoom := dglGetProcAddress('glPixelZoom');
11802 glPolygonStipple := dglGetProcAddress('glPolygonStipple');
11803 glPopAttrib := dglGetProcAddress('glPopAttrib');
11804 glPopClientAttrib := dglGetProcAddress('glPopClientAttrib');
11805 glPopMatrix := dglGetProcAddress('glPopMatrix');
11806 glPopName := dglGetProcAddress('glPopName');
11807 glPrioritizeTextures := dglGetProcAddress('glPrioritizeTextures');
11808 glPushAttrib := dglGetProcAddress('glPushAttrib');
11809 glPushClientAttrib := dglGetProcAddress('glPushClientAttrib');
11810 glPushMatrix := dglGetProcAddress('glPushMatrix');
11811 glPushName := dglGetProcAddress('glPushName');
11812 glRasterPos2d := dglGetProcAddress('glRasterPos2d');
11813 glRasterPos2dv := dglGetProcAddress('glRasterPos2dv');
11814 glRasterPos2f := dglGetProcAddress('glRasterPos2f');
11815 glRasterPos2fv := dglGetProcAddress('glRasterPos2fv');
11816 glRasterPos2i := dglGetProcAddress('glRasterPos2i');
11817 glRasterPos2iv := dglGetProcAddress('glRasterPos2iv');
11818 glRasterPos2s := dglGetProcAddress('glRasterPos2s');
11819 glRasterPos2sv := dglGetProcAddress('glRasterPos2sv');
11820 glRasterPos3d := dglGetProcAddress('glRasterPos3d');
11821 glRasterPos3dv := dglGetProcAddress('glRasterPos3dv');
11822 glRasterPos3f := dglGetProcAddress('glRasterPos3f');
11823 glRasterPos3fv := dglGetProcAddress('glRasterPos3fv');
11824 glRasterPos3i := dglGetProcAddress('glRasterPos3i');
11825 glRasterPos3iv := dglGetProcAddress('glRasterPos3iv');
11826 glRasterPos3s := dglGetProcAddress('glRasterPos3s');
11827 glRasterPos3sv := dglGetProcAddress('glRasterPos3sv');
11828 glRasterPos4d := dglGetProcAddress('glRasterPos4d');
11829 glRasterPos4dv := dglGetProcAddress('glRasterPos4dv');
11830 glRasterPos4f := dglGetProcAddress('glRasterPos4f');
11831 glRasterPos4fv := dglGetProcAddress('glRasterPos4fv');
11832 glRasterPos4i := dglGetProcAddress('glRasterPos4i');
11833 glRasterPos4iv := dglGetProcAddress('glRasterPos4iv');
11834 glRasterPos4s := dglGetProcAddress('glRasterPos4s');
11835 glRasterPos4sv := dglGetProcAddress('glRasterPos4sv');
11836 glRectd := dglGetProcAddress('glRectd');
11837 glRectdv := dglGetProcAddress('glRectdv');
11838 glRectf := dglGetProcAddress('glRectf');
11839 glRectfv := dglGetProcAddress('glRectfv');
11840 glRecti := dglGetProcAddress('glRecti');
11841 glRectiv := dglGetProcAddress('glRectiv');
11842 glRects := dglGetProcAddress('glRects');
11843 glRectsv := dglGetProcAddress('glRectsv');
11844 glRenderMode := dglGetProcAddress('glRenderMode');
11845 glRotated := dglGetProcAddress('glRotated');
11846 glRotatef := dglGetProcAddress('glRotatef');
11847 glScaled := dglGetProcAddress('glScaled');
11848 glScalef := dglGetProcAddress('glScalef');
11849 glSelectBuffer := dglGetProcAddress('glSelectBuffer');
11850 glShadeModel := dglGetProcAddress('glShadeModel');
11851 glTexCoord1d := dglGetProcAddress('glTexCoord1d');
11852 glTexCoord1dv := dglGetProcAddress('glTexCoord1dv');
11853 glTexCoord1f := dglGetProcAddress('glTexCoord1f');
11854 glTexCoord1fv := dglGetProcAddress('glTexCoord1fv');
11855 glTexCoord1i := dglGetProcAddress('glTexCoord1i');
11856 glTexCoord1iv := dglGetProcAddress('glTexCoord1iv');
11857 glTexCoord1s := dglGetProcAddress('glTexCoord1s');
11858 glTexCoord1sv := dglGetProcAddress('glTexCoord1sv');
11859 glTexCoord2d := dglGetProcAddress('glTexCoord2d');
11860 glTexCoord2dv := dglGetProcAddress('glTexCoord2dv');
11861 glTexCoord2f := dglGetProcAddress('glTexCoord2f');
11862 glTexCoord2fv := dglGetProcAddress('glTexCoord2fv');
11863 glTexCoord2i := dglGetProcAddress('glTexCoord2i');
11864 glTexCoord2iv := dglGetProcAddress('glTexCoord2iv');
11865 glTexCoord2s := dglGetProcAddress('glTexCoord2s');
11866 glTexCoord2sv := dglGetProcAddress('glTexCoord2sv');
11867 glTexCoord3d := dglGetProcAddress('glTexCoord3d');
11868 glTexCoord3dv := dglGetProcAddress('glTexCoord3dv');
11869 glTexCoord3f := dglGetProcAddress('glTexCoord3f');
11870 glTexCoord3fv := dglGetProcAddress('glTexCoord3fv');
11871 glTexCoord3i := dglGetProcAddress('glTexCoord3i');
11872 glTexCoord3iv := dglGetProcAddress('glTexCoord3iv');
11873 glTexCoord3s := dglGetProcAddress('glTexCoord3s');
11874 glTexCoord3sv := dglGetProcAddress('glTexCoord3sv');
11875 glTexCoord4d := dglGetProcAddress('glTexCoord4d');
11876 glTexCoord4dv := dglGetProcAddress('glTexCoord4dv');
11877 glTexCoord4f := dglGetProcAddress('glTexCoord4f');
11878 glTexCoord4fv := dglGetProcAddress('glTexCoord4fv');
11879 glTexCoord4i := dglGetProcAddress('glTexCoord4i');
11880 glTexCoord4iv := dglGetProcAddress('glTexCoord4iv');
11881 glTexCoord4s := dglGetProcAddress('glTexCoord4s');
11882 glTexCoord4sv := dglGetProcAddress('glTexCoord4sv');
11883 glTexCoordPointer := dglGetProcAddress('glTexCoordPointer');
11884 glTexEnvf := dglGetProcAddress('glTexEnvf');
11885 glTexEnvfv := dglGetProcAddress('glTexEnvfv');
11886 glTexEnvi := dglGetProcAddress('glTexEnvi');
11887 glTexEnviv := dglGetProcAddress('glTexEnviv');
11888 glTexGend := dglGetProcAddress('glTexGend');
11889 glTexGendv := dglGetProcAddress('glTexGendv');
11890 glTexGenf := dglGetProcAddress('glTexGenf');
11891 glTexGenfv := dglGetProcAddress('glTexGenfv');
11892 glTexGeni := dglGetProcAddress('glTexGeni');
11893 glTexGeniv := dglGetProcAddress('glTexGeniv');
11894 glTranslated := dglGetProcAddress('glTranslated');
11895 glTranslatef := dglGetProcAddress('glTranslatef');
11896 glVertex2d := dglGetProcAddress('glVertex2d');
11897 glVertex2dv := dglGetProcAddress('glVertex2dv');
11898 glVertex2f := dglGetProcAddress('glVertex2f');
11899 glVertex2fv := dglGetProcAddress('glVertex2fv');
11900 glVertex2i := dglGetProcAddress('glVertex2i');
11901 glVertex2iv := dglGetProcAddress('glVertex2iv');
11902 glVertex2s := dglGetProcAddress('glVertex2s');
11903 glVertex2sv := dglGetProcAddress('glVertex2sv');
11904 glVertex3d := dglGetProcAddress('glVertex3d');
11905 glVertex3dv := dglGetProcAddress('glVertex3dv');
11906 glVertex3f := dglGetProcAddress('glVertex3f');
11907 glVertex3fv := dglGetProcAddress('glVertex3fv');
11908 glVertex3i := dglGetProcAddress('glVertex3i');
11909 glVertex3iv := dglGetProcAddress('glVertex3iv');
11910 glVertex3s := dglGetProcAddress('glVertex3s');
11911 glVertex3sv := dglGetProcAddress('glVertex3sv');
11912 glVertex4d := dglGetProcAddress('glVertex4d');
11913 glVertex4dv := dglGetProcAddress('glVertex4dv');
11914 glVertex4f := dglGetProcAddress('glVertex4f');
11915 glVertex4fv := dglGetProcAddress('glVertex4fv');
11916 glVertex4i := dglGetProcAddress('glVertex4i');
11917 glVertex4iv := dglGetProcAddress('glVertex4iv');
11918 glVertex4s := dglGetProcAddress('glVertex4s');
11919 glVertex4sv := dglGetProcAddress('glVertex4sv');
11920 glVertexPointer := dglGetProcAddress('glVertexPointer');
11921 {$endif}
11922
11923 // GL_VERSION_1_2
11924 glBlendColor := dglGetProcAddress('glBlendColor');
11925 glBlendEquation := dglGetProcAddress('glBlendEquation');
11926 glDrawRangeElements := dglGetProcAddress('glDrawRangeElements');
11927 glTexImage3D := dglGetProcAddress('glTexImage3D');
11928 glTexSubImage3D := dglGetProcAddress('glTexSubImage3D');
11929 glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D');
11930 {$ifdef DGL_DEPRECATED}
11931 glColorTable := dglGetProcAddress('glColorTable');
11932 glColorTableParameterfv := dglGetProcAddress('glColorTableParameterfv');
11933 glColorTableParameteriv := dglGetProcAddress('glColorTableParameteriv');
11934 glCopyColorTable := dglGetProcAddress('glCopyColorTable');
11935 glGetColorTable := dglGetProcAddress('glGetColorTable');
11936 glGetColorTableParameterfv := dglGetProcAddress('glGetColorTableParameterfv');
11937 glGetColorTableParameteriv := dglGetProcAddress('glGetColorTableParameteriv');
11938 glColorSubTable := dglGetProcAddress('glColorSubTable');
11939 glCopyColorSubTable := dglGetProcAddress('glCopyColorSubTable');
11940 glConvolutionFilter1D := dglGetProcAddress('glConvolutionFilter1D');
11941 glConvolutionFilter2D := dglGetProcAddress('glConvolutionFilter2D');
11942 glConvolutionParameterf := dglGetProcAddress('glConvolutionParameterf');
11943 glConvolutionParameterfv := dglGetProcAddress('glConvolutionParameterfv');
11944 glConvolutionParameteri := dglGetProcAddress('glConvolutionParameteri');
11945 glConvolutionParameteriv := dglGetProcAddress('glConvolutionParameteriv');
11946 glCopyConvolutionFilter1D := dglGetProcAddress('glCopyConvolutionFilter1D');
11947 glCopyConvolutionFilter2D := dglGetProcAddress('glCopyConvolutionFilter2D');
11948 glGetConvolutionFilter := dglGetProcAddress('glGetConvolutionFilter');
11949 glGetConvolutionParameterfv := dglGetProcAddress('glGetConvolutionParameterfv');
11950 glGetConvolutionParameteriv := dglGetProcAddress('glGetConvolutionParameteriv');
11951 glGetSeparableFilter := dglGetProcAddress('glGetSeparableFilter');
11952 glSeparableFilter2D := dglGetProcAddress('glSeparableFilter2D');
11953 glGetHistogram := dglGetProcAddress('glGetHistogram');
11954 glGetHistogramParameterfv := dglGetProcAddress('glGetHistogramParameterfv');
11955 glGetHistogramParameteriv := dglGetProcAddress('glGetHistogramParameteriv');
11956 glGetMinmax := dglGetProcAddress('glGetMinmax');
11957 glGetMinmaxParameterfv := dglGetProcAddress('glGetMinmaxParameterfv');
11958 glGetMinmaxParameteriv := dglGetProcAddress('glGetMinmaxParameteriv');
11959 glHistogram := dglGetProcAddress('glHistogram');
11960 glMinmax := dglGetProcAddress('glMinmax');
11961 glResetHistogram := dglGetProcAddress('glResetHistogram');
11962 glResetMinmax := dglGetProcAddress('glResetMinmax');
11963 {$endif}
11964
11965 // GL_VERSION_1_3
11966 glActiveTexture := dglGetProcAddress('glActiveTexture');
11967 glSampleCoverage := dglGetProcAddress('glSampleCoverage');
11968 glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D');
11969 glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D');
11970 glCompressedTexImage1D := dglGetProcAddress('glCompressedTexImage1D');
11971 glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D');
11972 glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D');
11973 glCompressedTexSubImage1D := dglGetProcAddress('glCompressedTexSubImage1D');
11974 glGetCompressedTexImage := dglGetProcAddress('glGetCompressedTexImage');
11975 {$ifdef DGL_DEPRECATED}
11976 glClientActiveTexture := dglGetProcAddress('glClientActiveTexture');
11977 glMultiTexCoord1d := dglGetProcAddress('glMultiTexCoord1d');
11978 glMultiTexCoord1dv := dglGetProcAddress('glMultiTexCoord1dv');
11979 glMultiTexCoord1f := dglGetProcAddress('glMultiTexCoord1f');
11980 glMultiTexCoord1fv := dglGetProcAddress('glMultiTexCoord1fv');
11981 glMultiTexCoord1i := dglGetProcAddress('glMultiTexCoord1i');
11982 glMultiTexCoord1iv := dglGetProcAddress('glMultiTexCoord1iv');
11983 glMultiTexCoord1s := dglGetProcAddress('glMultiTexCoord1s');
11984 glMultiTexCoord1sv := dglGetProcAddress('glMultiTexCoord1sv');
11985 glMultiTexCoord2d := dglGetProcAddress('glMultiTexCoord2d');
11986 glMultiTexCoord2dv := dglGetProcAddress('glMultiTexCoord2dv');
11987 glMultiTexCoord2f := dglGetProcAddress('glMultiTexCoord2f');
11988 glMultiTexCoord2fv := dglGetProcAddress('glMultiTexCoord2fv');
11989 glMultiTexCoord2i := dglGetProcAddress('glMultiTexCoord2i');
11990 glMultiTexCoord2iv := dglGetProcAddress('glMultiTexCoord2iv');
11991 glMultiTexCoord2s := dglGetProcAddress('glMultiTexCoord2s');
11992 glMultiTexCoord2sv := dglGetProcAddress('glMultiTexCoord2sv');
11993 glMultiTexCoord3d := dglGetProcAddress('glMultiTexCoord3d');
11994 glMultiTexCoord3dv := dglGetProcAddress('glMultiTexCoord3dv');
11995 glMultiTexCoord3f := dglGetProcAddress('glMultiTexCoord3f');
11996 glMultiTexCoord3fv := dglGetProcAddress('glMultiTexCoord3fv');
11997 glMultiTexCoord3i := dglGetProcAddress('glMultiTexCoord3i');
11998 glMultiTexCoord3iv := dglGetProcAddress('glMultiTexCoord3iv');
11999 glMultiTexCoord3s := dglGetProcAddress('glMultiTexCoord3s');
12000 glMultiTexCoord3sv := dglGetProcAddress('glMultiTexCoord3sv');
12001 glMultiTexCoord4d := dglGetProcAddress('glMultiTexCoord4d');
12002 glMultiTexCoord4dv := dglGetProcAddress('glMultiTexCoord4dv');
12003 glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f');
12004 glMultiTexCoord4fv := dglGetProcAddress('glMultiTexCoord4fv');
12005 glMultiTexCoord4i := dglGetProcAddress('glMultiTexCoord4i');
12006 glMultiTexCoord4iv := dglGetProcAddress('glMultiTexCoord4iv');
12007 glMultiTexCoord4s := dglGetProcAddress('glMultiTexCoord4s');
12008 glMultiTexCoord4sv := dglGetProcAddress('glMultiTexCoord4sv');
12009 glLoadTransposeMatrixf := dglGetProcAddress('glLoadTransposeMatrixf');
12010 glLoadTransposeMatrixd := dglGetProcAddress('glLoadTransposeMatrixd');
12011 glMultTransposeMatrixf := dglGetProcAddress('glMultTransposeMatrixf');
12012 glMultTransposeMatrixd := dglGetProcAddress('glMultTransposeMatrixd');
12013 {$endif}
12014
12015 // GL_VERSION_1_4
12016 glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate');
12017 glMultiDrawArrays := dglGetProcAddress('glMultiDrawArrays');
12018 glMultiDrawElements := dglGetProcAddress('glMultiDrawElements');
12019 glPointParameterf := dglGetProcAddress('glPointParameterf');
12020 glPointParameterfv := dglGetProcAddress('glPointParameterfv');
12021 glPointParameteri := dglGetProcAddress('glPointParameteri');
12022 glPointParameteriv := dglGetProcAddress('glPointParameteriv');
12023 {$ifdef DGL_DEPRECATED}
12024 glFogCoordf := dglGetProcAddress('glFogCoordf');
12025 glFogCoordfv := dglGetProcAddress('glFogCoordfv');
12026 glFogCoordd := dglGetProcAddress('glFogCoordd');
12027 glFogCoorddv := dglGetProcAddress('glFogCoorddv');
12028 glFogCoordPointer := dglGetProcAddress('glFogCoordPointer');
12029 glSecondaryColor3b := dglGetProcAddress('glSecondaryColor3b');
12030 glSecondaryColor3bv := dglGetProcAddress('glSecondaryColor3bv');
12031 glSecondaryColor3d := dglGetProcAddress('glSecondaryColor3d');
12032 glSecondaryColor3dv := dglGetProcAddress('glSecondaryColor3dv');
12033 glSecondaryColor3f := dglGetProcAddress('glSecondaryColor3f');
12034 glSecondaryColor3fv := dglGetProcAddress('glSecondaryColor3fv');
12035 glSecondaryColor3i := dglGetProcAddress('glSecondaryColor3i');
12036 glSecondaryColor3iv := dglGetProcAddress('glSecondaryColor3iv');
12037 glSecondaryColor3s := dglGetProcAddress('glSecondaryColor3s');
12038 glSecondaryColor3sv := dglGetProcAddress('glSecondaryColor3sv');
12039 glSecondaryColor3ub := dglGetProcAddress('glSecondaryColor3ub');
12040 glSecondaryColor3ubv := dglGetProcAddress('glSecondaryColor3ubv');
12041 glSecondaryColor3ui := dglGetProcAddress('glSecondaryColor3ui');
12042 glSecondaryColor3uiv := dglGetProcAddress('glSecondaryColor3uiv');
12043 glSecondaryColor3us := dglGetProcAddress('glSecondaryColor3us');
12044 glSecondaryColor3usv := dglGetProcAddress('glSecondaryColor3usv');
12045 glSecondaryColorPointer := dglGetProcAddress('glSecondaryColorPointer');
12046 glWindowPos2d := dglGetProcAddress('glWindowPos2d');
12047 glWindowPos2dv := dglGetProcAddress('glWindowPos2dv');
12048 glWindowPos2f := dglGetProcAddress('glWindowPos2f');
12049 glWindowPos2fv := dglGetProcAddress('glWindowPos2fv');
12050 glWindowPos2i := dglGetProcAddress('glWindowPos2i');
12051 glWindowPos2iv := dglGetProcAddress('glWindowPos2iv');
12052 glWindowPos2s := dglGetProcAddress('glWindowPos2s');
12053 glWindowPos2sv := dglGetProcAddress('glWindowPos2sv');
12054 glWindowPos3d := dglGetProcAddress('glWindowPos3d');
12055 glWindowPos3dv := dglGetProcAddress('glWindowPos3dv');
12056 glWindowPos3f := dglGetProcAddress('glWindowPos3f');
12057 glWindowPos3fv := dglGetProcAddress('glWindowPos3fv');
12058 glWindowPos3i := dglGetProcAddress('glWindowPos3i');
12059 glWindowPos3iv := dglGetProcAddress('glWindowPos3iv');
12060 glWindowPos3s := dglGetProcAddress('glWindowPos3s');
12061 glWindowPos3sv := dglGetProcAddress('glWindowPos3sv');
12062 {$endif}
12063
12064 // GL_VERSION_1_5
12065 glGenQueries := dglGetProcAddress('glGenQueries');
12066 glDeleteQueries := dglGetProcAddress('glDeleteQueries');
12067 glIsQuery := dglGetProcAddress('glIsQuery');
12068 glBeginQuery := dglGetProcAddress('glBeginQuery');
12069 glEndQuery := dglGetProcAddress('glEndQuery');
12070 glGetQueryiv := dglGetProcAddress('glGetQueryiv');
12071 glGetQueryObjectiv := dglGetProcAddress('glGetQueryObjectiv');
12072 glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv');
12073 glBindBuffer := dglGetProcAddress('glBindBuffer');
12074 glDeleteBuffers := dglGetProcAddress('glDeleteBuffers');
12075 glGenBuffers := dglGetProcAddress('glGenBuffers');
12076 glIsBuffer := dglGetProcAddress('glIsBuffer');
12077 glBufferData := dglGetProcAddress('glBufferData');
12078 glBufferSubData := dglGetProcAddress('glBufferSubData');
12079 glGetBufferSubData := dglGetProcAddress('glGetBufferSubData');
12080 glMapBuffer := dglGetProcAddress('glMapBuffer');
12081 glUnmapBuffer := dglGetProcAddress('glUnmapBuffer');
12082 glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv');
12083 glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv');
12084
12085 // GL_VERSION_2_0
12086 glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate');
12087 glDrawBuffers := dglGetProcAddress('glDrawBuffers');
12088 glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate');
12089 glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate');
12090 glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate');
12091 glAttachShader := dglGetProcAddress('glAttachShader');
12092 glBindAttribLocation := dglGetProcAddress('glBindAttribLocation');
12093 glCompileShader := dglGetProcAddress('glCompileShader');
12094 glCreateProgram := dglGetProcAddress('glCreateProgram');
12095 glCreateShader := dglGetProcAddress('glCreateShader');
12096 glDeleteProgram := dglGetProcAddress('glDeleteProgram');
12097 glDeleteShader := dglGetProcAddress('glDeleteShader');
12098 glDetachShader := dglGetProcAddress('glDetachShader');
12099 glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray');
12100 glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray');
12101 glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib');
12102 glGetActiveUniform := dglGetProcAddress('glGetActiveUniform');
12103 glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders');
12104 glGetAttribLocation := dglGetProcAddress('glGetAttribLocation');
12105 glGetProgramiv := dglGetProcAddress('glGetProgramiv');
12106 glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog');
12107 glGetShaderiv := dglGetProcAddress('glGetShaderiv');
12108 glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog');
12109 glGetShaderSource := dglGetProcAddress('glGetShaderSource');
12110 glGetUniformLocation := dglGetProcAddress('glGetUniformLocation');
12111 glGetUniformfv := dglGetProcAddress('glGetUniformfv');
12112 glGetUniformiv := dglGetProcAddress('glGetUniformiv');
12113 glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv');
12114 glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv');
12115 glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv');
12116 glIsProgram := dglGetProcAddress('glIsProgram');
12117 glIsShader := dglGetProcAddress('glIsShader');
12118 glLinkProgram := dglGetProcAddress('glLinkProgram');
12119 glShaderSource := dglGetProcAddress('glShaderSource');
12120 glUseProgram := dglGetProcAddress('glUseProgram');
12121 glUniform1f := dglGetProcAddress('glUniform1f');
12122 glUniform2f := dglGetProcAddress('glUniform2f');
12123 glUniform3f := dglGetProcAddress('glUniform3f');
12124 glUniform4f := dglGetProcAddress('glUniform4f');
12125 glUniform1i := dglGetProcAddress('glUniform1i');
12126 glUniform2i := dglGetProcAddress('glUniform2i');
12127 glUniform3i := dglGetProcAddress('glUniform3i');
12128 glUniform4i := dglGetProcAddress('glUniform4i');
12129 glUniform1fv := dglGetProcAddress('glUniform1fv');
12130 glUniform2fv := dglGetProcAddress('glUniform2fv');
12131 glUniform3fv := dglGetProcAddress('glUniform3fv');
12132 glUniform4fv := dglGetProcAddress('glUniform4fv');
12133 glUniform1iv := dglGetProcAddress('glUniform1iv');
12134 glUniform2iv := dglGetProcAddress('glUniform2iv');
12135 glUniform3iv := dglGetProcAddress('glUniform3iv');
12136 glUniform4iv := dglGetProcAddress('glUniform4iv');
12137 glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv');
12138 glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv');
12139 glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv');
12140 glValidateProgram := dglGetProcAddress('glValidateProgram');
12141 glVertexAttrib1d := dglGetProcAddress('glVertexAttrib1d');
12142 glVertexAttrib1dv := dglGetProcAddress('glVertexAttrib1dv');
12143 glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f');
12144 glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv');
12145 glVertexAttrib1s := dglGetProcAddress('glVertexAttrib1s');
12146 glVertexAttrib1sv := dglGetProcAddress('glVertexAttrib1sv');
12147 glVertexAttrib2d := dglGetProcAddress('glVertexAttrib2d');
12148 glVertexAttrib2dv := dglGetProcAddress('glVertexAttrib2dv');
12149 glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f');
12150 glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv');
12151 glVertexAttrib2s := dglGetProcAddress('glVertexAttrib2s');
12152 glVertexAttrib2sv := dglGetProcAddress('glVertexAttrib2sv');
12153 glVertexAttrib3d := dglGetProcAddress('glVertexAttrib3d');
12154 glVertexAttrib3dv := dglGetProcAddress('glVertexAttrib3dv');
12155 glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f');
12156 glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv');
12157 glVertexAttrib3s := dglGetProcAddress('glVertexAttrib3s');
12158 glVertexAttrib3sv := dglGetProcAddress('glVertexAttrib3sv');
12159 glVertexAttrib4Nbv := dglGetProcAddress('glVertexAttrib4Nbv');
12160 glVertexAttrib4Niv := dglGetProcAddress('glVertexAttrib4Niv');
12161 glVertexAttrib4Nsv := dglGetProcAddress('glVertexAttrib4Nsv');
12162 glVertexAttrib4Nub := dglGetProcAddress('glVertexAttrib4Nub');
12163 glVertexAttrib4Nubv := dglGetProcAddress('glVertexAttrib4Nubv');
12164 glVertexAttrib4Nuiv := dglGetProcAddress('glVertexAttrib4Nuiv');
12165 glVertexAttrib4Nusv := dglGetProcAddress('glVertexAttrib4Nusv');
12166 glVertexAttrib4bv := dglGetProcAddress('glVertexAttrib4bv');
12167 glVertexAttrib4d := dglGetProcAddress('glVertexAttrib4d');
12168 glVertexAttrib4dv := dglGetProcAddress('glVertexAttrib4dv');
12169 glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f');
12170 glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv');
12171 glVertexAttrib4iv := dglGetProcAddress('glVertexAttrib4iv');
12172 glVertexAttrib4s := dglGetProcAddress('glVertexAttrib4s');
12173 glVertexAttrib4sv := dglGetProcAddress('glVertexAttrib4sv');
12174 glVertexAttrib4ubv := dglGetProcAddress('glVertexAttrib4ubv');
12175 glVertexAttrib4uiv := dglGetProcAddress('glVertexAttrib4uiv');
12176 glVertexAttrib4usv := dglGetProcAddress('glVertexAttrib4usv');
12177 glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer');
12178
12179 // GL_VERSION_2_1
12180 glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv');
12181 glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv');
12182 glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv');
12183 glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv');
12184 glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv');
12185 glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv');
12186
12187 // GL_VERSION_3_0
12188 { OpenGL 3.0 also reuses entry points from these extensions: }
12189 Read_GL_ARB_framebuffer_object;
12190 Read_GL_ARB_map_buffer_range;
12191 Read_GL_ARB_vertex_array_object;
12192
12193 glColorMaski := dglGetProcAddress('glColorMaski');
12194 glGetBooleani_v := dglGetProcAddress('glGetBooleani_v');
12195 glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v');
12196 glEnablei := dglGetProcAddress('glEnablei');
12197 glDisablei := dglGetProcAddress('glDisablei');
12198 glIsEnabledi := dglGetProcAddress('glIsEnabledi');
12199 glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback');
12200 glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback');
12201 glBindBufferRange := dglGetProcAddress('glBindBufferRange');
12202 glBindBufferBase := dglGetProcAddress('glBindBufferBase');
12203 glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings');
12204 glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying');
12205 glClampColor := dglGetProcAddress('glClampColor');
12206 glBeginConditionalRender := dglGetProcAddress('glBeginConditionalRender');
12207 glEndConditionalRender := dglGetProcAddress('glEndConditionalRender');
12208 glVertexAttribI1i := dglGetProcAddress('glVertexAttribI1i');
12209 glVertexAttribI2i := dglGetProcAddress('glVertexAttribI2i');
12210 glVertexAttribI3i := dglGetProcAddress('glVertexAttribI3i');
12211 glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i');
12212 glVertexAttribI1ui := dglGetProcAddress('glVertexAttribI1ui');
12213 glVertexAttribI2ui := dglGetProcAddress('glVertexAttribI2ui');
12214 glVertexAttribI3ui := dglGetProcAddress('glVertexAttribI3ui');
12215 glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui');
12216 glVertexAttribI1iv := dglGetProcAddress('glVertexAttribI1iv');
12217 glVertexAttribI2iv := dglGetProcAddress('glVertexAttribI2iv');
12218 glVertexAttribI3iv := dglGetProcAddress('glVertexAttribI3iv');
12219 glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv');
12220 glVertexAttribI1uiv := dglGetProcAddress('glVertexAttribI1uiv');
12221 glVertexAttribI2uiv := dglGetProcAddress('glVertexAttribI2uiv');
12222 glVertexAttribI3uiv := dglGetProcAddress('glVertexAttribI3uiv');
12223 glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv');
12224 glVertexAttribI4bv := dglGetProcAddress('glVertexAttribI4bv');
12225 glVertexAttribI4sv := dglGetProcAddress('glVertexAttribI4sv');
12226 glVertexAttribI4ubv := dglGetProcAddress('glVertexAttribI4ubv');
12227 glVertexAttribI4usv := dglGetProcAddress('glVertexAttribI4usv');
12228 glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer');
12229 glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv');
12230 glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv');
12231 glGetUniformuiv := dglGetProcAddress('glGetUniformuiv');
12232 glBindFragDataLocation := dglGetProcAddress('glBindFragDataLocation');
12233 glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation');
12234 glUniform1ui := dglGetProcAddress('glUniform1ui');
12235 glUniform2ui := dglGetProcAddress('glUniform2ui');
12236 glUniform3ui := dglGetProcAddress('glUniform3ui');
12237 glUniform4ui := dglGetProcAddress('glUniform4ui');
12238 glUniform1uiv := dglGetProcAddress('glUniform1uiv');
12239 glUniform2uiv := dglGetProcAddress('glUniform2uiv');
12240 glUniform3uiv := dglGetProcAddress('glUniform3uiv');
12241 glUniform4uiv := dglGetProcAddress('glUniform4uiv');
12242 glTexParameterIiv := dglGetProcAddress('glTexParameterIiv');
12243 glTexParameterIuiv := dglGetProcAddress('glTexParameterIuiv');
12244 glGetTexParameterIiv := dglGetProcAddress('glGetTexParameterIiv');
12245 glGetTexParameterIuiv := dglGetProcAddress('glGetTexParameterIuiv');
12246 glClearBufferiv := dglGetProcAddress('glClearBufferiv');
12247 glClearBufferuiv := dglGetProcAddress('glClearBufferuiv');
12248 glClearBufferfv := dglGetProcAddress('glClearBufferfv');
12249 glClearBufferfi := dglGetProcAddress('glClearBufferfi');
12250 glGetStringi := dglGetProcAddress('glGetStringi');
12251
12252 // GL_VERSION_3_1
12253 { OpenGL 3.1 also reuses entry points from these extensions: }
12254 Read_GL_ARB_copy_buffer;
12255 Read_GL_ARB_uniform_buffer_object;
12256
12257 glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced');
12258 glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced');
12259 glTexBuffer := dglGetProcAddress('glTexBuffer');
12260 glPrimitiveRestartIndex := dglGetProcAddress('glPrimitiveRestartIndex');
12261
12262 // GL_VERSION_3_2
12263 { OpenGL 3.2 also reuses entry points from these extensions: }
12264 Read_GL_ARB_draw_elements_base_vertex;
12265 Read_GL_ARB_provoking_vertex;
12266 Read_GL_ARB_sync;
12267 Read_GL_ARB_texture_multisample;
12268
12269 glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v');
12270 glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v');
12271 glProgramParameteri := dglGetProcAddress('glProgramParameteri');
12272 glFramebufferTexture := dglGetProcAddress('glFramebufferTexture');
12273 glFramebufferTextureFace := dglGetProcAddress('glFramebufferTextureFace');
12274 end;
12275
12276 procedure Read_GL_3DFX_tbuffer;
12277 begin
12278 glTbufferMask3DFX := dglGetProcAddress('glTbufferMask3DFX');
12279 end;
12280
12281 procedure Read_GL_APPLE_element_array;
12282 begin
12283 glElementPointerAPPLE := dglGetProcAddress('glElementPointerAPPLE');
12284 glDrawElementArrayAPPLE := dglGetProcAddress('glDrawElementArrayAPPLE');
12285 glDrawRangeElementArrayAPPLE := dglGetProcAddress('glDrawRangeElementArrayAPPLE');
12286 glMultiDrawElementArrayAPPLE := dglGetProcAddress('glMultiDrawElementArrayAPPLE');
12287 glMultiDrawRangeElementArrayAPPLE := dglGetProcAddress('glMultiDrawRangeElementArrayAPPLE');
12288 end;
12289
12290 procedure Read_GL_APPLE_fence;
12291 begin
12292 glGenFencesAPPLE := dglGetProcAddress('glGenFencesAPPLE');
12293 glDeleteFencesAPPLE := dglGetProcAddress('glDeleteFencesAPPLE');
12294 glSetFenceAPPLE := dglGetProcAddress('glSetFenceAPPLE');
12295 glIsFenceAPPLE := dglGetProcAddress('glIsFenceAPPLE');
12296 glTestFenceAPPLE := dglGetProcAddress('glTestFenceAPPLE');
12297 glFinishFenceAPPLE := dglGetProcAddress('glFinishFenceAPPLE');
12298 glTestObjectAPPLE := dglGetProcAddress('glTestObjectAPPLE');
12299 glFinishObjectAPPLE := dglGetProcAddress('glFinishObjectAPPLE');
12300 end;
12301
12302 procedure Read_GL_APPLE_vertex_array_object;
12303 begin
12304 glBindVertexArrayAPPLE := dglGetProcAddress('glBindVertexArrayAPPLE');
12305 glDeleteVertexArraysAPPLE := dglGetProcAddress('glDeleteVertexArraysAPPLE');
12306 glGenVertexArraysAPPLE := dglGetProcAddress('glGenVertexArraysAPPLE');
12307 glIsVertexArrayAPPLE := dglGetProcAddress('glIsVertexArrayAPPLE');
12308 end;
12309
12310 procedure Read_GL_APPLE_vertex_array_range;
12311 begin
12312 glVertexArrayRangeAPPLE := dglGetProcAddress('glVertexArrayRangeAPPLE');
12313 glFlushVertexArrayRangeAPPLE := dglGetProcAddress('glFlushVertexArrayRangeAPPLE');
12314 glVertexArrayParameteriAPPLE := dglGetProcAddress('glVertexArrayParameteriAPPLE');
12315 end;
12316
12317 procedure Read_GL_APPLE_texture_range;
12318 begin
12319 glTextureRangeAPPLE := dglGetProcAddress('glTextureRangeAPPLE');
12320 glGetTexParameterPointervAPPLE := dglGetProcAddress('glGetTexParameterPointervAPPLE');
12321 end;
12322
12323 procedure Read_GL_APPLE_vertex_program_evaluators;
12324 begin
12325 glEnableVertexAttribAPPLE := dglGetProcAddress('glEnableVertexAttribAPPLE');
12326 glDisableVertexAttribAPPLE := dglGetProcAddress('glDisableVertexAttribAPPLE');
12327 glIsVertexAttribEnabledAPPLE := dglGetProcAddress('glIsVertexAttribEnabledAPPLE');
12328 glMapVertexAttrib1dAPPLE := dglGetProcAddress('glMapVertexAttrib1dAPPLE');
12329 glMapVertexAttrib1fAPPLE := dglGetProcAddress('glMapVertexAttrib1fAPPLE');
12330 glMapVertexAttrib2dAPPLE := dglGetProcAddress('glMapVertexAttrib2dAPPLE');
12331 glMapVertexAttrib2fAPPLE := dglGetProcAddress('glMapVertexAttrib2fAPPLE');
12332 end;
12333
12334 procedure Read_GL_APPLE_object_purgeable;
12335 begin
12336 glObjectPurgeableAPPLE := dglGetProcAddress('glObjectPurgeableAPPLE');
12337 glObjectUnpurgeableAPPLE := dglGetProcAddress('glObjectUnpurgeableAPPLE');
12338 glGetObjectParameterivAPPLE := dglGetProcAddress('glGetObjectParameterivAPPLE');
12339 end;
12340
12341 procedure Read_GL_ARB_matrix_palette;
12342 begin
12343 glCurrentPaletteMatrixARB := dglGetProcAddress('glCurrentPaletteMatrixARB');
12344 glMatrixIndexubvARB := dglGetProcAddress('glMatrixIndexubvARB');
12345 glMatrixIndexusvARB := dglGetProcAddress('glMatrixIndexusvARB');
12346 glMatrixIndexuivARB := dglGetProcAddress('glMatrixIndexuivARB');
12347 glMatrixIndexPointerARB := dglGetProcAddress('glMatrixIndexPointerARB');
12348 end;
12349
12350 procedure Read_GL_ARB_multisample;
12351 begin
12352 glSampleCoverageARB := dglGetProcAddress('glSampleCoverageARB');
12353 end;
12354
12355 procedure Read_GL_ARB_multitexture;
12356 begin
12357 glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
12358 glClientActiveTextureARB := dglGetProcAddress('glClientActiveTextureARB');
12359 glMultiTexCoord1dARB := dglGetProcAddress('glMultiTexCoord1dARB');
12360 glMultiTexCoord1dvARB := dglGetProcAddress('glMultiTexCoord1dvARB');
12361 glMultiTexCoord1fARB := dglGetProcAddress('glMultiTexCoord1fARB');
12362 glMultiTexCoord1fvARB := dglGetProcAddress('glMultiTexCoord1fvARB');
12363 glMultiTexCoord1iARB := dglGetProcAddress('glMultiTexCoord1iARB');
12364 glMultiTexCoord1ivARB := dglGetProcAddress('glMultiTexCoord1ivARB');
12365 glMultiTexCoord1sARB := dglGetProcAddress('glMultiTexCoord1sARB');
12366 glMultiTexCoord1svARB := dglGetProcAddress('glMultiTexCoord1svARB');
12367 glMultiTexCoord2dARB := dglGetProcAddress('glMultiTexCoord2dARB');
12368 glMultiTexCoord2dvARB := dglGetProcAddress('glMultiTexCoord2dvARB');
12369 glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
12370 glMultiTexCoord2fvARB := dglGetProcAddress('glMultiTexCoord2fvARB');
12371 glMultiTexCoord2iARB := dglGetProcAddress('glMultiTexCoord2iARB');
12372 glMultiTexCoord2ivARB := dglGetProcAddress('glMultiTexCoord2ivARB');
12373 glMultiTexCoord2sARB := dglGetProcAddress('glMultiTexCoord2sARB');
12374 glMultiTexCoord2svARB := dglGetProcAddress('glMultiTexCoord2svARB');
12375 glMultiTexCoord3dARB := dglGetProcAddress('glMultiTexCoord3dARB');
12376 glMultiTexCoord3dvARB := dglGetProcAddress('glMultiTexCoord3dvARB');
12377 glMultiTexCoord3fARB := dglGetProcAddress('glMultiTexCoord3fARB');
12378 glMultiTexCoord3fvARB := dglGetProcAddress('glMultiTexCoord3fvARB');
12379 glMultiTexCoord3iARB := dglGetProcAddress('glMultiTexCoord3iARB');
12380 glMultiTexCoord3ivARB := dglGetProcAddress('glMultiTexCoord3ivARB');
12381 glMultiTexCoord3sARB := dglGetProcAddress('glMultiTexCoord3sARB');
12382 glMultiTexCoord3svARB := dglGetProcAddress('glMultiTexCoord3svARB');
12383 glMultiTexCoord4dARB := dglGetProcAddress('glMultiTexCoord4dARB');
12384 glMultiTexCoord4dvARB := dglGetProcAddress('glMultiTexCoord4dvARB');
12385 glMultiTexCoord4fARB := dglGetProcAddress('glMultiTexCoord4fARB');
12386 glMultiTexCoord4fvARB := dglGetProcAddress('glMultiTexCoord4fvARB');
12387 glMultiTexCoord4iARB := dglGetProcAddress('glMultiTexCoord4iARB');
12388 glMultiTexCoord4ivARB := dglGetProcAddress('glMultiTexCoord4ivARB');
12389 glMultiTexCoord4sARB := dglGetProcAddress('glMultiTexCoord4sARB');
12390 glMultiTexCoord4svARB := dglGetProcAddress('glMultiTexCoord4svARB');
12391 end;
12392
12393 procedure Read_GL_ARB_point_parameters;
12394 begin
12395 glPointParameterfARB := dglGetProcAddress('glPointParameterfARB');
12396 glPointParameterfvARB := dglGetProcAddress('glPointParameterfvARB');
12397 end;
12398
12399 procedure Read_GL_ARB_texture_compression;
12400 begin
12401 glCompressedTexImage3DARB := dglGetProcAddress('glCompressedTexImage3DARB');
12402 glCompressedTexImage2DARB := dglGetProcAddress('glCompressedTexImage2DARB');
12403 glCompressedTexImage1DARB := dglGetProcAddress('glCompressedTexImage1DARB');
12404 glCompressedTexSubImage3DARB := dglGetProcAddress('glCompressedTexSubImage3DARB');
12405 glCompressedTexSubImage2DARB := dglGetProcAddress('glCompressedTexSubImage2DARB');
12406 glCompressedTexSubImage1DARB := dglGetProcAddress('glCompressedTexSubImage1DARB');
12407 glGetCompressedTexImageARB := dglGetProcAddress('glGetCompressedTexImageARB');
12408 end;
12409
12410 procedure Read_GL_ARB_transpose_matrix;
12411 begin
12412 glLoadTransposeMatrixfARB := dglGetProcAddress('glLoadTransposeMatrixfARB');
12413 glLoadTransposeMatrixdARB := dglGetProcAddress('glLoadTransposeMatrixdARB');
12414 glMultTransposeMatrixfARB := dglGetProcAddress('glMultTransposeMatrixfARB');
12415 glMultTransposeMatrixdARB := dglGetProcAddress('glMultTransposeMatrixdARB');
12416 end;
12417
12418 procedure Read_GL_ARB_vertex_blend;
12419 begin
12420 glWeightbvARB := dglGetProcAddress('glWeightbvARB');
12421 glWeightsvARB := dglGetProcAddress('glWeightsvARB');
12422 glWeightivARB := dglGetProcAddress('glWeightivARB');
12423 glWeightfvARB := dglGetProcAddress('glWeightfvARB');
12424 glWeightdvARB := dglGetProcAddress('glWeightdvARB');
12425 glWeightubvARB := dglGetProcAddress('glWeightubvARB');
12426 glWeightusvARB := dglGetProcAddress('glWeightusvARB');
12427 glWeightuivARB := dglGetProcAddress('glWeightuivARB');
12428 glWeightPointerARB := dglGetProcAddress('glWeightPointerARB');
12429 glVertexBlendARB := dglGetProcAddress('glVertexBlendARB');
12430 end;
12431
12432 procedure Read_GL_ARB_vertex_buffer_object;
12433 begin
12434 glBindBufferARB := dglGetProcAddress('glBindBufferARB');
12435 glDeleteBuffersARB := dglGetProcAddress('glDeleteBuffersARB');
12436 glGenBuffersARB := dglGetProcAddress('glGenBuffersARB');
12437 glIsBufferARB := dglGetProcAddress('glIsBufferARB');
12438 glBufferDataARB := dglGetProcAddress('glBufferDataARB');
12439 glBufferSubDataARB := dglGetProcAddress('glBufferSubDataARB');
12440 glGetBufferSubDataARB := dglGetProcAddress('glGetBufferSubDataARB');
12441 glMapBufferARB := dglGetProcAddress('glMapBufferARB');
12442 glUnmapBufferARB := dglGetProcAddress('glUnmapBufferARB');
12443 glGetBufferParameterivARB := dglGetProcAddress('glGetBufferParameterivARB');
12444 glGetBufferPointervARB := dglGetProcAddress('glGetBufferPointervARB');
12445 end;
12446
12447 procedure Read_GL_ARB_vertex_program;
12448 begin
12449 glVertexAttrib1dARB := dglGetProcAddress('glVertexAttrib1dARB');
12450 glVertexAttrib1dvARB := dglGetProcAddress('glVertexAttrib1dvARB');
12451 glVertexAttrib1fARB := dglGetProcAddress('glVertexAttrib1fARB');
12452 glVertexAttrib1fvARB := dglGetProcAddress('glVertexAttrib1fvARB');
12453 glVertexAttrib1sARB := dglGetProcAddress('glVertexAttrib1sARB');
12454 glVertexAttrib1svARB := dglGetProcAddress('glVertexAttrib1svARB');
12455 glVertexAttrib2dARB := dglGetProcAddress('glVertexAttrib2dARB');
12456 glVertexAttrib2dvARB := dglGetProcAddress('glVertexAttrib2dvARB');
12457 glVertexAttrib2fARB := dglGetProcAddress('glVertexAttrib2fARB');
12458 glVertexAttrib2fvARB := dglGetProcAddress('glVertexAttrib2fvARB');
12459 glVertexAttrib2sARB := dglGetProcAddress('glVertexAttrib2sARB');
12460 glVertexAttrib2svARB := dglGetProcAddress('glVertexAttrib2svARB');
12461 glVertexAttrib3dARB := dglGetProcAddress('glVertexAttrib3dARB');
12462 glVertexAttrib3dvARB := dglGetProcAddress('glVertexAttrib3dvARB');
12463 glVertexAttrib3fARB := dglGetProcAddress('glVertexAttrib3fARB');
12464 glVertexAttrib3fvARB := dglGetProcAddress('glVertexAttrib3fvARB');
12465 glVertexAttrib3sARB := dglGetProcAddress('glVertexAttrib3sARB');
12466 glVertexAttrib3svARB := dglGetProcAddress('glVertexAttrib3svARB');
12467 glVertexAttrib4NbvARB := dglGetProcAddress('glVertexAttrib4NbvARB');
12468 glVertexAttrib4NivARB := dglGetProcAddress('glVertexAttrib4NivARB');
12469 glVertexAttrib4NsvARB := dglGetProcAddress('glVertexAttrib4NsvARB');
12470 glVertexAttrib4NubARB := dglGetProcAddress('glVertexAttrib4NubARB');
12471 glVertexAttrib4NubvARB := dglGetProcAddress('glVertexAttrib4NubvARB');
12472 glVertexAttrib4NuivARB := dglGetProcAddress('glVertexAttrib4NuivARB');
12473 glVertexAttrib4NusvARB := dglGetProcAddress('glVertexAttrib4NusvARB');
12474 glVertexAttrib4bvARB := dglGetProcAddress('glVertexAttrib4bvARB');
12475 glVertexAttrib4dARB := dglGetProcAddress('glVertexAttrib4dARB');
12476 glVertexAttrib4dvARB := dglGetProcAddress('glVertexAttrib4dvARB');
12477 glVertexAttrib4fARB := dglGetProcAddress('glVertexAttrib4fARB');
12478 glVertexAttrib4fvARB := dglGetProcAddress('glVertexAttrib4fvARB');
12479 glVertexAttrib4ivARB := dglGetProcAddress('glVertexAttrib4ivARB');
12480 glVertexAttrib4sARB := dglGetProcAddress('glVertexAttrib4sARB');
12481 glVertexAttrib4svARB := dglGetProcAddress('glVertexAttrib4svARB');
12482 glVertexAttrib4ubvARB := dglGetProcAddress('glVertexAttrib4ubvARB');
12483 glVertexAttrib4uivARB := dglGetProcAddress('glVertexAttrib4uivARB');
12484 glVertexAttrib4usvARB := dglGetProcAddress('glVertexAttrib4usvARB');
12485 glVertexAttribPointerARB := dglGetProcAddress('glVertexAttribPointerARB');
12486 glEnableVertexAttribArrayARB := dglGetProcAddress('glEnableVertexAttribArrayARB');
12487 glDisableVertexAttribArrayARB := dglGetProcAddress('glDisableVertexAttribArrayARB');
12488 glProgramStringARB := dglGetProcAddress('glProgramStringARB');
12489 glBindProgramARB := dglGetProcAddress('glBindProgramARB');
12490 glDeleteProgramsARB := dglGetProcAddress('glDeleteProgramsARB');
12491 glGenProgramsARB := dglGetProcAddress('glGenProgramsARB');
12492 glProgramEnvParameter4dARB := dglGetProcAddress('glProgramEnvParameter4dARB');
12493 glProgramEnvParameter4dvARB := dglGetProcAddress('glProgramEnvParameter4dvARB');
12494 glProgramEnvParameter4fARB := dglGetProcAddress('glProgramEnvParameter4fARB');
12495 glProgramEnvParameter4fvARB := dglGetProcAddress('glProgramEnvParameter4fvARB');
12496 glProgramLocalParameter4dARB := dglGetProcAddress('glProgramLocalParameter4dARB');
12497 glProgramLocalParameter4dvARB := dglGetProcAddress('glProgramLocalParameter4dvARB');
12498 glProgramLocalParameter4fARB := dglGetProcAddress('glProgramLocalParameter4fARB');
12499 glProgramLocalParameter4fvARB := dglGetProcAddress('glProgramLocalParameter4fvARB');
12500 glGetProgramEnvParameterdvARB := dglGetProcAddress('glGetProgramEnvParameterdvARB');
12501 glGetProgramEnvParameterfvARB := dglGetProcAddress('glGetProgramEnvParameterfvARB');
12502 glGetProgramLocalParameterdvARB := dglGetProcAddress('glGetProgramLocalParameterdvARB');
12503 glGetProgramLocalParameterfvARB := dglGetProcAddress('glGetProgramLocalParameterfvARB');
12504 glGetProgramivARB := dglGetProcAddress('glGetProgramivARB');
12505 glGetProgramStringARB := dglGetProcAddress('glGetProgramStringARB');
12506 glGetVertexAttribdvARB := dglGetProcAddress('glGetVertexAttribdvARB');
12507 glGetVertexAttribfvARB := dglGetProcAddress('glGetVertexAttribfvARB');
12508 glGetVertexAttribivARB := dglGetProcAddress('glGetVertexAttribivARB');
12509 glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
12510 glIsProgramARB := dglGetProcAddress('glIsProgramARB');
12511 end;
12512
12513 procedure Read_GL_ARB_window_pos;
12514 begin
12515 glWindowPos2dARB := dglGetProcAddress('glWindowPos2dARB');
12516 glWindowPos2dvARB := dglGetProcAddress('glWindowPos2dvARB');
12517 glWindowPos2fARB := dglGetProcAddress('glWindowPos2fARB');
12518 glWindowPos2fvARB := dglGetProcAddress('glWindowPos2fvARB');
12519 glWindowPos2iARB := dglGetProcAddress('glWindowPos2iARB');
12520 glWindowPos2ivARB := dglGetProcAddress('glWindowPos2ivARB');
12521 glWindowPos2sARB := dglGetProcAddress('glWindowPos2sARB');
12522 glWindowPos2svARB := dglGetProcAddress('glWindowPos2svARB');
12523 glWindowPos3dARB := dglGetProcAddress('glWindowPos3dARB');
12524 glWindowPos3dvARB := dglGetProcAddress('glWindowPos3dvARB');
12525 glWindowPos3fARB := dglGetProcAddress('glWindowPos3fARB');
12526 glWindowPos3fvARB := dglGetProcAddress('glWindowPos3fvARB');
12527 glWindowPos3iARB := dglGetProcAddress('glWindowPos3iARB');
12528 glWindowPos3ivARB := dglGetProcAddress('glWindowPos3ivARB');
12529 glWindowPos3sARB := dglGetProcAddress('glWindowPos3sARB');
12530 glWindowPos3svARB := dglGetProcAddress('glWindowPos3svARB');
12531 end;
12532
12533 procedure Read_GL_ARB_draw_buffers;
12534 begin
12535 glDrawBuffersARB := dglGetProcAddress('glDrawBuffersARB');
12536 end;
12537
12538 procedure Read_GL_ARB_color_buffer_float;
12539 begin
12540 glClampColorARB := dglGetProcAddress('glClampColorARB');
12541 end;
12542
12543 procedure Read_GL_ARB_Shader_Objects;
12544 begin
12545 // GL_ARB_Shader_Objects
12546 glCreateShaderObjectARB := dglGetProcAddress('glCreateShaderObjectARB');
12547 glShaderSourceARB := dglGetProcAddress('glShaderSourceARB');
12548 glCompileShaderARB := dglGetProcAddress('glCompileShaderARB');
12549 glDeleteObjectARB := dglGetProcAddress('glDeleteObjectARB');
12550 glGetHandleARB := dglGetProcAddress('glGetHandleARB');
12551 glDetachObjectARB := dglGetProcAddress('glDetachObjectARB');
12552 glCreateProgramObjectARB := dglGetProcAddress('glCreateProgramObjectARB');
12553 glAttachObjectARB := dglGetProcAddress('glAttachObjectARB');
12554 glLinkProgramARB := dglGetProcAddress('glLinkProgramARB');
12555 glUseProgramObjectARB := dglGetProcAddress('glUseProgramObjectARB');
12556 glValidateProgramARB := dglGetProcAddress('glValidateProgramARB');
12557 glGetObjectParameterfvARB := dglGetProcAddress('glGetObjectParameterfvARB');
12558 glGetObjectParameterivARB := dglGetProcAddress('glGetObjectParameterivARB');
12559 glGetActiveUniformARB := dglGetProcAddress('glGetActiveUniformARB');
12560 glGetAttachedObjectsARB := dglGetProcAddress('glGetAttachedObjectsARB');
12561 glGetShaderSourceARB := dglGetProcAddress('glGetShaderSourceARB');
12562 glGetUniformfvARB := dglGetProcAddress('glGetUniformfvARB');
12563 glGetUniformivARB := dglGetProcAddress('glGetUniformivARB');
12564 glGetUniformLocationARB := dglGetProcAddress('glGetUniformLocationARB');
12565 glGetInfoLogARB := dglGetProcAddress('glGetInfoLogARB');
12566 glUniform1fARB := dglGetProcAddress('glUniform1fARB');
12567 glUniform2fARB := dglGetProcAddress('glUniform2fARB');
12568 glUniform3fARB := dglGetProcAddress('glUniform3fARB');
12569 glUniform4fARB := dglGetProcAddress('glUniform4fARB');
12570 glUniform1iARB := dglGetProcAddress('glUniform1iARB');
12571 glUniform2iARB := dglGetProcAddress('glUniform2iARB');
12572 glUniform3iARB := dglGetProcAddress('glUniform3iARB');
12573 glUniform4iARB := dglGetProcAddress('glUniform4iARB');
12574 glUniform1fvARB := dglGetProcAddress('glUniform1fvARB');
12575 glUniform2fvARB := dglGetProcAddress('glUniform2fvARB');
12576 glUniform3fvARB := dglGetProcAddress('glUniform3fvARB');
12577 glUniform4fvARB := dglGetProcAddress('glUniform4fvARB');
12578 glUniform1ivARB := dglGetProcAddress('glUniform1ivARB');
12579 glUniform2ivARB := dglGetProcAddress('glUniform2ivARB');
12580 glUniform3ivARB := dglGetProcAddress('glUniform3ivARB');
12581 glUniform4ivARB := dglGetProcAddress('glUniform4ivARB');
12582 glUniformMatrix2fvARB := dglGetProcAddress('glUniformMatrix2fvARB');
12583 glUniformMatrix3fvARB := dglGetProcAddress('glUniformMatrix3fvARB');
12584 glUniformMatrix4fvARB := dglGetProcAddress('glUniformMatrix4fvARB');
12585
12586 // GL_ARB_vertex_shader
12587 glGetActiveAttribARB := dglGetProcAddress('glGetActiveAttribARB');
12588 glGetAttribLocationARB := dglGetProcAddress('glGetAttribLocationARB');
12589 glBindAttribLocationARB := dglGetProcAddress('glBindAttribLocationARB');
12590 glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
12591 end;
12592
12593 procedure Read_GL_ARB_occlusion_query;
12594 begin
12595 glGenQueriesARB := dglGetProcAddress('glGenQueriesARB');
12596 glDeleteQueriesARB := dglGetProcAddress('glDeleteQueriesARB');
12597 glIsQueryARB := dglGetProcAddress('glIsQueryARB');
12598 glBeginQueryARB := dglGetProcAddress('glBeginQueryARB');
12599 glEndQueryARB := dglGetProcAddress('glEndQueryARB');
12600 glGetQueryivARB := dglGetProcAddress('glGetQueryivARB');
12601 glGetQueryObjectivARB := dglGetProcAddress('glGetQueryObjectivARB');
12602 glGetQueryObjectuivARB := dglGetProcAddress('glGetQueryObjectuivARB');
12603 end;
12604
12605 procedure Read_GL_ARB_draw_instanced;
12606 begin
12607 glDrawArraysInstancedARB := dglGetProcAddress('glDrawArraysInstancedARB');
12608 glDrawElementsInstancedARB := dglGetProcAddress('glDrawElementsInstancedARB');
12609 end;
12610
12611 procedure Read_GL_ARB_framebuffer_object;
12612 begin
12613 glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer');
12614 glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer');
12615 glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers');
12616 glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers');
12617 glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage');
12618 glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv');
12619 glIsFramebuffer := dglGetProcAddress('glIsFramebuffer');
12620 glBindFramebuffer := dglGetProcAddress('glBindFramebuffer');
12621 glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers');
12622 glGenFramebuffers := dglGetProcAddress('glGenFramebuffers');
12623 glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus');
12624 glFramebufferTexture1D := dglGetProcAddress('glFramebufferTexture1D');
12625 glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D');
12626 glFramebufferTexture3D := dglGetProcAddress('glFramebufferTexture3D');
12627 glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer');
12628 glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
12629 glGenerateMipmap := dglGetProcAddress('glGenerateMipmap');
12630 glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer');
12631 glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample');
12632 glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer');
12633 end;
12634
12635 procedure Read_GL_ARB_geometry_shader4;
12636 begin
12637 glProgramParameteriARB := dglGetProcAddress('glProgramParameteriARB');
12638 glFramebufferTextureARB := dglGetProcAddress('glFramebufferTextureARB');
12639 glFramebufferTextureLayerARB := dglGetProcAddress('glFramebufferTextureLayerARB');
12640 glFramebufferTextureFaceARB := dglGetProcAddress('glFramebufferTextureFaceARB');
12641 end;
12642
12643 procedure Read_GL_ARB_instanced_arrays;
12644 begin
12645 glVertexAttribDivisorARB := dglGetProcAddress('glVertexAttribDivisorARB');
12646 end;
12647
12648 procedure Read_GL_ARB_map_buffer_range;
12649 begin
12650 glMapBufferRange := dglGetProcAddress('glMapBufferRange');
12651 glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange');
12652 end;
12653
12654 procedure Read_GL_ARB_texture_buffer_object;
12655 begin
12656 glTexBufferARB := dglGetProcAddress('glTexBufferARB');
12657 end;
12658
12659 procedure Read_GL_ARB_vertex_array_object;
12660 begin
12661 glBindVertexArray := dglGetProcAddress('glBindVertexArray');
12662 glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays');
12663 glGenVertexArrays := dglGetProcAddress('glGenVertexArrays');
12664 glIsVertexArray := dglGetProcAddress('glIsVertexArray');
12665 end;
12666
12667 procedure Read_GL_ARB_uniform_buffer_object;
12668 begin
12669 glGetUniformIndices := dglGetProcAddress('glGetUniformIndices');
12670 glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv');
12671 glGetActiveUniformName := dglGetProcAddress('glGetActiveUniformName');
12672 glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex');
12673 glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv');
12674 glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName');
12675 glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding');
12676 end;
12677
12678 procedure Read_GL_ARB_copy_buffer;
12679 begin
12680 glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData');
12681 end;
12682
12683 procedure Read_GL_ARB_draw_elements_base_vertex;
12684 begin
12685 glDrawElementsBaseVertex := dglGetProcAddress('glDrawElementsBaseVertex');
12686 glDrawRangeElementsBaseVertex := dglGetProcAddress('glDrawRangeElementsBaseVertex');
12687 glDrawElementsInstancedBaseVertex := dglGetProcAddress('glDrawElementsInstancedBaseVertex');
12688 glMultiDrawElementsBaseVertex := dglGetProcAddress('glMultiDrawElementsBaseVertex');
12689 end;
12690
12691 procedure Read_GL_ARB_provoking_vertex;
12692 begin
12693 glProvokingVertex := dglGetProcAddress('glProvokingVertex');
12694 end;
12695
12696 procedure Read_GL_ARB_sync;
12697 begin
12698 glFenceSync := dglGetProcAddress('glFenceSync');
12699 glIsSync := dglGetProcAddress('glIsSync');
12700 glDeleteSync := dglGetProcAddress('glDeleteSync');
12701 glClientWaitSync := dglGetProcAddress('glClientWaitSync');
12702 glWaitSync := dglGetProcAddress('glWaitSync');
12703 glGetInteger64v := dglGetProcAddress('glGetInteger64v');
12704 glGetSynciv := dglGetProcAddress('glGetSynciv');
12705 end;
12706
12707 procedure Read_GL_ARB_texture_multisample;
12708 begin
12709 glTexImage2DMultisample := dglGetProcAddress('glTexImage2DMultisample');
12710 glTexImage3DMultisample := dglGetProcAddress('glTexImage3DMultisample');
12711 glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv');
12712 glSampleMaski := dglGetProcAddress('glSampleMaski');
12713 end;
12714
12715 procedure Read_GL_ARB_draw_buffers_blend;
12716 begin
12717 glBlendEquationi := dglGetProcAddress('glBlendEquationi');
12718 glBlendEquationSeparatei := dglGetProcAddress('glBlendEquationSeparatei');
12719 glBlendFunci := dglGetProcAddress('glBlendFunci');
12720 glBlendFuncSeparatei := dglGetProcAddress('glBlendFuncSeparatei');
12721 end;
12722
12723 procedure Read_GL_ARB_sample_shading;
12724 begin
12725 glMinSampleShading := dglGetProcAddress('glMinSampleShading');;
12726 end;
12727
12728 procedure Read_GL_ATI_draw_buffers;
12729 begin
12730 glDrawBuffersATI := dglGetProcAddress('glDrawBuffersATI');
12731 end;
12732
12733 procedure Read_GL_ATI_element_array;
12734 begin
12735 glElementPointerATI := dglGetProcAddress('glElementPointerATI');
12736 glDrawElementArrayATI := dglGetProcAddress('glDrawElementArrayATI');
12737 glDrawRangeElementArrayATI := dglGetProcAddress('glDrawRangeElementArrayATI');
12738 end;
12739
12740 procedure Read_GL_ATI_envmap_bumpmap;
12741 begin
12742 glTexBumpParameterivATI := dglGetProcAddress('glTexBumpParameterivATI');
12743 glTexBumpParameterfvATI := dglGetProcAddress('glTexBumpParameterfvATI');
12744 glGetTexBumpParameterivATI := dglGetProcAddress('glGetTexBumpParameterivATI');
12745 glGetTexBumpParameterfvATI := dglGetProcAddress('glGetTexBumpParameterfvATI');
12746 end;
12747
12748 procedure Read_GL_ATI_fragment_shader;
12749 begin
12750 glGenFragmentShadersATI := dglGetProcAddress('glGenFragmentShadersATI');
12751 glBindFragmentShaderATI := dglGetProcAddress('glBindFragmentShaderATI');
12752 glDeleteFragmentShaderATI := dglGetProcAddress('glDeleteFragmentShaderATI');
12753 glBeginFragmentShaderATI := dglGetProcAddress('glBeginFragmentShaderATI');
12754 glEndFragmentShaderATI := dglGetProcAddress('glEndFragmentShaderATI');
12755 glPassTexCoordATI := dglGetProcAddress('glPassTexCoordATI');
12756 glSampleMapATI := dglGetProcAddress('glSampleMapATI');
12757 glColorFragmentOp1ATI := dglGetProcAddress('glColorFragmentOp1ATI');
12758 glColorFragmentOp2ATI := dglGetProcAddress('glColorFragmentOp2ATI');
12759 glColorFragmentOp3ATI := dglGetProcAddress('glColorFragmentOp3ATI');
12760 glAlphaFragmentOp1ATI := dglGetProcAddress('glAlphaFragmentOp1ATI');
12761 glAlphaFragmentOp2ATI := dglGetProcAddress('glAlphaFragmentOp2ATI');
12762 glAlphaFragmentOp3ATI := dglGetProcAddress('glAlphaFragmentOp3ATI');
12763 glSetFragmentShaderConstantATI := dglGetProcAddress('glSetFragmentShaderConstantATI');
12764 end;
12765
12766 procedure Read_GL_ATI_map_object_buffer;
12767 begin
12768 glMapObjectBufferATI := dglGetProcAddress('glMapObjectBufferATI');
12769 glUnmapObjectBufferATI := dglGetProcAddress('glUnmapObjectBufferATI');
12770 end;
12771
12772 procedure Read_GL_ATI_pn_triangles;
12773 begin
12774 glPNTrianglesiATI := dglGetProcAddress('glPNTrianglesiATI');
12775 glPNTrianglesfATI := dglGetProcAddress('glPNTrianglesfATI');
12776 end;
12777
12778 procedure Read_GL_ATI_separate_stencil;
12779 begin
12780 glStencilOpSeparateATI := dglGetProcAddress('glStencilOpSeparateATI');
12781 glStencilFuncSeparateATI := dglGetProcAddress('glStencilFuncSeparateATI');
12782 end;
12783
12784 procedure Read_GL_ATI_vertex_array_object;
12785 begin
12786 glNewObjectBufferATI := dglGetProcAddress('glNewObjectBufferATI');
12787 glIsObjectBufferATI := dglGetProcAddress('glIsObjectBufferATI');
12788 glUpdateObjectBufferATI := dglGetProcAddress('glUpdateObjectBufferATI');
12789 glGetObjectBufferfvATI := dglGetProcAddress('glGetObjectBufferfvATI');
12790 glGetObjectBufferivATI := dglGetProcAddress('glGetObjectBufferivATI');
12791 glFreeObjectBufferATI := dglGetProcAddress('glFreeObjectBufferATI');
12792 glArrayObjectATI := dglGetProcAddress('glArrayObjectATI');
12793 glGetArrayObjectfvATI := dglGetProcAddress('glGetArrayObjectfvATI');
12794 glGetArrayObjectivATI := dglGetProcAddress('glGetArrayObjectivATI');
12795 glVariantArrayObjectATI := dglGetProcAddress('glVariantArrayObjectATI');
12796 glGetVariantArrayObjectfvATI := dglGetProcAddress('glGetVariantArrayObjectfvATI');
12797 glGetVariantArrayObjectivATI := dglGetProcAddress('glGetVariantArrayObjectivATI');
12798
12799 end;
12800
12801 procedure Read_GL_ATI_vertex_attrib_array_object;
12802 begin
12803 glVertexAttribArrayObjectATI := dglGetProcAddress('glVertexAttribArrayObjectATI');
12804 glGetVertexAttribArrayObjectfvATI := dglGetProcAddress('glGetVertexAttribArrayObjectfvATI');
12805 glGetVertexAttribArrayObjectivATI := dglGetProcAddress('glGetVertexAttribArrayObjectivATI');
12806 end;
12807
12808 procedure Read_GL_ATI_vertex_streams;
12809 begin
12810 glVertexStream1sATI := dglGetProcAddress('glVertexStream1sATI');
12811 glVertexStream1svATI := dglGetProcAddress('glVertexStream1svATI');
12812 glVertexStream1iATI := dglGetProcAddress('glVertexStream1iATI');
12813 glVertexStream1ivATI := dglGetProcAddress('glVertexStream1ivATI');
12814 glVertexStream1fATI := dglGetProcAddress('glVertexStream1fATI');
12815 glVertexStream1fvATI := dglGetProcAddress('glVertexStream1fvATI');
12816 glVertexStream1dATI := dglGetProcAddress('glVertexStream1dATI');
12817 glVertexStream1dvATI := dglGetProcAddress('glVertexStream1dvATI');
12818 glVertexStream2sATI := dglGetProcAddress('glVertexStream2sATI');
12819 glVertexStream2svATI := dglGetProcAddress('glVertexStream2svATI');
12820 glVertexStream2iATI := dglGetProcAddress('glVertexStream2iATI');
12821 glVertexStream2ivATI := dglGetProcAddress('glVertexStream2ivATI');
12822 glVertexStream2fATI := dglGetProcAddress('glVertexStream2fATI');
12823 glVertexStream2fvATI := dglGetProcAddress('glVertexStream2fvATI');
12824 glVertexStream2dATI := dglGetProcAddress('glVertexStream2dATI');
12825 glVertexStream2dvATI := dglGetProcAddress('glVertexStream2dvATI');
12826 glVertexStream3sATI := dglGetProcAddress('glVertexStream3sATI');
12827 glVertexStream3svATI := dglGetProcAddress('glVertexStream3svATI');
12828 glVertexStream3iATI := dglGetProcAddress('glVertexStream3iATI');
12829 glVertexStream3ivATI := dglGetProcAddress('glVertexStream3ivATI');
12830 glVertexStream3fATI := dglGetProcAddress('glVertexStream3fATI');
12831 glVertexStream3fvATI := dglGetProcAddress('glVertexStream3fvATI');
12832 glVertexStream3dATI := dglGetProcAddress('glVertexStream3dATI');
12833 glVertexStream3dvATI := dglGetProcAddress('glVertexStream3dvATI');
12834 glVertexStream4sATI := dglGetProcAddress('glVertexStream4sATI');
12835 glVertexStream4svATI := dglGetProcAddress('glVertexStream4svATI');
12836 glVertexStream4iATI := dglGetProcAddress('glVertexStream4iATI');
12837 glVertexStream4ivATI := dglGetProcAddress('glVertexStream4ivATI');
12838 glVertexStream4fATI := dglGetProcAddress('glVertexStream4fATI');
12839 glVertexStream4fvATI := dglGetProcAddress('glVertexStream4fvATI');
12840 glVertexStream4dATI := dglGetProcAddress('glVertexStream4dATI');
12841 glVertexStream4dvATI := dglGetProcAddress('glVertexStream4dvATI');
12842 glNormalStream3bATI := dglGetProcAddress('glNormalStream3bATI');
12843 glNormalStream3bvATI := dglGetProcAddress('glNormalStream3bvATI');
12844 glNormalStream3sATI := dglGetProcAddress('glNormalStream3sATI');
12845 glNormalStream3svATI := dglGetProcAddress('glNormalStream3svATI');
12846 glNormalStream3iATI := dglGetProcAddress('glNormalStream3iATI');
12847 glNormalStream3ivATI := dglGetProcAddress('glNormalStream3ivATI');
12848 glNormalStream3fATI := dglGetProcAddress('glNormalStream3fATI');
12849 glNormalStream3fvATI := dglGetProcAddress('glNormalStream3fvATI');
12850 glNormalStream3dATI := dglGetProcAddress('glNormalStream3dATI');
12851 glNormalStream3dvATI := dglGetProcAddress('glNormalStream3dvATI');
12852 glClientActiveVertexStreamATI := dglGetProcAddress('glClientActiveVertexStreamATI');
12853 glVertexBlendEnviATI := dglGetProcAddress('glVertexBlendEnviATI');
12854 glVertexBlendEnvfATI := dglGetProcAddress('glVertexBlendEnvfATI');
12855 end;
12856
12857 procedure Read_GL_AMD_performance_monitor;
12858 begin
12859 glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD');
12860 glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD');
12861 glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD');
12862 glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD');
12863 glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD');
12864 glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD');
12865 glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD');
12866 glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD');
12867 glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD');
12868 glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD');
12869 glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD');
12870 end;
12871
12872 procedure Read_GL_EXT_blend_color;
12873 begin
12874 glBlendColorEXT := dglGetProcAddress('glBlendColorEXT');
12875 end;
12876
12877 procedure Read_GL_EXT_blend_func_separate;
12878 begin
12879 glBlendFuncSeparateEXT := dglGetProcAddress('glBlendFuncSeparateEXT');
12880 end;
12881
12882 procedure Read_GL_EXT_blend_minmax;
12883 begin
12884 glBlendEquationEXT := dglGetProcAddress('glBlendEquationEXT');
12885 end;
12886
12887 procedure Read_GL_EXT_color_subtable;
12888 begin
12889 glColorSubTableEXT := dglGetProcAddress('glColorSubTableEXT');
12890 glCopyColorSubTableEXT := dglGetProcAddress('glCopyColorSubTableEXT');
12891 end;
12892
12893 procedure Read_GL_EXT_compiled_vertex_array;
12894 begin
12895 glLockArraysEXT := dglGetProcAddress('glLockArraysEXT');
12896 glUnlockArraysEXT := dglGetProcAddress('glUnlockArraysEXT');
12897 end;
12898
12899 procedure Read_GL_EXT_convolution;
12900 begin
12901 glConvolutionFilter1DEXT := dglGetProcAddress('glConvolutionFilter1DEXT');
12902 glConvolutionFilter2DEXT := dglGetProcAddress('glConvolutionFilter2DEXT');
12903 glConvolutionParameterfEXT := dglGetProcAddress('glConvolutionParameterfEXT');
12904 glConvolutionParameterfvEXT := dglGetProcAddress('glConvolutionParameterfvEXT');
12905 glConvolutionParameteriEXT := dglGetProcAddress('glConvolutionParameteriEXT');
12906 glConvolutionParameterivEXT := dglGetProcAddress('glConvolutionParameterivEXT');
12907 glCopyConvolutionFilter1DEXT := dglGetProcAddress('glCopyConvolutionFilter1DEXT');
12908 glCopyConvolutionFilter2DEXT := dglGetProcAddress('glCopyConvolutionFilter2DEXT');
12909 glGetConvolutionFilterEXT := dglGetProcAddress('glGetConvolutionFilterEXT');
12910 glGetConvolutionParameterfvEXT := dglGetProcAddress('glGetConvolutionParameterfvEXT');
12911 glGetConvolutionParameterivEXT := dglGetProcAddress('glGetConvolutionParameterivEXT');
12912 glGetSeparableFilterEXT := dglGetProcAddress('glGetSeparableFilterEXT');
12913 glSeparableFilter2DEXT := dglGetProcAddress('glSeparableFilter2DEXT');
12914 end;
12915
12916 procedure Read_GL_EXT_coordinate_frame;
12917 begin
12918 glTangent3bEXT := dglGetProcAddress('glTangent3bEXT');
12919 glTangent3bvEXT := dglGetProcAddress('glTangent3bvEXT');
12920 glTangent3dEXT := dglGetProcAddress('glTangent3dEXT');
12921 glTangent3dvEXT := dglGetProcAddress('glTangent3dvEXT');
12922 glTangent3fEXT := dglGetProcAddress('glTangent3fEXT');
12923 glTangent3fvEXT := dglGetProcAddress('glTangent3fvEXT');
12924 glTangent3iEXT := dglGetProcAddress('glTangent3iEXT');
12925 glTangent3ivEXT := dglGetProcAddress('glTangent3ivEXT');
12926 glTangent3sEXT := dglGetProcAddress('glTangent3sEXT');
12927 glTangent3svEXT := dglGetProcAddress('glTangent3svEXT');
12928 glBinormal3bEXT := dglGetProcAddress('glBinormal3bEXT');
12929 glBinormal3bvEXT := dglGetProcAddress('glBinormal3bvEXT');
12930 glBinormal3dEXT := dglGetProcAddress('glBinormal3dEXT');
12931 glBinormal3dvEXT := dglGetProcAddress('glBinormal3dvEXT');
12932 glBinormal3fEXT := dglGetProcAddress('glBinormal3fEXT');
12933 glBinormal3fvEXT := dglGetProcAddress('glBinormal3fvEXT');
12934 glBinormal3iEXT := dglGetProcAddress('glBinormal3iEXT');
12935 glBinormal3ivEXT := dglGetProcAddress('glBinormal3ivEXT');
12936 glBinormal3sEXT := dglGetProcAddress('glBinormal3sEXT');
12937 glBinormal3svEXT := dglGetProcAddress('glBinormal3svEXT');
12938 glTangentPointerEXT := dglGetProcAddress('glTangentPointerEXT');
12939 glBinormalPointerEXT := dglGetProcAddress('glBinormalPointerEXT');
12940 end;
12941
12942 procedure Read_GL_EXT_copy_texture;
12943 begin
12944 glCopyTexImage1DEXT := dglGetProcAddress('glCopyTexImage1DEXT');
12945 glCopyTexImage2DEXT := dglGetProcAddress('glCopyTexImage2DEXT');
12946 glCopyTexSubImage1DEXT := dglGetProcAddress('glCopyTexSubImage1DEXT');
12947 glCopyTexSubImage2DEXT := dglGetProcAddress('glCopyTexSubImage2DEXT');
12948 glCopyTexSubImage3DEXT := dglGetProcAddress('glCopyTexSubImage3DEXT');
12949 end;
12950
12951 procedure Read_GL_EXT_cull_vertex;
12952 begin
12953 glCullParameterdvEXT := dglGetProcAddress('glCullParameterdvEXT');
12954 glCullParameterfvEXT := dglGetProcAddress('glCullParameterfvEXT');
12955 end;
12956
12957 procedure Read_GL_EXT_draw_range_elements;
12958 begin
12959 glDrawRangeElementsEXT := dglGetProcAddress('glDrawRangeElementsEXT');
12960 end;
12961
12962 procedure Read_GL_EXT_fog_coord;
12963 begin
12964 glFogCoordfEXT := dglGetProcAddress('glFogCoordfEXT');
12965 glFogCoordfvEXT := dglGetProcAddress('glFogCoordfvEXT');
12966 glFogCoorddEXT := dglGetProcAddress('glFogCoorddEXT');
12967 glFogCoorddvEXT := dglGetProcAddress('glFogCoorddvEXT');
12968 glFogCoordPointerEXT := dglGetProcAddress('glFogCoordPointerEXT');
12969 end;
12970
12971 procedure Read_GL_EXT_framebuffer_object;
12972 begin
12973 glIsRenderbufferEXT := dglGetProcAddress('glIsRenderbufferEXT');
12974 glBindRenderbufferEXT := dglGetProcAddress('glBindRenderbufferEXT');
12975 glDeleteRenderbuffersEXT := dglGetProcAddress('glDeleteRenderbuffersEXT');
12976 glGenRenderbuffersEXT := dglGetProcAddress('glGenRenderbuffersEXT');
12977 glRenderbufferStorageEXT := dglGetProcAddress('glRenderbufferStorageEXT');
12978 glGetRenderbufferParameterivEXT := dglGetProcAddress('glGetRenderbufferParameterivEXT');
12979 glIsFramebufferEXT := dglGetProcAddress('glIsFramebufferEXT');
12980 glBindFramebufferEXT := dglGetProcAddress('glBindFramebufferEXT');
12981 glDeleteFramebuffersEXT := dglGetProcAddress('glDeleteFramebuffersEXT');
12982 glGenFramebuffersEXT := dglGetProcAddress('glGenFramebuffersEXT');
12983 glCheckFramebufferStatusEXT := dglGetProcAddress('glCheckFramebufferStatusEXT');
12984 glFramebufferTexture1DEXT := dglGetProcAddress('glFramebufferTexture1DEXT');
12985 glFramebufferTexture2DEXT := dglGetProcAddress('glFramebufferTexture2DEXT');
12986 glFramebufferTexture3DEXT := dglGetProcAddress('glFramebufferTexture3DEXT');
12987 glFramebufferRenderbufferEXT := dglGetProcAddress('glFramebufferRenderbufferEXT');
12988 glGetFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetFramebufferAttachmentParameterivEXT');
12989 glGenerateMipmapEXT := dglGetProcAddress('glGenerateMipmapEXT');
12990 end;
12991
12992 procedure Read_GL_EXT_histogram;
12993 begin
12994 glGetHistogramEXT := dglGetProcAddress('glGetHistogramEXT');
12995 glGetHistogramParameterfvEXT := dglGetProcAddress('glGetHistogramParameterfvEXT');
12996 glGetHistogramParameterivEXT := dglGetProcAddress('glGetHistogramParameterivEXT');
12997 glGetMinmaxEXT := dglGetProcAddress('glGetMinmaxEXT');
12998 glGetMinmaxParameterfvEXT := dglGetProcAddress('glGetMinmaxParameterfvEXT');
12999 glGetMinmaxParameterivEXT := dglGetProcAddress('glGetMinmaxParameterivEXT');
13000 glHistogramEXT := dglGetProcAddress('glHistogramEXT');
13001 glMinmaxEXT := dglGetProcAddress('glMinmaxEXT');
13002 glResetHistogramEXT := dglGetProcAddress('glResetHistogramEXT');
13003 glResetMinmaxEXT := dglGetProcAddress('glResetMinmaxEXT');
13004 end;
13005
13006 procedure Read_GL_EXT_index_func;
13007 begin
13008 glIndexFuncEXT := dglGetProcAddress('glIndexFuncEXT');
13009 end;
13010
13011 procedure Read_GL_EXT_index_material;
13012 begin
13013 glIndexMaterialEXT := dglGetProcAddress('glIndexMaterialEXT');
13014 end;
13015
13016 procedure Read_GL_EXT_light_texture;
13017 begin
13018 glApplyTextureEXT := dglGetProcAddress('glApplyTextureEXT');
13019 glTextureLightEXT := dglGetProcAddress('glTextureLightEXT');
13020 glTextureMaterialEXT := dglGetProcAddress('glTextureMaterialEXT');
13021 end;
13022
13023 procedure Read_GL_EXT_multi_draw_arrays;
13024 begin
13025 glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT');
13026 glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT');
13027 end;
13028
13029 procedure Read_GL_EXT_multisample;
13030 begin
13031 glSampleMaskEXT := dglGetProcAddress('glSampleMaskEXT');
13032 glSamplePatternEXT := dglGetProcAddress('glSamplePatternEXT');
13033 end;
13034
13035 procedure Read_GL_EXT_paletted_texture;
13036 begin
13037 glColorTableEXT := dglGetProcAddress('glColorTableEXT');
13038 glGetColorTableEXT := dglGetProcAddress('glGetColorTableEXT');
13039 glGetColorTableParameterivEXT := dglGetProcAddress('glGetColorTableParameterivEXT');
13040 glGetColorTableParameterfvEXT := dglGetProcAddress('glGetColorTableParameterfvEXT');
13041 end;
13042
13043 procedure Read_GL_EXT_pixel_transform;
13044 begin
13045 glPixelTransformParameteriEXT := dglGetProcAddress('glPixelTransformParameteriEXT');
13046 glPixelTransformParameterfEXT := dglGetProcAddress('glPixelTransformParameterfEXT');
13047 glPixelTransformParameterivEXT := dglGetProcAddress('glPixelTransformParameterivEXT');
13048 glPixelTransformParameterfvEXT := dglGetProcAddress('glPixelTransformParameterfvEXT');
13049 end;
13050
13051 procedure Read_GL_EXT_point_parameters;
13052 begin
13053 glPointParameterfEXT := dglGetProcAddress('glPointParameterfEXT');
13054 glPointParameterfvEXT := dglGetProcAddress('glPointParameterfvEXT');
13055 end;
13056
13057 procedure Read_GL_EXT_polygon_offset;
13058 begin
13059 glPolygonOffsetEXT := dglGetProcAddress('glPolygonOffsetEXT');
13060 end;
13061
13062 procedure Read_GL_EXT_secondary_color;
13063 begin
13064 glSecondaryColor3bEXT := dglGetProcAddress('glSecondaryColor3bEXT');
13065 glSecondaryColor3bvEXT := dglGetProcAddress('glSecondaryColor3bvEXT');
13066 glSecondaryColor3dEXT := dglGetProcAddress('glSecondaryColor3dEXT');
13067 glSecondaryColor3dvEXT := dglGetProcAddress('glSecondaryColor3dvEXT');
13068 glSecondaryColor3fEXT := dglGetProcAddress('glSecondaryColor3fEXT');
13069 glSecondaryColor3fvEXT := dglGetProcAddress('glSecondaryColor3fvEXT');
13070 glSecondaryColor3iEXT := dglGetProcAddress('glSecondaryColor3iEXT');
13071 glSecondaryColor3ivEXT := dglGetProcAddress('glSecondaryColor3ivEXT');
13072 glSecondaryColor3sEXT := dglGetProcAddress('glSecondaryColor3sEXT');
13073 glSecondaryColor3svEXT := dglGetProcAddress('glSecondaryColor3svEXT');
13074 glSecondaryColor3ubEXT := dglGetProcAddress('glSecondaryColor3ubEXT');
13075 glSecondaryColor3ubvEXT := dglGetProcAddress('glSecondaryColor3ubvEXT');
13076 glSecondaryColor3uiEXT := dglGetProcAddress('glSecondaryColor3uiEXT');
13077 glSecondaryColor3uivEXT := dglGetProcAddress('glSecondaryColor3uivEXT');
13078 glSecondaryColor3usEXT := dglGetProcAddress('glSecondaryColor3usEXT');
13079 glSecondaryColor3usvEXT := dglGetProcAddress('glSecondaryColor3usvEXT');
13080 glSecondaryColorPointerEXT := dglGetProcAddress('glSecondaryColorPointerEXT');
13081 end;
13082
13083 procedure Read_GL_EXT_stencil_two_side;
13084 begin
13085 glActiveStencilFaceEXT := dglGetProcAddress('glActiveStencilFaceEXT');
13086 end;
13087
13088 procedure Read_GL_EXT_subtexture;
13089 begin
13090 glTexSubImage1DEXT := dglGetProcAddress('glTexSubImage1DEXT');
13091 glTexSubImage2DEXT := dglGetProcAddress('glTexSubImage2DEXT');
13092 end;
13093
13094 procedure Read_GL_EXT_texture3D;
13095 begin
13096 glTexImage3DEXT := dglGetProcAddress('glTexImage3DEXT');
13097 glTexSubImage3DEXT := dglGetProcAddress('glTexSubImage3DEXT');
13098 end;
13099
13100 procedure Read_GL_EXT_texture_object;
13101 begin
13102 glAreTexturesResidentEXT := dglGetProcAddress('glAreTexturesResidentEXT');
13103 glBindTextureEXT := dglGetProcAddress('glBindTextureEXT');
13104 glDeleteTexturesEXT := dglGetProcAddress('glDeleteTexturesEXT');
13105 glGenTexturesEXT := dglGetProcAddress('glGenTexturesEXT');
13106 glIsTextureEXT := dglGetProcAddress('glIsTextureEXT');
13107 glPrioritizeTexturesEXT := dglGetProcAddress('glPrioritizeTexturesEXT');
13108 end;
13109
13110 procedure Read_GL_EXT_texture_perturb_normal;
13111 begin
13112 glTextureNormalEXT := dglGetProcAddress('glTextureNormalEXT');
13113 end;
13114
13115 procedure Read_GL_EXT_vertex_array;
13116 begin
13117 glArrayElementEXT := dglGetProcAddress('glArrayElementEXT');
13118 glColorPointerEXT := dglGetProcAddress('glColorPointerEXT');
13119 glDrawArraysEXT := dglGetProcAddress('glDrawArraysEXT');
13120 glEdgeFlagPointerEXT := dglGetProcAddress('glEdgeFlagPointerEXT');
13121 glGetPointervEXT := dglGetProcAddress('glGetPointervEXT');
13122 glIndexPointerEXT := dglGetProcAddress('glIndexPointerEXT');
13123 glNormalPointerEXT := dglGetProcAddress('glNormalPointerEXT');
13124 glTexCoordPointerEXT := dglGetProcAddress('glTexCoordPointerEXT');
13125 glVertexPointerEXT := dglGetProcAddress('glVertexPointerEXT');
13126 end;
13127
13128 procedure Read_GL_EXT_vertex_shader;
13129 begin
13130 glBeginVertexShaderEXT := dglGetProcAddress('glBeginVertexShaderEXT');
13131 glEndVertexShaderEXT := dglGetProcAddress('glEndVertexShaderEXT');
13132 glBindVertexShaderEXT := dglGetProcAddress('glBindVertexShaderEXT');
13133 glGenVertexShadersEXT := dglGetProcAddress('glGenVertexShadersEXT');
13134 glDeleteVertexShaderEXT := dglGetProcAddress('glDeleteVertexShaderEXT');
13135 glShaderOp1EXT := dglGetProcAddress('glShaderOp1EXT');
13136 glShaderOp2EXT := dglGetProcAddress('glShaderOp2EXT');
13137 glShaderOp3EXT := dglGetProcAddress('glShaderOp3EXT');
13138 glSwizzleEXT := dglGetProcAddress('glSwizzleEXT');
13139 glWriteMaskEXT := dglGetProcAddress('glWriteMaskEXT');
13140 glInsertComponentEXT := dglGetProcAddress('glInsertComponentEXT');
13141 glExtractComponentEXT := dglGetProcAddress('glExtractComponentEXT');
13142 glGenSymbolsEXT := dglGetProcAddress('glGenSymbolsEXT');
13143 glSetInvariantEXT := dglGetProcAddress('glSetInvariantEXT');
13144 glSetLocalConstantEXT := dglGetProcAddress('glSetLocalConstantEXT');
13145 glVariantbvEXT := dglGetProcAddress('glVariantbvEXT');
13146 glVariantsvEXT := dglGetProcAddress('glVariantsvEXT');
13147 glVariantivEXT := dglGetProcAddress('glVariantivEXT');
13148 glVariantfvEXT := dglGetProcAddress('glVariantfvEXT');
13149 glVariantdvEXT := dglGetProcAddress('glVariantdvEXT');
13150 glVariantubvEXT := dglGetProcAddress('glVariantubvEXT');
13151 glVariantusvEXT := dglGetProcAddress('glVariantusvEXT');
13152 glVariantuivEXT := dglGetProcAddress('glVariantuivEXT');
13153 glVariantPointerEXT := dglGetProcAddress('glVariantPointerEXT');
13154 glEnableVariantClientStateEXT := dglGetProcAddress('glEnableVariantClientStateEXT');
13155 glDisableVariantClientStateEXT := dglGetProcAddress('glDisableVariantClientStateEXT');
13156 glBindLightParameterEXT := dglGetProcAddress('glBindLightParameterEXT');
13157 glBindMaterialParameterEXT := dglGetProcAddress('glBindMaterialParameterEXT');
13158 glBindTexGenParameterEXT := dglGetProcAddress('glBindTexGenParameterEXT');
13159 glBindTextureUnitParameterEXT := dglGetProcAddress('glBindTextureUnitParameterEXT');
13160 glBindParameterEXT := dglGetProcAddress('glBindParameterEXT');
13161 glIsVariantEnabledEXT := dglGetProcAddress('glIsVariantEnabledEXT');
13162 glGetVariantBooleanvEXT := dglGetProcAddress('glGetVariantBooleanvEXT');
13163 glGetVariantIntegervEXT := dglGetProcAddress('glGetVariantIntegervEXT');
13164 glGetVariantFloatvEXT := dglGetProcAddress('glGetVariantFloatvEXT');
13165 glGetVariantPointervEXT := dglGetProcAddress('glGetVariantPointervEXT');
13166 glGetInvariantBooleanvEXT := dglGetProcAddress('glGetInvariantBooleanvEXT');
13167 glGetInvariantIntegervEXT := dglGetProcAddress('glGetInvariantIntegervEXT');
13168 glGetInvariantFloatvEXT := dglGetProcAddress('glGetInvariantFloatvEXT');
13169 glGetLocalConstantBooleanvEXT := dglGetProcAddress('glGetLocalConstantBooleanvEXT');
13170 glGetLocalConstantIntegervEXT := dglGetProcAddress('glGetLocalConstantIntegervEXT');
13171 glGetLocalConstantFloatvEXT := dglGetProcAddress('glGetLocalConstantFloatvEXT');
13172 end;
13173
13174 procedure Read_GL_EXT_vertex_weighting;
13175 begin
13176 glVertexWeightfEXT := dglGetProcAddress('glVertexWeightfEXT');
13177 glVertexWeightfvEXT := dglGetProcAddress('glVertexWeightfvEXT');
13178 glVertexWeightPointerEXT := dglGetProcAddress('glVertexWeightPointerEXT');
13179 end;
13180
13181 procedure Read_GL_EXT_depth_bounds_test;
13182 begin
13183 glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
13184 glDepthBoundsEXT := dglGetProcAddress('glDepthBoundsEXT');
13185 end;
13186
13187 procedure Read_GL_EXT_blend_equation_separate;
13188 begin
13189 glBlendEquationSeparateEXT := dglGetProcAddress('glBlendEquationSeparateEXT');
13190 end;
13191
13192 procedure Read_GL_EXT_stencil_clear_tag;
13193 begin
13194 glStencilClearTagEXT := dglGetProcAddress('glStencilClearTagEXT');
13195 end;
13196
13197 procedure Read_GL_EXT_framebuffer_blit;
13198 begin
13199 glBlitFramebufferEXT := dglGetProcAddress('glBlitFramebufferEXT');
13200 end;
13201
13202 procedure Read_GL_EXT_framebuffer_multisample;
13203 begin
13204 glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT');
13205 end;
13206
13207 procedure Read_GL_EXT_timer_query;
13208 begin
13209 glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT');
13210 glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT');
13211 end;
13212
13213 procedure Read_GL_EXT_gpu_program_parameters;
13214 begin
13215 glProgramEnvParameters4fvEXT := dglGetProcAddress('glProgramEnvParameters4fvEXT');
13216 glProgramLocalParameters4fvEXT := dglGetProcAddress('glProgramLocalParameters4fvEXT');
13217 end;
13218
13219 procedure Read_GL_EXT_bindable_uniform;
13220 begin
13221 glUniformBufferEXT := dglGetProcAddress('glUniformBufferEXT');
13222 glGetUniformBufferSizeEXT := dglGetProcAddress('glGetUniformBufferSizeEXT');
13223 glGetUniformOffsetEXT := dglGetProcAddress('glGetUniformOffsetEXT');
13224 end;
13225
13226 procedure Read_GL_EXT_draw_buffers2;
13227 begin
13228 glColorMaskIndexedEXT := dglGetProcAddress('glColorMaskIndexedEXT');
13229 glGetBooleanIndexedvEXT := dglGetProcAddress('glGetBooleanIndexedvEXT');
13230 glGetIntegerIndexedvEXT := dglGetProcAddress('glGetIntegerIndexedvEXT');
13231 glEnableIndexedEXT := dglGetProcAddress('glEnableIndexedEXT');
13232 glDisableIndexedEXT := dglGetProcAddress('glDisableIndexedEXT');
13233 glIsEnabledIndexedEXT := dglGetProcAddress('glIsEnabledIndexedEXT');
13234 end;
13235
13236 procedure Read_GL_EXT_draw_instanced;
13237 begin
13238 glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT');
13239 glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT');
13240 end;
13241
13242 procedure Read_GL_EXT_geometry_shader4;
13243 begin
13244 glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT');
13245 glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT');
13246 // glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
13247 glFramebufferTextureFaceEXT := dglGetProcAddress('glFramebufferTextureFaceEXT');
13248 end;
13249
13250 procedure Read_GL_EXT_gpu_shader4;
13251 begin
13252 glVertexAttribI1iEXT := dglGetProcAddress('glVertexAttribI1iEXT');
13253 glVertexAttribI2iEXT := dglGetProcAddress('glVertexAttribI2iEXT');
13254 glVertexAttribI3iEXT := dglGetProcAddress('glVertexAttribI3iEXT');
13255 glVertexAttribI4iEXT := dglGetProcAddress('glVertexAttribI4iEXT');
13256 glVertexAttribI1uiEXT := dglGetProcAddress('glVertexAttribI1uiEXT');
13257 glVertexAttribI2uiEXT := dglGetProcAddress('glVertexAttribI2uiEXT');
13258 glVertexAttribI3uiEXT := dglGetProcAddress('glVertexAttribI3uiEXT');
13259 glVertexAttribI4uiEXT := dglGetProcAddress('glVertexAttribI4uiEXT');
13260 glVertexAttribI1ivEXT := dglGetProcAddress('glVertexAttribI1ivEXT');
13261 glVertexAttribI2ivEXT := dglGetProcAddress('glVertexAttribI2ivEXT');
13262 glVertexAttribI3ivEXT := dglGetProcAddress('glVertexAttribI3ivEXT');
13263 glVertexAttribI4ivEXT := dglGetProcAddress('glVertexAttribI4ivEXT');
13264 glVertexAttribI1uivEXT := dglGetProcAddress('glVertexAttribI1uivEXT');
13265 glVertexAttribI2uivEXT := dglGetProcAddress('glVertexAttribI2uivEXT');
13266 glVertexAttribI3uivEXT := dglGetProcAddress('glVertexAttribI3uivEXT');
13267 glVertexAttribI4uivEXT := dglGetProcAddress('glVertexAttribI4uivEXT');
13268 glVertexAttribI4bvEXT := dglGetProcAddress('glVertexAttribI4bvEXT');
13269 glVertexAttribI4svEXT := dglGetProcAddress('glVertexAttribI4svEXT');
13270 glVertexAttribI4ubvEXT := dglGetProcAddress('glVertexAttribI4ubvEXT');
13271 glVertexAttribI4usvEXT := dglGetProcAddress('glVertexAttribI4usvEXT');
13272 glVertexAttribIPointerEXT := dglGetProcAddress('glVertexAttribIPointerEXT');
13273 glGetVertexAttribIivEXT := dglGetProcAddress('glGetVertexAttribIivEXT');
13274 glGetVertexAttribIuivEXT := dglGetProcAddress('glGetVertexAttribIuivEXT');
13275 glUniform1uiEXT := dglGetProcAddress('glUniform1uiEXT');
13276 glUniform2uiEXT := dglGetProcAddress('glUniform2uiEXT');
13277 glUniform3uiEXT := dglGetProcAddress('glUniform3uiEXT');
13278 glUniform4uiEXT := dglGetProcAddress('glUniform4uiEXT');
13279 glUniform1uivEXT := dglGetProcAddress('glUniform1uivEXT');
13280 glUniform2uivEXT := dglGetProcAddress('glUniform2uivEXT');
13281 glUniform3uivEXT := dglGetProcAddress('glUniform3uivEXT');
13282 glUniform4uivEXT := dglGetProcAddress('glUniform4uivEXT');
13283 glGetUniformuivEXT := dglGetProcAddress('glGetUniformuivEXT');
13284 glBindFragDataLocationEXT := dglGetProcAddress('glBindFragDataLocationEXT');
13285 glGetFragDataLocationEXT := dglGetProcAddress('glGetFragDataLocationEXT');
13286 end;
13287
13288 procedure Read_GL_EXT_texture_array;
13289 begin
13290 glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
13291 end;
13292
13293 procedure Read_GL_EXT_texture_buffer_object;
13294 begin
13295 glTexBufferEXT := dglGetProcAddress('glTexBufferEXT');
13296 end;
13297
13298 procedure Read_GL_EXT_texture_integer;
13299 begin
13300 glClearColorIiEXT := dglGetProcAddress('glClearColorIiEXT');
13301 glClearColorIuiEXT := dglGetProcAddress('glClearColorIuiEXT');
13302 glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT');
13303 glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT');
13304 glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT');
13305 glGetTexParameterIiuvEXT := dglGetProcAddress('glGetTexParameterIiuvEXT');
13306 end;
13307
13308 procedure Read_GL_EXT_transform_feedback;
13309 begin
13310 glBeginTransformFeedbackEXT := dglGetProcAddress('lBeginTransformFeedbackEXT');
13311 glEndTransformFeedbackEXT := dglGetProcAddress('glEndTransformFeedbackEXT');
13312 glBindBufferRangeEXT := dglGetProcAddress('glBindBufferRangeEXT');
13313 glBindBufferOffsetEXT := dglGetProcAddress('glBindBufferOffsetEXT');
13314 glBindBufferBaseEXT := dglGetProcAddress('glBindBufferBaseEXT');
13315 glTransformFeedbackVaryingsEXT := dglGetProcAddress('glTransformFeedbackVaryingsEXT');
13316 glGetTransformFeedbackVaryingEXT := dglGetProcAddress('glGetTransformFeedbackVaryingEXT');
13317 end;
13318
13319 procedure Read_GL_EXT_direct_state_access;
13320 begin
13321 glClientAttribDefaultEXT := dglGetProcAddress('glClientAttribDefaultEXT');
13322 glPushClientAttribDefaultEXT := dglGetProcAddress('glPushClientAttribDefaultEXT');
13323 glMatrixLoadfEXT := dglGetProcAddress('glMatrixLoadfEXT');
13324 glMatrixLoaddEXT := dglGetProcAddress('glMatrixLoaddEXT');
13325 glMatrixMultfEXT := dglGetProcAddress('glMatrixMultfEXT');
13326 glMatrixMultdEXT := dglGetProcAddress('glMatrixMultdEXT');
13327 glMatrixLoadIdentityEXT := dglGetProcAddress('glMatrixLoadIdentityEXT');
13328 glMatrixRotatefEXT := dglGetProcAddress('glMatrixRotatefEXT');
13329 glMatrixRotatedEXT := dglGetProcAddress('glMatrixRotatedEXT');
13330 glMatrixScalefEXT := dglGetProcAddress('glMatrixScalefEXT');
13331 glMatrixScaledEXT := dglGetProcAddress('glMatrixScaledEXT');
13332 glMatrixTranslatefEXT := dglGetProcAddress('glMatrixTranslatefEXT');
13333 glMatrixTranslatedEXT := dglGetProcAddress('glMatrixTranslatedEXT');
13334 glMatrixFrustumEXT := dglGetProcAddress('glMatrixFrustumEXT');
13335 glMatrixOrthoEXT := dglGetProcAddress('glMatrixOrthoEXT');
13336 glMatrixPopEXT := dglGetProcAddress('glMatrixPopEXT');
13337 glMatrixPushEXT := dglGetProcAddress('glMatrixPushEXT');
13338 glMatrixLoadTransposefEXT := dglGetProcAddress('glMatrixLoadTransposefEXT');
13339 glMatrixLoadTransposedEXT := dglGetProcAddress('glMatrixLoadTransposedEXT');
13340 glMatrixMultTransposefEXT := dglGetProcAddress('glMatrixMultTransposefEXT');
13341 glMatrixMultTransposedEXT := dglGetProcAddress('glMatrixMultTransposedEXT');
13342 glTextureParameterfEXT := dglGetProcAddress('glTextureParameterfEXT');
13343 glTextureParameterfvEXT := dglGetProcAddress('glTextureParameterfvEXT');
13344 glTextureParameteriEXT := dglGetProcAddress('glTextureParameteriEXT');
13345 glTextureParameterivEXT := dglGetProcAddress('glTextureParameterivEXT');
13346 glTextureImage1DEXT := dglGetProcAddress('glTextureImage1DEXT');
13347 glTextureImage2DEXT := dglGetProcAddress('glTextureImage2DEXT');
13348 glTextureSubImage1DEXT := dglGetProcAddress('glTextureSubImage1DEXT');
13349 glTextureSubImage2DEXT := dglGetProcAddress('glTextureSubImage2DEXT');
13350 glCopyTextureImage1DEXT := dglGetProcAddress('glCopyTextureImage1DEXT');
13351 glCopyTextureImage2DEXT := dglGetProcAddress('glCopyTextureImage2DEXT');
13352 glCopyTextureSubImage1DEXT := dglGetProcAddress('glCopyTextureSubImage1DEXT');
13353 glCopyTextureSubImage2DEXT := dglGetProcAddress('glCopyTextureSubImage2DEXT');
13354 glGetTextureImageEXT := dglGetProcAddress('glGetTextureImageEXT');
13355 glGetTextureParameterfvEXT := dglGetProcAddress('glGetTextureParameterfvEXT');
13356 glGetTextureParameterivEXT := dglGetProcAddress('glGetTextureParameterivEXT');
13357 glGetTextureLevelParameterfvEXT := dglGetProcAddress('glGetTextureLevelParameterfvEXT');
13358 glGetTextureLevelParameterivEXT := dglGetProcAddress('glGetTextureLevelParameterivEXT');
13359 glTextureImage3DEXT := dglGetProcAddress('glTextureImage3DEXT');
13360 glTextureSubImage3DEXT := dglGetProcAddress('glTextureSubImage3DEXT');
13361 glCopyTextureSubImage3DEXT := dglGetProcAddress('glCopyTextureSubImage3DEXT');
13362 glMultiTexParameterfEXT := dglGetProcAddress('glMultiTexParameterfEXT');
13363 glMultiTexParameterfvEXT := dglGetProcAddress('glMultiTexParameterfvEXT');
13364 glMultiTexParameteriEXT := dglGetProcAddress('glMultiTexParameteriEXT');
13365 glMultiTexParameterivEXT := dglGetProcAddress('glMultiTexParameterivEXT');
13366 glMultiTexImage1DEXT := dglGetProcAddress('glMultiTexImage1DEXT');
13367 glMultiTexImage2DEXT := dglGetProcAddress('glMultiTexImage2DEXT');
13368 glMultiTexSubImage1DEXT := dglGetProcAddress('glMultiTexSubImage1DEXT');
13369 glMultiTexSubImage2DEXT := dglGetProcAddress('glMultiTexSubImage2DEXT');
13370 glCopyMultiTexImage1DEXT := dglGetProcAddress('glCopyMultiTexImage1DEXT');
13371 glCopyMultiTexImage2DEXT := dglGetProcAddress('glCopyMultiTexImage2DEXT');
13372 glCopyMultiTexSubImage1DEXT := dglGetProcAddress('glCopyMultiTexSubImage1DEXT');
13373 glCopyMultiTexSubImage2DEXT := dglGetProcAddress('glCopyMultiTexSubImage2DEXT');
13374 glGetMultiTexImageEXT := dglGetProcAddress('glGetMultiTexImageEXT');
13375 glGetMultiTexParameterfvEXT := dglGetProcAddress('glGetMultiTexParameterfvEXT');
13376 glGetMultiTexParameterivEXT := dglGetProcAddress('glGetMultiTexParameterivEXT');
13377 glGetMultiTexLevelParameterfvEXT := dglGetProcAddress('glGetMultiTexLevelParameterfvEXT');
13378 glGetMultiTexLevelParameterivEXT := dglGetProcAddress('glGetMultiTexLevelParameterivEXT');
13379 glMultiTexImage3DEXT := dglGetProcAddress('glMultiTexImage3DEXT');
13380 glMultiTexSubImage3DEXT := dglGetProcAddress('glMultiTexSubImage3DEXT');
13381 glCopyMultiTexSubImage3DEXT := dglGetProcAddress('glCopyMultiTexSubImage3DEXT');
13382 glBindMultiTextureEXT := dglGetProcAddress('glBindMultiTextureEXT');
13383 glEnableClientStateIndexedEXT := dglGetProcAddress('glEnableClientStateIndexedEXT');
13384 glDisableClientStateIndexedEXT := dglGetProcAddress('glDisableClientStateIndexedEXT');
13385 glMultiTexCoordPointerEXT := dglGetProcAddress('glMultiTexCoordPointerEXT');
13386 glMultiTexEnvfEXT := dglGetProcAddress('glMultiTexEnvfEXT');
13387 glMultiTexEnvfvEXT := dglGetProcAddress('glMultiTexEnvfvEXT');
13388 glMultiTexEnviEXT := dglGetProcAddress('glMultiTexEnviEXT');
13389 glMultiTexEnvivEXT := dglGetProcAddress('glMultiTexEnvivEXT');
13390 glMultiTexGendEXT := dglGetProcAddress('glMultiTexGendEXT');
13391 glMultiTexGendvEXT := dglGetProcAddress('glMultiTexGendvEXT');
13392 glMultiTexGenfEXT := dglGetProcAddress('glMultiTexGenfEXT');
13393 glMultiTexGenfvEXT := dglGetProcAddress('glMultiTexGenfvEXT');
13394 glMultiTexGeniEXT := dglGetProcAddress('glMultiTexGeniEXT');
13395 glMultiTexGenivEXT := dglGetProcAddress('glMultiTexGenivEXT');
13396 glGetMultiTexEnvfvEXT := dglGetProcAddress('glGetMultiTexEnvfvEXT');
13397 glGetMultiTexEnvivEXT := dglGetProcAddress('glGetMultiTexEnvivEXT');
13398 glGetMultiTexGendvEXT := dglGetProcAddress('glGetMultiTexGendvEXT');
13399 glGetMultiTexGenfvEXT := dglGetProcAddress('glGetMultiTexGenfvEXT');
13400 glGetMultiTexGenivEXT := dglGetProcAddress('glGetMultiTexGenivEXT');
13401 glGetFloatIndexedvEXT := dglGetProcAddress('glGetFloatIndexedvEXT');
13402 glGetDoubleIndexedvEXT := dglGetProcAddress('glGetDoubleIndexedvEXT');
13403 glGetPointerIndexedvEXT := dglGetProcAddress('glGetPointerIndexedvEXT');
13404 glCompressedTextureImage3DEXT := dglGetProcAddress('glCompressedTextureImage3DEXT');
13405 glCompressedTextureImage2DEXT := dglGetProcAddress('glCompressedTextureImage2DEXT');
13406 glCompressedTextureImage1DEXT := dglGetProcAddress('glCompressedTextureImage1DEXT');
13407 glCompressedTextureSubImage3DEXT := dglGetProcAddress('glCompressedTextureSubImage3DEXT');
13408 glCompressedTextureSubImage2DEXT := dglGetProcAddress('glCompressedTextureSubImage2DEXT');
13409 glCompressedTextureSubImage1DEXT := dglGetProcAddress('glCompressedTextureSubImage1DEXT');
13410 glGetCompressedTextureImageEXT := dglGetProcAddress('glGetCompressedTextureImageEXT');
13411 glCompressedMultiTexImage3DEXT := dglGetProcAddress('glCompressedMultiTexImage3DEXT');
13412 glCompressedMultiTexImage2DEXT := dglGetProcAddress('glCompressedMultiTexImage2DEXT');
13413 glCompressedMultiTexImage1DEXT := dglGetProcAddress('glCompressedMultiTexImage1DEXT');
13414 glCompressedMultiTexSubImage3DEXT := dglGetProcAddress('glCompressedMultiTexSubImage3DEXT');
13415 glCompressedMultiTexSubImage2DEXT := dglGetProcAddress('glCompressedMultiTexSubImage2DEXT');
13416 glCompressedMultiTexSubImage1DEXT := dglGetProcAddress('glCompressedMultiTexSubImage1DEXT');
13417 glGetCompressedMultiTexImageEXT := dglGetProcAddress('glGetCompressedMultiTexImageEXT');
13418 glNamedProgramStringEXT := dglGetProcAddress('glNamedProgramStringEXT');
13419 glNamedProgramLocalParameter4dEXT := dglGetProcAddress('glNamedProgramLocalParameter4dEXT');
13420 glNamedProgramLocalParameter4dvEXT := dglGetProcAddress('glNamedProgramLocalParameter4dvEXT');
13421 glNamedProgramLocalParameter4fEXT := dglGetProcAddress('glNamedProgramLocalParameter4fEXT');
13422 glNamedProgramLocalParameter4fvEXT := dglGetProcAddress('glNamedProgramLocalParameter4fvEXT');
13423 glGetNamedProgramLocalParameterdvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterdvEXT');
13424 glGetNamedProgramLocalParameterfvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterfvEXT');
13425 glGetNamedProgramivEXT := dglGetProcAddress('glGetNamedProgramivEXT');
13426 glGetNamedProgramStringEXT := dglGetProcAddress('glGetNamedProgramStringEXT');
13427 glNamedProgramLocalParameters4fvEXT := dglGetProcAddress('glNamedProgramLocalParameters4fvEXT');
13428 glNamedProgramLocalParameterI4iEXT := dglGetProcAddress('glNamedProgramLocalParameterI4iEXT');
13429 glNamedProgramLocalParameterI4ivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4ivEXT');
13430 glNamedProgramLocalParametersI4ivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4ivEXT');
13431 glNamedProgramLocalParameterI4uiEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uiEXT');
13432 glNamedProgramLocalParameterI4uivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uivEXT');
13433 glNamedProgramLocalParametersI4uivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4uivEXT');
13434 glGetNamedProgramLocalParameterIivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIivEXT');
13435 glGetNamedProgramLocalParameterIuivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIuivEXT');
13436 glTextureParameterIivEXT := dglGetProcAddress('glTextureParameterIivEXT');
13437 glTextureParameterIuivEXT := dglGetProcAddress('glTextureParameterIuivEXT');
13438 glGetTextureParameterIivEXT := dglGetProcAddress('glGetTextureParameterIivEXT');
13439 glGetTextureParameterIuivEXT := dglGetProcAddress('glGetTextureParameterIuivEXT');
13440 glMultiTexParameterIivEXT := dglGetProcAddress('glMultiTexParameterIivEXT');
13441 glMultiTexParameterIuivEXT := dglGetProcAddress('glMultiTexParameterIuivEXT');
13442 glGetMultiTexParameterIivEXT := dglGetProcAddress('glGetMultiTexParameterIivEXT');
13443 glGetMultiTexParameterIuivEXT := dglGetProcAddress('glGetMultiTexParameterIuivEXT');
13444 glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT');
13445 glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT');
13446 glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT');
13447 glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT');
13448 glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT');
13449 glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT');
13450 glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT');
13451 glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT');
13452 glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT');
13453 glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT');
13454 glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT');
13455 glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT');
13456 glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT');
13457 glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT');
13458 glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT');
13459 glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT');
13460 glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT');
13461 glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT');
13462 glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT');
13463 glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT');
13464 glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT');
13465 glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT');
13466 glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT');
13467 glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT');
13468 glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT');
13469 glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT');
13470 glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT');
13471 glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT');
13472 glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT');
13473 glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT');
13474 glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT');
13475 glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT');
13476 glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT');
13477 glNamedBufferDataEXT := dglGetProcAddress('glNamedBufferDataEXT');
13478 glNamedBufferSubDataEXT := dglGetProcAddress('glNamedBufferSubDataEXT');
13479 glMapNamedBufferEXT := dglGetProcAddress('glMapNamedBufferEXT');
13480 glUnmapNamedBufferEXT := dglGetProcAddress('glUnmapNamedBufferEXT');
13481 glGetNamedBufferParameterivEXT := dglGetProcAddress('glGetNamedBufferParameterivEXT');
13482 glGetNamedBufferPointervEXT := dglGetProcAddress('glGetNamedBufferPointervEXT');
13483 glGetNamedBufferSubDataEXT := dglGetProcAddress('glGetNamedBufferSubDataEXT');
13484 glTextureBufferEXT := dglGetProcAddress('glTextureBufferEXT');
13485 glMultiTexBufferEXT := dglGetProcAddress('glMultiTexBufferEXT');
13486 glNamedRenderbufferStorageEXT := dglGetProcAddress('glNamedRenderbufferStorageEXT');
13487 glGetNamedRenderbufferParameterivEXT := dglGetProcAddress('glGetNamedRenderbufferParameterivEXT');
13488 glCheckNamedFramebufferStatusEXT := dglGetProcAddress('glCheckNamedFramebufferStatusEXT');
13489 glNamedFramebufferTexture1DEXT := dglGetProcAddress('glNamedFramebufferTexture1DEXT');
13490 glNamedFramebufferTexture2DEXT := dglGetProcAddress('glNamedFramebufferTexture2DEXT');
13491 glNamedFramebufferTexture3DEXT := dglGetProcAddress('glNamedFramebufferTexture3DEXT');
13492 glNamedFramebufferRenderbufferEXT := dglGetProcAddress('glNamedFramebufferRenderbufferEXT');
13493 glGetNamedFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetNamedFramebufferAttachmentParameterivEXT');
13494 glGenerateTextureMipmapEXT := dglGetProcAddress('glGenerateTextureMipmapEXT');
13495 glGenerateMultiTexMipmapEXT := dglGetProcAddress('glGenerateMultiTexMipmapEXT');
13496 glFramebufferDrawBufferEXT := dglGetProcAddress('glFramebufferDrawBufferEXT');
13497 glFramebufferDrawBuffersEXT := dglGetProcAddress('glFramebufferDrawBuffersEXT');
13498 glFramebufferReadBufferEXT := dglGetProcAddress('glFramebufferReadBufferEXT');
13499 glGetFramebufferParameterivEXT := dglGetProcAddress('glGetFramebufferParameterivEXT');
13500 glNamedRenderbufferStorageMultisampleEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleEXT');
13501 glNamedRenderbufferStorageMultisampleCoverageEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleCoverageEXT');
13502 glNamedFramebufferTextureEXT := dglGetProcAddress('glNamedFramebufferTextureEXT');
13503 glNamedFramebufferTextureLayerEXT := dglGetProcAddress('glNamedFramebufferTextureLayerEXT');
13504 glNamedFramebufferTextureFaceEXT := dglGetProcAddress('glNamedFramebufferTextureFaceEXT');
13505 glTextureRenderbufferEXT := dglGetProcAddress('glTextureRenderbufferEXT');
13506 glMultiTexRenderbufferEXT := dglGetProcAddress('glMultiTexRenderbufferEXT');
13507 end;
13508
13509 procedure Read_GL_HP_image_transform;
13510 begin
13511 glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
13512 glImageTransformParameterfHP := dglGetProcAddress('glImageTransformParameterfHP');
13513 glImageTransformParameterivHP := dglGetProcAddress('glImageTransformParameterivHP');
13514 glImageTransformParameterfvHP := dglGetProcAddress('glImageTransformParameterfvHP');
13515 glGetImageTransformParameterivHP := dglGetProcAddress('glGetImageTransformParameterivHP');
13516 glGetImageTransformParameterfvHP := dglGetProcAddress('glGetImageTransformParameterfvHP');
13517 end;
13518
13519 procedure Read_GL_IBM_multimode_draw_arrays;
13520 begin
13521 glMultiModeDrawArraysIBM := dglGetProcAddress('glMultiModeDrawArraysIBM');
13522 glMultiModeDrawElementsIBM := dglGetProcAddress('glMultiModeDrawElementsIBM');
13523 end;
13524
13525 procedure Read_GL_IBM_vertex_array_lists;
13526 begin
13527 glColorPointerListIBM := dglGetProcAddress('glColorPointerListIBM');
13528 glSecondaryColorPointerListIBM := dglGetProcAddress('glSecondaryColorPointerListIBM');
13529 glEdgeFlagPointerListIBM := dglGetProcAddress('glEdgeFlagPointerListIBM');
13530 glFogCoordPointerListIBM := dglGetProcAddress('glFogCoordPointerListIBM');
13531 glIndexPointerListIBM := dglGetProcAddress('glIndexPointerListIBM');
13532 glNormalPointerListIBM := dglGetProcAddress('glNormalPointerListIBM');
13533 glTexCoordPointerListIBM := dglGetProcAddress('glTexCoordPointerListIBM');
13534 glVertexPointerListIBM := dglGetProcAddress('glVertexPointerListIBM');
13535 end;
13536
13537 procedure Read_GL_INGR_blend_func_separate;
13538 begin
13539 glBlendFuncSeparateINGR := dglGetProcAddress('glBlendFuncSeparateINGR');
13540 end;
13541
13542 procedure Read_GL_INTEL_parallel_arrays;
13543 begin
13544 glVertexPointervINTEL := dglGetProcAddress('glVertexPointervINTEL');
13545 glNormalPointervINTEL := dglGetProcAddress('glNormalPointervINTEL');
13546 glColorPointervINTEL := dglGetProcAddress('glColorPointervINTEL');
13547 glTexCoordPointervINTEL := dglGetProcAddress('glTexCoordPointervINTEL');
13548 end;
13549
13550 procedure Read_GL_MESA_resize_buffers;
13551 begin
13552 glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA');
13553 end;
13554
13555 procedure Read_GL_MESA_window_pos;
13556 begin
13557 glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA');
13558 glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA');
13559 glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA');
13560 glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA');
13561 glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA');
13562 glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA');
13563 glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA');
13564 glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA');
13565 glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA');
13566 glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA');
13567 glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA');
13568 glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA');
13569 glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA');
13570 glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA');
13571 glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA');
13572 glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA');
13573 glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA');
13574 glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA');
13575 glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA');
13576 glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA');
13577 glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA');
13578 glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA');
13579 glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA');
13580 glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA');
13581 end;
13582
13583 procedure Read_GL_NV_evaluators;
13584 begin
13585 glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV');
13586 glMapParameterivNV := dglGetProcAddress('glMapParameterivNV');
13587 glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV');
13588 glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV');
13589 glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV');
13590 glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV');
13591 glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV');
13592 glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV');
13593 glEvalMapsNV := dglGetProcAddress('glEvalMapsNV');
13594 end;
13595
13596 procedure Read_GL_NV_fence;
13597 begin
13598 glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV');
13599 glGenFencesNV := dglGetProcAddress('glGenFencesNV');
13600 glIsFenceNV := dglGetProcAddress('glIsFenceNV');
13601 glTestFenceNV := dglGetProcAddress('glTestFenceNV');
13602 glGetFenceivNV := dglGetProcAddress('glGetFenceivNV');
13603 glFinishFenceNV := dglGetProcAddress('glFinishFenceNV');
13604 glSetFenceNV := dglGetProcAddress('glSetFenceNV');
13605 end;
13606
13607 procedure Read_GL_NV_fragment_program;
13608 begin
13609 glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV');
13610 glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV');
13611 glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV');
13612 glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV');
13613 glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV');
13614 glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV');
13615 end;
13616
13617 procedure Read_GL_NV_half_float;
13618 begin
13619 glVertex2hNV := dglGetProcAddress('glVertex2hNV');
13620 glVertex2hvNV := dglGetProcAddress('glVertex2hvNV');
13621 glVertex3hNV := dglGetProcAddress('glVertex3hNV');
13622 glVertex3hvNV := dglGetProcAddress('glVertex3hvNV');
13623 glVertex4hNV := dglGetProcAddress('glVertex4hNV');
13624 glVertex4hvNV := dglGetProcAddress('glVertex4hvNV');
13625 glNormal3hNV := dglGetProcAddress('glNormal3hNV');
13626 glNormal3hvNV := dglGetProcAddress('glNormal3hvNV');
13627 glColor3hNV := dglGetProcAddress('glColor3hNV');
13628 glColor3hvNV := dglGetProcAddress('glColor3hvNV');
13629 glColor4hNV := dglGetProcAddress('glColor4hNV');
13630 glColor4hvNV := dglGetProcAddress('glColor4hvNV');
13631 glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV');
13632 glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV');
13633 glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV');
13634 glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV');
13635 glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV');
13636 glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV');
13637 glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV');
13638 glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV');
13639 glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV');
13640 glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV');
13641 glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV');
13642 glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV');
13643 glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV');
13644 glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV');
13645 glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV');
13646 glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV');
13647 glFogCoordhNV := dglGetProcAddress('glFogCoordhNV');
13648 glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV');
13649 glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV');
13650 glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV');
13651 glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV');
13652 glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV');
13653 glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV');
13654 glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV');
13655 glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV');
13656 glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV');
13657 glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV');
13658 glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV');
13659 glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV');
13660 glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV');
13661 glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV');
13662 glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV');
13663 glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV');
13664 glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV');
13665 end;
13666
13667 procedure Read_GL_NV_occlusion_query;
13668 begin
13669 glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV');
13670 glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV');
13671 glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV');
13672 glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV');
13673 glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV');
13674 glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV');
13675 glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV');
13676 end;
13677
13678 procedure Read_GL_NV_pixel_data_range;
13679 begin
13680 glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV');
13681 glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV');
13682 end;
13683
13684 procedure Read_GL_NV_point_sprite;
13685 begin
13686 glPointParameteriNV := dglGetProcAddress('glPointParameteriNV');
13687 glPointParameterivNV := dglGetProcAddress('glPointParameterivNV');
13688 end;
13689
13690 procedure Read_GL_NV_primitive_restart;
13691 begin
13692 glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV');
13693 glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV');
13694 end;
13695
13696 procedure Read_GL_NV_register_combiners;
13697 begin
13698 glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV');
13699 glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV');
13700 glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV');
13701 glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV');
13702 glCombinerInputNV := dglGetProcAddress('glCombinerInputNV');
13703 glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV');
13704 glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV');
13705 glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV');
13706 glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV');
13707 glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV');
13708 glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV');
13709 glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV');
13710 glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV');
13711 end;
13712
13713 procedure Read_GL_NV_register_combiners2;
13714 begin
13715 glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV');
13716 glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV');
13717 end;
13718
13719 procedure Read_GL_NV_vertex_array_range;
13720 begin
13721 glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV');
13722 glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV');
13723 end;
13724
13725 procedure Read_GL_NV_vertex_program;
13726 begin
13727 glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV');
13728 glBindProgramNV := dglGetProcAddress('glBindProgramNV');
13729 glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV');
13730 glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV');
13731 glGenProgramsNV := dglGetProcAddress('glGenProgramsNV');
13732 glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV');
13733 glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV');
13734 glGetProgramivNV := dglGetProcAddress('glGetProgramivNV');
13735 glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV');
13736 glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV');
13737 glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV');
13738 glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV');
13739 glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV');
13740 glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV');
13741 glIsProgramNV := dglGetProcAddress('glIsProgramNV');
13742 glLoadProgramNV := dglGetProcAddress('glLoadProgramNV');
13743 glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV');
13744 glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV');
13745 glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV');
13746 glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV');
13747 glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV');
13748 glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV');
13749 glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV');
13750 glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV');
13751 glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV');
13752 glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV');
13753 glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV');
13754 glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV');
13755 glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV');
13756 glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV');
13757 glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV');
13758 glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV');
13759 glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV');
13760 glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV');
13761 glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV');
13762 glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV');
13763 glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV');
13764 glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV');
13765 glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV');
13766 glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV');
13767 glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV');
13768 glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV');
13769 glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV');
13770 glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV');
13771 glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV');
13772 glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV');
13773 glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV');
13774 glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV');
13775 glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV');
13776 glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV');
13777 glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV');
13778 glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV');
13779 glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV');
13780 glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV');
13781 glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV');
13782 glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV');
13783 glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV');
13784 glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV');
13785 glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV');
13786 glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV');
13787 glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV');
13788 glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV');
13789 glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV');
13790 glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV');
13791 end;
13792
13793 procedure Read_GL_NV_depth_buffer_float;
13794 begin
13795 glDepthRangedNV := dglGetProcAddress('glDepthRangedNV');
13796 glClearDepthdNV := dglGetProcAddress('glClearDepthdNV');
13797 glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV');
13798 end;
13799
13800 procedure Read_GL_NV_framebuffer_multisample_coverage;
13801 begin
13802 glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV');
13803 end;
13804
13805 procedure Read_GL_NV_geometry_program4;
13806 begin
13807 glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV');
13808 end;
13809
13810 procedure Read_GL_NV_gpu_program4;
13811 begin
13812 glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV');
13813 glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV');
13814 glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV');
13815 glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV');
13816 glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV');
13817 glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV');
13818 glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV');
13819 glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV');
13820 glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV');
13821 glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV');
13822 glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV');
13823 glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV');
13824 glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV');
13825 glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV');
13826 glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV');
13827 glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV');
13828 end;
13829
13830 procedure Read_GL_NV_parameter_buffer_object;
13831 begin
13832 glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV');
13833 glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV');
13834 glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV');
13835 end;
13836
13837 procedure Read_GL_NV_transform_feedback;
13838 begin
13839 glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV');
13840 glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV');
13841 glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV');
13842 glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV');
13843 glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV');
13844 glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV');
13845 glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV');
13846 glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV');
13847 glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV');
13848 glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV');
13849 glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV');
13850 end;
13851
13852 procedure Read_GL_NV_conditional_render;
13853 begin
13854 glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV');
13855 glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV');
13856 end;
13857
13858 procedure Read_GL_NV_present_video;
13859 begin
13860 glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV');
13861 glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV');
13862 glGetVideoivNV := dglGetProcAddress('glGetVideoivNV');
13863 glGetVideouivNV := dglGetProcAddress('glGetVideouivNV');
13864 glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV');
13865 glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV');
13866 // glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV');
13867 end;
13868
13869 procedure Read_GL_NV_explicit_multisample;
13870 begin
13871 glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV');
13872 glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV');
13873 glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV');
13874 end;
13875
13876 procedure Read_GL_NV_transform_feedback2;
13877 begin
13878 glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV');
13879 glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV');
13880 glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV');
13881 glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV');
13882 glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV');
13883 glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV');
13884 glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV');
13885 end;
13886
13887 procedure Read_GL_PGI_misc_hints;
13888 begin
13889 glHintPGI := dglGetProcAddress('glHintPGI');
13890 end;
13891
13892 procedure Read_GL_SGIS_detail_texture;
13893 begin
13894 glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS');
13895 glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS');
13896 end;
13897
13898 procedure Read_GL_SGIS_fog_function;
13899 begin
13900 glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS');
13901 glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS');
13902 end;
13903
13904 procedure Read_GL_SGIS_multisample;
13905 begin
13906 glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS');
13907 glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS');
13908 end;
13909
13910 procedure Read_GL_SGIS_pixel_texture;
13911 begin
13912 glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS');
13913 glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS');
13914 glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS');
13915 glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS');
13916 glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS');
13917 glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS');
13918 end;
13919
13920 procedure Read_GL_SGIS_point_parameters;
13921 begin
13922 glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS');
13923 glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS');
13924 end;
13925
13926 procedure Read_GL_SGIS_sharpen_texture;
13927 begin
13928 glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS');
13929 glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS');
13930 end;
13931
13932 procedure Read_GL_SGIS_texture4D;
13933 begin
13934 glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS');
13935 glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS');
13936 end;
13937
13938 procedure Read_GL_SGIS_texture_color_mask;
13939 begin
13940 glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS');
13941 end;
13942
13943 procedure Read_GL_SGIS_texture_filter4;
13944 begin
13945 glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS');
13946 glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS');
13947 end;
13948
13949 procedure Read_GL_SGIX_async;
13950 begin
13951 glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX');
13952 glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX');
13953 glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX');
13954 glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX');
13955 glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX');
13956 glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX');
13957 end;
13958
13959 procedure Read_GL_SGIX_flush_raster;
13960 begin
13961 glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX');
13962 end;
13963
13964 procedure Read_GL_SGIX_fragment_lighting;
13965 begin
13966 glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX');
13967 glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX');
13968 glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX');
13969 glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX');
13970 glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX');
13971 glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX');
13972 glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX');
13973 glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX');
13974 glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX');
13975 glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX');
13976 glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX');
13977 glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX');
13978 glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX');
13979 glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX');
13980 glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX');
13981 glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX');
13982 glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX');
13983 glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX');
13984 end;
13985
13986 procedure Read_GL_SGIX_framezoom;
13987 begin
13988 glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX');
13989 end;
13990
13991 procedure Read_GL_SGIX_igloo_interface;
13992 begin
13993 glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX');
13994 end;
13995
13996 procedure Read_GL_SGIX_instruments;
13997 begin
13998 glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX');
13999 glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX');
14000 glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX');
14001 glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX');
14002 glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX');
14003 glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX');
14004 end;
14005
14006 procedure Read_GL_SGIX_list_priority;
14007 begin
14008 glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX');
14009 glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX');
14010 glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX');
14011 glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX');
14012 glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX');
14013 glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX');
14014 end;
14015
14016 procedure Read_GL_SGIX_pixel_texture;
14017 begin
14018 glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX');
14019 end;
14020
14021 procedure Read_GL_SGIX_polynomial_ffd;
14022 begin
14023 glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX');
14024 glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX');
14025 glDeformSGIX := dglGetProcAddress('glDeformSGIX');
14026 glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX');
14027 end;
14028
14029 procedure Read_GL_SGIX_reference_plane;
14030 begin
14031 glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX');
14032 end;
14033
14034 procedure Read_GL_SGIX_sprite;
14035 begin
14036 glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX');
14037 glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX');
14038 glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX');
14039 glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX');
14040 end;
14041
14042 procedure Read_GL_SGIX_tag_sample_buffer;
14043 begin
14044 glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX');
14045 end;
14046
14047 procedure Read_GL_SGI_color_table;
14048 begin
14049 glColorTableSGI := dglGetProcAddress('glColorTableSGI');
14050 glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI');
14051 glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI');
14052 glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI');
14053 glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI');
14054 glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI');
14055 glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI');
14056 end;
14057
14058 procedure Read_GL_SUNX_constant_data;
14059 begin
14060 glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX');
14061 end;
14062
14063 procedure Read_GL_SUN_global_alpha;
14064 begin
14065 glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN');
14066 glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN');
14067 glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN');
14068 glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN');
14069 glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN');
14070 glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN');
14071 glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN');
14072 glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN');
14073 end;
14074
14075 procedure Read_GL_SUN_mesh_array;
14076 begin
14077 glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN');
14078 end;
14079
14080 procedure Read_GL_SUN_triangle_list;
14081 begin
14082 glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN');
14083 glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN');
14084 glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN');
14085 glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN');
14086 glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN');
14087 glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN');
14088 glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN');
14089 end;
14090
14091 procedure Read_GL_SUN_vertex;
14092 begin
14093 glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN');
14094 glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN');
14095 glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN');
14096 glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN');
14097 glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN');
14098 glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN');
14099 glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN');
14100 glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN');
14101 glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN');
14102 glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN');
14103 glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN');
14104 glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN');
14105 glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN');
14106 glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN');
14107 glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN');
14108 glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN');
14109 glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN');
14110 glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN');
14111 glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN');
14112 glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN');
14113 glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN');
14114 glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN');
14115 glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN');
14116 glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN');
14117 glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN');
14118 glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN');
14119 glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN');
14120 glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN');
14121 glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN');
14122 glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN');
14123 glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN');
14124 glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN');
14125 glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
14126 glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
14127 glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN');
14128 glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN');
14129 glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
14130 glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
14131 glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
14132 glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
14133 end;
14134
14135 {$IFDEF DGL_WIN}
14136 procedure Read_WGL_ARB_buffer_region;
14137 begin
14138 wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB');
14139 wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB');
14140 wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB');
14141 wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB');
14142 end;
14143
14144 procedure Read_WGL_ARB_extensions_string;
14145 begin
14146 wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
14147 end;
14148
14149 procedure Read_WGL_ARB_make_current_read;
14150 begin
14151 wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB');
14152 wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB');
14153 end;
14154
14155 procedure Read_WGL_ARB_pbuffer;
14156 begin
14157 wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB');
14158 wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB');
14159 wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB');
14160 wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB');
14161 wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB');
14162 end;
14163
14164 procedure Read_WGL_ARB_pixel_format;
14165 begin
14166 wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB');
14167 wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB');
14168 wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB');
14169 end;
14170
14171 procedure Read_WGL_ARB_pixel_format_float;
14172 begin
14173 wglClampColorARB := dglGetProcAddress('wglClampColorARB');
14174 end;
14175
14176 procedure Read_WGL_ARB_render_texture;
14177 begin
14178 wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB');
14179 wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB');
14180 wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB');
14181 end;
14182
14183 procedure Read_WGL_ARB_create_context;
14184 begin
14185 wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB');
14186 end;
14187
14188 procedure Read_WGL_AMD_gpu_association;
14189 begin
14190 wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD');
14191 wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD');
14192 wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD');
14193 wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD');
14194 wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD');
14195 wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD');
14196 wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD');
14197 wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD');
14198 wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD');
14199 end;
14200
14201 procedure Read_WGL_EXT_display_color_table;
14202 begin
14203 wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT');
14204 wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT');
14205 wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT');
14206 wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT');
14207 end;
14208
14209 procedure Read_WGL_EXT_extensions_string;
14210 begin
14211 wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
14212 end;
14213
14214 procedure Read_WGL_EXT_make_current_read;
14215 begin
14216 wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT');
14217 wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT');
14218 end;
14219
14220 procedure Read_WGL_EXT_pbuffer;
14221 begin
14222 wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT');
14223 wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT');
14224 wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT');
14225 wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT');
14226 wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT');
14227 end;
14228
14229 procedure Read_WGL_EXT_pixel_format;
14230 begin
14231 wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT');
14232 wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT');
14233 wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT');
14234 end;
14235
14236 procedure Read_WGL_EXT_swap_control;
14237 begin
14238 wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT');
14239 wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT');
14240 end;
14241
14242 procedure Read_WGL_I3D_digital_video_control;
14243 begin
14244 wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D');
14245 wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D');
14246 end;
14247
14248 procedure Read_WGL_I3D_gamma;
14249 begin
14250 wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D');
14251 wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D');
14252 wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D');
14253 wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D');
14254 end;
14255
14256 procedure Read_WGL_I3D_genlock;
14257 begin
14258 wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D');
14259 wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D');
14260 wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D');
14261 wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D');
14262 wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D');
14263 wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D');
14264 wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D');
14265 wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D');
14266 wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D');
14267 wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D');
14268 wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D');
14269 wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
14270 end;
14271
14272 procedure Read_WGL_I3D_image_buffer;
14273 begin
14274 wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D');
14275 wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D');
14276 wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D');
14277 wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D');
14278 end;
14279
14280 procedure Read_WGL_I3D_swap_frame_lock;
14281 begin
14282 wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D');
14283 wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D');
14284 wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D');
14285 wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D');
14286 end;
14287
14288 procedure Read_WGL_I3D_swap_frame_usage;
14289 begin
14290 wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D');
14291 wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D');
14292 wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D');
14293 wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D');
14294 end;
14295
14296 procedure Read_WGL_NV_vertex_array_range;
14297 begin
14298 wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV');
14299 wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV');
14300 end;
14301
14302 procedure Read_WGL_NV_present_video;
14303 begin
14304 wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV');
14305 wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV');
14306 wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV');
14307 end;
14308
14309 procedure Read_WGL_NV_video_out;
14310 begin
14311 wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV');
14312 wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV');
14313 wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV');
14314 wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV');
14315 wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV');
14316 wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV');
14317 end;
14318
14319 procedure Read_WGL_NV_swap_group;
14320 begin
14321 wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV');
14322 wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV');
14323 wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV');
14324 wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV');
14325 wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV');
14326 wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV');
14327 end;
14328
14329 procedure Read_WGL_NV_gpu_affinity;
14330 begin
14331 wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV');
14332 wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV');
14333 wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV');
14334 wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV');
14335 wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV');
14336 end;
14337
14338 procedure Read_WGL_OML_sync_control;
14339 begin
14340 wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML');
14341 wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML');
14342 wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML');
14343 wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML');
14344 wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML');
14345 wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML');
14346 end;
14347
14348 procedure Read_WGL_3DL_stereo_control;
14349 begin
14350 wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL');
14351 end;
14352
14353 procedure Read_WIN_draw_range_elements;
14354 begin
14355 glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN');
14356 end;
14357
14358 procedure Read_WIN_swap_hint;
14359 begin
14360 glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN');
14361 end;
14362 {$ENDIF}
14363
14364
14365 procedure ReadExtensions;
14366 begin
14367 ReadOpenGLCore;
14368
14369 Read_GL_3DFX_tbuffer;
14370 Read_GL_APPLE_element_array;
14371 Read_GL_APPLE_fence;
14372 Read_GL_APPLE_vertex_array_object;
14373 Read_GL_APPLE_vertex_array_range;
14374 Read_GL_APPLE_texture_range;
14375 Read_GL_APPLE_vertex_program_evaluators;
14376 Read_GL_APPLE_object_purgeable;
14377 Read_GL_ARB_matrix_palette;
14378 Read_GL_ARB_multitexture;
14379 Read_GL_ARB_point_parameters;
14380 Read_GL_ARB_texture_compression;
14381 Read_GL_ARB_transpose_matrix;
14382 Read_GL_ARB_vertex_blend;
14383 Read_GL_ARB_vertex_buffer_object;
14384 Read_GL_ARB_vertex_program;
14385 Read_GL_ARB_window_pos;
14386 Read_GL_ARB_color_buffer_float;
14387 Read_GL_ARB_Shader_Objects;
14388 Read_GL_ARB_occlusion_query;
14389 Read_GL_ARB_draw_instanced;
14390 Read_GL_ARB_framebuffer_object;
14391 Read_GL_ARB_geometry_shader4;
14392 Read_GL_ARB_instanced_arrays;
14393 Read_GL_ARB_map_buffer_range;
14394 Read_GL_ARB_texture_buffer_object;
14395 Read_GL_ARB_vertex_array_object;
14396 Read_GL_ARB_uniform_buffer_object;
14397 Read_GL_ARB_copy_buffer;
14398 Read_GL_ARB_draw_elements_base_vertex;
14399 Read_GL_ARB_provoking_vertex;
14400 Read_GL_ARB_sync;
14401 Read_GL_ARB_texture_multisample;
14402 Read_GL_ARB_draw_buffers_blend;
14403 Read_GL_ARB_sample_shading;
14404 Read_GL_ATI_draw_buffers;
14405 Read_GL_ATI_element_array;
14406 Read_GL_ATI_envmap_bumpmap;
14407 Read_GL_ATI_fragment_shader;
14408 Read_GL_ATI_map_object_buffer;
14409 Read_GL_ATI_pn_triangles;
14410 Read_GL_ATI_separate_stencil;
14411 Read_GL_ATI_vertex_array_object;
14412 Read_GL_ATI_vertex_attrib_array_object;
14413 Read_GL_ATI_vertex_streams;
14414 Read_GL_AMD_performance_monitor;
14415 Read_GL_EXT_blend_color;
14416 Read_GL_EXT_blend_func_separate;
14417 Read_GL_EXT_blend_minmax;
14418 Read_GL_EXT_color_subtable;
14419 Read_GL_EXT_compiled_vertex_array;
14420 Read_GL_EXT_convolution;
14421 Read_GL_EXT_coordinate_frame;
14422 Read_GL_EXT_copy_texture;
14423 Read_GL_EXT_cull_vertex;
14424 Read_GL_EXT_draw_range_elements;
14425 Read_GL_EXT_fog_coord;
14426 Read_GL_EXT_framebuffer_object;
14427 Read_GL_EXT_histogram;
14428 Read_GL_EXT_index_func;
14429 Read_GL_EXT_index_material;
14430 Read_GL_EXT_multi_draw_arrays;
14431 Read_GL_EXT_multisample;
14432 Read_GL_EXT_paletted_texture;
14433 Read_GL_EXT_pixel_transform;
14434 Read_GL_EXT_point_parameters;
14435 Read_GL_EXT_polygon_offset;
14436 Read_GL_EXT_secondary_color;
14437 Read_GL_EXT_stencil_two_side;
14438 Read_GL_EXT_subtexture;
14439 Read_GL_EXT_texture3D;
14440 Read_GL_EXT_texture_object;
14441 Read_GL_EXT_texture_perturb_normal;
14442 Read_GL_EXT_vertex_array;
14443 Read_GL_EXT_vertex_shader;
14444 Read_GL_EXT_vertex_weighting;
14445 Read_GL_EXT_depth_bounds_test;
14446 Read_GL_EXT_blend_equation_separate;
14447 Read_GL_EXT_stencil_clear_tag;
14448 Read_GL_EXT_framebuffer_blit;
14449 Read_GL_EXT_framebuffer_multisample;
14450 Read_GL_EXT_timer_query;
14451 Read_GL_EXT_gpu_program_parameters;
14452 Read_GL_EXT_bindable_uniform;
14453 Read_GL_EXT_draw_buffers2;
14454 Read_GL_EXT_draw_instanced;
14455 Read_GL_EXT_geometry_shader4;
14456 Read_GL_EXT_gpu_shader4;
14457 Read_GL_EXT_texture_array;
14458 Read_GL_EXT_texture_buffer_object;
14459 Read_GL_EXT_texture_integer;
14460 Read_GL_EXT_transform_feedback;
14461 Read_GL_EXT_direct_state_access;
14462 Read_GL_HP_image_transform;
14463 Read_GL_IBM_multimode_draw_arrays;
14464 Read_GL_IBM_vertex_array_lists;
14465 Read_GL_INGR_blend_func_separate;
14466 Read_GL_INTEL_parallel_arrays;
14467 Read_GL_MESA_resize_buffers;
14468 Read_GL_MESA_window_pos;
14469 Read_GL_NV_evaluators;
14470 Read_GL_NV_fence;
14471 Read_GL_NV_fragment_program;
14472 Read_GL_NV_half_float;
14473 Read_GL_NV_occlusion_query;
14474 Read_GL_NV_pixel_data_range;
14475 Read_GL_NV_point_sprite;
14476 Read_GL_NV_primitive_restart;
14477 Read_GL_NV_register_combiners;
14478 Read_GL_NV_register_combiners2;
14479 Read_GL_NV_vertex_array_range;
14480 Read_GL_NV_vertex_program;
14481 Read_GL_NV_depth_buffer_float;
14482 Read_GL_NV_framebuffer_multisample_coverage;
14483 Read_GL_NV_geometry_program4;
14484 Read_GL_NV_gpu_program4;
14485 Read_GL_NV_parameter_buffer_object;
14486 Read_GL_NV_transform_feedback;
14487 Read_GL_NV_conditional_render;
14488 Read_GL_NV_present_video;
14489 Read_GL_NV_explicit_multisample;
14490 Read_GL_NV_transform_feedback2;
14491 Read_GL_PGI_misc_hints;
14492 Read_GL_SGIS_detail_texture;
14493 Read_GL_SGIS_fog_function;
14494 Read_GL_SGIS_multisample;
14495 Read_GL_SGIS_pixel_texture;
14496 Read_GL_SGIS_point_parameters;
14497 Read_GL_SGIS_sharpen_texture;
14498 Read_GL_SGIS_texture4D;
14499 Read_GL_SGIS_texture_color_mask;
14500 Read_GL_SGIS_texture_filter4;
14501 Read_GL_SGIX_async;
14502 Read_GL_SGIX_flush_raster;
14503 Read_GL_SGIX_fragment_lighting;
14504 Read_GL_SGIX_framezoom;
14505 Read_GL_SGIX_igloo_interface;
14506 Read_GL_SGIX_instruments;
14507 Read_GL_SGIX_list_priority;
14508 Read_GL_SGIX_pixel_texture;
14509 Read_GL_SGIX_polynomial_ffd;
14510 Read_GL_SGIX_reference_plane;
14511 Read_GL_SGIX_sprite;
14512 Read_GL_SGIX_tag_sample_buffer;
14513 Read_GL_SGI_color_table;
14514 Read_GL_SUNX_constant_data;
14515 Read_GL_SUN_global_alpha;
14516 Read_GL_SUN_mesh_array;
14517 Read_GL_SUN_triangle_list;
14518 Read_GL_SUN_vertex;
14519
14520 {$IFDEF DGL_WIN}
14521 Read_WGL_ARB_buffer_region;
14522 Read_WGL_ARB_extensions_string;
14523 Read_WGL_ARB_make_current_read;
14524 Read_WGL_ARB_pbuffer;
14525 Read_WGL_ARB_pixel_format;
14526 Read_WGL_ARB_pixel_format_float;
14527 Read_WGL_ARB_render_texture;
14528 Read_WGL_ARB_create_context;
14529 Read_WGL_AMD_gpu_association;
14530 Read_WGL_EXT_display_color_table;
14531 Read_WGL_EXT_extensions_string;
14532 Read_WGL_EXT_make_current_read;
14533 Read_WGL_EXT_pbuffer;
14534 Read_WGL_EXT_pixel_format;
14535 Read_WGL_EXT_swap_control;
14536 Read_WGL_I3D_digital_video_control;
14537 Read_WGL_I3D_gamma;
14538 Read_WGL_I3D_genlock;
14539 Read_WGL_I3D_image_buffer;
14540 Read_WGL_I3D_swap_frame_lock;
14541 Read_WGL_I3D_swap_frame_usage;
14542 Read_WGL_NV_vertex_array_range;
14543 Read_WGL_NV_present_video;
14544 Read_WGL_NV_video_out;
14545 Read_WGL_NV_swap_group;
14546 Read_WGL_NV_gpu_affinity;
14547 Read_WGL_OML_sync_control;
14548 Read_WGL_3DL_stereo_control;
14549
14550 Read_WIN_draw_range_elements;
14551 Read_WIN_swap_hint;
14552 {$ENDIF}
14553
14554 ExtensionsRead := True;
14555 end;
14556
14557 // =============================================================================
14558 // ReadCoreVersion
14559 // =============================================================================
14560
14561 procedure ReadCoreVersion;
14562 var
14563 AnsiBuffer: AnsiString;
14564 Buffer: String;
14565 MajorVersion, MinorVersion: Integer;
14566
14567 procedure TrimAndSplitVersionString(Buffer: String; var Max, Min: Integer);
14568 // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
14569 // at least however "Major.Minor".
14570 var
14571 Separator: Integer;
14572 begin
14573 try
14574 // There must be at least one dot to separate major and minor version number.
14575 Separator := Pos('.', Buffer);
14576 // At least one number must be before and one after the dot.
14577 if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and
14578 (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then
14579 begin
14580 // OK, it's a valid version string. Now remove unnecessary parts.
14581 Dec(Separator);
14582 // Find last non-numeric character before version number.
14583 while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
14584 Dec(Separator);
14585 // Delete leading characters which do not belong to the version string.
14586 Delete(Buffer, 1, Separator);
14587 Separator := Pos('.', Buffer) + 1;
14588 // Find first non-numeric character after version number
14589 while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
14590 Inc(Separator);
14591 // delete trailing characters not belonging to the version string
14592 Delete(Buffer, Separator, 255);
14593 // Now translate the numbers.
14594 Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.
14595 Max := StrToInt(Copy(Buffer, 1, Separator - 1));
14596 Min := StrToInt(Copy(Buffer, Separator + 1, 1));
14597 end
14598 else
14599 Abort;
14600 except
14601 Min := 0;
14602 Max := 0;
14603 end;
14604 end;
14605
14606
14607 begin
14608 // determine version of implementation
14609 // GL
14610 if not Assigned(@glGetString) then
14611 glGetString := dglGetProcAddress('glGetString');
14612
14613 AnsiBuffer := glGetString(GL_VERSION);
14614 Buffer := String(AnsiBuffer);
14615
14616 TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion);
14617
14618 GL_VERSION_1_0 := True;
14619 GL_VERSION_1_1 := False;
14620 GL_VERSION_1_2 := False;
14621 GL_VERSION_1_3 := False;
14622 GL_VERSION_1_4 := False;
14623 GL_VERSION_1_5 := False;
14624 GL_VERSION_2_0 := False;
14625 GL_VERSION_2_1 := False;
14626 GL_VERSION_3_0 := False;
14627 GL_VERSION_3_1 := False;
14628 GL_VERSION_3_2 := False;
14629
14630 if MajorVersion = 1 then
14631 begin
14632 if MinorVersion >= 1 then
14633 GL_VERSION_1_1 := True;
14634 if MinorVersion >= 2 then
14635 GL_VERSION_1_2 := True;
14636 if MinorVersion >= 3 then
14637 GL_VERSION_1_3 := True;
14638 if MinorVersion >= 4 then
14639 GL_VERSION_1_4 := True;
14640 if MinorVersion >= 5 then
14641 GL_VERSION_1_5 := True;
14642 end;
14643
14644 if MajorVersion >= 2 then
14645 begin
14646 GL_VERSION_1_1 := True;
14647 GL_VERSION_1_2 := True;
14648 GL_VERSION_1_3 := True;
14649 GL_VERSION_1_4 := True;
14650 GL_VERSION_1_5 := True;
14651 GL_VERSION_2_0 := True;
14652
14653 if MinorVersion >= 1 then
14654 GL_VERSION_2_1 := True;
14655 end;
14656
14657 if MajorVersion >= 3 then
14658 begin
14659 GL_VERSION_2_1 := True;
14660 GL_VERSION_3_0 := True;
14661
14662 if MinorVersion >= 1 then
14663 GL_VERSION_3_1 := True;
14664 if MinorVersion >= 2 then
14665 GL_VERSION_3_2 := True;
14666 end;
14667
14668
14669 // GLU
14670 GLU_VERSION_1_1 := False;
14671 GLU_VERSION_1_2 := False;
14672 GLU_VERSION_1_3 := False;
14673
14674 if Assigned(gluGetString) then begin
14675 AnsiBuffer := gluGetString(GLU_VERSION);
14676 Buffer := String(AnsiBuffer);
14677
14678 TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion);
14679
14680 GLU_VERSION_1_1 := True;
14681
14682 if MinorVersion >= 2 then
14683 GLU_VERSION_1_2 := True;
14684
14685 if MinorVersion >= 3 then
14686 GLU_VERSION_1_3 := True;
14687 end;
14688 end;
14689
14690
14691 // =============================================================================
14692 // ReadImplementationProperties
14693 // =============================================================================
14694
14695 procedure ReadImplementationProperties;
14696 var
14697 Buffer: Ansistring;
14698 begin
14699 ReadCoreVersion;
14700
14701 // Check all extensions
14702 Buffer := Int_GetExtensionString;
14703
14704 // === 3DFX ====================================================================
14705 GL_3DFX_multisample := Int_CheckExtension(Buffer, 'GL_3DFX_multisample');
14706 GL_3DFX_tbuffer := Int_CheckExtension(Buffer, 'GL_3DFX_tbuffer');
14707 GL_3DFX_texture_compression_FXT1 := Int_CheckExtension(Buffer, 'GL_3DFX_texture_compression_FXT1');
14708
14709 // === APPLE ===================================================================
14710 GL_APPLE_client_storage := Int_CheckExtension(Buffer, 'GL_APPLE_client_storage');
14711 GL_APPLE_element_array := Int_CheckExtension(Buffer, 'GL_APPLE_element_array');
14712 GL_APPLE_fence := Int_CheckExtension(Buffer, 'GL_APPLE_fence');
14713 GL_APPLE_specular_vector := Int_CheckExtension(Buffer, 'GL_APPLE_specular_vector');
14714 GL_APPLE_transform_hint := Int_CheckExtension(Buffer, 'GL_APPLE_transform_hint');
14715 GL_APPLE_vertex_array_object := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_object');
14716 GL_APPLE_vertex_array_range := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_range');
14717 GL_APPLE_ycbcr_422 := Int_CheckExtension(Buffer, 'GL_APPLE_ycbcr_422');
14718 GL_APPLE_texture_range := Int_CheckExtension(Buffer, 'GL_APPLE_texture_range');
14719 GL_APPLE_float_pixels := Int_CheckExtension(Buffer, 'GL_APPLE_float_pixels');
14720 GL_APPLE_vertex_program_evaluators := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_program_evaluators');
14721 GL_APPLE_aux_depth_stencil := Int_CheckExtension(Buffer, 'GL_APPLE_aux_depth_stencil');
14722 GL_APPLE_object_purgeable := Int_CheckExtension(Buffer, 'GL_APPLE_object_purgeable');
14723
14724 // === ARB =====================================================================
14725 GL_ARB_depth_texture := Int_CheckExtension(Buffer, 'GL_ARB_depth_texture');
14726 GL_ARB_fragment_program := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program');
14727 GL_ARB_imaging := Int_CheckExtension(Buffer, 'GL_ARB_imaging');
14728 GL_ARB_matrix_palette := Int_CheckExtension(Buffer, 'GL_ARB_matrix_palette');
14729 GL_ARB_multisample := Int_CheckExtension(Buffer, 'GL_ARB_multisample');
14730 GL_ARB_multitexture := Int_CheckExtension(Buffer, 'GL_ARB_multitexture');
14731 GL_ARB_point_parameters := Int_CheckExtension(Buffer, 'GL_ARB_point_parameters');
14732 GL_ARB_shadow := Int_CheckExtension(Buffer, 'GL_ARB_shadow');
14733 GL_ARB_shadow_ambient := Int_CheckExtension(Buffer, 'GL_ARB_shadow_ambient');
14734 GL_ARB_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp');
14735 GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression');
14736 GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map');
14737 GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add');
14738 GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine');
14739 GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar');
14740 GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3');
14741 GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat');
14742 GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix');
14743 GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend');
14744 GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object');
14745 GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program');
14746 GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos');
14747 GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects');
14748 GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader');
14749 GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader');
14750 GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query');
14751 GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100');
14752 GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite');
14753 GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two');
14754 GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow');
14755 GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers');
14756 GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle');
14757 GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float');
14758 GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel');
14759 GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float');
14760 GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object');
14761 GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float');
14762 GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced');
14763 GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object');
14764 GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB');
14765 GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4');
14766 GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex');
14767 GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays');
14768 GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range');
14769 GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object');
14770 GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc');
14771 GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg');
14772 GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object');
14773 GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object');
14774 GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility');
14775 GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer');
14776 GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod');
14777 GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp');
14778 GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex');
14779 GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions');
14780 GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex');
14781 GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map');
14782 GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync');
14783 GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample');
14784 GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra');
14785 GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend');
14786 GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading');
14787 GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array');
14788 GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather');
14789 GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod');
14790
14791 // === ATI/AMD =================================================================
14792 GL_ATI_draw_buffers := Int_CheckExtension(Buffer, 'GL_ATI_draw_buffers');
14793 GL_ATI_element_array := Int_CheckExtension(Buffer, 'GL_ATI_element_array');
14794 GL_ATI_envmap_bumpmap := Int_CheckExtension(Buffer, 'GL_ATI_envmap_bumpmap');
14795 GL_ATI_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_fragment_shader');
14796 GL_ATI_map_object_buffer := Int_CheckExtension(Buffer, 'GL_ATI_map_object_buffer');
14797 GL_ATI_pn_triangles := Int_CheckExtension(Buffer, 'GL_ATI_pn_triangles');
14798 GL_ATI_separate_stencil := Int_CheckExtension(Buffer, 'GL_ATI_separate_stencil');
14799 GL_ATI_text_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_text_fragment_shader');
14800 GL_ATI_texture_env_combine3 := Int_CheckExtension(Buffer, 'GL_ATI_texture_env_combine3');
14801 GL_ATI_texture_float := Int_CheckExtension(Buffer, 'GL_ATI_texture_float');
14802 GL_ATI_texture_mirror_once := Int_CheckExtension(Buffer, 'GL_ATI_texture_mirror_once');
14803 GL_ATI_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_array_object');
14804 GL_ATI_vertex_attrib_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_attrib_array_object');
14805 GL_ATI_vertex_streams := Int_CheckExtension(Buffer, 'GL_ATI_vertex_streams');
14806 GL_ATI_meminfo := Int_CheckExtension(Buffer, 'GL_ATI_meminfo');
14807 GL_AMD_performance_monitor := Int_CheckExtension(Buffer, 'GL_AMD_performance_monitor');
14808 GL_AMD_texture_texture4 := Int_CheckExtension(Buffer, 'GL_AMD_texture_texture4');
14809 GL_AMD_vertex_shader_tesselator := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_tesselator');
14810
14811 // === EXT =====================================================================
14812 GL_EXT_422_pixels := Int_CheckExtension(Buffer, 'GL_EXT_422_pixels');
14813 GL_EXT_abgr := Int_CheckExtension(Buffer, 'GL_EXT_abgr');
14814 GL_EXT_bgra := Int_CheckExtension(Buffer, 'GL_EXT_bgra');
14815 GL_EXT_blend_color := Int_CheckExtension(Buffer, 'GL_EXT_blend_color');
14816 GL_EXT_blend_func_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_func_separate');
14817 GL_EXT_blend_logic_op := Int_CheckExtension(Buffer, 'GL_EXT_blend_logic_op');
14818 GL_EXT_blend_minmax := Int_CheckExtension(Buffer, 'GL_EXT_blend_minmax');
14819 GL_EXT_blend_subtract := Int_CheckExtension(Buffer, 'GL_EXT_blend_subtract');
14820 GL_EXT_clip_volume_hint := Int_CheckExtension(Buffer, 'GL_EXT_clip_volume_hint');
14821 GL_EXT_cmyka := Int_CheckExtension(Buffer, 'GL_EXT_cmyka');
14822 GL_EXT_color_matrix := Int_CheckExtension(Buffer, 'GL_EXT_color_matrix');
14823 GL_EXT_color_subtable := Int_CheckExtension(Buffer, 'GL_EXT_color_subtable');
14824 GL_EXT_compiled_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_compiled_vertex_array');
14825 GL_EXT_convolution := Int_CheckExtension(Buffer, 'GL_EXT_convolution');
14826 GL_EXT_coordinate_frame := Int_CheckExtension(Buffer, 'GL_EXT_coordinate_frame');
14827 GL_EXT_copy_texture := Int_CheckExtension(Buffer, 'GL_EXT_copy_texture');
14828 GL_EXT_cull_vertex := Int_CheckExtension(Buffer, 'GL_EXT_cull_vertex');
14829 GL_EXT_draw_range_elements := Int_CheckExtension(Buffer, 'GL_EXT_draw_range_elements');
14830 GL_EXT_fog_coord := Int_CheckExtension(Buffer, 'GL_EXT_fog_coord');
14831 GL_EXT_framebuffer_object := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_object');
14832 GL_EXT_histogram := Int_CheckExtension(Buffer, 'GL_EXT_histogram');
14833 GL_EXT_index_array_formats := Int_CheckExtension(Buffer, 'GL_EXT_index_array_formats');
14834 GL_EXT_index_func := Int_CheckExtension(Buffer, 'GL_EXT_index_func');
14835 GL_EXT_index_material := Int_CheckExtension(Buffer, 'GL_EXT_index_material');
14836 GL_EXT_index_texture := Int_CheckExtension(Buffer, 'GL_EXT_index_texture');
14837 GL_EXT_light_texture := Int_CheckExtension(Buffer, 'GL_EXT_light_texture');
14838 GL_EXT_misc_attribute := Int_CheckExtension(Buffer, 'GL_EXT_misc_attribute');
14839 GL_EXT_multi_draw_arrays := Int_CheckExtension(Buffer, 'GL_EXT_multi_draw_arrays');
14840 GL_EXT_multisample := Int_CheckExtension(Buffer, 'GL_EXT_multisample');
14841 GL_EXT_packed_pixels := Int_CheckExtension(Buffer, 'GL_EXT_packed_pixels');
14842 GL_EXT_paletted_texture := Int_CheckExtension(Buffer, 'GL_EXT_paletted_texture');
14843 GL_EXT_pixel_transform := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform');
14844 GL_EXT_pixel_transform_color_table := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform_color_table');
14845 GL_EXT_point_parameters := Int_CheckExtension(Buffer, 'GL_EXT_point_parameters');
14846 GL_EXT_polygon_offset := Int_CheckExtension(Buffer, 'GL_EXT_polygon_offset');
14847 GL_EXT_rescale_normal := Int_CheckExtension(Buffer, 'GL_EXT_rescale_normal');
14848 GL_EXT_secondary_color := Int_CheckExtension(Buffer, 'GL_EXT_secondary_color');
14849 GL_EXT_separate_specular_color := Int_CheckExtension(Buffer, 'GL_EXT_separate_specular_color');
14850 GL_EXT_shadow_funcs := Int_CheckExtension(Buffer, 'GL_EXT_shadow_funcs');
14851 GL_EXT_shared_texture_palette := Int_CheckExtension(Buffer, 'GL_EXT_shared_texture_palette');
14852 GL_EXT_stencil_two_side := Int_CheckExtension(Buffer, 'GL_EXT_stencil_two_side');
14853 GL_EXT_stencil_wrap := Int_CheckExtension(Buffer, 'GL_EXT_stencil_wrap');
14854 GL_EXT_subtexture := Int_CheckExtension(Buffer, 'GL_EXT_subtexture');
14855 GL_EXT_texture := Int_CheckExtension(Buffer, 'GL_EXT_texture');
14856 GL_EXT_texture3D := Int_CheckExtension(Buffer, 'GL_EXT_texture3D');
14857 GL_EXT_texture_compression_s3tc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_s3tc');
14858 GL_EXT_texture_cube_map := Int_CheckExtension(Buffer, 'GL_EXT_texture_cube_map');
14859 GL_EXT_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_edge_clamp');
14860 GL_EXT_texture_env_add := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_add');
14861 GL_EXT_texture_env_combine := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_combine');
14862 GL_EXT_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_dot3');
14863 GL_EXT_texture_filter_anisotropic := Int_CheckExtension(Buffer, 'GL_EXT_texture_filter_anisotropic');
14864 GL_EXT_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_EXT_texture_lod_bias');
14865 GL_EXT_texture_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_object');
14866 GL_EXT_texture_perturb_normal := Int_CheckExtension(Buffer, 'GL_EXT_texture_perturb_normal');
14867 GL_EXT_texture_rectangle := Int_CheckExtension(Buffer, 'GL_EXT_texture_rectangle');
14868 GL_EXT_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array');
14869 GL_EXT_vertex_shader := Int_CheckExtension(Buffer, 'GL_EXT_vertex_shader');
14870 GL_EXT_vertex_weighting := Int_CheckExtension(Buffer, 'GL_EXT_vertex_weighting');
14871 GL_EXT_depth_bounds_test := Int_CheckExtension(Buffer, 'GL_EXT_depth_bounds_test');
14872 GL_EXT_texture_mirror_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_mirror_clamp');
14873 GL_EXT_blend_equation_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_equation_separate');
14874 GL_EXT_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_pixel_buffer_object');
14875 GL_EXT_texture_compression_dxt1 := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_dxt1');
14876 GL_EXT_stencil_clear_tag := Int_CheckExtension(Buffer, 'GL_EXT_stencil_clear_tag');
14877 GL_EXT_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_EXT_packed_depth_stencil');
14878 GL_EXT_texture_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB');
14879 GL_EXT_framebuffer_blit := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_blit');
14880 GL_EXT_framebuffer_multisample := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_multisample');
14881 GL_EXT_timer_query := Int_CheckExtension(Buffer, 'GL_EXT_timer_query');
14882 GL_EXT_gpu_program_parameters := Int_CheckExtension(Buffer, 'GL_EXT_gpu_program_parameters');
14883 GL_EXT_bindable_uniform := Int_CheckExtension(Buffer, 'GL_EXT_bindable_uniform');
14884 GL_EXT_draw_buffers2 := Int_CheckExtension(Buffer, 'GL_EXT_draw_buffers2');
14885 GL_EXT_draw_instanced := Int_CheckExtension(Buffer, 'GL_EXT_draw_instanced');
14886 GL_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_sRGB');
14887 GL_EXT_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_geometry_shader4');
14888 GL_EXT_gpu_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_gpu_shader4');
14889 GL_EXT_packed_float := Int_CheckExtension(Buffer, 'GL_EXT_packed_float');
14890 GL_EXT_texture_array := Int_CheckExtension(Buffer, 'GL_EXT_texture_array');
14891 GL_EXT_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_buffer_object');
14892 GL_EXT_texture_compression_latc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_latc');
14893 GL_EXT_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_rgtc');
14894 GL_EXT_texture_integer := Int_CheckExtension(Buffer, 'GL_EXT_texture_integer');
14895 GL_EXT_texture_shared_exponent := Int_CheckExtension(Buffer, 'GL_EXT_texture_shared_exponent');
14896 GL_EXT_transform_feedback := Int_CheckExtension(Buffer, 'GL_EXT_transform_feedback');
14897 GL_EXT_direct_state_access := Int_CheckExtension(Buffer, 'GL_EXT_direct_state_access');
14898 GL_EXT_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array_bgra');
14899 GL_EXT_texture_swizzle := Int_CheckExtension(Buffer, 'GL_EXT_texture_swizzle');
14900 GL_EXT_provoking_vertex := Int_CheckExtension(Buffer, 'GL_EXT_provoking_vertex');
14901
14902 // === HP ======================================================================
14903 GL_HP_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_HP_convolution_border_modes');
14904 GL_HP_image_transform := Int_CheckExtension(Buffer, 'GL_HP_image_transform');
14905 GL_HP_occlusion_test := Int_CheckExtension(Buffer, 'GL_HP_occlusion_test');
14906 GL_HP_texture_lighting := Int_CheckExtension(Buffer, 'GL_HP_texture_lighting');
14907
14908 // === IBM =====================================================================
14909 GL_IBM_cull_vertex := Int_CheckExtension(Buffer, 'GL_IBM_cull_vertex');
14910 GL_IBM_multimode_draw_arrays := Int_CheckExtension(Buffer, 'GL_IBM_multimode_draw_arrays');
14911 GL_IBM_rasterpos_clip := Int_CheckExtension(Buffer, 'GL_IBM_rasterpos_clip');
14912 GL_IBM_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_IBM_texture_mirrored_repeat');
14913 GL_IBM_vertex_array_lists := Int_CheckExtension(Buffer, 'GL_IBM_vertex_array_lists');
14914
14915 // === INGR ====================================================================
14916 GL_INGR_blend_func_separate := Int_CheckExtension(Buffer, 'GL_INGR_blend_func_separate');
14917 GL_INGR_color_clamp := Int_CheckExtension(Buffer, 'GL_INGR_color_clamp');
14918 GL_INGR_interlace_read := Int_CheckExtension(Buffer, 'GL_INGR_interlace_read');
14919 GL_INGR_palette_buffer := Int_CheckExtension(Buffer, 'GL_INGR_palette_buffer');
14920
14921 // === INTEL ===================================================================
14922 GL_INTEL_parallel_arrays := Int_CheckExtension(Buffer, 'GL_INTEL_parallel_arrays');
14923 GL_INTEL_texture_scissor := Int_CheckExtension(Buffer, 'GL_INTEL_texture_scissor');
14924
14925 // === MESA ====================================================================
14926 GL_MESA_resize_buffers := Int_CheckExtension(Buffer, 'GL_MESA_resize_buffers');
14927 GL_MESA_window_pos := Int_CheckExtension(Buffer, 'GL_MESA_window_pos');
14928
14929 // === NVIDIA ==================================================================
14930 GL_NV_blend_square := Int_CheckExtension(Buffer, 'GL_NV_blend_square');
14931 GL_NV_copy_depth_to_color := Int_CheckExtension(Buffer, 'GL_NV_copy_depth_to_color');
14932 GL_NV_depth_clamp := Int_CheckExtension(Buffer, 'GL_NV_depth_clamp');
14933 GL_NV_evaluators := Int_CheckExtension(Buffer, 'GL_NV_evaluators');
14934 GL_NV_fence := Int_CheckExtension(Buffer, 'GL_NV_fence');
14935 GL_NV_float_buffer := Int_CheckExtension(Buffer, 'GL_NV_float_buffer');
14936 GL_NV_fog_distance := Int_CheckExtension(Buffer, 'GL_NV_fog_distance');
14937 GL_NV_fragment_program := Int_CheckExtension(Buffer, 'GL_NV_fragment_program');
14938 GL_NV_half_float := Int_CheckExtension(Buffer, 'GL_NV_half_float');
14939 GL_NV_light_max_exponent := Int_CheckExtension(Buffer, 'GL_NV_light_max_exponent');
14940 GL_NV_multisample_filter_hint := Int_CheckExtension(Buffer, 'GL_NV_multisample_filter_hint');
14941 GL_NV_occlusion_query := Int_CheckExtension(Buffer, 'GL_NV_occlusion_query');
14942 GL_NV_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_NV_packed_depth_stencil');
14943 GL_NV_pixel_data_range := Int_CheckExtension(Buffer, 'GL_NV_pixel_data_range');
14944 GL_NV_point_sprite := Int_CheckExtension(Buffer, 'GL_NV_point_sprite');
14945 GL_NV_primitive_restart := Int_CheckExtension(Buffer, 'GL_NV_primitive_restart');
14946 GL_NV_register_combiners := Int_CheckExtension(Buffer, 'GL_NV_register_combiners');
14947 GL_NV_register_combiners2 := Int_CheckExtension(Buffer, 'GL_NV_register_combiners2');
14948 GL_NV_texgen_emboss := Int_CheckExtension(Buffer, 'GL_NV_texgen_emboss');
14949 GL_NV_texgen_reflection := Int_CheckExtension(Buffer, 'GL_NV_texgen_reflection');
14950 GL_NV_texture_compression_vtc := Int_CheckExtension(Buffer, 'GL_NV_texture_compression_vtc');
14951 GL_NV_texture_env_combine4 := Int_CheckExtension(Buffer, 'GL_NV_texture_env_combine4');
14952 GL_NV_texture_expand_normal := Int_CheckExtension(Buffer, 'GL_NV_texture_expand_normal');
14953 GL_NV_texture_rectangle := Int_CheckExtension(Buffer, 'GL_NV_texture_rectangle');
14954 GL_NV_texture_shader := Int_CheckExtension(Buffer, 'GL_NV_texture_shader');
14955 GL_NV_texture_shader2 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader2');
14956 GL_NV_texture_shader3 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader3');
14957 GL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range');
14958 GL_NV_vertex_array_range2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range2');
14959 GL_NV_vertex_program := Int_CheckExtension(Buffer, 'GL_NV_vertex_program');
14960 GL_NV_vertex_program1_1 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program1_1');
14961 GL_NV_vertex_program2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2');
14962 GL_NV_fragment_program_option := Int_CheckExtension(Buffer, 'GL_NV_fragment_program_option');
14963 GL_NV_fragment_program2 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program2');
14964 GL_NV_vertex_program2_option := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2_option');
14965 GL_NV_vertex_program3 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program3');
14966 GL_NV_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_NV_depth_buffer_float');
14967 GL_NV_fragment_program4 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program4');
14968 GL_NV_framebuffer_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_framebuffer_multisample_coverage');
14969 GL_NV_geometry_program4 := Int_CheckExtension(Buffer, 'GL_NV_geometry_program4');
14970 GL_NV_gpu_program4 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program4');
14971 GL_NV_parameter_buffer_object := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object');
14972 GL_NV_transform_feedback := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback');
14973 GL_NV_vertex_program4 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program4');
14974 GL_NV_conditional_render := Int_CheckExtension(Buffer, 'GL_NV_conditional_render');
14975 GL_NV_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video');
14976 GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample');
14977 GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2');
14978
14979 // === OML =====================================================================
14980 GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace');
14981 GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample');
14982 GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample');
14983
14984 // === PGI =====================================================================
14985 GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints');
14986 GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints');
14987
14988 // === REND ====================================================================
14989 GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates');
14990
14991 // === S3 ======================================================================
14992 GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc');
14993
14994 // === SGIS ====================================================================
14995 GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture');
14996 GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function');
14997 GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap');
14998 GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample');
14999 GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture');
15000 GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen');
15001 GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters');
15002 GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture');
15003 GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D');
15004 GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp');
15005 GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask');
15006 GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp');
15007 GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4');
15008 GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod');
15009 GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select');
15010
15011 // === SGIX ====================================================================
15012 GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX');
15013 GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async');
15014 GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram');
15015 GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel');
15016 GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax');
15017 GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment');
15018 GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap');
15019 GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy');
15020 GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument');
15021 GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture');
15022 GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster');
15023 GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset');
15024 GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale');
15025 GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting');
15026 GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom');
15027 GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface');
15028 GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture');
15029 GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments');
15030 GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace');
15031 GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1');
15032 GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority');
15033 GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture');
15034 GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles');
15035 GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd');
15036 GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane');
15037 GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample');
15038 GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint');
15039 GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow');
15040 GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient');
15041 GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite');
15042 GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample');
15043 GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer');
15044 GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env');
15045 GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp');
15046 GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias');
15047 GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer');
15048 GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias');
15049 GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select');
15050 GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip');
15051 GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb');
15052 GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample');
15053 GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba');
15054
15055 // === SGI =====================================================================
15056 GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix');
15057 GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table');
15058 GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument');
15059 GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table');
15060
15061 // === SUN =====================================================================
15062 GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data');
15063 GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes');
15064 GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha');
15065 GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array');
15066 GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum');
15067 GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list');
15068 GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex');
15069
15070 // === WIN =====================================================================
15071 GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading');
15072 GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog');
15073
15074 {$IFDEF DGL_WIN}
15075 // === WGL =====================================================================
15076 WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample');
15077 WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region');
15078 WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string');
15079 WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read');
15080 WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample');
15081 WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer');
15082 WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format');
15083 WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float');
15084 WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture');
15085 WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context');
15086 WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile');
15087 WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float');
15088 WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association');
15089 WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float');
15090 WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table');
15091 WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string');
15092 WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read');
15093 WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample');
15094 WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer');
15095 WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format');
15096 WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control');
15097 WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control');
15098 WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma');
15099 WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock');
15100 WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer');
15101 WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock');
15102 WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage');
15103 WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer');
15104 WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture');
15105 WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle');
15106 WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range');
15107 WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video');
15108 WGL_NV_video_out := Int_CheckExtension(Buffer, 'WGL_NV_video_out');
15109 WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group');
15110 WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity');
15111 WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control');
15112 WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control');
15113
15114 WIN_draw_range_elements := Int_CheckExtension(Buffer, 'WIN_draw_range_elements');
15115 WIN_swap_hint := Int_CheckExtension(Buffer, 'WIN_swap_hint');
15116 {$ENDIF}
15117
15118 {$IFDEF DGL_LINUX}
15119 // === GLX =====================================================================
15120 GLX_ARB_multisample := Int_CheckExtension(Buffer, 'GLX_ARB_multisample');
15121 GLX_ARB_fbconfig_float := Int_CheckExtension(Buffer, 'GLX_ARB_fbconfig_float');
15122 GLX_ARB_get_proc_address := Int_CheckExtension(Buffer, 'GLX_ARB_get_proc_address');
15123 GLX_ARB_create_context := Int_CheckExtension(Buffer, 'GLX_ARB_create_context');
15124 GLX_ARB_create_context_profile := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_profile');
15125 GLX_EXT_visual_info := Int_CheckExtension(Buffer, 'GLX_EXT_visual_info');
15126 GLX_EXT_visual_rating := Int_CheckExtension(Buffer, 'GLX_EXT_visual_rating');
15127 GLX_EXT_import_context := Int_CheckExtension(Buffer, 'GLX_EXT_import_context');
15128 GLX_EXT_fbconfig_packed_float := Int_CheckExtension(Buffer, 'GLX_EXT_fbconfig_packed_float');
15129 GLX_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_EXT_framebuffer_sRGB');
15130 GLX_EXT_texture_from_pixmap := Int_CheckExtension(Buffer, 'GLX_EXT_texture_from_pixmap');
15131 {$ENDIF}
15132 ImplementationRead := True;
15133 end;
15134
15135 {$IFDEF DGL_WIN}
15136 // =============================================================================
15137 // RaiseLastOSError
15138 // =============================================================================
15139 // Needed for compatibility with older Delphiversions
15140 // =============================================================================
15141
15142 procedure RaiseLastOSError;
15143 begin
15144 {$IFDEF FPC}
15145 raise Exception.Create('RaiseLastOSError!'); // To-Do: find a better solution
15146 {$ELSE}
15147 {$IFDEF DELPHI6_AND_DOWN} // If Delphi 6 or later
15148 SysUtils.RaiseLastWin32Error;
15149 {$ELSE}
15150 SysUtils.RaiseLastOSError;
15151 {$ENDIF}
15152 {$ENDIF}
15153 end;
15154
15155 // =============================================================================
15156 // CreateRenderingContext
15157 // =============================================================================
15158
15159 function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
15160 const
15161 OBJ_MEMDC = 10;
15162 OBJ_ENHMETADC = 12;
15163 OBJ_METADC = 4;
15164 PFD_DOUBLEBUFFER = $00000001;
15165 PFD_STEREO = $00000002;
15166 PFD_DRAW_TO_WINDOW = $00000004;
15167 PFD_DRAW_TO_BITMAP = $00000008;
15168 PFD_SUPPORT_GDI = $00000010;
15169 PFD_SUPPORT_OPENGL = $00000020;
15170 PFD_TYPE_RGBA = 0;
15171 PFD_MAIN_PLANE = 0;
15172 PFD_OVERLAY_PLANE = 1;
15173 PFD_UNDERLAY_PLANE = LongWord(-1);
15174 MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
15175 var
15176 PFDescriptor: TPixelFormatDescriptor;
15177 PixelFormat: Integer;
15178 AType: DWORD;
15179 begin
15180 if GL_LibHandle = nil then
15181 InitOpenGL;
15182
15183 FillChar(PFDescriptor, SizeOf(PFDescriptor), 0);
15184
15185 with PFDescriptor do
15186 begin
15187 nSize := SizeOf(PFDescriptor);
15188 nVersion := 1;
15189 dwFlags := PFD_SUPPORT_OPENGL;
15190
15191 AType := GetObjectType(DC);
15192
15193 if AType = 0 then
15194 RaiseLastOSError;
15195
15196 if AType in MemoryDCs then
15197 dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
15198 else
15199 dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
15200
15201 if opDoubleBuffered in Options then
15202 dwFlags := dwFlags or PFD_DOUBLEBUFFER;
15203
15204 if opGDI in Options then
15205 dwFlags := dwFlags or PFD_SUPPORT_GDI;
15206
15207 if opStereo in Options then
15208 dwFlags := dwFlags or PFD_STEREO;
15209
15210 iPixelType := PFD_TYPE_RGBA;
15211 cColorBits := ColorBits;
15212 cDepthBits := zBits;
15213 cStencilBits := StencilBits;
15214 cAccumBits := AccumBits;
15215 cAuxBuffers := AuxBuffers;
15216
15217 if Layer = 0 then
15218 iLayerType := PFD_MAIN_PLANE
15219 else
15220 if Layer > 0 then
15221 iLayerType := PFD_OVERLAY_PLANE
15222 else
15223 iLayerType := Byte(PFD_UNDERLAY_PLANE);
15224 end;
15225
15226 PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
15227
15228 if PixelFormat = 0 then
15229 RaiseLastOSError;
15230
15231 if GetPixelFormat(DC) <> PixelFormat then
15232 if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
15233 RaiseLastOSError;
15234
15235 DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
15236
15237 Result := wglCreateContext(DC);
15238
15239 if Result = 0 then
15240 RaiseLastOSError
15241 else
15242 LastPixelFormat := 0;
15243 end;
15244
15245 // =============================================================================
15246 // DestroyRenderingContext
15247 // =============================================================================
15248
15249 procedure DestroyRenderingContext(RC: HGLRC);
15250 begin
15251 wglDeleteContext(RC);
15252 end;
15253
15254
15255 // =============================================================================
15256 // ActivateRenderingContext
15257 // =============================================================================
15258
15259 procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
15260 begin
15261 Assert((DC <> 0), 'DC must not be 0');
15262 Assert((RC <> 0), 'RC must not be 0');
15263
15264 wglMakeCurrent(DC, RC);
15265
15266 {$ifdef DGL_TINY_HEADER}
15267 ReadCoreVersion;
15268 {$else}
15269 ReadImplementationProperties;
15270
15271 if (loadext) then
15272 ReadExtensions;
15273 {$endif}
15274 end;
15275
15276 // =============================================================================
15277 // DeactivateRenderingContext
15278 // =============================================================================
15279
15280 procedure DeactivateRenderingContext;
15281 begin
15282 wglMakeCurrent(0, 0);
15283 end;
15284 {$ENDIF}
15285
15286
15287 initialization
15288
15289 {$IFDEF CPU386}
15290 Set8087CW($133F);
15291 {$ENDIF}
15292
15293 finalization
15294
15295 end.
15296
[MIRROR] Doom2DF editor ported to FPC/Lazarus
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024