2
// This unit is part of the GLScene Engine https://github.com/glscene
5
OpenGL 1.x import unit for GLScene. Unit remains "general purpose", but with
6
a more "pragmatic" approach :)
8
This unit is based on OpenGL12.pas orginally written by Mike Lischke,
9
please refer to OpenGL12.pas header.
12
23/01/11 - DanB - Entry points now use procedural types from OpenGLTokens.pas
13
Added OpenGL 4.1 + ARB extensions
14
Switched to use GLS_REGIONS define
15
23/08/10 - Yar - Moved tokens part to OpenGLTokens.pas
16
22/07/10 - Yar - Added GL_ARB_debug_output constant
17
01/06/10 - Yar - Fixes for Linux x64
18
31/05/10 - Yar - Added WGL_NV_gpu_affinity
19
12/05/10 - Yar - Added GL_ARB_texture_compression_bptc
20
04/05/10 - Yar - Added GL_S3_s3tc extension (thanks to Rustam Asmandiarov aka Predator)
21
01/05/10 - DanB - Fixed glGetTransformFeedbackVarying params
22
16/04/10 - Yar - Added Graphics Remedy's Extensions
23
28/03/10 - DanB - Added missing OpenGL 3.1/3.2 function lookups +
24
added bindless graphics extensions
25
18/03/10 - Yar - Added more GLX extensions
26
(thanks to Rustam Asmandiarov aka Predator)
27
12/03/10 - DanB - OpenGL 3.3/4.0 support (new ARB extensions), removed
28
_ARB suffix from functions/procedures in
29
GL_ARB_draw_buffers_blend + GL_ARB_sample_shading
30
04/03/10 - DanB - Organised core into relevant + deprecated sections,
31
fixed a couple of function params + misc changes.
32
12/02/10 - Yar - Added GL_AMD_vertex_shader_tessellator
33
07/02/10 - Yar - Added GL_NV_primitive_restart
34
21/01/10 - DaStr - Bugfixed wglChoosePixelFormatARB() and
35
wglCreatePbufferARB() parameters
36
07/01/10 - DaStr - Added WGL_COLOR_SAMPLES_NV (thanks YarUndeoaker)
37
25/12/09 - DaStr - Added GL_NV_copy_image, GL_LUMINANCE_INTEGER,
38
GL_LUMINANCE_ALPHA_INTEGER extentions and constants
39
Re-added $region declarations (thanks YarUndeoaker)
40
13/12/09 - DaStr - Added missing stdcall/cdecl modifiers
41
25/10/09 - DaStr - Added some texture compression extensions and updated
42
glTransformFeedbackVaryings()(thanks YarUndeoaker)
43
28/09/09 - DaStr - Added some NVidia-specific extensions (thanks YarUndeoaker)
44
30/08/09 - DanB - GLsync changed to NativeInt, fixes to glBindBufferRange calls
45
14/08/09 - DanB - Added missing GL_ARB_framebuffer_object extension check + fixed typo
46
04/08/09 - DanB - OpenGL 3.1/3.2 support + new ARB extensions added
47
28/07/09 - DaStr - Added GL_GEOMETRY_PROGRAM_NV and related extensions
48
20/01/08 - DanB - Fix due to Delphi6 not containing UInt64
49
05/10/08 - DanB - Moved error handling code here from GLContext.pas
50
OpenGL 3.0 support, new core features + ARB extensions
51
23/03/08 - DanB - Added more Vendor/EXT extensions
52
17/03/08 - mrqzzz - uncommented some constants "GL_NORMAL_MAP_EXT,..."
53
to keep compatibility with dws2OpenGL1x.
54
16/03/08 - DanB - Major rewrite of unit, including:
55
OpenGL 1.3, 1.4, 1.5, 2.0, 2.1 support.
56
removed TRCOptions (not used).
57
moved MRT_BUFFERS constant to GLContext.pas (isn't core openGL).
58
several new ARB extensions added.
59
several new Vendor/EXT exensions added.
60
new function IsOpenGLVersionMet added.
61
restructured unit so extensions are in numerical order.
62
17/06/07 - LC - Added GL_ARB_pixel_buffer_object, GL_EXT_pixel_buffer_object
63
22/03/07 - DaStr - Removed GetTextureRectangle (had many useless checks)
64
16/03/07 - DaStr - Dropped Kylix support in favor of FPC
65
(thanks Burkhard Carstens) (BugTracekrID=1681585)
66
09/03/07 - DaStr - Added GL_ARB_draw_buffers (thanks riz)
67
03/03/07 - DaStr - Added GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT
68
02/03/07 - DaStr - Added GL_[ARB/EXT]_texture_rectangle
69
Added GetTextureRectangle
70
10/01/07 - LC - Added GL_EXT_framebuffer_object
71
11/09/06 - NC - Added GL_ARB_texture_float, GL_ARB_texture_non_power_of_two
72
13/10/04 - NC - Added GL_ATI_draw_buffers
73
08/10/04 - LR - Added const in the prototype of the following function for compatibility :
74
TGLUTessCombineProc, TGLUTessCombineDataProc, gluPickMatrix
75
gluProject, gluUnProject, gluTessVertex, gluLoadSamplingMatrices
76
04/10/04 - NC - Added GL_ATI_texture_float, WGL_ATI_pixel_format_float,
77
WGL_NV_float_buffer, GL_NV_float_buffer
78
08/07/04 - LR - Change case for Linux
79
05/07/04 - LR - Corrections for Linux. Now glX function are directly load
80
by external action (like for Windows). So i suppress
81
the function LoadLinuxOpenGL.
82
28/06/04 - LR - Removed ..\ from the GLScene.inc
83
24/06/04 - SG - Added GL_ARB_fragment_program
84
17/05/04 - EG - Dropped EXT_vertex_array (assumed as standard)
85
06/04/04 - EG - Added GL_ARB_shader_objects, GL_ARB_vertex_shader
86
and GL_ARB_fragment_shader, dropped a few oldies
87
13/02/04 - EG - Added GL_NV_texture_rectangle
88
18/11/03 - EG - Fixed binding of core extensions, added GL_ARB_depth_texture
89
and GL_ARB_shadow support
90
20/09/03 - EG - Added GL_NV_occlusion_query, dropped some more oldies
91
09/09/03 - EG - Added GL_ARB_vertex_buffer_object, dropped some oldies
92
04/09/03 - EG - Added GL_ARB_vertex_program
93
23/07/03 - EG - Creation from OpenGL12.pas "morph": classic OpenGL
94
calls made static, obsolete/rare extensions support
104
// DaStr: MULTITHREADOPENGL is defined in GLScene.inc, but you can override it
105
// manually here, though I would not reccomend it. This is because other units
106
// may depend on this option too. So if you need this option, please use the
107
// _MULTITHREAD define in GLScene.inc.
108
{.$define MULTITHREADOPENGL}111
SysUtils, OpenGLTokens, GLVectorTypes,
115
{$IFDEF GLS_X11_SUPPORT}119
{Libc,}Types, LCLType, dynlibs122
{$IFDEF GLS_REGIONS} {$region 'OpenGL extension feature checks'} {$ENDIF}124
{$IFDEF MULTITHREADOPENGL}129
// supported version checks
149
GLU_VERSION_1_3: Boolean;
151
// ARB approved OpenGL extension checks
152
GL_ARB_blend_func_extended,
153
GL_ARB_color_buffer_float,
154
GL_ARB_compatibility,
157
GL_ARB_depth_buffer_float,
159
GL_ARB_depth_texture,
161
GL_ARB_draw_buffers_blend,
162
GL_ARB_draw_elements_base_vertex,
163
GL_ARB_draw_indirect,
164
GL_ARB_draw_instanced,
165
GL_ARB_ES2_compatibility,
166
GL_ARB_explicit_attrib_location,
167
GL_ARB_fragment_coord_conventions,
168
GL_ARB_fragment_program,
169
GL_ARB_fragment_program_shadow,
170
GL_ARB_fragment_shader,
171
GL_ARB_framebuffer_object,
172
GL_ARB_framebuffer_sRGB,
173
GL_ARB_geometry_shader4,
174
GL_ARB_get_program_binary,
175
GL_ARB_gpu_shader_fp64,
177
GL_ARB_half_float_pixel,
178
GL_ARB_half_float_vertex,
180
GL_ARB_instanced_arrays,
181
GL_ARB_map_buffer_range,
182
GL_ARB_matrix_palette,
185
GL_ARB_occlusion_query,
186
GL_ARB_occlusion_query2,
187
GL_ARB_pixel_buffer_object,
188
GL_ARB_point_parameters,
190
GL_ARB_provoking_vertex,
192
GL_ARB_sample_shading,
193
GL_ARB_sampler_objects,
194
GL_ARB_seamless_cube_map,
195
GL_ARB_separate_shader_objects,
196
GL_ARB_shader_bit_encoding,
197
GL_ARB_shader_precision,
198
GL_ARB_shader_stencil_export,
199
GL_ARB_shader_subroutine,
200
GL_ARB_shader_texture_lod,
201
GL_ARB_shading_language_100,
203
GL_ARB_shadow_ambient,
204
GL_ARB_shader_objects,
206
GL_ARB_tessellation_shader,
207
GL_ARB_texture_border_clamp,
208
GL_ARB_texture_buffer_object,
209
GL_ARB_texture_buffer_object_rgb32,
210
GL_ARB_texture_compression,
211
GL_ARB_texture_compression_rgtc,
212
GL_ARB_texture_cube_map,
213
GL_ARB_texture_cube_map_array,
214
GL_ARB_texture_env_add,
215
GL_ARB_texture_env_combine,
216
GL_ARB_texture_env_crossbar,
217
GL_ARB_texture_env_dot3,
218
GL_ARB_texture_float,
219
GL_ARB_texture_gather,
220
GL_ARB_texture_mirrored_repeat,
221
GL_ARB_texture_multisample,
222
GL_ARB_texture_non_power_of_two,
223
GL_ARB_texture_query_lod,
224
GL_ARB_texture_rectangle,
226
GL_ARB_texture_rgb10_a2ui,
227
GL_ARB_texture_swizzle,
229
GL_ARB_transform_feedback2,
230
GL_ARB_transform_feedback3,
231
GL_ARB_transpose_matrix,
232
GL_ARB_uniform_buffer_object,
233
GL_ARB_vertex_array_bgra,
234
GL_ARB_vertex_array_object,
235
GL_ARB_vertex_attrib_64bit,
237
GL_ARB_vertex_buffer_object,
238
GL_ARB_vertex_program,
239
GL_ARB_vertex_shader,
240
GL_ARB_vertex_type_2_10_10_10_rev,
241
GL_ARB_viewport_array,
243
GL_ARB_texture_compression_bptc,
245
// Vendor/EXT OpenGL extension checks
248
GL_3DFX_texture_compression_FXT1,
251
GL_ATI_texture_compression_3dc,
252
GL_ATI_texture_float,
253
GL_ATI_texture_mirror_once,
259
GL_EXT_bindable_uniform,
261
GL_EXT_blend_equation_separate,
262
GL_EXT_blend_func_separate,
263
GL_EXT_blend_logic_op,
265
GL_EXT_blend_subtract,
267
GL_EXT_clip_volume_hint,
268
GL_EXT_compiled_vertex_array,
270
GL_EXT_depth_bounds_test,
271
GL_EXT_draw_buffers2,
272
GL_EXT_draw_instanced,
273
GL_EXT_draw_range_elements,
275
GL_EXT_framebuffer_blit,
276
GL_EXT_framebuffer_multisample,
277
GL_EXT_framebuffer_object,
278
GL_EXT_framebuffer_sRGB,
279
GL_EXT_geometry_shader4,
280
GL_EXT_gpu_program_parameters,
282
GL_EXT_multi_draw_arrays,
284
GL_EXT_packed_depth_stencil,
286
GL_EXT_packed_pixels,
287
GL_EXT_paletted_texture,
288
GL_EXT_pixel_buffer_object,
289
GL_EXT_polygon_offset,
290
GL_EXT_rescale_normal,
291
GL_EXT_secondary_color,
292
GL_EXT_separate_specular_color,
294
GL_EXT_shared_texture_palette,
295
GL_EXT_stencil_clear_tag,
296
GL_EXT_stencil_two_side,
299
GL_EXT_texture_array,
300
GL_EXT_texture_buffer_object,
301
GL_EXT_texture_compression_latc,
302
GL_EXT_texture_compression_rgtc,
303
GL_EXT_texture_compression_s3tc,
304
GL_EXT_texture_cube_map,
305
GL_EXT_texture_edge_clamp,
306
GL_EXT_texture_env_add,
307
GL_EXT_texture_env_combine,
308
GL_EXT_texture_env_dot3,
309
GL_EXT_texture_filter_anisotropic,
310
GL_EXT_texture_integer,
312
GL_EXT_texture_lod_bias,
313
GL_EXT_texture_mirror_clamp,
314
GL_EXT_texture_object,
315
GL_EXT_texture_rectangle,
317
GL_EXT_texture_shared_exponent,
319
GL_EXT_transform_feedback,
322
GL_HP_occlusion_test,
324
GL_IBM_rasterpos_clip,
326
GL_KTX_buffer_region,
328
GL_MESA_resize_buffers,
331
GL_NV_conditional_render,
333
GL_NV_depth_buffer_float,
337
GL_NV_geometry_program4,
338
GL_NV_light_max_exponent,
339
GL_NV_multisample_filter_hint,
340
GL_NV_occlusion_query,
342
GL_NV_primitive_restart,
343
GL_NV_register_combiners,
344
GL_NV_shader_buffer_load,
345
GL_NV_texgen_reflection,
346
GL_NV_texture_compression_vtc,
347
GL_NV_texture_env_combine4,
348
GL_NV_texture_rectangle,
349
GL_NV_texture_shader,
350
GL_NV_texture_shader2,
351
GL_NV_texture_shader3,
352
GL_NV_transform_feedback,
353
GL_NV_vertex_array_range,
354
GL_NV_vertex_array_range2,
355
GL_NV_vertex_buffer_unified_memory,
356
GL_NV_vertex_program,
360
GL_SGIS_generate_mipmap,
362
GL_SGIS_texture_border_clamp,
363
GL_SGIS_texture_color_mask,
364
GL_SGIS_texture_edge_clamp,
367
GL_SGIX_depth_texture,
369
GL_SGIX_shadow_ambient,
371
GL_AMD_vertex_shader_tessellator,
375
// ARB approved WGL extension checks
376
WGL_ARB_buffer_region,
377
WGL_ARB_create_context,
378
WGL_ARB_create_context_profile,
379
WGL_ARB_extensions_string,
380
WGL_ARB_framebuffer_sRGB,
381
WGL_ARB_make_current_read,
384
WGL_ARB_pixel_format,
385
WGL_ARB_pixel_format_float,
386
WGL_ARB_render_texture,
388
// Vendor/EXT WGL extension checks
389
WGL_ATI_pixel_format_float,
391
WGL_EXT_framebuffer_sRGB,
392
WGL_EXT_pixel_format_packed_float,
393
WGL_EXT_swap_control,
396
// GLX extension checks
401
GLX_ARB_create_context,
402
GLX_ARB_create_context_profile,
403
GLX_ARB_framebuffer_sRGB,
405
GLX_EXT_framebuffer_sRGB,
406
GLX_EXT_fbconfig_packed_float,
408
GLX_SGIS_multisample,
410
GLX_SGI_swap_control,
412
GLX_SGI_make_current_read,
413
GLX_SGIX_video_source,
414
GLX_EXT_visual_rating,
415
GLX_EXT_import_context,
419
GLX_SGIX_video_resize,
422
GLX_SGIX_swap_barrier,
423
GLX_SGIS_blended_overlay,
424
GLX_SGIS_shared_multisample,
425
GLX_SUN_get_transparent_index,
426
GLX_3DFX_multisample,
427
GLX_MESA_copy_sub_buffer,
428
GLX_MESA_pixmap_colormap,
429
GLX_MESA_release_buffers,
430
GLX_MESA_set_3dfx_mode,
431
GLX_SGIX_visual_select_group,
434
// Graphics Remedy's Extensions
435
GL_GREMEDY_frame_terminator,
436
GL_GREMEDY_string_marker,
438
// OpenGL Utility (GLU) extension checks
439
GLU_EXT_object_space_tess,
440
GLU_EXT_nurbs_tessellator,
441
GLU_EXT_Texture: Boolean;
443
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}445
{$IFDEF GLS_REGIONS} {$region 'OpenGL v1.1 core functions and procedures'} {$ENDIF}446
procedure glBindTexture(target: TGLEnum; texture: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;447
procedure glBlendFunc(sfactor: TGLEnum; dfactor: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;448
procedure glClear(mask: TGLbitfield); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;449
procedure glClearColor(red, green, blue, alpha: TGLclampf); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;450
procedure glClearDepth(depth: TGLclampd); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;451
procedure glClearStencil(s: TGLint ); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;453
procedure glColorMask(red, green, blue, alpha: TGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;455
procedure glCopyTexImage1D(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width: TGLsizei; border: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;456
procedure glCopyTexImage2D(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width, height: TGLsizei; border: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;457
procedure glCopyTexSubImage1D(target: TGLEnum; level, xoffset, x, y: TGLint; width: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;458
procedure glCopyTexSubImage2D(target: TGLEnum; level, xoffset, yoffset, x, y: TGLint; width, height: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;459
procedure glCullFace(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;461
procedure glDeleteTextures(n: TGLsizei; textures: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;462
procedure glDepthFunc(func: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;463
procedure glDepthMask(flag: TGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;464
procedure glDepthRange(zNear, zFar: TGLclampd); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;465
procedure glDisable(cap: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;467
procedure glDrawArrays(mode: TGLEnum; first: TGLint; count: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;468
procedure glDrawBuffer(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;469
procedure glDrawElements(mode: TGLEnum; count: TGLsizei; atype: TGLEnum; indices: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; 471
procedure glEnable(cap: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;473
procedure glFinish; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;474
procedure glFlush; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;476
procedure glFrontFace(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;478
procedure glGenTextures(n: TGLsizei; textures: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;479
procedure glGetBooleanv(pname: TGLEnum; params: PGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;481
procedure glGetDoublev(pname: TGLEnum; params: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;482
function glGetError: TGLuint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;483
procedure glGetFloatv(pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;484
procedure glGetIntegerv(pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;486
procedure glGetPointerv(pname: TGLEnum; var params); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;488
function glGetString(name: TGLEnum): PGLChar; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; 489
procedure glGetTexImage(target: TGLEnum; level: TGLint; format, atype: TGLEnum; pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;490
procedure glGetTexLevelParameterfv(target: TGLEnum; level: TGLint; pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;491
procedure glGetTexLevelParameteriv(target: TGLEnum; level: TGLint; pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;492
procedure glGetTexParameterfv(target, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;493
procedure glGetTexParameteriv(target, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;495
procedure glHint(target, mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;497
function glIsEnabled(cap: TGLEnum): TGLboolean; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;498
function glIsTexture(texture: TGLuint): TGLboolean; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;500
procedure glLineWidth(width: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;501
procedure glLogicOp(opcode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;503
procedure glPixelStoref(pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;504
procedure glPixelStorei(pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;505
procedure glPointSize(size: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;506
procedure glPolygonMode(face, mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;507
procedure glPolygonOffset(factor, units: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;509
procedure glReadBuffer(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;510
procedure glReadPixels(x, y: TGLint; width, height: TGLsizei; format, atype: TGLEnum; pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;512
procedure glScissor(x, y: TGLint; width, height: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;513
procedure glStencilFunc(func: TGLEnum; ref: TGLint; mask: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;514
procedure glStencilMask(mask: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;515
procedure glStencilOp(fail, zfail, zpass: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;517
procedure glTexImage1D(target: TGLEnum; level, internalformat: TGLint; width: TGLsizei; border: TGLint; format,
518
atype: TGLEnum; pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;519
procedure glTexImage2D(target: TGLEnum; level, internalformat: TGLint; width, height: TGLsizei; border: TGLint;
520
format, atype: TGLEnum; Pixels:Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;521
procedure glTexParameterf(target, pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;522
procedure glTexParameterfv(target, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;523
procedure glTexParameteri(target, pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;524
procedure glTexParameteriv(target, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;525
procedure glTexSubImage1D(target: TGLEnum; level, xoffset: TGLint; width: TGLsizei; format, atype: TGLEnum;
526
pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;527
procedure glTexSubImage2D(target: TGLEnum; level, xoffset, yoffset: TGLint; width, height: TGLsizei; format,
528
atype: TGLEnum; pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;530
procedure glViewport(x, y: TGLint; width, height: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32;532
{$IFDEF GLS_REGIONS} {$region 'OpenGL 1.1 deprecated'} {$ENDIF}533
procedure glAccum(op: TGLuint; value: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;534
procedure glAlphaFunc(func: TGLEnum; ref: TGLclampf); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;535
function glAreTexturesResident(n: TGLsizei; Textures: PGLuint; residences: PGLboolean): TGLboolean; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;536
procedure glArrayElement(i: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;537
procedure glBegin(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;538
procedure glBitmap(width: TGLsizei; height: TGLsizei; xorig, yorig: TGLfloat; xmove: TGLfloat; ymove: TGLfloat; bitmap: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;539
procedure glCallList(list: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;540
procedure glCallLists(n: TGLsizei; atype: TGLEnum; lists: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;541
procedure glClearAccum(red, green, blue, alpha: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;542
procedure glClearIndex(c: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;543
procedure glClipPlane(plane: TGLEnum; equation: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;545
procedure glColor3b(red, green, blue: TGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;546
procedure glColor3bv(v: PGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;547
procedure glColor3d(red, green, blue: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;548
procedure glColor3dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;549
procedure glColor3f(red, green, blue: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;550
procedure glColor3fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;551
procedure glColor3i(red, green, blue: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;552
procedure glColor3iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;553
procedure glColor3s(red, green, blue: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;554
procedure glColor3sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;555
procedure glColor3ub(red, green, blue: TGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;556
procedure glColor3ubv(v: PGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;557
procedure glColor3ui(red, green, blue: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;558
procedure glColor3uiv(v: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;559
procedure glColor3us(red, green, blue: TGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;560
procedure glColor3usv(v: PGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;561
procedure glColor4b(red, green, blue, alpha: TGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;562
procedure glColor4bv(v: PGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;563
procedure glColor4d(red, green, blue, alpha: TGLdouble ); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;564
procedure glColor4dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;565
procedure glColor4f(red, green, blue, alpha: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;566
procedure glColor4fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;567
procedure glColor4i(red, green, blue, alpha: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;568
procedure glColor4iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;569
procedure glColor4s(red, green, blue, alpha: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;570
procedure glColor4sv(v: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;571
procedure glColor4ub(red, green, blue, alpha: TGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;572
procedure glColor4ubv(v: PGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;573
procedure glColor4ui(red, green, blue, alpha: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;574
procedure glColor4uiv(v: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;575
procedure glColor4us(red, green, blue, alpha: TGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;576
procedure glColor4usv(v: PGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;578
procedure glColorMaterial(face: TGLEnum; mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;579
procedure glColorPointer(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;580
procedure glCopyPixels(x, y: TGLint; width, height: TGLsizei; atype: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;581
procedure glDeleteLists(list: TGLuint; range: TGLsizei); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;582
procedure glDisableClientState(aarray: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;583
procedure glDrawPixels(width, height: TGLsizei; format, atype: TGLEnum; pixels: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;585
procedure glEdgeFlag(flag: TGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;586
procedure glEdgeFlagPointer(stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;587
procedure glEdgeFlagv(flag: PGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;588
procedure glEnableClientState(aarray: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;589
procedure glEnd; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;590
procedure glEndList; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;591
procedure glEvalCoord1d(u: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;592
procedure glEvalCoord1dv(u: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;593
procedure glEvalCoord1f(u: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;594
procedure glEvalCoord1fv(u: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;595
procedure glEvalCoord2d(u: TGLdouble; v: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;596
procedure glEvalCoord2dv(u: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;597
procedure glEvalCoord2f(u, v: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;598
procedure glEvalCoord2fv(u: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;599
procedure glEvalMesh1(mode: TGLEnum; i1, i2: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;600
procedure glEvalMesh2(mode: TGLEnum; i1, i2, j1, j2: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;601
procedure glEvalPoint1(i: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;602
procedure glEvalPoint2(i, j: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;604
procedure glFeedbackBuffer(size: TGLsizei; atype: TGLEnum; buffer: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;605
procedure glFogf(pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;606
procedure glFogfv(pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;607
procedure glFogi(pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;608
procedure glFogiv(pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;609
procedure glFrustum(left, right, bottom, top, zNear, zFar: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;610
function glGenLists(range: TGLsizei): TGLuint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;611
procedure glGetClipPlane(plane: TGLEnum; equation: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;612
procedure glGetLightfv(light, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;613
procedure glGetLightiv(light, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;614
procedure glGetMapdv(target, query: TGLEnum; v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;615
procedure glGetMapfv(target, query: TGLEnum; v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;616
procedure glGetMapiv(target, query: TGLEnum; v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;617
procedure glGetMaterialfv(face, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;618
procedure glGetMaterialiv(face, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;619
procedure glGetPixelMapfv(map: TGLEnum; values: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;620
procedure glGetPixelMapuiv(map: TGLEnum; values: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;621
procedure glGetPixelMapusv(map: TGLEnum; values: PGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;622
procedure glGetPolygonStipple(mask: PGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;623
procedure glGetTexEnvfv(target, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;624
procedure glGetTexEnviv(target, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;625
procedure glGetTexGendv(coord, pname: TGLEnum; params: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;626
procedure glGetTexGenfv(coord, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;627
procedure glGetTexGeniv(coord, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;629
procedure glIndexMask(mask: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;630
procedure glIndexPointer(atype: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;631
procedure glIndexd(c: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;632
procedure glIndexdv(c: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;633
procedure glIndexf(c: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;634
procedure glIndexfv(c: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;635
procedure glIndexi(c: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;636
procedure glIndexiv(c: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;637
procedure glIndexs(c: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;638
procedure glIndexsv(c: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;639
procedure glIndexub(c: TGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;640
procedure glIndexubv(c: PGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;641
procedure glInitNames; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;642
procedure glInterleavedArrays(format: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;643
function glIsList(list: TGLuint): TGLboolean; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;644
procedure glLightModelf(pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;645
procedure glLightModelfv(pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;646
procedure glLightModeli(pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;647
procedure glLightModeliv(pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;648
procedure glLightf(light, pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;649
procedure glLightfv(light, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;650
procedure glLighti(light, pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;651
procedure glLightiv(light, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;652
procedure glLineStipple(factor: TGLint; pattern: TGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;653
procedure glListBase(base: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;654
procedure glLoadIdentity; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;655
procedure glLoadMatrixd(m: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;656
procedure glLoadMatrixf(m: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;657
procedure glLoadName(name: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;659
procedure glMap1d(target: TGLEnum; u1, u2: TGLdouble; stride, order: TGLint; points: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;660
procedure glMap1f(target: TGLEnum; u1, u2: TGLfloat; stride, order: TGLint; points: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;661
procedure glMap2d(target: TGLEnum; u1, u2: TGLdouble; ustride, uorder: TGLint; v1, v2: TGLdouble; vstride,
662
vorder: TGLint; points: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;663
procedure glMap2f(target: TGLEnum; u1, u2: TGLfloat; ustride, uorder: TGLint; v1, v2: TGLfloat; vstride,
664
vorder: TGLint; points: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;665
procedure glMapGrid1d(un: TGLint; u1, u2: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;666
procedure glMapGrid1f(un: TGLint; u1, u2: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;667
procedure glMapGrid2d(un: TGLint; u1, u2: TGLdouble; vn: TGLint; v1, v2: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;668
procedure glMapGrid2f(un: TGLint; u1, u2: TGLfloat; vn: TGLint; v1, v2: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;669
procedure glMaterialf(face, pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;670
procedure glMaterialfv(face, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;671
procedure glMateriali(face, pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;672
procedure glMaterialiv(face, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;673
procedure glMatrixMode(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;674
procedure glMultMatrixd(m: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;675
procedure glMultMatrixf(m: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;676
procedure glNewList(list: TGLuint; mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;677
procedure glNormal3b(nx, ny, nz: TGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;678
procedure glNormal3bv(v: PGLbyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;679
procedure glNormal3d(nx, ny, nz: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;680
procedure glNormal3dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;681
procedure glNormal3f(nx, ny, nz: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;682
procedure glNormal3fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;683
procedure glNormal3i(nx, ny, nz: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;684
procedure glNormal3iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;685
procedure glNormal3s(nx, ny, nz: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;686
procedure glNormal3sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;687
procedure glNormalPointer(atype: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;689
procedure glOrtho(left, right, bottom, top, zNear, zFar: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;690
procedure glPassThrough(token: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;691
procedure glPixelMapfv(map: TGLEnum; mapsize: TGLsizei; values: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;692
procedure glPixelMapuiv(map: TGLEnum; mapsize: TGLsizei; values: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;693
procedure glPixelMapusv(map: TGLEnum; mapsize: TGLsizei; values: PGLushort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;694
procedure glPixelTransferf(pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;695
procedure glPixelTransferi(pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;696
procedure glPixelZoom(xfactor, yfactor: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;697
procedure glPolygonStipple(mask: PGLubyte); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;698
procedure glPopAttrib; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;699
procedure glPopClientAttrib; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;700
procedure glPopMatrix; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;701
procedure glPopName; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;702
procedure glPrioritizeTextures(n: TGLsizei; textures: PGLuint; priorities: PGLclampf); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;703
procedure glPushAttrib(mask: TGLbitfield); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;704
procedure glPushClientAttrib(mask: TGLbitfield); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;705
procedure glPushMatrix; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;706
procedure glPushName(name: TGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;708
procedure glRasterPos2d(x, y: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;709
procedure glRasterPos2dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;710
procedure glRasterPos2f(x, y: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;711
procedure glRasterPos2fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;712
procedure glRasterPos2i(x, y: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;713
procedure glRasterPos2iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;714
procedure glRasterPos2s(x, y: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;715
procedure glRasterPos2sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;716
procedure glRasterPos3d(x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;717
procedure glRasterPos3dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;718
procedure glRasterPos3f(x, y, z: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;719
procedure glRasterPos3fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;720
procedure glRasterPos3i(x, y, z: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;721
procedure glRasterPos3iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;722
procedure glRasterPos3s(x, y, z: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;723
procedure glRasterPos3sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;724
procedure glRasterPos4d(x, y, z, w: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;725
procedure glRasterPos4dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;726
procedure glRasterPos4f(x, y, z, w: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;727
procedure glRasterPos4fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;728
procedure glRasterPos4i(x, y, z, w: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;729
procedure glRasterPos4iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;730
procedure glRasterPos4s(x, y, z, w: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;731
procedure glRasterPos4sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;732
procedure glRectd(x1, y1, x2, y2: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;733
procedure glRectdv(v1, v2: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;734
procedure glRectf(x1, y1, x2, y2: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;735
procedure glRectfv(v1, v2: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;736
procedure glRecti(x1, y1, x2, y2: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;737
procedure glRectiv(v1, v2: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;738
procedure glRects(x1, y1, x2, y2: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;739
procedure glRectsv(v1, v2: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;740
function glRenderMode(mode: TGLEnum): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;741
procedure glRotated(angle, x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;742
procedure glRotatef(angle, x, y, z: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;744
procedure glScaled(x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;745
procedure glScalef(x, y, z: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;746
procedure glSelectBuffer(size: TGLsizei; buffer: PGLuint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;747
procedure glShadeModel(mode: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;748
procedure glTexCoord1d(s: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;749
procedure glTexCoord1dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;750
procedure glTexCoord1f(s: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;751
procedure glTexCoord1fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;752
procedure glTexCoord1i(s: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;753
procedure glTexCoord1iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;754
procedure glTexCoord1s(s: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;755
procedure glTexCoord1sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;756
procedure glTexCoord2d(s, t: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;757
procedure glTexCoord2dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;758
procedure glTexCoord2f(s, t: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;759
procedure glTexCoord2fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;760
procedure glTexCoord2i(s, t: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;761
procedure glTexCoord2iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;762
procedure glTexCoord2s(s, t: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;763
procedure glTexCoord2sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;764
procedure glTexCoord3d(s, t, r: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;765
procedure glTexCoord3dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;766
procedure glTexCoord3f(s, t, r: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;767
procedure glTexCoord3fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;768
procedure glTexCoord3i(s, t, r: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;769
procedure glTexCoord3iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;770
procedure glTexCoord3s(s, t, r: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;771
procedure glTexCoord3sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;772
procedure glTexCoord4d(s, t, r, q: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;773
procedure glTexCoord4dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;774
procedure glTexCoord4f(s, t, r, q: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;775
procedure glTexCoord4fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;776
procedure glTexCoord4i(s, t, r, q: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;777
procedure glTexCoord4iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;778
procedure glTexCoord4s(s, t, r, q: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;779
procedure glTexCoord4sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;780
procedure glTexCoordPointer(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;781
procedure glTexEnvf(target, pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;782
procedure glTexEnvfv(target, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;783
procedure glTexEnvi(target, pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;784
procedure glTexEnviv(target, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;785
procedure glTexGend(coord, pname: TGLEnum; param: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;786
procedure glTexGendv(coord, pname: TGLEnum; params: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;787
procedure glTexGenf(coord, pname: TGLEnum; param: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;788
procedure glTexGenfv(coord, pname: TGLEnum; params: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;789
procedure glTexGeni(coord, pname: TGLEnum; param: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;790
procedure glTexGeniv(coord, pname: TGLEnum; params: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;791
procedure glTranslated(x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;792
procedure glTranslatef(x, y, z: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;794
procedure glVertex2d(x, y: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;795
procedure glVertex2dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;796
procedure glVertex2f(x, y: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;797
procedure glVertex2fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;798
procedure glVertex2i(x, y: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;799
procedure glVertex2iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;800
procedure glVertex2s(x, y: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;801
procedure glVertex2sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;802
procedure glVertex3d(x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;803
procedure glVertex3dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;804
procedure glVertex3f(x, y, z: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;805
procedure glVertex3fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;806
procedure glVertex3i(x, y, z: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;807
procedure glVertex3iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;808
procedure glVertex3s(x, y, z: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;809
procedure glVertex3sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;810
procedure glVertex4d(x, y, z, w: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;811
procedure glVertex4dv(v: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;812
procedure glVertex4f(x, y, z, w: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;813
procedure glVertex4fv(v: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;814
procedure glVertex4i(x, y, z, w: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;815
procedure glVertex4iv(v: PGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;816
procedure glVertex4s(x, y, z, w: TGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;817
procedure glVertex4sv(v: PGLshort); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;818
procedure glVertexPointer(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external opengl32; //deprecated;819
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}821
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}823
{$IFDEF GLS_REGIONS} {$region 'OpenGL utility (GLU) functions and procedures'} {$ENDIF}824
function gluErrorString(errCode: TGLEnum): PGLChar; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;825
function gluGetString(name: TGLEnum): PGLChar; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;826
procedure gluOrtho2D(left, right, bottom, top: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;827
procedure gluPerspective(fovy, aspect, zNear, zFar: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;828
procedure gluPickMatrix(x, y, width, height: TGLdouble; const viewport: TVector4i); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;829
procedure gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;830
function gluProject(objx, objy, objz: TGLdouble; const modelMatrix: TMatrix4d; const projMatrix: TMatrix4d; const viewport: TVector4i;
831
winx, winy, winz: PGLdouble): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;832
function gluUnProject(winx, winy, winz: TGLdouble; const modelMatrix: TMatrix4d; const projMatrix: TMatrix4d; const viewport: TVector4i;
833
objx, objy, objz: PGLdouble): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;834
function gluScaleImage(format: TGLEnum; widthin, heightin: TGLint; typein: TGLEnum; datain: Pointer; widthout,
835
heightout: TGLint; typeout: TGLEnum; dataout: Pointer): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;836
function gluBuild1DMipmaps(target: TGLEnum; components, width: TGLint; format, atype: TGLEnum;
837
data: Pointer): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;838
function gluBuild2DMipmaps(target: TGLEnum; components, width, height: TGLint; format, atype: TGLEnum;
839
data: Pointer): TGLint; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;840
function gluNewQuadric: PGLUquadric; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;841
procedure gluDeleteQuadric(state: PGLUquadric); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;842
procedure gluQuadricNormals(quadObject: PGLUquadric; normals: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;843
procedure gluQuadricTexture(quadObject: PGLUquadric; textureCoords: TGLboolean); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;844
procedure gluQuadricOrientation(quadObject: PGLUquadric; orientation: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;845
procedure gluQuadricDrawStyle(quadObject: PGLUquadric; drawStyle: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;846
procedure gluCylinder(quadObject: PGLUquadric; baseRadius, topRadius, height: TGLdouble; slices,
847
stacks: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;848
procedure gluDisk(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;849
procedure gluPartialDisk(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint;
850
startAngle, sweepAngle: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;851
procedure gluSphere(quadObject: PGLUquadric; radius: TGLdouble; slices, stacks: TGLint); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;852
procedure gluQuadricCallback(quadObject: PGLUquadric; which: TGLEnum; fn: TGLUQuadricErrorProc); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;853
function gluNewTess: PGLUtesselator; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;854
procedure gluDeleteTess(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;855
procedure gluTessBeginPolygon(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;856
procedure gluTessBeginContour(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;857
procedure gluTessVertex(tess: PGLUtesselator; const coords: TVector3d; data: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;858
procedure gluTessEndContour(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;859
procedure gluTessEndPolygon(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;860
procedure gluTessProperty(tess: PGLUtesselator; which: TGLEnum; value: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;861
procedure gluTessNormal(tess: PGLUtesselator; x, y, z: TGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;862
procedure gluTessCallback(tess: PGLUtesselator; which: TGLEnum; fn: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;863
procedure gluGetTessProperty(tess: PGLUtesselator; which: TGLEnum; value: PGLdouble); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;864
function gluNewNurbsRenderer: PGLUnurbs; {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;865
procedure gluDeleteNurbsRenderer(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;866
procedure gluBeginSurface(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;867
procedure gluBeginCurve(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;868
procedure gluEndCurve(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;869
procedure gluEndSurface(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;870
procedure gluBeginTrim(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;871
procedure gluEndTrim(nobj: PGLUnurbs); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;872
procedure gluPwlCurve(nobj: PGLUnurbs; count: TGLint; points: PGLfloat; stride: TGLint; atype: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;873
procedure gluNurbsCurve(nobj: PGLUnurbs; nknots: TGLint; knot: PGLfloat; stride: TGLint; ctlarray: PGLfloat; order: TGLint; atype: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;874
procedure gluNurbsSurface(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 MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;875
procedure gluLoadSamplingMatrices(nobj: PGLUnurbs; const modelMatrix: TMatrix4f; const projMatrix: TMatrix4f; const viewport: TVector4i); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;876
procedure gluNurbsProperty(nobj: PGLUnurbs; aproperty: TGLEnum; value: TGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;877
procedure gluGetNurbsProperty(nobj: PGLUnurbs; aproperty: TGLEnum; value: PGLfloat); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;878
procedure gluNurbsCallback(nobj: PGLUnurbs; which: TGLEnum; fn: TGLUNurbsErrorProc); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;879
procedure gluBeginPolygon(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;880
procedure gluNextContour(tess: PGLUtesselator; atype: TGLEnum); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;881
procedure gluEndPolygon(tess: PGLUtesselator); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF} external glu32;883
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}885
{$IFDEF GLS_REGIONS} {$region 'Windows OpenGL (WGL) support functions'} {$ENDIF}887
function wglGetProcAddress(ProcName: PGLChar): Pointer; stdcall; external opengl32;
888
function wglCopyContext(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall; external opengl32;
889
function wglCreateContext(DC: HDC): HGLRC; stdcall; external opengl32;
890
function wglCreateLayerContext(p1: HDC; p2: Integer): HGLRC; stdcall; external opengl32;
891
function wglDeleteContext(p1: HGLRC): BOOL; stdcall; external opengl32;
892
function wglDescribeLayerPlane(p1: HDC; p2, p3: Integer; p4: Cardinal; var p5: TLayerPlaneDescriptor): BOOL; stdcall; external opengl32;
893
function wglGetCurrentContext: HGLRC; stdcall; external opengl32;
894
function wglGetCurrentDC: HDC; stdcall; external opengl32;
895
function wglGetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; external opengl32;
896
function wglMakeCurrent(DC: HDC; p2: HGLRC): BOOL; stdcall; external opengl32;
897
function wglRealizeLayerPalette(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall; external opengl32;
898
function wglSetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall; external opengl32;
899
function wglShareLists(p1, p2: HGLRC): BOOL; stdcall; external opengl32;
900
function wglSwapLayerBuffers(p1: HDC; p2: Cardinal): BOOL; stdcall; external opengl32;
901
function wglSwapMultipleBuffers(p1: UINT; const p2: PWGLSwap): DWORD; stdcall; external opengl32;
902
function wglUseFontBitmapsA(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; external opengl32;
903
function wglUseFontOutlinesA (p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; external opengl32;
904
function wglUseFontBitmapsW(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; external opengl32;
905
function wglUseFontOutlinesW (p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; external opengl32;
906
function wglUseFontBitmaps(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall; external opengl32 name 'wglUseFontBitmapsA';
907
function wglUseFontOutlines(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall; external opengl32 name 'wglUseFontOutlinesA';
909
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}911
{$IFDEF GLS_REGIONS} {$region 'OpenGL Extension to the X Window System (GLX) support functions'} {$ENDIF}914
function glXChooseVisual(dpy: PDisplay; screen: TGLint; attribList: PGLint): PXVisualInfo; cdecl; external opengl32;
915
function glXCreateContext(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: TGLboolean): GLXContext; cdecl; external opengl32;
916
procedure glXDestroyContext(dpy: PDisplay; ctx: GLXContext); cdecl; external opengl32;
917
function glXMakeCurrent(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): TGLboolean; cdecl; external opengl32;
918
procedure glXCopyContext(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: TGLuint); cdecl; external opengl32;
919
procedure glXSwapBuffers(dpy: PDisplay; drawable: GLXDrawable); cdecl; external opengl32;
920
function glXCreateGLXPixmap(dpy: PDisplay; visual: PXVisualInfo; pixmap: GLXPixmap): GLXPixmap; cdecl; external opengl32;
921
procedure glXDestroyGLXPixmap(dpy: PDisplay; pixmap: GLXPixmap); cdecl; external opengl32;
922
function glXQueryExtension(dpy: PDisplay; errorb: PGLInt; event: PGLInt): TGLboolean; cdecl; external opengl32;
923
function glXQueryVersion(dpy: PDisplay; maj: PGLInt; min: PGLINT): TGLboolean; cdecl; external opengl32;
924
function glXIsDirect(dpy: PDisplay; ctx: GLXContext): TGLboolean; cdecl; external opengl32;
925
function glXGetConfig(dpy: PDisplay; visual: PXVisualInfo; attrib: TGLInt; value: PGLInt): TGLInt; cdecl; external opengl32;
926
function glXGetCurrentContext: GLXContext; cdecl; external opengl32;
927
function glXGetCurrentDrawable: GLXDrawable; cdecl; external opengl32;
928
procedure glXWaitGL; cdecl; external opengl32;
929
procedure glXWaitX; cdecl; external opengl32;
930
procedure glXUseXFont(font: XFont; first: TGLInt; count: TGLInt; list: TGLint); cdecl; external opengl32;
933
function glXQueryExtensionsString(dpy: PDisplay; screen: TGLInt): PGLChar; cdecl; external opengl32;
934
function glXQueryServerString(dpy: PDisplay; screen: TGLInt; name: TGLInt): PGLChar; cdecl; external opengl32;
935
function glXGetClientString(dpy: PDisplay; name: TGLInt): PGLChar; cdecl; external opengl32;
938
function glXGetCurrentDisplay: PDisplay; cdecl; external opengl32;
940
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}944
{$IFDEF MULTITHREADOPENGL}950
{$IFDEF GLS_REGIONS} {$region 'OpenGL extension function/procedure definitions'} {$ENDIF}952
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 1.2'} {$ENDIF}954
// ###########################################################
955
// function and procedure definitions for
956
// extensions integrated into OpenGL 1.2 Core
957
// ###########################################################
959
// promoted to core v1.2 from GL_EXT_blend_color (#2)
960
glBlendColor: PFNGLBLENDCOLORPROC;
962
// promoted to core v1.2 from GL_EXT_blend_minmax (#37)
963
glBlendEquation: PFNGLBLENDEQUATIONPROC;
965
// promoted to core v1.2 from GL_EXT_draw_range_elements (#112)
966
glDrawRangeElements: PFNGLDRAWRANGEELEMENTSPROC;
968
// promoted to core v1.2 from GL_EXT_texture3D (#6)
969
glTexImage3D: PFNGLTEXIMAGE3DPROC;
970
glTexSubImage3D: PFNGLTEXSUBIMAGE3DPROC;
972
// promoted to core v1.2 from GL_EXT_copy_texture
973
glCopyTexSubImage3D: PFNGLCOPYTEXSUBIMAGE3DPROC;
975
{$IFDEF GLS_REGIONS} {$region 'OpenGL 1.2 deprecated'} {$ENDIF}976
// promoted to core v1.2 from GL_SGI_color_table (#14)
977
glColorTable: PFNGLCOLORTABLEPROC;
978
glColorTableParameterfv: PFNGLCOLORTABLEPARAMETERFVPROC;
979
glColorTableParameteriv: PFNGLCOLORTABLEPARAMETERIVPROC;
980
glCopyColorTable: PFNGLCOPYCOLORTABLEPROC;
981
glGetColorTable: PFNGLGETCOLORTABLEPROC;
982
glGetColorTableParameterfv: PFNGLGETCOLORTABLEPARAMETERFVPROC;
983
glGetColorTableParameteriv: PFNGLGETCOLORTABLEPARAMETERIVPROC;
985
// promoted to core v1.2 from GL_EXT_color_subtable (#74)
986
glColorSubTable: PFNGLCOLORSUBTABLEPROC;
987
glCopyColorSubTable: PFNGLCOPYCOLORSUBTABLEPROC;
989
// promoted to core v1.2 from GL_EXT_convolution (#12)
990
glConvolutionFilter1D: PFNGLCONVOLUTIONFILTER1DPROC;
991
glConvolutionFilter2D: PFNGLCONVOLUTIONFILTER2DPROC;
992
glConvolutionParameterf: PFNGLCONVOLUTIONPARAMETERFPROC;
993
glConvolutionParameterfv: PFNGLCONVOLUTIONPARAMETERFVPROC;
994
glConvolutionParameteri: PFNGLCONVOLUTIONPARAMETERIPROC;
995
glConvolutionParameteriv: PFNGLCONVOLUTIONPARAMETERIVPROC;
996
glCopyConvolutionFilter1D: PFNGLCOPYCONVOLUTIONFILTER1DPROC;
997
glCopyConvolutionFilter2D: PFNGLCOPYCONVOLUTIONFILTER2DPROC;
998
glGetConvolutionFilter: PFNGLGETCONVOLUTIONFILTERPROC;
999
glGetConvolutionParameterfv: PFNGLGETCONVOLUTIONPARAMETERFVPROC;
1000
glGetConvolutionParameteriv: PFNGLGETCONVOLUTIONPARAMETERIVPROC;
1001
glGetSeparableFilter: PFNGLGETSEPARABLEFILTERPROC;
1002
glSeparableFilter2D: PFNGLSEPARABLEFILTER2DPROC;
1004
// promoted to core v1.2 from GL_EXT_histogram (#11)
1005
glGetHistogram: PFNGLGETHISTOGRAMPROC;
1006
glGetHistogramParameterfv: PFNGLGETHISTOGRAMPARAMETERFVPROC;
1007
glGetHistogramParameteriv: PFNGLGETHISTOGRAMPARAMETERIVPROC;
1008
glGetMinmax: PFNGLGETMINMAXPROC;
1009
glGetMinmaxParameterfv: PFNGLGETMINMAXPARAMETERFVPROC;
1010
glGetMinmaxParameteriv: PFNGLGETMINMAXPARAMETERIVPROC;
1011
glHistogram: PFNGLHISTOGRAMPROC;
1012
glMinmax: PFNGLMINMAXPROC;
1013
glResetHistogram: PFNGLRESETHISTOGRAMPROC;
1014
glResetMinmax: PFNGLRESETMINMAXPROC;
1015
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1017
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1019
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 1.3'} {$ENDIF}1021
// ###########################################################
1022
// function and procedure definitions for
1023
// extensions integrated into OpenGL 1.3 Core
1024
// ###########################################################
1026
// promoted to core v1.3 from GL_ARB_multitexture (#1)
1027
glActiveTexture: PFNGLACTIVETEXTUREPROC;
1029
// promoted to core v1.3 from GL_ARB_multisample (#5)
1030
glSampleCoverage: PFNGLSAMPLECOVERAGEPROC;
1032
// promoted to core v1.3 from GL_ARB_texture_compression (#12)
1033
glCompressedTexImage3D: PFNGLCOMPRESSEDTEXIMAGE3DPROC;
1034
glCompressedTexImage2D: PFNGLCOMPRESSEDTEXIMAGE2DPROC;
1035
glCompressedTexImage1D: PFNGLCOMPRESSEDTEXIMAGE1DPROC;
1036
glCompressedTexSubImage3D: PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC;
1037
glCompressedTexSubImage2D: PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC;
1038
glCompressedTexSubImage1D: PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC;
1039
glGetCompressedTexImage: PFNGLGETCOMPRESSEDTEXIMAGEPROC;
1041
{$IFDEF GLS_REGIONS} {$region 'OpenGL 1.3 deprecated'} {$ENDIF}1042
// promoted to core v1.3 from GL_ARB_multitexture (#1)
1043
glClientActiveTexture: PFNGLCLIENTACTIVETEXTUREPROC;
1044
glMultiTexCoord1d: PFNGLMULTITEXCOORD1DPROC;
1045
glMultiTexCoord1dV: PFNGLMULTITEXCOORD1DVPROC;
1046
glMultiTexCoord1f: PFNGLMULTITEXCOORD1FPROC;
1047
glMultiTexCoord1fV: PFNGLMULTITEXCOORD1FVPROC;
1048
glMultiTexCoord1i: PFNGLMULTITEXCOORD1IPROC;
1049
glMultiTexCoord1iV: PFNGLMULTITEXCOORD1IVPROC;
1050
glMultiTexCoord1s: PFNGLMULTITEXCOORD1SPROC;
1051
glMultiTexCoord1sV: PFNGLMULTITEXCOORD1SVPROC;
1052
glMultiTexCoord2d: PFNGLMULTITEXCOORD2DPROC;
1053
glMultiTexCoord2dv: PFNGLMULTITEXCOORD2DVPROC;
1054
glMultiTexCoord2f: PFNGLMULTITEXCOORD2FPROC;
1055
glMultiTexCoord2fv: PFNGLMULTITEXCOORD2FVPROC;
1056
glMultiTexCoord2i: PFNGLMULTITEXCOORD2IPROC;
1057
glMultiTexCoord2iv: PFNGLMULTITEXCOORD2IVPROC;
1058
glMultiTexCoord2s: PFNGLMULTITEXCOORD2SPROC;
1059
glMultiTexCoord2sv: PFNGLMULTITEXCOORD2SVPROC;
1060
glMultiTexCoord3d: PFNGLMULTITEXCOORD3DPROC;
1061
glMultiTexCoord3dv: PFNGLMULTITEXCOORD3DVPROC;
1062
glMultiTexCoord3f: PFNGLMULTITEXCOORD3FPROC;
1063
glMultiTexCoord3fv: PFNGLMULTITEXCOORD3FVPROC;
1064
glMultiTexCoord3i: PFNGLMULTITEXCOORD3IPROC;
1065
glMultiTexCoord3iv: PFNGLMULTITEXCOORD3IVPROC;
1066
glMultiTexCoord3s: PFNGLMULTITEXCOORD3SPROC;
1067
glMultiTexCoord3sv: PFNGLMULTITEXCOORD3SVPROC;
1068
glMultiTexCoord4d: PFNGLMULTITEXCOORD4DPROC;
1069
glMultiTexCoord4dv: PFNGLMULTITEXCOORD4DVPROC;
1070
glMultiTexCoord4f: PFNGLMULTITEXCOORD4FPROC;
1071
glMultiTexCoord4fv: PFNGLMULTITEXCOORD4FVPROC;
1072
glMultiTexCoord4i: PFNGLMULTITEXCOORD4IPROC;
1073
glMultiTexCoord4iv: PFNGLMULTITEXCOORD4IVPROC;
1074
glMultiTexCoord4s: PFNGLMULTITEXCOORD4SPROC;
1075
glMultiTexCoord4sv: PFNGLMULTITEXCOORD4SVPROC;
1077
// promoted to core v1.3 from GL_ARB_transpose_matrix
1078
glLoadTransposeMatrixf: PFNGLLOADTRANSPOSEMATRIXFPROC;
1079
glLoadTransposeMatrixd: PFNGLLOADTRANSPOSEMATRIXDPROC;
1080
glMultTransposeMatrixf: PFNGLMULTTRANSPOSEMATRIXFPROC;
1081
glMultTransposeMatrixd: PFNGLMULTTRANSPOSEMATRIXDPROC;
1082
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1084
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1086
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 1.4'} {$ENDIF}1088
// ###########################################################
1089
// function and procedure definitions for
1090
// extensions integrated into OpenGL 1.4 Core
1091
// ###########################################################
1093
// promoted to core v1.4 from GL_EXT_blend_func_separate (#173)
1094
glBlendFuncSeparate: PFNGLBLENDFUNCSEPARATEPROC;
1096
// promoted to core v1.4 from GL_EXT_multi_draw_arrays (#148)
1097
glMultiDrawArrays: PFNGLMULTIDRAWARRAYSPROC;
1098
glMultiDrawElements: PFNGLMULTIDRAWELEMENTSPROC;
1100
// promoted to core v1.4 from GL_ARB_point_parameters (#14), GL_NV_point_sprite (#262)
1101
glPointParameterf: PFNGLPOINTPARAMETERFPROC;
1102
glPointParameterfv: PFNGLPOINTPARAMETERFVPROC;
1103
glPointParameteri: PFNGLPOINTPARAMETERIPROC;
1104
glPointParameteriv: PFNGLPOINTPARAMETERIVPROC;
1106
{$IFDEF GLS_REGIONS} {$region 'OpenGL 1.4 deprecated'} {$ENDIF}1107
// promoted to core v1.4 from GL_EXT_fog_coord (#149)
1108
glFogCoordf: PFNGLFOGCOORDFPROC;
1109
glFogCoordfv: PFNGLFOGCOORDFVPROC;
1110
glFogCoordd: PFNGLFOGCOORDDPROC;
1111
glFogCoorddv: PFNGLFOGCOORDDVPROC;
1112
glFogCoordPointer: PFNGLFOGCOORDPOINTERPROC;
1114
// promoted to core v1.4 from GL_EXT_secondary_color (#145)
1115
glSecondaryColor3b: PFNGLSECONDARYCOLOR3BPROC;
1116
glSecondaryColor3bv: PFNGLSECONDARYCOLOR3BVPROC;
1117
glSecondaryColor3d: PFNGLSECONDARYCOLOR3DPROC;
1118
glSecondaryColor3dv: PFNGLSECONDARYCOLOR3DVPROC;
1119
glSecondaryColor3f: PFNGLSECONDARYCOLOR3FPROC;
1120
glSecondaryColor3fv: PFNGLSECONDARYCOLOR3FVPROC;
1121
glSecondaryColor3i: PFNGLSECONDARYCOLOR3IPROC;
1122
glSecondaryColor3iv: PFNGLSECONDARYCOLOR3IVPROC;
1123
glSecondaryColor3s: PFNGLSECONDARYCOLOR3SPROC;
1124
glSecondaryColor3sv: PFNGLSECONDARYCOLOR3SVPROC;
1125
glSecondaryColor3ub: PFNGLSECONDARYCOLOR3UBPROC;
1126
glSecondaryColor3ubv: PFNGLSECONDARYCOLOR3UBVPROC;
1127
glSecondaryColor3ui: PFNGLSECONDARYCOLOR3UIPROC;
1128
glSecondaryColor3uiv: PFNGLSECONDARYCOLOR3UIVPROC;
1129
glSecondaryColor3us: PFNGLSECONDARYCOLOR3USPROC;
1130
glSecondaryColor3usv: PFNGLSECONDARYCOLOR3USVPROC;
1131
glSecondaryColorPointer: PFNGLSECONDARYCOLORPOINTERPROC;
1133
// promoted to core v1.4 from GL_ARB_window_pos (#25)
1134
glWindowPos2d: PFNGLWINDOWPOS2DPROC;
1135
glWindowPos2dv: PFNGLWINDOWPOS2DVPROC;
1136
glWindowPos2f: PFNGLWINDOWPOS2FPROC;
1137
glWindowPos2fv: PFNGLWINDOWPOS2FVPROC;
1138
glWindowPos2i: PFNGLWINDOWPOS2IPROC;
1139
glWindowPos2iv: PFNGLWINDOWPOS2IVPROC;
1140
glWindowPos2s: PFNGLWINDOWPOS2SPROC;
1141
glWindowPos2sv: PFNGLWINDOWPOS2SVPROC;
1142
glWindowPos3d: PFNGLWINDOWPOS3DPROC;
1143
glWindowPos3dv: PFNGLWINDOWPOS3DVPROC;
1144
glWindowPos3f: PFNGLWINDOWPOS3FPROC;
1145
glWindowPos3fv: PFNGLWINDOWPOS3FVPROC;
1146
glWindowPos3i: PFNGLWINDOWPOS3IPROC;
1147
glWindowPos3iv: PFNGLWINDOWPOS3IVPROC;
1148
glWindowPos3s: PFNGLWINDOWPOS3SPROC;
1149
glWindowPos3sv: PFNGLWINDOWPOS3SVPROC;
1150
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1152
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1154
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 1.5'} {$ENDIF}1156
// ###########################################################
1157
// function and procedure definitions for
1158
// extensions integrated into OpenGL 1.5 Core
1159
// ###########################################################
1161
// promoted to core v1.5 from GL_ARB_occlusion_query (#29)
1162
glGenQueries: PFNGLGENQUERIESPROC;
1163
glDeleteQueries: PFNGLDELETEQUERIESPROC;
1164
glIsQuery: PFNGLISQUERYPROC;
1165
glBeginQuery: PFNGLBEGINQUERYPROC;
1166
glEndQuery: PFNGLENDQUERYPROC;
1167
glGetQueryiv: PFNGLGETQUERYIVPROC;
1168
glGetQueryObjectiv: PFNGLGETQUERYOBJECTIVPROC;
1169
glGetQueryObjectuiv: PFNGLGETQUERYOBJECTUIVPROC;
1171
// promoted to core v1.5 from GL_ARB_vertex_buffer_object (#28)
1172
glBindBuffer: PFNGLBINDBUFFERPROC;
1173
glDeleteBuffers: PFNGLDELETEBUFFERSPROC;
1174
glGenBuffers: PFNGLGENBUFFERSPROC;
1175
glIsBuffer: PFNGLISBUFFERPROC;
1176
glBufferData: PFNGLBUFFERDATAPROC;
1177
glBufferSubData: PFNGLBUFFERSUBDATAPROC;
1178
glGetBufferSubData: PFNGLGETBUFFERSUBDATAPROC;
1179
glMapBuffer: PFNGLMAPBUFFERPROC;
1180
glUnmapBuffer: PFNGLUNMAPBUFFERPROC;
1181
glGetBufferParameteriv: PFNGLGETBUFFERPARAMETERIVPROC;
1182
glGetBufferPointerv: PFNGLGETBUFFERPOINTERVPROC;
1184
// promoted to core v1.5 from GL_EXT_shadow_funcs (#267)
1185
// (no functions or procedures)
1187
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1189
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 2.0'} {$ENDIF}1191
// ###########################################################
1192
// function and procedure definitions for
1193
// extensions integrated into OpenGL 2.0 Core
1194
// ###########################################################
1196
// promoted to core v2.0 from GL_EXT_blend_equation_separate (#299)
1197
glBlendEquationSeparate: PFNGLBLENDEQUATIONSEPARATEPROC;
1199
// promoted to core v2.0 from GL_ARB_draw_buffers (#37)
1200
glDrawBuffers: PFNGLDRAWBUFFERSPROC;
1202
// promoted to core v2.0 from GL_ARB_stencil_two_side (no # found)
1203
glStencilOpSeparate: PFNGLSTENCILOPSEPARATEPROC;
1204
glStencilFuncSeparate: PFNGLSTENCILFUNCSEPARATEPROC;
1205
glStencilMaskSeparate: PFNGLSTENCILMASKSEPARATEPROC;
1207
// promoted to core v2.0 from GL_ARB_shader_objects (#30) / GL_ARB_vertex_shader (#31) / GL_ARB_fragment_shader (#32)
1208
glAttachShader: PFNGLATTACHSHADERPROC;
1209
glBindAttribLocation: PFNGLBINDATTRIBLOCATIONPROC;
1210
glCompileShader: PFNGLCOMPILESHADERPROC;
1211
glCreateProgram: PFNGLCREATEPROGRAMPROC;
1212
glCreateShader: PFNGLCREATESHADERPROC;
1213
glDeleteProgram: PFNGLDELETEPROGRAMPROC;
1214
glDeleteShader: PFNGLDELETESHADERPROC;
1215
glDetachShader: PFNGLDETACHSHADERPROC;
1216
glDisableVertexAttribArray: PFNGLDISABLEVERTEXATTRIBARRAYPROC;
1217
glEnableVertexAttribArray: PFNGLENABLEVERTEXATTRIBARRAYPROC;
1218
glGetActiveAttrib: PFNGLGETACTIVEATTRIBPROC;
1219
glGetActiveUniform: PFNGLGETACTIVEUNIFORMPROC;
1220
glGetAttachedShaders: PFNGLGETATTACHEDSHADERSPROC;
1221
glGetAttribLocation: PFNGLGETATTRIBLOCATIONPROC;
1222
glGetProgramiv: PFNGLGETPROGRAMIVPROC;
1223
glGetProgramInfoLog: PFNGLGETPROGRAMINFOLOGPROC;
1224
glGetShaderiv: PFNGLGETSHADERIVPROC;
1225
glGetShaderInfoLog: PFNGLGETSHADERINFOLOGPROC;
1226
glGetShaderSource: PFNGLGETSHADERSOURCEPROC;
1227
glGetUniformLocation: PFNGLGETUNIFORMLOCATIONPROC;
1228
glGetUniformfv: PFNGLGETUNIFORMFVPROC;
1229
glGetUniformiv: PFNGLGETUNIFORMIVPROC;
1230
glGetVertexAttribdv: PFNGLGETVERTEXATTRIBDVPROC;
1231
glGetVertexAttribfv: PFNGLGETVERTEXATTRIBFVPROC;
1232
glGetVertexAttribiv: PFNGLGETVERTEXATTRIBIVPROC;
1233
glGetVertexAttribPointerv: PFNGLGETVERTEXATTRIBPOINTERVPROC;
1234
glIsProgram: PFNGLISPROGRAMPROC;
1235
glIsShader: PFNGLISSHADERPROC;
1236
glLinkProgram: PFNGLLINKPROGRAMPROC;
1237
glShaderSource: PFNGLSHADERSOURCEPROC;
1238
glUseProgram: PFNGLUSEPROGRAMPROC;
1239
glUniform1f: PFNGLUNIFORM1FPROC;
1240
glUniform2f: PFNGLUNIFORM2FPROC;
1241
glUniform3f: PFNGLUNIFORM3FPROC;
1242
glUniform4f: PFNGLUNIFORM4FPROC;
1243
glUniform1i: PFNGLUNIFORM1IPROC;
1244
glUniform2i: PFNGLUNIFORM2IPROC;
1245
glUniform3i: PFNGLUNIFORM3IPROC;
1246
glUniform4i: PFNGLUNIFORM4IPROC;
1247
glUniform1fv: PFNGLUNIFORM1FVPROC;
1248
glUniform2fv: PFNGLUNIFORM2FVPROC;
1249
glUniform3fv: PFNGLUNIFORM3FVPROC;
1250
glUniform4fv: PFNGLUNIFORM4FVPROC;
1251
glUniform1iv: PFNGLUNIFORM1IVPROC;
1252
glUniform2iv: PFNGLUNIFORM2IVPROC;
1253
glUniform3iv: PFNGLUNIFORM3IVPROC;
1254
glUniform4iv: PFNGLUNIFORM4IVPROC;
1255
glUniformMatrix2fv: PFNGLUNIFORMMATRIX2FVPROC;
1256
glUniformMatrix3fv: PFNGLUNIFORMMATRIX3FVPROC;
1257
glUniformMatrix4fv: PFNGLUNIFORMMATRIX4FVPROC;
1258
glValidateProgram: PFNGLVALIDATEPROGRAMPROC;
1259
glVertexAttrib1d: PFNGLVERTEXATTRIB1DPROC;
1260
glVertexAttrib1dv: PFNGLVERTEXATTRIB1DVPROC;
1261
glVertexAttrib1f: PFNGLVERTEXATTRIB1FPROC;
1262
glVertexAttrib1fv: PFNGLVERTEXATTRIB1FVPROC;
1263
glVertexAttrib1s: PFNGLVERTEXATTRIB1SPROC;
1264
glVertexAttrib1sv: PFNGLVERTEXATTRIB1SVPROC;
1265
glVertexAttrib2d: PFNGLVERTEXATTRIB2DPROC;
1266
glVertexAttrib2dv: PFNGLVERTEXATTRIB2DVPROC;
1267
glVertexAttrib2f: PFNGLVERTEXATTRIB2FPROC;
1268
glVertexAttrib2fv: PFNGLVERTEXATTRIB2FVPROC;
1269
glVertexAttrib2s: PFNGLVERTEXATTRIB2SPROC;
1270
glVertexAttrib2sv: PFNGLVERTEXATTRIB2SVPROC;
1271
glVertexAttrib3d: PFNGLVERTEXATTRIB3DPROC;
1272
glVertexAttrib3dv: PFNGLVERTEXATTRIB3DVPROC;
1273
glVertexAttrib3f: PFNGLVERTEXATTRIB3FPROC;
1274
glVertexAttrib3fv: PFNGLVERTEXATTRIB3FVPROC;
1275
glVertexAttrib3s: PFNGLVERTEXATTRIB3SPROC;
1276
glVertexAttrib3sv: PFNGLVERTEXATTRIB3SVPROC;
1277
glVertexAttrib4Nbv: PFNGLVERTEXATTRIB4NBVPROC;
1278
glVertexAttrib4Niv: PFNGLVERTEXATTRIB4NIVPROC;
1279
glVertexAttrib4Nsv: PFNGLVERTEXATTRIB4NSVPROC;
1280
glVertexAttrib4Nub: PFNGLVERTEXATTRIB4NUBPROC;
1281
glVertexAttrib4Nubv: PFNGLVERTEXATTRIB4NUBVPROC;
1282
glVertexAttrib4Nuiv: PFNGLVERTEXATTRIB4NUIVPROC;
1283
glVertexAttrib4Nusv: PFNGLVERTEXATTRIB4NUSVPROC;
1284
glVertexAttrib4bv: PFNGLVERTEXATTRIB4BVPROC;
1285
glVertexAttrib4d: PFNGLVERTEXATTRIB4DPROC;
1286
glVertexAttrib4dv: PFNGLVERTEXATTRIB4DVPROC;
1287
glVertexAttrib4f: PFNGLVERTEXATTRIB4FPROC;
1288
glVertexAttrib4fv: PFNGLVERTEXATTRIB4FVPROC;
1289
glVertexAttrib4iv: PFNGLVERTEXATTRIB4IVPROC;
1290
glVertexAttrib4s: PFNGLVERTEXATTRIB4SPROC;
1291
glVertexAttrib4sv: PFNGLVERTEXATTRIB4SVPROC;
1292
glVertexAttrib4ubv: PFNGLVERTEXATTRIB4UBVPROC;
1293
glVertexAttrib4uiv: PFNGLVERTEXATTRIB4UIVPROC;
1294
glVertexAttrib4usv: PFNGLVERTEXATTRIB4USVPROC;
1295
glVertexAttribPointer: PFNGLVERTEXATTRIBPOINTERPROC;
1297
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1299
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 2.1'} {$ENDIF}1301
// ###########################################################
1302
// function and procedure definitions for
1303
// extensions integrated into OpenGL 2.1 Core
1304
// ###########################################################
1306
// promoted to core v2.1 from GL_ARB_pixel_buffer_object
1307
// (no functions or procedures)
1309
// promoted to core v2.1 from GL_EXT_texture_sRGB (#315)
1310
// (no functions or procedures)
1312
// New commands in OpenGL 2.1
1313
glUniformMatrix2x3fv: PFNGLUNIFORMMATRIX2X3FVPROC;
1314
glUniformMatrix3x2fv: PFNGLUNIFORMMATRIX3X2FVPROC;
1315
glUniformMatrix2x4fv: PFNGLUNIFORMMATRIX2X4FVPROC;
1316
glUniformMatrix4x2fv: PFNGLUNIFORMMATRIX4X2FVPROC;
1317
glUniformMatrix3x4fv: PFNGLUNIFORMMATRIX3X4FVPROC;
1318
glUniformMatrix4x3fv: PFNGLUNIFORMMATRIX4X3FVPROC;
1320
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1322
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 3.0'} {$ENDIF}1324
// ###########################################################
1325
// function and procedure definitions for
1326
// extensions integrated into OpenGL 3.0 Core
1327
// ###########################################################
1329
// promoted to core v3.0 from GL_EXT_gpu_shader4
1330
glVertexAttribI1i: PFNGLVERTEXATTRIBI1IPROC;
1331
glVertexAttribI2i: PFNGLVERTEXATTRIBI2IPROC;
1332
glVertexAttribI3i: PFNGLVERTEXATTRIBI3IPROC;
1333
glVertexAttribI4i: PFNGLVERTEXATTRIBI4IPROC;
1334
glVertexAttribI1ui: PFNGLVERTEXATTRIBI1UIPROC;
1335
glVertexAttribI2ui: PFNGLVERTEXATTRIBI2UIPROC;
1336
glVertexAttribI3ui: PFNGLVERTEXATTRIBI3UIPROC;
1337
glVertexAttribI4ui: PFNGLVERTEXATTRIBI4UIPROC;
1338
glVertexAttribI1iv: PFNGLVERTEXATTRIBI1IVPROC;
1339
glVertexAttribI2iv: PFNGLVERTEXATTRIBI2IVPROC;
1340
glVertexAttribI3iv: PFNGLVERTEXATTRIBI3IVPROC;
1341
glVertexAttribI4iv: PFNGLVERTEXATTRIBI4IVPROC;
1342
glVertexAttribI1uiv: PFNGLVERTEXATTRIBI1UIVPROC;
1343
glVertexAttribI2uiv: PFNGLVERTEXATTRIBI2UIVPROC;
1344
glVertexAttribI3uiv: PFNGLVERTEXATTRIBI3UIVPROC;
1345
glVertexAttribI4uiv: PFNGLVERTEXATTRIBI4UIVPROC;
1346
glVertexAttribI4bv: PFNGLVERTEXATTRIBI4BVPROC;
1347
glVertexAttribI4sv: PFNGLVERTEXATTRIBI4SVPROC;
1348
glVertexAttribI4ubv: PFNGLVERTEXATTRIBI4UBVPROC;
1349
glVertexAttribI4usv: PFNGLVERTEXATTRIBI4USVPROC;
1350
glVertexAttribIPointer: PFNGLVERTEXATTRIBIPOINTERPROC;
1351
glGetVertexAttribIiv: PFNGLGETVERTEXATTRIBIIVPROC;
1352
glGetVertexAttribIuiv: PFNGLGETVERTEXATTRIBIUIVPROC;
1353
glUniform1ui: PFNGLUNIFORM1UIPROC;
1354
glUniform2ui: PFNGLUNIFORM2UIPROC;
1355
glUniform3ui: PFNGLUNIFORM3UIPROC;
1356
glUniform4ui: PFNGLUNIFORM4UIPROC;
1357
glUniform1uiv: PFNGLUNIFORM1UIVPROC;
1358
glUniform2uiv: PFNGLUNIFORM2UIVPROC;
1359
glUniform3uiv: PFNGLUNIFORM3UIVPROC;
1360
glUniform4uiv: PFNGLUNIFORM4UIVPROC;
1361
glGetUniformuiv: PFNGLGETUNIFORMUIVPROC;
1362
glBindFragDataLocation: PFNGLBINDFRAGDATALOCATIONPROC;
1363
glGetFragDataLocation: PFNGLGETFRAGDATALOCATIONPROC;
1365
// promoted to core v3.0 from GL_NV_conditional_render
1366
glBeginConditionalRender: PFNGLBEGINCONDITIONALRENDERPROC;
1367
glEndConditionalRender: PFNGLENDCONDITIONALRENDERPROC;
1369
// promoted to core v3.0 from GL_ARB_color_buffer_float
1370
glClampColor: PFNGLCLAMPCOLORPROC;
1372
// promoted to core v3.0 from GL_EXT_texture_integer
1373
//glClearColorIi: procedure(r: TGLint; g: TGLint; b: TGLint; a: TGLint);{$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF}1374
//glClearColorIui: procedure(r: TGLuint; g: TGLuint; b: TGLuint; a: TGLuint);{$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF}1375
glTexParameterIiv: PFNGLTEXPARAMETERIIVPROC;
1376
glTexParameterIuiv: PFNGLTEXPARAMETERIUIVPROC;
1377
glGetTexParameterIiv: PFNGLGETTEXPARAMETERIIVPROC;
1378
glGetTexParameterIuiv: PFNGLGETTEXPARAMETERIUIVPROC;
1380
// promoted to core v3.0 from GL_EXT_draw_buffers2
1381
glColorMaski: PFNGLCOLORMASKIPROC;
1382
glGetBooleani_v: PFNGLGETBOOLEANI_VPROC;
1383
glGetIntegeri_v: PFNGLGETINTEGERI_VPROC;
1384
glEnablei: PFNGLENABLEIPROC;
1385
glDisablei: PFNGLDISABLEIPROC;
1386
glIsEnabledi: PFNGLISENABLEDIPROC;
1388
//promoted to core v3.0 from GL_EXT_transform_feedback
1389
glBindBufferRange: PFNGLBINDBUFFERRANGEPROC;
1390
glBindBufferBase: PFNGLBINDBUFFERBASEPROC;
1391
glBeginTransformFeedback: PFNGLBEGINTRANSFORMFEEDBACKPROC;
1392
glEndTransformFeedback: PFNGLENDTRANSFORMFEEDBACKPROC;
1393
glTransformFeedbackVaryings: PFNGLTRANSFORMFEEDBACKVARYINGSPROC;
1394
glGetTransformFeedbackVarying: PFNGLGETTRANSFORMFEEDBACKVARYINGPROC;
1396
// New commands in OpenGL 3.0
1397
glClearBufferiv: PFNGLCLEARBUFFERIVPROC;
1398
glClearBufferuiv: PFNGLCLEARBUFFERUIVPROC;
1399
glClearBufferfv: PFNGLCLEARBUFFERFVPROC;
1400
glClearBufferfi: PFNGLCLEARBUFFERFIPROC;
1401
glGetStringi: PFNGLGETSTRINGIPROC;
1403
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1405
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 3.1'} {$ENDIF}1407
// ###########################################################
1408
// function and procedure definitions for
1409
// extensions integrated into OpenGL 3.1 Core
1410
// ###########################################################
1412
glDrawArraysInstanced: PFNGLDRAWARRAYSINSTANCEDPROC;
1413
glDrawElementsInstanced: PFNGLDRAWELEMENTSINSTANCEDPROC;
1414
glTexBuffer: PFNGLTEXBUFFERPROC;
1415
glPrimitiveRestartIndex: PFNGLPRIMITIVERESTARTINDEXPROC;
1417
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1419
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 3.2'} {$ENDIF}1421
// ###########################################################
1422
// function and procedure definitions for
1423
// extensions integrated into OpenGL 3.2 Core
1424
// ###########################################################
1426
glGetInteger64i_v: PFNGLGETINTEGER64I_VPROC;
1427
glGetBufferParameteri64v: PFNGLGETBUFFERPARAMETERI64VPROC;
1428
glFramebufferTexture: PFNGLFRAMEBUFFERTEXTUREPROC;
1429
// glFramebufferTextureFace: procedure(target: TGLenum; attachment: TGLenum; texture: TGLuint; level: TGLint; face: TGLenum);{$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF}1430
// OpenGL 3.2 also reuses entry points from these extensions:
1431
// GL_ARB_draw_elements_base_vertex
1432
// GL_ARB_provoking_vertex
1434
// GL_ARB_texture_multisample
1436
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1438
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 3.3'} {$ENDIF}1440
// ###########################################################
1441
// function and procedure definitions for
1442
// extensions integrated into OpenGL 3.3 Core
1443
// ###########################################################
1445
// New commands in OpenGL 3.3
1446
glVertexAttribDivisor: PFNGLVERTEXATTRIBDIVISORPROC;
1448
// OpenGL 3.3 reuses entry points from these extensions:
1449
// GL_ARB_blend_func_extended (ARB #78)
1450
// GL_ARB_explicit_attrib_location (ARB #79) (none)
1451
// GL_ARB_occlusion_query2 (ARB #80)
1452
// GL_ARB_sampler_objects (ARB #81)
1453
// GL_ARB_shader_bit_encoding (ARB #82)
1454
// GL_ARB_texture_rgb10_a2ui (ARB #83)
1455
// GL_ARB_texture_swizzle (ARB #84)
1456
// GL_ARB_timer_query (ARB #85)
1457
// GL_ARB_vertex_type_2_10_10_10_rev (ARB #86)
1459
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1461
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 4.0'} {$ENDIF}1463
// ###########################################################
1464
// function and procedure definitions for
1465
// extensions integrated into OpenGL 4.0 Core
1466
// ###########################################################
1468
// New commands in OpenGL 4.0
1469
glMinSampleShading: PFNGLMINSAMPLESHADINGPROC;
1470
glBlendEquationi: PFNGLBLENDEQUATIONIPROC;
1471
glBlendEquationSeparatei: PFNGLBLENDEQUATIONSEPARATEIPROC;
1472
glBlendFunci: PFNGLBLENDFUNCIPROC;
1473
glBlendFuncSeparatei: PFNGLBLENDFUNCSEPARATEIPROC;
1475
// OpenGL 4.0 uses entry points from these extensions:
1476
// GL_ARB_draw_indirect (ARB #87)
1477
// GL_ARB_gpu_shader5 (ARB #88) (none)
1478
// GL_ARB_gpu_shader_fp64 (ARB #89)
1479
// GL_ARB_shader_subroutine (ARB #90)
1480
// GL_ARB_tessellation_shader (ARB #91)
1481
// GL_ARB_texture_buffer_object_rgb32 (ARB #92) (none)
1482
// GL_ARB_transform_feedback2 (ARB #93)
1483
// GL_ARB_transform_feedback3 (ARB #94)
1485
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1487
{$IFDEF GLS_REGIONS} {$region 'New core function/procedure definitions in OpenGL 4.1'} {$ENDIF}1489
// OpenGL 4.1 uses entry points from these extensions:
1490
// ARB_ES2_compatibility
1491
// ARB_get_program_binary
1492
// ARB_separate_shader_objects
1493
// ARB_shader_precision (no entry points)
1494
// ARB_vertex_attrib_64bit
1495
// ARB_viewport_array
1497
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1499
{$IFDEF GLS_REGIONS} {$region 'OpenGL Utility (GLU) function/procedure definitions'} {$ENDIF}1501
// ###########################################################
1502
// function and procedure definitions for
1504
// ###########################################################
1507
gluNurbsCallbackDataEXT: PFNGLUNURBSCALLBACKDATAEXTPROC;
1508
gluNewNurbsTessellatorEXT: PFNGLUNEWNURBSTESSELLATOREXTPROC;
1509
gluDeleteNurbsTessellatorEXT: PFNGLUDELETENURBSTESSELLATOREXTPROC;
1511
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1513
{$IFDEF GLS_REGIONS} {$region 'Windows OpenGL (WGL) function/procedure definitions for ARB approved extensions'} {$ENDIF}1514
{$IFDEF SUPPORT_WGL}1515
// ###########################################################
1516
// function and procedure definitions for
1517
// ARB approved WGL extensions
1518
// ###########################################################
1520
// WGL_buffer_region (ARB #4)
1521
wglCreateBufferRegionARB: PFNWGLCREATEBUFFERREGIONARBPROC;
1522
wglDeleteBufferRegionARB: PFNWGLDELETEBUFFERREGIONARBPROC;
1523
wglSaveBufferRegionARB: PFNWGLSAVEBUFFERREGIONARBPROC;
1524
wglRestoreBufferRegionARB: PFNWGLRESTOREBUFFERREGIONARBPROC;
1526
// WGL_ARB_extensions_string (ARB #8)
1527
wglGetExtensionsStringARB: PFNWGLGETEXTENSIONSSTRINGARBPROC;
1529
// WGL_ARB_pixel_format (ARB #9)
1530
wglGetPixelFormatAttribivARB: PFNWGLGETPIXELFORMATATTRIBIVARBPROC;
1531
wglGetPixelFormatAttribfvARB: PFNWGLGETPIXELFORMATATTRIBFVARBPROC;
1532
wglChoosePixelFormatARB: PFNWGLCHOOSEPIXELFORMATARBPROC;
1534
// WGL_make_current_read (ARB #10)
1535
wglMakeContextCurrentARB: PFNWGLMAKECONTEXTCURRENTARBPROC;
1536
wglGetCurrentReadDCARB: PFNWGLGETCURRENTREADDCARBPROC;
1538
// WGL_ARB_pbuffer (ARB #11)
1539
wglCreatePbufferARB: PFNWGLCREATEPBUFFERARBPROC;
1540
wglGetPbufferDCARB: PFNWGLGETPBUFFERDCARBPROC;
1541
wglReleasePbufferDCARB: PFNWGLRELEASEPBUFFERDCARBPROC;
1542
wglDestroyPbufferARB: PFNWGLDESTROYPBUFFERARBPROC;
1543
wglQueryPbufferARB: PFNWGLQUERYPBUFFERARBPROC;
1545
// WGL_ARB_render_texture (ARB #20)
1546
wglBindTexImageARB: PFNWGLBINDTEXIMAGEARBPROC;
1547
wglReleaseTexImageARB: PFNWGLRELEASETEXIMAGEARBPROC;
1548
wglSetPbufferAttribARB: PFNWGLSETPBUFFERATTRIBARBPROC;
1550
// WGL_ARB_create_context (ARB #55)
1551
wglCreateContextAttribsARB: PFNWGLCREATECONTEXTATTRIBSARBPROC;
1553
// WGL_NV_gpu_affinity
1554
wglEnumGpusNV: PFNWGLENUMGPUSNVPROC;
1555
wglEnumGpuDevicesNV: PFNWGLENUMGPUDEVICESNVPROC;
1556
wglCreateAffinityDCNV: PFNWGLCREATEAFFINITYDCNVPROC;
1557
wglEnumGpusFromAffinityDCNV: PFNWGLENUMGPUSFROMAFFINITYDCNVPROC;
1558
wglDeleteDCNV: PFNWGLDELETEDCNVPROC;
1561
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1563
{$IFDEF GLS_REGIONS} {$region 'Windows OpenGL (WGL) function/procedure definitions for Vendor/EXT extensions'} {$ENDIF}1564
{$IFDEF SUPPORT_WGL}1565
// ###########################################################
1566
// function and procedure definitions for
1567
// Vendor/EXT WGL extensions
1568
// ###########################################################
1570
// WGL_EXT_swap_control (EXT #172)
1571
wglSwapIntervalEXT: PFNWGLSWAPINTERVALEXTPROC;
1572
wglGetSwapIntervalEXT: PFNWGLGETSWAPINTERVALEXTPROC;
1574
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1576
{$IFDEF GLS_REGIONS} {$region 'GLX function/procedure definitions for ARB approved extensions'} {$ENDIF}1577
{$IFDEF SUPPORT_GLX}1578
// ###########################################################
1579
// function and procedure definitions for
1580
// ARB approved GLX extensions
1581
// ###########################################################
1583
// GLX 1.3 and later
1584
glXChooseFBConfig: PFNGLXCHOOSEFBCONFIGPROC;
1585
glXGetFBConfigAttrib: PFNGLXGETFBCONFIGATTRIBPROC;
1586
glXGetFBConfigs: PFNGLXGETFBCONFIGSPROC;
1587
glXGetVisualFromFBConfig: PFNGLXGETVISUALFROMFBCONFIGPROC;
1588
glXCreateWindow: PFNGLXCREATEWINDOWPROC;
1589
glXDestroyWindow: PFNGLXDESTROYWINDOWPROC;
1590
glXCreatePixmap: PFNGLXCREATEPIXMAPPROC;
1591
glXDestroyPixmap: PFNGLXDESTROYPIXMAPPROC;
1592
glXCreatePbuffer: PFNGLXCREATEPBUFFERPROC;
1593
glXDestroyPbuffer: PFNGLXDESTROYPBUFFERPROC;
1594
glXQueryDrawable: PFNGLXQUERYDRAWABLEPROC;
1595
glXCreateNewContext: PFNGLXCREATENEWCONTEXTPROC;
1596
glXMakeContextCurrent: PFNGLXMAKECONTEXTCURRENTPROC;
1597
glXGetCurrentReadDrawable: PFNGLXGETCURRENTREADDRAWABLEPROC;
1598
glXQueryContext: PFNGLXQUERYCONTEXTPROC;
1599
glXSelectEvent: PFNGLXSELECTEVENTPROC;
1600
glXGetSelectedEvent: PFNGLXGETSELECTEDEVENTPROC;
1601
glXBindTexImageARB: PFNGLXBINDTEXIMAGEARBPROC;
1602
glXReleaseTexImageARB: PFNGLXRELEASETEXIMAGEARBPROC;
1603
glxDrawableAttribARB: PFNGLXDRAWABLEATTRIBARBPROC;
1606
// GLX_ARB_create_context (EXT #56)
1607
glXCreateContextAttribsARB: PFNGLXCREATECONTEXTATTRIBSARBPROC;
1608
glXGetProcAddress: PFNGLXGETPROCADDRESSPROC;
1609
glXGetProcAddressARB: PFNGLXGETPROCADDRESSARBPROC;
1612
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1614
{$IFDEF GLS_REGIONS} {$region 'GLX function/procedure definitions for Vendor/EXT extensions'} {$ENDIF}1615
{$IFDEF SUPPORT_GLX}1616
// ###########################################################
1617
// function and procedure definitions for
1618
// Vendor/EXT GLX extensions
1619
// ###########################################################
1621
// GLX_SGI_swap_control (EXT #40)
1622
glXSwapIntervalSGI: PFNGLXSWAPINTERVALSGIPROC;
1623
glXGetVideoSyncSGI: PFNGLXGETVIDEOSYNCSGIPROC;
1624
glXWaitVideoSyncSGI: PFNGLXWAITVIDEOSYNCSGIPROC;
1625
glXFreeContextEXT: PFNGLXFREECONTEXTEXTPROC;
1626
glXGetContextIDEXT: PFNGLXGETCONTEXTIDEXTPROC;
1627
glXGetCurrentDisplayEXT: PFNGLXGETCURRENTDISPLAYEXTPROC;
1628
glXImportContextEXT: PFNGLXIMPORTCONTEXTEXTPROC;
1629
glXQueryContextInfoEXT: PFNGLXQUERYCONTEXTINFOEXTPROC;
1630
glXCopySubBufferMESA: PFNGLXCOPYSUBBUFFERMESAPROC;
1631
glXCreateGLXPixmapMESA: PFNGLXCREATEGLXPIXMAPMESAPROC;
1632
glXReleaseBuffersMESA: PFNGLXRELEASEBUFFERSMESAPROC;
1633
glXSet3DfxModeMESA: PFNGLXSET3DFXMODEMESAPROC;
1635
glXBindTexImageEXT: PFNGLXBINDTEXIMAGEEXTPROC;
1636
glXReleaseTexImageEXT: PFNGLXRELEASETEXIMAGEEXTPROC;
1639
glXMakeCurrentReadSGI: PFNGLXMAKECURRENTREADSGIPROC;
1640
glXGetCurrentReadDrawableSGI: PFNGLXGETCURRENTREADDRAWABLESGIPROC;
1641
glXGetFBConfigAttribSGIX: PFNGLXGETFBCONFIGATTRIBSGIXPROC;
1642
glXChooseFBConfigSGIX: PFNGLXCHOOSEFBCONFIGSGIXPROC;
1643
glXCreateGLXPixmapWithConfigSGIX: PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC;
1644
glXCreateContextWithConfigSGIX: PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC;
1645
glXGetVisualFromFBConfigSGIX: PFNGLXGETVISUALFROMFBCONFIGSGIXPROC;
1646
glXGetFBConfigFromVisualSGIX: PFNGLXGETFBCONFIGFROMVISUALSGIXPROC;
1647
glXCreateGLXPbufferSGIX: PFNGLXCREATEGLXPBUFFERSGIXPROC;
1648
glXDestroyGLXPbufferSGIX: PFNGLXDESTROYGLXPBUFFERSGIXPROC;
1649
glXQueryGLXPbufferSGIX: PFNGLXQUERYGLXPBUFFERSGIXPROC;
1650
glXSelectEventSGIX: PFNGLXSELECTEVENTSGIXPROC;
1651
glXGetSelectedEventSGIX: PFNGLXGETSELECTEDEVENTSGIXPROC;
1652
glXCushionSGI: PFNGLXCUSHIONSGIPROC;
1653
glXBindChannelToWindowSGIX: PFNGLXBINDCHANNELTOWINDOWSGIXPROC;
1654
glXChannelRectSGIX: PFNGLXCHANNELRECTSGIXPROC;
1655
glXQueryChannelRectSGIX: PFNGLXQUERYCHANNELRECTSGIXPROC;
1656
glXQueryChannelDeltasSGIX: PFNGLXQUERYCHANNELDELTASSGIXPROC;
1657
glXChannelRectSyncSGIX: PFNGLXCHANNELRECTSYNCSGIXPROC;
1658
glXJoinSwapGroupSGIX: PFNGLXJOINSWAPGROUPSGIXPROC;
1659
glXBindSwapBarrierSGIX: PFNGLXBINDSWAPBARRIERSGIXPROC;
1660
glXQueryMaxSwapBarriersSGIX: PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC;
1661
glXQueryHyperpipeNetworkSGIX: PFNGLXQUERYHYPERPIPENETWORKSGIXPROC;
1662
glXHyperpipeConfigSGIX: PFNGLXHYPERPIPECONFIGSGIXPROC;
1663
glXQueryHyperpipeConfigSGIX: PFNGLXQUERYHYPERPIPECONFIGSGIXPROC;
1664
glXDestroyHyperpipeConfigSGIX: PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC;
1665
glXBindHyperpipeSGIX: PFNGLXBINDHYPERPIPESGIXPROC;
1666
glXQueryHyperpipeBestAttribSGIX: PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC;
1667
glXHyperpipeAttribSGIX: PFNGLXHYPERPIPEATTRIBSGIXPROC;
1668
glXQueryHyperpipeAttribSGIX: PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC;
1669
glXGetAGPOffsetMESA: PFNGLXGETAGPOFFSETMESAPROC;
1670
glXEnumerateVideoDevicesNV: PFNGLXENUMERATEVIDEODEVICESNVPROC;
1671
glXBindVideoDeviceNV: PFNGLXBINDVIDEODEVICENVPROC;
1672
glxGetVideoDeviceNV: PFNGLXGETVIDEODEVICENVPROC;
1674
glXAllocateMemoryNV: PFNGLXALLOCATEMEMORYNVPROC;
1675
glXFreeMemoryNV: PFNGLXFREEMEMORYNVPROC;
1677
glXReleaseVideoDeviceNV: PFNGLXRELEASEVIDEODEVICENVPROC;
1678
glXBindVideoImageNV: PFNGLXBINDVIDEOIMAGENVPROC;
1679
glXReleaseVideoImageNV: PFNGLXRELEASEVIDEOIMAGENVPROC;
1680
glXSendPbufferToVideoNV: PFNGLXSENDPBUFFERTOVIDEONVPROC;
1681
glXGetVideoInfoNV: PFNGLXGETVIDEOINFONVPROC;
1682
glXJoinSwapGroupNV: PFNGLXJOINSWAPGROUPNVPROC;
1683
glXBindSwapBarrierNV: PFNGLXBINDSWAPBARRIERNVPROC;
1684
glXQuerySwapGroupNV: PFNGLXQUERYSWAPGROUPNVPROC;
1685
glXQueryMaxSwapGroupsNV: PFNGLXQUERYMAXSWAPGROUPSNVPROC;
1686
glXQueryFrameCountNV: PFNGLXQUERYFRAMECOUNTNVPROC;
1687
glXResetFrameCountNV: PFNGLXRESETFRAMECOUNTNVPROC;
1688
glXBindVideoCaptureDeviceNV: PFNGLXBINDVIDEOCAPTUREDEVICENVPROC;
1689
glXEnumerateVideoCaptureDevicesNV: PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC;
1690
glxLockVideoCaptureDeviceNV: PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC;
1691
glXQueryVideoCaptureDeviceNV: PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC;
1692
glXReleaseVideoCaptureDeviceNV: PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC;
1693
glXSwapIntervalEXT: PFNGLXSWAPINTERVALEXTPROC;
1694
glXCopyImageSubDataNV: PFNGLXCOPYIMAGESUBDATANVPROC;
1697
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}1699
{$IFDEF GLS_REGIONS} {$region 'OpenGL function/procedure definitions for ARB approved extensions'} {$ENDIF}1701
// ###########################################################
1702
// function and procedure definitions for
1703
// ARB approved extensions
1704
// ###########################################################
1706
// unknown ARB extension
1707
glSamplePassARB: PFNGLSAMPLEPASSARBPROC;
1709
// GL_ARB_multitexture (ARB #1)
1710
glActiveTextureARB: PFNGLACTIVETEXTUREARBPROC;
1711
glClientActiveTextureARB: PFNGLCLIENTACTIVETEXTUREARBPROC;
1712
glMultiTexCoord1dARB: PFNGLMULTITEXCOORD1DARBPROC;
1713
glMultiTexCoord1dVARB: PFNGLMULTITEXCOORD1DVARBPROC;
1714
glMultiTexCoord1fARB: PFNGLMULTITEXCOORD1FARBPROC;
1715
glMultiTexCoord1fVARB: PFNGLMULTITEXCOORD1FVARBPROC;
1716
glMultiTexCoord1iARB: PFNGLMULTITEXCOORD1IARBPROC;
1717
glMultiTexCoord1iVARB: PFNGLMULTITEXCOORD1IVARBPROC;
1718
glMultiTexCoord1sARB: PFNGLMULTITEXCOORD1SARBPROC;
1719
glMultiTexCoord1sVARB: PFNGLMULTITEXCOORD1SVARBPROC;
1720
glMultiTexCoord2dARB: PFNGLMULTITEXCOORD2DARBPROC;
1721
glMultiTexCoord2dvARB: PFNGLMULTITEXCOORD2DVARBPROC;
1722
glMultiTexCoord2fARB: PFNGLMULTITEXCOORD2FARBPROC;
1723
glMultiTexCoord2fvARB: PFNGLMULTITEXCOORD2FVARBPROC;
1724
glMultiTexCoord2iARB: PFNGLMULTITEXCOORD2IARBPROC;
1725
glMultiTexCoord2ivARB: PFNGLMULTITEXCOORD2IVARBPROC;
1726
glMultiTexCoord2sARB: PFNGLMULTITEXCOORD2SARBPROC;
1727
glMultiTexCoord2svARB: PFNGLMULTITEXCOORD2SVARBPROC;
1728
glMultiTexCoord3dARB: PFNGLMULTITEXCOORD3DARBPROC;
1729
glMultiTexCoord3dvARB: PFNGLMULTITEXCOORD3DVARBPROC;
1730
glMultiTexCoord3fARB: PFNGLMULTITEXCOORD3FARBPROC;
1731
glMultiTexCoord3fvARB: PFNGLMULTITEXCOORD3FVARBPROC;
1732
glMultiTexCoord3iARB: PFNGLMULTITEXCOORD3IARBPROC;
1733
glMultiTexCoord3ivARB: PFNGLMULTITEXCOORD3IVARBPROC;
1734
glMultiTexCoord3sARB: PFNGLMULTITEXCOORD3SARBPROC;
1735
glMultiTexCoord3svARB: PFNGLMULTITEXCOORD3SVARBPROC;
1736
glMultiTexCoord4dARB: PFNGLMULTITEXCOORD4DARBPROC;
1737
glMultiTexCoord4dvARB: PFNGLMULTITEXCOORD4DVARBPROC;
1738
glMultiTexCoord4fARB: PFNGLMULTITEXCOORD4FARBPROC;
1739
glMultiTexCoord4fvARB: PFNGLMULTITEXCOORD4FVARBPROC;
1740
glMultiTexCoord4iARB: PFNGLMULTITEXCOORD4IARBPROC;
1741
glMultiTexCoord4ivARB: PFNGLMULTITEXCOORD4IVARBPROC;
1742
glMultiTexCoord4sARB: PFNGLMULTITEXCOORD4SARBPROC;
1743
glMultiTexCoord4svARB: PFNGLMULTITEXCOORD4SVARBPROC;
1745
// GL_ARB_transpose_matrix (ARB #3)
1746
glLoadTransposeMatrixfARB: PFNGLLOADTRANSPOSEMATRIXFARBPROC;
1747
glLoadTransposeMatrixdARB: PFNGLLOADTRANSPOSEMATRIXDARBPROC;
1748
glMultTransposeMatrixfARB: PFNGLMULTTRANSPOSEMATRIXFARBPROC;
1749
glMultTransposeMatrixdARB: PFNGLMULTTRANSPOSEMATRIXDARBPROC;
1751
// GL_ARB_multisample (ARB #5)
1752
glSampleCoverageARB: PFNGLSAMPLECOVERAGEARBPROC;
1754
// GL_ARB_texture_compression (ARB #12)
1755
glCompressedTexImage3DARB: PFNGLCOMPRESSEDTEXIMAGE3DARBPROC;
1756
glCompressedTexImage2DARB: PFNGLCOMPRESSEDTEXIMAGE2DARBPROC;
1757
glCompressedTexImage1DARB: PFNGLCOMPRESSEDTEXIMAGE1DARBPROC;
1758
glCompressedTexSubImage3DARB: PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC;
1759
glCompressedTexSubImage2DARB: PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC;
1760
glCompressedTexSubImage1DARB: PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC;
1761
glGetCompressedTexImageARB: PFNGLGETCOMPRESSEDTEXIMAGEARBPROC;
1763
// GL_ARB_point_parameter (ARB #14)
1764
glPointParameterfARB: PFNGLPOINTPARAMETERFARBPROC;
1765
glPointParameterfvARB: PFNGLPOINTPARAMETERFVARBPROC;
1767
// GL_ARB_vertex_blend (ARB #15) {deprecated?}1768
glWeightbvARB: PFNGLWEIGHTBVARBPROC;
1769
glWeightsvARB: PFNGLWEIGHTSVARBPROC;
1770
glWeightivARB: PFNGLWEIGHTIVARBPROC;
1771
glWeightfvARB: PFNGLWEIGHTFVARBPROC;
1772
glWeightdvARB: PFNGLWEIGHTDVARBPROC;
1773
glWeightubvARB: PFNGLWEIGHTUBVARBPROC;
1774
glWeightusvARB: PFNGLWEIGHTUSVARBPROC;
1775
glWeightuivARB: PFNGLWEIGHTUIVARBPROC;
1776
glWeightPointerARB: PFNGLWEIGHTPOINTERARBPROC;
1777
glVertexBlendARB: PFNGLVERTEXBLENDARBPROC;
1779
// GL_ARB_matrix_palette (ARB #16) {deprecated?}1780
glCurrentPaletteMatrixARB: PFNGLCURRENTPALETTEMATRIXARBPROC;
1781
glMatrixIndexubvARB: PFNGLMATRIXINDEXUBVARBPROC;
1782
glMatrixIndexusvARB: PFNGLMATRIXINDEXUSVARBPROC;
1783
glMatrixIndexuivARB: PFNGLMATRIXINDEXUIVARBPROC;
1784
glMatrixIndexPointerARB: PFNGLMATRIXINDEXPOINTERARBPROC;
1786
// GL_ARB_window_pos (ARB #25)
1787
glWindowPos2dARB: PFNGLWINDOWPOS2DARBPROC;
1788
glWindowPos2dvARB: PFNGLWINDOWPOS2DVARBPROC;
1789
glWindowPos2fARB: PFNGLWINDOWPOS2FARBPROC;
1790
glWindowPos2fvARB: PFNGLWINDOWPOS2FVARBPROC;
1791
glWindowPos2iARB: PFNGLWINDOWPOS2IARBPROC;
1792
glWindowPos2ivARB: PFNGLWINDOWPOS2IVARBPROC;
1793
glWindowPos2sARB: PFNGLWINDOWPOS2SARBPROC;
1794
glWindowPos2svARB: PFNGLWINDOWPOS2SVARBPROC;
1795
glWindowPos3dARB: PFNGLWINDOWPOS3DARBPROC;
1796
glWindowPos3dvARB: PFNGLWINDOWPOS3DVARBPROC;
1797
glWindowPos3fARB: PFNGLWINDOWPOS3FARBPROC;
1798
glWindowPos3fvARB: PFNGLWINDOWPOS3FVARBPROC;
1799
glWindowPos3iARB: PFNGLWINDOWPOS3IARBPROC;
1800
glWindowPos3ivARB: PFNGLWINDOWPOS3IVARBPROC;
1801
glWindowPos3sARB: PFNGLWINDOWPOS3SARBPROC;
1802
glWindowPos3svARB: PFNGLWINDOWPOS3SVARBPROC;
1804
// GL_ARB_vertex_program (ARB #26)
1805
glVertexAttrib1dARB: PFNGLVERTEXATTRIB1DARBPROC;
1806
glVertexAttrib1dvARB: PFNGLVERTEXATTRIB1DVARBPROC;
1807
glVertexAttrib1fARB: PFNGLVERTEXATTRIB1FARBPROC;
1808
glVertexAttrib1fvARB: PFNGLVERTEXATTRIB1FVARBPROC;
1809
glVertexAttrib1sARB: PFNGLVERTEXATTRIB1SARBPROC;
1810
glVertexAttrib1svARB: PFNGLVERTEXATTRIB1SVARBPROC;
1811
glVertexAttrib2dARB: PFNGLVERTEXATTRIB2DARBPROC;
1812
glVertexAttrib2dvARB: PFNGLVERTEXATTRIB2DVARBPROC;
1813
glVertexAttrib2fARB: PFNGLVERTEXATTRIB2FARBPROC;
1814
glVertexAttrib2fvARB: PFNGLVERTEXATTRIB2FVARBPROC;
1815
glVertexAttrib2sARB: PFNGLVERTEXATTRIB2SARBPROC;
1816
glVertexAttrib2svARB: PFNGLVERTEXATTRIB2SVARBPROC;
1817
glVertexAttrib3dARB: PFNGLVERTEXATTRIB3DARBPROC;
1818
glVertexAttrib3dvARB: PFNGLVERTEXATTRIB3DVARBPROC;
1819
glVertexAttrib3fARB: PFNGLVERTEXATTRIB3FARBPROC;
1820
glVertexAttrib3fvARB: PFNGLVERTEXATTRIB3FVARBPROC;
1821
glVertexAttrib3sARB: PFNGLVERTEXATTRIB3SARBPROC;
1822
glVertexAttrib3svARB: PFNGLVERTEXATTRIB3SVARBPROC;
1823
glVertexAttrib4NbvARB: PFNGLVERTEXATTRIB4NBVARBPROC;
1824
glVertexAttrib4NivARB: PFNGLVERTEXATTRIB4NIVARBPROC;
1825
glVertexAttrib4NsvARB: PFNGLVERTEXATTRIB4NSVARBPROC;
1826
glVertexAttrib4NubARB: PFNGLVERTEXATTRIB4NUBARBPROC;
1827
glVertexAttrib4NubvARB: PFNGLVERTEXATTRIB4NUBVARBPROC;
1828
glVertexAttrib4NuivARB: PFNGLVERTEXATTRIB4NUIVARBPROC;
1829
glVertexAttrib4NusvARB: PFNGLVERTEXATTRIB4NUSVARBPROC;
1830
glVertexAttrib4bvARB: PFNGLVERTEXATTRIB4BVARBPROC;
1831
glVertexAttrib4dARB: PFNGLVERTEXATTRIB4DARBPROC;
1832
glVertexAttrib4dvARB: PFNGLVERTEXATTRIB4DVARBPROC;
1833
glVertexAttrib4fARB: PFNGLVERTEXATTRIB4FARBPROC;
1834
glVertexAttrib4fvARB: PFNGLVERTEXATTRIB4FVARBPROC;
1835
glVertexAttrib4ivARB: PFNGLVERTEXATTRIB4IVARBPROC;
1836
glVertexAttrib4sARB: PFNGLVERTEXATTRIB4SARBPROC;
1837
glVertexAttrib4svARB: PFNGLVERTEXATTRIB4SVARBPROC;
1838
glVertexAttrib4ubvARB: PFNGLVERTEXATTRIB4UBVARBPROC;
1839
glVertexAttrib4uivARB: PFNGLVERTEXATTRIB4UIVARBPROC;
1840
glVertexAttrib4usvARB: PFNGLVERTEXATTRIB4USVARBPROC;
1841
glVertexAttribPointerARB: PFNGLVERTEXATTRIBPOINTERARBPROC;
1842
glEnableVertexAttribArrayARB: PFNGLENABLEVERTEXATTRIBARRAYARBPROC;
1843
glDisableVertexAttribArrayARB: PFNGLDISABLEVERTEXATTRIBARRAYARBPROC;
1844
glProgramStringARB: PFNGLPROGRAMSTRINGARBPROC;
1845
glBindProgramARB: PFNGLBINDPROGRAMARBPROC;
1846
glDeleteProgramsARB: PFNGLDELETEPROGRAMSARBPROC;
1847
glGenProgramsARB: PFNGLGENPROGRAMSARBPROC;
1848
glProgramEnvParameter4dARB: PFNGLPROGRAMENVPARAMETER4DARBPROC;
1849
glProgramEnvParameter4dvARB: PFNGLPROGRAMENVPARAMETER4DVARBPROC;
1850
glProgramEnvParameter4fARB: PFNGLPROGRAMENVPARAMETER4FARBPROC;
1851
glProgramEnvParameter4fvARB: PFNGLPROGRAMENVPARAMETER4FVARBPROC;
1852
glProgramLocalParameter4dARB: PFNGLPROGRAMLOCALPARAMETER4DARBPROC;
1853
glProgramLocalParameter4dvARB: PFNGLPROGRAMLOCALPARAMETER4DVARBPROC;
1854
glProgramLocalParameter4fARB: PFNGLPROGRAMLOCALPARAMETER4FARBPROC;
1855
glProgramLocalParameter4fvARB: PFNGLPROGRAMLOCALPARAMETER4FVARBPROC;
1856
glGetProgramEnvParameterdvARB: PFNGLGETPROGRAMENVPARAMETERDVARBPROC;
1857
glGetProgramEnvParameterfvARB: PFNGLGETPROGRAMENVPARAMETERFVARBPROC;
1858
glGetProgramLocalParameterdvARB: PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC;
1859
glGetProgramLocalParameterfvARB: PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC;
1860
glGetProgramivARB: PFNGLGETPROGRAMIVARBPROC;
1861
glGetProgramStringARB: PFNGLGETPROGRAMSTRINGARBPROC;
1862
glGetVertexAttribdvARB: PFNGLGETVERTEXATTRIBDVARBPROC;
1863
glGetVertexAttribfvARB: PFNGLGETVERTEXATTRIBFVARBPROC;
1864
glGetVertexAttribivARB: PFNGLGETVERTEXATTRIBIVARBPROC;
1865
glGetVertexAttribPointervARB: PFNGLGETVERTEXATTRIBPOINTERVARBPROC;
1866
glIsProgramARB: PFNGLISPROGRAMARBPROC;
1868
// GL_ARB_vertex_buffer_object (ARB #28)
1869
glBindBufferARB: PFNGLBINDBUFFERARBPROC;
1870
glDeleteBuffersARB: PFNGLDELETEBUFFERSARBPROC;
1871
glGenBuffersARB: PFNGLGENBUFFERSARBPROC;
1872
glIsBufferARB: PFNGLISBUFFERARBPROC;
1873
glBufferDataARB: PFNGLBUFFERDATAARBPROC;
1874
glBufferSubDataARB: PFNGLBUFFERSUBDATAARBPROC;
1875
glGetBufferSubDataARB: PFNGLGETBUFFERSUBDATAARBPROC;
1876
glMapBufferARB: PFNGLMAPBUFFERARBPROC;
1877
glUnmapBufferARB: PFNGLUNMAPBUFFERARBPROC;
1878
glGetBufferParameterivARB: PFNGLGETBUFFERPARAMETERIVARBPROC;
1879
glGetBufferPointervARB: PFNGLGETBUFFERPOINTERVARBPROC;
1881
// GL_ARB_occlusion_query (ARB #29)
1882
glGenQueriesARB: PFNGLGENQUERIESARBPROC;
1883
glDeleteQueriesARB: PFNGLDELETEQUERIESARBPROC;
1884
glIsQueryARB: PFNGLISQUERYARBPROC;
1885
glBeginQueryARB: PFNGLBEGINQUERYARBPROC;
1886
glEndQueryARB: PFNGLENDQUERYARBPROC;
1887
glGetQueryivARB: PFNGLGETQUERYIVARBPROC;
1888
glGetQueryObjectivARB: PFNGLGETQUERYOBJECTIVARBPROC;
1889
glGetQueryObjectuivARB: PFNGLGETQUERYOBJECTUIVARBPROC;
1891
// GL_ARB_shader_objects (ARB #30)
1892
glDeleteObjectARB: PFNGLDELETEOBJECTARBPROC;
1893
glGetHandleARB: PFNGLGETHANDLEARBPROC;
1894
glDetachObjectARB: PFNGLDETACHOBJECTARBPROC;
1895
glCreateShaderObjectARB: PFNGLCREATESHADEROBJECTARBPROC;
1896
glShaderSourceARB: PFNGLSHADERSOURCEARBPROC;
1897
glCompileShaderARB: PFNGLCOMPILESHADERARBPROC;
1898
glCreateProgramObjectARB: PFNGLCREATEPROGRAMOBJECTARBPROC;
1899
glAttachObjectARB: PFNGLATTACHOBJECTARBPROC;
1900
glLinkProgramARB: PFNGLLINKPROGRAMARBPROC;
1901
glUseProgramObjectARB: PFNGLUSEPROGRAMOBJECTARBPROC;
1902
glValidateProgramARB: PFNGLVALIDATEPROGRAMARBPROC;
1903
glUniform1fARB: PFNGLUNIFORM1FARBPROC;
1904
glUniform2fARB: PFNGLUNIFORM2FARBPROC;
1905
glUniform3fARB: PFNGLUNIFORM3FARBPROC;
1906
glUniform4fARB: PFNGLUNIFORM4FARBPROC;
1907
glUniform1iARB: PFNGLUNIFORM1IARBPROC;
1908
glUniform2iARB: PFNGLUNIFORM2IARBPROC;
1909
glUniform3iARB: PFNGLUNIFORM3IARBPROC;
1910
glUniform4iARB: PFNGLUNIFORM4IARBPROC;
1911
glUniform1fvARB: PFNGLUNIFORM1FVARBPROC;
1912
glUniform2fvARB: PFNGLUNIFORM2FVARBPROC;
1913
glUniform3fvARB: PFNGLUNIFORM3FVARBPROC;
1914
glUniform4fvARB: PFNGLUNIFORM4FVARBPROC;
1915
glUniform1ivARB: PFNGLUNIFORM1IVARBPROC;
1916
glUniform2ivARB: PFNGLUNIFORM2IVARBPROC;
1917
glUniform3ivARB: PFNGLUNIFORM3IVARBPROC;
1918
glUniform4ivARB: PFNGLUNIFORM4IVARBPROC;
1919
glUniformMatrix2fvARB: PFNGLUNIFORMMATRIX2FVARBPROC;
1920
glUniformMatrix3fvARB: PFNGLUNIFORMMATRIX3FVARBPROC;
1921
glUniformMatrix4fvARB: PFNGLUNIFORMMATRIX4FVARBPROC;
1922
glGetObjectParameterfvARB: PFNGLGETOBJECTPARAMETERFVARBPROC;
1923
glGetObjectParameterivARB: PFNGLGETOBJECTPARAMETERIVARBPROC;
1924
glGetInfoLogARB: PFNGLGETINFOLOGARBPROC;
1925
glGetAttachedObjectsARB: PFNGLGETATTACHEDOBJECTSARBPROC;
1926
glGetUniformLocationARB: PFNGLGETUNIFORMLOCATIONARBPROC;
1927
glGetActiveUniformARB: PFNGLGETACTIVEUNIFORMARBPROC;
1928
glGetUniformfvARB: PFNGLGETUNIFORMFVARBPROC;
1929
glGetUniformivARB: PFNGLGETUNIFORMIVARBPROC;
1930
glGetShaderSourceARB: PFNGLGETSHADERSOURCEARBPROC;
1932
// GL_ARB_vertex_shader (ARB #31)
1933
glBindAttribLocationARB: PFNGLBINDATTRIBLOCATIONARBPROC;
1934
glGetActiveAttribARB: PFNGLGETACTIVEATTRIBARBPROC;
1935
glGetAttribLocationARB: PFNGLGETATTRIBLOCATIONARBPROC;
1937
// GL_ARB_DrawBuffers (ARB #37)
1938
glDrawBuffersARB: PFNGLDRAWBUFFERSARBPROC;
1940
// GL_ARB_color_buffer_float (ARB #39)
1941
glClampColorARB: PFNGLCLAMPCOLORARBPROC;
1943
// GL_ARB_draw_instanced (ARB #44)
1944
glDrawArraysInstancedARB: PFNGLDRAWARRAYSINSTANCEDARBPROC;
1945
glDrawElementsInstancedARB: PFNGLDRAWELEMENTSINSTANCEDARBPROC;
1947
// GL_ARB_framebuffer_object (ARB #45)
1948
glIsRenderbuffer: PFNGLISRENDERBUFFERPROC;
1949
glBindRenderbuffer: PFNGLBINDRENDERBUFFERPROC;
1950
glDeleteRenderbuffers: PFNGLDELETERENDERBUFFERSPROC;
1951
glGenRenderbuffers: PFNGLGENRENDERBUFFERSPROC;
1952
glRenderbufferStorage: PFNGLRENDERBUFFERSTORAGEPROC;
1953
glRenderbufferStorageMultisample: PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC;
1954
glGetRenderbufferParameteriv: PFNGLGETRENDERBUFFERPARAMETERIVPROC;
1955
glIsFramebuffer: PFNGLISFRAMEBUFFERPROC;
1956
glBindFramebuffer: PFNGLBINDFRAMEBUFFERPROC;
1957
glDeleteFramebuffers: PFNGLDELETEFRAMEBUFFERSPROC;
1958
glGenFramebuffers: PFNGLGENFRAMEBUFFERSPROC;
1959
glCheckFramebufferStatus: PFNGLCHECKFRAMEBUFFERSTATUSPROC;
1960
glFramebufferTexture1D: PFNGLFRAMEBUFFERTEXTURE1DPROC;
1961
glFramebufferTexture2D: PFNGLFRAMEBUFFERTEXTURE2DPROC;
1962
glFramebufferTexture3D: PFNGLFRAMEBUFFERTEXTURE3DPROC;
1963
glFramebufferTextureLayer: PFNGLFRAMEBUFFERTEXTURELAYERPROC;
1964
glFramebufferRenderbuffer: PFNGLFRAMEBUFFERRENDERBUFFERPROC;
1965
glGetFramebufferAttachmentParameteriv: PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC;
1966
glBlitFramebuffer: PFNGLBLITFRAMEBUFFERPROC;
1967
glGenerateMipmap: PFNGLGENERATEMIPMAPPROC;
1969
// GL_ARB_geometry_shader4 (ARB #47)
1970
glProgramParameteriARB: PFNGLPROGRAMPARAMETERIARBPROC;
1971
glFramebufferTextureARB: PFNGLFRAMEBUFFERTEXTUREARBPROC;
1972
glFramebufferTextureLayerARB: PFNGLFRAMEBUFFERTEXTURELAYERARBPROC;
1973
glFramebufferTextureFaceARB: PFNGLFRAMEBUFFERTEXTUREFACEARBPROC;
1975
// GL_ARB_instanced_arrays (ARB #49)
1976
glVertexAttribDivisorARB: PFNGLVERTEXATTRIBDIVISORARBPROC;
1978
// GL_ARB_map_buffer_range (ARB #50)
1979
glMapBufferRange: PFNGLMAPBUFFERRANGEPROC;
1980
glFlushMappedBufferRange: PFNGLFLUSHMAPPEDBUFFERRANGEPROC;
1982
// GL_ARB_texture_buffer_object (ARB #51)
1983
glTexBufferARB: PFNGLTEXBUFFERARBPROC;
1985
// GL_ARB_vertex_array_object (ARB #54)
1986
glBindVertexArray: PFNGLBINDVERTEXARRAYPROC;
1987
glDeleteVertexArrays: PFNGLDELETEVERTEXARRAYSPROC;
1988
glGenVertexArrays: PFNGLGENVERTEXARRAYSPROC;
1989
glIsVertexArray: PFNGLISVERTEXARRAYPROC;
1991
// GL_ARB_uniform_buffer_object (ARB #57)
1992
glGetUniformIndices: PFNGLGETUNIFORMINDICESPROC;
1993
glGetActiveUniformsiv: PFNGLGETACTIVEUNIFORMSIVPROC;
1994
glGetActiveUniformName: PFNGLGETACTIVEUNIFORMNAMEPROC;
1995
glGetUniformBlockIndex: PFNGLGETUNIFORMBLOCKINDEXPROC;
1996
glGetActiveUniformBlockiv: PFNGLGETACTIVEUNIFORMBLOCKIVPROC;
1997
glGetActiveUniformBlockName: PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC;
1998
glUniformBlockBinding: PFNGLUNIFORMBLOCKBINDINGPROC;
2000
// GL_ARB_copy_buffer (ARB #59)
2001
glCopyBufferSubData: PFNGLCOPYBUFFERSUBDATAPROC;
2003
// GL_ARB_draw_elements_base_vertex (ARB #62)
2004
glDrawElementsBaseVertex: PFNGLDRAWELEMENTSBASEVERTEXPROC;
2005
glDrawRangeElementsBaseVertex: PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC;
2006
glDrawElementsInstancedBaseVertex: PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC;
2007
glMultiDrawElementsBaseVertex: PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC;
2009
// GL_ARB_provoking_vertex (ARB #64)
2010
glProvokingVertex: PFNGLPROVOKINGVERTEXPROC;
2012
// GL_ARB_sync (ARB #66)
2013
glFenceSync: PFNGLFENCESYNCPROC;
2014
glIsSync: PFNGLISSYNCPROC;
2015
glDeleteSync: PFNGLDELETESYNCPROC;
2016
glClientWaitSync: PFNGLCLIENTWAITSYNCPROC;
2017
glWaitSync: PFNGLWAITSYNCPROC;
2018
glGetInteger64v: PFNGLGETINTEGER64VPROC;
2019
glGetSynciv: PFNGLGETSYNCIVPROC;
2021
// GL_ARB_texture_multisample (ARB #67)
2022
glTexImage2DMultisample: PFNGLTEXIMAGE2DMULTISAMPLEPROC;
2023
glTexImage3DMultisample: PFNGLTEXIMAGE3DMULTISAMPLEPROC;
2024
glGetMultisamplefv: PFNGLGETMULTISAMPLEFVPROC;
2025
glSampleMaski: PFNGLSAMPLEMASKIPROC;
2027
// GL_ARB_draw_buffers_blend (ARB #69)
2028
glBlendEquationiARB: PFNGLBLENDEQUATIONIARBPROC;
2029
glBlendEquationSeparateiARB: PFNGLBLENDEQUATIONSEPARATEIARBPROC;
2030
glBlendFunciARB: PFNGLBLENDFUNCIARBPROC;
2031
glBlendFuncSeparateiARB: PFNGLBLENDFUNCSEPARATEIARBPROC;
2033
// GL_ARB_sample_shading (ARB #70)
2034
glMinSampleShadingARB: PFNGLMINSAMPLESHADINGARBPROC;
2036
// GL_ARB_blend_func_extended (ARB #78)
2037
glBindFragDataLocationIndexed: PFNGLBINDFRAGDATALOCATIONINDEXEDPROC;
2038
glGetFragDataIndex: PFNGLGETFRAGDATAINDEXPROC;
2040
// GL_ARB_sampler_objects (ARB #81)
2041
glGenSamplers: PFNGLGENSAMPLERSPROC;
2042
glDeleteSamplers: PFNGLDELETESAMPLERSPROC;
2043
glIsSampler: PFNGLISSAMPLERPROC;
2044
glBindSampler: PFNGLBINDSAMPLERPROC;
2045
glSamplerParameteri: PFNGLSAMPLERPARAMETERIPROC;
2046
glSamplerParameteriv: PFNGLSAMPLERPARAMETERIVPROC;
2047
glSamplerParameterf: PFNGLSAMPLERPARAMETERFPROC;
2048
glSamplerParameterfv: PFNGLSAMPLERPARAMETERFVPROC;
2049
glSamplerParameterIiv: PFNGLSAMPLERPARAMETERIIVPROC;
2050
glSamplerParameterIuiv: PFNGLSAMPLERPARAMETERIUIVPROC;
2051
glGetSamplerParameteriv: PFNGLGETSAMPLERPARAMETERIVPROC;
2052
glGetSamplerParameterIiv: PFNGLGETSAMPLERPARAMETERIIVPROC;
2053
glGetSamplerParameterfv: PFNGLGETSAMPLERPARAMETERFVPROC;
2054
glGetSamplerParameterIfv: PFNGLGETSAMPLERPARAMETERIFVPROC;
2056
// GL_ARB_timer_query (ARB #85)
2057
glQueryCounter: PFNGLQUERYCOUNTERPROC;
2058
glGetQueryObjecti64v: PFNGLGETQUERYOBJECTI64VPROC;
2059
glGetQueryObjectui64v: PFNGLGETQUERYOBJECTUI64VPROC;
2061
// GL_ARB_vertex_type_2_10_10_10_rev (ARB #86)
2062
glVertexP2ui: PFNGLVERTEXP2UIPROC;
2063
glVertexP2uiv: PFNGLVERTEXP2UIVPROC;
2064
glVertexP3ui: PFNGLVERTEXP3UIPROC;
2065
glVertexP3uiv: PFNGLVERTEXP3UIVPROC;
2066
glVertexP4ui: PFNGLVERTEXP4UIPROC;
2067
glVertexP4uiv: PFNGLVERTEXP4UIVPROC;
2068
glTexCoordP1ui: PFNGLTEXCOORDP1UIPROC;
2069
glTexCoordP1uiv: PFNGLTEXCOORDP1UIVPROC;
2070
glTexCoordP2ui: PFNGLTEXCOORDP2UIPROC;
2071
glTexCoordP2uiv: PFNGLTEXCOORDP2UIVPROC;
2072
glTexCoordP3ui: PFNGLTEXCOORDP3UIPROC;
2073
glTexCoordP3uiv: PFNGLTEXCOORDP3UIVPROC;
2074
glTexCoordP4ui: PFNGLTEXCOORDP4UIPROC;
2075
glTexCoordP4uiv: PFNGLTEXCOORDP4UIVPROC;
2076
glMultiTexCoordP1ui: PFNGLMULTITEXCOORDP1UIPROC;
2077
glMultiTexCoordP1uiv: PFNGLMULTITEXCOORDP1UIVPROC;
2078
glMultiTexCoordP2ui: PFNGLMULTITEXCOORDP2UIPROC;
2079
glMultiTexCoordP2uiv: PFNGLMULTITEXCOORDP2UIVPROC;
2080
glMultiTexCoordP3ui: PFNGLMULTITEXCOORDP3UIPROC;
2081
glMultiTexCoordP3uiv: PFNGLMULTITEXCOORDP3UIVPROC;
2082
glMultiTexCoordP4ui: PFNGLMULTITEXCOORDP4UIPROC;
2083
glMultiTexCoordP4uiv: PFNGLMULTITEXCOORDP4UIVPROC;
2084
glNormalP3ui: PFNGLNORMALP3UIPROC;
2085
glNormalP3uiv: PFNGLNORMALP3UIVPROC;
2086
glColorP3ui: PFNGLCOLORP3UIPROC;
2087
glColorP3uiv: PFNGLCOLORP3UIVPROC;
2088
glColorP4ui: PFNGLCOLORP4UIPROC;
2089
glColorP4uiv: PFNGLCOLORP4UIVPROC;
2090
glSecondaryColorP3ui: PFNGLSECONDARYCOLORP3UIPROC;
2091
glSecondaryColorP3uiv: PFNGLSECONDARYCOLORP3UIVPROC;
2092
glVertexAttribP1ui: PFNGLVERTEXATTRIBP1UIPROC;
2093
glVertexAttribP1uiv: PFNGLVERTEXATTRIBP1UIVPROC;
2094
glVertexAttribP2ui: PFNGLVERTEXATTRIBP2UIPROC;
2095
glVertexAttribP2uiv: PFNGLVERTEXATTRIBP2UIVPROC;
2096
glVertexAttribP3ui: PFNGLVERTEXATTRIBP3UIPROC;
2097
glVertexAttribP3uiv: PFNGLVERTEXATTRIBP3UIVPROC;
2098
glVertexAttribP4ui: PFNGLVERTEXATTRIBP4UIPROC;
2099
glVertexAttribP4uiv: PFNGLVERTEXATTRIBP4UIVPROC;
2101
// GL_ARB_draw_indirect (ARB #87)
2102
glDrawArraysIndirect: PFNGLDRAWARRAYSINDIRECTPROC;
2103
glDrawElementsIndirect: PFNGLDRAWELEMENTSINDIRECTPROC;
2105
// GL_ARB_gpu_shader_fp64 (ARB #89)
2106
glUniform1d: PFNGLUNIFORM1DPROC;
2107
glUniform2d: PFNGLUNIFORM2DPROC;
2108
glUniform3d: PFNGLUNIFORM3DPROC;
2109
glUniform4d: PFNGLUNIFORM4DPROC;
2110
glUniform1dv: PFNGLUNIFORM1DVPROC;
2111
glUniform2dv: PFNGLUNIFORM2DVPROC;
2112
glUniform3dv: PFNGLUNIFORM3DVPROC;
2113
glUniform4dv: PFNGLUNIFORM4DVPROC;
2114
glUniformMatrix2dv: PFNGLUNIFORMMATRIX2DVPROC;
2115
glUniformMatrix3dv: PFNGLUNIFORMMATRIX3DVPROC;
2116
glUniformMatrix4dv: PFNGLUNIFORMMATRIX4DVPROC;
2117
glUniformMatrix2x3dv: PFNGLUNIFORMMATRIX2X3DVPROC;
2118
glUniformMatrix2x4dv: PFNGLUNIFORMMATRIX2X4DVPROC;
2119
glUniformMatrix3x2dv: PFNGLUNIFORMMATRIX3X2DVPROC;
2120
glUniformMatrix3x4dv: PFNGLUNIFORMMATRIX3X4DVPROC;
2121
glUniformMatrix4x2dv: PFNGLUNIFORMMATRIX4X2DVPROC;
2122
glUniformMatrix4x3dv: PFNGLUNIFORMMATRIX4X3DVPROC;
2123
glGetUniformdv: PFNGLGETUNIFORMDVPROC;
2124
// glProgramUniformXXX only valid if EXT_direct_state_access is available
2125
glProgramUniform1dEXT: PFNGLPROGRAMUNIFORM1DEXTPROC;
2126
glProgramUniform2dEXT: PFNGLPROGRAMUNIFORM2DEXTPROC;
2127
glProgramUniform3dEXT: PFNGLPROGRAMUNIFORM3DEXTPROC;
2128
glProgramUniform4dEXT: PFNGLPROGRAMUNIFORM4DEXTPROC;
2129
glProgramUniform1dvEXT: PFNGLPROGRAMUNIFORM1DVEXTPROC;
2130
glProgramUniform2dvEXT: PFNGLPROGRAMUNIFORM2DVEXTPROC;
2131
glProgramUniform3dvEXT: PFNGLPROGRAMUNIFORM3DVEXTPROC;
2132
glProgramUniform4dvEXT: PFNGLPROGRAMUNIFORM4DVEXTPROC;
2133
glProgramUniformMatrix2dvEXT: PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC;
2134
glProgramUniformMatrix3dvEXT: PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC;
2135
glProgramUniformMatrix4dvEXT: PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC;
2136
glProgramUniformMatrix2x3dvEXT: PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC;
2137
glProgramUniformMatrix2x4dvEXT: PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC;
2138
glProgramUniformMatrix3x2dvEXT: PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC;
2139
glProgramUniformMatrix3x4dvEXT: PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC;
2140
glProgramUniformMatrix4x2dvEXT: PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC;
2141
glProgramUniformMatrix4x3dvEXT: PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC;
2143
// GL_ARB_shader_subroutine (ARB #90)
2144
glGetSubroutineUniformLocation: PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC;
2145
glGetSubroutineIndex: PFNGLGETSUBROUTINEINDEXPROC;
2146
glGetActiveSubroutineUniformiv: PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC;
2147
glGetActiveSubroutineUniformName: PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC;
2148
glGetActiveSubroutineName: PFNGLGETACTIVESUBROUTINENAMEPROC;
2149
glUniformSubroutinesuiv: PFNGLUNIFORMSUBROUTINESUIVPROC;
2150
glGetUniformSubroutineuiv: PFNGLGETUNIFORMSUBROUTINEUIVPROC;
2151
glGetProgramStageiv: PFNGLGETPROGRAMSTAGEIVPROC;
2153
// GL_ARB_tessellation_shader (ARB #91)
2154
glPatchParameteri: PFNGLPATCHPARAMETERIPROC;
2155
glPatchParameterfv: PFNGLPATCHPARAMETERFVPROC;
2157
// GL_ARB_transform_feedback2 (ARB #93)
2158
glBindTransformFeedback: PFNGLBINDTRANSFORMFEEDBACKPROC;
2159
glDeleteTransformFeedbacks: PFNGLDELETETRANSFORMFEEDBACKSPROC;
2160
glGenTransformFeedbacks: PFNGLGENTRANSFORMFEEDBACKSPROC;
2161
glIsTransformFeedback: PFNGLISTRANSFORMFEEDBACKPROC;
2162
glPauseTransformFeedback: PFNGLPAUSETRANSFORMFEEDBACKPROC;
2163
glResumeTransformFeedback: PFNGLRESUMETRANSFORMFEEDBACKPROC;
2164
glDrawTransformFeedback: PFNGLDRAWTRANSFORMFEEDBACKPROC;
2166
// GL_ARB_transform_feedback3 (ARB #94)
2167
glDrawTransformFeedbackStream: PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC;
2168
glBeginQueryIndexed: PFNGLBEGINQUERYINDEXEDPROC;
2169
glEndQueryIndexed: PFNGLENDQUERYINDEXEDPROC;
2170
glGetQueryIndexediv: PFNGLGETQUERYINDEXEDIVPROC;
2172
// GL_ARB_ES2_compatibility (ARB #95)
2173
glReleaseShaderCompiler: PFNGLRELEASESHADERCOMPILERPROC;
2174
glShaderBinary: PFNGLSHADERBINARYPROC;
2175
glGetShaderPrecisionFormat: PFNGLGETSHADERPRECISIONFORMATPROC;
2176
glDepthRangef: PFNGLDEPTHRANGEFPROC;
2177
glClearDepthf: PFNGLCLEARDEPTHFPROC;
2179
// GL_ARB_get_program_binary (ARB #96)
2180
glGetProgramBinary: PFNGLGetProgramBinaryPROC;
2181
glProgramBinary: PFNGLProgramBinaryPROC;
2182
glProgramParameteri: PFNGLProgramParameteriPROC; // not a core function
2184
// GL_ARB_separate_shader_objects (ARB #97)
2185
glUseProgramStages: PFNGLUSEPROGRAMSTAGESPROC;
2186
glActiveShaderProgram: PFNGLACTIVESHADERPROGRAMPROC;
2187
glCreateShaderProgramv: PFNGLCREATESHADERPROGRAMVPROC;
2188
glBindProgramPipeline: PFNGLBINDPROGRAMPIPELINEPROC;
2189
glDeleteProgramPipelines: PFNGLDELETEPROGRAMPIPELINESPROC;
2190
glGenProgramPipelines: PFNGLGENPROGRAMPIPELINESPROC;
2191
glIsProgramPipeline: PFNGLISPROGRAMPIPELINEPROC;
2192
glGetProgramPipelineiv: PFNGLGETPROGRAMPIPELINEIVPROC;
2193
glProgramUniform1i: PFNGLPROGRAMUNIFORM1IPROC;
2194
glProgramUniform1iv: PFNGLPROGRAMUNIFORM1IVPROC;
2195
glProgramUniform1f: PFNGLPROGRAMUNIFORM1FPROC;
2196
glProgramUniform1fv: PFNGLPROGRAMUNIFORM1FVPROC;
2197
glProgramUniform1d: PFNGLPROGRAMUNIFORM1DPROC;
2198
glProgramUniform1dv: PFNGLPROGRAMUNIFORM1DVPROC;
2199
glProgramUniform1ui: PFNGLPROGRAMUNIFORM1UIPROC;
2200
glProgramUniform1uiv: PFNGLPROGRAMUNIFORM1UIVPROC;
2201
glProgramUniform2i: PFNGLPROGRAMUNIFORM2IPROC;
2202
glProgramUniform2iv: PFNGLPROGRAMUNIFORM2IVPROC;
2203
glProgramUniform2f: PFNGLPROGRAMUNIFORM2FPROC;
2204
glProgramUniform2fv: PFNGLPROGRAMUNIFORM2FVPROC;
2205
glProgramUniform2d: PFNGLPROGRAMUNIFORM2DPROC;
2206
glProgramUniform2dv: PFNGLPROGRAMUNIFORM2DVPROC;
2207
glProgramUniform2ui: PFNGLPROGRAMUNIFORM2UIPROC;
2208
glProgramUniform2uiv: PFNGLPROGRAMUNIFORM2UIVPROC;
2209
glProgramUniform3i: PFNGLPROGRAMUNIFORM3IPROC;
2210
glProgramUniform3iv: PFNGLPROGRAMUNIFORM3IVPROC;
2211
glProgramUniform3f: PFNGLPROGRAMUNIFORM3FPROC;
2212
glProgramUniform3fv: PFNGLPROGRAMUNIFORM3FVPROC;
2213
glProgramUniform3d: PFNGLPROGRAMUNIFORM3DPROC;
2214
glProgramUniform3dv: PFNGLPROGRAMUNIFORM3DVPROC;
2215
glProgramUniform3ui: PFNGLPROGRAMUNIFORM3UIPROC;
2216
glProgramUniform3uiv: PFNGLPROGRAMUNIFORM3UIVPROC;
2217
glProgramUniform4i: PFNGLPROGRAMUNIFORM4IPROC;
2218
glProgramUniform4iv: PFNGLPROGRAMUNIFORM4IVPROC;
2219
glProgramUniform4f: PFNGLPROGRAMUNIFORM4FPROC;
2220
glProgramUniform4fv: PFNGLPROGRAMUNIFORM4FVPROC;
2221
glProgramUniform4d: PFNGLPROGRAMUNIFORM4DPROC;
2222
glProgramUniform4dv: PFNGLPROGRAMUNIFORM4DVPROC;
2223
glProgramUniform4ui: PFNGLPROGRAMUNIFORM4UIPROC;
2224
glProgramUniform4uiv: PFNGLPROGRAMUNIFORM4UIVPROC;
2225
glProgramUniformMatrix2fv: PFNGLPROGRAMUNIFORMMATRIX2FVPROC;
2226
glProgramUniformMatrix3fv: PFNGLPROGRAMUNIFORMMATRIX3FVPROC;
2227
glProgramUniformMatrix4fv: PFNGLPROGRAMUNIFORMMATRIX4FVPROC;
2228
glProgramUniformMatrix2dv: PFNGLPROGRAMUNIFORMMATRIX2DVPROC;
2229
glProgramUniformMatrix3dv: PFNGLPROGRAMUNIFORMMATRIX3DVPROC;
2230
glProgramUniformMatrix4dv: PFNGLPROGRAMUNIFORMMATRIX4DVPROC;
2231
glProgramUniformMatrix2x3fv: PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC;
2232
glProgramUniformMatrix3x2fv: PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC;
2233
glProgramUniformMatrix2x4fv: PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC;
2234
glProgramUniformMatrix4x2fv: PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC;
2235
glProgramUniformMatrix3x4fv: PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC;
2236
glProgramUniformMatrix4x3fv: PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC;
2237
glProgramUniformMatrix2x3dv: PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC;
2238
glProgramUniformMatrix3x2dv: PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC;
2239
glProgramUniformMatrix2x4dv: PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC;
2240
glProgramUniformMatrix4x2dv: PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC;
2241
glProgramUniformMatrix3x4dv: PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC;
2242
glProgramUniformMatrix4x3dv: PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC;
2243
glValidateProgramPipeline: PFNGLVALIDATEPROGRAMPIPELINEPROC;
2244
glGetProgramPipelineInfoLog: PFNGLGETPROGRAMPIPELINEINFOLOGPROC;
2246
// GL_ARB_shader_precision (ARB #98)
2247
// (no entry points)
2249
// GL_ARB_vertex_attrib_64bit (ARB #99)
2250
glVertexAttribL1d: PFNGLVERTEXATTRIBL1DPROC;
2251
glVertexAttribL2d: PFNGLVERTEXATTRIBL2DPROC;
2252
glVertexAttribL3d: PFNGLVERTEXATTRIBL3DPROC;
2253
glVertexAttribL4d: PFNGLVERTEXATTRIBL4DPROC;
2254
glVertexAttribL1dv: PFNGLVERTEXATTRIBL1DVPROC;
2255
glVertexAttribL2dv: PFNGLVERTEXATTRIBL2DVPROC;
2256
glVertexAttribL3dv: PFNGLVERTEXATTRIBL3DVPROC;
2257
glVertexAttribL4dv: PFNGLVERTEXATTRIBL4DVPROC;
2258
glVertexAttribLPointer: PFNGLVERTEXATTRIBLPOINTERPROC;
2259
glGetVertexAttribLdv: PFNGLGETVERTEXATTRIBLDVPROC;
2260
// glVertexArrayVertexAttribLOffsetEXT is only valid if EXT_direct_state_access is available
2261
glVertexArrayVertexAttribLOffsetEXT: PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC;
2263
// GL_ARB_viewport_array (ARB #100)
2264
glViewportArrayv: PFNGLVIEWPORTARRAYVPROC;
2265
glViewportIndexedf: PFNGLVIEWPORTINDEXEDFPROC;
2266
glViewportIndexedfv: PFNGLVIEWPORTINDEXEDFVPROC;
2267
glScissorArrayv: PFNGLSCISSORARRAYVPROC;
2268
glScissorIndexed: PFNGLSCISSORINDEXEDPROC;
2269
glScissorIndexedv: PFNGLSCISSORINDEXEDVPROC;
2270
glDepthRangeArrayv: PFNGLDEPTHRANGEARRAYVPROC;
2271
glDepthRangeIndexed: PFNGLDEPTHRANGEINDEXEDPROC;
2272
glGetFloati_v: PFNGLGETFLOATI_VPROC;
2273
glGetDoublei_v: PFNGLGETDOUBLEI_VPROC;
2275
// GL_ARB_debug_output (ARB #104)
2276
glDebugMessageControlARB: PFNGLDEBUGMESSAGECONTROLARBPROC;
2277
glDebugMessageInsertARB: PFNGLDEBUGMESSAGEINSERTARBPROC;
2278
glDebugMessageCallbackARB: PFNGLDEBUGMESSAGECALLBACKARBPROC;
2279
glGetDebugMessageLogARB: PFNGLGETDEBUGMESSAGELOGARBPROC;
2281
// GL_ARB_robustness (ARB #105)
2282
glGetGraphicsResetStatusARB: PFNGLGETGRAPHICSRESETSTATUSARBPROC;
2283
glGetnMapdvARB: PFNGLGETNMAPDVARBPROC;
2284
glGetnMapfvARB: PFNGLGETNMAPFVARBPROC;
2285
glGetnMapivARB: PFNGLGETNMAPIVARBPROC;
2286
glGetnPixelMapfvARB: PFNGLGETNPIXELMAPFVARBPROC;
2287
glGetnPixelMapuivARB: PFNGLGETNPIXELMAPUIVARBPROC;
2288
glGetnPixelMapusvARB: PFNGLGETNPIXELMAPUSVARBPROC;
2289
glGetnPolygonStippleARB: PFNGLGETNPOLYGONSTIPPLEARBPROC;
2290
glGetnColorTableARB: PFNGLGETNCOLORTABLEARBPROC;
2291
glGetnConvolutionFilterARB: PFNGLGETNCONVOLUTIONFILTERARBPROC;
2292
glGetnSeparableFilterARB: PFNGLGETNSEPARABLEFILTERARBPROC;
2293
glGetnHistogramARB: PFNGLGETNHISTOGRAMARBPROC;
2294
glGetnMinmaxARB: PFNGLGETNMINMAXARBPROC;
2295
glGetnTexImageARB: PFNGLGETNTEXIMAGEARBPROC;
2296
glReadnPixelsARB: PFNGLREADNPIXELSARBPROC;
2297
glGetnCompressedTexImageARB: PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC;
2298
glGetnUniformfvARB: PFNGLGETNUNIFORMFVARBPROC;
2299
glGetnUniformivARB: PFNGLGETNUNIFORMIVARBPROC;
2300
glGetnUniformuivARB: PFNGLGETNUNIFORMUIVARBPROC;
2301
glGetnUniformdvARB: PFNGLGETNUNIFORMDVARBPROC;
2303
// GL_ARB_shader_stencil_export (ARB #106)
2304
// (no entry points)
2306
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}2308
{$IFDEF GLS_REGIONS} {$region 'OpenGL function/procedure definitions for Vendor/EXT extensions'} {$ENDIF}2310
// ###########################################################
2311
// function and procedure definitions for
2312
// Vendor/EXT extensions
2313
// ###########################################################
2315
// Unknown Vendor/EXT functions
2316
glArrayElementArrayEXT: PFNGLARRAYELEMENTARRAYEXTPROC;
2318
// GL_WIN_swap_hint (extension # not found)
2319
glAddSwapHintRectWIN: PFNGLADDSWAPHINTRECTWINPROC;
2321
// GL_EXT_blend_color (EXT #2)
2322
glBlendColorEXT: PFNGLBLENDCOLOREXTPROC;
2324
// GL_EXT_polygon_offset (EXT #3)
2325
glPolygonOffsetEXT: PFNGLPOLYGONOFFSETEXTPROC;
2327
// GL_EXT_texture3D (EXT #6)
2328
glTexImage3DEXT: PFNGLTEXIMAGE3DEXTPROC;
2330
// GL_EXT_subtexture (EXT #9)
2331
glTexSubImage1DEXT: PFNGLTEXSUBIMAGE1DEXTPROC;
2332
glTexSubImage2DEXT: PFNGLTEXSUBIMAGE2DEXTPROC;
2333
glTexSubImage3DEXT: PFNGLTEXSUBIMAGE3DEXTPROC;
2335
// GL_EXT_copy_texture (EXT #10)
2336
glCopyTexImage1DEXT: PFNGLCOPYTEXIMAGE1DEXTPROC;
2337
glCopyTexImage2DEXT: PFNGLCOPYTEXIMAGE2DEXTPROC;
2338
glCopyTexSubImage1DEXT: PFNGLCOPYTEXSUBIMAGE1DEXTPROC;
2339
glCopyTexSubImage2DEXT: PFNGLCOPYTEXSUBIMAGE2DEXTPROC;
2340
glCopyTexSubImage3DEXT: PFNGLCOPYTEXSUBIMAGE3DEXTPROC;
2342
// GL_EXT_texture_object (EXT #20)
2343
glGenTexturesEXT: PFNGLGENTEXTURESEXTPROC;
2344
glDeleteTexturesEXT: PFNGLDELETETEXTURESEXTPROC;
2345
glBindTextureEXT: PFNGLBINDTEXTUREEXTPROC;
2346
glPrioritizeTexturesEXT: PFNGLPRIORITIZETEXTURESEXTPROC;
2347
glAreTexturesResidentEXT: PFNGLARETEXTURESRESIDENTEXTPROC;
2348
glIsTextureEXT: PFNGLISTEXTUREEXTPROC;
2350
// GL_SGIS_multisample (EXT #25)
2351
glSampleMaskSGIS: PFNGLSAMPLEMASKSGISPROC;
2352
glSamplePatternSGIS: PFNGLSAMPLEPATTERNSGISPROC;
2354
// GL_EXT_blend_minmax (EXT #37)
2355
glBlendEquationEXT: PFNGLBLENDEQUATIONEXTPROC;
2357
// GL_EXT_paletted_texture (EXT #78)
2358
glColorTableEXT: PFNGLCOLORTABLEEXTPROC;
2359
glColorSubTableExt: PFNGLCOLORSUBTABLEEXTPROC;
2360
glGetColorTableEXT: PFNGLGETCOLORTABLEEXTPROC;
2361
glGetColorTableParameterfvEXT: PFNGLGETCOLORTABLEPARAMETERFVEXTPROC;
2362
glGetColorTableParameterivEXT: PFNGLGETCOLORTABLEPARAMETERIVEXTPROC;
2364
// glGetColorTableParameterfvEXT: procedure(target, pname: TGLEnum; params: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF}2365
// glGetColorTableParameterivEXT: procedure(target, pname: TGLEnum; params: Pointer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF} {$IFDEF UNIX} cdecl; {$ENDIF}2367
// GL_EXT_index_material (EXT #94)
2368
glIndexMaterialEXT: PFNGLINDEXMATERIALEXTPROC;
2370
// GL_EXT_index_func (EXT #95)
2371
glIndexFuncEXT: PFNGLINDEXFUNCEXTPROC;
2373
// GL_EXT_compiled_vertex_array (EXT #97)
2374
glLockArraysEXT: PFNGLLOCKARRAYSEXTPROC;
2375
glUnlockArraysEXT: PFNGLUNLOCKARRAYSEXTPROC;
2377
// GL_EXT_draw_range_elements (EXT #112)
2378
glDrawRangeElementsEXT: PFNGLDRAWRANGEELEMENTSEXTPROC;
2380
// GL_EXT_scene_marker (EXT #120)
2381
glBeginSceneEXT: PFNGLBEGINSCENEEXTPROC;
2382
glEndSceneEXT: PFNGLENDSCENEEXTPROC;
2384
// GL_EXT_secondary_color (EXT #145)
2385
glSecondaryColor3bEXT: PFNGLSECONDARYCOLOR3BEXTPROC;
2386
glSecondaryColor3bvEXT: PFNGLSECONDARYCOLOR3BVEXTPROC;
2387
glSecondaryColor3dEXT: PFNGLSECONDARYCOLOR3DEXTPROC;
2388
glSecondaryColor3dvEXT: PFNGLSECONDARYCOLOR3DVEXTPROC;
2389
glSecondaryColor3fEXT: PFNGLSECONDARYCOLOR3FEXTPROC;
2390
glSecondaryColor3fvEXT: PFNGLSECONDARYCOLOR3FVEXTPROC;
2391
glSecondaryColor3iEXT: PFNGLSECONDARYCOLOR3IEXTPROC;
2392
glSecondaryColor3ivEXT: PFNGLSECONDARYCOLOR3IVEXTPROC;
2393
glSecondaryColor3sEXT: PFNGLSECONDARYCOLOR3SEXTPROC;
2394
glSecondaryColor3svEXT: PFNGLSECONDARYCOLOR3SVEXTPROC;
2395
glSecondaryColor3ubEXT: PFNGLSECONDARYCOLOR3UBEXTPROC;
2396
glSecondaryColor3ubvEXT: PFNGLSECONDARYCOLOR3UBVEXTPROC;
2397
glSecondaryColor3uiEXT: PFNGLSECONDARYCOLOR3UIEXTPROC;
2398
glSecondaryColor3uivEXT: PFNGLSECONDARYCOLOR3UIVEXTPROC;
2399
glSecondaryColor3usEXT: PFNGLSECONDARYCOLOR3USEXTPROC;
2400
glSecondaryColor3usvEXT: PFNGLSECONDARYCOLOR3USVEXTPROC;
2401
glSecondaryColorPointerEXT: PFNGLSECONDARYCOLORPOINTEREXTPROC;
2403
// GL_EXT_multi_draw_arrays (EXT #148)
2404
glMultiDrawArraysEXT: PFNGLMULTIDRAWARRAYSEXTPROC;
2405
glMultiDrawElementsEXT: PFNGLMULTIDRAWELEMENTSEXTPROC;
2407
// GL_EXT_fog_coord (EXT #149)
2408
glFogCoordfEXT: PFNGLFOGCOORDFEXTPROC;
2409
glFogCoordfvEXT: PFNGLFOGCOORDFVEXTPROC;
2410
glFogCoorddEXT: PFNGLFOGCOORDDEXTPROC;
2411
glFogCoorddvEXT: PFNGLFOGCOORDDVEXTPROC;
2412
glFogCoordPointerEXT: PFNGLFOGCOORDPOINTEREXTPROC;
2414
// GL_EXT_blend_func_separate (EXT #173)
2415
glBlendFuncSeparateEXT: PFNGLBLENDFUNCSEPARATEEXTPROC;
2417
// GL_NV_vertex_array_range (EXT #190)
2418
glFlushVertexArrayRangeNV: PFNGLFLUSHVERTEXARRAYRANGENVPROC;
2419
glVertexArrayRangeNV: PFNGLVERTEXARRAYRANGENVPROC;
2420
wglAllocateMemoryNV: PFNWGLALLOCATEMEMORYNVPROC;
2421
wglFreeMemoryNV: PFNWGLFREEMEMORYNVPROC;
2423
// GL_NV_register_combiners (EXT #191)
2424
glCombinerParameterfvNV: PFNGLCOMBINERPARAMETERFVNVPROC;
2425
glCombinerParameterfNV: PFNGLCOMBINERPARAMETERFNVPROC;
2426
glCombinerParameterivNV: PFNGLCOMBINERPARAMETERIVNVPROC;
2427
glCombinerParameteriNV: PFNGLCOMBINERPARAMETERINVPROC;
2428
glCombinerInputNV: PFNGLCOMBINERINPUTNVPROC;
2429
glCombinerOutputNV: PFNGLCOMBINEROUTPUTNVPROC;
2430
glFinalCombinerInputNV: PFNGLFINALCOMBINERINPUTNVPROC;
2431
glGetCombinerInputParameterfvNV: PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC;
2432
glGetCombinerInputParameterivNV: PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC;
2433
glGetCombinerOutputParameterfvNV: PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC;
2434
glGetCombinerOutputParameterivNV: PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC;
2435
glGetFinalCombinerInputParameterfvNV: PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC;
2436
glGetFinalCombinerInputParameterivNV: PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC;
2438
// GL_MESA_resize_buffers (EXT #196)
2439
glResizeBuffersMESA: PFNGLRESIZEBUFFERSMESAPROC;
2441
// GL_3DFX_tbuffer (EXT #208)
2442
glTbufferMask3DFX: PFNGLTBUFFERMASK3DFXPROC;
2444
// GL_EXT_multisample (EXT #209)
2445
glSampleMaskEXT: PFNGLSAMPLEMASKEXTPROC;
2446
glSamplePatternEXT: PFNGLSAMPLEPATTERNEXTPROC;
2448
// GL_SGIS_texture_color_mask (EXT #214)
2449
glTextureColorMaskSGIS: PFNGLTEXTURECOLORMASKSGISPROC;
2451
// GL_NV_fence (EXT #222)
2452
glGenFencesNV: PFNGLGENFENCESNVPROC;
2453
glDeleteFencesNV: PFNGLDELETEFENCESNVPROC;
2454
glSetFenceNV: PFNGLSETFENCENVPROC;
2455
glTestFenceNV: PFNGLTESTFENCENVPROC;
2456
glFinishFenceNV: PFNGLFINISHFENCENVPROC;
2457
glIsFenceNV: PFNGLISFENCENVPROC;
2458
glGetFenceivNV: PFNGLGETFENCEIVNVPROC;
2460
// GL_NV_vertex_program (EXT #233)
2461
glAreProgramsResidentNV: PFNGLAREPROGRAMSRESIDENTNVPROC;
2462
glBindProgramNV: PFNGLBINDPROGRAMNVPROC;
2463
glDeleteProgramsNV: PFNGLDELETEPROGRAMSNVPROC;
2464
glExecuteProgramNV: PFNGLEXECUTEPROGRAMNVPROC;
2465
glGenProgramsNV: PFNGLGENPROGRAMSNVPROC;
2466
glGetProgramParameterdvNV: PFNGLGETPROGRAMPARAMETERDVNVPROC;
2467
glGetProgramParameterfvNV: PFNGLGETPROGRAMPARAMETERFVNVPROC;
2468
glGetProgramivNV: PFNGLGETPROGRAMIVNVPROC;
2469
glGetProgramStringNV: PFNGLGETPROGRAMSTRINGNVPROC;
2470
glGetTrackMatrixivNV: PFNGLGETTRACKMATRIXIVNVPROC;
2471
glGetVertexAttribdvNV: PFNGLGETVERTEXATTRIBDVNVPROC;
2472
glGetVertexAttribfvNV: PFNGLGETVERTEXATTRIBFVNVPROC;
2473
glGetVertexAttribivNV: PFNGLGETVERTEXATTRIBIVNVPROC;
2474
glGetVertexAttribPointervNV: PFNGLGETVERTEXATTRIBPOINTERVNVPROC;
2475
glIsProgramNV: PFNGLISPROGRAMNVPROC;
2476
glLoadProgramNV: PFNGLLOADPROGRAMNVPROC;
2477
glProgramParameter4dNV: PFNGLPROGRAMPARAMETER4DNVPROC;
2478
glProgramParameter4dvNV: PFNGLPROGRAMPARAMETER4DVNVPROC;
2479
glProgramParameter4fNV: PFNGLPROGRAMPARAMETER4FNVPROC;
2480
glProgramParameter4fvNV: PFNGLPROGRAMPARAMETER4FVNVPROC;
2481
glProgramParameters4dvNV: PFNGLPROGRAMPARAMETERS4DVNVPROC;
2482
glProgramParameters4fvNV: PFNGLPROGRAMPARAMETERS4FVNVPROC;
2483
glRequestResidentProgramsNV: PFNGLREQUESTRESIDENTPROGRAMSNVPROC;
2484
glTrackMatrixNV: PFNGLTRACKMATRIXNVPROC;
2485
glVertexAttribPointerNV: PFNGLVERTEXATTRIBPOINTERNVPROC;
2486
glVertexAttrib1dNV: PFNGLVERTEXATTRIB1DNVPROC;
2487
glVertexAttrib1dvNV: PFNGLVERTEXATTRIB1DVNVPROC;
2488
glVertexAttrib1fNV: PFNGLVERTEXATTRIB1FNVPROC;
2489
glVertexAttrib1fvNV: PFNGLVERTEXATTRIB1FVNVPROC;
2490
glVertexAttrib1sNV: PFNGLVERTEXATTRIB1SNVPROC;
2491
glVertexAttrib1svNV: PFNGLVERTEXATTRIB1SVNVPROC;
2492
glVertexAttrib2dNV: PFNGLVERTEXATTRIB2DNVPROC;
2493
glVertexAttrib2dvNV: PFNGLVERTEXATTRIB2DVNVPROC;
2494
glVertexAttrib2fNV: PFNGLVERTEXATTRIB2FNVPROC;
2495
glVertexAttrib2fvNV: PFNGLVERTEXATTRIB2FVNVPROC;
2496
glVertexAttrib2sNV: PFNGLVERTEXATTRIB2SNVPROC;
2497
glVertexAttrib2svNV: PFNGLVERTEXATTRIB2SVNVPROC;
2498
glVertexAttrib3dNV: PFNGLVERTEXATTRIB3DNVPROC;
2499
glVertexAttrib3dvNV: PFNGLVERTEXATTRIB3DVNVPROC;
2500
glVertexAttrib3fNV: PFNGLVERTEXATTRIB3FNVPROC;
2501
glVertexAttrib3fvNV: PFNGLVERTEXATTRIB3FVNVPROC;
2502
glVertexAttrib3sNV: PFNGLVERTEXATTRIB3SNVPROC;
2503
glVertexAttrib3svNV: PFNGLVERTEXATTRIB3SVNVPROC;
2504
glVertexAttrib4dNV: PFNGLVERTEXATTRIB4DNVPROC;
2505
glVertexAttrib4dvNV: PFNGLVERTEXATTRIB4DVNVPROC;
2506
glVertexAttrib4fNV: PFNGLVERTEXATTRIB4FNVPROC;
2507
glVertexAttrib4fvNV: PFNGLVERTEXATTRIB4FVNVPROC;
2508
glVertexAttrib4sNV: PFNGLVERTEXATTRIB4SNVPROC;
2509
glVertexAttrib4svNV: PFNGLVERTEXATTRIB4SVNVPROC;
2510
glVertexAttrib4ubvNV: PFNGLVERTEXATTRIB4UBVNVPROC;
2511
glVertexAttribs1dvNV: PFNGLVERTEXATTRIBS1DVNVPROC;
2512
glVertexAttribs1fvNV: PFNGLVERTEXATTRIBS1FVNVPROC;
2513
glVertexAttribs1svNV: PFNGLVERTEXATTRIBS1SVNVPROC;
2514
glVertexAttribs2dvNV: PFNGLVERTEXATTRIBS2DVNVPROC;
2515
glVertexAttribs2fvNV: PFNGLVERTEXATTRIBS2FVNVPROC;
2516
glVertexAttribs2svNV: PFNGLVERTEXATTRIBS2SVNVPROC;
2517
glVertexAttribs3dvNV: PFNGLVERTEXATTRIBS3DVNVPROC;
2518
glVertexAttribs3fvNV: PFNGLVERTEXATTRIBS3FVNVPROC;
2519
glVertexAttribs3svNV: PFNGLVERTEXATTRIBS3SVNVPROC;
2520
glVertexAttribs4dvNV: PFNGLVERTEXATTRIBS4DVNVPROC;
2521
glVertexAttribs4fvNV: PFNGLVERTEXATTRIBS4FVNVPROC;
2522
glVertexAttribs4svNV: PFNGLVERTEXATTRIBS4SVNVPROC;
2523
glVertexAttribs4ubvNV: PFNGLVERTEXATTRIBS4UBVNVPROC;
2525
// GL_NV_occlusion_query (EXT #261)
2526
glGenOcclusionQueriesNV: PFNGLGENOCCLUSIONQUERIESNVPROC;
2527
glDeleteOcclusionQueriesNV: PFNGLDELETEOCCLUSIONQUERIESNVPROC;
2528
glIsOcclusionQueryNV: PFNGLISOCCLUSIONQUERYNVPROC;
2529
glBeginOcclusionQueryNV: PFNGLBEGINOCCLUSIONQUERYNVPROC;
2530
glEndOcclusionQueryNV: PFNGLENDOCCLUSIONQUERYNVPROC;
2531
glGetOcclusionQueryivNV: PFNGLGETOCCLUSIONQUERYIVNVPROC;
2532
glGetOcclusionQueryuivNV: PFNGLGETOCCLUSIONQUERYUIVNVPROC;
2534
// GL_NV_point_sprite (EXT #262)
2535
glPointParameteriNV: PFNGLPOINTPARAMETERINVPROC;
2536
glPointParameterivNV: PFNGLPOINTPARAMETERIVNVPROC;
2538
// GL_EXT_stencil_two_side (EXT #268)
2539
glActiveStencilFaceEXT: PFNGLACTIVESTENCILFACEEXTPROC;
2541
// GL_ATI_draw_buffers (EXT #277)
2542
glDrawBuffersATI: PFNGLDRAWBUFFERSATIPROC;
2544
// GL_NV_primitive_restart (EXT #285)
2545
glPrimitiveRestartNV: PFNGLPRIMITIVERESTARTNVPROC;
2546
glPrimitiveRestartIndexNV: PFNGLPRIMITIVERESTARTINDEXNVPROC;
2548
// GL_EXT_depth_bounds_test (EXT #297)
2549
glDepthBoundsEXT: PFNGLDEPTHBOUNDSEXTPROC;
2551
// GL_EXT_blend_equation_separate (EXT #299)
2552
glBlendEquationSeparateEXT: PFNGLBLENDEQUATIONSEPARATEEXTPROC;
2554
// GL_EXT_framebuffer_object (EXT #310)
2555
glIsRenderbufferEXT: PFNGLISRENDERBUFFEREXTPROC;
2556
glBindRenderbufferEXT: PFNGLBINDRENDERBUFFEREXTPROC;
2557
glDeleteRenderbuffersEXT: PFNGLDELETERENDERBUFFERSEXTPROC;
2558
glGenRenderbuffersEXT: PFNGLGENRENDERBUFFERSEXTPROC;
2559
glRenderbufferStorageEXT: PFNGLRENDERBUFFERSTORAGEEXTPROC;
2560
glGetRenderbufferParameterivEXT: PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC;
2561
glIsFramebufferEXT: PFNGLISFRAMEBUFFEREXTPROC;
2562
glBindFramebufferEXT: PFNGLBINDFRAMEBUFFEREXTPROC;
2563
glDeleteFramebuffersEXT: PFNGLDELETEFRAMEBUFFERSEXTPROC;
2564
glGenFramebuffersEXT: PFNGLGENFRAMEBUFFERSEXTPROC;
2565
glCheckFramebufferStatusEXT: PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC;
2566
glFramebufferTexture1DEXT: PFNGLFRAMEBUFFERTEXTURE1DEXTPROC;
2567
glFramebufferTexture2DEXT: PFNGLFRAMEBUFFERTEXTURE2DEXTPROC;
2568
glFramebufferTexture3DEXT: PFNGLFRAMEBUFFERTEXTURE3DEXTPROC;
2569
glFramebufferRenderbufferEXT: PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC;
2570
glGetFramebufferAttachmentParameterivEXT: PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC;
2571
glGenerateMipmapEXT: PFNGLGENERATEMIPMAPEXTPROC;
2573
// GL_GREMEDY_string_marker (EXT #311)
2574
glStringMarkerGREMEDY: PFNGLSTRINGMARKERGREMEDYPROC;
2576
// GL_EXT_stencil_clear_tag (EXT #314)
2577
glStencilClearTagEXT: PFNGLSTENCILCLEARTAGEXTPROC;
2579
// GL_EXT_framebuffer_blit (#316)
2580
glBlitFramebufferEXT: PFNGLBLITFRAMEBUFFEREXTPROC;
2582
// GL_EXT_framebuffer_multisample (#317)
2583
glRenderbufferStorageMultisampleEXT: PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC;
2585
// GL_EXT_timer_query (#319)
2586
glGetQueryObjecti64vEXT: PFNGLGETQUERYOBJECTI64VEXTPROC;
2587
glGetQueryObjectui64vEXT: PFNGLGETQUERYOBJECTUI64VEXTPROC;
2589
// GL_EXT_gpu_program_parameters (EXT #320)
2590
glProgramEnvParameters4fvEXT: PFNGLPROGRAMENVPARAMETERS4FVEXTPROC;
2591
glProgramLocalParameters4fvEXT: PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC;
2593
// GL_NV_geometry_program4 (EXT #323)
2594
glProgramVertexLimitNV: PFNGLPROGRAMVERTEXLIMITNVPROC;
2596
// GL_EXT_geometry_shader4 (EXT #324)
2597
glProgramParameteriEXT: PFNGLPROGRAMPARAMETERIEXTPROC;
2598
glFramebufferTextureEXT: PFNGLFRAMEBUFFERTEXTUREEXTPROC;
2599
glFramebufferTextureLayerEXT: PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC;
2600
glFramebufferTextureFaceEXT: PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC;
2602
// GL_EXT_gpu_shader4 (EXT #326)
2603
glVertexAttribI1iEXT: PFNGLVERTEXATTRIBI1IEXTPROC;
2604
glVertexAttribI2iEXT: PFNGLVERTEXATTRIBI2IEXTPROC;
2605
glVertexAttribI3iEXT: PFNGLVERTEXATTRIBI3IEXTPROC;
2606
glVertexAttribI4iEXT: PFNGLVERTEXATTRIBI4IEXTPROC;
2607
glVertexAttribI1uiEXT: PFNGLVERTEXATTRIBI1UIEXTPROC;
2608
glVertexAttribI2uiEXT: PFNGLVERTEXATTRIBI2UIEXTPROC;
2609
glVertexAttribI3uiEXT: PFNGLVERTEXATTRIBI3UIEXTPROC;
2610
glVertexAttribI4uiEXT: PFNGLVERTEXATTRIBI4UIEXTPROC;
2611
glVertexAttribI1ivEXT: PFNGLVERTEXATTRIBI1IVEXTPROC;
2612
glVertexAttribI2ivEXT: PFNGLVERTEXATTRIBI2IVEXTPROC;
2613
glVertexAttribI3ivEXT: PFNGLVERTEXATTRIBI3IVEXTPROC;
2614
glVertexAttribI4ivEXT: PFNGLVERTEXATTRIBI4IVEXTPROC;
2615
glVertexAttribI1uivEXT: PFNGLVERTEXATTRIBI1UIVEXTPROC;
2616
glVertexAttribI2uivEXT: PFNGLVERTEXATTRIBI2UIVEXTPROC;
2617
glVertexAttribI3uivEXT: PFNGLVERTEXATTRIBI3UIVEXTPROC;
2618
glVertexAttribI4uivEXT: PFNGLVERTEXATTRIBI4UIVEXTPROC;
2619
glVertexAttribI4bvEXT: PFNGLVERTEXATTRIBI4BVEXTPROC;
2620
glVertexAttribI4svEXT: PFNGLVERTEXATTRIBI4SVEXTPROC;
2621
glVertexAttribI4ubvEXT: PFNGLVERTEXATTRIBI4UBVEXTPROC;
2622
glVertexAttribI4usvEXT: PFNGLVERTEXATTRIBI4USVEXTPROC;
2623
glVertexAttribIPointerEXT: PFNGLVERTEXATTRIBIPOINTEREXTPROC;
2624
glGetVertexAttribIivEXT: PFNGLGETVERTEXATTRIBIIVEXTPROC;
2625
glGetVertexAttribIuivEXT: PFNGLGETVERTEXATTRIBIUIVEXTPROC;
2626
glUniform1uiEXT: PFNGLUNIFORM1UIEXTPROC;
2627
glUniform2uiEXT: PFNGLUNIFORM2UIEXTPROC;
2628
glUniform3uiEXT: PFNGLUNIFORM3UIEXTPROC;
2629
glUniform4uiEXT: PFNGLUNIFORM4UIEXTPROC;
2630
glUniform1uivEXT: PFNGLUNIFORM1UIVEXTPROC;
2631
glUniform2uivEXT: PFNGLUNIFORM2UIVEXTPROC;
2632
glUniform3uivEXT: PFNGLUNIFORM3UIVEXTPROC;
2633
glUniform4uivEXT: PFNGLUNIFORM4UIVEXTPROC;
2634
glGetUniformuivEXT: PFNGLGETUNIFORMUIVEXTPROC;
2635
glBindFragDataLocationEXT: PFNGLBINDFRAGDATALOCATIONEXTPROC;
2636
glGetFragDataLocationEXT: PFNGLGETFRAGDATALOCATIONEXTPROC;
2638
// GL_EXT_draw_instanced (#327)
2639
glDrawArraysInstancedEXT: PFNGLDRAWARRAYSINSTANCEDEXTPROC;
2640
glDrawElementsInstancedEXT: PFNGLDRAWELEMENTSINSTANCEDEXTPROC;
2642
// GL_EXT_packed_float (#328)
2643
// WGL_EXT_pixel_format_packed_float
2644
// GLX_EXT_fbconfig_packed_float
2647
// GL_EXT_texture_array (#329)
2648
//glFramebufferTextureLayerEXT: procedure(target: TGLenum; attachment: TGLenum;
2649
// texture: TGLuint; level: TGLint; layer: TGLint);
2652
// GL_EXT_texture_buffer_object (#330)
2653
glTexBufferEXT: PFNGLTEXBUFFEREXTPROC;
2655
// GL_EXT_draw_buffers2 (#340)
2656
glColorMaskIndexedEXT: PFNGLCOLORMASKINDEXEDEXTPROC;
2657
glGetBooleanIndexedvEXT: PFNGLGETBOOLEANINDEXEDVEXTPROC;
2658
glGetIntegerIndexedvEXT: PFNGLGETINTEGERINDEXEDVEXTPROC;
2659
glEnableIndexedEXT: PFNGLENABLEINDEXEDEXTPROC;
2660
glDisableIndexedEXT: PFNGLDISABLEINDEXEDEXTPROC;
2661
glIsEnabledIndexedEXT: PFNGLISENABLEDINDEXEDEXTPROC;
2663
// GL_NV_transform_feedback (#341)
2664
glBindBufferRangeNV: PFNGLBINDBUFFERRANGENVPROC;
2665
glBindBufferOffsetNV: PFNGLBINDBUFFEROFFSETNVPROC;
2666
glBindBufferBaseNV: PFNGLBINDBUFFERBASENVPROC;
2667
glTransformFeedbackAttribsNV: PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC;
2668
glTransformFeedbackVaryingsNV: PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC;
2669
glBeginTransformFeedbackNV: PFNGLBEGINTRANSFORMFEEDBACKNVPROC;
2670
glEndTransformFeedbackNV: PFNGLENDTRANSFORMFEEDBACKNVPROC;
2672
glGetVaryingLocationNV: PFNGLGETVARYINGLOCATIONNVPROC;
2673
glGetActiveVaryingNV: PFNGLGETACTIVEVARYINGNVPROC;
2674
glActiveVaryingNV: PFNGLACTIVEVARYINGNVPROC;
2675
glGetTransformFeedbackVaryingNV: PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC;
2677
// GL_EXT_bindable_uniform (#342)
2678
glUniformBufferEXT: PFNGLUNIFORMBUFFEREXTPROC;
2679
glGetUniformBufferSizeEXT: PFNGLGETUNIFORMBUFFERSIZEEXTPROC;
2680
glGetUniformOffsetEXT: PFNGLGETUNIFORMOFFSETEXTPROC;
2682
// GL_EXT_texture_integer (#343)
2683
glClearColorIiEXT: PFNGLCLEARCOLORIIEXTPROC;
2684
glClearColorIuiEXT: PFNGLCLEARCOLORIUIEXTPROC;
2685
glTexParameterIivEXT: PFNGLTEXPARAMETERIIVEXTPROC;
2686
glTexParameterIuivEXT: PFNGLTEXPARAMETERIUIVEXTPROC;
2687
glGetTexParameterIivEXT: PFNGLGETTEXPARAMETERIIVEXTPROC;
2688
glGetTexParameterIuivEXT: PFNGLGETTEXPARAMETERIUIVEXTPROC;
2690
// GL_GREMEDY_frame_terminator (EXT #345)
2691
glFrameTerminatorGREMEDY: PFNGLFRAMETERMINATORGREMEDYPROC;
2693
// GL_NV_conditional_render (#346)
2694
glBeginConditionalRenderNV: PFNGLBEGINCONDITIONALRENDERNVPROC;
2695
glEndConditionalRenderNV: PFNGLENDCONDITIONALRENDERNVPROC;
2697
// GL_EXT_transform_feedback (#352)
2698
glBindBufferRangeEXT: PFNGLBINDBUFFERRANGEEXTPROC;
2699
glBindBufferOffsetEXT: PFNGLBINDBUFFEROFFSETEXTPROC;
2700
glBindBufferBaseEXT: PFNGLBINDBUFFERBASEEXTPROC;
2701
glBeginTransformFeedbackEXT: PFNGLBEGINTRANSFORMFEEDBACKEXTPROC;
2702
glEndTransformFeedbackEXT: PFNGLENDTRANSFORMFEEDBACKEXTPROC;
2703
glTransformFeedbackVaryingsEXT: PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC;
2704
glGetTransformFeedbackVaryingEXT: PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC;
2706
// GL_AMD_vertex_shader_tessellator (#363)
2707
glTessellationFactorAMD: PFNGLTESSELLATIONFACTORAMDPROC;
2708
glTessellationModeAMD: PFNGLTESSELLATIONMODEAMDPROC;
2710
// GL_NV_copy_image (#376)
2711
glCopyImageSubDataNV: PFNGLCOPYIMAGESUBDATANVPROC;
2713
// GL_NV_shader_buffer_load (#379)
2714
glMakeBufferResidentNV: PFNGLMAKEBUFFERRESIDENTNVPROC;
2715
glMakeBufferNonResidentNV: PFNGLMAKEBUFFERNONRESIDENTNVPROC;
2716
glIsBufferResidentNV: PFNGLISBUFFERRESIDENTNVPROC;
2717
glMakeNamedBufferResidentNV: PFNGLMAKENAMEDBUFFERRESIDENTNVPROC;
2718
glMakeNamedBufferNonResidentNV: PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC;
2719
glIsNamedBufferResidentNV: PFNGLISNAMEDBUFFERRESIDENTNVPROC;
2720
glGetBufferParameterui64vNV: PFNGLGETBUFFERPARAMETERUI64VNVPROC;
2721
glGetNamedBufferParameterui64vNV: PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC;
2722
glGetIntegerui64vNV: PFNGLGETINTEGERUI64VNVPROC;
2723
glUniformui64NV: PFNGLUNIFORMUI64NVPROC;
2724
glUniformui64vNV: PFNGLUNIFORMUI64VNVPROC;
2725
glGetUniformui64vNV: PFNGLGETUNIFORMUI64VNVPROC;
2726
glProgramUniformui64NV: PFNGLPROGRAMUNIFORMUI64NVPROC;
2727
glProgramUniformui64vNV: PFNGLPROGRAMUNIFORMUI64VNVPROC;
2729
// GL_NV_vertex_buffer_unified_memory (#380)
2730
glBufferAddressRangeNV: PFNGLBUFFERADDRESSRANGENVPROC;
2731
glVertexFormatNV: PFNGLVERTEXFORMATNVPROC;
2732
glNormalFormatNV: PFNGLNORMALFORMATNVPROC;
2733
glColorFormatNV: PFNGLCOLORFORMATNVPROC;
2734
glIndexFormatNV: PFNGLINDEXFORMATNVPROC;
2735
glTexCoordFormatNV: PFNGLTEXCOORDFORMATNVPROC;
2736
glEdgeFlagFormatNV: PFNGLEDGEFLAGFORMATNVPROC;
2737
glSecondaryColorFormatNV: PFNGLSECONDARYCOLORFORMATNVPROC;
2738
glFogCoordFormatNV: PFNGLFOGCOORDFORMATNVPROC;
2739
glVertexAttribFormatNV: PFNGLVERTEXATTRIBFORMATNVPROC;
2740
glVertexAttribIFormatNV: PFNGLVERTEXATTRIBIFORMATNVPROC;
2741
glGetIntegerui64i_vNV: PFNGLGETINTEGERUI64I_VNVPROC;
2743
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}2746
//------------------------------------------------------------------------------
2747
function GLLibGetProcAddress(ProcName: PGLChar): Pointer;
2748
function GLGetProcAddress(ProcName: PGLChar): Pointer;
2749
procedure ReadExtensions;
2750
procedure ReadImplementationProperties;
2752
procedure ReadWGLExtensions;
2753
procedure ReadWGLImplementationProperties;
2756
procedure ReadGLXExtensions;
2757
procedure ReadGLXImplementationProperties;
2760
procedure CloseOpenGL;
2761
function InitOpenGL : Boolean;
2762
function InitOpenGLFromLibrary(const GLName, GLUName : String) : Boolean;
2763
function IsOpenGLInitialized: Boolean;
2765
// compatibility routines
2766
procedure UnloadOpenGL;
2767
function LoadOpenGL : Boolean;
2768
function LoadOpenGLFromLibrary(GLName, GLUName: String): Boolean;
2769
function IsOpenGLLoaded : Boolean;
2771
function IsMesaGL : Boolean;
2772
procedure TrimAndSplitVersionString(Buffer: String; var Max, Min: Integer);
2773
function IsVersionMet(MajorVersion,MinorVersion, actualMajorVersion, actualMinorVersion:Integer): boolean;
2774
function IsOpenGLVersionMet(MajorVersion,MinorVersion: Integer): boolean;
2777
EOpenGLError = class(Exception);
2779
{ Gets the oldest error from OpenGL engine and tries to clear the error queue. }2780
procedure CheckOpenGLError;
2781
{ Clears all pending OpenGL errors. }2782
procedure ClearGLError;
2783
{ Raises an EOpenGLError with 'msg' error string. }2784
procedure RaiseOpenGLError(const msg : String);
2787
vIgnoreOpenGLErrors : Boolean = false;
2789
// ------------------------------------------------------------------
2790
// ------------------------------------------------------------------
2791
// ------------------------------------------------------------------
2793
// ------------------------------------------------------------------
2794
// ------------------------------------------------------------------
2795
// ------------------------------------------------------------------
2797
// ************** Windows specific ********************
2800
INVALID_MODULEHANDLE = 0;
2806
function GLGetProcAddress(ProcName: PGLChar):Pointer;
2808
result := wglGetProcAddress(ProcName);
2813
// ************** UNIX specific ********************
2816
INVALID_MODULEHANDLE = 0;//nil;
2819
GLHandle: TLibHandle = 0;//Pointer;
2820
GLUHandle: TLibHandle = 0;//Pointer;
2822
function GLGetProcAddress(ProcName: PGLChar):Pointer;
2824
{$IFDEF SUPPORT_GLX}2825
if @glXGetProcAddress<>nil then
2826
result := glXGetProcAddress(ProcName);
2828
if result<> nil then exit;
2830
if @glXGetProcAddressARB<>nil then
2831
result := glXGetProcAddressARB(ProcName);
2833
if result<> nil then exit;
2835
result := GetProcAddress(GLHandle, ProcName);
2839
function GLLibGetProcAddress(ProcName: PGLChar):Pointer;
2841
result := GetProcAddress(GLHandle, ProcName);
2846
procedure CheckOpenGLError;
2851
GLError:=glGetError;
2852
if GLError <> GL_NO_ERROR then begin
2854
// Because under some circumstances reading the error code creates a new error
2855
// and thus hanging up the thread, we limit the loop to 6 reads.
2857
while (glGetError <> GL_NO_ERROR) and (Count < 6) do Inc(Count);
2859
// Egg : ignore exceptions here, will perhaps avoid problem expressed before
2861
if not vIgnoreOpenGLErrors then
2862
raise EOpenGLError.Create(String(gluErrorString(GLError)));
2868
procedure ClearGLError;
2873
while (glGetError<>GL_NO_ERROR) and (n<6) do Inc(n);
2878
procedure RaiseOpenGLError(const msg : String);
2880
raise EOpenGLError.Create(msg);
2883
// ************** Extensions ********************
2887
procedure ReadExtensions;
2888
// To be used in an active rendering context only!
2891
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 1.2'} {$ENDIF}2893
// ###########################################################
2894
// locate functions and procedures for
2895
// extensions integrated into OpenGL 1.2 core
2896
// ###########################################################
2898
// promoted to core v1.2 from GL_EXT_blend_color (#2)
2899
glBlendColor := GLGetProcAddress('glBlendColor');2901
//promoted to core v1.2 from GL_EXT_blend_minmax (#37)
2902
glBlendEquation := GLGetProcAddress('glBlendEquation');2904
// promoted to core v1.2 from GL_EXT_draw_range_elements (#112)
2905
glDrawRangeElements := GLGetProcAddress('glDrawRangeElements');2907
// promoted to core v1.2 from GL_SGI_color_table (#14)
2908
glColorTable := GLGetProcAddress('glColorTable');2909
glColorTableParameterfv := GLGetProcAddress('glColorTableParameterfv');2910
glColorTableParameteriv := GLGetProcAddress('glColorTableParameteriv');2911
glCopyColorTable := GLGetProcAddress('glCopyColorTable');2912
glGetColorTable := GLGetProcAddress('glGetColorTable');2913
glGetColorTableParameterfv := GLGetProcAddress('glGetColorTableParameterfv');2914
glGetColorTableParameteriv := GLGetProcAddress('glGetColorTableParameteriv');2916
// promoted to core v1.2 from GL_EXT_color_subtable (#74)
2917
glColorSubTable := GLGetProcAddress('glColorSubTable');2918
glCopyColorSubTable := GLGetProcAddress('glCopyColorSubTable');2920
// promoted to core v1.2 from GL_EXT_convolution (#12)
2921
glConvolutionFilter1D := GLGetProcAddress('glConvolutionFilter1D');2922
glConvolutionFilter2D := GLGetProcAddress('glConvolutionFilter2D'); 2923
glConvolutionParameterf := GLGetProcAddress('glConvolutionParameterf');2924
glConvolutionParameterfv := GLGetProcAddress('glConvolutionParameterfv');2925
glConvolutionParameteri := GLGetProcAddress('glConvolutionParameteri'); 2926
glConvolutionParameteriv := GLGetProcAddress('glConvolutionParameteriv');2927
glCopyConvolutionFilter1D := GLGetProcAddress('glCopyConvolutionFilter1D');2928
glCopyConvolutionFilter2D := GLGetProcAddress('glCopyConvolutionFilter2D');2929
glGetConvolutionFilter := GLGetProcAddress('glGetConvolutionFilter');2930
glGetConvolutionParameterfv := GLGetProcAddress('glGetConvolutionParameterfv');2931
glGetConvolutionParameteriv := GLGetProcAddress('glGetConvolutionParameteriv');2932
glGetSeparableFilter := GLGetProcAddress('glGetSeparableFilter');2933
glSeparableFilter2D := GLGetProcAddress('glSeparableFilter2D');2935
// promoted to core v1.2 from GL_EXT_histogram (#11)
2936
glGetHistogram := GLGetProcAddress('glGetHistogram');2937
glGetHistogramParameterfv := GLGetProcAddress('glGetHistogramParameterfv');2938
glGetHistogramParameteriv := GLGetProcAddress('glGetHistogramParameteriv');2939
glGetMinmax := GLGetProcAddress('glGetMinmax');2940
glGetMinmaxParameterfv := GLGetProcAddress('glGetMinmaxParameterfv');2941
glGetMinmaxParameteriv := GLGetProcAddress('glGetMinmaxParameteriv');2942
glHistogram := GLGetProcAddress('glHistogram');2943
glMinmax := GLGetProcAddress('glMinmax');2944
glResetHistogram := GLGetProcAddress('glResetHistogram');2945
glResetMinmax := GLGetProcAddress('glResetMinmax');2947
// promoted to core v1.2 from GL_EXT_texture3D (#6)
2948
glTexImage3D := GLGetProcAddress('glTexImage3D');2949
glTexSubImage3D := GLGetProcAddress('glTexSubImage3D');2951
// promoted to core v1.2 from GL_EXT_copy_texture
2952
glCopyTexSubImage3D := GLGetProcAddress('glCopyTexSubImage3D');2954
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}2956
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 1.3'} {$ENDIF}2958
// ###########################################################
2959
// locate functions and procedures for
2960
// extensions integrated into OpenGL 1.3 core
2961
// ###########################################################
2963
// promoted to core v1.3 from GL_ARB_multitexture (#1)
2964
glActiveTexture := GLGetProcAddress('glActiveTexture');2965
glClientActiveTexture := GLGetProcAddress('glClientActiveTexture');2966
glMultiTexCoord1d := GLGetProcAddress('glMultiTexCoord1d');2967
glMultiTexCoord1dV := GLGetProcAddress('glMultiTexCoord1dV');2968
glMultiTexCoord1f := GLGetProcAddress('glMultiTexCoord1f');2969
glMultiTexCoord1fV := GLGetProcAddress('glMultiTexCoord1fV');2970
glMultiTexCoord1i := GLGetProcAddress('glMultiTexCoord1i');2971
glMultiTexCoord1iV := GLGetProcAddress('glMultiTexCoord1iV');2972
glMultiTexCoord1s := GLGetProcAddress('glMultiTexCoord1s');2973
glMultiTexCoord1sV := GLGetProcAddress('glMultiTexCoord1sV'); 2974
glMultiTexCoord2d := GLGetProcAddress('glMultiTexCoord2d');2975
glMultiTexCoord2dv := GLGetProcAddress('glMultiTexCoord2dv');2976
glMultiTexCoord2f := GLGetProcAddress('glMultiTexCoord2f');2977
glMultiTexCoord2fv := GLGetProcAddress('glMultiTexCoord2fv');2978
glMultiTexCoord2i := GLGetProcAddress('glMultiTexCoord2i');2979
glMultiTexCoord2iv := GLGetProcAddress('glMultiTexCoord2iv');2980
glMultiTexCoord2s := GLGetProcAddress('glMultiTexCoord2s'); 2981
glMultiTexCoord2sv := GLGetProcAddress('glMultiTexCoord2sv');2982
glMultiTexCoord3d := GLGetProcAddress('glMultiTexCoord3d');2983
glMultiTexCoord3dv := GLGetProcAddress('glMultiTexCoord3dv'); 2984
glMultiTexCoord3f := GLGetProcAddress('glMultiTexCoord3f');2985
glMultiTexCoord3fv := GLGetProcAddress('glMultiTexCoord3fv');2986
glMultiTexCoord3i := GLGetProcAddress('glMultiTexCoord3i');2987
glMultiTexCoord3iv := GLGetProcAddress('glMultiTexCoord3iv'); 2988
glMultiTexCoord3s := GLGetProcAddress('glMultiTexCoord3s'); 2989
glMultiTexCoord3sv := GLGetProcAddress('glMultiTexCoord3sv');2990
glMultiTexCoord4d := GLGetProcAddress('glMultiTexCoord4d'); 2991
glMultiTexCoord4dv := GLGetProcAddress('glMultiTexCoord4dv');2992
glMultiTexCoord4f := GLGetProcAddress('glMultiTexCoord4f');2993
glMultiTexCoord4fv := GLGetProcAddress('glMultiTexCoord4fv');2994
glMultiTexCoord4i := GLGetProcAddress('glMultiTexCoord4i');2995
glMultiTexCoord4iv := GLGetProcAddress('glMultiTexCoord4iv');2996
glMultiTexCoord4s := GLGetProcAddress('glMultiTexCoord4s');2997
glMultiTexCoord4sv := GLGetProcAddress('glMultiTexCoord4sv');2999
// promoted to core v1.3 from GL_ARB_transpose_matrix
3000
glLoadTransposeMatrixf := GLGetProcAddress('glLoadTransposeMatrixf');3001
glLoadTransposeMatrixd := GLGetProcAddress('glLoadTransposeMatrixd');3002
glMultTransposeMatrixf := GLGetProcAddress('glMultTransposeMatrixf');3003
glMultTransposeMatrixd := GLGetProcAddress('glMultTransposeMatrixd');3005
// promoted to core v1.3 from GL_ARB_multisample (#5)
3006
glSampleCoverage := GLGetProcAddress('glSampleCoverage');3008
// promoted to core v1.3 from GL_ARB_texture_compression (#12)
3009
glCompressedTexImage3D := GLGetProcAddress('glCompressedTexImage3D');3010
glCompressedTexImage2D := GLGetProcAddress('glCompressedTexImage2D');3011
glCompressedTexImage1D := GLGetProcAddress('glCompressedTexImage1D');3012
glCompressedTexSubImage3D := GLGetProcAddress('glCompressedTexSubImage3D');3013
glCompressedTexSubImage2D := GLGetProcAddress('glCompressedTexSubImage2D');3014
glCompressedTexSubImage1D := GLGetProcAddress('glCompressedTexSubImage1D');3015
glGetCompressedTexImage := GLGetProcAddress('glGetCompressedTexImage');3017
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3019
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 1.4'} {$ENDIF}3021
// ###########################################################
3022
// locate functions and procedures for
3023
// extensions integrated into OpenGL 1.4 core
3024
// ###########################################################
3026
// promoted to core v1.4 from GL_EXT_blend_func_separate (#173)
3027
glBlendFuncSeparate := GLGetProcAddress('glBlendFuncSeparate');3029
// promoted to core v1.4 from GL_EXT_fog_coord (#149)
3030
glFogCoordf := GLGetProcAddress('glFogCoordf');3031
glFogCoordfv := GLGetProcAddress('glFogCoordfv');3032
glFogCoordd := GLGetProcAddress('glFogCoordd');3033
glFogCoorddv := GLGetProcAddress('glFogCoorddv');3034
glFogCoordPointer := GLGetProcAddress('glFogCoordPointer');3036
// promoted to core v1.4 from GL_EXT_multi_draw_arrays (#148)
3037
glMultiDrawArrays := GLGetProcAddress('glMultiDrawArrays');3038
glMultiDrawElements := GLGetProcAddress('glMultiDrawElements');3040
// promoted to core v1.4 from GL_ARB_point_parameters (#14), GL_NV_point_sprite (#262)
3041
glPointParameterf := GLGetProcAddress('glPointParameterf');3042
glPointParameterfv := GLGetProcAddress('glPointParameterfv');3043
glPointParameteri := GLGetProcAddress('glPointParameteri');3044
glPointParameteriv := GLGetProcAddress('glPointParameteriv');3046
// promoted to core v1.4 from GL_EXT_secondary_color (#145)
3047
glSecondaryColor3b := GLGetProcAddress('glSecondaryColor3b');3048
glSecondaryColor3bv := GLGetProcAddress('glSecondaryColor3bv');3049
glSecondaryColor3d := GLGetProcAddress('glSecondaryColor3d');3050
glSecondaryColor3dv := GLGetProcAddress('glSecondaryColor3dv');3051
glSecondaryColor3f := GLGetProcAddress('glSecondaryColor3f');3052
glSecondaryColor3fv := GLGetProcAddress('glSecondaryColor3fv');3053
glSecondaryColor3i := GLGetProcAddress('glSecondaryColor3i');3054
glSecondaryColor3iv := GLGetProcAddress('glSecondaryColor3iv');3055
glSecondaryColor3s := GLGetProcAddress('glSecondaryColor3s');3056
glSecondaryColor3sv := GLGetProcAddress('glSecondaryColor3sv');3057
glSecondaryColor3ub := GLGetProcAddress('glSecondaryColor3ub');3058
glSecondaryColor3ubv := GLGetProcAddress('glSecondaryColor3ubv');3059
glSecondaryColor3ui := GLGetProcAddress('glSecondaryColor3ui');3060
glSecondaryColor3uiv := GLGetProcAddress('glSecondaryColor3uiv');3061
glSecondaryColor3us := GLGetProcAddress('glSecondaryColor3us');3062
glSecondaryColor3usv := GLGetProcAddress('glSecondaryColor3usv');3063
glSecondaryColorPointer := GLGetProcAddress('glSecondaryColorPointer');3065
// promoted to core v1.4 from GL_ARB_window_pos (#25)
3066
glWindowPos2d := GLGetProcAddress('glWindowPos2d');3067
glWindowPos2dv := GLGetProcAddress('glWindowPos2dv');3068
glWindowPos2f := GLGetProcAddress('glWindowPos2f');3069
glWindowPos2fv := GLGetProcAddress('glWindowPos2fv');3070
glWindowPos2i := GLGetProcAddress('glWindowPos2i');3071
glWindowPos2iv := GLGetProcAddress('glWindowPos2iv');3072
glWindowPos2s := GLGetProcAddress('glWindowPos2s');3073
glWindowPos2sv := GLGetProcAddress('glWindowPos2sv');3074
glWindowPos3d := GLGetProcAddress('glWindowPos3d');3075
glWindowPos3dv := GLGetProcAddress('glWindowPos3dv');3076
glWindowPos3f := GLGetProcAddress('glWindowPos3f');3077
glWindowPos3fv := GLGetProcAddress('glWindowPos3fv');3078
glWindowPos3i := GLGetProcAddress('glWindowPos3i');3079
glWindowPos3iv := GLGetProcAddress('glWindowPos3iv');3080
glWindowPos3s := GLGetProcAddress('glWindowPos3s');3081
glWindowPos3sv := GLGetProcAddress('glWindowPos3sv');3083
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3085
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 1.5'} {$ENDIF}3087
// ###########################################################
3088
// locate functions and procedures for
3089
// extensions integrated into OpenGL 1.5 core
3090
// ###########################################################
3092
// promoted to core v1.5 from GL_ARB_occlusion_query (#29)
3093
glGenQueries := GLGetProcAddress('glGenQueries');3094
glDeleteQueries := GLGetProcAddress('glDeleteQueries');3095
glIsQuery := GLGetProcAddress('glIsQuery');3096
glBeginQuery := GLGetProcAddress('glBeginQuery');3097
glEndQuery := GLGetProcAddress('glEndQuery');3098
glGetQueryiv := GLGetProcAddress('glGetQueryiv');3099
glGetQueryObjectiv := GLGetProcAddress('glGetQueryObjectiv');3100
glGetQueryObjectuiv := GLGetProcAddress('glGetQueryObjectuiv');3103
// promoted to core v1.5 from GL_ARB_vertex_buffer_object (#28)
3104
glBindBuffer := GLGetProcAddress('glBindBuffer');3105
glDeleteBuffers := GLGetProcAddress('glDeleteBuffers');3106
glGenBuffers := GLGetProcAddress('glGenBuffers');3107
glIsBuffer := GLGetProcAddress('glIsBuffer');3108
glBufferData := GLGetProcAddress('glBufferData');3109
glBufferSubData := GLGetProcAddress('glBufferSubData');3110
glGetBufferSubData := GLGetProcAddress('glGetBufferSubData');3111
glMapBuffer := GLGetProcAddress('glMapBuffer');3112
glUnmapBuffer := GLGetProcAddress('glUnmapBuffer');3113
glGetBufferParameteriv := GLGetProcAddress('glGetBufferParameteriv');3114
glGetBufferPointerv := GLGetProcAddress('glGetBufferPointerv');3116
// promoted to core v1.5 from GL_EXT_shadow_funcs (#267)
3117
// (no functions or procedures)
3119
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3121
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 2.0'} {$ENDIF}3123
// ###########################################################
3124
// locate functions and procedures for
3125
// extensions integrated into OpenGL 2.0 core
3126
// ###########################################################
3128
// promoted to core v2.0 from GL_EXT_blend_equation_separate (#299)
3129
glBlendEquationSeparate := GLGetProcAddress('glBlendEquationSeparate');3131
// promoted to core v2.0 from GL_ARB_draw_buffers (#37)
3132
glDrawBuffers := GLGetProcAddress('glDrawBuffers');3134
// promoted to core v2.0 from GL_ARB_stencil_two_side (no # found)
3135
glStencilOpSeparate := GLGetProcAddress('glStencilOpSeparate');3136
glStencilFuncSeparate := GLGetProcAddress('glStencilFuncSeparate');3137
glStencilMaskSeparate := GLGetProcAddress('glStencilMaskSeparate');3139
// promoted to core v2.0 from GL_ARB_shader_objects (#30) / GL_ARB_vertex_shader (#31) / GL_ARB_fragment_shader (#32)
3140
glAttachShader := GLGetProcAddress('glAttachShader');3141
glBindAttribLocation := GLGetProcAddress('glBindAttribLocation');3142
glCompileShader := GLGetProcAddress('glCompileShader');3143
glCreateProgram := GLGetProcAddress('glCreateProgram');3144
glCreateShader := GLGetProcAddress('glCreateShader');3145
glDeleteProgram := GLGetProcAddress('glDeleteProgram');3146
glDeleteShader := GLGetProcAddress('glDeleteShader');3147
glDetachShader := GLGetProcAddress('glDetachShader');3148
glDisableVertexAttribArray := GLGetProcAddress('glDisableVertexAttribArray');3149
glEnableVertexAttribArray := GLGetProcAddress('glEnableVertexAttribArray');3150
glGetActiveAttrib := GLGetProcAddress('glGetActiveAttrib');3151
glGetActiveUniform := GLGetProcAddress('glGetActiveUniform');3152
glGetAttachedShaders := GLGetProcAddress('glGetAttachedShaders');3153
glGetAttribLocation := GLGetProcAddress('glGetAttribLocation');3154
glGetProgramiv := GLGetProcAddress('glGetProgramiv');3155
glGetProgramInfoLog := GLGetProcAddress('glGetProgramInfoLog');3156
glGetShaderiv := GLGetProcAddress('glGetShaderiv');3157
glGetShaderInfoLog := GLGetProcAddress('glGetShaderInfoLog');3158
glGetShaderSource := GLGetProcAddress('glGetShaderSource');3159
glGetUniformLocation := GLGetProcAddress('glGetUniformLocation');3160
glGetUniformfv := GLGetProcAddress('glGetUniformfv');3161
glGetUniformiv := GLGetProcAddress('glGetUniformiv');3162
glGetVertexAttribdv := GLGetProcAddress('glGetVertexAttribdv');3163
glGetVertexAttribfv := GLGetProcAddress('glGetVertexAttribfv');3164
glGetVertexAttribiv := GLGetProcAddress('glGetVertexAttribiv');3165
glGetVertexAttribPointerv := GLGetProcAddress('glGetVertexAttribPointerv');3166
glIsProgram := GLGetProcAddress('glIsProgram');3167
glIsShader := GLGetProcAddress('glIsShader');3168
glLinkProgram := GLGetProcAddress('glLinkProgram');3169
glShaderSource := GLGetProcAddress('glShaderSource');3170
glUseProgram := GLGetProcAddress('glUseProgram');3171
glUniform1f := GLGetProcAddress('glUniform1f');3172
glUniform2f := GLGetProcAddress('glUniform2f');3173
glUniform3f := GLGetProcAddress('glUniform3f');3174
glUniform4f := GLGetProcAddress('glUniform4f');3175
glUniform1i := GLGetProcAddress('glUniform1i');3176
glUniform2i := GLGetProcAddress('glUniform2i');3177
glUniform3i := GLGetProcAddress('glUniform3i');3178
glUniform4i := GLGetProcAddress('glUniform4i');3179
glUniform1fv := GLGetProcAddress('glUniform1fv');3180
glUniform2fv := GLGetProcAddress('glUniform2fv');3181
glUniform3fv := GLGetProcAddress('glUniform3fv');3182
glUniform4fv := GLGetProcAddress('glUniform4fv');3183
glUniform1iv := GLGetProcAddress('glUniform1iv');3184
glUniform2iv := GLGetProcAddress('glUniform2iv');3185
glUniform3iv := GLGetProcAddress('glUniform3iv');3186
glUniform4iv := GLGetProcAddress('glUniform4iv');3187
glUniformMatrix2fv := GLGetProcAddress('glUniformMatrix2fv');3188
glUniformMatrix3fv := GLGetProcAddress('glUniformMatrix3fv');3189
glUniformMatrix4fv := GLGetProcAddress('glUniformMatrix4fv');3190
glValidateProgram := GLGetProcAddress('glValidateProgram');3191
glVertexAttrib1d := GLGetProcAddress('glVertexAttrib1d');3192
glVertexAttrib1dv := GLGetProcAddress('glVertexAttrib1dv');3193
glVertexAttrib1f := GLGetProcAddress('glVertexAttrib1f');3194
glVertexAttrib1fv := GLGetProcAddress('glVertexAttrib1fv');3195
glVertexAttrib1s := GLGetProcAddress('glVertexAttrib1s');3196
glVertexAttrib1sv := GLGetProcAddress('glVertexAttrib1sv');3197
glVertexAttrib2d := GLGetProcAddress('glVertexAttrib2d');3198
glVertexAttrib2dv := GLGetProcAddress('glVertexAttrib2dv');3199
glVertexAttrib2f := GLGetProcAddress('glVertexAttrib2f');3200
glVertexAttrib2fv := GLGetProcAddress('glVertexAttrib2fv');3201
glVertexAttrib2s := GLGetProcAddress('glVertexAttrib2s');3202
glVertexAttrib2sv := GLGetProcAddress('glVertexAttrib2sv');3203
glVertexAttrib3d := GLGetProcAddress('glVertexAttrib3d');3204
glVertexAttrib3dv := GLGetProcAddress('glVertexAttrib3dv');3205
glVertexAttrib3f := GLGetProcAddress('glVertexAttrib3f');3206
glVertexAttrib3fv := GLGetProcAddress('glVertexAttrib3fv');3207
glVertexAttrib3s := GLGetProcAddress('glVertexAttrib3s');3208
glVertexAttrib3sv := GLGetProcAddress('glVertexAttrib3sv');3209
glVertexAttrib4Nbv := GLGetProcAddress('glVertexAttrib4Nbv');3210
glVertexAttrib4Niv := GLGetProcAddress('glVertexAttrib4Niv');3211
glVertexAttrib4Nsv := GLGetProcAddress('glVertexAttrib4Nsv');3212
glVertexAttrib4Nub := GLGetProcAddress('glVertexAttrib4Nub');3213
glVertexAttrib4Nubv := GLGetProcAddress('glVertexAttrib4Nubv');3214
glVertexAttrib4Nuiv := GLGetProcAddress('glVertexAttrib4Nuiv');3215
glVertexAttrib4Nusv := GLGetProcAddress('glVertexAttrib4Nusv');3216
glVertexAttrib4bv := GLGetProcAddress('glVertexAttrib4bv');3217
glVertexAttrib4d := GLGetProcAddress('glVertexAttrib4d');3218
glVertexAttrib4dv := GLGetProcAddress('glVertexAttrib4dv');3219
glVertexAttrib4f := GLGetProcAddress('glVertexAttrib4f');3220
glVertexAttrib4fv := GLGetProcAddress('glVertexAttrib4fv');3221
glVertexAttrib4iv := GLGetProcAddress('glVertexAttrib4iv');3222
glVertexAttrib4s := GLGetProcAddress('glVertexAttrib4s');3223
glVertexAttrib4sv := GLGetProcAddress('glVertexAttrib4sv');3224
glVertexAttrib4ubv := GLGetProcAddress('glVertexAttrib4ubv');3225
glVertexAttrib4uiv := GLGetProcAddress('glVertexAttrib4uiv');3226
glVertexAttrib4usv := GLGetProcAddress('glVertexAttrib4usv');3227
glVertexAttribPointer := GLGetProcAddress('glVertexAttribPointer');3229
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3231
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 2.1'} {$ENDIF}3233
// ###########################################################
3234
// locate functions and procedures for
3235
// extensions integrated into OpenGL 2.1 core
3236
// ###########################################################
3238
// promoted to core v2.1 from GL_ARB_pixel_buffer_object
3239
// (no functions or procedures)
3241
// promoted to core v2.1 from GL_EXT_texture_sRGB
3242
// (no functions or procedures)
3244
// New commands in OpenGL 2.1
3245
glUniformMatrix2x3fv := GLGetProcAddress('glUniformMatrix2x3fv');3246
glUniformMatrix3x2fv := GLGetProcAddress('glUniformMatrix3x2fv');3247
glUniformMatrix2x4fv := GLGetProcAddress('glUniformMatrix2x4fv');3248
glUniformMatrix4x2fv := GLGetProcAddress('glUniformMatrix4x2fv');3249
glUniformMatrix3x4fv := GLGetProcAddress('glUniformMatrix3x4fv');3250
glUniformMatrix4x3fv := GLGetProcAddress('glUniformMatrix4x3fv');3252
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3254
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 3.0'} {$ENDIF}3256
// ###########################################################
3257
// locate functions and procedures for
3258
// extensions integrated into OpenGL 3.0 core
3259
// ###########################################################
3261
// promoted to core v3.0 from GL_EXT_gpu_shader4
3262
glVertexAttribI1i := GLGetProcAddress('glVertexAttribI1i');3263
glVertexAttribI2i := GLGetProcAddress('glVertexAttribI2i');3264
glVertexAttribI3i := GLGetProcAddress('glVertexAttribI3i');3265
glVertexAttribI4i := GLGetProcAddress('glVertexAttribI4i');3266
glVertexAttribI1ui := GLGetProcAddress('glVertexAttribI1ui');3267
glVertexAttribI2ui := GLGetProcAddress('glVertexAttribI2ui');3268
glVertexAttribI3ui := GLGetProcAddress('glVertexAttribI3ui');3269
glVertexAttribI4ui := GLGetProcAddress('glVertexAttribI4ui');3270
glVertexAttribI1iv := GLGetProcAddress('glVertexAttribI1iv');3271
glVertexAttribI2iv := GLGetProcAddress('glVertexAttribI2iv');3272
glVertexAttribI3iv := GLGetProcAddress('glVertexAttribI3iv');3273
glVertexAttribI4iv := GLGetProcAddress('glVertexAttribI4iv');3274
glVertexAttribI1uiv := GLGetProcAddress('glVertexAttribI1uiv');3275
glVertexAttribI2uiv := GLGetProcAddress('glVertexAttribI2uiv');3276
glVertexAttribI3uiv := GLGetProcAddress('glVertexAttribI3uiv');3277
glVertexAttribI4uiv := GLGetProcAddress('glVertexAttribI4uiv');3278
glVertexAttribI4bv := GLGetProcAddress('glVertexAttribI4bv');3279
glVertexAttribI4sv := GLGetProcAddress('glVertexAttribI4sv');3280
glVertexAttribI4ubv := GLGetProcAddress('glVertexAttribI4ubv');3281
glVertexAttribI4usv := GLGetProcAddress('glVertexAttribI4usv');3282
glVertexAttribIPointer := GLGetProcAddress('glVertexAttribIPointer');3283
glGetVertexAttribIiv := GLGetProcAddress('glGetVertexAttribIiv');3284
glGetVertexAttribIuiv := GLGetProcAddress('glGetVertexAttribIuiv');3285
glUniform1ui := GLGetProcAddress('glUniform1ui');3286
glUniform2ui := GLGetProcAddress('glUniform2ui');3287
glUniform3ui := GLGetProcAddress('glUniform3ui');3288
glUniform4ui := GLGetProcAddress('glUniform4ui');3289
glUniform1uiv := GLGetProcAddress('glUniform1uiv');3290
glUniform2uiv := GLGetProcAddress('glUniform2uiv');3291
glUniform3uiv := GLGetProcAddress('glUniform3uiv');3292
glUniform4uiv := GLGetProcAddress('glUniform4uiv');3293
glGetUniformuiv := GLGetProcAddress('glGetUniformuiv');3294
glBindFragDataLocation := GLGetProcAddress('glBindFragDataLocation');3295
glGetFragDataLocation := GLGetProcAddress('glGetFragDataLocation');3297
// promoted to core v3.0 from GL_NV_conditional_render
3298
glBeginConditionalRender := GLGetProcAddress('glBeginConditionalRender');3299
glEndConditionalRender := GLGetProcAddress('glEndConditionalRender');3300
// promoted to core v3.0 from GL_ARB_color_buffer_float
3301
glClampColor := GLGetProcAddress('glClampColor');3302
// promoted to core v3.0 from GL_EXT_texture_integer
3303
//glClearColorIi := GLGetProcAddress('glClearColorIi');3304
//glClearColorIui := GLGetProcAddress('glClearColorIui');3305
glTexParameterIiv := GLGetProcAddress('glTexParameterIiv');3306
glTexParameterIuiv := GLGetProcAddress('glTexParameterIuiv');3307
glGetTexParameterIiv := GLGetProcAddress('glGetTexParameterIiv');3308
glGetTexParameterIuiv := GLGetProcAddress('glGetTexParameterIuiv');3310
// promoted to core v3.0 from GL_EXT_draw_buffers2
3311
glColorMaski := GLGetProcAddress('glColorMaski');3312
glGetBooleani_v := GLGetProcAddress('glGetBooleani_v');3313
glGetIntegeri_v := GLGetProcAddress('glGetIntegeri_v');3314
glEnablei := GLGetProcAddress('glEnablei');3315
glDisablei := GLGetProcAddress('glDisablei');3316
glIsEnabledi := GLGetProcAddress('glIsEnabledi');3318
// GL_EXT_transform_feedback (#352)
3319
glBindBufferRange := GLGetProcAddress('glBindBufferRange');3320
glBindBufferBase := GLGetProcAddress('glBindBufferBase');3321
glBeginTransformFeedback := GLGetProcAddress('glBeginTransformFeedback');3322
glEndTransformFeedback := GLGetProcAddress('glEndTransformFeedback');3323
glTransformFeedbackVaryings := GLGetProcAddress('glTransformFeedbackVaryings');3324
glGetTransformFeedbackVarying := GLGetProcAddress('glGetTransformFeedbackVarying');3326
// New commands in OpenGL 3.0
3327
glClearBufferiv := GLGetProcAddress('glClearBufferiv');3328
glClearBufferuiv := GLGetProcAddress('glClearBufferuiv');3329
glClearBufferfv := GLGetProcAddress('glClearBufferfv');3330
glClearBufferfi := GLGetProcAddress('glClearBufferfi');3331
glGetStringi := GLGetProcAddress('glGetStringi');3333
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3335
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 3.1'} {$ENDIF}3337
// ###########################################################
3338
// locate functions and procedures for
3339
// extensions integrated into OpenGL 3.1 core
3340
// ###########################################################
3342
glDrawArraysInstanced := GLGetProcAddress('glDrawArraysInstanced');3343
glDrawElementsInstanced := GLGetProcAddress('glDrawElementsInstanced');3344
glTexBuffer := GLGetProcAddress('glTexBuffer');3345
glPrimitiveRestartIndex := GLGetProcAddress('glPrimitiveRestartIndex');3347
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3349
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 3.2'} {$ENDIF}3351
// ###########################################################
3352
// locate functions and procedures for
3353
// extensions integrated into OpenGL 3.2 core
3354
// ###########################################################
3356
glGetInteger64i_v := GLGetProcAddress('glGetInteger64i_v');3357
glGetBufferParameteri64v := GLGetProcAddress('glGetBufferParameteri64v');3358
glProgramParameteri := GLGetProcAddress('glProgramParameteri');3359
glFramebufferTexture := GLGetProcAddress('glFramebufferTexture');3361
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3363
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 3.3'} {$ENDIF}3365
// ###########################################################
3366
// locate functions and procedures for
3367
// extensions integrated into OpenGL 3.3 core
3368
// ###########################################################
3370
glVertexAttribDivisor := GLGetProcAddress('glVertexAttribDivisor');3372
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3374
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures added with OpenGL 3.3'} {$ENDIF}3376
// ###########################################################
3377
// locate functions and procedures for
3378
// extensions integrated into OpenGL 3.3 core
3379
// ###########################################################
3381
glBlendEquationi := GLGetProcAddress('glBlendEquationi');3382
glBlendEquationSeparatei := GLGetProcAddress('glBlendEquationSeparatei');3383
glBlendFunci := GLGetProcAddress('glBlendFunci');3384
glBlendFuncSeparatei := GLGetProcAddress('glBlendFuncSeparatei');3385
glMinSampleShading := GLGetProcAddress('glMinSampleShading');3387
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3389
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures for OpenGL Utility (GLU) extensions'} {$ENDIF}3391
// ###########################################################
3392
// locate functions and procedures for
3394
// ###########################################################
3396
gluNurbsCallbackDataEXT := GLGetProcAddress('gluNurbsCallbackDataEXT');3397
gluNewNurbsTessellatorEXT := GLGetProcAddress('gluNewNurbsTessellatorEXT');3398
gluDeleteNurbsTessellatorEXT := GLGetProcAddress('gluDeleteNurbsTessellatorEXT');3400
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}3402
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures for ARB approved extensions'} {$ENDIF}3404
// ###########################################################
3405
// locate functions and procedures for
3406
// ARB approved extensions
3407
// ###########################################################
3409
// GL_ARB_multitexture (#1)
3410
glActiveTextureARB := GLGetProcAddress('glActiveTextureARB');3411
glClientActiveTextureARB := GLGetProcAddress('glClientActiveTextureARB');3412
glMultiTexCoord1dARB := GLGetProcAddress('glMultiTexCoord1dARB');3413
glMultiTexCoord1dVARB := GLGetProcAddress('glMultiTexCoord1dVARB');3414
glMultiTexCoord1fARB := GLGetProcAddress('glMultiTexCoord1fARB');3415
glMultiTexCoord1fVARB := GLGetProcAddress('glMultiTexCoord1fVARB');3416
glMultiTexCoord1iARB := GLGetProcAddress('glMultiTexCoord1iARB');3417
glMultiTexCoord1iVARB := GLGetProcAddress('glMultiTexCoord1iVARB');3418
glMultiTexCoord1sARB := GLGetProcAddress('glMultiTexCoord1sARB');3419
glMultiTexCoord1sVARB := GLGetProcAddress('glMultiTexCoord1sVARB');3420
glMultiTexCoord2dARB := GLGetProcAddress('glMultiTexCoord2dARB');3421
glMultiTexCoord2dvARB := GLGetProcAddress('glMultiTexCoord2dvARB');3422
glMultiTexCoord2fARB := GLGetProcAddress('glMultiTexCoord2fARB');3423
glMultiTexCoord2fvARB := GLGetProcAddress('glMultiTexCoord2fvARB');3424
glMultiTexCoord2iARB := GLGetProcAddress('glMultiTexCoord2iARB');3425
glMultiTexCoord2ivARB := GLGetProcAddress('glMultiTexCoord2ivARB');3426
glMultiTexCoord2sARB := GLGetProcAddress('glMultiTexCoord2sARB');3427
glMultiTexCoord2svARB := GLGetProcAddress('glMultiTexCoord2svARB');3428
glMultiTexCoord3dARB := GLGetProcAddress('glMultiTexCoord3dARB');3429
glMultiTexCoord3dvARB := GLGetProcAddress('glMultiTexCoord3dvARB');3430
glMultiTexCoord3fARB := GLGetProcAddress('glMultiTexCoord3fARB');3431
glMultiTexCoord3fvARB := GLGetProcAddress('glMultiTexCoord3fvARB');3432
glMultiTexCoord3iARB := GLGetProcAddress('glMultiTexCoord3iARB');3433
glMultiTexCoord3ivARB := GLGetProcAddress('glMultiTexCoord3ivARB');3434
glMultiTexCoord3sARB := GLGetProcAddress('glMultiTexCoord3sARB');3435
glMultiTexCoord3svARB := GLGetProcAddress('glMultiTexCoord3svARB');3436
glMultiTexCoord4dARB := GLGetProcAddress('glMultiTexCoord4dARB');3437
glMultiTexCoord4dvARB := GLGetProcAddress('glMultiTexCoord4dvARB');3438
glMultiTexCoord4fARB := GLGetProcAddress('glMultiTexCoord4fARB');3439
glMultiTexCoord4fvARB := GLGetProcAddress('glMultiTexCoord4fvARB');3440
glMultiTexCoord4iARB := GLGetProcAddress('glMultiTexCoord4iARB');3441
glMultiTexCoord4ivARB := GLGetProcAddress('glMultiTexCoord4ivARB');3442
glMultiTexCoord4sARB := GLGetProcAddress('glMultiTexCoord4sARB');3443
glMultiTexCoord4svARB := GLGetProcAddress('glMultiTexCoord4svARB');3445
// GL_ARB_transpose_matrix (#3)
3446
glLoadTransposeMatrixfARB := GLGetProcAddress('glLoadTransposeMatrixfARB');3447
glLoadTransposeMatrixdARB := GLGetProcAddress('glLoadTransposeMatrixdARB');3448
glMultTransposeMatrixfARB := GLGetProcAddress('glMultTransposeMatrixfARB');3449
glMultTransposeMatrixdARB := GLGetProcAddress('glMultTransposeMatrixdARB');3451
// GL_ARB_multisample (#5)
3452
glSampleCoverageARB := GLGetProcAddress('glSampleCoverageARB');3454
// GL_ARB_texture_compression (#12)
3455
glCompressedTexImage3DARB := GLGetProcAddress('glCompressedTexImage3DARB');3456
glCompressedTexImage2DARB := GLGetProcAddress('glCompressedTexImage2DARB');3457
glCompressedTexImage1DARB := GLGetProcAddress('glCompressedTexImage1DARB');3458
glCompressedTexSubImage3DARB := GLGetProcAddress('glCompressedTexSubImage3DARB');3459
glCompressedTexSubImage2DARB := GLGetProcAddress('glCompressedTexSubImage2DARB');3460
glCompressedTexSubImage1DARB := GLGetProcAddress('glCompressedTexSubImage1DARB');3461
glGetCompressedTexImageARB := GLGetProcAddress('glGetCompressedTexImageARB');3463
// GL_ARB_point_parameter (#14)
3464
glPointParameterfARB := GLGetProcAddress('glPointParameterfARB');3465
glPointParameterfvARB := GLGetProcAddress('glPointParameterfvARB');3467
// GL_ARB_vertex_blend (#15) {deprecated?}3468
glWeightbvARB := GLGetProcAddress('glWeightbvARB');3469
glWeightsvARB := GLGetProcAddress('glWeightsvARB');3470
glWeightivARB := GLGetProcAddress('glWeightivARB');3471
glWeightfvARB := GLGetProcAddress('glWeightfvARB');3472
glWeightdvARB := GLGetProcAddress('glWeightdvARB');3473
glWeightubvARB := GLGetProcAddress('glWeightubvARB');3474
glWeightusvARB := GLGetProcAddress('glWeightusvARB');3475
glWeightuivARB := GLGetProcAddress('glWeightuivARB');3476
glWeightPointerARB := GLGetProcAddress('glWeightPointerARB');3477
glVertexBlendARB := GLGetProcAddress('glVertexBlendARB');3479
// GL_ARB_matrix_palette (#16) {deprecated?}3480
glCurrentPaletteMatrixARB := GLGetProcAddress('glCurrentPaletteMatrixARB');3481
glMatrixIndexubvARB := GLGetProcAddress('glMatrixIndexubvARB');3482
glMatrixIndexusvARB := GLGetProcAddress('glMatrixIndexusvARB');3483
glMatrixIndexuivARB := GLGetProcAddress('glMatrixIndexuivARB');3484
glMatrixIndexPointerARB := GLGetProcAddress('glMatrixIndexPointerARB');3486
// GL_ARB_window_pos (#25)
3487
glWindowPos2dARB := GLGetProcAddress('glWindowPos2dARB');3488
glWindowPos2dvARB := GLGetProcAddress('glWindowPos2dvARB');3489
glWindowPos2fARB := GLGetProcAddress('glWindowPos2fARB');3490
glWindowPos2fvARB := GLGetProcAddress('glWindowPos2fvARB');3491
glWindowPos2iARB := GLGetProcAddress('glWindowPos2iARB');3492
glWindowPos2ivARB := GLGetProcAddress('glWindowPos2ivARB');3493
glWindowPos2sARB := GLGetProcAddress('glWindowPos2sARB');3494
glWindowPos2svARB := GLGetProcAddress('glWindowPos2svARB');3495
glWindowPos3dARB := GLGetProcAddress('glWindowPos3dARB');3496
glWindowPos3dvARB := GLGetProcAddress('glWindowPos3dvARB');3497
glWindowPos3fARB := GLGetProcAddress('glWindowPos3fARB');3498
glWindowPos3fvARB := GLGetProcAddress('glWindowPos3fvARB');3499
glWindowPos3iARB := GLGetProcAddress('glWindowPos3iARB');3500
glWindowPos3ivARB := GLGetProcAddress('glWindowPos3ivARB');3501
glWindowPos3sARB := GLGetProcAddress('glWindowPos3sARB');3502
glWindowPos3svARB := GLGetProcAddress('glWindowPos3svARB');3504
// GL_ARB_vertex_program (#26)
3505
glVertexAttrib1dARB := GLGetProcAddress('glVertexAttrib1dARB');3506
glVertexAttrib1dvARB := GLGetProcAddress('glVertexAttrib1dvARB');3507
glVertexAttrib1fARB := GLGetProcAddress('glVertexAttrib1fARB');3508
glVertexAttrib1fvARB := GLGetProcAddress('glVertexAttrib1fvARB');3509
glVertexAttrib1sARB := GLGetProcAddress('glVertexAttrib1sARB');3510
glVertexAttrib1svARB := GLGetProcAddress('glVertexAttrib1svARB');3511
glVertexAttrib2dARB := GLGetProcAddress('glVertexAttrib2dARB');3512
glVertexAttrib2dvARB := GLGetProcAddress('glVertexAttrib2dvARB');3513
glVertexAttrib2fARB := GLGetProcAddress('glVertexAttrib2fARB');3514
glVertexAttrib2fvARB := GLGetProcAddress('glVertexAttrib2fvARB');3515
glVertexAttrib2sARB := GLGetProcAddress('glVertexAttrib2sARB');3516
glVertexAttrib2svARB := GLGetProcAddress('glVertexAttrib2svARB');3517
glVertexAttrib3dARB := GLGetProcAddress('glVertexAttrib3dARB');3518
glVertexAttrib3dvARB := GLGetProcAddress('glVertexAttrib3dvARB');3519
glVertexAttrib3fARB := GLGetProcAddress('glVertexAttrib3fARB');3520
glVertexAttrib3fvARB := GLGetProcAddress('glVertexAttrib3fvARB');3521
glVertexAttrib3sARB := GLGetProcAddress('glVertexAttrib3sARB');3522
glVertexAttrib3svARB := GLGetProcAddress('glVertexAttrib3svARB');3523
glVertexAttrib4NbvARB := GLGetProcAddress('glVertexAttrib4NbvARB');3524
glVertexAttrib4NivARB := GLGetProcAddress('glVertexAttrib4NivARB');3525
glVertexAttrib4NsvARB := GLGetProcAddress('glVertexAttrib4NsvARB');3526
glVertexAttrib4NubARB := GLGetProcAddress('glVertexAttrib4NubARB');3527
glVertexAttrib4NubvARB := GLGetProcAddress('glVertexAttrib4NubvARB');3528
glVertexAttrib4NuivARB := GLGetProcAddress('glVertexAttrib4NuivARB');3529
glVertexAttrib4NusvARB := GLGetProcAddress('glVertexAttrib4NusvARB');3530
glVertexAttrib4bvARB := GLGetProcAddress('glVertexAttrib4bvARB');3531
glVertexAttrib4dARB := GLGetProcAddress('glVertexAttrib4dARB');3532
glVertexAttrib4dvARB := GLGetProcAddress('glVertexAttrib4dvARB');3533
glVertexAttrib4fARB := GLGetProcAddress('glVertexAttrib4fARB');3534
glVertexAttrib4fvARB := GLGetProcAddress('glVertexAttrib4fvARB');3535
glVertexAttrib4ivARB := GLGetProcAddress('glVertexAttrib4ivARB');3536
glVertexAttrib4sARB := GLGetProcAddress('glVertexAttrib4sARB');3537
glVertexAttrib4svARB := GLGetProcAddress('glVertexAttrib4svARB');3538
glVertexAttrib4ubvARB := GLGetProcAddress('glVertexAttrib4ubvARB');3539
glVertexAttrib4uivARB := GLGetProcAddress('glVertexAttrib4uivARB');3540
glVertexAttrib4usvARB := GLGetProcAddress('glVertexAttrib4usvARB');3541
glVertexAttribPointerARB := GLGetProcAddress('glVertexAttribPointerARB');3542
glEnableVertexAttribArrayARB := GLGetProcAddress('glEnableVertexAttribArrayARB');3543
glDisableVertexAttribArrayARB := GLGetProcAddress('glDisableVertexAttribArrayARB');3544
glProgramStringARB := GLGetProcAddress('glProgramStringARB');3545
glBindProgramARB := GLGetProcAddress('glBindProgramARB');3546
glDeleteProgramsARB := GLGetProcAddress('glDeleteProgramsARB');3547
glGenProgramsARB := GLGetProcAddress('glGenProgramsARB');3548
glProgramEnvParameter4dARB := GLGetProcAddress('glProgramEnvParameter4dARB');3549
glProgramEnvParameter4dvARB := GLGetProcAddress('glProgramEnvParameter4dvARB');3550
glProgramEnvParameter4fARB := GLGetProcAddress('glProgramEnvParameter4fARB');3551
glProgramEnvParameter4fvARB := GLGetProcAddress('glProgramEnvParameter4fvARB');3552
glProgramLocalParameter4dARB := GLGetProcAddress('glProgramLocalParameter4dARB');3553
glProgramLocalParameter4dvARB := GLGetProcAddress('glProgramLocalParameter4dvARB');3554
glProgramLocalParameter4fARB := GLGetProcAddress('glProgramLocalParameter4fARB');3555
glProgramLocalParameter4fvARB := GLGetProcAddress('glProgramLocalParameter4fvARB');3556
glGetProgramEnvParameterdvARB := GLGetProcAddress('glGetProgramEnvParameterdvARB');3557
glGetProgramEnvParameterfvARB := GLGetProcAddress('glGetProgramEnvParameterfvARB');3558
glGetProgramLocalParameterdvARB := GLGetProcAddress('glGetProgramLocalParameterdvARB');3559
glGetProgramLocalParameterfvARB := GLGetProcAddress('glGetProgramLocalParameterfvARB');3560
glGetProgramivARB := GLGetProcAddress('glGetProgramivARB');3561
glGetProgramStringARB := GLGetProcAddress('glGetProgramStringARB');3562
glGetVertexAttribdvARB := GLGetProcAddress('glGetVertexAttribdvARB');3563
glGetVertexAttribfvARB := GLGetProcAddress('glGetVertexAttribfvARB');3564
glGetVertexAttribivARB := GLGetProcAddress('glGetVertexAttribivARB');3565
glGetVertexAttribPointervARB := GLGetProcAddress('glGetVertexAttribPointervARB');3566
glIsProgramARB := GLGetProcAddress('glIsProgramARB');3568
// GL_ARB_vertex_buffer_object (#28)
3569
glBindBufferARB := GLGetProcAddress('glBindBufferARB');3570
glDeleteBuffersARB := GLGetProcAddress('glDeleteBuffersARB');3571
glGenBuffersARB := GLGetProcAddress('glGenBuffersARB');3572
glIsBufferARB := GLGetProcAddress('glIsBufferARB');3573
glBufferDataARB := GLGetProcAddress('glBufferDataARB');3574
glBufferSubDataARB := GLGetProcAddress('glBufferSubDataARB');3575
glGetBufferSubDataARB := GLGetProcAddress('glGetBufferSubDataARB');3576
glMapBufferARB := GLGetProcAddress('glMapBufferARB');3577
glUnmapBufferARB := GLGetProcAddress('glUnmapBufferARB');3578
glGetBufferParameterivARB := GLGetProcAddress('glGetBufferParameterivARB');3579
glGetBufferPointervARB := GLGetProcAddress('glGetBufferPointervARB');3581
// GL_ARB_occlusion_query (#29)
3582
glGenQueriesARB := GLGetProcAddress('glGenQueriesARB');3583
glDeleteQueriesARB := GLGetProcAddress('glDeleteQueriesARB');3584
glIsQueryARB := GLGetProcAddress('glIsQueryARB');3585
glBeginQueryARB := GLGetProcAddress('glBeginQueryARB');3586
glEndQueryARB := GLGetProcAddress('glEndQueryARB');3587
glGetQueryivARB := GLGetProcAddress('glGetQueryivARB');3588
glGetQueryObjectivARB := GLGetProcAddress('glGetQueryObjectivARB');3589
glGetQueryObjectuivARB := GLGetProcAddress('glGetQueryObjectuivARB');3591
// GL_ARB_shader_objects (#30)
3592
glDeleteObjectARB := GLGetProcAddress('glDeleteObjectARB');3593
glGetHandleARB := GLGetProcAddress('glGetHandleARB');3594
glDetachObjectARB := GLGetProcAddress('glDetachObjectARB');3595
glCreateShaderObjectARB := GLGetProcAddress('glCreateShaderObjectARB');3596
glShaderSourceARB := GLGetProcAddress('glShaderSourceARB');3597
glCompileShaderARB := GLGetProcAddress('glCompileShaderARB');3598
glCreateProgramObjectARB := GLGetProcAddress('glCreateProgramObjectARB');3599
glAttachObjectARB := GLGetProcAddress('glAttachObjectARB');3600
glLinkProgramARB := GLGetProcAddress('glLinkProgramARB');3601
glUseProgramObjectARB := GLGetProcAddress('glUseProgramObjectARB');3602
glValidateProgramARB := GLGetProcAddress('glValidateProgramARB');3603
glUniform1fARB := GLGetProcAddress('glUniform1fARB');3604
glUniform2fARB := GLGetProcAddress('glUniform2fARB');3605
glUniform3fARB := GLGetProcAddress('glUniform3fARB');3606
glUniform4fARB := GLGetProcAddress('glUniform4fARB');3607
glUniform1iARB := GLGetProcAddress('glUniform1iARB');3608
glUniform2iARB := GLGetProcAddress('glUniform2iARB');3609
glUniform3iARB := GLGetProcAddress('glUniform3iARB');3610
glUniform4iARB := GLGetProcAddress('glUniform4iARB');3611
glUniform1fvARB := GLGetProcAddress('glUniform1fvARB');3612
glUniform2fvARB := GLGetProcAddress('glUniform2fvARB');3613
glUniform3fvARB := GLGetProcAddress('glUniform3fvARB');3614
glUniform4fvARB := GLGetProcAddress('glUniform4fvARB');3615
glUniform1ivARB := GLGetProcAddress('glUniform1ivARB');3616
glUniform2ivARB := GLGetProcAddress('glUniform2ivARB');3617
glUniform3ivARB := GLGetProcAddress('glUniform3ivARB');3618
glUniform4ivARB := GLGetProcAddress('glUniform4ivARB');3619
glUniformMatrix2fvARB := GLGetProcAddress('glUniformMatrix2fvARB');3620
glUniformMatrix3fvARB := GLGetProcAddress('glUniformMatrix3fvARB');3621
glUniformMatrix4fvARB := GLGetProcAddress('glUniformMatrix4fvARB');3622
glGetObjectParameterfvARB := GLGetProcAddress('glGetObjectParameterfvARB');3623
glGetObjectParameterivARB := GLGetProcAddress('glGetObjectParameterivARB');3624
glGetInfoLogARB := GLGetProcAddress('glGetInfoLogARB');3625
glGetAttachedObjectsARB := GLGetProcAddress('glGetAttachedObjectsARB');3626
glGetUniformLocationARB := GLGetProcAddress('glGetUniformLocationARB');3627
glGetActiveUniformARB := GLGetProcAddress('glGetActiveUniformARB');3628
glGetUniformfvARB := GLGetProcAddress('glGetUniformfvARB');3629
glGetUniformivARB := GLGetProcAddress('glGetUniformivARB');3630
glGetShaderSourceARB := GLGetProcAddress('glGetShaderSourceARB');3632
// GL_ARB_vertex_shader (#31)
3633
glBindAttribLocationARB := GLGetProcAddress('glBindAttribLocationARB');3634
glGetActiveAttribARB := GLGetProcAddress('glGetActiveAttribARB');3635
glGetAttribLocationARB := GLGetProcAddress('glGetAttribLocationARB');3637
// GL_ARB_draw_buffers (#37)
3638
glDrawBuffersARB := GLGetProcAddress('glDrawBuffersARB');3640
// GL_ARB_color_buffer_float (#39)
3641
glClampColorARB := GLGetProcAddress('glClampColorARB');3643
// GL_ARB_draw_instanced (ARB #44)
3644
glDrawArraysInstancedARB := GLGetProcAddress('glDrawArraysInstancedARB');3645
glDrawElementsInstancedARB := GLGetProcAddress('glDrawElementsInstancedARB');3647
// GL_ARB_framebuffer_object (ARB #45)
3648
glIsRenderbuffer := GLGetProcAddress('glIsRenderbuffer');3649
glBindRenderbuffer := GLGetProcAddress('glBindRenderbuffer');3650
glDeleteRenderbuffers := GLGetProcAddress('glDeleteRenderbuffers');3651
glGenRenderbuffers := GLGetProcAddress('glGenRenderbuffers');3652
glRenderbufferStorage := GLGetProcAddress('glRenderbufferStorage');3653
glRenderbufferStorageMultisample := GLGetProcAddress('glRenderbufferStorageMultisample');3654
glGetRenderbufferParameteriv := GLGetProcAddress('glGetRenderbufferParameteriv');3655
glIsFramebuffer := GLGetProcAddress('glIsFramebuffer');3656
glBindFramebuffer := GLGetProcAddress('glBindFramebuffer');3657
glDeleteFramebuffers := GLGetProcAddress('glDeleteFramebuffers');3658
glGenFramebuffers := GLGetProcAddress('glGenFramebuffers');3659
glCheckFramebufferStatus := GLGetProcAddress('glCheckFramebufferStatus');3660
glFramebufferTexture1D := GLGetProcAddress('glFramebufferTexture1D');3661
glFramebufferTexture2D := GLGetProcAddress('glFramebufferTexture2D');3662
glFramebufferTexture3D := GLGetProcAddress('glFramebufferTexture3D');3663
glFramebufferTextureLayer := GLGetProcAddress('glFramebufferTextureLayer');3664
glFramebufferRenderbuffer := GLGetProcAddress('glFramebufferRenderbuffer');3665
glGetFramebufferAttachmentParameteriv := GLGetProcAddress('glGetFramebufferAttachmentParameteriv');3666
glBlitFramebuffer := GLGetProcAddress('glBlitFramebuffer');3667
glGenerateMipmap := GLGetProcAddress('glGenerateMipmap');3669
// GL_ARB_geometry_shader4 (ARB #47)
3670
glProgramParameteriARB := GLGetProcAddress('glProgramParameteriARB');3671
glFramebufferTextureARB := GLGetProcAddress('glFramebufferTextureARB');3672
glFramebufferTextureLayerARB := GLGetProcAddress('glFramebufferTextureLayerARB');3673
glFramebufferTextureFaceARB := GLGetProcAddress('glFramebufferTextureFaceARB');3675
// GL_ARB_instanced_arrays (ARB #49)
3676
glVertexAttribDivisorARB := GLGetProcAddress('glVertexAttribDivisorARB');3678
// GL_ARB_map_buffer_range (ARB #50)
3679
glMapBufferRange := GLGetProcAddress('glMapBufferRange');3680
glFlushMappedBufferRange := GLGetProcAddress('glFlushMappedBufferRange');3682
// GL_ARB_texture_buffer_object (ARB #51)
3683
glTexBufferARB := GLGetProcAddress('glTexBufferARB');3685
// GL_ARB_vertex_array_object (ARB #54)
3686
glBindVertexArray := GLGetProcAddress('glBindVertexArray');3687
glDeleteVertexArrays := GLGetProcAddress('glDeleteVertexArrays');3688
glGenVertexArrays := GLGetProcAddress('glGenVertexArrays');3689
glIsVertexArray := GLGetProcAddress('glIsVertexArray');3691
// GL_ARB_uniform_buffer_object (ARB #57)
3692
glGetUniformIndices := GLGetProcAddress('glGetUniformIndices');3693
glGetActiveUniformsiv := GLGetProcAddress('glGetActiveUniformsiv');3694
glGetActiveUniformName := GLGetProcAddress('glGetActiveUniformName');3695
glGetUniformBlockIndex := GLGetProcAddress('glGetUniformBlockIndex');3696
glGetActiveUniformBlockiv := GLGetProcAddress('glGetActiveUniformBlockiv');3697
glGetActiveUniformBlockName := GLGetProcAddress('glGetActiveUniformBlockName');3698
glUniformBlockBinding := GLGetProcAddress('glUniformBlockBinding');3700
// GL_ARB_copy_buffer (ARB #59)
3701
glCopyBufferSubData := GLGetProcAddress('glCopyBufferSubData');3703
// GL_ARB_draw_elements_base_vertex (ARB #62)
3704
glDrawElementsBaseVertex := GLGetProcAddress('glDrawElementsBaseVertex');3705
glDrawRangeElementsBaseVertex := GLGetProcAddress('glDrawRangeElementsBaseVertex');3706
glDrawElementsInstancedBaseVertex := GLGetProcAddress('glDrawElementsInstancedBaseVertex');3707
glMultiDrawElementsBaseVertex := GLGetProcAddress('glMultiDrawElementsBaseVertex');3709
// GL_ARB_provoking_vertex (ARB #64)
3710
glProvokingVertex := GLGetProcAddress('glProvokingVertex');3712
// GL_ARB_sync commands (ARB #66)
3713
glFenceSync := GLGetProcAddress('glFenceSync');3714
glIsSync := GLGetProcAddress('glIsSync');3715
glDeleteSync := GLGetProcAddress('glDeleteSync');3716
glClientWaitSync := GLGetProcAddress('glClientWaitSync');3717
glWaitSync := GLGetProcAddress('glWaitSync');3718
glGetInteger64v := GLGetProcAddress('glGetInteger64v');3719
glGetSynciv := GLGetProcAddress('glGetSynciv');3721
// GL_ARB_texture_multisample (ARB #67)
3722
glTexImage2DMultisample := GLGetProcAddress('glTexImage2DMultisample');3723
glTexImage3DMultisample := GLGetProcAddress('glTexImage3DMultisample');3724
glGetMultisamplefv := GLGetProcAddress('glGetMultisamplefv');3725
glSampleMaski := GLGetProcAddress('glSampleMaski');3727
// GL_ARB_draw_buffers_blend (ARB #69)
3728
glBlendEquationiARB := GLGetProcAddress('glBlendEquationiARB');3729
glBlendEquationSeparateiARB := GLGetProcAddress('glBlendEquationSeparateiARB');3730
glBlendFunciARB := GLGetProcAddress('glBlendFunciARB');3731
glBlendFuncSeparateiARB := GLGetProcAddress('glBlendFuncSeparateiARB');3733
// GL_ARB_sample_shading (ARB #70)
3734
glMinSampleShadingARB := GLGetProcAddress('glMinSampleShadingARB');3736
// GL_ARB_blend_func_extended (ARB #78)
3737
glBindFragDataLocationIndexed := GLGetProcAddress('glBindFragDataLocationIndexed');3738
glGetFragDataIndex := GLGetProcAddress('glGetFragDataIndex');3740
// GL_ARB_sampler_objects (ARB #81)
3741
glGenSamplers := GLGetProcAddress('glGenSamplers');3742
glDeleteSamplers := GLGetProcAddress('glDeleteSamplers');3743
glIsSampler := GLGetProcAddress('glIsSampler');3744
glBindSampler := GLGetProcAddress('glBindSampler');3745
glSamplerParameteri := GLGetProcAddress('glSamplerParameteri');3746
glSamplerParameteriv := GLGetProcAddress('glSamplerParameteriv');3747
glSamplerParameterf := GLGetProcAddress('glSamplerParameterf');3748
glSamplerParameterfv := GLGetProcAddress('glSamplerParameterfv');3749
glSamplerParameterIiv := GLGetProcAddress('glSamplerParameterIiv');3750
glSamplerParameterIuiv := GLGetProcAddress('glSamplerParameterIuiv');3751
glGetSamplerParameteriv := GLGetProcAddress('glGetSamplerParameteriv');3752
glGetSamplerParameterIiv := GLGetProcAddress('glGetSamplerParameterIiv');3753
glGetSamplerParameterfv := GLGetProcAddress('glGetSamplerParameterfv');3754
glGetSamplerParameterIfv := GLGetProcAddress('glGetSamplerParameterIfv');3756
// GL_ARB_timer_query (ARB #85)
3757
glQueryCounter := GLGetProcAddress('glQueryCounter');3758
glGetQueryObjecti64v := GLGetProcAddress('glGetQueryObjecti64v');3759
glGetQueryObjectui64v := GLGetProcAddress('glGetQueryObjectui64v');3761
// GL_ARB_vertex_type_2_10_10_10_rev (ARB #86)
3762
glVertexP2ui := GLGetProcAddress('glVertexP2ui');3763
glVertexP2uiv := GLGetProcAddress('glVertexP2uiv');3764
glVertexP3ui := GLGetProcAddress('glVertexP3ui');3765
glVertexP3uiv := GLGetProcAddress('glVertexP3uiv');3766
glVertexP4ui := GLGetProcAddress('glVertexP4ui');3767
glVertexP4uiv := GLGetProcAddress('glVertexP4uiv');3768
glTexCoordP1ui := GLGetProcAddress('glTexCoordP1ui');3769
glTexCoordP1uiv := GLGetProcAddress('glTexCoordP1uiv');3770
glTexCoordP2ui := GLGetProcAddress('glTexCoordP2ui');3771
glTexCoordP2uiv := GLGetProcAddress('glTexCoordP2uiv');3772
glTexCoordP3ui := GLGetProcAddress('glTexCoordP3ui');3773
glTexCoordP3uiv := GLGetProcAddress('glTexCoordP3uiv');3774
glTexCoordP4ui := GLGetProcAddress('glTexCoordP4ui');3775
glTexCoordP4uiv := GLGetProcAddress('glTexCoordP4uiv');3776
glMultiTexCoordP1ui := GLGetProcAddress('glMultiTexCoordP1ui');3777
glMultiTexCoordP1uiv := GLGetProcAddress('glMultiTexCoordP1uiv');3778
glMultiTexCoordP2ui := GLGetProcAddress('glMultiTexCoordP2ui');3779
glMultiTexCoordP2uiv := GLGetProcAddress('glMultiTexCoordP2uiv');3780
glMultiTexCoordP3ui := GLGetProcAddress('glMultiTexCoordP3ui');3781
glMultiTexCoordP3uiv := GLGetProcAddress('glMultiTexCoordP3uiv');3782
glMultiTexCoordP4ui := GLGetProcAddress('glMultiTexCoordP4ui');3783
glMultiTexCoordP4uiv := GLGetProcAddress('glMultiTexCoordP4uiv');3784
glNormalP3ui := GLGetProcAddress('glNormalP3ui');3785
glNormalP3uiv := GLGetProcAddress('glNormalP3uiv');3786
glColorP3ui := GLGetProcAddress('glColorP3ui');3787
glColorP3uiv := GLGetProcAddress('glColorP3uiv');3788
glColorP4ui := GLGetProcAddress('glColorP4ui');3789
glColorP4uiv := GLGetProcAddress('glColorP4uiv');3790
glSecondaryColorP3ui := GLGetProcAddress('glSecondaryColorP3ui');3791
glSecondaryColorP3uiv := GLGetProcAddress('glSecondaryColorP3uiv');3792
glVertexAttribP1ui := GLGetProcAddress('glVertexAttribP1ui');3793
glVertexAttribP1uiv := GLGetProcAddress('glVertexAttribP1uiv');3794
glVertexAttribP2ui := GLGetProcAddress('glVertexAttribP2ui');3795
glVertexAttribP2uiv := GLGetProcAddress('glVertexAttribP2uiv');3796
glVertexAttribP3ui := GLGetProcAddress('glVertexAttribP3ui');3797
glVertexAttribP3uiv := GLGetProcAddress('glVertexAttribP3uiv');3798
glVertexAttribP4ui := GLGetProcAddress('glVertexAttribP4ui');3799
glVertexAttribP4uiv := GLGetProcAddress('glVertexAttribP4uiv');3801
// GL_ARB_draw_indirect (ARB #87)
3802
glDrawArraysIndirect := GLGetProcAddress('glDrawArraysIndirect');3803
glDrawElementsIndirect := GLGetProcAddress('glDrawElementsIndirect');3805
// GL_ARB_gpu_shader_fp64 (ARB #89)
3806
glUniform1d := GLGetProcAddress('glUniform1d');3807
glUniform2d := GLGetProcAddress('glUniform2d');3808
glUniform3d := GLGetProcAddress('glUniform3d');3809
glUniform4d := GLGetProcAddress('glUniform4d');3810
glUniform1dv := GLGetProcAddress('glUniform1dv');3811
glUniform2dv := GLGetProcAddress('glUniform2dv');3812
glUniform3dv := GLGetProcAddress('glUniform3dv');3813
glUniform4dv := GLGetProcAddress('glUniform4dv');3814
glUniformMatrix2dv := GLGetProcAddress('glUniformMatrix2dv');3815
glUniformMatrix3dv := GLGetProcAddress('glUniformMatrix3dv');3816
glUniformMatrix4dv := GLGetProcAddress('glUniformMatrix4dv');3817
glUniformMatrix2x3dv := GLGetProcAddress('glUniformMatrix2x3dv');3818
glUniformMatrix2x4dv := GLGetProcAddress('glUniformMatrix2x4dv');3819
glUniformMatrix3x2dv := GLGetProcAddress('glUniformMatrix3x2dv');3820
glUniformMatrix3x4dv := GLGetProcAddress('glUniformMatrix3x4dv');3821
glUniformMatrix4x2dv := GLGetProcAddress('glUniformMatrix4x2dv');3822
glUniformMatrix4x3dv := GLGetProcAddress('glUniformMatrix4x3dv');3823
glGetUniformdv := GLGetProcAddress('glGetUniformdv');3824
glProgramUniform1dEXT := GLGetProcAddress('glProgramUniform1dEXT');3825
glProgramUniform2dEXT := GLGetProcAddress('glProgramUniform2dEXT');3826
glProgramUniform3dEXT := GLGetProcAddress('glProgramUniform3dEXT');3827
glProgramUniform4dEXT := GLGetProcAddress('glProgramUniform4dEXT');3828
glProgramUniform1dvEXT := GLGetProcAddress('glProgramUniform1dvEXT');3829
glProgramUniform2dvEXT := GLGetProcAddress('glProgramUniform2dvEXT');3830
glProgramUniform3dvEXT := GLGetProcAddress('glProgramUniform3dvEXT');3831
glProgramUniform4dvEXT := GLGetProcAddress('glProgramUniform4dvEXT');3832
glProgramUniformMatrix2dvEXT := GLGetProcAddress('glProgramUniformMatrix2dvEXT');3833
glProgramUniformMatrix3dvEXT := GLGetProcAddress('glProgramUniformMatrix3dvEXT');3834
glProgramUniformMatrix4dvEXT := GLGetProcAddress('glProgramUniformMatrix4dvEXT');3835
glProgramUniformMatrix2x3dvEXT := GLGetProcAddress('glProgramUniformMatrix2x3dvEXT');3836
glProgramUniformMatrix2x4dvEXT := GLGetProcAddress('glProgramUniformMatrix2x4dvEXT');3837
glProgramUniformMatrix3x2dvEXT := GLGetProcAddress('glProgramUniformMatrix3x2dvEXT');3838
glProgramUniformMatrix3x4dvEXT := GLGetProcAddress('glProgramUniformMatrix3x4dvEXT');3839
glProgramUniformMatrix4x2dvEXT := GLGetProcAddress('glProgramUniformMatrix4x2dvEXT');3840
glProgramUniformMatrix4x3dvEXT := GLGetProcAddress('glProgramUniformMatrix4x3dvEXT');3842
// GL_ARB_shader_subroutine (ARB #90)
3843
glGetSubroutineUniformLocation := GLGetProcAddress('glGetSubroutineUniformLocation');3844
glGetSubroutineIndex := GLGetProcAddress('glGetSubroutineIndex');3845
glGetActiveSubroutineUniformiv := GLGetProcAddress('glGetActiveSubroutineUniformiv');3846
glGetActiveSubroutineUniformName := GLGetProcAddress('glGetActiveSubroutineUniformName');3847
glGetActiveSubroutineName := GLGetProcAddress('glGetActiveSubroutineName');3848
glUniformSubroutinesuiv := GLGetProcAddress('glUniformSubroutinesuiv');3849
glGetUniformSubroutineuiv := GLGetProcAddress('glGetUniformSubroutineuiv');3850
glGetProgramStageiv := GLGetProcAddress('glGetProgramStageiv');3852
// GL_ARB_tessellation_shader (ARB #91)
3853
glPatchParameteri := GLGetProcAddress('glPatchParameteri');3854
glPatchParameterfv := GLGetProcAddress('glPatchParameterfv');3856
// GL_ARB_transform_feedback2 (ARB #93)
3857
glBindTransformFeedback := GLGetProcAddress('glBindTransformFeedback');3858
glDeleteTransformFeedbacks := GLGetProcAddress('glDeleteTransformFeedbacks');3859
glGenTransformFeedbacks := GLGetProcAddress('glGenTransformFeedbacks');3860
glIsTransformFeedback := GLGetProcAddress('glIsTransformFeedback');3861
glPauseTransformFeedback := GLGetProcAddress('glPauseTransformFeedback');3862
glResumeTransformFeedback := GLGetProcAddress('glResumeTransformFeedback');3863
glDrawTransformFeedback := GLGetProcAddress('glDrawTransformFeedback');3865
// GL_ARB_transform_feedback3 (ARB # 94)
3866
glDrawTransformFeedbackStream := GLGetProcAddress('glDrawTransformFeedbackStream');3867
glBeginQueryIndexed := GLGetProcAddress('glBeginQueryIndexed');3868
glEndQueryIndexed := GLGetProcAddress('glEndQueryIndexed');3869
glGetQueryIndexediv := GLGetProcAddress('glGetQueryIndexediv');3871
// GL_ARB_ES2_compatibility (ARB #95)
3872
glReleaseShaderCompiler := GLGetProcAddress('glReleaseShaderCompiler');3873
glShaderBinary := GLGetProcAddress('glShaderBinary');3874
glGetShaderPrecisionFormat := GLGetProcAddress('glGetShaderPrecisionFormat');3875
glDepthRangef := GLGetProcAddress('glDepthRangef');3876
glClearDepthf := GLGetProcAddress('glClearDepthf');3878
// GL_ARB_get_program_binary (ARB #96)
3879
glGetProgramBinary := GLGetProcAddress('glGetProgramBinary');3880
glProgramBinary := GLGetProcAddress('glProgramBinary');3881
glProgramParameteri := GLGetProcAddress('glProgramParameteri');3883
// GL_ARB_separate_shader_objects (ARB #97)
3884
glUseProgramStages := GLGetProcAddress('glUseProgramStages');3885
glActiveShaderProgram := GLGetProcAddress('glActiveShaderProgram');3886
glCreateShaderProgramv := GLGetProcAddress('glCreateShaderProgramv');3887
glBindProgramPipeline := GLGetProcAddress('glBindProgramPipeline');3888
glDeleteProgramPipelines := GLGetProcAddress('glDeleteProgramPipelines');3889
glGenProgramPipelines := GLGetProcAddress('glGenProgramPipelines');3890
glIsProgramPipeline := GLGetProcAddress('glIsProgramPipeline');3891
glGetProgramPipelineiv := GLGetProcAddress('glGetProgramPipelineiv');3892
glProgramUniform1i := GLGetProcAddress('glProgramUniform1i');3893
glProgramUniform1iv := GLGetProcAddress('glProgramUniform1iv');3894
glProgramUniform1f := GLGetProcAddress('glProgramUniform1f');3895
glProgramUniform1fv := GLGetProcAddress('glProgramUniform1fv');3896
glProgramUniform1d := GLGetProcAddress('glProgramUniform1d');3897
glProgramUniform1dv := GLGetProcAddress('glProgramUniform1dv');3898
glProgramUniform1ui := GLGetProcAddress('glProgramUniform1ui');3899
glProgramUniform1uiv := GLGetProcAddress('glProgramUniform1uiv');3900
glProgramUniform2i := GLGetProcAddress('glProgramUniform2i');3901
glProgramUniform2iv := GLGetProcAddress('glProgramUniform2iv');3902
glProgramUniform2f := GLGetProcAddress('glProgramUniform2f');3903
glProgramUniform2fv := GLGetProcAddress('glProgramUniform2fv');3904
glProgramUniform2d := GLGetProcAddress('glProgramUniform2d');3905
glProgramUniform2dv := GLGetProcAddress('glProgramUniform2dv');3906
glProgramUniform2ui := GLGetProcAddress('glProgramUniform2ui');3907
glProgramUniform2uiv := GLGetProcAddress('glProgramUniform2uiv');3908
glProgramUniform3i := GLGetProcAddress('glProgramUniform3i');3909
glProgramUniform3iv := GLGetProcAddress('glProgramUniform3iv');3910
glProgramUniform3f := GLGetProcAddress('glProgramUniform3f');3911
glProgramUniform3fv := GLGetProcAddress('glProgramUniform3fv');3912
glProgramUniform3d := GLGetProcAddress('glProgramUniform3d');3913
glProgramUniform3dv := GLGetProcAddress('glProgramUniform3dv');3914
glProgramUniform3ui := GLGetProcAddress('glProgramUniform3ui');3915
glProgramUniform3uiv := GLGetProcAddress('glProgramUniform3uiv');3916
glProgramUniform4i := GLGetProcAddress('glProgramUniform4i');3917
glProgramUniform4iv := GLGetProcAddress('glProgramUniform4iv');3918
glProgramUniform4f := GLGetProcAddress('glProgramUniform4f');3919
glProgramUniform4fv := GLGetProcAddress('glProgramUniform4fv');3920
glProgramUniform4d := GLGetProcAddress('glProgramUniform4d');3921
glProgramUniform4dv := GLGetProcAddress('glProgramUniform4dv');3922
glProgramUniform4ui := GLGetProcAddress('glProgramUniform4ui');3923
glProgramUniform4uiv := GLGetProcAddress('glProgramUniform4uiv');3924
glProgramUniformMatrix2fv := GLGetProcAddress('glProgramUniformMatrix2fv');3925
glProgramUniformMatrix3fv := GLGetProcAddress('glProgramUniformMatrix3fv');3926
glProgramUniformMatrix4fv := GLGetProcAddress('glProgramUniformMatrix4fv');3927
glProgramUniformMatrix2dv := GLGetProcAddress('glProgramUniformMatrix2dv');3928
glProgramUniformMatrix3dv := GLGetProcAddress('glProgramUniformMatrix3dv');3929
glProgramUniformMatrix4dv := GLGetProcAddress('glProgramUniformMatrix4dv');3930
glProgramUniformMatrix2x3fv := GLGetProcAddress('glProgramUniformMatrix2x3fv');3931
glProgramUniformMatrix3x2fv := GLGetProcAddress('glProgramUniformMatrix3x2fv');3932
glProgramUniformMatrix2x4fv := GLGetProcAddress('glProgramUniformMatrix2x4fv');3933
glProgramUniformMatrix4x2fv := GLGetProcAddress('glProgramUniformMatrix4x2fv');3934
glProgramUniformMatrix3x4fv := GLGetProcAddress('glProgramUniformMatrix3x4fv');3935
glProgramUniformMatrix4x3fv := GLGetProcAddress('glProgramUniformMatrix4x3fv');3936
glProgramUniformMatrix2x3dv := GLGetProcAddress('glProgramUniformMatrix2x3dv');3937
glProgramUniformMatrix3x2dv := GLGetProcAddress('glProgramUniformMatrix3x2dv');3938
glProgramUniformMatrix2x4dv := GLGetProcAddress('glProgramUniformMatrix2x4dv');3939
glProgramUniformMatrix4x2dv := GLGetProcAddress('glProgramUniformMatrix4x2dv');3940
glProgramUniformMatrix3x4dv := GLGetProcAddress('glProgramUniformMatrix3x4dv');3941
glProgramUniformMatrix4x3dv := GLGetProcAddress('glProgramUniformMatrix4x3dv');3942
glValidateProgramPipeline := GLGetProcAddress('glValidateProgramPipeline');3943
glGetProgramPipelineInfoLog := GLGetProcAddress('glGetProgramPipelineInfoLog');3945
// GL_ARB_shader_precision (ARB #98)
3946
// (no entry points)
3948
// GL_ARB_vertex_attrib_64bit (ARB #99)
3949
glVertexAttribL1d := GLGetProcAddress('glVertexAttribL1d');3950
glVertexAttribL2d := GLGetProcAddress('glVertexAttribL2d');3951
glVertexAttribL3d := GLGetProcAddress('glVertexAttribL3d');3952
glVertexAttribL4d := GLGetProcAddress('glVertexAttribL4d');3953
glVertexAttribL1dv := GLGetProcAddress('glVertexAttribL1dv');3954
glVertexAttribL2dv := GLGetProcAddress('glVertexAttribL2dv');3955
glVertexAttribL3dv := GLGetProcAddress('glVertexAttribL3dv');3956
glVertexAttribL4dv := GLGetProcAddress('glVertexAttribL4dv');3957
glVertexAttribLPointer := GLGetProcAddress('glVertexAttribLPointer');3958
glGetVertexAttribLdv := GLGetProcAddress('glGetVertexAttribLdv');3959
// glVertexArrayVertexAttribLOffsetEXT is only valid if EXT_direct_state_access is available
3960
glVertexArrayVertexAttribLOffsetEXT := GLGetProcAddress('glVertexArrayVertexAttribLOffsetEXT');3962
// GL_ARB_viewport_array (ARB #100)
3963
glViewportArrayv := GLGetProcAddress('glViewportArrayv');3964
glViewportIndexedf := GLGetProcAddress('glViewportIndexedf');3965
glViewportIndexedfv := GLGetProcAddress('glViewportIndexedfv');3966
glScissorArrayv := GLGetProcAddress('glScissorArrayv');3967
glScissorIndexed := GLGetProcAddress('glScissorIndexed');3968
glScissorIndexedv := GLGetProcAddress('glScissorIndexedv');3969
glDepthRangeArrayv := GLGetProcAddress('glDepthRangeArrayv');3970
glDepthRangeIndexed := GLGetProcAddress('glDepthRangeIndexed');3971
glGetFloati_v := GLGetProcAddress('glGetFloati_v');3972
glGetDoublei_v := GLGetProcAddress('glGetDoublei_v');3974
// GL_ARB_debug_output (ARB #104)
3975
glDebugMessageControlARB := GLGetProcAddress('glDebugMessageControlARB');3976
glDebugMessageInsertARB := GLGetProcAddress('glDebugMessageInsertARB');3977
glDebugMessageCallbackARB := GLGetProcAddress('glDebugMessageCallbackARB');3978
glGetDebugMessageLogARB := GLGetProcAddress('glGetDebugMessageLogARB');3980
// GL_ARB_robustness (ARB #105)
3981
glGetGraphicsResetStatusARB := GLGetProcAddress('glGetGraphicsResetStatusARB');3982
glGetnMapdvARB := GLGetProcAddress('glGetnMapdvARB');3983
glGetnMapfvARB := GLGetProcAddress('glGetnMapfvARB');3984
glGetnMapivARB := GLGetProcAddress('glGetnMapivARB');3985
glGetnPixelMapfvARB := GLGetProcAddress('glGetnPixelMapfvARB');3986
glGetnPixelMapuivARB := GLGetProcAddress('glGetnPixelMapuivARB');3987
glGetnPixelMapusvARB := GLGetProcAddress('glGetnPixelMapusvARB');3988
glGetnPolygonStippleARB := GLGetProcAddress('glGetnPolygonStippleARB');3989
glGetnColorTableARB := GLGetProcAddress('glGetnColorTableARB');3990
glGetnConvolutionFilterARB := GLGetProcAddress('glGetnConvolutionFilterARB');3991
glGetnSeparableFilterARB := GLGetProcAddress('glGetnSeparableFilterARB');3992
glGetnHistogramARB := GLGetProcAddress('glGetnHistogramARB');3993
glGetnMinmaxARB := GLGetProcAddress('glGetnMinmaxARB');3994
glGetnTexImageARB := GLGetProcAddress('glGetnTexImageARB');3995
glReadnPixelsARB := GLGetProcAddress('glReadnPixelsARB');3996
glGetnCompressedTexImageARB := GLGetProcAddress('glGetnCompressedTexImageARB');3997
glGetnUniformfvARB := GLGetProcAddress('glGetnUniformfvARB');3998
glGetnUniformivARB := GLGetProcAddress('glGetnUniformivARB');3999
glGetnUniformuivARB := GLGetProcAddress('glGetnUniformuivARB');4000
glGetnUniformdvARB := GLGetProcAddress('glGetnUniformdvARB');4002
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}4004
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures for Vendor/EXT extensions'} {$ENDIF}4006
// ###########################################################
4007
// locate functions and procedures for
4008
// Vendor/EXT extensions
4009
// ###########################################################
4011
// functions/procedures belonging to unknown extensions
4012
glSamplePassARB := GLGetProcAddress('glSamplePassARB');4013
glArrayElementArrayEXT := GLGetProcAddress('glArrayElementArrayEXT');4015
// WIN_swap_hint (extension # not found)
4016
glAddSwapHintRectWIN := GLGetProcAddress('glAddSwapHintRectWIN');4018
// GL_EXT_blend_color (#2)
4019
glBlendColorEXT := GLGetProcAddress('glBlendColorEXT');4021
// GL_EXT_polygon_offset (#3)
4022
glPolygonOffsetEXT := GLGetProcAddress('glPolygonOffsetEXT');4024
// GL_EXT_texture3D (#6)
4025
glTexImage3DEXT := GLGetProcAddress('glTexImage3DEXT');4027
// GL_EXT_subtexture (#9)
4028
glTexSubImage1dEXT := GLGetProcAddress('glTexSubImage1DEXT');4029
glTexSubImage2dEXT := GLGetProcAddress('glTexSubImage2DEXT');4030
glTexSubImage3dEXT := GLGetProcAddress('glTexSubImage3DEXT');4032
// GL_EXT_copy_texture (#10)
4033
glCopyTexImage1DEXT := GLGetProcAddress('glCopyTexImage1DEXT');4034
glCopyTexImage2DEXT := GLGetProcAddress('glCopyTexImage2DEXT');4035
glCopyTexSubImage1DEXT := GLGetProcAddress('glCopyTexSubImage1DEXT');4036
glCopyTexSubImage2DEXT := GLGetProcAddress('glCopyTexSubImage2DEXT');4037
glCopyTexSubImage3DEXT := GLGetProcAddress('glCopyTexSubImage3DEXT');4039
// GL_EXT_texture_object (#20)
4040
glGenTexturesEXT := GLGetProcAddress('glGenTexturesEXT');4041
glDeleteTexturesEXT := GLGetProcAddress('glDeleteTexturesEXT');4042
glBindTextureEXT := GLGetProcAddress('glBindTextureEXT');4043
glPrioritizeTexturesEXT := GLGetProcAddress('glPrioritizeTexturesEXT');4044
glAreTexturesResidentEXT := GLGetProcAddress('glAreTexturesResidentEXT');4045
glIsTextureEXT := GLGetProcAddress('glIsTextureEXT');4047
// GL_SGIS_multisample (#25)
4048
glSampleMaskSGIS := GLGetProcAddress('glSampleMaskSGIS');4049
glSamplePatternSGIS := GLGetProcAddress('glSamplePatternSGIS');4051
// GL_EXT_blend_minmax (#37)
4052
glBlendEquationEXT := GLGetProcAddress('glBlendEquationEXT');4054
// GL_EXT_paletted_texture (#78)
4055
glColorTableEXT := GLGetProcAddress('glColorTableEXT');4056
glColorSubTableEXT := GLGetProcAddress('glColorSubTableEXT');4057
glGetColorTableEXT := GLGetProcAddress('glGetColorTableEXT');4058
glGetColorTableParameterivEXT := GLGetProcAddress('glGetColorTableParameterivEXT');4059
glGetColorTableParameterfvEXT := GLGetProcAddress('glGetColorTableParameterfvEXT');4061
// GL_EXT_index_material (#94)
4062
glIndexMaterialEXT := GLGetProcAddress('glIndexMaterialEXT');4064
// GL_EXT_index_func (#95)
4065
glIndexFuncEXT := GLGetProcAddress('glIndexFuncEXT');4067
// EXT_compiled_vertex_array (#97)
4068
glLockArraysEXT := GLGetProcAddress('glLockArraysEXT');4069
glUnlockArraysEXT := GLGetProcAddress('glUnlockArraysEXT');4071
// GL_EXT_draw_range_elements (#112)
4072
glDrawRangeElementsEXT := GLGetProcAddress('glDrawRangeElementsEXT');4074
// GL_EXT_secondary_color (#145)
4075
glSecondaryColor3bEXT := GLGetProcAddress('glSecondaryColor3bEXT');4076
glSecondaryColor3bvEXT := GLGetProcAddress('glSecondaryColor3bvEXT');4077
glSecondaryColor3dEXT := GLGetProcAddress('glSecondaryColor3dEXT');4078
glSecondaryColor3dvEXT := GLGetProcAddress('glSecondaryColor3dvEXT');4079
glSecondaryColor3fEXT := GLGetProcAddress('glSecondaryColor3fEXT');4080
glSecondaryColor3fvEXT := GLGetProcAddress('glSecondaryColor3fvEXT');4081
glSecondaryColor3iEXT := GLGetProcAddress('glSecondaryColor3iEXT');4082
glSecondaryColor3ivEXT := GLGetProcAddress('glSecondaryColor3ivEXT');4083
glSecondaryColor3sEXT := GLGetProcAddress('glSecondaryColor3sEXT');4084
glSecondaryColor3svEXT := GLGetProcAddress('glSecondaryColor3svEXT');4085
glSecondaryColor3ubEXT := GLGetProcAddress('glSecondaryColor3ubEXT');4086
glSecondaryColor3ubvEXT := GLGetProcAddress('glSecondaryColor3ubvEXT');4087
glSecondaryColor3uiEXT := GLGetProcAddress('glSecondaryColor3uiEXT');4088
glSecondaryColor3uivEXT := GLGetProcAddress('glSecondaryColor3uivEXT');4089
glSecondaryColor3usEXT := GLGetProcAddress('glSecondaryColor3usEXT');4090
glSecondaryColor3usvEXT := GLGetProcAddress('glSecondaryColor3usvEXT');4091
glSecondaryColorPointerEXT := GLGetProcAddress('glSecondaryColorPointerEXT');4093
// GL_EXT_multi_draw_arrays (#148)
4094
glMultiDrawArraysEXT := GLGetProcAddress('glMultiDrawArraysEXT');4095
glMultiDrawElementsEXT := GLGetProcAddress('glMultiDrawElementsEXT');4097
// GL_EXT_fog_coord (#149)
4098
glFogCoordfEXT := GLGetProcAddress('glFogCoordfEXT'); 4099
glFogCoordfvEXT := GLGetProcAddress('glFogCoordfvEXT'); 4100
glFogCoorddEXT := GLGetProcAddress('glFogCoorddEXT');4101
glFogCoorddvEXT := GLGetProcAddress('glFogCoorddvEXT'); 4102
glFogCoordPointerEXT := GLGetProcAddress('glFogCoordPointerEXT'); 4104
// GL_EXT_blend_func_separate (#173)
4105
glBlendFuncSeparateEXT := GLGetProcAddress('glBlendFuncSeparateEXT');4107
// GL_NV_vertex_array_range (#190)
4108
glFlushVertexArrayRangeNV := GLGetProcAddress('glFlushVertexArrayRangeNV'); 4109
glVertexArrayRangeNV := GLGetProcAddress('glVertexArrayRangeNV');4110
wglAllocateMemoryNV := GLGetProcAddress('wglAllocateMemoryNV'); 4111
wglFreeMemoryNV := GLGetProcAddress('wglFreeMemoryNV'); 4113
// GL_NV_register_combiners (#191)
4114
glCombinerParameterfvNV := GLGetProcAddress('glCombinerParameterfvNV'); 4115
glCombinerParameterfNV := GLGetProcAddress('glCombinerParameterfNV');4116
glCombinerParameterivNV := GLGetProcAddress('glCombinerParameterivNV'); 4117
glCombinerParameteriNV := GLGetProcAddress('glCombinerParameteriNV'); 4118
glCombinerInputNV := GLGetProcAddress('glCombinerInputNV');4119
glCombinerOutputNV := GLGetProcAddress('glCombinerOutputNV'); 4120
glFinalCombinerInputNV := GLGetProcAddress('glFinalCombinerInputNV');4121
glGetCombinerInputParameterfvNV := GLGetProcAddress('glGetCombinerInputParameterfvNV');4122
glGetCombinerInputParameterivNV := GLGetProcAddress('glGetCombinerInputParameterivNV'); 4123
glGetCombinerOutputParameterfvNV := GLGetProcAddress('glGetCombinerOutputParameterfvNV');4124
glGetCombinerOutputParameterivNV := GLGetProcAddress('glGetCombinerOutputParameterivNV');4125
glGetFinalCombinerInputParameterfvNV := GLGetProcAddress('glGetFinalCombinerInputParameterfvNV'); 4126
glGetFinalCombinerInputParameterivNV := GLGetProcAddress('glGetFinalCombinerInputParameterivNV');4128
// GL_MESA_resize_buffers (#196)
4129
glResizeBuffersMESA := GLGetProcAddress('glResizeBuffersMESA');4131
// GL_3DFX_tbuffer (#208)
4132
glTbufferMask3DFX := GLGetProcAddress('glTbufferMask3DFX');4134
// GL_EXT_multisample (#209)
4135
glSampleMaskEXT := GLGetProcAddress('glSampleMaskEXT');4136
glSamplePatternEXT := GLGetProcAddress('glSamplePatternEXT');4138
// GL_SGIS_texture_color_mask (#214)
4139
glTextureColorMaskSGIS := GLGetProcAddress('glTextureColorMaskSGIS');4141
// GL_NV_fence (#222)
4142
glGenFencesNV := GLGetProcAddress('glGenFencesNV');4143
glDeleteFencesNV := GLGetProcAddress('glDeleteFencesNV');4144
glSetFenceNV := GLGetProcAddress('glSetFenceNV');4145
glTestFenceNV := GLGetProcAddress('glTestFenceNV');4146
glFinishFenceNV := GLGetProcAddress('glFinishFenceNV');4147
glIsFenceNV := GLGetProcAddress('glIsFenceNV');4148
glGetFenceivNV := GLGetProcAddress('glGetFenceivNV');4150
// GL_NV_vertex_program (#233)
4151
glAreProgramsResidentNV := GLGetProcAddress('glAreProgramsResidentNV');4152
glBindProgramNV := GLGetProcAddress('glBindProgramNV');4153
glDeleteProgramsNV := GLGetProcAddress('glDeleteProgramsNV');4154
glExecuteProgramNV := GLGetProcAddress('glExecuteProgramNV');4155
glGenProgramsNV := GLGetProcAddress('glGenProgramsNV');4156
glGetProgramParameterdvNV := GLGetProcAddress('glGetProgramParameterdvNV');4157
glGetProgramParameterfvNV := GLGetProcAddress('glGetProgramParameterfvNV');4158
glGetProgramivNV := GLGetProcAddress('glGetProgramivNV');4159
glGetProgramStringNV := GLGetProcAddress('glGetProgramStringNV');4160
glGetTrackMatrixivNV := GLGetProcAddress('glGetTrackMatrixivNV');4161
glGetVertexAttribdvNV:= GLGetProcAddress('glGetVertexAttribdvNV');4162
glGetVertexAttribfvNV:= GLGetProcAddress('glGetVertexAttribfvNV');4163
glGetVertexAttribivNV:= GLGetProcAddress('glGetVertexAttribivNV');4164
glGetVertexAttribPointervNV := GLGetProcAddress ('glGetVertexAttribPointervNV');4165
glIsProgramNV := GLGetProcAddress('glIsProgramNV');4166
glLoadProgramNV := GLGetProcAddress('glLoadProgramNV');4167
glProgramParameter4dNV := GLGetProcAddress('glProgramParameter4dNV');4168
glProgramParameter4dvNV := GLGetProcAddress('glProgramParameter4dvNV');4169
glProgramParameter4fNV := GLGetProcAddress('glProgramParameter4fNV');4170
glProgramParameter4fvNV := GLGetProcAddress('glProgramParameter4fvNV');4171
glProgramParameters4dvNV := GLGetProcAddress ('glProgramParameters4dvNV');4172
glProgramParameters4fvNV := GLGetProcAddress ('glProgramParameters4fvNV');4173
glRequestResidentProgramsNV := GLGetProcAddress ('glRequestResidentProgramsNV');4174
glTrackMatrixNV := GLGetProcAddress('glTrackMatrixNV');4175
glVertexAttribPointerNV := GLGetProcAddress('glVertexAttribPointerNV');4176
glVertexAttrib1dNV := GLGetProcAddress('glVertexAttrib1dNV');4177
glVertexAttrib1dvNV := GLGetProcAddress('glVertexAttrib1dvNV');4178
glVertexAttrib1fNV := GLGetProcAddress('glVertexAttrib1fNV');4179
glVertexAttrib1fvNV := GLGetProcAddress('glVertexAttrib1fvNV');4180
glVertexAttrib1sNV := GLGetProcAddress('glVertexAttrib1sNV');4181
glVertexAttrib1svNV := GLGetProcAddress('glVertexAttrib1svNV');4182
glVertexAttrib2dNV := GLGetProcAddress('glVertexAttrib2dNV');4183
glVertexAttrib2dvNV := GLGetProcAddress('glVertexAttrib2dvNV');4184
glVertexAttrib2fNV := GLGetProcAddress('glVertexAttrib2fNV');4185
glVertexAttrib2fvNV := GLGetProcAddress('glVertexAttrib2fvNV');4186
glVertexAttrib2sNV := GLGetProcAddress('glVertexAttrib2sNV');4187
glVertexAttrib2svNV := GLGetProcAddress('glVertexAttrib2svNV');4188
glVertexAttrib3dNV := GLGetProcAddress('glVertexAttrib3dNV');4189
glVertexAttrib3dvNV := GLGetProcAddress('glVertexAttrib3dvNV');4190
glVertexAttrib3fNV := GLGetProcAddress('glVertexAttrib3fNV');4191
glVertexAttrib3fvNV := GLGetProcAddress('glVertexAttrib3fvNV');4192
glVertexAttrib3sNV := GLGetProcAddress('glVertexAttrib3sNV');4193
glVertexAttrib3svNV := GLGetProcAddress('glVertexAttrib3svNV');4194
glVertexAttrib4dNV := GLGetProcAddress('glVertexAttrib4dNV');4195
glVertexAttrib4dvNV := GLGetProcAddress('glVertexAttrib4dvNV');4196
glVertexAttrib4fNV := GLGetProcAddress('glVertexAttrib4fNV');4197
glVertexAttrib4fvNV := GLGetProcAddress('glVertexAttrib4fvNV');4198
glVertexAttrib4sNV := GLGetProcAddress('glVertexAttrib4sNV');4199
glVertexAttrib4svNV := GLGetProcAddress('glVertexAttrib4svNV');4200
glVertexAttrib4ubvNV := GLGetProcAddress('glVertexAttrib4ubvNV');4201
glVertexAttribs1dvNV := GLGetProcAddress('glVertexAttribs1dvNV');4202
glVertexAttribs1fvNV := GLGetProcAddress('glVertexAttribs1fvNV');4203
glVertexAttribs1svNV := GLGetProcAddress('glVertexAttribs1svNV');4204
glVertexAttribs2dvNV := GLGetProcAddress('glVertexAttribs2dvNV');4205
glVertexAttribs2fvNV := GLGetProcAddress('glVertexAttribs2fvNV');4206
glVertexAttribs2svNV := GLGetProcAddress('glVertexAttribs2svNV');4207
glVertexAttribs3dvNV := GLGetProcAddress('glVertexAttribs3dvNV');4208
glVertexAttribs3fvNV := GLGetProcAddress('glVertexAttribs3fvNV');4209
glVertexAttribs3svNV := GLGetProcAddress('glVertexAttribs3svNV');4210
glVertexAttribs4dvNV := GLGetProcAddress('glVertexAttribs4dvNV');4211
glVertexAttribs4fvNV := GLGetProcAddress('glVertexAttribs4fvNV');4212
glVertexAttribs4svNV := GLGetProcAddress('glVertexAttribs4svNV');4213
glVertexAttribs4ubvNV := GLGetProcAddress('glVertexAttribs4ubvN');4215
// GL_NV_occlusion_query (#261)
4216
glGenOcclusionQueriesNV := GLGetProcAddress('glGenOcclusionQueriesNV');4217
glDeleteOcclusionQueriesNV := GLGetProcAddress('glDeleteOcclusionQueriesNV');4218
glIsOcclusionQueryNV := GLGetProcAddress('glIsOcclusionQueryNV');4219
glBeginOcclusionQueryNV := GLGetProcAddress('glBeginOcclusionQueryNV');4220
glEndOcclusionQueryNV := GLGetProcAddress('glEndOcclusionQueryNV');4221
glGetOcclusionQueryivNV := GLGetProcAddress('glGetOcclusionQueryivNV');4222
glGetOcclusionQueryuivNV := GLGetProcAddress('glGetOcclusionQueryuivNV');4224
// GL_NV_point_sprite (#262)
4225
glPointParameteriNV := GLGetProcAddress('glPointParameteriNV');4226
glPointParameterivNV := GLGetProcAddress('glPointParameterivNV');4228
// GL_EXT_stencil_two_side (#268)
4229
glActiveStencilFaceEXT := GLGetProcAddress('glActiveStencilFaceEXT');4231
// GL_ATI_draw_buffers (#277)
4232
glDrawBuffersATI := GLGetProcAddress('glDrawBuffersATI');4234
// GL_NV_primitive_restart (#285)
4235
glPrimitiveRestartNV := GLGetProcAddress('glPrimitiveRestartNV');4236
glPrimitiveRestartIndexNV := GLGetProcAddress('glPrimitiveRestartIndexNV');4237
glPrimitiveRestartIndex := GLGetProcAddress('glPrimitiveRestartIndex');4238
if Addr(glPrimitiveRestartIndex) = nil then
4239
glPrimitiveRestartIndex := glPrimitiveRestartIndexNV;
4241
// GL_EXT_depth_bounds_test (#297)
4242
glDepthBoundsEXT := GLGetProcAddress('glDepthBoundsEXT');4244
// GL_EXT_blend_equation_separate (#299)
4245
glBlendEquationSeparateEXT := GLGetProcAddress('glBlendEquationSeparateEXT');4247
// GL_EXT_framebuffer_object (#310)
4248
glIsRenderbufferEXT := GLGetProcAddress('glIsRenderbufferEXT');4249
glBindRenderbufferEXT := GLGetProcAddress('glBindRenderbufferEXT');4250
glDeleteRenderbuffersEXT := GLGetProcAddress('glDeleteRenderbuffersEXT');4251
glGenRenderbuffersEXT := GLGetProcAddress('glGenRenderbuffersEXT');4252
glRenderbufferStorageEXT := GLGetProcAddress('glRenderbufferStorageEXT');4253
glGetRenderbufferParameterivEXT := GLGetProcAddress('glGetRenderbufferParameterivEXT');4254
glIsFramebufferEXT := GLGetProcAddress('glIsFramebufferEXT');4255
glBindFramebufferEXT := GLGetProcAddress('glBindFramebufferEXT');4256
glDeleteFramebuffersEXT := GLGetProcAddress('glDeleteFramebuffersEXT');4257
glGenFramebuffersEXT := GLGetProcAddress('glGenFramebuffersEXT');4258
glCheckFramebufferStatusEXT := GLGetProcAddress('glCheckFramebufferStatusEXT');4259
glFramebufferTexture1DEXT := GLGetProcAddress('glFramebufferTexture1DEXT');4260
glFramebufferTexture2DEXT := GLGetProcAddress('glFramebufferTexture2DEXT');4261
glFramebufferTexture3DEXT := GLGetProcAddress('glFramebufferTexture3DEXT');4262
glFramebufferRenderbufferEXT := GLGetProcAddress('glFramebufferRenderbufferEXT');4263
glGetFramebufferAttachmentParameterivEXT := GLGetProcAddress('glGetFramebufferAttachmentParameterivEXT');4264
glGenerateMipmapEXT := GLGetProcAddress('glGenerateMipmapEXT');4266
// GL_GREMEDY_string_marker (EXT #311)
4267
glStringMarkerGREMEDY := GLGetProcAddress('glStringMarkerGREMEDY');4269
// GL_EXT_stencil_clear_tag (EXT #314)
4270
glStencilClearTagEXT := GLGetProcAddress('glStencilClearTagEXT');4272
// GL_EXT_framebuffer_blit (#316)
4273
glBlitFramebufferEXT := GLGetProcAddress('glBlitFramebufferEXT');4275
// GL_EXT_framebuffer_multisample (#317)
4276
glRenderbufferStorageMultisampleEXT := GLGetProcAddress('glRenderbufferStorageMultisampleEXT');4278
// GL_EXT_timer_query (#319)
4279
glGetQueryObjecti64vEXT := GLGetProcAddress('glGetQueryObjecti64vEXT');4280
glGetQueryObjectui64vEXT := GLGetProcAddress('glGetQueryObjectui64vEXT');4282
// GL_EXT_gpu_program_parameters (#320)
4283
glProgramEnvParameters4fvEXT := GLGetProcAddress('glProgramEnvParameters4fvEXT');4284
glProgramLocalParameters4fvEXT := GLGetProcAddress('glProgramLocalParameters4fvEXT');4286
// GL_NV_geometry_program4 (#323)
4287
glProgramVertexLimitNV := GLGetProcAddress('glProgramVertexLimitNV');4289
// GL_EXT_geometry_shader4 (#324)
4290
glProgramParameteriEXT := GLGetProcAddress('glProgramParameteriEXT');4291
glFramebufferTextureEXT := GLGetProcAddress('glFramebufferTextureEXT');4292
glFramebufferTextureLayerEXT := GLGetProcAddress('glFramebufferTextureLayerEXT');4293
glFramebufferTextureFaceEXT := GLGetProcAddress('glFramebufferTextureFaceEXT');4295
// GL_EXT_gpu_shader4 (#326)
4296
glVertexAttribI1iEXT := GLGetProcAddress('glVertexAttribI1iEXT');4297
glVertexAttribI2iEXT := GLGetProcAddress('glVertexAttribI2iEXT');4298
glVertexAttribI3iEXT := GLGetProcAddress('glVertexAttribI3iEXT');4299
glVertexAttribI4iEXT := GLGetProcAddress('glVertexAttribI4iEXT');4301
glVertexAttribI1uiEXT := GLGetProcAddress('glVertexAttribI1uiEXT');4302
glVertexAttribI2uiEXT := GLGetProcAddress('glVertexAttribI2uiEXT');4303
glVertexAttribI3uiEXT := GLGetProcAddress('glVertexAttribI3uiEXT');4304
glVertexAttribI4uiEXT := GLGetProcAddress('glVertexAttribI4uiEXT');4306
glVertexAttribI1ivEXT := GLGetProcAddress('glVertexAttribI1ivEXT');4307
glVertexAttribI2ivEXT := GLGetProcAddress('glVertexAttribI2ivEXT');4308
glVertexAttribI3ivEXT := GLGetProcAddress('glVertexAttribI3ivEXT');4309
glVertexAttribI4ivEXT := GLGetProcAddress('glVertexAttribI4ivEXT');4311
glVertexAttribI1uivEXT := GLGetProcAddress('glVertexAttribI1uivEXT');4312
glVertexAttribI2uivEXT := GLGetProcAddress('glVertexAttribI2uivEXT');4313
glVertexAttribI3uivEXT := GLGetProcAddress('glVertexAttribI3uivEXT');4314
glVertexAttribI4uivEXT := GLGetProcAddress('glVertexAttribI4uivEXT');4316
glVertexAttribI4bvEXT := GLGetProcAddress('glVertexAttribI4bvEXT');4317
glVertexAttribI4svEXT := GLGetProcAddress('glVertexAttribI4svEXT');4318
glVertexAttribI4ubvEXT := GLGetProcAddress('glVertexAttribI4ubvEXT');4319
glVertexAttribI4usvEXT := GLGetProcAddress('glVertexAttribI4usvEXT');4321
glVertexAttribIPointerEXT := GLGetProcAddress('glVertexAttribIPointerEXT');4323
glGetVertexAttribIivEXT := GLGetProcAddress('glGetVertexAttribIivEXT');4324
glGetVertexAttribIuivEXT := GLGetProcAddress('glGetVertexAttribIuivEXT');4326
glUniform1uiEXT := GLGetProcAddress('glUniform1uiEXT');4327
glUniform2uiEXT := GLGetProcAddress('glUniform2uiEXT');4328
glUniform3uiEXT := GLGetProcAddress('glUniform3uiEXT');4329
glUniform4uiEXT := GLGetProcAddress('glUniform4uiEXT');4331
glUniform1uivEXT := GLGetProcAddress('glUniform1uivEXT');4332
glUniform2uivEXT := GLGetProcAddress('glUniform2uivEXT');4333
glUniform3uivEXT := GLGetProcAddress('glUniform3uivEXT');4334
glUniform4uivEXT := GLGetProcAddress('glUniform4uivEXT');4336
glGetUniformuivEXT := GLGetProcAddress('glGetUniformuivEXT');4338
glBindFragDataLocationEXT := GLGetProcAddress('glBindFragDataLocationEXT');4339
glGetFragDataLocationEXT := GLGetProcAddress('glGetFragDataLocationEXT');4341
// GL_EXT_draw_instanced (#327)
4342
glDrawArraysInstancedEXT := GLGetProcAddress('glDrawArraysInstancedEXT');4343
glDrawElementsInstancedEXT := GLGetProcAddress('glDrawElementsInstancedEXT');4345
// GL_EXT_texture_array (#329)
4346
// glFramebufferTextureLayerEXT:= GLGetProcAddress('glFramebufferTextureLayerEXT');4348
// GL_EXT_texture_buffer_object (#330)
4349
glTexBufferEXT := GLGetProcAddress('glTexBufferEXT');4351
// GL_EXT_draw_buffers2 (#340)
4352
glColorMaskIndexedEXT := GLGetProcAddress('glColorMaskIndexedEXT');4353
glGetBooleanIndexedvEXT := GLGetProcAddress('glGetBooleanIndexedvEXT');4354
glGetIntegerIndexedvEXT:= GLGetProcAddress('glGetIntegerIndexedvEXT');4355
glEnableIndexedEXT:= GLGetProcAddress('glEnableIndexedEXT');4356
glDisableIndexedEXT:= GLGetProcAddress('glDisableIndexedEXT');4357
glIsEnabledIndexedEXT:= GLGetProcAddress('glIsEnabledIndexedEXT');4359
// GL_NV_transform_feedback (#341)
4360
glBindBufferRangeNV := GLGetProcAddress('glBindBufferRangeNV');4361
glBindBufferOffsetNV := GLGetProcAddress('glBindBufferOffsetNV');4362
glBindBufferBaseNV := GLGetProcAddress('glBindBufferBaseNV');4363
glTransformFeedbackAttribsNV := GLGetProcAddress('glTransformFeedbackAttribsNV');4364
glTransformFeedbackVaryingsNV := GLGetProcAddress('glTransformFeedbackVaryingsNV');4365
glBeginTransformFeedbackNV := GLGetProcAddress('glBeginTransformFeedbackNV');4366
glEndTransformFeedbackNV := GLGetProcAddress('glEndTransformFeedbackNV');4367
glGetVaryingLocationNV := GLGetProcAddress('glGetVaryingLocationNV');4368
glGetActiveVaryingNV := GLGetProcAddress('glGetActiveVaryingNV');4369
glActiveVaryingNV := GLGetProcAddress('glActiveVaryingNV');4370
glGetTransformFeedbackVaryingNV := GLGetProcAddress('glGetTransformFeedbackVaryingNV');4372
// GL_EXT_bindable_uniform (#342)
4373
glUniformBufferEXT := GLGetProcAddress('glUniformBufferEXT');4374
glGetUniformBufferSizeEXT := GLGetProcAddress('glGetUniformBufferSizeEXT');4375
glGetUniformOffsetEXT := GLGetProcAddress('glGetUniformOffsetEXT');4377
// GL_EXT_texture_integer (#343)
4378
glClearColorIiEXT := GLGetProcAddress('glClearColorIiEXT');4379
glClearColorIuiEXT := GLGetProcAddress('glClearColorIuiEXT');4380
glTexParameterIivEXT := GLGetProcAddress('glTexParameterIivEXT');4381
glTexParameterIuivEXT := GLGetProcAddress('glTexParameterIuivEXT');4382
glGetTexParameterIivEXT := GLGetProcAddress('glGetTexParameterIivEXT');4383
glGetTexParameterIuivEXT := GLGetProcAddress('glGetTexParameterIuivEXT');4385
// GL_GREMEDY_frame_terminator (EXT #345)
4386
glFrameTerminatorGREMEDY := GLGetProcAddress('glFrameTerminatorGREMEDY');4388
// GL_NV_conditional_render (#346)
4389
glBeginConditionalRenderNV := GLGetProcAddress('glBeginConditionalRenderNV');4390
glEndConditionalRenderNV := GLGetProcAddress('glEndConditionalRenderNV');4392
// GL_EXT_transform_feedback (#352)
4393
glBindBufferRangeEXT := GLGetProcAddress('glBindBufferRangeEXT');4394
glBindBufferOffsetEXT := GLGetProcAddress('glBindBufferOffsetEXT');4395
glBindBufferBaseEXT := GLGetProcAddress('glBindBufferBaseEXT');4396
glBeginTransformFeedbackEXT := GLGetProcAddress('glBeginTransformFeedbackEXT');4397
glEndTransformFeedbackEXT := GLGetProcAddress('glEndTransformFeedbackEXT');4398
glTransformFeedbackVaryingsEXT := GLGetProcAddress('glTransformFeedbackVaryingsEXT');4399
glGetTransformFeedbackVaryingEXT:= GLGetProcAddress('glGetTransformFeedbackVaryingEXT');4401
// GL_AMD_vertex_shader_tesselator (#363)
4402
glTessellationFactorAMD := GLGetProcAddress('glTessellationFactorAMD');4403
glTessellationModeAMD := GLGetProcAddress('glTessellationModeAMD');4405
// GL_NV_copy_image (#376)
4406
glCopyImageSubDataNV := GLGetProcAddress('glCopyImageSubDataNV');4408
// GL_NV_shader_buffer_load (#379)
4409
glMakeBufferResidentNV := GLGetProcAddress('glMakeBufferResidentNV');4410
glMakeBufferNonResidentNV := GLGetProcAddress('glMakeBufferNonResidentNV');4411
glIsBufferResidentNV := GLGetProcAddress('glIsBufferResidentNV');4412
glMakeNamedBufferResidentNV := GLGetProcAddress('glMakeNamedBufferResidentNV');4413
glMakeNamedBufferNonResidentNV := GLGetProcAddress('glMakeNamedBufferNonResidentNV');4414
glIsNamedBufferResidentNV := GLGetProcAddress('glIsNamedBufferResidentNV');4415
glGetBufferParameterui64vNV := GLGetProcAddress('glGetBufferParameterui64vNV');4416
glGetNamedBufferParameterui64vNV := GLGetProcAddress('glGetNamedBufferParameterui64vNV');4417
glGetIntegerui64vNV := GLGetProcAddress('glGetIntegerui64vNV');4418
glUniformui64NV := GLGetProcAddress('glUniformui64NV');4419
glUniformui64vNV := GLGetProcAddress('glUniformui64vNV');4420
glGetUniformui64vNV := GLGetProcAddress('glGetUniformui64vNV');4421
glProgramUniformui64NV := GLGetProcAddress('glProgramUniformui64NV');4422
glProgramUniformui64vNV := GLGetProcAddress('glProgramUniformui64vNV');4424
// GL_NV_vertex_buffer_unified_memory (#380)
4425
glBufferAddressRangeNV := GLGetProcAddress('glBufferAddressRangeNV');4426
glVertexFormatNV := GLGetProcAddress('glVertexFormatNV');4427
glNormalFormatNV := GLGetProcAddress('glNormalFormatNV');4428
glColorFormatNV := GLGetProcAddress('glColorFormatNV');4429
glIndexFormatNV := GLGetProcAddress('glIndexFormatNV');4430
glTexCoordFormatNV := GLGetProcAddress('glTexCoordFormatNV');4431
glEdgeFlagFormatNV := GLGetProcAddress('glEdgeFlagFormatNV');4432
glSecondaryColorFormatNV := GLGetProcAddress('glSecondaryColorFormatNV');4433
glFogCoordFormatNV := GLGetProcAddress('glFogCoordFormatNV');4434
glVertexAttribFormatNV := GLGetProcAddress('glVertexAttribFormatNV');4435
glVertexAttribIFormatNV := GLGetProcAddress('glVertexAttribIFormatNV');4436
glGetIntegerui64i_vNV := GLGetProcAddress('glGetIntegerui64i_vNV');4438
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}4440
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures for Windows OpenGL (WGL) extensions'} {$ENDIF}4441
{$IFDEF SUPPORT_WGL}4444
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}4446
{$IFDEF GLS_REGIONS} {$region 'locate functions/procedures for GLX extensions'} {$ENDIF}4447
{$IFDEF SUPPORT_GLX}4450
{$IFDEF GLS_REGIONS} {$endregion} {$ENDIF}4457
procedure ReadWGLExtensions;
4459
// ARB wgl extensions
4461
// ###########################################################
4462
// locating functions and procedures for
4463
// ARB approved WGL extensions
4464
// ###########################################################
4466
// WGL_buffer_region (ARB #4)
4467
wglCreateBufferRegionARB := GLGetProcAddress('wglCreateBufferRegionARB');4468
wglDeleteBufferRegionARB := GLGetProcAddress('wglDeleteBufferRegionARB');4469
wglSaveBufferRegionARB := GLGetProcAddress('wglSaveBufferRegionARB');4470
wglRestoreBufferRegionARB := GLGetProcAddress('wglRestoreBufferRegionARB');4472
// WGL_ARB_extensions_string (ARB #8)
4473
wglGetExtensionsStringARB := GLGetProcAddress('wglGetExtensionsStringARB');4475
// WGL_ARB_pixel_format (ARB #9)
4476
wglGetPixelFormatAttribivARB := GLGetProcAddress('wglGetPixelFormatAttribivARB');4477
wglGetPixelFormatAttribfvARB := GLGetProcAddress('wglGetPixelFormatAttribfvARB');4478
wglChoosePixelFormatARB := GLGetProcAddress('wglChoosePixelFormatARB');4480
// WGL_make_current_read (ARB #10)
4481
wglMakeContextCurrentARB := GLGetProcAddress('wglMakeContextCurrentARB');4482
wglGetCurrentReadDCARB := GLGetProcAddress('wglGetCurrentReadDCARB');4484
// WGL_ARB_pbuffer (ARB #11)
4485
wglCreatePbufferARB := GLGetProcAddress('wglCreatePbufferARB');4486
wglGetPbufferDCARB := GLGetProcAddress('wglGetPbufferDCARB');4487
wglReleasePbufferDCARB := GLGetProcAddress('wglReleasePbufferDCARB');4488
wglDestroyPbufferARB := GLGetProcAddress('wglDestroyPbufferARB');4489
wglQueryPbufferARB := GLGetProcAddress('wglQueryPbufferARB');4491
// WGL_ARB_render_texture (ARB #20)
4492
wglBindTexImageARB := GLGetProcAddress('wglBindTexImageARB');4493
wglReleaseTexImageARB := GLGetProcAddress('wglReleaseTexImageARB');4494
wglSetPbufferAttribARB := GLGetProcAddress('wglSetPbufferAttribARB');4496
// WGL_ARB_create_context (ARB #55)
4497
wglCreateContextAttribsARB := GLGetProcAddress('wglCreateContextAttribsARB');4499
// ###########################################################
4500
// locating functions and procedures for
4501
// Vendor/EXT WGL extensions
4502
// ###########################################################
4504
// WGL_EXT_swap_control (EXT #172)
4505
wglSwapIntervalEXT := GLGetProcAddress('wglSwapIntervalEXT');4506
wglGetSwapIntervalEXT := GLGetProcAddress('wglGetSwapIntervalEXT');4508
// WGL_NV_gpu_affinity
4509
wglEnumGpusNV := GLGetProcAddress('wglEnumGpusNV');4510
wglEnumGpuDevicesNV := GLGetProcAddress('wglEnumGpuDevicesNV');4511
wglCreateAffinityDCNV := GLGetProcAddress('wglCreateAffinityDCNV');4512
wglEnumGpusFromAffinityDCNV := GLGetProcAddress('wglEnumGpusFromAffinityDCNV');4513
wglDeleteDCNV := GLGetProcAddress('wglDeleteDCNV');4520
procedure ReadGLXExtensions;
4522
// ARB glx extensions
4524
// ###########################################################
4525
// locating functions and procedures for
4526
// ARB approved GLX extensions
4527
// ###########################################################
4530
glXGetProcAddress := GLLibGetProcAddress('glXGetProcAddress');4531
glXGetProcAddressARB := GLLibGetProcAddress('glXGetProcAddressARB');4534
glXChooseFBConfig := GLGetProcAddress('glXChooseFBConfig');4535
glXGetFBConfigAttrib := GLGetProcAddress('glXGetFBConfigAttrib');4536
glXGetFBConfigs := GLGetProcAddress('glXGetFBConfigs');4537
glXGetVisualFromFBConfig := GLGetProcAddress('glXGetVisualFromFBConfig');4538
glXCreateWindow := GLGetProcAddress('glXCreateWindow');4539
glXDestroyWindow := GLGetProcAddress('glXDestroyWindow');4540
glXCreatePixmap := GLGetProcAddress('glXCreatePixmap');4541
glXDestroyPixmap := GLGetProcAddress('glXDestroyPixmap');4542
glXCreatePbuffer := GLGetProcAddress('glXCreatePbuffer');4543
glXDestroyPbuffer := GLGetProcAddress('glXDestroyPbuffer');4544
glXQueryDrawable := GLGetProcAddress('glXQueryDrawable');4545
glXCreateNewContext := GLGetProcAddress('glXCreateNewContext');4546
glXMakeContextCurrent := GLGetProcAddress('glXMakeContextCurrent');4547
glXGetCurrentReadDrawable := GLGetProcAddress('glXGetCurrentReadDrawable');4548
glXQueryContext := GLGetProcAddress('glXQueryContext');4549
glXSelectEvent := GLGetProcAddress('glXSelectEvent');4550
glXGetSelectedEvent := GLGetProcAddress('glXGetSelectedEvent');4551
glXBindTexImageARB := GLGetProcAddress('glXBindTexImageARB');4552
glXReleaseTexImageARB := GLGetProcAddress('glXReleaseTexImageARB');4553
glxDrawableAttribARB := GLGetProcAddress('glxDrawableAttribARB');4556
// GLX_ARB_create_context (EXT #56)
4557
glXCreateContextAttribsARB := GLGetProcAddress('glXCreateContextAttribsARB');4559
// ###########################################################
4560
// locating functions and procedures for
4561
// Vendor/EXT WGL extensions
4562
// ###########################################################
4564
// WGL_EXT_swap_control (EXT #172)
4565
glXSwapIntervalSGI := GLGetProcAddress('glXSwapIntervalSGI');4566
glXGetVideoSyncSGI := GLGetProcAddress('glXGetVideoSyncSGI');4567
glXWaitVideoSyncSGI := GLGetProcAddress('glXWaitVideoSyncSGI');4568
glXFreeContextEXT := GLGetProcAddress('glXFreeContextEXT');4569
glXGetContextIDEXT := GLGetProcAddress('glXGetContextIDEXT');4570
glXGetCurrentDisplayEXT := GLGetProcAddress('glXGetCurrentDisplayEXT');4571
glXImportContextEXT := GLGetProcAddress('glXImportContextEXT');4572
glXQueryContextInfoEXT := GLGetProcAddress('glXQueryContextInfoEXT');4573
glXCopySubBufferMESA := GLGetProcAddress('glXCopySubBufferMESA');4574
glXCreateGLXPixmapMESA := GLGetProcAddress('glXCreateGLXPixmapMESA');4575
glXReleaseBuffersMESA := GLGetProcAddress('glXReleaseBuffersMESA');4576
glXSet3DfxModeMESA := GLGetProcAddress('glXSet3DfxModeMESA');4578
glXBindTexImageEXT := GLGetProcAddress('glXBindTexImageEXT');4579
glXReleaseTexImageEXT := GLGetProcAddress('glXReleaseTexImageEXT');4582
glXMakeCurrentReadSGI := GLGetProcAddress('glXMakeCurrentReadSGI');4583
glXGetCurrentReadDrawableSGI := GLGetProcAddress('glXGetCurrentReadDrawableSGI');4584
glXGetFBConfigAttribSGIX := GLGetProcAddress('glXGetFBConfigAttribSGIX');4585
glXChooseFBConfigSGIX := GLGetProcAddress('glXChooseFBConfigSGIX');4586
glXCreateGLXPixmapWithConfigSGIX := GLGetProcAddress('glXCreateGLXPixmapWithConfigSGIX');4587
glXCreateContextWithConfigSGIX := GLGetProcAddress('glXCreateContextWithConfigSGIX');4588
glXGetVisualFromFBConfigSGIX := GLGetProcAddress('glXGetVisualFromFBConfigSGIX');4589
glXGetFBConfigFromVisualSGIX := GLGetProcAddress('glXGetFBConfigFromVisualSGIX');4590
glXCreateGLXPbufferSGIX := GLGetProcAddress('glXCreateGLXPbufferSGIX');4591
glXDestroyGLXPbufferSGIX := GLGetProcAddress('glXDestroyGLXPbufferSGIX');4592
glXQueryGLXPbufferSGIX := GLGetProcAddress('glXQueryGLXPbufferSGIX');4593
glXSelectEventSGIX := GLGetProcAddress('glXSelectEventSGIX');4594
glXGetSelectedEventSGIX := GLGetProcAddress('glXGetSelectedEventSGIX');4595
glXCushionSGI := GLGetProcAddress('glXCushionSGI');4596
glXBindChannelToWindowSGIX := GLGetProcAddress('glXBindChannelToWindowSGIX');4597
glXChannelRectSGIX := GLGetProcAddress('glXChannelRectSGIX');4598
glXQueryChannelRectSGIX := GLGetProcAddress('glXQueryChannelRectSGIX');4599
glXQueryChannelDeltasSGIX := GLGetProcAddress('glXQueryChannelDeltasSGIX');4600
glXChannelRectSyncSGIX := GLGetProcAddress('glXChannelRectSyncSGIX');4601
glXJoinSwapGroupSGIX := GLGetProcAddress('glXJoinSwapGroupSGIX');4602
glXBindSwapBarrierSGIX := GLGetProcAddress('glXBindSwapBarrierSGIX');4603
glXQueryMaxSwapBarriersSGIX := GLGetProcAddress('glXQueryMaxSwapBarriersSGIX');4604
glXQueryHyperpipeNetworkSGIX := GLGetProcAddress('glXQueryHyperpipeNetworkSGIX');4607
glXHyperpipeConfigSGIX := GLGetProcAddress('glXHyperpipeConfigSGIX');4608
glXQueryHyperpipeConfigSGIX := GLGetProcAddress('glXQueryHyperpipeConfigSGIX');4609
glXDestroyHyperpipeConfigSGIX := GLGetProcAddress('glXDestroyHyperpipeConfigSGIX');4610
glXBindHyperpipeSGIX := GLGetProcAddress('glXBindHyperpipeSGIX');4611
glXQueryHyperpipeBestAttribSGIX := GLGetProcAddress('glXQueryHyperpipeBestAttribSGIX');4612
glXHyperpipeAttribSGIX := GLGetProcAddress('glXHyperpipeAttribSGIX');4613
glXQueryHyperpipeAttribSGIX := GLGetProcAddress('glXQueryHyperpipeAttribSGIX');4614
glXGetAGPOffsetMESA := GLGetProcAddress('glXGetAGPOffsetMESA');4615
glXEnumerateVideoDevicesNV := GLGetProcAddress('glXEnumerateVideoDevicesNV');4616
glXBindVideoDeviceNV := GLGetProcAddress('glXBindVideoDeviceNV');4617
glxGetVideoDeviceNV := GLGetProcAddress('glxGetVideoDeviceNV');4618
glXCopySubBufferMESA := GLGetProcAddress('glXCopySubBufferMESA');4619
glXReleaseBuffersMESA := GLGetProcAddress('glXReleaseBuffersMESA');4620
glXCreateGLXPixmapMESA := GLGetProcAddress('glXCreateGLXPixmapMESA');4621
glXSet3DfxModeMESA := GLGetProcAddress('glXSet3DfxModeMESA');4623
glXAllocateMemoryNV := GLGetProcAddress('glXAllocateMemoryNV');4624
glXFreeMemoryNV := GLGetProcAddress('glXFreeMemoryNV');4626
glXReleaseVideoDeviceNV := GLGetProcAddress('glXReleaseVideoDeviceNV');4627
glXBindVideoImageNV := GLGetProcAddress('glXBindVideoImageNV');4628
glXReleaseVideoImageNV := GLGetProcAddress('glXReleaseVideoImageNV');4629
glXSendPbufferToVideoNV := GLGetProcAddress('glXSendPbufferToVideoNV');4630
glXGetVideoInfoNV := GLGetProcAddress('glXGetVideoInfoNV');4631
glXJoinSwapGroupNV := GLGetProcAddress('glXJoinSwapGroupNV');4632
glXBindSwapBarrierNV := GLGetProcAddress('glXBindSwapBarrierNV');4633
glXQuerySwapGroupNV := GLGetProcAddress('glXQuerySwapGroupNV');4634
glXQueryMaxSwapGroupsNV := GLGetProcAddress('glXQueryMaxSwapGroupsNV');4635
glXQueryFrameCountNV := GLGetProcAddress('glXQueryFrameCountNV');4636
glXResetFrameCountNV := GLGetProcAddress('glXResetFrameCountNV');4637
glXBindVideoCaptureDeviceNV := GLGetProcAddress('glXBindVideoCaptureDeviceNV');4638
glXEnumerateVideoCaptureDevicesNV := GLGetProcAddress('glXEnumerateVideoCaptureDevicesNV');4639
glxLockVideoCaptureDeviceNV := GLGetProcAddress('glxLockVideoCaptureDeviceNV');4640
glXQueryVideoCaptureDeviceNV := GLGetProcAddress('glXQueryVideoCaptureDeviceNV');4641
glXReleaseVideoCaptureDeviceNV := GLGetProcAddress('glXReleaseVideoCaptureDeviceNV');4642
glXSwapIntervalEXT := GLGetProcAddress('glXSwapIntervalEXT');4643
glXCopyImageSubDataNV := GLGetProcAddress('glXCopyImageSubDataNV');4647
// TrimAndSplitVersionString
4649
procedure TrimAndSplitVersionString(Buffer: String; var Max, Min: Integer);
4650
// Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
4651
// at least however "Major.Minor".
4656
// There must be at least one dot to separate major and minor version number.
4657
Separator := Pos('.', Buffer);4658
// At least one number must be before and one after the dot.
4659
if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and
4660
(AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then
4662
// OK, it's a valid version string. Now remove unnecessary parts.
4664
// Find last non-numeric character before version number.
4665
while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
4667
// Delete leading characters which do not belong to the version string.
4668
Delete(Buffer, 1, Separator);
4669
Separator := Pos('.', Buffer) + 1;4670
// Find first non-numeric character after version number
4671
while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
4673
// delete trailing characters not belonging to the version string
4674
Delete(Buffer, Separator, 255);
4675
// Now translate the numbers.
4676
Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.4677
Max := StrToInt(Copy(Buffer, 1, Separator - 1));
4678
Min := StrToInt(Copy(Buffer, Separator + 1, 255));
4688
function IsVersionMet(MajorVersion,MinorVersion,actualMajorVersion, actualMinorVersion:Integer): boolean;
4690
Result:=(actualMajorVersion>MajorVersion)or
4691
((actualMajorVersion=MajorVersion)and(actualMinorVersion>=MinorVersion));
4694
// ReadImplementationProperties
4696
procedure ReadImplementationProperties;
4699
MajorVersion, MinorVersion: Integer;
4701
// Checks if the given Extension string is in Buffer.
4702
function CheckExtension(const Extension: string): Boolean;
4706
// First find the position of the extension string as substring in Buffer.
4707
ExtPos := Pos(Extension, Buffer);
4708
Result := ExtPos > 0;
4709
// Now check that it isn't only a substring of another extension.
4711
Result := ((ExtPos + Length(Extension) - 1)= Length(Buffer))
4712
or (Buffer[ExtPos + Length(Extension)]=' ');
4716
// determine OpenGL versions supported
4717
buffer:=String(glGetString(GL_VERSION));
4718
TrimAndSplitVersionString(buffer, majorversion, minorVersion);
4719
GL_VERSION_1_0:=True;
4720
GL_VERSION_1_1:=IsVersionMet(1,1,majorVersion,minorVersion);
4721
GL_VERSION_1_2:=IsVersionMet(1,2,majorVersion,minorVersion);
4722
GL_VERSION_1_3:=IsVersionMet(1,3,majorVersion,minorVersion);
4723
GL_VERSION_1_4:=IsVersionMet(1,4,majorVersion,minorVersion);
4724
GL_VERSION_1_5:=IsVersionMet(1,5,majorVersion,minorVersion);
4725
GL_VERSION_2_0:=IsVersionMet(2,0,majorVersion,minorVersion);
4726
GL_VERSION_2_1:=IsVersionMet(2,1,majorVersion,minorVersion);
4727
GL_VERSION_3_0:=IsVersionMet(3,0,majorVersion,minorVersion);
4728
GL_VERSION_3_1:=IsVersionMet(3,1,majorVersion,minorVersion);
4729
GL_VERSION_3_2:=IsVersionMet(3,2,majorVersion,minorVersion);
4730
GL_VERSION_3_3:=IsVersionMet(3,3,majorVersion,minorVersion);
4731
GL_VERSION_4_0:=IsVersionMet(4,0,majorVersion,minorVersion);
4732
GL_VERSION_4_1:=IsVersionMet(4,1,majorVersion,minorVersion);
4734
// determine GLU versions met
4735
buffer:=String(gluGetString(GLU_VERSION));
4736
TrimAndSplitVersionString(buffer, majorversion, minorVersion);
4737
GLU_VERSION_1_1:=True; // won't load without at least GLU 1.1
4738
GLU_VERSION_1_2:=IsVersionMet(1,2,majorVersion,minorVersion);
4739
GLU_VERSION_1_3:=IsVersionMet(1,3,majorVersion,minorVersion);
4741
// check supported OpenGL extensions
4742
Buffer := String(glGetString(GL_EXTENSIONS));
4743
// check ARB approved OpenGL extensions
4744
GL_ARB_blend_func_extended := CheckExtension('GL_ARB_blend_func_extended');4745
GL_ARB_color_buffer_float := CheckExtension('GL_ARB_color_buffer_float');4746
GL_ARB_compatibility := CheckExtension('GL_ARB_compatibility');4747
GL_ARB_copy_buffer := CheckExtension('GL_ARB_copy_buffer');4748
GL_ARB_debug_output := CheckExtension('GL_ARB_debug_output');4749
GL_ARB_depth_buffer_float := CheckExtension('GL_ARB_depth_buffer_float');4750
GL_ARB_depth_clamp := CheckExtension('GL_ARB_depth_clamp');4751
GL_ARB_depth_texture := CheckExtension('GL_ARB_depth_texture');4752
GL_ARB_draw_buffers := CheckExtension('GL_ARB_draw_buffers');4753
GL_ARB_draw_buffers_blend := CheckExtension('GL_ARB_draw_buffers_blend');4754
GL_ARB_draw_elements_base_vertex := CheckExtension('GL_ARB_draw_elements_base_vertex');4755
GL_ARB_draw_indirect := CheckExtension('GL_ARB_draw_indirect');4756
GL_ARB_draw_instanced := CheckExtension('GL_ARB_draw_instanced');4757
GL_ARB_ES2_compatibility := CheckExtension('GL_ARB_ES2_compatibility');4758
GL_ARB_explicit_attrib_location := CheckExtension('GL_ARB_explicit_attrib_location');4759
GL_ARB_fragment_coord_conventions := CheckExtension('GL_ARB_fragment_coord_conventions');4760
GL_ARB_fragment_program := CheckExtension('GL_ARB_fragment_program');4761
GL_ARB_fragment_program_shadow := CheckExtension('GL_ARB_fragment_program_shadow');4762
GL_ARB_fragment_shader := CheckExtension('GL_ARB_fragment_shader');4763
GL_ARB_framebuffer_object := CheckExtension('GL_ARB_framebuffer_object');4764
GL_ARB_framebuffer_sRGB := CheckExtension('GL_ARB_framebuffer_sRGB');4765
GL_ARB_geometry_shader4 := CheckExtension('GL_ARB_geometry_shader4');4766
GL_ARB_get_program_binary := CheckExtension('GL_ARB_get_program_binary');4767
GL_ARB_gpu_shader_fp64 := CheckExtension('GL_ARB_gpu_shader_fp64');4768
GL_ARB_gpu_shader5 := CheckExtension('GL_ARB_gpu_shader5');4769
GL_ARB_half_float_pixel := CheckExtension('GL_ARB_half_float_pixel');4770
GL_ARB_half_float_vertex := CheckExtension('GL_ARB_half_float_vertex');4771
GL_ARB_imaging := CheckExtension('GL_ARB_imaging');4772
GL_ARB_instanced_arrays := CheckExtension('GL_ARB_instanced_arrays');4773
GL_ARB_map_buffer_range := CheckExtension('GL_ARB_map_buffer_range');4774
GL_ARB_matrix_palette := CheckExtension('GL_ARB_matrix_palette');4775
GL_ARB_multisample := CheckExtension(' GL_ARB_multisample'); // ' ' to avoid collision with WGL variant4776
GL_ARB_multitexture := CheckExtension('GL_ARB_multitexture');4777
GL_ARB_occlusion_query := CheckExtension('GL_ARB_occlusion_query');4778
GL_ARB_occlusion_query2 := CheckExtension('GL_ARB_occlusion_query2');4779
GL_ARB_pixel_buffer_object := CheckExtension('GL_ARB_pixel_buffer_object');4780
GL_ARB_point_parameters := CheckExtension('GL_ARB_point_parameters');4781
GL_ARB_point_sprite := CheckExtension('GL_ARB_point_sprite');4782
GL_ARB_provoking_vertex := CheckExtension('GL_ARB_provoking_vertex');4783
GL_ARB_robustness := CheckExtension('GL_ARB_robustness');4784
GL_ARB_sample_shading := CheckExtension('GL_ARB_sample_shading');4785
GL_ARB_sampler_objects := CheckExtension('GL_ARB_sampler_objects');4786
GL_ARB_seamless_cube_map := CheckExtension('GL_ARB_seamless_cube_map');4787
GL_ARB_separate_shader_objects := CheckExtension('GL_ARB_separate_shader_objects');4788
GL_ARB_shader_bit_encoding := CheckExtension('GL_ARB_shader_bit_encoding');4789
GL_ARB_shader_precision := CheckExtension('GL_ARB_shader_precision');4790
GL_ARB_shader_objects := CheckExtension('GL_ARB_shader_objects');4791
GL_ARB_shader_stencil_export := CheckExtension('GL_ARB_shader_stencil_export');4792
GL_ARB_shader_subroutine := CheckExtension('GL_ARB_shader_subroutine');4793
GL_ARB_shader_texture_lod := CheckExtension('GL_ARB_shader_texture_lod');4794
GL_ARB_shading_language_100 := CheckExtension('GL_ARB_shading_language_100');4795
GL_ARB_shadow := CheckExtension('GL_ARB_shadow');4796
GL_ARB_shadow_ambient := CheckExtension('GL_ARB_shadow_ambient');4797
GL_ARB_sync := CheckExtension('GL_ARB_sync');4798
GL_ARB_tessellation_shader := CheckExtension('GL_ARB_tessellation_shader');4799
GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp');4800
GL_ARB_texture_buffer_object := CheckExtension('GL_ARB_texture_buffer_object');4801
GL_ARB_texture_buffer_object_rgb32 := CheckExtension('GL_ARB_texture_buffer_object_rgb32');4802
GL_ARB_texture_compression := CheckExtension('GL_ARB_texture_compression');4803
GL_ARB_texture_compression_rgtc := CheckExtension('GL_ARB_texture_compression_rgtc');4804
GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map');4805
GL_ARB_texture_cube_map_array := CheckExtension('GL_ARB_texture_cube_map_array');4806
GL_ARB_texture_env_add := CheckExtension('GL_ARB_texture_env_add');4807
GL_ARB_texture_env_combine := CheckExtension('GL_ARB_texture_env_combine');4808
GL_ARB_texture_env_crossbar := CheckExtension('GL_ARB_texture_env_crossbar');4809
GL_ARB_texture_env_dot3 := CheckExtension('GL_ARB_texture_env_dot3');4810
GL_ARB_texture_float := CheckExtension('GL_ARB_texture_float');4811
GL_ARB_texture_gather := CheckExtension('GL_ARB_texture_gather');4812
GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat');4813
GL_ARB_texture_multisample := CheckExtension('GL_ARB_texture_multisample');4814
GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two');4815
GL_ARB_texture_query_lod := CheckExtension('GL_ARB_texture_query_lod');4816
GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle');4817
GL_ARB_texture_rg := CheckExtension('GL_ARB_texture_rg');4818
GL_ARB_texture_rgb10_a2ui := CheckExtension('GL_ARB_texture_rgb10_a2ui');4819
GL_ARB_texture_swizzle := CheckExtension('GL_ARB_texture_swizzle');4820
GL_ARB_timer_query := CheckExtension('GL_ARB_timer_query');4821
GL_ARB_transform_feedback2 := CheckExtension('GL_ARB_transform_feedback2');4822
GL_ARB_transform_feedback3 := CheckExtension('GL_ARB_transform_feedback3');4823
GL_ARB_transpose_matrix := CheckExtension('GL_ARB_transpose_matrix');4824
GL_ARB_uniform_buffer_object := CheckExtension('GL_ARB_uniform_buffer_object');4825
GL_ARB_vertex_array_bgra := CheckExtension('GL_ARB_vertex_array_bgra');4826
GL_ARB_vertex_array_object := CheckExtension('GL_ARB_vertex_array_object');4827
GL_ARB_vertex_attrib_64bit := CheckExtension('GL_ARB_vertex_attrib_64bit');4828
GL_ARB_vertex_blend := CheckExtension('GL_ARB_vertex_blend');4829
GL_ARB_vertex_buffer_object := CheckExtension('GL_ARB_vertex_buffer_object');4830
GL_ARB_vertex_program := CheckExtension('GL_ARB_vertex_program');4831
GL_ARB_vertex_shader := CheckExtension('GL_ARB_vertex_shader');4832
GL_ARB_vertex_type_2_10_10_10_rev := CheckExtension('GL_ARB_vertex_type_2_10_10_10_rev');4833
GL_ARB_viewport_array := CheckExtension('GL_ARB_viewport_array');4834
GL_ARB_window_pos := CheckExtension('GL_ARB_window_pos');4835
GL_ARB_texture_compression_bptc := CheckExtension('GL_ARB_texture_compression_bptc');4837
// check Vendor/EXT OpenGL extensions
4838
GL_3DFX_multisample := CheckExtension('GL_3DFX_multisample');4839
GL_3DFX_tbuffer := CheckExtension('GL_3DFX_tbuffer');4840
GL_3DFX_texture_compression_FXT1 := CheckExtension('GL_3DFX_texture_compression_FXT1');4841
GL_ATI_draw_buffers := CheckExtension('GL_ATI_draw_buffers');4842
GL_ATI_texture_compression_3dc := CheckExtension('GL_ATI_texture_compression_3dc');4843
GL_ATI_texture_float := CheckExtension('GL_ATI_texture_float');4844
GL_ATI_texture_mirror_once := CheckExtension('GL_ATI_texture_mirror_once');4846
GL_S3_s3tc := CheckExtension('GL_S3_s3tc');4848
GL_EXT_abgr := CheckExtension('GL_EXT_abgr');4849
GL_EXT_bgra := CheckExtension('GL_EXT_bgra');4850
GL_EXT_bindable_uniform := CheckExtension('GL_EXT_bindable_uniform'); 4851
GL_EXT_blend_color := CheckExtension('GL_EXT_blend_color');4852
GL_EXT_blend_equation_separate := CheckExtension('GL_EXT_blend_equation_separate');4853
GL_EXT_blend_func_separate := CheckExtension('GL_EXT_blend_func_separate');4854
GL_EXT_blend_logic_op := CheckExtension('GL_EXT_blend_logic_op');4855
GL_EXT_blend_minmax := CheckExtension('GL_EXT_blend_minmax');4856
GL_EXT_blend_subtract := CheckExtension('GL_EXT_blend_subtract');4857
GL_EXT_Cg_shader := CheckExtension('GL_EXT_Cg_shader');4858
GL_EXT_clip_volume_hint := CheckExtension('GL_EXT_clip_volume_hint');4859
GL_EXT_compiled_vertex_array := CheckExtension('GL_EXT_compiled_vertex_array');4860
GL_EXT_copy_texture := CheckExtension('GL_EXT_copy_texture');4861
GL_EXT_depth_bounds_test := CheckExtension('GL_EXT_depth_bounds_test');4862
GL_EXT_draw_buffers2 := CheckExtension('GL_EXT_draw_buffers2');4863
GL_EXT_draw_instanced := CheckExtension('GL_EXT_draw_instanced');4864
GL_EXT_draw_range_elements := CheckExtension('GL_EXT_draw_range_elements');4865
GL_EXT_fog_coord := CheckExtension('GL_EXT_fog_coord');4866
GL_EXT_framebuffer_blit := CheckExtension('GL_EXT_framebuffer_blit');4867
GL_EXT_framebuffer_multisample := CheckExtension('GL_EXT_framebuffer_multisample');4868
GL_EXT_framebuffer_object := CheckExtension('GL_EXT_framebuffer_object');4869
GL_EXT_framebuffer_sRGB := CheckExtension('GL_EXT_framebuffer_sRGB');4870
GL_EXT_geometry_shader4 := CheckExtension('GL_EXT_geometry_shader4');4871
GL_EXT_gpu_program_parameters := CheckExtension('GL_EXT_gpu_program_parameters');4872
GL_EXT_gpu_shader4 := CheckExtension('GL_EXT_gpu_shader4');4873
GL_EXT_multi_draw_arrays := CheckExtension('GL_EXT_multi_draw_arrays');4874
GL_EXT_multisample := CheckExtension('GL_EXT_multisample');4875
GL_EXT_packed_depth_stencil := CheckExtension('GL_EXT_packed_depth_stencil');4876
GL_EXT_packed_float := CheckExtension('GL_EXT_packed_float');4877
GL_EXT_packed_pixels := CheckExtension('GL_EXT_packed_pixels');4878
GL_EXT_paletted_texture := CheckExtension('GL_EXT_paletted_texture');4879
GL_EXT_pixel_buffer_object := CheckExtension('GL_EXT_pixel_buffer_object');4880
GL_EXT_polygon_offset := CheckExtension('GL_EXT_polygon_offset');4881
GL_EXT_rescale_normal := CheckExtension('GL_EXT_rescale_normal');4882
GL_EXT_secondary_color := CheckExtension('GL_EXT_secondary_color');4883
GL_EXT_separate_specular_color := CheckExtension('GL_EXT_separate_specular_color');4884
GL_EXT_shadow_funcs := CheckExtension('GL_EXT_shadow_funcs');4885
GL_EXT_shared_texture_palette := CheckExtension('GL_EXT_shared_texture_palette');4886
GL_EXT_stencil_clear_tag := CheckExtension('GL_EXT_stencil_clear_tag');4887
GL_EXT_stencil_two_side := CheckExtension('EXT_stencil_two_side');4888
GL_EXT_stencil_wrap := CheckExtension('GL_EXT_stencil_wrap');4889
GL_EXT_texture3D := CheckExtension('GL_EXT_texture3D');4890
GL_EXT_texture_array := CheckExtension('GL_EXT_texture_array');4891
GL_EXT_texture_buffer_object := CheckExtension('GL_EXT_texture_buffer_object');4892
GL_EXT_texture_compression_latc := CheckExtension('GL_EXT_texture_compression_latc');4893
GL_EXT_texture_compression_rgtc := CheckExtension('GL_EXT_texture_compression_rgtc');4894
GL_EXT_texture_compression_s3tc := CheckExtension('GL_EXT_texture_compression_s3tc');4895
GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map');4896
GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp');4897
GL_EXT_texture_env_add := CheckExtension('GL_EXT_texture_env_add');4898
GL_EXT_texture_env_combine := CheckExtension('GL_EXT_texture_env_combine');4899
GL_EXT_texture_env_dot3 := CheckExtension('GL_EXT_texture_env_dot3');4900
GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');4901
GL_EXT_texture_integer := CheckExtension('GL_EXT_texture_integer');4902
GL_EXT_texture_lod := CheckExtension('GL_EXT_texture_lod');4903
GL_EXT_texture_lod_bias := CheckExtension('GL_EXT_texture_lod_bias');4904
GL_EXT_texture_mirror_clamp := CheckExtension('GL_EXT_texture_mirror_clamp');4905
GL_EXT_texture_object := CheckExtension('GL_EXT_texture_object');4906
GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle');4907
GL_EXT_texture_sRGB := CheckExtension('GL_EXT_texture_sRGB');4908
GL_EXT_texture_shared_exponent := CheckExtension('GL_EXT_texture_shared_exponent');4909
GL_EXT_timer_query := CheckExtension('GL_EXT_timer_query');4910
GL_EXT_transform_feedback := CheckExtension('GL_EXT_transform_feedback');4911
GL_EXT_vertex_array := CheckExtension('GL_EXT_vertex_array');4913
GL_HP_occlusion_test := CheckExtension('GL_HP_occlusion_test');4915
GL_IBM_rasterpos_clip := CheckExtension('GL_IBM_rasterpos_clip');4917
GL_KTX_buffer_region := CheckExtension('GL_KTX_buffer_region');4919
GL_MESA_resize_buffers := CheckExtension('GL_MESA_resize_buffers');4921
GL_NV_blend_square := CheckExtension('GL_NV_blend_square');4922
GL_NV_conditional_render := CheckExtension('GL_NV_conditional_render');4923
GL_NV_copy_image := CheckExtension('GL_NV_copy_image');4924
GL_NV_depth_buffer_float := CheckExtension('GL_NV_depth_buffer_float');4925
GL_NV_fence := CheckExtension('GL_NV_fence');4926
GL_NV_float_buffer := CheckExtension('GL_NV_float_buffer');4927
GL_NV_fog_distance := CheckExtension('GL_NV_fog_distance');4928
GL_NV_geometry_program4 := CheckExtension('GL_NV_geometry_program4');4929
GL_NV_light_max_exponent := CheckExtension('GL_NV_light_max_exponent');4930
GL_NV_multisample_filter_hint := CheckExtension('GL_NV_multisample_filter_hint');4931
GL_NV_occlusion_query := CheckExtension('GL_NV_occlusion_query');4932
GL_NV_point_sprite := CheckExtension('GL_NV_point_sprite');4933
GL_NV_primitive_restart := CheckExtension('GL_NV_primitive_restart');4934
GL_NV_register_combiners := CheckExtension('GL_NV_register_combiners');4935
GL_NV_shader_buffer_load := CheckExtension('GL_NV_shader_buffer_load');4936
GL_NV_texgen_reflection := CheckExtension('GL_NV_texgen_reflection');4937
GL_NV_texture_compression_vtc := CheckExtension('GL_NV_texture_compression_vtc');4938
GL_NV_texture_env_combine4 := CheckExtension('GL_NV_texture_env_combine4');4939
GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle');4940
GL_NV_texture_shader := CheckExtension('GL_NV_texture_shader');4941
GL_NV_texture_shader2 := CheckExtension('GL_NV_texture_shader2');4942
GL_NV_texture_shader3 := CheckExtension('GL_NV_texture_shader3');4943
GL_NV_transform_feedback := CheckExtension('GL_NV_transform_feedback');4944
GL_NV_vertex_array_range := CheckExtension('GL_NV_vertex_array_range');4945
GL_NV_vertex_array_range2 := CheckExtension('GL_NV_vertex_array_range2');4946
GL_NV_vertex_buffer_unified_memory := CheckExtension('GL_NV_vertex_buffer_unified_memory');4947
GL_NV_vertex_program := CheckExtension('GL_NV_vertex_program');4949
GL_SGI_color_matrix := CheckExtension('GL_SGI_color_matrix');4951
GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap');4952
GL_SGIS_multisample := CheckExtension('GL_SGIS_multisample');4953
GL_SGIS_texture_border_clamp := CheckExtension('GL_SGIS_texture_border_clamp');4954
GL_SGIS_texture_color_mask := CheckExtension('GL_SGIS_texture_color_mask');4955
GL_SGIS_texture_edge_clamp := CheckExtension('GL_SGIS_texture_edge_clamp');4956
GL_SGIS_texture_lod := CheckExtension('GL_SGIS_texture_lod');4958
GL_SGIX_depth_texture := CheckExtension('GL_SGIX_depth_texture');4959
GL_SGIX_shadow := CheckExtension('GL_SGIX_shadow'); 4960
GL_SGIX_shadow_ambient := CheckExtension('GL_SGIX_shadow_ambient');4962
GL_AMD_vertex_shader_tessellator := CheckExtension('GL_AMD_vertex_shader_tessellator');4964
GL_WIN_swap_hint := CheckExtension('GL_WIN_swap_hint');4966
GL_GREMEDY_frame_terminator := CheckExtension('GL_GREMEDY_frame_terminator');4967
GL_GREMEDY_string_marker := CheckExtension('GL_GREMEDY_string_marker');4969
// check supported GLU extensions
4970
Buffer := String(gluGetString(GLU_EXTENSIONS));
4971
GLU_EXT_nurbs_tessellator := CheckExtension('GLU_EXT_nurbs_tessellator');4972
GLU_EXT_object_space_tess := CheckExtension('GLU_EXT_object_space_tess');4973
GLU_EXT_TEXTURE := CheckExtension('GLU_EXT_TEXTURE');4975
{$IFDEF SUPPORT_WGL}4976
//check supported WGL extensions
4977
ReadWGLImplementationProperties;
4980
{$IFDEF SUPPORT_GLX}4981
//check supported GLX extensions
4982
ReadGLXImplementationProperties;
4987
// ReadWGLImplementationProperties
4989
procedure ReadWGLImplementationProperties;
4993
// Checks if the given Extension string is in Buffer.
4994
function CheckExtension(const Extension: string): Boolean;
4998
// First find the position of the extension string as substring in Buffer.
4999
ExtPos := Pos(Extension, Buffer);
5000
Result := ExtPos > 0;
5001
// Now check that it isn't only a substring of another extension.
5003
Result := ((ExtPos + Length(Extension) - 1)= Length(Buffer))
5004
or (Buffer[ExtPos + Length(Extension)]=' ');
5008
// ARB wgl extensions
5009
if Assigned(wglGetExtensionsStringARB) then
5010
Buffer:=String(wglGetExtensionsStringARB(wglGetCurrentDC))
5012
WGL_ARB_buffer_region:=CheckExtension('WGL_ARB_buffer_region');5013
WGL_ARB_create_context := CheckExtension('WGL_ARB_create_context');5014
WGL_ARB_create_context_profile := CheckExtension('WGL_ARB_create_context_profile');5015
WGL_ARB_extensions_string:=CheckExtension('WGL_ARB_extensions_string');5016
WGL_ARB_framebuffer_sRGB := CheckExtension('WGL_ARB_framebuffer_sRGB');5017
WGL_ARB_make_current_read:=CheckExtension('WGL_ARB_make_current_read');5018
WGL_ARB_multisample:=CheckExtension('WGL_ARB_multisample');5019
WGL_ARB_pbuffer:=CheckExtension('WGL_ARB_pbuffer');5020
WGL_ARB_pixel_format:=CheckExtension('WGL_ARB_pixel_format');5021
WGL_ARB_pixel_format_float:=CheckExtension('WGL_ARB_pixel_format_float');5022
WGL_ARB_render_texture:=CheckExtension('WGL_ARB_render_texture');5023
// Vendor/EXT wgl extensions
5024
WGL_ATI_pixel_format_float := CheckExtension('WGL_ATI_pixel_format_float');5025
WGL_EXT_framebuffer_sRGB := CheckExtension('WGL_EXT_framebuffer_sRGB');5026
WGL_EXT_pixel_format_packed_float := CheckExtension('WGL_EXT_pixel_format_packed_float');5027
WGL_EXT_swap_control := CheckExtension('WGL_EXT_swap_control');5028
WGL_NV_gpu_affinity := CheckExtension('WGL_NV_gpu_affinity');5033
// ReadGLXImplementationProperties
5035
procedure ReadGLXImplementationProperties;
5038
MajorVersion, MinorVersion: Integer;
5040
// Checks if the given Extension string is in Buffer.
5041
function CheckExtension(const Extension: string): Boolean;
5045
// First find the position of the extension string as substring in Buffer.
5046
ExtPos := Pos(Extension, Buffer);
5047
Result := ExtPos > 0;
5048
// Now check that it isn't only a substring of another extension.
5050
Result := ((ExtPos + Length(Extension) - 1)= Length(Buffer))
5051
or (Buffer[ExtPos + Length(Extension)]=' ');
5054
Dpy:=glXGetCurrentDisplay();
5055
buffer:=String(glXQueryServerString(Dpy, XDefaultScreen(Dpy), GLX_VERSION));
5056
TrimAndSplitVersionString(buffer, majorversion, minorVersion);
5057
GLX_VERSION_1_1:=IsVersionMet(1,1,majorVersion,minorVersion);
5058
GLX_VERSION_1_2:=IsVersionMet(1,2,majorVersion,minorVersion);
5059
GLX_VERSION_1_3:=IsVersionMet(1,3,majorVersion,minorVersion);
5060
GLX_VERSION_1_4:=IsVersionMet(1,4,majorVersion,minorVersion);
5062
// This procedure will probably need changing, as totally untested
5063
// This might only work if GLX functions/procedures are loaded dynamically
5065
if Assigned(@glXQueryExtensionsString) then
5066
Buffer := glXQueryExtensionsString(Dpy, 0) //guess at a valid screen
5069
GLX_ARB_create_context := CheckExtension('GLX_ARB_create_context');5070
GLX_ARB_create_context_profile := CheckExtension('GLX_ARB_create_context_profile');5071
GLX_ARB_framebuffer_sRGB := CheckExtension('GLX_ARB_framebuffer_sRGB');5072
GLX_EXT_framebuffer_sRGB := CheckExtension('GLX_EXT_framebuffer_sRGB');5073
GLX_EXT_fbconfig_packed_float := CheckExtension('GLX_EXT_fbconfig_packed_float');5074
GLX_SGI_swap_control := CheckExtension('GLX_SGI_swap_control');5075
GLX_ARB_multisample := CheckExtension('GLX_ARB_multisample');5077
GLX_SGIS_multisample := CheckExtension('GLX_SGIS_multisample');5078
GLX_EXT_visual_info := CheckExtension('GLX_EXT_visual_info');5079
GLX_SGI_video_sync := CheckExtension('GLX_SGI_video_sync');5080
GLX_SGI_make_current_read := CheckExtension('GLX_SGI_make_current_read');5081
GLX_SGIX_video_source := CheckExtension('GLX_SGIX_video_source');5082
GLX_EXT_visual_rating := CheckExtension('GLX_EXT_visual_rating');5083
GLX_EXT_import_context := CheckExtension('GLX_EXT_import_context');5084
GLX_SGIX_fbconfig := CheckExtension('GLX_SGIX_fbconfig');5085
GLX_SGIX_pbuffer := CheckExtension('GLX_SGIX_pbuffer');5086
GLX_SGI_cushion := CheckExtension('GLX_SGI_cushion');5087
GLX_SGIX_video_resize := CheckExtension('GLX_SGIX_video_resize');5088
GLX_SGIX_dmbuffer := CheckExtension('GLX_SGIX_dmbuffer');5089
GLX_SGIX_swap_group := CheckExtension('GLX_SGIX_swap_group');5090
GLX_SGIX_swap_barrier := CheckExtension('GLX_SGIX_swap_barrier');5091
GLX_SGIS_blended_overlay := CheckExtension('GLX_SGIS_blended_overlay');5092
GLX_SGIS_shared_multisample := CheckExtension('GLX_SGIS_shared_multisample');5093
GLX_SUN_get_transparent_index := CheckExtension('GLX_SUN_get_transparent_index');5094
GLX_3DFX_multisample := CheckExtension('GLX_3DFX_multisample');5095
GLX_MESA_copy_sub_buffer := CheckExtension('GLX_MESA_copy_sub_buffer');5096
GLX_MESA_pixmap_colormap := CheckExtension('GLX_MESA_pixmap_colormap');5097
GLX_MESA_release_buffers := CheckExtension('GLX_MESA_release_buffers');5098
GLX_MESA_set_3dfx_mode := CheckExtension('GLX_MESA_set_3dfx_mode');5099
GLX_SGIX_visual_select_group := CheckExtension('GLX_SGIX_visual_select_group');5100
GLX_SGIX_hyperpipe := CheckExtension('GLX_SGIX_hyperpipe');5106
procedure CloseOpenGL;
5108
if GLHandle<>INVALID_MODULEHANDLE then begin
5109
FreeLibrary(Cardinal(GLHandle));
5110
GLHandle:=INVALID_MODULEHANDLE;
5113
if GLUHandle<>INVALID_MODULEHANDLE then begin
5114
FreeLibrary(Cardinal(GLUHandle));
5115
GLUHandle:=INVALID_MODULEHANDLE;
5121
function InitOpenGL : Boolean;
5123
if (GLHandle=INVALID_MODULEHANDLE) or (GLUHandle=INVALID_MODULEHANDLE) then
5124
Result:=InitOpenGLFromLibrary(opengl32, glu32)
5128
// InitOpenGLFromLibrary
5130
function InitOpenGLFromLibrary(const GLName, GLUName : String) : Boolean;
5135
GLHandle:=LoadLibrary(PChar(GLName));
5136
GLUHandle:=LoadLibrary(PChar(GLUName));
5138
{$IFDEF Linux} // make it work when mesa-dev is not installed and only libGL.so.1 is available5139
if (GLHandle=INVALID_MODULEHANDLE) then
5140
GLHandle:=LoadLibrary(PChar(GLName+'.1'));
5141
if (GLUHandle=INVALID_MODULEHANDLE) then
5142
GLUHandle:=LoadLibrary(PChar(GLUName+'.1'));
5145
if (GLHandle<>INVALID_MODULEHANDLE) and (GLUHandle<>INVALID_MODULEHANDLE) then
5148
if GLHandle<>INVALID_MODULEHANDLE then
5149
FreeLibrary(Cardinal(GLHandle));
5150
if GLUHandle<>INVALID_MODULEHANDLE then
5151
FreeLibrary(Cardinal(GLUHandle));
5155
// IsOpenGLInitialized
5157
function IsOpenGLInitialized: Boolean;
5159
Result:=(GLHandle<>INVALID_MODULEHANDLE);
5162
// compatibility routines
5166
procedure UnloadOpenGL;
5173
function LoadOpenGL: Boolean;
5175
Result := InitOpenGL;
5178
// LoadOpenGLFromLibrary
5180
function LoadOpenGLFromLibrary(GLName, GLUName: String): Boolean;
5182
Result := InitOpenGLFromLibrary(GLName, GLUName);
5187
function IsOpenGLLoaded: Boolean;
5189
Result := IsOpenGLInitialized();
5194
function IsMesaGL : Boolean;
5196
Result:=GLGetProcAddress('glResizeBuffersMESA')<>nil;5199
// IsOpenGLVersionMet
5201
function IsOpenGLVersionMet(MajorVersion, MinorVersion: Integer): boolean;
5204
GLMajorVersion, GLMinorVersion: Integer;
5206
buffer:=String(glGetString(GL_VERSION));
5207
TrimAndSplitVersionString(buffer, GLMajorVersion, GLMinorVersion);
5208
Result:=IsVersionMet(MajorVersion,MinorVersion,GLMajorVersion,GLMinorVersion);