CoCalc -- check

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/mapi/glapi/tests/check_table.cpp
⁴⁵⁶⁵ views
1
/*
2
 * Copyright © 2012 Intel Corporation
3
 *
4
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 * copy of this software and associated documentation files (the "Software"),
6
 * to deal in the Software without restriction, including without limitation
7
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 * and/or sell copies of the Software, and to permit persons to whom the
9
 * Software is furnished to do so, subject to the following conditions:
10
 *
11
 * The above copyright notice and this permission notice (including the next
12
 * paragraph) shall be included in all copies or substantial portions of the
13
 * Software.
14
 *
15
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21
 * DEALINGS IN THE SOFTWARE.
22
 */
23

24
#include <gtest/gtest.h>
25
#include "main/glheader.h"
26

27
#include "glapi/glapi.h"
28
#include "glapitable.h"
29

30
struct name_offset {
31
   const char *name;
32
   unsigned int offset;
33
};
34

35
extern const struct name_offset linux_gl_abi[];
36
extern const struct name_offset known_dispatch[];
37

38
TEST(GetProcAddress, ABIOffsetByName)
39
{
40
   /* 408 functions have had their locations in the dispatch table set since
41
    * the dawn of time.  Verify that all of these functions are at the correct
42
    * locations.
43
    */
44
   for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) {
45
      EXPECT_EQ(linux_gl_abi[i].offset,
46
		_glapi_get_proc_offset(linux_gl_abi[i].name))
47
	 << "function name: " << linux_gl_abi[i].name;
48
   }
49
}
50

51
TEST(GetProcAddress, ABINameByOffset)
52
{
53
   /* 408 functions have had their locations in the dispatch table set since
54
    * the dawn of time.  Verify that all of these functions are at the correct
55
    * locations.
56
    */
57
   for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) {
58
      EXPECT_STREQ(linux_gl_abi[i].name,
59
		   _glapi_get_proc_name(linux_gl_abi[i].offset))
60
	 << "function offset: " << linux_gl_abi[i].offset;
61
   }
62
}
63

64
TEST(GetProcAddress, TableBigEnoughForABI)
65
{
66
   const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
67

68
   EXPECT_GE(table_entries, 408u);
69
}
70

71
TEST(GetProcAddress, TableDidntShrink)
72
{
73
   const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
74

75
   /* The dispatch table is not expected to shrink.  At GIT commit b45052b the
76
    * table had 978 entries.  Changes that intentionally reduce the size of
77
    * the table are very rare.  In those cases, the expected value should be
78
    * updated to reflect the change.
79
    *
80
    * Changes that accidentally reduce the size of the table are bugs, and
81
    * they should be fixed.
82
    *
83
    * 6 entries were removed when GL_SGIS_pixel_texture was removed from the
84
    * dispatch table.
85
    *
86
    * 1 entry was removed when GL_SGIX_pixel_texture was removed from the
87
    * dispatch table.
88
    *
89
    * 2 entries were removed when GL_APPLE_texture_range was removed from the
90
    * dispatch table.
91
    *
92
    * 13 entries were removed when GL_NV_register_combiners was removed from
93
    * the dispatch table.
94
    *
95
    * 7 entries were removed when GL_NV_fence was removed from the dispatch
96
    * table.
97
    *
98
    * 2 entries were removed when GL_NV_vertex_array_range was removed from
99
    * the dispatch table.
100
    */
101
   EXPECT_GE(table_entries, 978u - 6u - 1u - 2u - 13u - 7u - 2u);
102
}
103

104
TEST(GetProcAddress, QueriedDispatchSizeBigEnough)
105
{
106
   const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *);
107

108
   /* _glapi_get_dispatch_table_size returns the size of the extended dispatch
109
    * table.  This is the size of the static table with some extra entries for
110
    * drivers to use for extensions that the core does not know about.
111
    */
112
   EXPECT_LT(table_entries, _glapi_get_dispatch_table_size());
113
}
114

115
TEST(GetProcAddress, KnownDispatchOffsetsAreConsistent)
116
{
117
   /* Verify that the queried dispatch offset for every known function is
118
    * consistent with its location in the static dispatch table.
119
    *
120
    * There is some redundancy between this test and ABIOffsetByName.  That's
121
    * okay.  The offsets in ABIOffsetByName comdirectly from the ABI
122
    * definition.  The offsets in this test come from locations in a structure
123
    * definition generated by scripts.
124
    */
125
   for (unsigned i = 0; known_dispatch[i].name != NULL; i++) {
126
      EXPECT_EQ(known_dispatch[i].offset,
127
		_glapi_get_proc_offset(known_dispatch[i].name))
128
	 << "function name: " << known_dispatch[i].name;
129
   }
130
}
131

132
TEST(GetProcAddress, KnownDispatchNamesAreConsistent)
133
{
134
   /* Verify that the queried dispatch name for every known function is
135
    * consistent with its location in the static dispatch table.
136
    *
137
    * There is some redundancy between this test and ABINameByOffset.  That's
138
    * okay.  The offsets in ABIOffsetByName comdirectly from the ABI
139
    * definition.  The offsets in this test come from locations in a structure
140
    * definition generated by scripts.
141
    */
142
   for (unsigned i = 0; known_dispatch[i].name != NULL; i++) {
143
      EXPECT_STREQ(known_dispatch[i].name,
144
		   _glapi_get_proc_name(known_dispatch[i].offset))
145
	 << "function offset: " << known_dispatch[i].offset;
146
   }
147
}
148

149
const struct name_offset linux_gl_abi[] = {
150
   { "glNewList", 0 },
151
   { "glEndList", 1 },
152
   { "glCallList", 2 },
153
   { "glCallLists", 3 },
154
   { "glDeleteLists", 4 },
155
   { "glGenLists", 5 },
156
   { "glListBase", 6 },
157
   { "glBegin", 7 },
158
   { "glBitmap", 8 },
159
   { "glColor3b", 9 },
160
   { "glColor3bv", 10 },
161
   { "glColor3d", 11 },
162
   { "glColor3dv", 12 },
163
   { "glColor3f", 13 },
164
   { "glColor3fv", 14 },
165
   { "glColor3i", 15 },
166
   { "glColor3iv", 16 },
167
   { "glColor3s", 17 },
168
   { "glColor3sv", 18 },
169
   { "glColor3ub", 19 },
170
   { "glColor3ubv", 20 },
171
   { "glColor3ui", 21 },
172
   { "glColor3uiv", 22 },
173
   { "glColor3us", 23 },
174
   { "glColor3usv", 24 },
175
   { "glColor4b", 25 },
176
   { "glColor4bv", 26 },
177
   { "glColor4d", 27 },
178
   { "glColor4dv", 28 },
179
   { "glColor4f", 29 },
180
   { "glColor4fv", 30 },
181
   { "glColor4i", 31 },
182
   { "glColor4iv", 32 },
183
   { "glColor4s", 33 },
184
   { "glColor4sv", 34 },
185
   { "glColor4ub", 35 },
186
   { "glColor4ubv", 36 },
187
   { "glColor4ui", 37 },
188
   { "glColor4uiv", 38 },
189
   { "glColor4us", 39 },
190
   { "glColor4usv", 40 },
191
   { "glEdgeFlag", 41 },
192
   { "glEdgeFlagv", 42 },
193
   { "glEnd", 43 },
194
   { "glIndexd", 44 },
195
   { "glIndexdv", 45 },
196
   { "glIndexf", 46 },
197
   { "glIndexfv", 47 },
198
   { "glIndexi", 48 },
199
   { "glIndexiv", 49 },
200
   { "glIndexs", 50 },
201
   { "glIndexsv", 51 },
202
   { "glNormal3b", 52 },
203
   { "glNormal3bv", 53 },
204
   { "glNormal3d", 54 },
205
   { "glNormal3dv", 55 },
206
   { "glNormal3f", 56 },
207
   { "glNormal3fv", 57 },
208
   { "glNormal3i", 58 },
209
   { "glNormal3iv", 59 },
210
   { "glNormal3s", 60 },
211
   { "glNormal3sv", 61 },
212
   { "glRasterPos2d", 62 },
213
   { "glRasterPos2dv", 63 },
214
   { "glRasterPos2f", 64 },
215
   { "glRasterPos2fv", 65 },
216
   { "glRasterPos2i", 66 },
217
   { "glRasterPos2iv", 67 },
218
   { "glRasterPos2s", 68 },
219
   { "glRasterPos2sv", 69 },
220
   { "glRasterPos3d", 70 },
221
   { "glRasterPos3dv", 71 },
222
   { "glRasterPos3f", 72 },
223
   { "glRasterPos3fv", 73 },
224
   { "glRasterPos3i", 74 },
225
   { "glRasterPos3iv", 75 },
226
   { "glRasterPos3s", 76 },
227
   { "glRasterPos3sv", 77 },
228
   { "glRasterPos4d", 78 },
229
   { "glRasterPos4dv", 79 },
230
   { "glRasterPos4f", 80 },
231
   { "glRasterPos4fv", 81 },
232
   { "glRasterPos4i", 82 },
233
   { "glRasterPos4iv", 83 },
234
   { "glRasterPos4s", 84 },
235
   { "glRasterPos4sv", 85 },
236
   { "glRectd", 86 },
237
   { "glRectdv", 87 },
238
   { "glRectf", 88 },
239
   { "glRectfv", 89 },
240
   { "glRecti", 90 },
241
   { "glRectiv", 91 },
242
   { "glRects", 92 },
243
   { "glRectsv", 93 },
244
   { "glTexCoord1d", 94 },
245
   { "glTexCoord1dv", 95 },
246
   { "glTexCoord1f", 96 },
247
   { "glTexCoord1fv", 97 },
248
   { "glTexCoord1i", 98 },
249
   { "glTexCoord1iv", 99 },
250
   { "glTexCoord1s", 100 },
251
   { "glTexCoord1sv", 101 },
252
   { "glTexCoord2d", 102 },
253
   { "glTexCoord2dv", 103 },
254
   { "glTexCoord2f", 104 },
255
   { "glTexCoord2fv", 105 },
256
   { "glTexCoord2i", 106 },
257
   { "glTexCoord2iv", 107 },
258
   { "glTexCoord2s", 108 },
259
   { "glTexCoord2sv", 109 },
260
   { "glTexCoord3d", 110 },
261
   { "glTexCoord3dv", 111 },
262
   { "glTexCoord3f", 112 },
263
   { "glTexCoord3fv", 113 },
264
   { "glTexCoord3i", 114 },
265
   { "glTexCoord3iv", 115 },
266
   { "glTexCoord3s", 116 },
267
   { "glTexCoord3sv", 117 },
268
   { "glTexCoord4d", 118 },
269
   { "glTexCoord4dv", 119 },
270
   { "glTexCoord4f", 120 },
271
   { "glTexCoord4fv", 121 },
272
   { "glTexCoord4i", 122 },
273
   { "glTexCoord4iv", 123 },
274
   { "glTexCoord4s", 124 },
275
   { "glTexCoord4sv", 125 },
276
   { "glVertex2d", 126 },
277
   { "glVertex2dv", 127 },
278
   { "glVertex2f", 128 },
279
   { "glVertex2fv", 129 },
280
   { "glVertex2i", 130 },
281
   { "glVertex2iv", 131 },
282
   { "glVertex2s", 132 },
283
   { "glVertex2sv", 133 },
284
   { "glVertex3d", 134 },
285
   { "glVertex3dv", 135 },
286
   { "glVertex3f", 136 },
287
   { "glVertex3fv", 137 },
288
   { "glVertex3i", 138 },
289
   { "glVertex3iv", 139 },
290
   { "glVertex3s", 140 },
291
   { "glVertex3sv", 141 },
292
   { "glVertex4d", 142 },
293
   { "glVertex4dv", 143 },
294
   { "glVertex4f", 144 },
295
   { "glVertex4fv", 145 },
296
   { "glVertex4i", 146 },
297
   { "glVertex4iv", 147 },
298
   { "glVertex4s", 148 },
299
   { "glVertex4sv", 149 },
300
   { "glClipPlane", 150 },
301
   { "glColorMaterial", 151 },
302
   { "glCullFace", 152 },
303
   { "glFogf", 153 },
304
   { "glFogfv", 154 },
305
   { "glFogi", 155 },
306
   { "glFogiv", 156 },
307
   { "glFrontFace", 157 },
308
   { "glHint", 158 },
309
   { "glLightf", 159 },
310
   { "glLightfv", 160 },
311
   { "glLighti", 161 },
312
   { "glLightiv", 162 },
313
   { "glLightModelf", 163 },
314
   { "glLightModelfv", 164 },
315
   { "glLightModeli", 165 },
316
   { "glLightModeliv", 166 },
317
   { "glLineStipple", 167 },
318
   { "glLineWidth", 168 },
319
   { "glMaterialf", 169 },
320
   { "glMaterialfv", 170 },
321
   { "glMateriali", 171 },
322
   { "glMaterialiv", 172 },
323
   { "glPointSize", 173 },
324
   { "glPolygonMode", 174 },
325
   { "glPolygonStipple", 175 },
326
   { "glScissor", 176 },
327
   { "glShadeModel", 177 },
328
   { "glTexParameterf", 178 },
329
   { "glTexParameterfv", 179 },
330
   { "glTexParameteri", 180 },
331
   { "glTexParameteriv", 181 },
332
   { "glTexImage1D", 182 },
333
   { "glTexImage2D", 183 },
334
   { "glTexEnvf", 184 },
335
   { "glTexEnvfv", 185 },
336
   { "glTexEnvi", 186 },
337
   { "glTexEnviv", 187 },
338
   { "glTexGend", 188 },
339
   { "glTexGendv", 189 },
340
   { "glTexGenf", 190 },
341
   { "glTexGenfv", 191 },
342
   { "glTexGeni", 192 },
343
   { "glTexGeniv", 193 },
344
   { "glFeedbackBuffer", 194 },
345
   { "glSelectBuffer", 195 },
346
   { "glRenderMode", 196 },
347
   { "glInitNames", 197 },
348
   { "glLoadName", 198 },
349
   { "glPassThrough", 199 },
350
   { "glPopName", 200 },
351
   { "glPushName", 201 },
352
   { "glDrawBuffer", 202 },
353
   { "glClear", 203 },
354
   { "glClearAccum", 204 },
355
   { "glClearIndex", 205 },
356
   { "glClearColor", 206 },
357
   { "glClearStencil", 207 },
358
   { "glClearDepth", 208 },
359
   { "glStencilMask", 209 },
360
   { "glColorMask", 210 },
361
   { "glDepthMask", 211 },
362
   { "glIndexMask", 212 },
363
   { "glAccum", 213 },
364
   { "glDisable", 214 },
365
   { "glEnable", 215 },
366
   { "glFinish", 216 },
367
   { "glFlush", 217 },
368
   { "glPopAttrib", 218 },
369
   { "glPushAttrib", 219 },
370
   { "glMap1d", 220 },
371
   { "glMap1f", 221 },
372
   { "glMap2d", 222 },
373
   { "glMap2f", 223 },
374
   { "glMapGrid1d", 224 },
375
   { "glMapGrid1f", 225 },
376
   { "glMapGrid2d", 226 },
377
   { "glMapGrid2f", 227 },
378
   { "glEvalCoord1d", 228 },
379
   { "glEvalCoord1dv", 229 },
380
   { "glEvalCoord1f", 230 },
381
   { "glEvalCoord1fv", 231 },
382
   { "glEvalCoord2d", 232 },
383
   { "glEvalCoord2dv", 233 },
384
   { "glEvalCoord2f", 234 },
385
   { "glEvalCoord2fv", 235 },
386
   { "glEvalMesh1", 236 },
387
   { "glEvalPoint1", 237 },
388
   { "glEvalMesh2", 238 },
389
   { "glEvalPoint2", 239 },
390
   { "glAlphaFunc", 240 },
391
   { "glBlendFunc", 241 },
392
   { "glLogicOp", 242 },
393
   { "glStencilFunc", 243 },
394
   { "glStencilOp", 244 },
395
   { "glDepthFunc", 245 },
396
   { "glPixelZoom", 246 },
397
   { "glPixelTransferf", 247 },
398
   { "glPixelTransferi", 248 },
399
   { "glPixelStoref", 249 },
400
   { "glPixelStorei", 250 },
401
   { "glPixelMapfv", 251 },
402
   { "glPixelMapuiv", 252 },
403
   { "glPixelMapusv", 253 },
404
   { "glReadBuffer", 254 },
405
   { "glCopyPixels", 255 },
406
   { "glReadPixels", 256 },
407
   { "glDrawPixels", 257 },
408
   { "glGetBooleanv", 258 },
409
   { "glGetClipPlane", 259 },
410
   { "glGetDoublev", 260 },
411
   { "glGetError", 261 },
412
   { "glGetFloatv", 262 },
413
   { "glGetIntegerv", 263 },
414
   { "glGetLightfv", 264 },
415
   { "glGetLightiv", 265 },
416
   { "glGetMapdv", 266 },
417
   { "glGetMapfv", 267 },
418
   { "glGetMapiv", 268 },
419
   { "glGetMaterialfv", 269 },
420
   { "glGetMaterialiv", 270 },
421
   { "glGetPixelMapfv", 271 },
422
   { "glGetPixelMapuiv", 272 },
423
   { "glGetPixelMapusv", 273 },
424
   { "glGetPolygonStipple", 274 },
425
   { "glGetString", 275 },
426
   { "glGetTexEnvfv", 276 },
427
   { "glGetTexEnviv", 277 },
428
   { "glGetTexGendv", 278 },
429
   { "glGetTexGenfv", 279 },
430
   { "glGetTexGeniv", 280 },
431
   { "glGetTexImage", 281 },
432
   { "glGetTexParameterfv", 282 },
433
   { "glGetTexParameteriv", 283 },
434
   { "glGetTexLevelParameterfv", 284 },
435
   { "glGetTexLevelParameteriv", 285 },
436
   { "glIsEnabled", 286 },
437
   { "glIsList", 287 },
438
   { "glDepthRange", 288 },
439
   { "glFrustum", 289 },
440
   { "glLoadIdentity", 290 },
441
   { "glLoadMatrixf", 291 },
442
   { "glLoadMatrixd", 292 },
443
   { "glMatrixMode", 293 },
444
   { "glMultMatrixf", 294 },
445
   { "glMultMatrixd", 295 },
446
   { "glOrtho", 296 },
447
   { "glPopMatrix", 297 },
448
   { "glPushMatrix", 298 },
449
   { "glRotated", 299 },
450
   { "glRotatef", 300 },
451
   { "glScaled", 301 },
452
   { "glScalef", 302 },
453
   { "glTranslated", 303 },
454
   { "glTranslatef", 304 },
455
   { "glViewport", 305 },
456
   { "glArrayElement", 306 },
457
   { "glColorPointer", 308 },
458
   { "glDisableClientState", 309 },
459
   { "glDrawArrays", 310 },
460
   { "glDrawElements", 311 },
461
   { "glEdgeFlagPointer", 312 },
462
   { "glEnableClientState", 313 },
463
   { "glGetPointerv", 329 },
464
   { "glIndexPointer", 314 },
465
   { "glInterleavedArrays", 317 },
466
   { "glNormalPointer", 318 },
467
   { "glTexCoordPointer", 320 },
468
   { "glVertexPointer", 321 },
469
   { "glPolygonOffset", 319 },
470
   { "glCopyTexImage1D", 323 },
471
   { "glCopyTexImage2D", 324 },
472
   { "glCopyTexSubImage1D", 325 },
473
   { "glCopyTexSubImage2D", 326 },
474
   { "glTexSubImage1D", 332 },
475
   { "glTexSubImage2D", 333 },
476
   { "glAreTexturesResident", 322 },
477
   { "glBindTexture", 307 },
478
   { "glDeleteTextures", 327 },
479
   { "glGenTextures", 328 },
480
   { "glIsTexture", 330 },
481
   { "glPrioritizeTextures", 331 },
482
   { "glIndexub", 315 },
483
   { "glIndexubv", 316 },
484
   { "glPopClientAttrib", 334 },
485
   { "glPushClientAttrib", 335 },
486
   { "glBlendColor", 336 },
487
   { "glBlendEquation", 337 },
488
   { "glDrawRangeElements", 338 },
489
   { "glColorTable", 339 },
490
   { "glColorTableParameterfv", 340 },
491
   { "glColorTableParameteriv", 341 },
492
   { "glCopyColorTable", 342 },
493
   { "glGetColorTable", 343 },
494
   { "glGetColorTableParameterfv", 344 },
495
   { "glGetColorTableParameteriv", 345 },
496
   { "glColorSubTable", 346 },
497
   { "glCopyColorSubTable", 347 },
498
   { "glConvolutionFilter1D", 348 },
499
   { "glConvolutionFilter2D", 349 },
500
   { "glConvolutionParameterf", 350 },
501
   { "glConvolutionParameterfv", 351 },
502
   { "glConvolutionParameteri", 352 },
503
   { "glConvolutionParameteriv", 353 },
504
   { "glCopyConvolutionFilter1D", 354 },
505
   { "glCopyConvolutionFilter2D", 355 },
506
   { "glGetConvolutionFilter", 356 },
507
   { "glGetConvolutionParameterfv", 357 },
508
   { "glGetConvolutionParameteriv", 358 },
509
   { "glGetSeparableFilter", 359 },
510
   { "glSeparableFilter2D", 360 },
511
   { "glGetHistogram", 361 },
512
   { "glGetHistogramParameterfv", 362 },
513
   { "glGetHistogramParameteriv", 363 },
514
   { "glGetMinmax", 364 },
515
   { "glGetMinmaxParameterfv", 365 },
516
   { "glGetMinmaxParameteriv", 366 },
517
   { "glHistogram", 367 },
518
   { "glMinmax", 368 },
519
   { "glResetHistogram", 369 },
520
   { "glResetMinmax", 370 },
521
   { "glTexImage3D", 371 },
522
   { "glTexSubImage3D", 372 },
523
   { "glCopyTexSubImage3D", 373 },
524
   { "glActiveTexture", 374 },
525
   { "glClientActiveTexture", 375 },
526
   { "glMultiTexCoord1d", 376 },
527
   { "glMultiTexCoord1dv", 377 },
528
   { "glMultiTexCoord1fARB", 378 },
529
   { "glMultiTexCoord1fvARB", 379 },
530
   { "glMultiTexCoord1i", 380 },
531
   { "glMultiTexCoord1iv", 381 },
532
   { "glMultiTexCoord1s", 382 },
533
   { "glMultiTexCoord1sv", 383 },
534
   { "glMultiTexCoord2d", 384 },
535
   { "glMultiTexCoord2dv", 385 },
536
   { "glMultiTexCoord2fARB", 386 },
537
   { "glMultiTexCoord2fvARB", 387 },
538
   { "glMultiTexCoord2i", 388 },
539
   { "glMultiTexCoord2iv", 389 },
540
   { "glMultiTexCoord2s", 390 },
541
   { "glMultiTexCoord2sv", 391 },
542
   { "glMultiTexCoord3d", 392 },
543
   { "glMultiTexCoord3dv", 393 },
544
   { "glMultiTexCoord3fARB", 394 },
545
   { "glMultiTexCoord3fvARB", 395 },
546
   { "glMultiTexCoord3i", 396 },
547
   { "glMultiTexCoord3iv", 397 },
548
   { "glMultiTexCoord3s", 398 },
549
   { "glMultiTexCoord3sv", 399 },
550
   { "glMultiTexCoord4d", 400 },
551
   { "glMultiTexCoord4dv", 401 },
552
   { "glMultiTexCoord4fARB", 402 },
553
   { "glMultiTexCoord4fvARB", 403 },
554
   { "glMultiTexCoord4i", 404 },
555
   { "glMultiTexCoord4iv", 405 },
556
   { "glMultiTexCoord4s", 406 },
557
   { "glMultiTexCoord4sv", 407 },
558
   { NULL, 0 }
559
};
560

561
#define _O(f) ((intptr_t) & (((struct _glapi_table *) 0)->f)) / sizeof(void *)
562

563
const struct name_offset known_dispatch[] = {
564
   { "glNewList", _O(NewList) },
565
   { "glEndList", _O(EndList) },
566
   { "glCallList", _O(CallList) },
567
   { "glCallLists", _O(CallLists) },
568
   { "glDeleteLists", _O(DeleteLists) },
569
   { "glGenLists", _O(GenLists) },
570
   { "glListBase", _O(ListBase) },
571
   { "glBegin", _O(Begin) },
572
   { "glBitmap", _O(Bitmap) },
573
   { "glColor3b", _O(Color3b) },
574
   { "glColor3bv", _O(Color3bv) },
575
   { "glColor3d", _O(Color3d) },
576
   { "glColor3dv", _O(Color3dv) },
577
   { "glColor3f", _O(Color3f) },
578
   { "glColor3fv", _O(Color3fv) },
579
   { "glColor3i", _O(Color3i) },
580
   { "glColor3iv", _O(Color3iv) },
581
   { "glColor3s", _O(Color3s) },
582
   { "glColor3sv", _O(Color3sv) },
583
   { "glColor3ub", _O(Color3ub) },
584
   { "glColor3ubv", _O(Color3ubv) },
585
   { "glColor3ui", _O(Color3ui) },
586
   { "glColor3uiv", _O(Color3uiv) },
587
   { "glColor3us", _O(Color3us) },
588
   { "glColor3usv", _O(Color3usv) },
589
   { "glColor4b", _O(Color4b) },
590
   { "glColor4bv", _O(Color4bv) },
591
   { "glColor4d", _O(Color4d) },
592
   { "glColor4dv", _O(Color4dv) },
593
   { "glColor4f", _O(Color4f) },
594
   { "glColor4fv", _O(Color4fv) },
595
   { "glColor4i", _O(Color4i) },
596
   { "glColor4iv", _O(Color4iv) },
597
   { "glColor4s", _O(Color4s) },
598
   { "glColor4sv", _O(Color4sv) },
599
   { "glColor4ub", _O(Color4ub) },
600
   { "glColor4ubv", _O(Color4ubv) },
601
   { "glColor4ui", _O(Color4ui) },
602
   { "glColor4uiv", _O(Color4uiv) },
603
   { "glColor4us", _O(Color4us) },
604
   { "glColor4usv", _O(Color4usv) },
605
   { "glEdgeFlag", _O(EdgeFlag) },
606
   { "glEdgeFlagv", _O(EdgeFlagv) },
607
   { "glEnd", _O(End) },
608
   { "glIndexd", _O(Indexd) },
609
   { "glIndexdv", _O(Indexdv) },
610
   { "glIndexf", _O(Indexf) },
611
   { "glIndexfv", _O(Indexfv) },
612
   { "glIndexi", _O(Indexi) },
613
   { "glIndexiv", _O(Indexiv) },
614
   { "glIndexs", _O(Indexs) },
615
   { "glIndexsv", _O(Indexsv) },
616
   { "glNormal3b", _O(Normal3b) },
617
   { "glNormal3bv", _O(Normal3bv) },
618
   { "glNormal3d", _O(Normal3d) },
619
   { "glNormal3dv", _O(Normal3dv) },
620
   { "glNormal3f", _O(Normal3f) },
621
   { "glNormal3fv", _O(Normal3fv) },
622
   { "glNormal3i", _O(Normal3i) },
623
   { "glNormal3iv", _O(Normal3iv) },
624
   { "glNormal3s", _O(Normal3s) },
625
   { "glNormal3sv", _O(Normal3sv) },
626
   { "glRasterPos2d", _O(RasterPos2d) },
627
   { "glRasterPos2dv", _O(RasterPos2dv) },
628
   { "glRasterPos2f", _O(RasterPos2f) },
629
   { "glRasterPos2fv", _O(RasterPos2fv) },
630
   { "glRasterPos2i", _O(RasterPos2i) },
631
   { "glRasterPos2iv", _O(RasterPos2iv) },
632
   { "glRasterPos2s", _O(RasterPos2s) },
633
   { "glRasterPos2sv", _O(RasterPos2sv) },
634
   { "glRasterPos3d", _O(RasterPos3d) },
635
   { "glRasterPos3dv", _O(RasterPos3dv) },
636
   { "glRasterPos3f", _O(RasterPos3f) },
637
   { "glRasterPos3fv", _O(RasterPos3fv) },
638
   { "glRasterPos3i", _O(RasterPos3i) },
639
   { "glRasterPos3iv", _O(RasterPos3iv) },
640
   { "glRasterPos3s", _O(RasterPos3s) },
641
   { "glRasterPos3sv", _O(RasterPos3sv) },
642
   { "glRasterPos4d", _O(RasterPos4d) },
643
   { "glRasterPos4dv", _O(RasterPos4dv) },
644
   { "glRasterPos4f", _O(RasterPos4f) },
645
   { "glRasterPos4fv", _O(RasterPos4fv) },
646
   { "glRasterPos4i", _O(RasterPos4i) },
647
   { "glRasterPos4iv", _O(RasterPos4iv) },
648
   { "glRasterPos4s", _O(RasterPos4s) },
649
   { "glRasterPos4sv", _O(RasterPos4sv) },
650
   { "glRectd", _O(Rectd) },
651
   { "glRectdv", _O(Rectdv) },
652
   { "glRectf", _O(Rectf) },
653
   { "glRectfv", _O(Rectfv) },
654
   { "glRecti", _O(Recti) },
655
   { "glRectiv", _O(Rectiv) },
656
   { "glRects", _O(Rects) },
657
   { "glRectsv", _O(Rectsv) },
658
   { "glTexCoord1d", _O(TexCoord1d) },
659
   { "glTexCoord1dv", _O(TexCoord1dv) },
660
   { "glTexCoord1f", _O(TexCoord1f) },
661
   { "glTexCoord1fv", _O(TexCoord1fv) },
662
   { "glTexCoord1i", _O(TexCoord1i) },
663
   { "glTexCoord1iv", _O(TexCoord1iv) },
664
   { "glTexCoord1s", _O(TexCoord1s) },
665
   { "glTexCoord1sv", _O(TexCoord1sv) },
666
   { "glTexCoord2d", _O(TexCoord2d) },
667
   { "glTexCoord2dv", _O(TexCoord2dv) },
668
   { "glTexCoord2f", _O(TexCoord2f) },
669
   { "glTexCoord2fv", _O(TexCoord2fv) },
670
   { "glTexCoord2i", _O(TexCoord2i) },
671
   { "glTexCoord2iv", _O(TexCoord2iv) },
672
   { "glTexCoord2s", _O(TexCoord2s) },
673
   { "glTexCoord2sv", _O(TexCoord2sv) },
674
   { "glTexCoord3d", _O(TexCoord3d) },
675
   { "glTexCoord3dv", _O(TexCoord3dv) },
676
   { "glTexCoord3f", _O(TexCoord3f) },
677
   { "glTexCoord3fv", _O(TexCoord3fv) },
678
   { "glTexCoord3i", _O(TexCoord3i) },
679
   { "glTexCoord3iv", _O(TexCoord3iv) },
680
   { "glTexCoord3s", _O(TexCoord3s) },
681
   { "glTexCoord3sv", _O(TexCoord3sv) },
682
   { "glTexCoord4d", _O(TexCoord4d) },
683
   { "glTexCoord4dv", _O(TexCoord4dv) },
684
   { "glTexCoord4f", _O(TexCoord4f) },
685
   { "glTexCoord4fv", _O(TexCoord4fv) },
686
   { "glTexCoord4i", _O(TexCoord4i) },
687
   { "glTexCoord4iv", _O(TexCoord4iv) },
688
   { "glTexCoord4s", _O(TexCoord4s) },
689
   { "glTexCoord4sv", _O(TexCoord4sv) },
690
   { "glVertex2d", _O(Vertex2d) },
691
   { "glVertex2dv", _O(Vertex2dv) },
692
   { "glVertex2f", _O(Vertex2f) },
693
   { "glVertex2fv", _O(Vertex2fv) },
694
   { "glVertex2i", _O(Vertex2i) },
695
   { "glVertex2iv", _O(Vertex2iv) },
696
   { "glVertex2s", _O(Vertex2s) },
697
   { "glVertex2sv", _O(Vertex2sv) },
698
   { "glVertex3d", _O(Vertex3d) },
699
   { "glVertex3dv", _O(Vertex3dv) },
700
   { "glVertex3f", _O(Vertex3f) },
701
   { "glVertex3fv", _O(Vertex3fv) },
702
   { "glVertex3i", _O(Vertex3i) },
703
   { "glVertex3iv", _O(Vertex3iv) },
704
   { "glVertex3s", _O(Vertex3s) },
705
   { "glVertex3sv", _O(Vertex3sv) },
706
   { "glVertex4d", _O(Vertex4d) },
707
   { "glVertex4dv", _O(Vertex4dv) },
708
   { "glVertex4f", _O(Vertex4f) },
709
   { "glVertex4fv", _O(Vertex4fv) },
710
   { "glVertex4i", _O(Vertex4i) },
711
   { "glVertex4iv", _O(Vertex4iv) },
712
   { "glVertex4s", _O(Vertex4s) },
713
   { "glVertex4sv", _O(Vertex4sv) },
714
   { "glClipPlane", _O(ClipPlane) },
715
   { "glColorMaterial", _O(ColorMaterial) },
716
   { "glCullFace", _O(CullFace) },
717
   { "glFogf", _O(Fogf) },
718
   { "glFogfv", _O(Fogfv) },
719
   { "glFogi", _O(Fogi) },
720
   { "glFogiv", _O(Fogiv) },
721
   { "glFrontFace", _O(FrontFace) },
722
   { "glHint", _O(Hint) },
723
   { "glLightf", _O(Lightf) },
724
   { "glLightfv", _O(Lightfv) },
725
   { "glLighti", _O(Lighti) },
726
   { "glLightiv", _O(Lightiv) },
727
   { "glLightModelf", _O(LightModelf) },
728
   { "glLightModelfv", _O(LightModelfv) },
729
   { "glLightModeli", _O(LightModeli) },
730
   { "glLightModeliv", _O(LightModeliv) },
731
   { "glLineStipple", _O(LineStipple) },
732
   { "glLineWidth", _O(LineWidth) },
733
   { "glMaterialf", _O(Materialf) },
734
   { "glMaterialfv", _O(Materialfv) },
735
   { "glMateriali", _O(Materiali) },
736
   { "glMaterialiv", _O(Materialiv) },
737
   { "glPointSize", _O(PointSize) },
738
   { "glPolygonMode", _O(PolygonMode) },
739
   { "glPolygonStipple", _O(PolygonStipple) },
740
   { "glScissor", _O(Scissor) },
741
   { "glShadeModel", _O(ShadeModel) },
742
   { "glTexParameterf", _O(TexParameterf) },
743
   { "glTexParameterfv", _O(TexParameterfv) },
744
   { "glTexParameteri", _O(TexParameteri) },
745
   { "glTexParameteriv", _O(TexParameteriv) },
746
   { "glTexImage1D", _O(TexImage1D) },
747
   { "glTexImage2D", _O(TexImage2D) },
748
   { "glTexEnvf", _O(TexEnvf) },
749
   { "glTexEnvfv", _O(TexEnvfv) },
750
   { "glTexEnvi", _O(TexEnvi) },
751
   { "glTexEnviv", _O(TexEnviv) },
752
   { "glTexGend", _O(TexGend) },
753
   { "glTexGendv", _O(TexGendv) },
754
   { "glTexGenf", _O(TexGenf) },
755
   { "glTexGenfv", _O(TexGenfv) },
756
   { "glTexGeni", _O(TexGeni) },
757
   { "glTexGeniv", _O(TexGeniv) },
758
   { "glFeedbackBuffer", _O(FeedbackBuffer) },
759
   { "glSelectBuffer", _O(SelectBuffer) },
760
   { "glRenderMode", _O(RenderMode) },
761
   { "glInitNames", _O(InitNames) },
762
   { "glLoadName", _O(LoadName) },
763
   { "glPassThrough", _O(PassThrough) },
764
   { "glPopName", _O(PopName) },
765
   { "glPushName", _O(PushName) },
766
   { "glDrawBuffer", _O(DrawBuffer) },
767
   { "glClear", _O(Clear) },
768
   { "glClearAccum", _O(ClearAccum) },
769
   { "glClearIndex", _O(ClearIndex) },
770
   { "glClearColor", _O(ClearColor) },
771
   { "glClearStencil", _O(ClearStencil) },
772
   { "glClearDepth", _O(ClearDepth) },
773
   { "glStencilMask", _O(StencilMask) },
774
   { "glColorMask", _O(ColorMask) },
775
   { "glDepthMask", _O(DepthMask) },
776
   { "glIndexMask", _O(IndexMask) },
777
   { "glAccum", _O(Accum) },
778
   { "glDisable", _O(Disable) },
779
   { "glEnable", _O(Enable) },
780
   { "glFinish", _O(Finish) },
781
   { "glFlush", _O(Flush) },
782
   { "glPopAttrib", _O(PopAttrib) },
783
   { "glPushAttrib", _O(PushAttrib) },
784
   { "glMap1d", _O(Map1d) },
785
   { "glMap1f", _O(Map1f) },
786
   { "glMap2d", _O(Map2d) },
787
   { "glMap2f", _O(Map2f) },
788
   { "glMapGrid1d", _O(MapGrid1d) },
789
   { "glMapGrid1f", _O(MapGrid1f) },
790
   { "glMapGrid2d", _O(MapGrid2d) },
791
   { "glMapGrid2f", _O(MapGrid2f) },
792
   { "glEvalCoord1d", _O(EvalCoord1d) },
793
   { "glEvalCoord1dv", _O(EvalCoord1dv) },
794
   { "glEvalCoord1f", _O(EvalCoord1f) },
795
   { "glEvalCoord1fv", _O(EvalCoord1fv) },
796
   { "glEvalCoord2d", _O(EvalCoord2d) },
797
   { "glEvalCoord2dv", _O(EvalCoord2dv) },
798
   { "glEvalCoord2f", _O(EvalCoord2f) },
799
   { "glEvalCoord2fv", _O(EvalCoord2fv) },
800
   { "glEvalMesh1", _O(EvalMesh1) },
801
   { "glEvalPoint1", _O(EvalPoint1) },
802
   { "glEvalMesh2", _O(EvalMesh2) },
803
   { "glEvalPoint2", _O(EvalPoint2) },
804
   { "glAlphaFunc", _O(AlphaFunc) },
805
   { "glBlendFunc", _O(BlendFunc) },
806
   { "glLogicOp", _O(LogicOp) },
807
   { "glStencilFunc", _O(StencilFunc) },
808
   { "glStencilOp", _O(StencilOp) },
809
   { "glDepthFunc", _O(DepthFunc) },
810
   { "glPixelZoom", _O(PixelZoom) },
811
   { "glPixelTransferf", _O(PixelTransferf) },
812
   { "glPixelTransferi", _O(PixelTransferi) },
813
   { "glPixelStoref", _O(PixelStoref) },
814
   { "glPixelStorei", _O(PixelStorei) },
815
   { "glPixelMapfv", _O(PixelMapfv) },
816
   { "glPixelMapuiv", _O(PixelMapuiv) },
817
   { "glPixelMapusv", _O(PixelMapusv) },
818
   { "glReadBuffer", _O(ReadBuffer) },
819
   { "glCopyPixels", _O(CopyPixels) },
820
   { "glReadPixels", _O(ReadPixels) },
821
   { "glDrawPixels", _O(DrawPixels) },
822
   { "glGetBooleanv", _O(GetBooleanv) },
823
   { "glGetClipPlane", _O(GetClipPlane) },
824
   { "glGetDoublev", _O(GetDoublev) },
825
   { "glGetError", _O(GetError) },
826
   { "glGetFloatv", _O(GetFloatv) },
827
   { "glGetIntegerv", _O(GetIntegerv) },
828
   { "glGetLightfv", _O(GetLightfv) },
829
   { "glGetLightiv", _O(GetLightiv) },
830
   { "glGetMapdv", _O(GetMapdv) },
831
   { "glGetMapfv", _O(GetMapfv) },
832
   { "glGetMapiv", _O(GetMapiv) },
833
   { "glGetMaterialfv", _O(GetMaterialfv) },
834
   { "glGetMaterialiv", _O(GetMaterialiv) },
835
   { "glGetPixelMapfv", _O(GetPixelMapfv) },
836
   { "glGetPixelMapuiv", _O(GetPixelMapuiv) },
837
   { "glGetPixelMapusv", _O(GetPixelMapusv) },
838
   { "glGetPolygonStipple", _O(GetPolygonStipple) },
839
   { "glGetString", _O(GetString) },
840
   { "glGetTexEnvfv", _O(GetTexEnvfv) },
841
   { "glGetTexEnviv", _O(GetTexEnviv) },
842
   { "glGetTexGendv", _O(GetTexGendv) },
843
   { "glGetTexGenfv", _O(GetTexGenfv) },
844
   { "glGetTexGeniv", _O(GetTexGeniv) },
845
   { "glGetTexImage", _O(GetTexImage) },
846
   { "glGetTexParameterfv", _O(GetTexParameterfv) },
847
   { "glGetTexParameteriv", _O(GetTexParameteriv) },
848
   { "glGetTexLevelParameterfv", _O(GetTexLevelParameterfv) },
849
   { "glGetTexLevelParameteriv", _O(GetTexLevelParameteriv) },
850
   { "glIsEnabled", _O(IsEnabled) },
851
   { "glIsList", _O(IsList) },
852
   { "glDepthRange", _O(DepthRange) },
853
   { "glFrustum", _O(Frustum) },
854
   { "glLoadIdentity", _O(LoadIdentity) },
855
   { "glLoadMatrixf", _O(LoadMatrixf) },
856
   { "glLoadMatrixd", _O(LoadMatrixd) },
857
   { "glMatrixMode", _O(MatrixMode) },
858
   { "glMultMatrixf", _O(MultMatrixf) },
859
   { "glMultMatrixd", _O(MultMatrixd) },
860
   { "glOrtho", _O(Ortho) },
861
   { "glPopMatrix", _O(PopMatrix) },
862
   { "glPushMatrix", _O(PushMatrix) },
863
   { "glRotated", _O(Rotated) },
864
   { "glRotatef", _O(Rotatef) },
865
   { "glScaled", _O(Scaled) },
866
   { "glScalef", _O(Scalef) },
867
   { "glTranslated", _O(Translated) },
868
   { "glTranslatef", _O(Translatef) },
869
   { "glViewport", _O(Viewport) },
870
   { "glArrayElement", _O(ArrayElement) },
871
   { "glBindTexture", _O(BindTexture) },
872
   { "glColorPointer", _O(ColorPointer) },
873
   { "glDisableClientState", _O(DisableClientState) },
874
   { "glDrawArrays", _O(DrawArrays) },
875
   { "glDrawElements", _O(DrawElements) },
876
   { "glEdgeFlagPointer", _O(EdgeFlagPointer) },
877
   { "glEnableClientState", _O(EnableClientState) },
878
   { "glIndexPointer", _O(IndexPointer) },
879
   { "glIndexub", _O(Indexub) },
880
   { "glIndexubv", _O(Indexubv) },
881
   { "glInterleavedArrays", _O(InterleavedArrays) },
882
   { "glNormalPointer", _O(NormalPointer) },
883
   { "glPolygonOffset", _O(PolygonOffset) },
884
   { "glTexCoordPointer", _O(TexCoordPointer) },
885
   { "glVertexPointer", _O(VertexPointer) },
886
   { "glAreTexturesResident", _O(AreTexturesResident) },
887
   { "glCopyTexImage1D", _O(CopyTexImage1D) },
888
   { "glCopyTexImage2D", _O(CopyTexImage2D) },
889
   { "glCopyTexSubImage1D", _O(CopyTexSubImage1D) },
890
   { "glCopyTexSubImage2D", _O(CopyTexSubImage2D) },
891
   { "glDeleteTextures", _O(DeleteTextures) },
892
   { "glGenTextures", _O(GenTextures) },
893
   { "glGetPointerv", _O(GetPointerv) },
894
   { "glIsTexture", _O(IsTexture) },
895
   { "glPrioritizeTextures", _O(PrioritizeTextures) },
896
   { "glTexSubImage1D", _O(TexSubImage1D) },
897
   { "glTexSubImage2D", _O(TexSubImage2D) },
898
   { "glPopClientAttrib", _O(PopClientAttrib) },
899
   { "glPushClientAttrib", _O(PushClientAttrib) },
900
   { "glBlendColor", _O(BlendColor) },
901
   { "glBlendEquation", _O(BlendEquation) },
902
   { "glDrawRangeElements", _O(DrawRangeElements) },
903
   { "glColorTable", _O(ColorTable) },
904
   { "glColorTableParameterfv", _O(ColorTableParameterfv) },
905
   { "glColorTableParameteriv", _O(ColorTableParameteriv) },
906
   { "glCopyColorTable", _O(CopyColorTable) },
907
   { "glGetColorTable", _O(GetColorTable) },
908
   { "glGetColorTableParameterfv", _O(GetColorTableParameterfv) },
909
   { "glGetColorTableParameteriv", _O(GetColorTableParameteriv) },
910
   { "glColorSubTable", _O(ColorSubTable) },
911
   { "glCopyColorSubTable", _O(CopyColorSubTable) },
912
   { "glConvolutionFilter1D", _O(ConvolutionFilter1D) },
913
   { "glConvolutionFilter2D", _O(ConvolutionFilter2D) },
914
   { "glConvolutionParameterf", _O(ConvolutionParameterf) },
915
   { "glConvolutionParameterfv", _O(ConvolutionParameterfv) },
916
   { "glConvolutionParameteri", _O(ConvolutionParameteri) },
917
   { "glConvolutionParameteriv", _O(ConvolutionParameteriv) },
918
   { "glCopyConvolutionFilter1D", _O(CopyConvolutionFilter1D) },
919
   { "glCopyConvolutionFilter2D", _O(CopyConvolutionFilter2D) },
920
   { "glGetConvolutionFilter", _O(GetConvolutionFilter) },
921
   { "glGetConvolutionParameterfv", _O(GetConvolutionParameterfv) },
922
   { "glGetConvolutionParameteriv", _O(GetConvolutionParameteriv) },
923
   { "glGetSeparableFilter", _O(GetSeparableFilter) },
924
   { "glSeparableFilter2D", _O(SeparableFilter2D) },
925
   { "glGetHistogram", _O(GetHistogram) },
926
   { "glGetHistogramParameterfv", _O(GetHistogramParameterfv) },
927
   { "glGetHistogramParameteriv", _O(GetHistogramParameteriv) },
928
   { "glGetMinmax", _O(GetMinmax) },
929
   { "glGetMinmaxParameterfv", _O(GetMinmaxParameterfv) },
930
   { "glGetMinmaxParameteriv", _O(GetMinmaxParameteriv) },
931
   { "glHistogram", _O(Histogram) },
932
   { "glMinmax", _O(Minmax) },
933
   { "glResetHistogram", _O(ResetHistogram) },
934
   { "glResetMinmax", _O(ResetMinmax) },
935
   { "glTexImage3D", _O(TexImage3D) },
936
   { "glTexSubImage3D", _O(TexSubImage3D) },
937
   { "glCopyTexSubImage3D", _O(CopyTexSubImage3D) },
938
   { "glActiveTexture", _O(ActiveTexture) },
939
   { "glClientActiveTexture", _O(ClientActiveTexture) },
940
   { "glMultiTexCoord1d", _O(MultiTexCoord1d) },
941
   { "glMultiTexCoord1dv", _O(MultiTexCoord1dv) },
942
   { "glMultiTexCoord1fARB", _O(MultiTexCoord1fARB) },
943
   { "glMultiTexCoord1fvARB", _O(MultiTexCoord1fvARB) },
944
   { "glMultiTexCoord1i", _O(MultiTexCoord1i) },
945
   { "glMultiTexCoord1iv", _O(MultiTexCoord1iv) },
946
   { "glMultiTexCoord1s", _O(MultiTexCoord1s) },
947
   { "glMultiTexCoord1sv", _O(MultiTexCoord1sv) },
948
   { "glMultiTexCoord2d", _O(MultiTexCoord2d) },
949
   { "glMultiTexCoord2dv", _O(MultiTexCoord2dv) },
950
   { "glMultiTexCoord2fARB", _O(MultiTexCoord2fARB) },
951
   { "glMultiTexCoord2fvARB", _O(MultiTexCoord2fvARB) },
952
   { "glMultiTexCoord2i", _O(MultiTexCoord2i) },
953
   { "glMultiTexCoord2iv", _O(MultiTexCoord2iv) },
954
   { "glMultiTexCoord2s", _O(MultiTexCoord2s) },
955
   { "glMultiTexCoord2sv", _O(MultiTexCoord2sv) },
956
   { "glMultiTexCoord3d", _O(MultiTexCoord3d) },
957
   { "glMultiTexCoord3dv", _O(MultiTexCoord3dv) },
958
   { "glMultiTexCoord3fARB", _O(MultiTexCoord3fARB) },
959
   { "glMultiTexCoord3fvARB", _O(MultiTexCoord3fvARB) },
960
   { "glMultiTexCoord3i", _O(MultiTexCoord3i) },
961
   { "glMultiTexCoord3iv", _O(MultiTexCoord3iv) },
962
   { "glMultiTexCoord3s", _O(MultiTexCoord3s) },
963
   { "glMultiTexCoord3sv", _O(MultiTexCoord3sv) },
964
   { "glMultiTexCoord4d", _O(MultiTexCoord4d) },
965
   { "glMultiTexCoord4dv", _O(MultiTexCoord4dv) },
966
   { "glMultiTexCoord4fARB", _O(MultiTexCoord4fARB) },
967
   { "glMultiTexCoord4fvARB", _O(MultiTexCoord4fvARB) },
968
   { "glMultiTexCoord4i", _O(MultiTexCoord4i) },
969
   { "glMultiTexCoord4iv", _O(MultiTexCoord4iv) },
970
   { "glMultiTexCoord4s", _O(MultiTexCoord4s) },
971
   { "glMultiTexCoord4sv", _O(MultiTexCoord4sv) },
972
   { "glAttachShader", _O(AttachShader) },
973
   { "glCreateProgram", _O(CreateProgram) },
974
   { "glCreateShader", _O(CreateShader) },
975
   { "glDeleteProgram", _O(DeleteProgram) },
976
   { "glDeleteShader", _O(DeleteShader) },
977
   { "glDetachShader", _O(DetachShader) },
978
   { "glGetAttachedShaders", _O(GetAttachedShaders) },
979
   { "glGetProgramInfoLog", _O(GetProgramInfoLog) },
980
   { "glGetProgramiv", _O(GetProgramiv) },
981
   { "glGetShaderInfoLog", _O(GetShaderInfoLog) },
982
   { "glGetShaderiv", _O(GetShaderiv) },
983
   { "glIsProgram", _O(IsProgram) },
984
   { "glIsShader", _O(IsShader) },
985
   { "glStencilFuncSeparate", _O(StencilFuncSeparate) },
986
   { "glStencilMaskSeparate", _O(StencilMaskSeparate) },
987
   { "glStencilOpSeparate", _O(StencilOpSeparate) },
988
   { "glUniformMatrix2x3fv", _O(UniformMatrix2x3fv) },
989
   { "glUniformMatrix2x4fv", _O(UniformMatrix2x4fv) },
990
   { "glUniformMatrix3x2fv", _O(UniformMatrix3x2fv) },
991
   { "glUniformMatrix3x4fv", _O(UniformMatrix3x4fv) },
992
   { "glUniformMatrix4x2fv", _O(UniformMatrix4x2fv) },
993
   { "glUniformMatrix4x3fv", _O(UniformMatrix4x3fv) },
994
   { "glClearBufferfi", _O(ClearBufferfi) },
995
   { "glClearBufferfv", _O(ClearBufferfv) },
996
   { "glClearBufferiv", _O(ClearBufferiv) },
997
   { "glClearBufferuiv", _O(ClearBufferuiv) },
998
   { "glGetStringi", _O(GetStringi) },
999
   { "glFramebufferTexture", _O(FramebufferTexture) },
1000
   { "glGetBufferParameteri64v", _O(GetBufferParameteri64v) },
1001
   { "glGetInteger64i_v", _O(GetInteger64i_v) },
1002
   { "glLoadTransposeMatrixd", _O(LoadTransposeMatrixd) },
1003
   { "glLoadTransposeMatrixf", _O(LoadTransposeMatrixf) },
1004
   { "glMultTransposeMatrixd", _O(MultTransposeMatrixd) },
1005
   { "glMultTransposeMatrixf", _O(MultTransposeMatrixf) },
1006
   { "glSampleCoverage", _O(SampleCoverage) },
1007
   { "glCompressedTexImage1D", _O(CompressedTexImage1D) },
1008
   { "glCompressedTexImage2D", _O(CompressedTexImage2D) },
1009
   { "glCompressedTexImage3D", _O(CompressedTexImage3D) },
1010
   { "glCompressedTexSubImage1D", _O(CompressedTexSubImage1D) },
1011
   { "glCompressedTexSubImage2D", _O(CompressedTexSubImage2D) },
1012
   { "glCompressedTexSubImage3D", _O(CompressedTexSubImage3D) },
1013
   { "glGetCompressedTexImage", _O(GetCompressedTexImage) },
1014
   { "glDisableVertexAttribArray", _O(DisableVertexAttribArray) },
1015
   { "glEnableVertexAttribArray", _O(EnableVertexAttribArray) },
1016
   { "glGetProgramEnvParameterdvARB", _O(GetProgramEnvParameterdvARB) },
1017
   { "glGetProgramEnvParameterfvARB", _O(GetProgramEnvParameterfvARB) },
1018
   { "glGetProgramLocalParameterdvARB", _O(GetProgramLocalParameterdvARB) },
1019
   { "glGetProgramLocalParameterfvARB", _O(GetProgramLocalParameterfvARB) },
1020
   { "glGetProgramStringARB", _O(GetProgramStringARB) },
1021
   { "glGetProgramivARB", _O(GetProgramivARB) },
1022
   { "glGetVertexAttribdv", _O(GetVertexAttribdv) },
1023
   { "glGetVertexAttribfv", _O(GetVertexAttribfv) },
1024
   { "glGetVertexAttribiv", _O(GetVertexAttribiv) },
1025
   { "glProgramEnvParameter4dARB", _O(ProgramEnvParameter4dARB) },
1026
   { "glProgramEnvParameter4dvARB", _O(ProgramEnvParameter4dvARB) },
1027
   { "glProgramEnvParameter4fARB", _O(ProgramEnvParameter4fARB) },
1028
   { "glProgramEnvParameter4fvARB", _O(ProgramEnvParameter4fvARB) },
1029
   { "glProgramLocalParameter4dARB", _O(ProgramLocalParameter4dARB) },
1030
   { "glProgramLocalParameter4dvARB", _O(ProgramLocalParameter4dvARB) },
1031
   { "glProgramLocalParameter4fARB", _O(ProgramLocalParameter4fARB) },
1032
   { "glProgramLocalParameter4fvARB", _O(ProgramLocalParameter4fvARB) },
1033
   { "glProgramStringARB", _O(ProgramStringARB) },
1034
   { "glVertexAttrib1d", _O(VertexAttrib1d) },
1035
   { "glVertexAttrib1dv", _O(VertexAttrib1dv) },
1036
   { "glVertexAttrib1fARB", _O(VertexAttrib1fARB) },
1037
   { "glVertexAttrib1fvARB", _O(VertexAttrib1fvARB) },
1038
   { "glVertexAttrib1s", _O(VertexAttrib1s) },
1039
   { "glVertexAttrib1sv", _O(VertexAttrib1sv) },
1040
   { "glVertexAttrib2d", _O(VertexAttrib2d) },
1041
   { "glVertexAttrib2dv", _O(VertexAttrib2dv) },
1042
   { "glVertexAttrib2fARB", _O(VertexAttrib2fARB) },
1043
   { "glVertexAttrib2fvARB", _O(VertexAttrib2fvARB) },
1044
   { "glVertexAttrib2s", _O(VertexAttrib2s) },
1045
   { "glVertexAttrib2sv", _O(VertexAttrib2sv) },
1046
   { "glVertexAttrib3d", _O(VertexAttrib3d) },
1047
   { "glVertexAttrib3dv", _O(VertexAttrib3dv) },
1048
   { "glVertexAttrib3fARB", _O(VertexAttrib3fARB) },
1049
   { "glVertexAttrib3fvARB", _O(VertexAttrib3fvARB) },
1050
   { "glVertexAttrib3s", _O(VertexAttrib3s) },
1051
   { "glVertexAttrib3sv", _O(VertexAttrib3sv) },
1052
   { "glVertexAttrib4Nbv", _O(VertexAttrib4Nbv) },
1053
   { "glVertexAttrib4Niv", _O(VertexAttrib4Niv) },
1054
   { "glVertexAttrib4Nsv", _O(VertexAttrib4Nsv) },
1055
   { "glVertexAttrib4Nub", _O(VertexAttrib4Nub) },
1056
   { "glVertexAttrib4Nubv", _O(VertexAttrib4Nubv) },
1057
   { "glVertexAttrib4Nuiv", _O(VertexAttrib4Nuiv) },
1058
   { "glVertexAttrib4Nusv", _O(VertexAttrib4Nusv) },
1059
   { "glVertexAttrib4bv", _O(VertexAttrib4bv) },
1060
   { "glVertexAttrib4d", _O(VertexAttrib4d) },
1061
   { "glVertexAttrib4dv", _O(VertexAttrib4dv) },
1062
   { "glVertexAttrib4fARB", _O(VertexAttrib4fARB) },
1063
   { "glVertexAttrib4fvARB", _O(VertexAttrib4fvARB) },
1064
   { "glVertexAttrib4iv", _O(VertexAttrib4iv) },
1065
   { "glVertexAttrib4s", _O(VertexAttrib4s) },
1066
   { "glVertexAttrib4sv", _O(VertexAttrib4sv) },
1067
   { "glVertexAttrib4ubv", _O(VertexAttrib4ubv) },
1068
   { "glVertexAttrib4uiv", _O(VertexAttrib4uiv) },
1069
   { "glVertexAttrib4usv", _O(VertexAttrib4usv) },
1070
   { "glVertexAttribPointer", _O(VertexAttribPointer) },
1071
   { "glBindBuffer", _O(BindBuffer) },
1072
   { "glBufferData", _O(BufferData) },
1073
   { "glBufferSubData", _O(BufferSubData) },
1074
   { "glDeleteBuffers", _O(DeleteBuffers) },
1075
   { "glGenBuffers", _O(GenBuffers) },
1076
   { "glGetBufferParameteriv", _O(GetBufferParameteriv) },
1077
   { "glGetBufferPointerv", _O(GetBufferPointerv) },
1078
   { "glGetBufferSubData", _O(GetBufferSubData) },
1079
   { "glIsBuffer", _O(IsBuffer) },
1080
   { "glMapBuffer", _O(MapBuffer) },
1081
   { "glUnmapBuffer", _O(UnmapBuffer) },
1082
   { "glBeginQuery", _O(BeginQuery) },
1083
   { "glDeleteQueries", _O(DeleteQueries) },
1084
   { "glEndQuery", _O(EndQuery) },
1085
   { "glGenQueries", _O(GenQueries) },
1086
   { "glGetQueryObjectiv", _O(GetQueryObjectiv) },
1087
   { "glGetQueryObjectuiv", _O(GetQueryObjectuiv) },
1088
   { "glGetQueryiv", _O(GetQueryiv) },
1089
   { "glIsQuery", _O(IsQuery) },
1090
   { "glAttachObjectARB", _O(AttachObjectARB) },
1091
   { "glCompileShader", _O(CompileShader) },
1092
   { "glCreateProgramObjectARB", _O(CreateProgramObjectARB) },
1093
   { "glCreateShaderObjectARB", _O(CreateShaderObjectARB) },
1094
   { "glDeleteObjectARB", _O(DeleteObjectARB) },
1095
   { "glDetachObjectARB", _O(DetachObjectARB) },
1096
   { "glGetActiveUniform", _O(GetActiveUniform) },
1097
   { "glGetAttachedObjectsARB", _O(GetAttachedObjectsARB) },
1098
   { "glGetHandleARB", _O(GetHandleARB) },
1099
   { "glGetInfoLogARB", _O(GetInfoLogARB) },
1100
   { "glGetObjectParameterfvARB", _O(GetObjectParameterfvARB) },
1101
   { "glGetObjectParameterivARB", _O(GetObjectParameterivARB) },
1102
   { "glGetShaderSource", _O(GetShaderSource) },
1103
   { "glGetUniformLocation", _O(GetUniformLocation) },
1104
   { "glGetUniformfv", _O(GetUniformfv) },
1105
   { "glGetUniformiv", _O(GetUniformiv) },
1106
   { "glLinkProgram", _O(LinkProgram) },
1107
   { "glShaderSource", _O(ShaderSource) },
1108
   { "glUniform1f", _O(Uniform1f) },
1109
   { "glUniform1fv", _O(Uniform1fv) },
1110
   { "glUniform1i", _O(Uniform1i) },
1111
   { "glUniform1iv", _O(Uniform1iv) },
1112
   { "glUniform2f", _O(Uniform2f) },
1113
   { "glUniform2fv", _O(Uniform2fv) },
1114
   { "glUniform2i", _O(Uniform2i) },
1115
   { "glUniform2iv", _O(Uniform2iv) },
1116
   { "glUniform3f", _O(Uniform3f) },
1117
   { "glUniform3fv", _O(Uniform3fv) },
1118
   { "glUniform3i", _O(Uniform3i) },
1119
   { "glUniform3iv", _O(Uniform3iv) },
1120
   { "glUniform4f", _O(Uniform4f) },
1121
   { "glUniform4fv", _O(Uniform4fv) },
1122
   { "glUniform4i", _O(Uniform4i) },
1123
   { "glUniform4iv", _O(Uniform4iv) },
1124
   { "glUniformMatrix2fv", _O(UniformMatrix2fv) },
1125
   { "glUniformMatrix3fv", _O(UniformMatrix3fv) },
1126
   { "glUniformMatrix4fv", _O(UniformMatrix4fv) },
1127
   { "glUseProgram", _O(UseProgram) },
1128
   { "glValidateProgram", _O(ValidateProgram) },
1129
   { "glBindAttribLocation", _O(BindAttribLocation) },
1130
   { "glGetActiveAttrib", _O(GetActiveAttrib) },
1131
   { "glGetAttribLocation", _O(GetAttribLocation) },
1132
   { "glDrawBuffers", _O(DrawBuffers) },
1133
   { "glClampColor", _O(ClampColor) },
1134
   { "glDrawArraysInstancedARB", _O(DrawArraysInstancedARB) },
1135
   { "glDrawElementsInstancedARB", _O(DrawElementsInstancedARB) },
1136
   { "glRenderbufferStorageMultisample", _O(RenderbufferStorageMultisample) },
1137
   { "glFramebufferTexture", _O(FramebufferTexture) },
1138
   { "glProgramParameteri", _O(ProgramParameteri) },
1139
   { "glVertexAttribDivisor", _O(VertexAttribDivisor) },
1140
   { "glFlushMappedBufferRange", _O(FlushMappedBufferRange) },
1141
   { "glMapBufferRange", _O(MapBufferRange) },
1142
   { "glTexBuffer", _O(TexBuffer) },
1143
   { "glBindVertexArray", _O(BindVertexArray) },
1144
   { "glGenVertexArrays", _O(GenVertexArrays) },
1145
   { "glCopyBufferSubData", _O(CopyBufferSubData) },
1146
   { "glClientWaitSync", _O(ClientWaitSync) },
1147
   { "glDeleteSync", _O(DeleteSync) },
1148
   { "glFenceSync", _O(FenceSync) },
1149
   { "glGetInteger64v", _O(GetInteger64v) },
1150
   { "glGetSynciv", _O(GetSynciv) },
1151
   { "glIsSync", _O(IsSync) },
1152
   { "glWaitSync", _O(WaitSync) },
1153
   { "glDrawElementsBaseVertex", _O(DrawElementsBaseVertex) },
1154
   { "glDrawElementsInstancedBaseVertex", _O(DrawElementsInstancedBaseVertex) },
1155
   { "glDrawRangeElementsBaseVertex", _O(DrawRangeElementsBaseVertex) },
1156
   { "glMultiDrawElementsBaseVertex", _O(MultiDrawElementsBaseVertex) },
1157
   { "glBlendEquationSeparateiARB", _O(BlendEquationSeparateiARB) },
1158
   { "glBlendEquationiARB", _O(BlendEquationiARB) },
1159
   { "glBlendFuncSeparateiARB", _O(BlendFuncSeparateiARB) },
1160
   { "glBlendFunciARB", _O(BlendFunciARB) },
1161
   { "glBindFragDataLocationIndexed", _O(BindFragDataLocationIndexed) },
1162
   { "glGetFragDataIndex", _O(GetFragDataIndex) },
1163
   { "glBindSampler", _O(BindSampler) },
1164
   { "glDeleteSamplers", _O(DeleteSamplers) },
1165
   { "glGenSamplers", _O(GenSamplers) },
1166
   { "glGetSamplerParameterIiv", _O(GetSamplerParameterIiv) },
1167
   { "glGetSamplerParameterIuiv", _O(GetSamplerParameterIuiv) },
1168
   { "glGetSamplerParameterfv", _O(GetSamplerParameterfv) },
1169
   { "glGetSamplerParameteriv", _O(GetSamplerParameteriv) },
1170
   { "glIsSampler", _O(IsSampler) },
1171
   { "glSamplerParameterIiv", _O(SamplerParameterIiv) },
1172
   { "glSamplerParameterIuiv", _O(SamplerParameterIuiv) },
1173
   { "glSamplerParameterf", _O(SamplerParameterf) },
1174
   { "glSamplerParameterfv", _O(SamplerParameterfv) },
1175
   { "glSamplerParameteri", _O(SamplerParameteri) },
1176
   { "glSamplerParameteriv", _O(SamplerParameteriv) },
1177
   { "glColorP3ui", _O(ColorP3ui) },
1178
   { "glColorP3uiv", _O(ColorP3uiv) },
1179
   { "glColorP4ui", _O(ColorP4ui) },
1180
   { "glColorP4uiv", _O(ColorP4uiv) },
1181
   { "glMultiTexCoordP1ui", _O(MultiTexCoordP1ui) },
1182
   { "glMultiTexCoordP1uiv", _O(MultiTexCoordP1uiv) },
1183
   { "glMultiTexCoordP2ui", _O(MultiTexCoordP2ui) },
1184
   { "glMultiTexCoordP2uiv", _O(MultiTexCoordP2uiv) },
1185
   { "glMultiTexCoordP3ui", _O(MultiTexCoordP3ui) },
1186
   { "glMultiTexCoordP3uiv", _O(MultiTexCoordP3uiv) },
1187
   { "glMultiTexCoordP4ui", _O(MultiTexCoordP4ui) },
1188
   { "glMultiTexCoordP4uiv", _O(MultiTexCoordP4uiv) },
1189
   { "glNormalP3ui", _O(NormalP3ui) },
1190
   { "glNormalP3uiv", _O(NormalP3uiv) },
1191
   { "glSecondaryColorP3ui", _O(SecondaryColorP3ui) },
1192
   { "glSecondaryColorP3uiv", _O(SecondaryColorP3uiv) },
1193
   { "glTexCoordP1ui", _O(TexCoordP1ui) },
1194
   { "glTexCoordP1uiv", _O(TexCoordP1uiv) },
1195
   { "glTexCoordP2ui", _O(TexCoordP2ui) },
1196
   { "glTexCoordP2uiv", _O(TexCoordP2uiv) },
1197
   { "glTexCoordP3ui", _O(TexCoordP3ui) },
1198
   { "glTexCoordP3uiv", _O(TexCoordP3uiv) },
1199
   { "glTexCoordP4ui", _O(TexCoordP4ui) },
1200
   { "glTexCoordP4uiv", _O(TexCoordP4uiv) },
1201
   { "glVertexAttribP1ui", _O(VertexAttribP1ui) },
1202
   { "glVertexAttribP1uiv", _O(VertexAttribP1uiv) },
1203
   { "glVertexAttribP2ui", _O(VertexAttribP2ui) },
1204
   { "glVertexAttribP2uiv", _O(VertexAttribP2uiv) },
1205
   { "glVertexAttribP3ui", _O(VertexAttribP3ui) },
1206
   { "glVertexAttribP3uiv", _O(VertexAttribP3uiv) },
1207
   { "glVertexAttribP4ui", _O(VertexAttribP4ui) },
1208
   { "glVertexAttribP4uiv", _O(VertexAttribP4uiv) },
1209
   { "glVertexP2ui", _O(VertexP2ui) },
1210
   { "glVertexP2uiv", _O(VertexP2uiv) },
1211
   { "glVertexP3ui", _O(VertexP3ui) },
1212
   { "glVertexP3uiv", _O(VertexP3uiv) },
1213
   { "glVertexP4ui", _O(VertexP4ui) },
1214
   { "glVertexP4uiv", _O(VertexP4uiv) },
1215
   { "glBindTransformFeedback", _O(BindTransformFeedback) },
1216
   { "glDeleteTransformFeedbacks", _O(DeleteTransformFeedbacks) },
1217
   { "glDrawTransformFeedback", _O(DrawTransformFeedback) },
1218
   { "glGenTransformFeedbacks", _O(GenTransformFeedbacks) },
1219
   { "glIsTransformFeedback", _O(IsTransformFeedback) },
1220
   { "glPauseTransformFeedback", _O(PauseTransformFeedback) },
1221
   { "glResumeTransformFeedback", _O(ResumeTransformFeedback) },
1222
   { "glClearDepthf", _O(ClearDepthf) },
1223
   { "glDepthRangef", _O(DepthRangef) },
1224
   { "glGetShaderPrecisionFormat", _O(GetShaderPrecisionFormat) },
1225
   { "glReleaseShaderCompiler", _O(ReleaseShaderCompiler) },
1226
   { "glShaderBinary", _O(ShaderBinary) },
1227
   { "glDebugMessageCallback", _O(DebugMessageCallback) },
1228
   { "glDebugMessageControl", _O(DebugMessageControl) },
1229
   { "glDebugMessageInsert", _O(DebugMessageInsert) },
1230
   { "glGetDebugMessageLog", _O(GetDebugMessageLog) },
1231
   { "glPushDebugGroup", _O(PushDebugGroup) },
1232
   { "glPopDebugGroup", _O(PopDebugGroup) },
1233
   { "glGetObjectLabel", _O(GetObjectLabel) },
1234
   { "glGetObjectPtrLabel", _O(GetObjectPtrLabel) },
1235
   { "glObjectLabel", _O(ObjectLabel) },
1236
   { "glObjectPtrLabel", _O(ObjectPtrLabel) },
1237
   { "glGetGraphicsResetStatusARB", _O(GetGraphicsResetStatusARB) },
1238
   { "glGetnColorTableARB", _O(GetnColorTableARB) },
1239
   { "glGetnCompressedTexImageARB", _O(GetnCompressedTexImageARB) },
1240
   { "glGetnConvolutionFilterARB", _O(GetnConvolutionFilterARB) },
1241
   { "glGetnHistogramARB", _O(GetnHistogramARB) },
1242
   { "glGetnMapdvARB", _O(GetnMapdvARB) },
1243
   { "glGetnMapfvARB", _O(GetnMapfvARB) },
1244
   { "glGetnMapivARB", _O(GetnMapivARB) },
1245
   { "glGetnMinmaxARB", _O(GetnMinmaxARB) },
1246
   { "glGetnPixelMapfvARB", _O(GetnPixelMapfvARB) },
1247
   { "glGetnPixelMapuivARB", _O(GetnPixelMapuivARB) },
1248
   { "glGetnPixelMapusvARB", _O(GetnPixelMapusvARB) },
1249
   { "glGetnPolygonStippleARB", _O(GetnPolygonStippleARB) },
1250
   { "glGetnSeparableFilterARB", _O(GetnSeparableFilterARB) },
1251
   { "glGetnTexImageARB", _O(GetnTexImageARB) },
1252
   { "glGetnUniformdvARB", _O(GetnUniformdvARB) },
1253
   { "glGetnUniformfvARB", _O(GetnUniformfvARB) },
1254
   { "glGetnUniformivARB", _O(GetnUniformivARB) },
1255
   { "glGetnUniformuivARB", _O(GetnUniformuivARB) },
1256
   { "glReadnPixelsARB", _O(ReadnPixelsARB) },
1257
   { "glTexStorage1D", _O(TexStorage1D) },
1258
   { "glTexStorage2D", _O(TexStorage2D) },
1259
   { "glTexStorage3D", _O(TexStorage3D) },
1260
   { "glTextureStorage1DEXT", _O(TextureStorage1DEXT) },
1261
   { "glTextureStorage2DEXT", _O(TextureStorage2DEXT) },
1262
   { "glTextureStorage3DEXT", _O(TextureStorage3DEXT) },
1263
   { "glSampleMaskSGIS", _O(SampleMaskSGIS) },
1264
   { "glSamplePatternSGIS", _O(SamplePatternSGIS) },
1265
   { "glColorPointerEXT", _O(ColorPointerEXT) },
1266
   { "glEdgeFlagPointerEXT", _O(EdgeFlagPointerEXT) },
1267
   { "glIndexPointerEXT", _O(IndexPointerEXT) },
1268
   { "glNormalPointerEXT", _O(NormalPointerEXT) },
1269
   { "glTexCoordPointerEXT", _O(TexCoordPointerEXT) },
1270
   { "glVertexPointerEXT", _O(VertexPointerEXT) },
1271
   { "glPointParameterf", _O(PointParameterf) },
1272
   { "glPointParameterfv", _O(PointParameterfv) },
1273
   { "glLockArraysEXT", _O(LockArraysEXT) },
1274
   { "glUnlockArraysEXT", _O(UnlockArraysEXT) },
1275
   { "glSecondaryColor3b", _O(SecondaryColor3b) },
1276
   { "glSecondaryColor3bv", _O(SecondaryColor3bv) },
1277
   { "glSecondaryColor3d", _O(SecondaryColor3d) },
1278
   { "glSecondaryColor3dv", _O(SecondaryColor3dv) },
1279
   { "glSecondaryColor3fEXT", _O(SecondaryColor3fEXT) },
1280
   { "glSecondaryColor3fvEXT", _O(SecondaryColor3fvEXT) },
1281
   { "glSecondaryColor3i", _O(SecondaryColor3i) },
1282
   { "glSecondaryColor3iv", _O(SecondaryColor3iv) },
1283
   { "glSecondaryColor3s", _O(SecondaryColor3s) },
1284
   { "glSecondaryColor3sv", _O(SecondaryColor3sv) },
1285
   { "glSecondaryColor3ub", _O(SecondaryColor3ub) },
1286
   { "glSecondaryColor3ubv", _O(SecondaryColor3ubv) },
1287
   { "glSecondaryColor3ui", _O(SecondaryColor3ui) },
1288
   { "glSecondaryColor3uiv", _O(SecondaryColor3uiv) },
1289
   { "glSecondaryColor3us", _O(SecondaryColor3us) },
1290
   { "glSecondaryColor3usv", _O(SecondaryColor3usv) },
1291
   { "glSecondaryColorPointer", _O(SecondaryColorPointer) },
1292
   { "glMultiDrawArrays", _O(MultiDrawArrays) },
1293
   { "glMultiDrawElementsEXT", _O(MultiDrawElementsEXT) },
1294
   { "glFogCoordPointer", _O(FogCoordPointer) },
1295
   { "glFogCoordd", _O(FogCoordd) },
1296
   { "glFogCoorddv", _O(FogCoorddv) },
1297
   { "glFogCoordfEXT", _O(FogCoordfEXT) },
1298
   { "glFogCoordfvEXT", _O(FogCoordfvEXT) },
1299
   { "glBlendFuncSeparate", _O(BlendFuncSeparate) },
1300
   { "glResizeBuffersMESA", _O(ResizeBuffersMESA) },
1301
   { "glWindowPos2d", _O(WindowPos2d) },
1302
   { "glWindowPos2dv", _O(WindowPos2dv) },
1303
   { "glWindowPos2f", _O(WindowPos2f) },
1304
   { "glWindowPos2fv", _O(WindowPos2fv) },
1305
   { "glWindowPos2i", _O(WindowPos2i) },
1306
   { "glWindowPos2iv", _O(WindowPos2iv) },
1307
   { "glWindowPos2s", _O(WindowPos2s) },
1308
   { "glWindowPos2sv", _O(WindowPos2sv) },
1309
   { "glWindowPos3d", _O(WindowPos3d) },
1310
   { "glWindowPos3dv", _O(WindowPos3dv) },
1311
   { "glWindowPos3f", _O(WindowPos3f) },
1312
   { "glWindowPos3fv", _O(WindowPos3fv) },
1313
   { "glWindowPos3i", _O(WindowPos3i) },
1314
   { "glWindowPos3iv", _O(WindowPos3iv) },
1315
   { "glWindowPos3s", _O(WindowPos3s) },
1316
   { "glWindowPos3sv", _O(WindowPos3sv) },
1317
   { "glWindowPos4dMESA", _O(WindowPos4dMESA) },
1318
   { "glWindowPos4dvMESA", _O(WindowPos4dvMESA) },
1319
   { "glWindowPos4fMESA", _O(WindowPos4fMESA) },
1320
   { "glWindowPos4fvMESA", _O(WindowPos4fvMESA) },
1321
   { "glWindowPos4iMESA", _O(WindowPos4iMESA) },
1322
   { "glWindowPos4ivMESA", _O(WindowPos4ivMESA) },
1323
   { "glWindowPos4sMESA", _O(WindowPos4sMESA) },
1324
   { "glWindowPos4svMESA", _O(WindowPos4svMESA) },
1325
   { "glMultiModeDrawArraysIBM", _O(MultiModeDrawArraysIBM) },
1326
   { "glMultiModeDrawElementsIBM", _O(MultiModeDrawElementsIBM) },
1327
   { "glAreProgramsResidentNV", _O(AreProgramsResidentNV) },
1328
   { "glBindProgramARB", _O(BindProgramARB) },
1329
   { "glDeleteProgramsARB", _O(DeleteProgramsARB) },
1330
   { "glExecuteProgramNV", _O(ExecuteProgramNV) },
1331
   { "glGenProgramsARB", _O(GenProgramsARB) },
1332
   { "glGetProgramParameterdvNV", _O(GetProgramParameterdvNV) },
1333
   { "glGetProgramParameterfvNV", _O(GetProgramParameterfvNV) },
1334
   { "glGetProgramStringNV", _O(GetProgramStringNV) },
1335
   { "glGetProgramivNV", _O(GetProgramivNV) },
1336
   { "glGetTrackMatrixivNV", _O(GetTrackMatrixivNV) },
1337
   { "glGetVertexAttribPointerv", _O(GetVertexAttribPointerv) },
1338
   { "glGetVertexAttribdvNV", _O(GetVertexAttribdvNV) },
1339
   { "glGetVertexAttribfvNV", _O(GetVertexAttribfvNV) },
1340
   { "glGetVertexAttribivNV", _O(GetVertexAttribivNV) },
1341
   { "glIsProgram", _O(IsProgram) },
1342
   { "glLoadProgramNV", _O(LoadProgramNV) },
1343
   { "glProgramParameters4dvNV", _O(ProgramParameters4dvNV) },
1344
   { "glProgramParameters4fvNV", _O(ProgramParameters4fvNV) },
1345
   { "glRequestResidentProgramsNV", _O(RequestResidentProgramsNV) },
1346
   { "glTrackMatrixNV", _O(TrackMatrixNV) },
1347
   { "glVertexAttrib1dNV", _O(VertexAttrib1dNV) },
1348
   { "glVertexAttrib1dvNV", _O(VertexAttrib1dvNV) },
1349
   { "glVertexAttrib1fNV", _O(VertexAttrib1fNV) },
1350
   { "glVertexAttrib1fvNV", _O(VertexAttrib1fvNV) },
1351
   { "glVertexAttrib1sNV", _O(VertexAttrib1sNV) },
1352
   { "glVertexAttrib1svNV", _O(VertexAttrib1svNV) },
1353
   { "glVertexAttrib2dNV", _O(VertexAttrib2dNV) },
1354
   { "glVertexAttrib2dvNV", _O(VertexAttrib2dvNV) },
1355
   { "glVertexAttrib2fNV", _O(VertexAttrib2fNV) },
1356
   { "glVertexAttrib2fvNV", _O(VertexAttrib2fvNV) },
1357
   { "glVertexAttrib2sNV", _O(VertexAttrib2sNV) },
1358
   { "glVertexAttrib2svNV", _O(VertexAttrib2svNV) },
1359
   { "glVertexAttrib3dNV", _O(VertexAttrib3dNV) },
1360
   { "glVertexAttrib3dvNV", _O(VertexAttrib3dvNV) },
1361
   { "glVertexAttrib3fNV", _O(VertexAttrib3fNV) },
1362
   { "glVertexAttrib3fvNV", _O(VertexAttrib3fvNV) },
1363
   { "glVertexAttrib3sNV", _O(VertexAttrib3sNV) },
1364
   { "glVertexAttrib3svNV", _O(VertexAttrib3svNV) },
1365
   { "glVertexAttrib4dNV", _O(VertexAttrib4dNV) },
1366
   { "glVertexAttrib4dvNV", _O(VertexAttrib4dvNV) },
1367
   { "glVertexAttrib4fNV", _O(VertexAttrib4fNV) },
1368
   { "glVertexAttrib4fvNV", _O(VertexAttrib4fvNV) },
1369
   { "glVertexAttrib4sNV", _O(VertexAttrib4sNV) },
1370
   { "glVertexAttrib4svNV", _O(VertexAttrib4svNV) },
1371
   { "glVertexAttrib4ubNV", _O(VertexAttrib4ubNV) },
1372
   { "glVertexAttrib4ubvNV", _O(VertexAttrib4ubvNV) },
1373
   { "glVertexAttribPointerNV", _O(VertexAttribPointerNV) },
1374
   { "glVertexAttribs1dvNV", _O(VertexAttribs1dvNV) },
1375
   { "glVertexAttribs1fvNV", _O(VertexAttribs1fvNV) },
1376
   { "glVertexAttribs1svNV", _O(VertexAttribs1svNV) },
1377
   { "glVertexAttribs2dvNV", _O(VertexAttribs2dvNV) },
1378
   { "glVertexAttribs2fvNV", _O(VertexAttribs2fvNV) },
1379
   { "glVertexAttribs2svNV", _O(VertexAttribs2svNV) },
1380
   { "glVertexAttribs3dvNV", _O(VertexAttribs3dvNV) },
1381
   { "glVertexAttribs3fvNV", _O(VertexAttribs3fvNV) },
1382
   { "glVertexAttribs3svNV", _O(VertexAttribs3svNV) },
1383
   { "glVertexAttribs4dvNV", _O(VertexAttribs4dvNV) },
1384
   { "glVertexAttribs4fvNV", _O(VertexAttribs4fvNV) },
1385
   { "glVertexAttribs4svNV", _O(VertexAttribs4svNV) },
1386
   { "glVertexAttribs4ubvNV", _O(VertexAttribs4ubvNV) },
1387
   { "glAlphaFragmentOp1ATI", _O(AlphaFragmentOp1ATI) },
1388
   { "glAlphaFragmentOp2ATI", _O(AlphaFragmentOp2ATI) },
1389
   { "glAlphaFragmentOp3ATI", _O(AlphaFragmentOp3ATI) },
1390
   { "glBeginFragmentShaderATI", _O(BeginFragmentShaderATI) },
1391
   { "glBindFragmentShaderATI", _O(BindFragmentShaderATI) },
1392
   { "glColorFragmentOp1ATI", _O(ColorFragmentOp1ATI) },
1393
   { "glColorFragmentOp2ATI", _O(ColorFragmentOp2ATI) },
1394
   { "glColorFragmentOp3ATI", _O(ColorFragmentOp3ATI) },
1395
   { "glDeleteFragmentShaderATI", _O(DeleteFragmentShaderATI) },
1396
   { "glEndFragmentShaderATI", _O(EndFragmentShaderATI) },
1397
   { "glGenFragmentShadersATI", _O(GenFragmentShadersATI) },
1398
   { "glPassTexCoordATI", _O(PassTexCoordATI) },
1399
   { "glSampleMapATI", _O(SampleMapATI) },
1400
   { "glSetFragmentShaderConstantATI", _O(SetFragmentShaderConstantATI) },
1401
   { "glPointParameteri", _O(PointParameteri) },
1402
   { "glPointParameteriv", _O(PointParameteriv) },
1403
   { "glActiveStencilFaceEXT", _O(ActiveStencilFaceEXT) },
1404
   { "glDeleteVertexArrays", _O(DeleteVertexArrays) },
1405
   { "glIsVertexArray", _O(IsVertexArray) },
1406
   { "glGetProgramNamedParameterdvNV", _O(GetProgramNamedParameterdvNV) },
1407
   { "glGetProgramNamedParameterfvNV", _O(GetProgramNamedParameterfvNV) },
1408
   { "glProgramNamedParameter4dNV", _O(ProgramNamedParameter4dNV) },
1409
   { "glProgramNamedParameter4dvNV", _O(ProgramNamedParameter4dvNV) },
1410
   { "glProgramNamedParameter4fNV", _O(ProgramNamedParameter4fNV) },
1411
   { "glProgramNamedParameter4fvNV", _O(ProgramNamedParameter4fvNV) },
1412
   { "glPrimitiveRestartIndex", _O(PrimitiveRestartIndex) },
1413
   { "glPrimitiveRestartNV", _O(PrimitiveRestartNV) },
1414
   { "glDepthBoundsEXT", _O(DepthBoundsEXT) },
1415
   { "glBlendEquationSeparate", _O(BlendEquationSeparate) },
1416
   { "glBindFramebuffer", _O(BindFramebuffer) },
1417
   { "glBindRenderbuffer", _O(BindRenderbuffer) },
1418
   { "glCheckFramebufferStatus", _O(CheckFramebufferStatus) },
1419
   { "glDeleteFramebuffers", _O(DeleteFramebuffers) },
1420
   { "glDeleteRenderbuffers", _O(DeleteRenderbuffers) },
1421
   { "glFramebufferRenderbuffer", _O(FramebufferRenderbuffer) },
1422
   { "glFramebufferTexture1D", _O(FramebufferTexture1D) },
1423
   { "glFramebufferTexture2D", _O(FramebufferTexture2D) },
1424
   { "glFramebufferTexture3D", _O(FramebufferTexture3D) },
1425
   { "glGenFramebuffers", _O(GenFramebuffers) },
1426
   { "glGenRenderbuffers", _O(GenRenderbuffers) },
1427
   { "glGenerateMipmap", _O(GenerateMipmap) },
1428
   { "glGetFramebufferAttachmentParameteriv", _O(GetFramebufferAttachmentParameteriv) },
1429
   { "glGetRenderbufferParameteriv", _O(GetRenderbufferParameteriv) },
1430
   { "glIsFramebuffer", _O(IsFramebuffer) },
1431
   { "glIsRenderbuffer", _O(IsRenderbuffer) },
1432
   { "glRenderbufferStorage", _O(RenderbufferStorage) },
1433
   { "glBlitFramebuffer", _O(BlitFramebuffer) },
1434
   { "glBufferParameteriAPPLE", _O(BufferParameteriAPPLE) },
1435
   { "glFlushMappedBufferRangeAPPLE", _O(FlushMappedBufferRangeAPPLE) },
1436
   { "glBindFragDataLocation", _O(BindFragDataLocation) },
1437
   { "glGetFragDataLocation", _O(GetFragDataLocation) },
1438
   { "glGetUniformuiv", _O(GetUniformuiv) },
1439
   { "glGetVertexAttribIiv", _O(GetVertexAttribIiv) },
1440
   { "glGetVertexAttribIuiv", _O(GetVertexAttribIuiv) },
1441
   { "glUniform1ui", _O(Uniform1ui) },
1442
   { "glUniform1uiv", _O(Uniform1uiv) },
1443
   { "glUniform2ui", _O(Uniform2ui) },
1444
   { "glUniform2uiv", _O(Uniform2uiv) },
1445
   { "glUniform3ui", _O(Uniform3ui) },
1446
   { "glUniform3uiv", _O(Uniform3uiv) },
1447
   { "glUniform4ui", _O(Uniform4ui) },
1448
   { "glUniform4uiv", _O(Uniform4uiv) },
1449
   { "glVertexAttribI1iEXT", _O(VertexAttribI1iEXT) },
1450
   { "glVertexAttribI1iv", _O(VertexAttribI1iv) },
1451
   { "glVertexAttribI1uiEXT", _O(VertexAttribI1uiEXT) },
1452
   { "glVertexAttribI1uiv", _O(VertexAttribI1uiv) },
1453
   { "glVertexAttribI2iEXT", _O(VertexAttribI2iEXT) },
1454
   { "glVertexAttribI2ivEXT", _O(VertexAttribI2ivEXT) },
1455
   { "glVertexAttribI2uiEXT", _O(VertexAttribI2uiEXT) },
1456
   { "glVertexAttribI2uivEXT", _O(VertexAttribI2uivEXT) },
1457
   { "glVertexAttribI3iEXT", _O(VertexAttribI3iEXT) },
1458
   { "glVertexAttribI3ivEXT", _O(VertexAttribI3ivEXT) },
1459
   { "glVertexAttribI3uiEXT", _O(VertexAttribI3uiEXT) },
1460
   { "glVertexAttribI3uivEXT", _O(VertexAttribI3uivEXT) },
1461
   { "glVertexAttribI4bv", _O(VertexAttribI4bv) },
1462
   { "glVertexAttribI4iEXT", _O(VertexAttribI4iEXT) },
1463
   { "glVertexAttribI4ivEXT", _O(VertexAttribI4ivEXT) },
1464
   { "glVertexAttribI4sv", _O(VertexAttribI4sv) },
1465
   { "glVertexAttribI4ubv", _O(VertexAttribI4ubv) },
1466
   { "glVertexAttribI4uiEXT", _O(VertexAttribI4uiEXT) },
1467
   { "glVertexAttribI4uivEXT", _O(VertexAttribI4uivEXT) },
1468
   { "glVertexAttribI4usv", _O(VertexAttribI4usv) },
1469
   { "glVertexAttribIPointer", _O(VertexAttribIPointer) },
1470
   { "glFramebufferTextureLayer", _O(FramebufferTextureLayer) },
1471
   { "glColorMaski", _O(ColorMaski) },
1472
   { "glDisablei", _O(Disablei) },
1473
   { "glEnablei", _O(Enablei) },
1474
   { "glGetBooleani_v", _O(GetBooleani_v) },
1475
   { "glGetIntegeri_v", _O(GetIntegeri_v) },
1476
   { "glIsEnabledi", _O(IsEnabledi) },
1477
   { "glClearColorIiEXT", _O(ClearColorIiEXT) },
1478
   { "glClearColorIuiEXT", _O(ClearColorIuiEXT) },
1479
   { "glGetTexParameterIiv", _O(GetTexParameterIiv) },
1480
   { "glGetTexParameterIuiv", _O(GetTexParameterIuiv) },
1481
   { "glTexParameterIiv", _O(TexParameterIiv) },
1482
   { "glTexParameterIuiv", _O(TexParameterIuiv) },
1483
   { "glBeginConditionalRender", _O(BeginConditionalRender) },
1484
   { "glEndConditionalRender", _O(EndConditionalRender) },
1485
   { "glBeginTransformFeedback", _O(BeginTransformFeedback) },
1486
   { "glBindBufferBase", _O(BindBufferBase) },
1487
   { "glBindBufferOffsetEXT", _O(BindBufferOffsetEXT) },
1488
   { "glBindBufferRange", _O(BindBufferRange) },
1489
   { "glEndTransformFeedback", _O(EndTransformFeedback) },
1490
   { "glGetTransformFeedbackVarying", _O(GetTransformFeedbackVarying) },
1491
   { "glTransformFeedbackVaryings", _O(TransformFeedbackVaryings) },
1492
   { "glProvokingVertex", _O(ProvokingVertex) },
1493
   { "glGetObjectParameterivAPPLE", _O(GetObjectParameterivAPPLE) },
1494
   { "glObjectPurgeableAPPLE", _O(ObjectPurgeableAPPLE) },
1495
   { "glObjectUnpurgeableAPPLE", _O(ObjectUnpurgeableAPPLE) },
1496
   { "glActiveProgramEXT", _O(ActiveProgramEXT) },
1497
   { "glCreateShaderProgramEXT", _O(CreateShaderProgramEXT) },
1498
   { "glUseShaderProgramEXT", _O(UseShaderProgramEXT) },
1499
   { "glTextureBarrierNV", _O(TextureBarrierNV) },
1500
   { "glStencilFuncSeparateATI", _O(StencilFuncSeparateATI) },
1501
   { "glProgramEnvParameters4fvEXT", _O(ProgramEnvParameters4fvEXT) },
1502
   { "glProgramLocalParameters4fvEXT", _O(ProgramLocalParameters4fvEXT) },
1503
   { "glGetQueryObjecti64v", _O(GetQueryObjecti64v) },
1504
   { "glGetQueryObjectui64v", _O(GetQueryObjectui64v) },
1505
   { "glEGLImageTargetRenderbufferStorageOES", _O(EGLImageTargetRenderbufferStorageOES) },
1506
   { "glEGLImageTargetTexture2DOES", _O(EGLImageTargetTexture2DOES) },
1507
   { NULL, 0 }
1508
};
1509

1510
#ifdef GLX_INDIRECT_RENDERING
1511
extern "C" {
1512
GLAPI GLboolean GLAPIENTRY
1513
glAreTexturesResidentEXT(GLsizei n, const GLuint *textures,
1514
			 GLboolean *residences)
1515
{
1516
   (void) n;
1517
   (void) textures;
1518
   (void) residences;
1519
   return GL_FALSE;
1520
}
1521

1522
GLAPI void GLAPIENTRY
1523
glDeleteTexturesEXT(GLsizei n, const GLuint *textures)
1524
{
1525
   (void) n;
1526
   (void) textures;
1527
}
1528

1529
GLAPI void GLAPIENTRY
1530
glGenTexturesEXT(GLsizei n, GLuint *textures)
1531
{
1532
   (void) n;
1533
   (void) textures;
1534
}
1535

1536
GLAPI GLboolean GLAPIENTRY
1537
glIsTextureEXT(GLuint texture)
1538
{
1539
   (void) texture;
1540
   return GL_FALSE;
1541
}
1542

1543
GLAPI void GLAPIENTRY
1544
glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
1545
{
1546
   (void) target;
1547
   (void) format;
1548
   (void) type;
1549
   (void) table;
1550
}
1551

1552
GLAPI void GLAPIENTRY
1553
glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
1554
{
1555
   (void) target;
1556
   (void) pname;
1557
   (void) params;
1558
}
1559

1560
GLAPI void GLAPIENTRY
1561
glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params)
1562
{
1563
   (void) target;
1564
   (void) pname;
1565
   (void) params;
1566
}
1567

1568
void GLAPIENTRY
1569
gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image)
1570
{
1571
   (void) target;
1572
   (void) format;
1573
   (void) type;
1574
   (void) image;
1575
}
1576

1577
void GLAPIENTRY
1578
gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
1579
{
1580
   (void) target;
1581
   (void) pname;
1582
   (void) params;
1583
}
1584

1585
void GLAPIENTRY
1586
gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
1587
{
1588
   (void) target;
1589
   (void) pname;
1590
   (void) params;
1591
}
1592

1593
void GLAPIENTRY
1594
gl_dispatch_stub_359(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)
1595
{
1596
   (void) target;
1597
   (void) format;
1598
   (void) type;
1599
   (void) row;
1600
   (void) column;
1601
   (void) span;
1602
}
1603

1604
void GLAPIENTRY
1605
gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
1606
{
1607
   (void) target;
1608
   (void) reset;
1609
   (void) format;
1610
   (void) type;
1611
   (void) values;
1612
}
1613

1614
void GLAPIENTRY
1615
gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
1616
{
1617
   (void) target;
1618
   (void) pname;
1619
   (void) params;
1620
}
1621

1622
void GLAPIENTRY
1623
gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
1624
{
1625
   (void) target;
1626
   (void) pname;
1627
   (void) params;
1628
}
1629

1630
void GLAPIENTRY
1631
gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
1632
{
1633
   (void) target;
1634
   (void) reset;
1635
   (void) format;
1636
   (void) type;
1637
   (void) values;
1638
}
1639

1640
void GLAPIENTRY
1641
gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
1642
{
1643
   (void) target;
1644
   (void) pname;
1645
   (void) params;
1646
}
1647

1648
void GLAPIENTRY
1649
gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
1650
{
1651
   (void) target;
1652
   (void) pname;
1653
   (void) params;
1654
}
1655

1656
}
1657
#endif
1658

1659
Product

Resources

Company
