1 /* DO NOT EDIT - This file generated automatically by gl_gen_table.py (from Mesa) script */
2
3 /*
4 * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
5 * (C) Copyright IBM Corporation 2004, 2005
6 * (C) Copyright Apple Inc 2011
7 * All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sub license,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
18 * Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
23 * BRIAN PAUL, IBM,
24 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
25 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
26 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 * SOFTWARE.
28 */
29
30 /* GLXEXT is the define used in the xserver when the GLX extension is being
31 * built. Hijack this to determine whether this file is being built for the
32 * server or the client.
33 */
34 #ifdef HAVE_DIX_CONFIG_H
35 #include <dix-config.h>
36 #endif
37
38 #if (defined(GLXEXT) && defined(HAVE_BACKTRACE)) \
39 || (!defined(GLXEXT) && defined(DEBUG) && !defined(_WIN32_WCE))
40 #define USE_BACKTRACE
41 #endif
42
43 #ifdef USE_BACKTRACE
44 #include <execinfo.h>
45 #endif
46
47 #include <dlfcn.h>
48 #include <stdlib.h>
49 #include <stdio.h>
50
51 #include <GL/gl.h>
52
53 #include "glapi.h"
54 #include "glapitable.h"
55
56 #ifdef GLXEXT
57 #include "os.h"
58 #endif
59
60 static void
__glapi_gentable_NoOp(void)61 __glapi_gentable_NoOp(void) {
62 const char *fstr = "Unknown";
63
64 /* Silence potential GCC warning for some #ifdef paths.
65 */
66 (void) fstr;
67 #if defined(USE_BACKTRACE)
68 #if !defined(GLXEXT)
69 if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
70 #endif
71 {
72 void *frames[2];
73
74 if(backtrace(frames, 2) == 2) {
75 Dl_info info;
76 dladdr(frames[1], &info);
77 if(info.dli_sname)
78 fstr = info.dli_sname;
79 }
80
81 #if !defined(GLXEXT)
82 fprintf(stderr, "Call to unimplemented API: %s\n", fstr);
83 #endif
84 }
85 #endif
86 #if defined(GLXEXT)
87 LogMessage(X_ERROR, "GLX: Call to unimplemented API: %s\n", fstr);
88 #endif
89 }
90
91 static void
__glapi_gentable_set_remaining_noop(struct _glapi_table * disp)92 __glapi_gentable_set_remaining_noop(struct _glapi_table *disp) {
93 GLuint entries = _glapi_get_dispatch_table_size();
94 void **dispatch = (void **) disp;
95 int i;
96
97 /* ISO C is annoying sometimes */
98 union {_glapi_proc p; void *v;} p;
99 p.p = __glapi_gentable_NoOp;
100
101 for(i=0; i < entries; i++)
102 if(dispatch[i] == NULL)
103 dispatch[i] = p.v;
104 }
105
106 struct _glapi_table *
_glapi_create_table_from_handle(void * handle,const char * symbol_prefix)107 _glapi_create_table_from_handle(void *handle, const char *symbol_prefix) {
108 struct _glapi_table *disp = calloc(1, sizeof(struct _glapi_table));
109 char symboln[512];
110
111 if(!disp)
112 return NULL;
113
114 if(symbol_prefix == NULL)
115 symbol_prefix = "";
116
117
118 if(!disp->NewList) {
119 void ** procp = (void **) &disp->NewList;
120 snprintf(symboln, sizeof(symboln), "%sNewList", symbol_prefix);
121 *procp = dlsym(handle, symboln);
122 }
123
124
125 if(!disp->EndList) {
126 void ** procp = (void **) &disp->EndList;
127 snprintf(symboln, sizeof(symboln), "%sEndList", symbol_prefix);
128 *procp = dlsym(handle, symboln);
129 }
130
131
132 if(!disp->CallList) {
133 void ** procp = (void **) &disp->CallList;
134 snprintf(symboln, sizeof(symboln), "%sCallList", symbol_prefix);
135 *procp = dlsym(handle, symboln);
136 }
137
138
139 if(!disp->CallLists) {
140 void ** procp = (void **) &disp->CallLists;
141 snprintf(symboln, sizeof(symboln), "%sCallLists", symbol_prefix);
142 *procp = dlsym(handle, symboln);
143 }
144
145
146 if(!disp->DeleteLists) {
147 void ** procp = (void **) &disp->DeleteLists;
148 snprintf(symboln, sizeof(symboln), "%sDeleteLists", symbol_prefix);
149 *procp = dlsym(handle, symboln);
150 }
151
152
153 if(!disp->GenLists) {
154 void ** procp = (void **) &disp->GenLists;
155 snprintf(symboln, sizeof(symboln), "%sGenLists", symbol_prefix);
156 *procp = dlsym(handle, symboln);
157 }
158
159
160 if(!disp->ListBase) {
161 void ** procp = (void **) &disp->ListBase;
162 snprintf(symboln, sizeof(symboln), "%sListBase", symbol_prefix);
163 *procp = dlsym(handle, symboln);
164 }
165
166
167 if(!disp->Begin) {
168 void ** procp = (void **) &disp->Begin;
169 snprintf(symboln, sizeof(symboln), "%sBegin", symbol_prefix);
170 *procp = dlsym(handle, symboln);
171 }
172
173
174 if(!disp->Bitmap) {
175 void ** procp = (void **) &disp->Bitmap;
176 snprintf(symboln, sizeof(symboln), "%sBitmap", symbol_prefix);
177 *procp = dlsym(handle, symboln);
178 }
179
180
181 if(!disp->Color3b) {
182 void ** procp = (void **) &disp->Color3b;
183 snprintf(symboln, sizeof(symboln), "%sColor3b", symbol_prefix);
184 *procp = dlsym(handle, symboln);
185 }
186
187
188 if(!disp->Color3bv) {
189 void ** procp = (void **) &disp->Color3bv;
190 snprintf(symboln, sizeof(symboln), "%sColor3bv", symbol_prefix);
191 *procp = dlsym(handle, symboln);
192 }
193
194
195 if(!disp->Color3d) {
196 void ** procp = (void **) &disp->Color3d;
197 snprintf(symboln, sizeof(symboln), "%sColor3d", symbol_prefix);
198 *procp = dlsym(handle, symboln);
199 }
200
201
202 if(!disp->Color3dv) {
203 void ** procp = (void **) &disp->Color3dv;
204 snprintf(symboln, sizeof(symboln), "%sColor3dv", symbol_prefix);
205 *procp = dlsym(handle, symboln);
206 }
207
208
209 if(!disp->Color3f) {
210 void ** procp = (void **) &disp->Color3f;
211 snprintf(symboln, sizeof(symboln), "%sColor3f", symbol_prefix);
212 *procp = dlsym(handle, symboln);
213 }
214
215
216 if(!disp->Color3fv) {
217 void ** procp = (void **) &disp->Color3fv;
218 snprintf(symboln, sizeof(symboln), "%sColor3fv", symbol_prefix);
219 *procp = dlsym(handle, symboln);
220 }
221
222
223 if(!disp->Color3i) {
224 void ** procp = (void **) &disp->Color3i;
225 snprintf(symboln, sizeof(symboln), "%sColor3i", symbol_prefix);
226 *procp = dlsym(handle, symboln);
227 }
228
229
230 if(!disp->Color3iv) {
231 void ** procp = (void **) &disp->Color3iv;
232 snprintf(symboln, sizeof(symboln), "%sColor3iv", symbol_prefix);
233 *procp = dlsym(handle, symboln);
234 }
235
236
237 if(!disp->Color3s) {
238 void ** procp = (void **) &disp->Color3s;
239 snprintf(symboln, sizeof(symboln), "%sColor3s", symbol_prefix);
240 *procp = dlsym(handle, symboln);
241 }
242
243
244 if(!disp->Color3sv) {
245 void ** procp = (void **) &disp->Color3sv;
246 snprintf(symboln, sizeof(symboln), "%sColor3sv", symbol_prefix);
247 *procp = dlsym(handle, symboln);
248 }
249
250
251 if(!disp->Color3ub) {
252 void ** procp = (void **) &disp->Color3ub;
253 snprintf(symboln, sizeof(symboln), "%sColor3ub", symbol_prefix);
254 *procp = dlsym(handle, symboln);
255 }
256
257
258 if(!disp->Color3ubv) {
259 void ** procp = (void **) &disp->Color3ubv;
260 snprintf(symboln, sizeof(symboln), "%sColor3ubv", symbol_prefix);
261 *procp = dlsym(handle, symboln);
262 }
263
264
265 if(!disp->Color3ui) {
266 void ** procp = (void **) &disp->Color3ui;
267 snprintf(symboln, sizeof(symboln), "%sColor3ui", symbol_prefix);
268 *procp = dlsym(handle, symboln);
269 }
270
271
272 if(!disp->Color3uiv) {
273 void ** procp = (void **) &disp->Color3uiv;
274 snprintf(symboln, sizeof(symboln), "%sColor3uiv", symbol_prefix);
275 *procp = dlsym(handle, symboln);
276 }
277
278
279 if(!disp->Color3us) {
280 void ** procp = (void **) &disp->Color3us;
281 snprintf(symboln, sizeof(symboln), "%sColor3us", symbol_prefix);
282 *procp = dlsym(handle, symboln);
283 }
284
285
286 if(!disp->Color3usv) {
287 void ** procp = (void **) &disp->Color3usv;
288 snprintf(symboln, sizeof(symboln), "%sColor3usv", symbol_prefix);
289 *procp = dlsym(handle, symboln);
290 }
291
292
293 if(!disp->Color4b) {
294 void ** procp = (void **) &disp->Color4b;
295 snprintf(symboln, sizeof(symboln), "%sColor4b", symbol_prefix);
296 *procp = dlsym(handle, symboln);
297 }
298
299
300 if(!disp->Color4bv) {
301 void ** procp = (void **) &disp->Color4bv;
302 snprintf(symboln, sizeof(symboln), "%sColor4bv", symbol_prefix);
303 *procp = dlsym(handle, symboln);
304 }
305
306
307 if(!disp->Color4d) {
308 void ** procp = (void **) &disp->Color4d;
309 snprintf(symboln, sizeof(symboln), "%sColor4d", symbol_prefix);
310 *procp = dlsym(handle, symboln);
311 }
312
313
314 if(!disp->Color4dv) {
315 void ** procp = (void **) &disp->Color4dv;
316 snprintf(symboln, sizeof(symboln), "%sColor4dv", symbol_prefix);
317 *procp = dlsym(handle, symboln);
318 }
319
320
321 if(!disp->Color4f) {
322 void ** procp = (void **) &disp->Color4f;
323 snprintf(symboln, sizeof(symboln), "%sColor4f", symbol_prefix);
324 *procp = dlsym(handle, symboln);
325 }
326
327
328 if(!disp->Color4fv) {
329 void ** procp = (void **) &disp->Color4fv;
330 snprintf(symboln, sizeof(symboln), "%sColor4fv", symbol_prefix);
331 *procp = dlsym(handle, symboln);
332 }
333
334
335 if(!disp->Color4i) {
336 void ** procp = (void **) &disp->Color4i;
337 snprintf(symboln, sizeof(symboln), "%sColor4i", symbol_prefix);
338 *procp = dlsym(handle, symboln);
339 }
340
341
342 if(!disp->Color4iv) {
343 void ** procp = (void **) &disp->Color4iv;
344 snprintf(symboln, sizeof(symboln), "%sColor4iv", symbol_prefix);
345 *procp = dlsym(handle, symboln);
346 }
347
348
349 if(!disp->Color4s) {
350 void ** procp = (void **) &disp->Color4s;
351 snprintf(symboln, sizeof(symboln), "%sColor4s", symbol_prefix);
352 *procp = dlsym(handle, symboln);
353 }
354
355
356 if(!disp->Color4sv) {
357 void ** procp = (void **) &disp->Color4sv;
358 snprintf(symboln, sizeof(symboln), "%sColor4sv", symbol_prefix);
359 *procp = dlsym(handle, symboln);
360 }
361
362
363 if(!disp->Color4ub) {
364 void ** procp = (void **) &disp->Color4ub;
365 snprintf(symboln, sizeof(symboln), "%sColor4ub", symbol_prefix);
366 *procp = dlsym(handle, symboln);
367 }
368
369
370 if(!disp->Color4ubv) {
371 void ** procp = (void **) &disp->Color4ubv;
372 snprintf(symboln, sizeof(symboln), "%sColor4ubv", symbol_prefix);
373 *procp = dlsym(handle, symboln);
374 }
375
376
377 if(!disp->Color4ui) {
378 void ** procp = (void **) &disp->Color4ui;
379 snprintf(symboln, sizeof(symboln), "%sColor4ui", symbol_prefix);
380 *procp = dlsym(handle, symboln);
381 }
382
383
384 if(!disp->Color4uiv) {
385 void ** procp = (void **) &disp->Color4uiv;
386 snprintf(symboln, sizeof(symboln), "%sColor4uiv", symbol_prefix);
387 *procp = dlsym(handle, symboln);
388 }
389
390
391 if(!disp->Color4us) {
392 void ** procp = (void **) &disp->Color4us;
393 snprintf(symboln, sizeof(symboln), "%sColor4us", symbol_prefix);
394 *procp = dlsym(handle, symboln);
395 }
396
397
398 if(!disp->Color4usv) {
399 void ** procp = (void **) &disp->Color4usv;
400 snprintf(symboln, sizeof(symboln), "%sColor4usv", symbol_prefix);
401 *procp = dlsym(handle, symboln);
402 }
403
404
405 if(!disp->EdgeFlag) {
406 void ** procp = (void **) &disp->EdgeFlag;
407 snprintf(symboln, sizeof(symboln), "%sEdgeFlag", symbol_prefix);
408 *procp = dlsym(handle, symboln);
409 }
410
411
412 if(!disp->EdgeFlagv) {
413 void ** procp = (void **) &disp->EdgeFlagv;
414 snprintf(symboln, sizeof(symboln), "%sEdgeFlagv", symbol_prefix);
415 *procp = dlsym(handle, symboln);
416 }
417
418
419 if(!disp->End) {
420 void ** procp = (void **) &disp->End;
421 snprintf(symboln, sizeof(symboln), "%sEnd", symbol_prefix);
422 *procp = dlsym(handle, symboln);
423 }
424
425
426 if(!disp->Indexd) {
427 void ** procp = (void **) &disp->Indexd;
428 snprintf(symboln, sizeof(symboln), "%sIndexd", symbol_prefix);
429 *procp = dlsym(handle, symboln);
430 }
431
432
433 if(!disp->Indexdv) {
434 void ** procp = (void **) &disp->Indexdv;
435 snprintf(symboln, sizeof(symboln), "%sIndexdv", symbol_prefix);
436 *procp = dlsym(handle, symboln);
437 }
438
439
440 if(!disp->Indexf) {
441 void ** procp = (void **) &disp->Indexf;
442 snprintf(symboln, sizeof(symboln), "%sIndexf", symbol_prefix);
443 *procp = dlsym(handle, symboln);
444 }
445
446
447 if(!disp->Indexfv) {
448 void ** procp = (void **) &disp->Indexfv;
449 snprintf(symboln, sizeof(symboln), "%sIndexfv", symbol_prefix);
450 *procp = dlsym(handle, symboln);
451 }
452
453
454 if(!disp->Indexi) {
455 void ** procp = (void **) &disp->Indexi;
456 snprintf(symboln, sizeof(symboln), "%sIndexi", symbol_prefix);
457 *procp = dlsym(handle, symboln);
458 }
459
460
461 if(!disp->Indexiv) {
462 void ** procp = (void **) &disp->Indexiv;
463 snprintf(symboln, sizeof(symboln), "%sIndexiv", symbol_prefix);
464 *procp = dlsym(handle, symboln);
465 }
466
467
468 if(!disp->Indexs) {
469 void ** procp = (void **) &disp->Indexs;
470 snprintf(symboln, sizeof(symboln), "%sIndexs", symbol_prefix);
471 *procp = dlsym(handle, symboln);
472 }
473
474
475 if(!disp->Indexsv) {
476 void ** procp = (void **) &disp->Indexsv;
477 snprintf(symboln, sizeof(symboln), "%sIndexsv", symbol_prefix);
478 *procp = dlsym(handle, symboln);
479 }
480
481
482 if(!disp->Normal3b) {
483 void ** procp = (void **) &disp->Normal3b;
484 snprintf(symboln, sizeof(symboln), "%sNormal3b", symbol_prefix);
485 *procp = dlsym(handle, symboln);
486 }
487
488
489 if(!disp->Normal3bv) {
490 void ** procp = (void **) &disp->Normal3bv;
491 snprintf(symboln, sizeof(symboln), "%sNormal3bv", symbol_prefix);
492 *procp = dlsym(handle, symboln);
493 }
494
495
496 if(!disp->Normal3d) {
497 void ** procp = (void **) &disp->Normal3d;
498 snprintf(symboln, sizeof(symboln), "%sNormal3d", symbol_prefix);
499 *procp = dlsym(handle, symboln);
500 }
501
502
503 if(!disp->Normal3dv) {
504 void ** procp = (void **) &disp->Normal3dv;
505 snprintf(symboln, sizeof(symboln), "%sNormal3dv", symbol_prefix);
506 *procp = dlsym(handle, symboln);
507 }
508
509
510 if(!disp->Normal3f) {
511 void ** procp = (void **) &disp->Normal3f;
512 snprintf(symboln, sizeof(symboln), "%sNormal3f", symbol_prefix);
513 *procp = dlsym(handle, symboln);
514 }
515
516
517 if(!disp->Normal3fv) {
518 void ** procp = (void **) &disp->Normal3fv;
519 snprintf(symboln, sizeof(symboln), "%sNormal3fv", symbol_prefix);
520 *procp = dlsym(handle, symboln);
521 }
522
523
524 if(!disp->Normal3i) {
525 void ** procp = (void **) &disp->Normal3i;
526 snprintf(symboln, sizeof(symboln), "%sNormal3i", symbol_prefix);
527 *procp = dlsym(handle, symboln);
528 }
529
530
531 if(!disp->Normal3iv) {
532 void ** procp = (void **) &disp->Normal3iv;
533 snprintf(symboln, sizeof(symboln), "%sNormal3iv", symbol_prefix);
534 *procp = dlsym(handle, symboln);
535 }
536
537
538 if(!disp->Normal3s) {
539 void ** procp = (void **) &disp->Normal3s;
540 snprintf(symboln, sizeof(symboln), "%sNormal3s", symbol_prefix);
541 *procp = dlsym(handle, symboln);
542 }
543
544
545 if(!disp->Normal3sv) {
546 void ** procp = (void **) &disp->Normal3sv;
547 snprintf(symboln, sizeof(symboln), "%sNormal3sv", symbol_prefix);
548 *procp = dlsym(handle, symboln);
549 }
550
551
552 if(!disp->RasterPos2d) {
553 void ** procp = (void **) &disp->RasterPos2d;
554 snprintf(symboln, sizeof(symboln), "%sRasterPos2d", symbol_prefix);
555 *procp = dlsym(handle, symboln);
556 }
557
558
559 if(!disp->RasterPos2dv) {
560 void ** procp = (void **) &disp->RasterPos2dv;
561 snprintf(symboln, sizeof(symboln), "%sRasterPos2dv", symbol_prefix);
562 *procp = dlsym(handle, symboln);
563 }
564
565
566 if(!disp->RasterPos2f) {
567 void ** procp = (void **) &disp->RasterPos2f;
568 snprintf(symboln, sizeof(symboln), "%sRasterPos2f", symbol_prefix);
569 *procp = dlsym(handle, symboln);
570 }
571
572
573 if(!disp->RasterPos2fv) {
574 void ** procp = (void **) &disp->RasterPos2fv;
575 snprintf(symboln, sizeof(symboln), "%sRasterPos2fv", symbol_prefix);
576 *procp = dlsym(handle, symboln);
577 }
578
579
580 if(!disp->RasterPos2i) {
581 void ** procp = (void **) &disp->RasterPos2i;
582 snprintf(symboln, sizeof(symboln), "%sRasterPos2i", symbol_prefix);
583 *procp = dlsym(handle, symboln);
584 }
585
586
587 if(!disp->RasterPos2iv) {
588 void ** procp = (void **) &disp->RasterPos2iv;
589 snprintf(symboln, sizeof(symboln), "%sRasterPos2iv", symbol_prefix);
590 *procp = dlsym(handle, symboln);
591 }
592
593
594 if(!disp->RasterPos2s) {
595 void ** procp = (void **) &disp->RasterPos2s;
596 snprintf(symboln, sizeof(symboln), "%sRasterPos2s", symbol_prefix);
597 *procp = dlsym(handle, symboln);
598 }
599
600
601 if(!disp->RasterPos2sv) {
602 void ** procp = (void **) &disp->RasterPos2sv;
603 snprintf(symboln, sizeof(symboln), "%sRasterPos2sv", symbol_prefix);
604 *procp = dlsym(handle, symboln);
605 }
606
607
608 if(!disp->RasterPos3d) {
609 void ** procp = (void **) &disp->RasterPos3d;
610 snprintf(symboln, sizeof(symboln), "%sRasterPos3d", symbol_prefix);
611 *procp = dlsym(handle, symboln);
612 }
613
614
615 if(!disp->RasterPos3dv) {
616 void ** procp = (void **) &disp->RasterPos3dv;
617 snprintf(symboln, sizeof(symboln), "%sRasterPos3dv", symbol_prefix);
618 *procp = dlsym(handle, symboln);
619 }
620
621
622 if(!disp->RasterPos3f) {
623 void ** procp = (void **) &disp->RasterPos3f;
624 snprintf(symboln, sizeof(symboln), "%sRasterPos3f", symbol_prefix);
625 *procp = dlsym(handle, symboln);
626 }
627
628
629 if(!disp->RasterPos3fv) {
630 void ** procp = (void **) &disp->RasterPos3fv;
631 snprintf(symboln, sizeof(symboln), "%sRasterPos3fv", symbol_prefix);
632 *procp = dlsym(handle, symboln);
633 }
634
635
636 if(!disp->RasterPos3i) {
637 void ** procp = (void **) &disp->RasterPos3i;
638 snprintf(symboln, sizeof(symboln), "%sRasterPos3i", symbol_prefix);
639 *procp = dlsym(handle, symboln);
640 }
641
642
643 if(!disp->RasterPos3iv) {
644 void ** procp = (void **) &disp->RasterPos3iv;
645 snprintf(symboln, sizeof(symboln), "%sRasterPos3iv", symbol_prefix);
646 *procp = dlsym(handle, symboln);
647 }
648
649
650 if(!disp->RasterPos3s) {
651 void ** procp = (void **) &disp->RasterPos3s;
652 snprintf(symboln, sizeof(symboln), "%sRasterPos3s", symbol_prefix);
653 *procp = dlsym(handle, symboln);
654 }
655
656
657 if(!disp->RasterPos3sv) {
658 void ** procp = (void **) &disp->RasterPos3sv;
659 snprintf(symboln, sizeof(symboln), "%sRasterPos3sv", symbol_prefix);
660 *procp = dlsym(handle, symboln);
661 }
662
663
664 if(!disp->RasterPos4d) {
665 void ** procp = (void **) &disp->RasterPos4d;
666 snprintf(symboln, sizeof(symboln), "%sRasterPos4d", symbol_prefix);
667 *procp = dlsym(handle, symboln);
668 }
669
670
671 if(!disp->RasterPos4dv) {
672 void ** procp = (void **) &disp->RasterPos4dv;
673 snprintf(symboln, sizeof(symboln), "%sRasterPos4dv", symbol_prefix);
674 *procp = dlsym(handle, symboln);
675 }
676
677
678 if(!disp->RasterPos4f) {
679 void ** procp = (void **) &disp->RasterPos4f;
680 snprintf(symboln, sizeof(symboln), "%sRasterPos4f", symbol_prefix);
681 *procp = dlsym(handle, symboln);
682 }
683
684
685 if(!disp->RasterPos4fv) {
686 void ** procp = (void **) &disp->RasterPos4fv;
687 snprintf(symboln, sizeof(symboln), "%sRasterPos4fv", symbol_prefix);
688 *procp = dlsym(handle, symboln);
689 }
690
691
692 if(!disp->RasterPos4i) {
693 void ** procp = (void **) &disp->RasterPos4i;
694 snprintf(symboln, sizeof(symboln), "%sRasterPos4i", symbol_prefix);
695 *procp = dlsym(handle, symboln);
696 }
697
698
699 if(!disp->RasterPos4iv) {
700 void ** procp = (void **) &disp->RasterPos4iv;
701 snprintf(symboln, sizeof(symboln), "%sRasterPos4iv", symbol_prefix);
702 *procp = dlsym(handle, symboln);
703 }
704
705
706 if(!disp->RasterPos4s) {
707 void ** procp = (void **) &disp->RasterPos4s;
708 snprintf(symboln, sizeof(symboln), "%sRasterPos4s", symbol_prefix);
709 *procp = dlsym(handle, symboln);
710 }
711
712
713 if(!disp->RasterPos4sv) {
714 void ** procp = (void **) &disp->RasterPos4sv;
715 snprintf(symboln, sizeof(symboln), "%sRasterPos4sv", symbol_prefix);
716 *procp = dlsym(handle, symboln);
717 }
718
719
720 if(!disp->Rectd) {
721 void ** procp = (void **) &disp->Rectd;
722 snprintf(symboln, sizeof(symboln), "%sRectd", symbol_prefix);
723 *procp = dlsym(handle, symboln);
724 }
725
726
727 if(!disp->Rectdv) {
728 void ** procp = (void **) &disp->Rectdv;
729 snprintf(symboln, sizeof(symboln), "%sRectdv", symbol_prefix);
730 *procp = dlsym(handle, symboln);
731 }
732
733
734 if(!disp->Rectf) {
735 void ** procp = (void **) &disp->Rectf;
736 snprintf(symboln, sizeof(symboln), "%sRectf", symbol_prefix);
737 *procp = dlsym(handle, symboln);
738 }
739
740
741 if(!disp->Rectfv) {
742 void ** procp = (void **) &disp->Rectfv;
743 snprintf(symboln, sizeof(symboln), "%sRectfv", symbol_prefix);
744 *procp = dlsym(handle, symboln);
745 }
746
747
748 if(!disp->Recti) {
749 void ** procp = (void **) &disp->Recti;
750 snprintf(symboln, sizeof(symboln), "%sRecti", symbol_prefix);
751 *procp = dlsym(handle, symboln);
752 }
753
754
755 if(!disp->Rectiv) {
756 void ** procp = (void **) &disp->Rectiv;
757 snprintf(symboln, sizeof(symboln), "%sRectiv", symbol_prefix);
758 *procp = dlsym(handle, symboln);
759 }
760
761
762 if(!disp->Rects) {
763 void ** procp = (void **) &disp->Rects;
764 snprintf(symboln, sizeof(symboln), "%sRects", symbol_prefix);
765 *procp = dlsym(handle, symboln);
766 }
767
768
769 if(!disp->Rectsv) {
770 void ** procp = (void **) &disp->Rectsv;
771 snprintf(symboln, sizeof(symboln), "%sRectsv", symbol_prefix);
772 *procp = dlsym(handle, symboln);
773 }
774
775
776 if(!disp->TexCoord1d) {
777 void ** procp = (void **) &disp->TexCoord1d;
778 snprintf(symboln, sizeof(symboln), "%sTexCoord1d", symbol_prefix);
779 *procp = dlsym(handle, symboln);
780 }
781
782
783 if(!disp->TexCoord1dv) {
784 void ** procp = (void **) &disp->TexCoord1dv;
785 snprintf(symboln, sizeof(symboln), "%sTexCoord1dv", symbol_prefix);
786 *procp = dlsym(handle, symboln);
787 }
788
789
790 if(!disp->TexCoord1f) {
791 void ** procp = (void **) &disp->TexCoord1f;
792 snprintf(symboln, sizeof(symboln), "%sTexCoord1f", symbol_prefix);
793 *procp = dlsym(handle, symboln);
794 }
795
796
797 if(!disp->TexCoord1fv) {
798 void ** procp = (void **) &disp->TexCoord1fv;
799 snprintf(symboln, sizeof(symboln), "%sTexCoord1fv", symbol_prefix);
800 *procp = dlsym(handle, symboln);
801 }
802
803
804 if(!disp->TexCoord1i) {
805 void ** procp = (void **) &disp->TexCoord1i;
806 snprintf(symboln, sizeof(symboln), "%sTexCoord1i", symbol_prefix);
807 *procp = dlsym(handle, symboln);
808 }
809
810
811 if(!disp->TexCoord1iv) {
812 void ** procp = (void **) &disp->TexCoord1iv;
813 snprintf(symboln, sizeof(symboln), "%sTexCoord1iv", symbol_prefix);
814 *procp = dlsym(handle, symboln);
815 }
816
817
818 if(!disp->TexCoord1s) {
819 void ** procp = (void **) &disp->TexCoord1s;
820 snprintf(symboln, sizeof(symboln), "%sTexCoord1s", symbol_prefix);
821 *procp = dlsym(handle, symboln);
822 }
823
824
825 if(!disp->TexCoord1sv) {
826 void ** procp = (void **) &disp->TexCoord1sv;
827 snprintf(symboln, sizeof(symboln), "%sTexCoord1sv", symbol_prefix);
828 *procp = dlsym(handle, symboln);
829 }
830
831
832 if(!disp->TexCoord2d) {
833 void ** procp = (void **) &disp->TexCoord2d;
834 snprintf(symboln, sizeof(symboln), "%sTexCoord2d", symbol_prefix);
835 *procp = dlsym(handle, symboln);
836 }
837
838
839 if(!disp->TexCoord2dv) {
840 void ** procp = (void **) &disp->TexCoord2dv;
841 snprintf(symboln, sizeof(symboln), "%sTexCoord2dv", symbol_prefix);
842 *procp = dlsym(handle, symboln);
843 }
844
845
846 if(!disp->TexCoord2f) {
847 void ** procp = (void **) &disp->TexCoord2f;
848 snprintf(symboln, sizeof(symboln), "%sTexCoord2f", symbol_prefix);
849 *procp = dlsym(handle, symboln);
850 }
851
852
853 if(!disp->TexCoord2fv) {
854 void ** procp = (void **) &disp->TexCoord2fv;
855 snprintf(symboln, sizeof(symboln), "%sTexCoord2fv", symbol_prefix);
856 *procp = dlsym(handle, symboln);
857 }
858
859
860 if(!disp->TexCoord2i) {
861 void ** procp = (void **) &disp->TexCoord2i;
862 snprintf(symboln, sizeof(symboln), "%sTexCoord2i", symbol_prefix);
863 *procp = dlsym(handle, symboln);
864 }
865
866
867 if(!disp->TexCoord2iv) {
868 void ** procp = (void **) &disp->TexCoord2iv;
869 snprintf(symboln, sizeof(symboln), "%sTexCoord2iv", symbol_prefix);
870 *procp = dlsym(handle, symboln);
871 }
872
873
874 if(!disp->TexCoord2s) {
875 void ** procp = (void **) &disp->TexCoord2s;
876 snprintf(symboln, sizeof(symboln), "%sTexCoord2s", symbol_prefix);
877 *procp = dlsym(handle, symboln);
878 }
879
880
881 if(!disp->TexCoord2sv) {
882 void ** procp = (void **) &disp->TexCoord2sv;
883 snprintf(symboln, sizeof(symboln), "%sTexCoord2sv", symbol_prefix);
884 *procp = dlsym(handle, symboln);
885 }
886
887
888 if(!disp->TexCoord3d) {
889 void ** procp = (void **) &disp->TexCoord3d;
890 snprintf(symboln, sizeof(symboln), "%sTexCoord3d", symbol_prefix);
891 *procp = dlsym(handle, symboln);
892 }
893
894
895 if(!disp->TexCoord3dv) {
896 void ** procp = (void **) &disp->TexCoord3dv;
897 snprintf(symboln, sizeof(symboln), "%sTexCoord3dv", symbol_prefix);
898 *procp = dlsym(handle, symboln);
899 }
900
901
902 if(!disp->TexCoord3f) {
903 void ** procp = (void **) &disp->TexCoord3f;
904 snprintf(symboln, sizeof(symboln), "%sTexCoord3f", symbol_prefix);
905 *procp = dlsym(handle, symboln);
906 }
907
908
909 if(!disp->TexCoord3fv) {
910 void ** procp = (void **) &disp->TexCoord3fv;
911 snprintf(symboln, sizeof(symboln), "%sTexCoord3fv", symbol_prefix);
912 *procp = dlsym(handle, symboln);
913 }
914
915
916 if(!disp->TexCoord3i) {
917 void ** procp = (void **) &disp->TexCoord3i;
918 snprintf(symboln, sizeof(symboln), "%sTexCoord3i", symbol_prefix);
919 *procp = dlsym(handle, symboln);
920 }
921
922
923 if(!disp->TexCoord3iv) {
924 void ** procp = (void **) &disp->TexCoord3iv;
925 snprintf(symboln, sizeof(symboln), "%sTexCoord3iv", symbol_prefix);
926 *procp = dlsym(handle, symboln);
927 }
928
929
930 if(!disp->TexCoord3s) {
931 void ** procp = (void **) &disp->TexCoord3s;
932 snprintf(symboln, sizeof(symboln), "%sTexCoord3s", symbol_prefix);
933 *procp = dlsym(handle, symboln);
934 }
935
936
937 if(!disp->TexCoord3sv) {
938 void ** procp = (void **) &disp->TexCoord3sv;
939 snprintf(symboln, sizeof(symboln), "%sTexCoord3sv", symbol_prefix);
940 *procp = dlsym(handle, symboln);
941 }
942
943
944 if(!disp->TexCoord4d) {
945 void ** procp = (void **) &disp->TexCoord4d;
946 snprintf(symboln, sizeof(symboln), "%sTexCoord4d", symbol_prefix);
947 *procp = dlsym(handle, symboln);
948 }
949
950
951 if(!disp->TexCoord4dv) {
952 void ** procp = (void **) &disp->TexCoord4dv;
953 snprintf(symboln, sizeof(symboln), "%sTexCoord4dv", symbol_prefix);
954 *procp = dlsym(handle, symboln);
955 }
956
957
958 if(!disp->TexCoord4f) {
959 void ** procp = (void **) &disp->TexCoord4f;
960 snprintf(symboln, sizeof(symboln), "%sTexCoord4f", symbol_prefix);
961 *procp = dlsym(handle, symboln);
962 }
963
964
965 if(!disp->TexCoord4fv) {
966 void ** procp = (void **) &disp->TexCoord4fv;
967 snprintf(symboln, sizeof(symboln), "%sTexCoord4fv", symbol_prefix);
968 *procp = dlsym(handle, symboln);
969 }
970
971
972 if(!disp->TexCoord4i) {
973 void ** procp = (void **) &disp->TexCoord4i;
974 snprintf(symboln, sizeof(symboln), "%sTexCoord4i", symbol_prefix);
975 *procp = dlsym(handle, symboln);
976 }
977
978
979 if(!disp->TexCoord4iv) {
980 void ** procp = (void **) &disp->TexCoord4iv;
981 snprintf(symboln, sizeof(symboln), "%sTexCoord4iv", symbol_prefix);
982 *procp = dlsym(handle, symboln);
983 }
984
985
986 if(!disp->TexCoord4s) {
987 void ** procp = (void **) &disp->TexCoord4s;
988 snprintf(symboln, sizeof(symboln), "%sTexCoord4s", symbol_prefix);
989 *procp = dlsym(handle, symboln);
990 }
991
992
993 if(!disp->TexCoord4sv) {
994 void ** procp = (void **) &disp->TexCoord4sv;
995 snprintf(symboln, sizeof(symboln), "%sTexCoord4sv", symbol_prefix);
996 *procp = dlsym(handle, symboln);
997 }
998
999
1000 if(!disp->Vertex2d) {
1001 void ** procp = (void **) &disp->Vertex2d;
1002 snprintf(symboln, sizeof(symboln), "%sVertex2d", symbol_prefix);
1003 *procp = dlsym(handle, symboln);
1004 }
1005
1006
1007 if(!disp->Vertex2dv) {
1008 void ** procp = (void **) &disp->Vertex2dv;
1009 snprintf(symboln, sizeof(symboln), "%sVertex2dv", symbol_prefix);
1010 *procp = dlsym(handle, symboln);
1011 }
1012
1013
1014 if(!disp->Vertex2f) {
1015 void ** procp = (void **) &disp->Vertex2f;
1016 snprintf(symboln, sizeof(symboln), "%sVertex2f", symbol_prefix);
1017 *procp = dlsym(handle, symboln);
1018 }
1019
1020
1021 if(!disp->Vertex2fv) {
1022 void ** procp = (void **) &disp->Vertex2fv;
1023 snprintf(symboln, sizeof(symboln), "%sVertex2fv", symbol_prefix);
1024 *procp = dlsym(handle, symboln);
1025 }
1026
1027
1028 if(!disp->Vertex2i) {
1029 void ** procp = (void **) &disp->Vertex2i;
1030 snprintf(symboln, sizeof(symboln), "%sVertex2i", symbol_prefix);
1031 *procp = dlsym(handle, symboln);
1032 }
1033
1034
1035 if(!disp->Vertex2iv) {
1036 void ** procp = (void **) &disp->Vertex2iv;
1037 snprintf(symboln, sizeof(symboln), "%sVertex2iv", symbol_prefix);
1038 *procp = dlsym(handle, symboln);
1039 }
1040
1041
1042 if(!disp->Vertex2s) {
1043 void ** procp = (void **) &disp->Vertex2s;
1044 snprintf(symboln, sizeof(symboln), "%sVertex2s", symbol_prefix);
1045 *procp = dlsym(handle, symboln);
1046 }
1047
1048
1049 if(!disp->Vertex2sv) {
1050 void ** procp = (void **) &disp->Vertex2sv;
1051 snprintf(symboln, sizeof(symboln), "%sVertex2sv", symbol_prefix);
1052 *procp = dlsym(handle, symboln);
1053 }
1054
1055
1056 if(!disp->Vertex3d) {
1057 void ** procp = (void **) &disp->Vertex3d;
1058 snprintf(symboln, sizeof(symboln), "%sVertex3d", symbol_prefix);
1059 *procp = dlsym(handle, symboln);
1060 }
1061
1062
1063 if(!disp->Vertex3dv) {
1064 void ** procp = (void **) &disp->Vertex3dv;
1065 snprintf(symboln, sizeof(symboln), "%sVertex3dv", symbol_prefix);
1066 *procp = dlsym(handle, symboln);
1067 }
1068
1069
1070 if(!disp->Vertex3f) {
1071 void ** procp = (void **) &disp->Vertex3f;
1072 snprintf(symboln, sizeof(symboln), "%sVertex3f", symbol_prefix);
1073 *procp = dlsym(handle, symboln);
1074 }
1075
1076
1077 if(!disp->Vertex3fv) {
1078 void ** procp = (void **) &disp->Vertex3fv;
1079 snprintf(symboln, sizeof(symboln), "%sVertex3fv", symbol_prefix);
1080 *procp = dlsym(handle, symboln);
1081 }
1082
1083
1084 if(!disp->Vertex3i) {
1085 void ** procp = (void **) &disp->Vertex3i;
1086 snprintf(symboln, sizeof(symboln), "%sVertex3i", symbol_prefix);
1087 *procp = dlsym(handle, symboln);
1088 }
1089
1090
1091 if(!disp->Vertex3iv) {
1092 void ** procp = (void **) &disp->Vertex3iv;
1093 snprintf(symboln, sizeof(symboln), "%sVertex3iv", symbol_prefix);
1094 *procp = dlsym(handle, symboln);
1095 }
1096
1097
1098 if(!disp->Vertex3s) {
1099 void ** procp = (void **) &disp->Vertex3s;
1100 snprintf(symboln, sizeof(symboln), "%sVertex3s", symbol_prefix);
1101 *procp = dlsym(handle, symboln);
1102 }
1103
1104
1105 if(!disp->Vertex3sv) {
1106 void ** procp = (void **) &disp->Vertex3sv;
1107 snprintf(symboln, sizeof(symboln), "%sVertex3sv", symbol_prefix);
1108 *procp = dlsym(handle, symboln);
1109 }
1110
1111
1112 if(!disp->Vertex4d) {
1113 void ** procp = (void **) &disp->Vertex4d;
1114 snprintf(symboln, sizeof(symboln), "%sVertex4d", symbol_prefix);
1115 *procp = dlsym(handle, symboln);
1116 }
1117
1118
1119 if(!disp->Vertex4dv) {
1120 void ** procp = (void **) &disp->Vertex4dv;
1121 snprintf(symboln, sizeof(symboln), "%sVertex4dv", symbol_prefix);
1122 *procp = dlsym(handle, symboln);
1123 }
1124
1125
1126 if(!disp->Vertex4f) {
1127 void ** procp = (void **) &disp->Vertex4f;
1128 snprintf(symboln, sizeof(symboln), "%sVertex4f", symbol_prefix);
1129 *procp = dlsym(handle, symboln);
1130 }
1131
1132
1133 if(!disp->Vertex4fv) {
1134 void ** procp = (void **) &disp->Vertex4fv;
1135 snprintf(symboln, sizeof(symboln), "%sVertex4fv", symbol_prefix);
1136 *procp = dlsym(handle, symboln);
1137 }
1138
1139
1140 if(!disp->Vertex4i) {
1141 void ** procp = (void **) &disp->Vertex4i;
1142 snprintf(symboln, sizeof(symboln), "%sVertex4i", symbol_prefix);
1143 *procp = dlsym(handle, symboln);
1144 }
1145
1146
1147 if(!disp->Vertex4iv) {
1148 void ** procp = (void **) &disp->Vertex4iv;
1149 snprintf(symboln, sizeof(symboln), "%sVertex4iv", symbol_prefix);
1150 *procp = dlsym(handle, symboln);
1151 }
1152
1153
1154 if(!disp->Vertex4s) {
1155 void ** procp = (void **) &disp->Vertex4s;
1156 snprintf(symboln, sizeof(symboln), "%sVertex4s", symbol_prefix);
1157 *procp = dlsym(handle, symboln);
1158 }
1159
1160
1161 if(!disp->Vertex4sv) {
1162 void ** procp = (void **) &disp->Vertex4sv;
1163 snprintf(symboln, sizeof(symboln), "%sVertex4sv", symbol_prefix);
1164 *procp = dlsym(handle, symboln);
1165 }
1166
1167
1168 if(!disp->ClipPlane) {
1169 void ** procp = (void **) &disp->ClipPlane;
1170 snprintf(symboln, sizeof(symboln), "%sClipPlane", symbol_prefix);
1171 *procp = dlsym(handle, symboln);
1172 }
1173
1174
1175 if(!disp->ColorMaterial) {
1176 void ** procp = (void **) &disp->ColorMaterial;
1177 snprintf(symboln, sizeof(symboln), "%sColorMaterial", symbol_prefix);
1178 *procp = dlsym(handle, symboln);
1179 }
1180
1181
1182 if(!disp->CullFace) {
1183 void ** procp = (void **) &disp->CullFace;
1184 snprintf(symboln, sizeof(symboln), "%sCullFace", symbol_prefix);
1185 *procp = dlsym(handle, symboln);
1186 }
1187
1188
1189 if(!disp->Fogf) {
1190 void ** procp = (void **) &disp->Fogf;
1191 snprintf(symboln, sizeof(symboln), "%sFogf", symbol_prefix);
1192 *procp = dlsym(handle, symboln);
1193 }
1194
1195
1196 if(!disp->Fogfv) {
1197 void ** procp = (void **) &disp->Fogfv;
1198 snprintf(symboln, sizeof(symboln), "%sFogfv", symbol_prefix);
1199 *procp = dlsym(handle, symboln);
1200 }
1201
1202
1203 if(!disp->Fogi) {
1204 void ** procp = (void **) &disp->Fogi;
1205 snprintf(symboln, sizeof(symboln), "%sFogi", symbol_prefix);
1206 *procp = dlsym(handle, symboln);
1207 }
1208
1209
1210 if(!disp->Fogiv) {
1211 void ** procp = (void **) &disp->Fogiv;
1212 snprintf(symboln, sizeof(symboln), "%sFogiv", symbol_prefix);
1213 *procp = dlsym(handle, symboln);
1214 }
1215
1216
1217 if(!disp->FrontFace) {
1218 void ** procp = (void **) &disp->FrontFace;
1219 snprintf(symboln, sizeof(symboln), "%sFrontFace", symbol_prefix);
1220 *procp = dlsym(handle, symboln);
1221 }
1222
1223
1224 if(!disp->Hint) {
1225 void ** procp = (void **) &disp->Hint;
1226 snprintf(symboln, sizeof(symboln), "%sHint", symbol_prefix);
1227 *procp = dlsym(handle, symboln);
1228 }
1229
1230
1231 if(!disp->Lightf) {
1232 void ** procp = (void **) &disp->Lightf;
1233 snprintf(symboln, sizeof(symboln), "%sLightf", symbol_prefix);
1234 *procp = dlsym(handle, symboln);
1235 }
1236
1237
1238 if(!disp->Lightfv) {
1239 void ** procp = (void **) &disp->Lightfv;
1240 snprintf(symboln, sizeof(symboln), "%sLightfv", symbol_prefix);
1241 *procp = dlsym(handle, symboln);
1242 }
1243
1244
1245 if(!disp->Lighti) {
1246 void ** procp = (void **) &disp->Lighti;
1247 snprintf(symboln, sizeof(symboln), "%sLighti", symbol_prefix);
1248 *procp = dlsym(handle, symboln);
1249 }
1250
1251
1252 if(!disp->Lightiv) {
1253 void ** procp = (void **) &disp->Lightiv;
1254 snprintf(symboln, sizeof(symboln), "%sLightiv", symbol_prefix);
1255 *procp = dlsym(handle, symboln);
1256 }
1257
1258
1259 if(!disp->LightModelf) {
1260 void ** procp = (void **) &disp->LightModelf;
1261 snprintf(symboln, sizeof(symboln), "%sLightModelf", symbol_prefix);
1262 *procp = dlsym(handle, symboln);
1263 }
1264
1265
1266 if(!disp->LightModelfv) {
1267 void ** procp = (void **) &disp->LightModelfv;
1268 snprintf(symboln, sizeof(symboln), "%sLightModelfv", symbol_prefix);
1269 *procp = dlsym(handle, symboln);
1270 }
1271
1272
1273 if(!disp->LightModeli) {
1274 void ** procp = (void **) &disp->LightModeli;
1275 snprintf(symboln, sizeof(symboln), "%sLightModeli", symbol_prefix);
1276 *procp = dlsym(handle, symboln);
1277 }
1278
1279
1280 if(!disp->LightModeliv) {
1281 void ** procp = (void **) &disp->LightModeliv;
1282 snprintf(symboln, sizeof(symboln), "%sLightModeliv", symbol_prefix);
1283 *procp = dlsym(handle, symboln);
1284 }
1285
1286
1287 if(!disp->LineStipple) {
1288 void ** procp = (void **) &disp->LineStipple;
1289 snprintf(symboln, sizeof(symboln), "%sLineStipple", symbol_prefix);
1290 *procp = dlsym(handle, symboln);
1291 }
1292
1293
1294 if(!disp->LineWidth) {
1295 void ** procp = (void **) &disp->LineWidth;
1296 snprintf(symboln, sizeof(symboln), "%sLineWidth", symbol_prefix);
1297 *procp = dlsym(handle, symboln);
1298 }
1299
1300
1301 if(!disp->Materialf) {
1302 void ** procp = (void **) &disp->Materialf;
1303 snprintf(symboln, sizeof(symboln), "%sMaterialf", symbol_prefix);
1304 *procp = dlsym(handle, symboln);
1305 }
1306
1307
1308 if(!disp->Materialfv) {
1309 void ** procp = (void **) &disp->Materialfv;
1310 snprintf(symboln, sizeof(symboln), "%sMaterialfv", symbol_prefix);
1311 *procp = dlsym(handle, symboln);
1312 }
1313
1314
1315 if(!disp->Materiali) {
1316 void ** procp = (void **) &disp->Materiali;
1317 snprintf(symboln, sizeof(symboln), "%sMateriali", symbol_prefix);
1318 *procp = dlsym(handle, symboln);
1319 }
1320
1321
1322 if(!disp->Materialiv) {
1323 void ** procp = (void **) &disp->Materialiv;
1324 snprintf(symboln, sizeof(symboln), "%sMaterialiv", symbol_prefix);
1325 *procp = dlsym(handle, symboln);
1326 }
1327
1328
1329 if(!disp->PointSize) {
1330 void ** procp = (void **) &disp->PointSize;
1331 snprintf(symboln, sizeof(symboln), "%sPointSize", symbol_prefix);
1332 *procp = dlsym(handle, symboln);
1333 }
1334
1335
1336 if(!disp->PolygonMode) {
1337 void ** procp = (void **) &disp->PolygonMode;
1338 snprintf(symboln, sizeof(symboln), "%sPolygonMode", symbol_prefix);
1339 *procp = dlsym(handle, symboln);
1340 }
1341
1342
1343 if(!disp->PolygonStipple) {
1344 void ** procp = (void **) &disp->PolygonStipple;
1345 snprintf(symboln, sizeof(symboln), "%sPolygonStipple", symbol_prefix);
1346 *procp = dlsym(handle, symboln);
1347 }
1348
1349
1350 if(!disp->Scissor) {
1351 void ** procp = (void **) &disp->Scissor;
1352 snprintf(symboln, sizeof(symboln), "%sScissor", symbol_prefix);
1353 *procp = dlsym(handle, symboln);
1354 }
1355
1356
1357 if(!disp->ShadeModel) {
1358 void ** procp = (void **) &disp->ShadeModel;
1359 snprintf(symboln, sizeof(symboln), "%sShadeModel", symbol_prefix);
1360 *procp = dlsym(handle, symboln);
1361 }
1362
1363
1364 if(!disp->TexParameterf) {
1365 void ** procp = (void **) &disp->TexParameterf;
1366 snprintf(symboln, sizeof(symboln), "%sTexParameterf", symbol_prefix);
1367 *procp = dlsym(handle, symboln);
1368 }
1369
1370
1371 if(!disp->TexParameterfv) {
1372 void ** procp = (void **) &disp->TexParameterfv;
1373 snprintf(symboln, sizeof(symboln), "%sTexParameterfv", symbol_prefix);
1374 *procp = dlsym(handle, symboln);
1375 }
1376
1377
1378 if(!disp->TexParameteri) {
1379 void ** procp = (void **) &disp->TexParameteri;
1380 snprintf(symboln, sizeof(symboln), "%sTexParameteri", symbol_prefix);
1381 *procp = dlsym(handle, symboln);
1382 }
1383
1384
1385 if(!disp->TexParameteriv) {
1386 void ** procp = (void **) &disp->TexParameteriv;
1387 snprintf(symboln, sizeof(symboln), "%sTexParameteriv", symbol_prefix);
1388 *procp = dlsym(handle, symboln);
1389 }
1390
1391
1392 if(!disp->TexImage1D) {
1393 void ** procp = (void **) &disp->TexImage1D;
1394 snprintf(symboln, sizeof(symboln), "%sTexImage1D", symbol_prefix);
1395 *procp = dlsym(handle, symboln);
1396 }
1397
1398
1399 if(!disp->TexImage2D) {
1400 void ** procp = (void **) &disp->TexImage2D;
1401 snprintf(symboln, sizeof(symboln), "%sTexImage2D", symbol_prefix);
1402 *procp = dlsym(handle, symboln);
1403 }
1404
1405
1406 if(!disp->TexEnvf) {
1407 void ** procp = (void **) &disp->TexEnvf;
1408 snprintf(symboln, sizeof(symboln), "%sTexEnvf", symbol_prefix);
1409 *procp = dlsym(handle, symboln);
1410 }
1411
1412
1413 if(!disp->TexEnvfv) {
1414 void ** procp = (void **) &disp->TexEnvfv;
1415 snprintf(symboln, sizeof(symboln), "%sTexEnvfv", symbol_prefix);
1416 *procp = dlsym(handle, symboln);
1417 }
1418
1419
1420 if(!disp->TexEnvi) {
1421 void ** procp = (void **) &disp->TexEnvi;
1422 snprintf(symboln, sizeof(symboln), "%sTexEnvi", symbol_prefix);
1423 *procp = dlsym(handle, symboln);
1424 }
1425
1426
1427 if(!disp->TexEnviv) {
1428 void ** procp = (void **) &disp->TexEnviv;
1429 snprintf(symboln, sizeof(symboln), "%sTexEnviv", symbol_prefix);
1430 *procp = dlsym(handle, symboln);
1431 }
1432
1433
1434 if(!disp->TexGend) {
1435 void ** procp = (void **) &disp->TexGend;
1436 snprintf(symboln, sizeof(symboln), "%sTexGend", symbol_prefix);
1437 *procp = dlsym(handle, symboln);
1438 }
1439
1440
1441 if(!disp->TexGendv) {
1442 void ** procp = (void **) &disp->TexGendv;
1443 snprintf(symboln, sizeof(symboln), "%sTexGendv", symbol_prefix);
1444 *procp = dlsym(handle, symboln);
1445 }
1446
1447
1448 if(!disp->TexGenf) {
1449 void ** procp = (void **) &disp->TexGenf;
1450 snprintf(symboln, sizeof(symboln), "%sTexGenf", symbol_prefix);
1451 *procp = dlsym(handle, symboln);
1452 }
1453
1454
1455 if(!disp->TexGenfv) {
1456 void ** procp = (void **) &disp->TexGenfv;
1457 snprintf(symboln, sizeof(symboln), "%sTexGenfv", symbol_prefix);
1458 *procp = dlsym(handle, symboln);
1459 }
1460
1461
1462 if(!disp->TexGeni) {
1463 void ** procp = (void **) &disp->TexGeni;
1464 snprintf(symboln, sizeof(symboln), "%sTexGeni", symbol_prefix);
1465 *procp = dlsym(handle, symboln);
1466 }
1467
1468
1469 if(!disp->TexGeniv) {
1470 void ** procp = (void **) &disp->TexGeniv;
1471 snprintf(symboln, sizeof(symboln), "%sTexGeniv", symbol_prefix);
1472 *procp = dlsym(handle, symboln);
1473 }
1474
1475
1476 if(!disp->FeedbackBuffer) {
1477 void ** procp = (void **) &disp->FeedbackBuffer;
1478 snprintf(symboln, sizeof(symboln), "%sFeedbackBuffer", symbol_prefix);
1479 *procp = dlsym(handle, symboln);
1480 }
1481
1482
1483 if(!disp->SelectBuffer) {
1484 void ** procp = (void **) &disp->SelectBuffer;
1485 snprintf(symboln, sizeof(symboln), "%sSelectBuffer", symbol_prefix);
1486 *procp = dlsym(handle, symboln);
1487 }
1488
1489
1490 if(!disp->RenderMode) {
1491 void ** procp = (void **) &disp->RenderMode;
1492 snprintf(symboln, sizeof(symboln), "%sRenderMode", symbol_prefix);
1493 *procp = dlsym(handle, symboln);
1494 }
1495
1496
1497 if(!disp->InitNames) {
1498 void ** procp = (void **) &disp->InitNames;
1499 snprintf(symboln, sizeof(symboln), "%sInitNames", symbol_prefix);
1500 *procp = dlsym(handle, symboln);
1501 }
1502
1503
1504 if(!disp->LoadName) {
1505 void ** procp = (void **) &disp->LoadName;
1506 snprintf(symboln, sizeof(symboln), "%sLoadName", symbol_prefix);
1507 *procp = dlsym(handle, symboln);
1508 }
1509
1510
1511 if(!disp->PassThrough) {
1512 void ** procp = (void **) &disp->PassThrough;
1513 snprintf(symboln, sizeof(symboln), "%sPassThrough", symbol_prefix);
1514 *procp = dlsym(handle, symboln);
1515 }
1516
1517
1518 if(!disp->PopName) {
1519 void ** procp = (void **) &disp->PopName;
1520 snprintf(symboln, sizeof(symboln), "%sPopName", symbol_prefix);
1521 *procp = dlsym(handle, symboln);
1522 }
1523
1524
1525 if(!disp->PushName) {
1526 void ** procp = (void **) &disp->PushName;
1527 snprintf(symboln, sizeof(symboln), "%sPushName", symbol_prefix);
1528 *procp = dlsym(handle, symboln);
1529 }
1530
1531
1532 if(!disp->DrawBuffer) {
1533 void ** procp = (void **) &disp->DrawBuffer;
1534 snprintf(symboln, sizeof(symboln), "%sDrawBuffer", symbol_prefix);
1535 *procp = dlsym(handle, symboln);
1536 }
1537
1538
1539 if(!disp->Clear) {
1540 void ** procp = (void **) &disp->Clear;
1541 snprintf(symboln, sizeof(symboln), "%sClear", symbol_prefix);
1542 *procp = dlsym(handle, symboln);
1543 }
1544
1545
1546 if(!disp->ClearAccum) {
1547 void ** procp = (void **) &disp->ClearAccum;
1548 snprintf(symboln, sizeof(symboln), "%sClearAccum", symbol_prefix);
1549 *procp = dlsym(handle, symboln);
1550 }
1551
1552
1553 if(!disp->ClearIndex) {
1554 void ** procp = (void **) &disp->ClearIndex;
1555 snprintf(symboln, sizeof(symboln), "%sClearIndex", symbol_prefix);
1556 *procp = dlsym(handle, symboln);
1557 }
1558
1559
1560 if(!disp->ClearColor) {
1561 void ** procp = (void **) &disp->ClearColor;
1562 snprintf(symboln, sizeof(symboln), "%sClearColor", symbol_prefix);
1563 *procp = dlsym(handle, symboln);
1564 }
1565
1566
1567 if(!disp->ClearStencil) {
1568 void ** procp = (void **) &disp->ClearStencil;
1569 snprintf(symboln, sizeof(symboln), "%sClearStencil", symbol_prefix);
1570 *procp = dlsym(handle, symboln);
1571 }
1572
1573
1574 if(!disp->ClearDepth) {
1575 void ** procp = (void **) &disp->ClearDepth;
1576 snprintf(symboln, sizeof(symboln), "%sClearDepth", symbol_prefix);
1577 *procp = dlsym(handle, symboln);
1578 }
1579
1580
1581 if(!disp->StencilMask) {
1582 void ** procp = (void **) &disp->StencilMask;
1583 snprintf(symboln, sizeof(symboln), "%sStencilMask", symbol_prefix);
1584 *procp = dlsym(handle, symboln);
1585 }
1586
1587
1588 if(!disp->ColorMask) {
1589 void ** procp = (void **) &disp->ColorMask;
1590 snprintf(symboln, sizeof(symboln), "%sColorMask", symbol_prefix);
1591 *procp = dlsym(handle, symboln);
1592 }
1593
1594
1595 if(!disp->DepthMask) {
1596 void ** procp = (void **) &disp->DepthMask;
1597 snprintf(symboln, sizeof(symboln), "%sDepthMask", symbol_prefix);
1598 *procp = dlsym(handle, symboln);
1599 }
1600
1601
1602 if(!disp->IndexMask) {
1603 void ** procp = (void **) &disp->IndexMask;
1604 snprintf(symboln, sizeof(symboln), "%sIndexMask", symbol_prefix);
1605 *procp = dlsym(handle, symboln);
1606 }
1607
1608
1609 if(!disp->Accum) {
1610 void ** procp = (void **) &disp->Accum;
1611 snprintf(symboln, sizeof(symboln), "%sAccum", symbol_prefix);
1612 *procp = dlsym(handle, symboln);
1613 }
1614
1615
1616 if(!disp->Disable) {
1617 void ** procp = (void **) &disp->Disable;
1618 snprintf(symboln, sizeof(symboln), "%sDisable", symbol_prefix);
1619 *procp = dlsym(handle, symboln);
1620 }
1621
1622
1623 if(!disp->Enable) {
1624 void ** procp = (void **) &disp->Enable;
1625 snprintf(symboln, sizeof(symboln), "%sEnable", symbol_prefix);
1626 *procp = dlsym(handle, symboln);
1627 }
1628
1629
1630 if(!disp->Finish) {
1631 void ** procp = (void **) &disp->Finish;
1632 snprintf(symboln, sizeof(symboln), "%sFinish", symbol_prefix);
1633 *procp = dlsym(handle, symboln);
1634 }
1635
1636
1637 if(!disp->Flush) {
1638 void ** procp = (void **) &disp->Flush;
1639 snprintf(symboln, sizeof(symboln), "%sFlush", symbol_prefix);
1640 *procp = dlsym(handle, symboln);
1641 }
1642
1643
1644 if(!disp->PopAttrib) {
1645 void ** procp = (void **) &disp->PopAttrib;
1646 snprintf(symboln, sizeof(symboln), "%sPopAttrib", symbol_prefix);
1647 *procp = dlsym(handle, symboln);
1648 }
1649
1650
1651 if(!disp->PushAttrib) {
1652 void ** procp = (void **) &disp->PushAttrib;
1653 snprintf(symboln, sizeof(symboln), "%sPushAttrib", symbol_prefix);
1654 *procp = dlsym(handle, symboln);
1655 }
1656
1657
1658 if(!disp->Map1d) {
1659 void ** procp = (void **) &disp->Map1d;
1660 snprintf(symboln, sizeof(symboln), "%sMap1d", symbol_prefix);
1661 *procp = dlsym(handle, symboln);
1662 }
1663
1664
1665 if(!disp->Map1f) {
1666 void ** procp = (void **) &disp->Map1f;
1667 snprintf(symboln, sizeof(symboln), "%sMap1f", symbol_prefix);
1668 *procp = dlsym(handle, symboln);
1669 }
1670
1671
1672 if(!disp->Map2d) {
1673 void ** procp = (void **) &disp->Map2d;
1674 snprintf(symboln, sizeof(symboln), "%sMap2d", symbol_prefix);
1675 *procp = dlsym(handle, symboln);
1676 }
1677
1678
1679 if(!disp->Map2f) {
1680 void ** procp = (void **) &disp->Map2f;
1681 snprintf(symboln, sizeof(symboln), "%sMap2f", symbol_prefix);
1682 *procp = dlsym(handle, symboln);
1683 }
1684
1685
1686 if(!disp->MapGrid1d) {
1687 void ** procp = (void **) &disp->MapGrid1d;
1688 snprintf(symboln, sizeof(symboln), "%sMapGrid1d", symbol_prefix);
1689 *procp = dlsym(handle, symboln);
1690 }
1691
1692
1693 if(!disp->MapGrid1f) {
1694 void ** procp = (void **) &disp->MapGrid1f;
1695 snprintf(symboln, sizeof(symboln), "%sMapGrid1f", symbol_prefix);
1696 *procp = dlsym(handle, symboln);
1697 }
1698
1699
1700 if(!disp->MapGrid2d) {
1701 void ** procp = (void **) &disp->MapGrid2d;
1702 snprintf(symboln, sizeof(symboln), "%sMapGrid2d", symbol_prefix);
1703 *procp = dlsym(handle, symboln);
1704 }
1705
1706
1707 if(!disp->MapGrid2f) {
1708 void ** procp = (void **) &disp->MapGrid2f;
1709 snprintf(symboln, sizeof(symboln), "%sMapGrid2f", symbol_prefix);
1710 *procp = dlsym(handle, symboln);
1711 }
1712
1713
1714 if(!disp->EvalCoord1d) {
1715 void ** procp = (void **) &disp->EvalCoord1d;
1716 snprintf(symboln, sizeof(symboln), "%sEvalCoord1d", symbol_prefix);
1717 *procp = dlsym(handle, symboln);
1718 }
1719
1720
1721 if(!disp->EvalCoord1dv) {
1722 void ** procp = (void **) &disp->EvalCoord1dv;
1723 snprintf(symboln, sizeof(symboln), "%sEvalCoord1dv", symbol_prefix);
1724 *procp = dlsym(handle, symboln);
1725 }
1726
1727
1728 if(!disp->EvalCoord1f) {
1729 void ** procp = (void **) &disp->EvalCoord1f;
1730 snprintf(symboln, sizeof(symboln), "%sEvalCoord1f", symbol_prefix);
1731 *procp = dlsym(handle, symboln);
1732 }
1733
1734
1735 if(!disp->EvalCoord1fv) {
1736 void ** procp = (void **) &disp->EvalCoord1fv;
1737 snprintf(symboln, sizeof(symboln), "%sEvalCoord1fv", symbol_prefix);
1738 *procp = dlsym(handle, symboln);
1739 }
1740
1741
1742 if(!disp->EvalCoord2d) {
1743 void ** procp = (void **) &disp->EvalCoord2d;
1744 snprintf(symboln, sizeof(symboln), "%sEvalCoord2d", symbol_prefix);
1745 *procp = dlsym(handle, symboln);
1746 }
1747
1748
1749 if(!disp->EvalCoord2dv) {
1750 void ** procp = (void **) &disp->EvalCoord2dv;
1751 snprintf(symboln, sizeof(symboln), "%sEvalCoord2dv", symbol_prefix);
1752 *procp = dlsym(handle, symboln);
1753 }
1754
1755
1756 if(!disp->EvalCoord2f) {
1757 void ** procp = (void **) &disp->EvalCoord2f;
1758 snprintf(symboln, sizeof(symboln), "%sEvalCoord2f", symbol_prefix);
1759 *procp = dlsym(handle, symboln);
1760 }
1761
1762
1763 if(!disp->EvalCoord2fv) {
1764 void ** procp = (void **) &disp->EvalCoord2fv;
1765 snprintf(symboln, sizeof(symboln), "%sEvalCoord2fv", symbol_prefix);
1766 *procp = dlsym(handle, symboln);
1767 }
1768
1769
1770 if(!disp->EvalMesh1) {
1771 void ** procp = (void **) &disp->EvalMesh1;
1772 snprintf(symboln, sizeof(symboln), "%sEvalMesh1", symbol_prefix);
1773 *procp = dlsym(handle, symboln);
1774 }
1775
1776
1777 if(!disp->EvalPoint1) {
1778 void ** procp = (void **) &disp->EvalPoint1;
1779 snprintf(symboln, sizeof(symboln), "%sEvalPoint1", symbol_prefix);
1780 *procp = dlsym(handle, symboln);
1781 }
1782
1783
1784 if(!disp->EvalMesh2) {
1785 void ** procp = (void **) &disp->EvalMesh2;
1786 snprintf(symboln, sizeof(symboln), "%sEvalMesh2", symbol_prefix);
1787 *procp = dlsym(handle, symboln);
1788 }
1789
1790
1791 if(!disp->EvalPoint2) {
1792 void ** procp = (void **) &disp->EvalPoint2;
1793 snprintf(symboln, sizeof(symboln), "%sEvalPoint2", symbol_prefix);
1794 *procp = dlsym(handle, symboln);
1795 }
1796
1797
1798 if(!disp->AlphaFunc) {
1799 void ** procp = (void **) &disp->AlphaFunc;
1800 snprintf(symboln, sizeof(symboln), "%sAlphaFunc", symbol_prefix);
1801 *procp = dlsym(handle, symboln);
1802 }
1803
1804
1805 if(!disp->BlendFunc) {
1806 void ** procp = (void **) &disp->BlendFunc;
1807 snprintf(symboln, sizeof(symboln), "%sBlendFunc", symbol_prefix);
1808 *procp = dlsym(handle, symboln);
1809 }
1810
1811
1812 if(!disp->LogicOp) {
1813 void ** procp = (void **) &disp->LogicOp;
1814 snprintf(symboln, sizeof(symboln), "%sLogicOp", symbol_prefix);
1815 *procp = dlsym(handle, symboln);
1816 }
1817
1818
1819 if(!disp->StencilFunc) {
1820 void ** procp = (void **) &disp->StencilFunc;
1821 snprintf(symboln, sizeof(symboln), "%sStencilFunc", symbol_prefix);
1822 *procp = dlsym(handle, symboln);
1823 }
1824
1825
1826 if(!disp->StencilOp) {
1827 void ** procp = (void **) &disp->StencilOp;
1828 snprintf(symboln, sizeof(symboln), "%sStencilOp", symbol_prefix);
1829 *procp = dlsym(handle, symboln);
1830 }
1831
1832
1833 if(!disp->DepthFunc) {
1834 void ** procp = (void **) &disp->DepthFunc;
1835 snprintf(symboln, sizeof(symboln), "%sDepthFunc", symbol_prefix);
1836 *procp = dlsym(handle, symboln);
1837 }
1838
1839
1840 if(!disp->PixelZoom) {
1841 void ** procp = (void **) &disp->PixelZoom;
1842 snprintf(symboln, sizeof(symboln), "%sPixelZoom", symbol_prefix);
1843 *procp = dlsym(handle, symboln);
1844 }
1845
1846
1847 if(!disp->PixelTransferf) {
1848 void ** procp = (void **) &disp->PixelTransferf;
1849 snprintf(symboln, sizeof(symboln), "%sPixelTransferf", symbol_prefix);
1850 *procp = dlsym(handle, symboln);
1851 }
1852
1853
1854 if(!disp->PixelTransferi) {
1855 void ** procp = (void **) &disp->PixelTransferi;
1856 snprintf(symboln, sizeof(symboln), "%sPixelTransferi", symbol_prefix);
1857 *procp = dlsym(handle, symboln);
1858 }
1859
1860
1861 if(!disp->PixelStoref) {
1862 void ** procp = (void **) &disp->PixelStoref;
1863 snprintf(symboln, sizeof(symboln), "%sPixelStoref", symbol_prefix);
1864 *procp = dlsym(handle, symboln);
1865 }
1866
1867
1868 if(!disp->PixelStorei) {
1869 void ** procp = (void **) &disp->PixelStorei;
1870 snprintf(symboln, sizeof(symboln), "%sPixelStorei", symbol_prefix);
1871 *procp = dlsym(handle, symboln);
1872 }
1873
1874
1875 if(!disp->PixelMapfv) {
1876 void ** procp = (void **) &disp->PixelMapfv;
1877 snprintf(symboln, sizeof(symboln), "%sPixelMapfv", symbol_prefix);
1878 *procp = dlsym(handle, symboln);
1879 }
1880
1881
1882 if(!disp->PixelMapuiv) {
1883 void ** procp = (void **) &disp->PixelMapuiv;
1884 snprintf(symboln, sizeof(symboln), "%sPixelMapuiv", symbol_prefix);
1885 *procp = dlsym(handle, symboln);
1886 }
1887
1888
1889 if(!disp->PixelMapusv) {
1890 void ** procp = (void **) &disp->PixelMapusv;
1891 snprintf(symboln, sizeof(symboln), "%sPixelMapusv", symbol_prefix);
1892 *procp = dlsym(handle, symboln);
1893 }
1894
1895
1896 if(!disp->ReadBuffer) {
1897 void ** procp = (void **) &disp->ReadBuffer;
1898 snprintf(symboln, sizeof(symboln), "%sReadBuffer", symbol_prefix);
1899 *procp = dlsym(handle, symboln);
1900 }
1901
1902
1903 if(!disp->CopyPixels) {
1904 void ** procp = (void **) &disp->CopyPixels;
1905 snprintf(symboln, sizeof(symboln), "%sCopyPixels", symbol_prefix);
1906 *procp = dlsym(handle, symboln);
1907 }
1908
1909
1910 if(!disp->ReadPixels) {
1911 void ** procp = (void **) &disp->ReadPixels;
1912 snprintf(symboln, sizeof(symboln), "%sReadPixels", symbol_prefix);
1913 *procp = dlsym(handle, symboln);
1914 }
1915
1916
1917 if(!disp->DrawPixels) {
1918 void ** procp = (void **) &disp->DrawPixels;
1919 snprintf(symboln, sizeof(symboln), "%sDrawPixels", symbol_prefix);
1920 *procp = dlsym(handle, symboln);
1921 }
1922
1923
1924 if(!disp->GetBooleanv) {
1925 void ** procp = (void **) &disp->GetBooleanv;
1926 snprintf(symboln, sizeof(symboln), "%sGetBooleanv", symbol_prefix);
1927 *procp = dlsym(handle, symboln);
1928 }
1929
1930
1931 if(!disp->GetClipPlane) {
1932 void ** procp = (void **) &disp->GetClipPlane;
1933 snprintf(symboln, sizeof(symboln), "%sGetClipPlane", symbol_prefix);
1934 *procp = dlsym(handle, symboln);
1935 }
1936
1937
1938 if(!disp->GetDoublev) {
1939 void ** procp = (void **) &disp->GetDoublev;
1940 snprintf(symboln, sizeof(symboln), "%sGetDoublev", symbol_prefix);
1941 *procp = dlsym(handle, symboln);
1942 }
1943
1944
1945 if(!disp->GetError) {
1946 void ** procp = (void **) &disp->GetError;
1947 snprintf(symboln, sizeof(symboln), "%sGetError", symbol_prefix);
1948 *procp = dlsym(handle, symboln);
1949 }
1950
1951
1952 if(!disp->GetFloatv) {
1953 void ** procp = (void **) &disp->GetFloatv;
1954 snprintf(symboln, sizeof(symboln), "%sGetFloatv", symbol_prefix);
1955 *procp = dlsym(handle, symboln);
1956 }
1957
1958
1959 if(!disp->GetIntegerv) {
1960 void ** procp = (void **) &disp->GetIntegerv;
1961 snprintf(symboln, sizeof(symboln), "%sGetIntegerv", symbol_prefix);
1962 *procp = dlsym(handle, symboln);
1963 }
1964
1965
1966 if(!disp->GetLightfv) {
1967 void ** procp = (void **) &disp->GetLightfv;
1968 snprintf(symboln, sizeof(symboln), "%sGetLightfv", symbol_prefix);
1969 *procp = dlsym(handle, symboln);
1970 }
1971
1972
1973 if(!disp->GetLightiv) {
1974 void ** procp = (void **) &disp->GetLightiv;
1975 snprintf(symboln, sizeof(symboln), "%sGetLightiv", symbol_prefix);
1976 *procp = dlsym(handle, symboln);
1977 }
1978
1979
1980 if(!disp->GetMapdv) {
1981 void ** procp = (void **) &disp->GetMapdv;
1982 snprintf(symboln, sizeof(symboln), "%sGetMapdv", symbol_prefix);
1983 *procp = dlsym(handle, symboln);
1984 }
1985
1986
1987 if(!disp->GetMapfv) {
1988 void ** procp = (void **) &disp->GetMapfv;
1989 snprintf(symboln, sizeof(symboln), "%sGetMapfv", symbol_prefix);
1990 *procp = dlsym(handle, symboln);
1991 }
1992
1993
1994 if(!disp->GetMapiv) {
1995 void ** procp = (void **) &disp->GetMapiv;
1996 snprintf(symboln, sizeof(symboln), "%sGetMapiv", symbol_prefix);
1997 *procp = dlsym(handle, symboln);
1998 }
1999
2000
2001 if(!disp->GetMaterialfv) {
2002 void ** procp = (void **) &disp->GetMaterialfv;
2003 snprintf(symboln, sizeof(symboln), "%sGetMaterialfv", symbol_prefix);
2004 *procp = dlsym(handle, symboln);
2005 }
2006
2007
2008 if(!disp->GetMaterialiv) {
2009 void ** procp = (void **) &disp->GetMaterialiv;
2010 snprintf(symboln, sizeof(symboln), "%sGetMaterialiv", symbol_prefix);
2011 *procp = dlsym(handle, symboln);
2012 }
2013
2014
2015 if(!disp->GetPixelMapfv) {
2016 void ** procp = (void **) &disp->GetPixelMapfv;
2017 snprintf(symboln, sizeof(symboln), "%sGetPixelMapfv", symbol_prefix);
2018 *procp = dlsym(handle, symboln);
2019 }
2020
2021
2022 if(!disp->GetPixelMapuiv) {
2023 void ** procp = (void **) &disp->GetPixelMapuiv;
2024 snprintf(symboln, sizeof(symboln), "%sGetPixelMapuiv", symbol_prefix);
2025 *procp = dlsym(handle, symboln);
2026 }
2027
2028
2029 if(!disp->GetPixelMapusv) {
2030 void ** procp = (void **) &disp->GetPixelMapusv;
2031 snprintf(symboln, sizeof(symboln), "%sGetPixelMapusv", symbol_prefix);
2032 *procp = dlsym(handle, symboln);
2033 }
2034
2035
2036 if(!disp->GetPolygonStipple) {
2037 void ** procp = (void **) &disp->GetPolygonStipple;
2038 snprintf(symboln, sizeof(symboln), "%sGetPolygonStipple", symbol_prefix);
2039 *procp = dlsym(handle, symboln);
2040 }
2041
2042
2043 if(!disp->GetString) {
2044 void ** procp = (void **) &disp->GetString;
2045 snprintf(symboln, sizeof(symboln), "%sGetString", symbol_prefix);
2046 *procp = dlsym(handle, symboln);
2047 }
2048
2049
2050 if(!disp->GetTexEnvfv) {
2051 void ** procp = (void **) &disp->GetTexEnvfv;
2052 snprintf(symboln, sizeof(symboln), "%sGetTexEnvfv", symbol_prefix);
2053 *procp = dlsym(handle, symboln);
2054 }
2055
2056
2057 if(!disp->GetTexEnviv) {
2058 void ** procp = (void **) &disp->GetTexEnviv;
2059 snprintf(symboln, sizeof(symboln), "%sGetTexEnviv", symbol_prefix);
2060 *procp = dlsym(handle, symboln);
2061 }
2062
2063
2064 if(!disp->GetTexGendv) {
2065 void ** procp = (void **) &disp->GetTexGendv;
2066 snprintf(symboln, sizeof(symboln), "%sGetTexGendv", symbol_prefix);
2067 *procp = dlsym(handle, symboln);
2068 }
2069
2070
2071 if(!disp->GetTexGenfv) {
2072 void ** procp = (void **) &disp->GetTexGenfv;
2073 snprintf(symboln, sizeof(symboln), "%sGetTexGenfv", symbol_prefix);
2074 *procp = dlsym(handle, symboln);
2075 }
2076
2077
2078 if(!disp->GetTexGeniv) {
2079 void ** procp = (void **) &disp->GetTexGeniv;
2080 snprintf(symboln, sizeof(symboln), "%sGetTexGeniv", symbol_prefix);
2081 *procp = dlsym(handle, symboln);
2082 }
2083
2084
2085 if(!disp->GetTexImage) {
2086 void ** procp = (void **) &disp->GetTexImage;
2087 snprintf(symboln, sizeof(symboln), "%sGetTexImage", symbol_prefix);
2088 *procp = dlsym(handle, symboln);
2089 }
2090
2091
2092 if(!disp->GetTexParameterfv) {
2093 void ** procp = (void **) &disp->GetTexParameterfv;
2094 snprintf(symboln, sizeof(symboln), "%sGetTexParameterfv", symbol_prefix);
2095 *procp = dlsym(handle, symboln);
2096 }
2097
2098
2099 if(!disp->GetTexParameteriv) {
2100 void ** procp = (void **) &disp->GetTexParameteriv;
2101 snprintf(symboln, sizeof(symboln), "%sGetTexParameteriv", symbol_prefix);
2102 *procp = dlsym(handle, symboln);
2103 }
2104
2105
2106 if(!disp->GetTexLevelParameterfv) {
2107 void ** procp = (void **) &disp->GetTexLevelParameterfv;
2108 snprintf(symboln, sizeof(symboln), "%sGetTexLevelParameterfv", symbol_prefix);
2109 *procp = dlsym(handle, symboln);
2110 }
2111
2112
2113 if(!disp->GetTexLevelParameteriv) {
2114 void ** procp = (void **) &disp->GetTexLevelParameteriv;
2115 snprintf(symboln, sizeof(symboln), "%sGetTexLevelParameteriv", symbol_prefix);
2116 *procp = dlsym(handle, symboln);
2117 }
2118
2119
2120 if(!disp->IsEnabled) {
2121 void ** procp = (void **) &disp->IsEnabled;
2122 snprintf(symboln, sizeof(symboln), "%sIsEnabled", symbol_prefix);
2123 *procp = dlsym(handle, symboln);
2124 }
2125
2126
2127 if(!disp->IsList) {
2128 void ** procp = (void **) &disp->IsList;
2129 snprintf(symboln, sizeof(symboln), "%sIsList", symbol_prefix);
2130 *procp = dlsym(handle, symboln);
2131 }
2132
2133
2134 if(!disp->DepthRange) {
2135 void ** procp = (void **) &disp->DepthRange;
2136 snprintf(symboln, sizeof(symboln), "%sDepthRange", symbol_prefix);
2137 *procp = dlsym(handle, symboln);
2138 }
2139
2140
2141 if(!disp->Frustum) {
2142 void ** procp = (void **) &disp->Frustum;
2143 snprintf(symboln, sizeof(symboln), "%sFrustum", symbol_prefix);
2144 *procp = dlsym(handle, symboln);
2145 }
2146
2147
2148 if(!disp->LoadIdentity) {
2149 void ** procp = (void **) &disp->LoadIdentity;
2150 snprintf(symboln, sizeof(symboln), "%sLoadIdentity", symbol_prefix);
2151 *procp = dlsym(handle, symboln);
2152 }
2153
2154
2155 if(!disp->LoadMatrixf) {
2156 void ** procp = (void **) &disp->LoadMatrixf;
2157 snprintf(symboln, sizeof(symboln), "%sLoadMatrixf", symbol_prefix);
2158 *procp = dlsym(handle, symboln);
2159 }
2160
2161
2162 if(!disp->LoadMatrixd) {
2163 void ** procp = (void **) &disp->LoadMatrixd;
2164 snprintf(symboln, sizeof(symboln), "%sLoadMatrixd", symbol_prefix);
2165 *procp = dlsym(handle, symboln);
2166 }
2167
2168
2169 if(!disp->MatrixMode) {
2170 void ** procp = (void **) &disp->MatrixMode;
2171 snprintf(symboln, sizeof(symboln), "%sMatrixMode", symbol_prefix);
2172 *procp = dlsym(handle, symboln);
2173 }
2174
2175
2176 if(!disp->MultMatrixf) {
2177 void ** procp = (void **) &disp->MultMatrixf;
2178 snprintf(symboln, sizeof(symboln), "%sMultMatrixf", symbol_prefix);
2179 *procp = dlsym(handle, symboln);
2180 }
2181
2182
2183 if(!disp->MultMatrixd) {
2184 void ** procp = (void **) &disp->MultMatrixd;
2185 snprintf(symboln, sizeof(symboln), "%sMultMatrixd", symbol_prefix);
2186 *procp = dlsym(handle, symboln);
2187 }
2188
2189
2190 if(!disp->Ortho) {
2191 void ** procp = (void **) &disp->Ortho;
2192 snprintf(symboln, sizeof(symboln), "%sOrtho", symbol_prefix);
2193 *procp = dlsym(handle, symboln);
2194 }
2195
2196
2197 if(!disp->PopMatrix) {
2198 void ** procp = (void **) &disp->PopMatrix;
2199 snprintf(symboln, sizeof(symboln), "%sPopMatrix", symbol_prefix);
2200 *procp = dlsym(handle, symboln);
2201 }
2202
2203
2204 if(!disp->PushMatrix) {
2205 void ** procp = (void **) &disp->PushMatrix;
2206 snprintf(symboln, sizeof(symboln), "%sPushMatrix", symbol_prefix);
2207 *procp = dlsym(handle, symboln);
2208 }
2209
2210
2211 if(!disp->Rotated) {
2212 void ** procp = (void **) &disp->Rotated;
2213 snprintf(symboln, sizeof(symboln), "%sRotated", symbol_prefix);
2214 *procp = dlsym(handle, symboln);
2215 }
2216
2217
2218 if(!disp->Rotatef) {
2219 void ** procp = (void **) &disp->Rotatef;
2220 snprintf(symboln, sizeof(symboln), "%sRotatef", symbol_prefix);
2221 *procp = dlsym(handle, symboln);
2222 }
2223
2224
2225 if(!disp->Scaled) {
2226 void ** procp = (void **) &disp->Scaled;
2227 snprintf(symboln, sizeof(symboln), "%sScaled", symbol_prefix);
2228 *procp = dlsym(handle, symboln);
2229 }
2230
2231
2232 if(!disp->Scalef) {
2233 void ** procp = (void **) &disp->Scalef;
2234 snprintf(symboln, sizeof(symboln), "%sScalef", symbol_prefix);
2235 *procp = dlsym(handle, symboln);
2236 }
2237
2238
2239 if(!disp->Translated) {
2240 void ** procp = (void **) &disp->Translated;
2241 snprintf(symboln, sizeof(symboln), "%sTranslated", symbol_prefix);
2242 *procp = dlsym(handle, symboln);
2243 }
2244
2245
2246 if(!disp->Translatef) {
2247 void ** procp = (void **) &disp->Translatef;
2248 snprintf(symboln, sizeof(symboln), "%sTranslatef", symbol_prefix);
2249 *procp = dlsym(handle, symboln);
2250 }
2251
2252
2253 if(!disp->Viewport) {
2254 void ** procp = (void **) &disp->Viewport;
2255 snprintf(symboln, sizeof(symboln), "%sViewport", symbol_prefix);
2256 *procp = dlsym(handle, symboln);
2257 }
2258
2259
2260 if(!disp->ArrayElement) {
2261 void ** procp = (void **) &disp->ArrayElement;
2262 snprintf(symboln, sizeof(symboln), "%sArrayElement", symbol_prefix);
2263 *procp = dlsym(handle, symboln);
2264 }
2265
2266
2267 if(!disp->ArrayElement) {
2268 void ** procp = (void **) &disp->ArrayElement;
2269 snprintf(symboln, sizeof(symboln), "%sArrayElementEXT", symbol_prefix);
2270 *procp = dlsym(handle, symboln);
2271 }
2272
2273
2274 if(!disp->BindTexture) {
2275 void ** procp = (void **) &disp->BindTexture;
2276 snprintf(symboln, sizeof(symboln), "%sBindTexture", symbol_prefix);
2277 *procp = dlsym(handle, symboln);
2278 }
2279
2280
2281 if(!disp->BindTexture) {
2282 void ** procp = (void **) &disp->BindTexture;
2283 snprintf(symboln, sizeof(symboln), "%sBindTextureEXT", symbol_prefix);
2284 *procp = dlsym(handle, symboln);
2285 }
2286
2287
2288 if(!disp->ColorPointer) {
2289 void ** procp = (void **) &disp->ColorPointer;
2290 snprintf(symboln, sizeof(symboln), "%sColorPointer", symbol_prefix);
2291 *procp = dlsym(handle, symboln);
2292 }
2293
2294
2295 if(!disp->DisableClientState) {
2296 void ** procp = (void **) &disp->DisableClientState;
2297 snprintf(symboln, sizeof(symboln), "%sDisableClientState", symbol_prefix);
2298 *procp = dlsym(handle, symboln);
2299 }
2300
2301
2302 if(!disp->DrawArrays) {
2303 void ** procp = (void **) &disp->DrawArrays;
2304 snprintf(symboln, sizeof(symboln), "%sDrawArrays", symbol_prefix);
2305 *procp = dlsym(handle, symboln);
2306 }
2307
2308
2309 if(!disp->DrawArrays) {
2310 void ** procp = (void **) &disp->DrawArrays;
2311 snprintf(symboln, sizeof(symboln), "%sDrawArraysEXT", symbol_prefix);
2312 *procp = dlsym(handle, symboln);
2313 }
2314
2315
2316 if(!disp->DrawElements) {
2317 void ** procp = (void **) &disp->DrawElements;
2318 snprintf(symboln, sizeof(symboln), "%sDrawElements", symbol_prefix);
2319 *procp = dlsym(handle, symboln);
2320 }
2321
2322
2323 if(!disp->EdgeFlagPointer) {
2324 void ** procp = (void **) &disp->EdgeFlagPointer;
2325 snprintf(symboln, sizeof(symboln), "%sEdgeFlagPointer", symbol_prefix);
2326 *procp = dlsym(handle, symboln);
2327 }
2328
2329
2330 if(!disp->EnableClientState) {
2331 void ** procp = (void **) &disp->EnableClientState;
2332 snprintf(symboln, sizeof(symboln), "%sEnableClientState", symbol_prefix);
2333 *procp = dlsym(handle, symboln);
2334 }
2335
2336
2337 if(!disp->IndexPointer) {
2338 void ** procp = (void **) &disp->IndexPointer;
2339 snprintf(symboln, sizeof(symboln), "%sIndexPointer", symbol_prefix);
2340 *procp = dlsym(handle, symboln);
2341 }
2342
2343
2344 if(!disp->Indexub) {
2345 void ** procp = (void **) &disp->Indexub;
2346 snprintf(symboln, sizeof(symboln), "%sIndexub", symbol_prefix);
2347 *procp = dlsym(handle, symboln);
2348 }
2349
2350
2351 if(!disp->Indexubv) {
2352 void ** procp = (void **) &disp->Indexubv;
2353 snprintf(symboln, sizeof(symboln), "%sIndexubv", symbol_prefix);
2354 *procp = dlsym(handle, symboln);
2355 }
2356
2357
2358 if(!disp->InterleavedArrays) {
2359 void ** procp = (void **) &disp->InterleavedArrays;
2360 snprintf(symboln, sizeof(symboln), "%sInterleavedArrays", symbol_prefix);
2361 *procp = dlsym(handle, symboln);
2362 }
2363
2364
2365 if(!disp->NormalPointer) {
2366 void ** procp = (void **) &disp->NormalPointer;
2367 snprintf(symboln, sizeof(symboln), "%sNormalPointer", symbol_prefix);
2368 *procp = dlsym(handle, symboln);
2369 }
2370
2371
2372 if(!disp->PolygonOffset) {
2373 void ** procp = (void **) &disp->PolygonOffset;
2374 snprintf(symboln, sizeof(symboln), "%sPolygonOffset", symbol_prefix);
2375 *procp = dlsym(handle, symboln);
2376 }
2377
2378
2379 if(!disp->TexCoordPointer) {
2380 void ** procp = (void **) &disp->TexCoordPointer;
2381 snprintf(symboln, sizeof(symboln), "%sTexCoordPointer", symbol_prefix);
2382 *procp = dlsym(handle, symboln);
2383 }
2384
2385
2386 if(!disp->VertexPointer) {
2387 void ** procp = (void **) &disp->VertexPointer;
2388 snprintf(symboln, sizeof(symboln), "%sVertexPointer", symbol_prefix);
2389 *procp = dlsym(handle, symboln);
2390 }
2391
2392
2393 if(!disp->AreTexturesResident) {
2394 void ** procp = (void **) &disp->AreTexturesResident;
2395 snprintf(symboln, sizeof(symboln), "%sAreTexturesResident", symbol_prefix);
2396 *procp = dlsym(handle, symboln);
2397 }
2398
2399
2400 if(!disp->AreTexturesResident) {
2401 void ** procp = (void **) &disp->AreTexturesResident;
2402 snprintf(symboln, sizeof(symboln), "%sAreTexturesResidentEXT", symbol_prefix);
2403 *procp = dlsym(handle, symboln);
2404 }
2405
2406
2407 if(!disp->CopyTexImage1D) {
2408 void ** procp = (void **) &disp->CopyTexImage1D;
2409 snprintf(symboln, sizeof(symboln), "%sCopyTexImage1D", symbol_prefix);
2410 *procp = dlsym(handle, symboln);
2411 }
2412
2413
2414 if(!disp->CopyTexImage1D) {
2415 void ** procp = (void **) &disp->CopyTexImage1D;
2416 snprintf(symboln, sizeof(symboln), "%sCopyTexImage1DEXT", symbol_prefix);
2417 *procp = dlsym(handle, symboln);
2418 }
2419
2420
2421 if(!disp->CopyTexImage2D) {
2422 void ** procp = (void **) &disp->CopyTexImage2D;
2423 snprintf(symboln, sizeof(symboln), "%sCopyTexImage2D", symbol_prefix);
2424 *procp = dlsym(handle, symboln);
2425 }
2426
2427
2428 if(!disp->CopyTexImage2D) {
2429 void ** procp = (void **) &disp->CopyTexImage2D;
2430 snprintf(symboln, sizeof(symboln), "%sCopyTexImage2DEXT", symbol_prefix);
2431 *procp = dlsym(handle, symboln);
2432 }
2433
2434
2435 if(!disp->CopyTexSubImage1D) {
2436 void ** procp = (void **) &disp->CopyTexSubImage1D;
2437 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage1D", symbol_prefix);
2438 *procp = dlsym(handle, symboln);
2439 }
2440
2441
2442 if(!disp->CopyTexSubImage1D) {
2443 void ** procp = (void **) &disp->CopyTexSubImage1D;
2444 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage1DEXT", symbol_prefix);
2445 *procp = dlsym(handle, symboln);
2446 }
2447
2448
2449 if(!disp->CopyTexSubImage2D) {
2450 void ** procp = (void **) &disp->CopyTexSubImage2D;
2451 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage2D", symbol_prefix);
2452 *procp = dlsym(handle, symboln);
2453 }
2454
2455
2456 if(!disp->CopyTexSubImage2D) {
2457 void ** procp = (void **) &disp->CopyTexSubImage2D;
2458 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage2DEXT", symbol_prefix);
2459 *procp = dlsym(handle, symboln);
2460 }
2461
2462
2463 if(!disp->DeleteTextures) {
2464 void ** procp = (void **) &disp->DeleteTextures;
2465 snprintf(symboln, sizeof(symboln), "%sDeleteTextures", symbol_prefix);
2466 *procp = dlsym(handle, symboln);
2467 }
2468
2469
2470 if(!disp->DeleteTextures) {
2471 void ** procp = (void **) &disp->DeleteTextures;
2472 snprintf(symboln, sizeof(symboln), "%sDeleteTexturesEXT", symbol_prefix);
2473 *procp = dlsym(handle, symboln);
2474 }
2475
2476
2477 if(!disp->GenTextures) {
2478 void ** procp = (void **) &disp->GenTextures;
2479 snprintf(symboln, sizeof(symboln), "%sGenTextures", symbol_prefix);
2480 *procp = dlsym(handle, symboln);
2481 }
2482
2483
2484 if(!disp->GenTextures) {
2485 void ** procp = (void **) &disp->GenTextures;
2486 snprintf(symboln, sizeof(symboln), "%sGenTexturesEXT", symbol_prefix);
2487 *procp = dlsym(handle, symboln);
2488 }
2489
2490
2491 if(!disp->GetPointerv) {
2492 void ** procp = (void **) &disp->GetPointerv;
2493 snprintf(symboln, sizeof(symboln), "%sGetPointerv", symbol_prefix);
2494 *procp = dlsym(handle, symboln);
2495 }
2496
2497
2498 if(!disp->GetPointerv) {
2499 void ** procp = (void **) &disp->GetPointerv;
2500 snprintf(symboln, sizeof(symboln), "%sGetPointervEXT", symbol_prefix);
2501 *procp = dlsym(handle, symboln);
2502 }
2503
2504
2505 if(!disp->IsTexture) {
2506 void ** procp = (void **) &disp->IsTexture;
2507 snprintf(symboln, sizeof(symboln), "%sIsTexture", symbol_prefix);
2508 *procp = dlsym(handle, symboln);
2509 }
2510
2511
2512 if(!disp->IsTexture) {
2513 void ** procp = (void **) &disp->IsTexture;
2514 snprintf(symboln, sizeof(symboln), "%sIsTextureEXT", symbol_prefix);
2515 *procp = dlsym(handle, symboln);
2516 }
2517
2518
2519 if(!disp->PrioritizeTextures) {
2520 void ** procp = (void **) &disp->PrioritizeTextures;
2521 snprintf(symboln, sizeof(symboln), "%sPrioritizeTextures", symbol_prefix);
2522 *procp = dlsym(handle, symboln);
2523 }
2524
2525
2526 if(!disp->PrioritizeTextures) {
2527 void ** procp = (void **) &disp->PrioritizeTextures;
2528 snprintf(symboln, sizeof(symboln), "%sPrioritizeTexturesEXT", symbol_prefix);
2529 *procp = dlsym(handle, symboln);
2530 }
2531
2532
2533 if(!disp->TexSubImage1D) {
2534 void ** procp = (void **) &disp->TexSubImage1D;
2535 snprintf(symboln, sizeof(symboln), "%sTexSubImage1D", symbol_prefix);
2536 *procp = dlsym(handle, symboln);
2537 }
2538
2539
2540 if(!disp->TexSubImage1D) {
2541 void ** procp = (void **) &disp->TexSubImage1D;
2542 snprintf(symboln, sizeof(symboln), "%sTexSubImage1DEXT", symbol_prefix);
2543 *procp = dlsym(handle, symboln);
2544 }
2545
2546
2547 if(!disp->TexSubImage2D) {
2548 void ** procp = (void **) &disp->TexSubImage2D;
2549 snprintf(symboln, sizeof(symboln), "%sTexSubImage2D", symbol_prefix);
2550 *procp = dlsym(handle, symboln);
2551 }
2552
2553
2554 if(!disp->TexSubImage2D) {
2555 void ** procp = (void **) &disp->TexSubImage2D;
2556 snprintf(symboln, sizeof(symboln), "%sTexSubImage2DEXT", symbol_prefix);
2557 *procp = dlsym(handle, symboln);
2558 }
2559
2560
2561 if(!disp->PopClientAttrib) {
2562 void ** procp = (void **) &disp->PopClientAttrib;
2563 snprintf(symboln, sizeof(symboln), "%sPopClientAttrib", symbol_prefix);
2564 *procp = dlsym(handle, symboln);
2565 }
2566
2567
2568 if(!disp->PushClientAttrib) {
2569 void ** procp = (void **) &disp->PushClientAttrib;
2570 snprintf(symboln, sizeof(symboln), "%sPushClientAttrib", symbol_prefix);
2571 *procp = dlsym(handle, symboln);
2572 }
2573
2574
2575 if(!disp->BlendColor) {
2576 void ** procp = (void **) &disp->BlendColor;
2577 snprintf(symboln, sizeof(symboln), "%sBlendColor", symbol_prefix);
2578 *procp = dlsym(handle, symboln);
2579 }
2580
2581
2582 if(!disp->BlendColor) {
2583 void ** procp = (void **) &disp->BlendColor;
2584 snprintf(symboln, sizeof(symboln), "%sBlendColorEXT", symbol_prefix);
2585 *procp = dlsym(handle, symboln);
2586 }
2587
2588
2589 if(!disp->BlendEquation) {
2590 void ** procp = (void **) &disp->BlendEquation;
2591 snprintf(symboln, sizeof(symboln), "%sBlendEquation", symbol_prefix);
2592 *procp = dlsym(handle, symboln);
2593 }
2594
2595
2596 if(!disp->BlendEquation) {
2597 void ** procp = (void **) &disp->BlendEquation;
2598 snprintf(symboln, sizeof(symboln), "%sBlendEquationEXT", symbol_prefix);
2599 *procp = dlsym(handle, symboln);
2600 }
2601
2602
2603 if(!disp->DrawRangeElements) {
2604 void ** procp = (void **) &disp->DrawRangeElements;
2605 snprintf(symboln, sizeof(symboln), "%sDrawRangeElements", symbol_prefix);
2606 *procp = dlsym(handle, symboln);
2607 }
2608
2609
2610 if(!disp->DrawRangeElements) {
2611 void ** procp = (void **) &disp->DrawRangeElements;
2612 snprintf(symboln, sizeof(symboln), "%sDrawRangeElementsEXT", symbol_prefix);
2613 *procp = dlsym(handle, symboln);
2614 }
2615
2616
2617 if(!disp->ColorTable) {
2618 void ** procp = (void **) &disp->ColorTable;
2619 snprintf(symboln, sizeof(symboln), "%sColorTable", symbol_prefix);
2620 *procp = dlsym(handle, symboln);
2621 }
2622
2623
2624 if(!disp->ColorTable) {
2625 void ** procp = (void **) &disp->ColorTable;
2626 snprintf(symboln, sizeof(symboln), "%sColorTableSGI", symbol_prefix);
2627 *procp = dlsym(handle, symboln);
2628 }
2629
2630
2631 if(!disp->ColorTable) {
2632 void ** procp = (void **) &disp->ColorTable;
2633 snprintf(symboln, sizeof(symboln), "%sColorTableEXT", symbol_prefix);
2634 *procp = dlsym(handle, symboln);
2635 }
2636
2637
2638 if(!disp->ColorTableParameterfv) {
2639 void ** procp = (void **) &disp->ColorTableParameterfv;
2640 snprintf(symboln, sizeof(symboln), "%sColorTableParameterfv", symbol_prefix);
2641 *procp = dlsym(handle, symboln);
2642 }
2643
2644
2645 if(!disp->ColorTableParameterfv) {
2646 void ** procp = (void **) &disp->ColorTableParameterfv;
2647 snprintf(symboln, sizeof(symboln), "%sColorTableParameterfvSGI", symbol_prefix);
2648 *procp = dlsym(handle, symboln);
2649 }
2650
2651
2652 if(!disp->ColorTableParameteriv) {
2653 void ** procp = (void **) &disp->ColorTableParameteriv;
2654 snprintf(symboln, sizeof(symboln), "%sColorTableParameteriv", symbol_prefix);
2655 *procp = dlsym(handle, symboln);
2656 }
2657
2658
2659 if(!disp->ColorTableParameteriv) {
2660 void ** procp = (void **) &disp->ColorTableParameteriv;
2661 snprintf(symboln, sizeof(symboln), "%sColorTableParameterivSGI", symbol_prefix);
2662 *procp = dlsym(handle, symboln);
2663 }
2664
2665
2666 if(!disp->CopyColorTable) {
2667 void ** procp = (void **) &disp->CopyColorTable;
2668 snprintf(symboln, sizeof(symboln), "%sCopyColorTable", symbol_prefix);
2669 *procp = dlsym(handle, symboln);
2670 }
2671
2672
2673 if(!disp->CopyColorTable) {
2674 void ** procp = (void **) &disp->CopyColorTable;
2675 snprintf(symboln, sizeof(symboln), "%sCopyColorTableSGI", symbol_prefix);
2676 *procp = dlsym(handle, symboln);
2677 }
2678
2679
2680 if(!disp->GetColorTable) {
2681 void ** procp = (void **) &disp->GetColorTable;
2682 snprintf(symboln, sizeof(symboln), "%sGetColorTable", symbol_prefix);
2683 *procp = dlsym(handle, symboln);
2684 }
2685
2686
2687 if(!disp->GetColorTable) {
2688 void ** procp = (void **) &disp->GetColorTable;
2689 snprintf(symboln, sizeof(symboln), "%sGetColorTableSGI", symbol_prefix);
2690 *procp = dlsym(handle, symboln);
2691 }
2692
2693
2694 if(!disp->GetColorTable) {
2695 void ** procp = (void **) &disp->GetColorTable;
2696 snprintf(symboln, sizeof(symboln), "%sGetColorTableEXT", symbol_prefix);
2697 *procp = dlsym(handle, symboln);
2698 }
2699
2700
2701 if(!disp->GetColorTableParameterfv) {
2702 void ** procp = (void **) &disp->GetColorTableParameterfv;
2703 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfv", symbol_prefix);
2704 *procp = dlsym(handle, symboln);
2705 }
2706
2707
2708 if(!disp->GetColorTableParameterfv) {
2709 void ** procp = (void **) &disp->GetColorTableParameterfv;
2710 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfvSGI", symbol_prefix);
2711 *procp = dlsym(handle, symboln);
2712 }
2713
2714
2715 if(!disp->GetColorTableParameterfv) {
2716 void ** procp = (void **) &disp->GetColorTableParameterfv;
2717 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterfvEXT", symbol_prefix);
2718 *procp = dlsym(handle, symboln);
2719 }
2720
2721
2722 if(!disp->GetColorTableParameteriv) {
2723 void ** procp = (void **) &disp->GetColorTableParameteriv;
2724 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameteriv", symbol_prefix);
2725 *procp = dlsym(handle, symboln);
2726 }
2727
2728
2729 if(!disp->GetColorTableParameteriv) {
2730 void ** procp = (void **) &disp->GetColorTableParameteriv;
2731 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterivSGI", symbol_prefix);
2732 *procp = dlsym(handle, symboln);
2733 }
2734
2735
2736 if(!disp->GetColorTableParameteriv) {
2737 void ** procp = (void **) &disp->GetColorTableParameteriv;
2738 snprintf(symboln, sizeof(symboln), "%sGetColorTableParameterivEXT", symbol_prefix);
2739 *procp = dlsym(handle, symboln);
2740 }
2741
2742
2743 if(!disp->ColorSubTable) {
2744 void ** procp = (void **) &disp->ColorSubTable;
2745 snprintf(symboln, sizeof(symboln), "%sColorSubTable", symbol_prefix);
2746 *procp = dlsym(handle, symboln);
2747 }
2748
2749
2750 if(!disp->ColorSubTable) {
2751 void ** procp = (void **) &disp->ColorSubTable;
2752 snprintf(symboln, sizeof(symboln), "%sColorSubTableEXT", symbol_prefix);
2753 *procp = dlsym(handle, symboln);
2754 }
2755
2756
2757 if(!disp->CopyColorSubTable) {
2758 void ** procp = (void **) &disp->CopyColorSubTable;
2759 snprintf(symboln, sizeof(symboln), "%sCopyColorSubTable", symbol_prefix);
2760 *procp = dlsym(handle, symboln);
2761 }
2762
2763
2764 if(!disp->CopyColorSubTable) {
2765 void ** procp = (void **) &disp->CopyColorSubTable;
2766 snprintf(symboln, sizeof(symboln), "%sCopyColorSubTableEXT", symbol_prefix);
2767 *procp = dlsym(handle, symboln);
2768 }
2769
2770
2771 if(!disp->ConvolutionFilter1D) {
2772 void ** procp = (void **) &disp->ConvolutionFilter1D;
2773 snprintf(symboln, sizeof(symboln), "%sConvolutionFilter1D", symbol_prefix);
2774 *procp = dlsym(handle, symboln);
2775 }
2776
2777
2778 if(!disp->ConvolutionFilter1D) {
2779 void ** procp = (void **) &disp->ConvolutionFilter1D;
2780 snprintf(symboln, sizeof(symboln), "%sConvolutionFilter1DEXT", symbol_prefix);
2781 *procp = dlsym(handle, symboln);
2782 }
2783
2784
2785 if(!disp->ConvolutionFilter2D) {
2786 void ** procp = (void **) &disp->ConvolutionFilter2D;
2787 snprintf(symboln, sizeof(symboln), "%sConvolutionFilter2D", symbol_prefix);
2788 *procp = dlsym(handle, symboln);
2789 }
2790
2791
2792 if(!disp->ConvolutionFilter2D) {
2793 void ** procp = (void **) &disp->ConvolutionFilter2D;
2794 snprintf(symboln, sizeof(symboln), "%sConvolutionFilter2DEXT", symbol_prefix);
2795 *procp = dlsym(handle, symboln);
2796 }
2797
2798
2799 if(!disp->ConvolutionParameterf) {
2800 void ** procp = (void **) &disp->ConvolutionParameterf;
2801 snprintf(symboln, sizeof(symboln), "%sConvolutionParameterf", symbol_prefix);
2802 *procp = dlsym(handle, symboln);
2803 }
2804
2805
2806 if(!disp->ConvolutionParameterf) {
2807 void ** procp = (void **) &disp->ConvolutionParameterf;
2808 snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfEXT", symbol_prefix);
2809 *procp = dlsym(handle, symboln);
2810 }
2811
2812
2813 if(!disp->ConvolutionParameterfv) {
2814 void ** procp = (void **) &disp->ConvolutionParameterfv;
2815 snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfv", symbol_prefix);
2816 *procp = dlsym(handle, symboln);
2817 }
2818
2819
2820 if(!disp->ConvolutionParameterfv) {
2821 void ** procp = (void **) &disp->ConvolutionParameterfv;
2822 snprintf(symboln, sizeof(symboln), "%sConvolutionParameterfvEXT", symbol_prefix);
2823 *procp = dlsym(handle, symboln);
2824 }
2825
2826
2827 if(!disp->ConvolutionParameteri) {
2828 void ** procp = (void **) &disp->ConvolutionParameteri;
2829 snprintf(symboln, sizeof(symboln), "%sConvolutionParameteri", symbol_prefix);
2830 *procp = dlsym(handle, symboln);
2831 }
2832
2833
2834 if(!disp->ConvolutionParameteri) {
2835 void ** procp = (void **) &disp->ConvolutionParameteri;
2836 snprintf(symboln, sizeof(symboln), "%sConvolutionParameteriEXT", symbol_prefix);
2837 *procp = dlsym(handle, symboln);
2838 }
2839
2840
2841 if(!disp->ConvolutionParameteriv) {
2842 void ** procp = (void **) &disp->ConvolutionParameteriv;
2843 snprintf(symboln, sizeof(symboln), "%sConvolutionParameteriv", symbol_prefix);
2844 *procp = dlsym(handle, symboln);
2845 }
2846
2847
2848 if(!disp->ConvolutionParameteriv) {
2849 void ** procp = (void **) &disp->ConvolutionParameteriv;
2850 snprintf(symboln, sizeof(symboln), "%sConvolutionParameterivEXT", symbol_prefix);
2851 *procp = dlsym(handle, symboln);
2852 }
2853
2854
2855 if(!disp->CopyConvolutionFilter1D) {
2856 void ** procp = (void **) &disp->CopyConvolutionFilter1D;
2857 snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter1D", symbol_prefix);
2858 *procp = dlsym(handle, symboln);
2859 }
2860
2861
2862 if(!disp->CopyConvolutionFilter1D) {
2863 void ** procp = (void **) &disp->CopyConvolutionFilter1D;
2864 snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter1DEXT", symbol_prefix);
2865 *procp = dlsym(handle, symboln);
2866 }
2867
2868
2869 if(!disp->CopyConvolutionFilter2D) {
2870 void ** procp = (void **) &disp->CopyConvolutionFilter2D;
2871 snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter2D", symbol_prefix);
2872 *procp = dlsym(handle, symboln);
2873 }
2874
2875
2876 if(!disp->CopyConvolutionFilter2D) {
2877 void ** procp = (void **) &disp->CopyConvolutionFilter2D;
2878 snprintf(symboln, sizeof(symboln), "%sCopyConvolutionFilter2DEXT", symbol_prefix);
2879 *procp = dlsym(handle, symboln);
2880 }
2881
2882
2883 if(!disp->GetConvolutionFilter) {
2884 void ** procp = (void **) &disp->GetConvolutionFilter;
2885 snprintf(symboln, sizeof(symboln), "%sGetConvolutionFilter", symbol_prefix);
2886 *procp = dlsym(handle, symboln);
2887 }
2888
2889
2890 if(!disp->GetConvolutionFilter) {
2891 void ** procp = (void **) &disp->GetConvolutionFilter;
2892 snprintf(symboln, sizeof(symboln), "%sGetConvolutionFilterEXT", symbol_prefix);
2893 *procp = dlsym(handle, symboln);
2894 }
2895
2896
2897 if(!disp->GetConvolutionParameterfv) {
2898 void ** procp = (void **) &disp->GetConvolutionParameterfv;
2899 snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterfv", symbol_prefix);
2900 *procp = dlsym(handle, symboln);
2901 }
2902
2903
2904 if(!disp->GetConvolutionParameterfv) {
2905 void ** procp = (void **) &disp->GetConvolutionParameterfv;
2906 snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterfvEXT", symbol_prefix);
2907 *procp = dlsym(handle, symboln);
2908 }
2909
2910
2911 if(!disp->GetConvolutionParameteriv) {
2912 void ** procp = (void **) &disp->GetConvolutionParameteriv;
2913 snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameteriv", symbol_prefix);
2914 *procp = dlsym(handle, symboln);
2915 }
2916
2917
2918 if(!disp->GetConvolutionParameteriv) {
2919 void ** procp = (void **) &disp->GetConvolutionParameteriv;
2920 snprintf(symboln, sizeof(symboln), "%sGetConvolutionParameterivEXT", symbol_prefix);
2921 *procp = dlsym(handle, symboln);
2922 }
2923
2924
2925 if(!disp->GetSeparableFilter) {
2926 void ** procp = (void **) &disp->GetSeparableFilter;
2927 snprintf(symboln, sizeof(symboln), "%sGetSeparableFilter", symbol_prefix);
2928 *procp = dlsym(handle, symboln);
2929 }
2930
2931
2932 if(!disp->GetSeparableFilter) {
2933 void ** procp = (void **) &disp->GetSeparableFilter;
2934 snprintf(symboln, sizeof(symboln), "%sGetSeparableFilterEXT", symbol_prefix);
2935 *procp = dlsym(handle, symboln);
2936 }
2937
2938
2939 if(!disp->SeparableFilter2D) {
2940 void ** procp = (void **) &disp->SeparableFilter2D;
2941 snprintf(symboln, sizeof(symboln), "%sSeparableFilter2D", symbol_prefix);
2942 *procp = dlsym(handle, symboln);
2943 }
2944
2945
2946 if(!disp->SeparableFilter2D) {
2947 void ** procp = (void **) &disp->SeparableFilter2D;
2948 snprintf(symboln, sizeof(symboln), "%sSeparableFilter2DEXT", symbol_prefix);
2949 *procp = dlsym(handle, symboln);
2950 }
2951
2952
2953 if(!disp->GetHistogram) {
2954 void ** procp = (void **) &disp->GetHistogram;
2955 snprintf(symboln, sizeof(symboln), "%sGetHistogram", symbol_prefix);
2956 *procp = dlsym(handle, symboln);
2957 }
2958
2959
2960 if(!disp->GetHistogram) {
2961 void ** procp = (void **) &disp->GetHistogram;
2962 snprintf(symboln, sizeof(symboln), "%sGetHistogramEXT", symbol_prefix);
2963 *procp = dlsym(handle, symboln);
2964 }
2965
2966
2967 if(!disp->GetHistogramParameterfv) {
2968 void ** procp = (void **) &disp->GetHistogramParameterfv;
2969 snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterfv", symbol_prefix);
2970 *procp = dlsym(handle, symboln);
2971 }
2972
2973
2974 if(!disp->GetHistogramParameterfv) {
2975 void ** procp = (void **) &disp->GetHistogramParameterfv;
2976 snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterfvEXT", symbol_prefix);
2977 *procp = dlsym(handle, symboln);
2978 }
2979
2980
2981 if(!disp->GetHistogramParameteriv) {
2982 void ** procp = (void **) &disp->GetHistogramParameteriv;
2983 snprintf(symboln, sizeof(symboln), "%sGetHistogramParameteriv", symbol_prefix);
2984 *procp = dlsym(handle, symboln);
2985 }
2986
2987
2988 if(!disp->GetHistogramParameteriv) {
2989 void ** procp = (void **) &disp->GetHistogramParameteriv;
2990 snprintf(symboln, sizeof(symboln), "%sGetHistogramParameterivEXT", symbol_prefix);
2991 *procp = dlsym(handle, symboln);
2992 }
2993
2994
2995 if(!disp->GetMinmax) {
2996 void ** procp = (void **) &disp->GetMinmax;
2997 snprintf(symboln, sizeof(symboln), "%sGetMinmax", symbol_prefix);
2998 *procp = dlsym(handle, symboln);
2999 }
3000
3001
3002 if(!disp->GetMinmax) {
3003 void ** procp = (void **) &disp->GetMinmax;
3004 snprintf(symboln, sizeof(symboln), "%sGetMinmaxEXT", symbol_prefix);
3005 *procp = dlsym(handle, symboln);
3006 }
3007
3008
3009 if(!disp->GetMinmaxParameterfv) {
3010 void ** procp = (void **) &disp->GetMinmaxParameterfv;
3011 snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterfv", symbol_prefix);
3012 *procp = dlsym(handle, symboln);
3013 }
3014
3015
3016 if(!disp->GetMinmaxParameterfv) {
3017 void ** procp = (void **) &disp->GetMinmaxParameterfv;
3018 snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterfvEXT", symbol_prefix);
3019 *procp = dlsym(handle, symboln);
3020 }
3021
3022
3023 if(!disp->GetMinmaxParameteriv) {
3024 void ** procp = (void **) &disp->GetMinmaxParameteriv;
3025 snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameteriv", symbol_prefix);
3026 *procp = dlsym(handle, symboln);
3027 }
3028
3029
3030 if(!disp->GetMinmaxParameteriv) {
3031 void ** procp = (void **) &disp->GetMinmaxParameteriv;
3032 snprintf(symboln, sizeof(symboln), "%sGetMinmaxParameterivEXT", symbol_prefix);
3033 *procp = dlsym(handle, symboln);
3034 }
3035
3036
3037 if(!disp->Histogram) {
3038 void ** procp = (void **) &disp->Histogram;
3039 snprintf(symboln, sizeof(symboln), "%sHistogram", symbol_prefix);
3040 *procp = dlsym(handle, symboln);
3041 }
3042
3043
3044 if(!disp->Histogram) {
3045 void ** procp = (void **) &disp->Histogram;
3046 snprintf(symboln, sizeof(symboln), "%sHistogramEXT", symbol_prefix);
3047 *procp = dlsym(handle, symboln);
3048 }
3049
3050
3051 if(!disp->Minmax) {
3052 void ** procp = (void **) &disp->Minmax;
3053 snprintf(symboln, sizeof(symboln), "%sMinmax", symbol_prefix);
3054 *procp = dlsym(handle, symboln);
3055 }
3056
3057
3058 if(!disp->Minmax) {
3059 void ** procp = (void **) &disp->Minmax;
3060 snprintf(symboln, sizeof(symboln), "%sMinmaxEXT", symbol_prefix);
3061 *procp = dlsym(handle, symboln);
3062 }
3063
3064
3065 if(!disp->ResetHistogram) {
3066 void ** procp = (void **) &disp->ResetHistogram;
3067 snprintf(symboln, sizeof(symboln), "%sResetHistogram", symbol_prefix);
3068 *procp = dlsym(handle, symboln);
3069 }
3070
3071
3072 if(!disp->ResetHistogram) {
3073 void ** procp = (void **) &disp->ResetHistogram;
3074 snprintf(symboln, sizeof(symboln), "%sResetHistogramEXT", symbol_prefix);
3075 *procp = dlsym(handle, symboln);
3076 }
3077
3078
3079 if(!disp->ResetMinmax) {
3080 void ** procp = (void **) &disp->ResetMinmax;
3081 snprintf(symboln, sizeof(symboln), "%sResetMinmax", symbol_prefix);
3082 *procp = dlsym(handle, symboln);
3083 }
3084
3085
3086 if(!disp->ResetMinmax) {
3087 void ** procp = (void **) &disp->ResetMinmax;
3088 snprintf(symboln, sizeof(symboln), "%sResetMinmaxEXT", symbol_prefix);
3089 *procp = dlsym(handle, symboln);
3090 }
3091
3092
3093 if(!disp->TexImage3D) {
3094 void ** procp = (void **) &disp->TexImage3D;
3095 snprintf(symboln, sizeof(symboln), "%sTexImage3D", symbol_prefix);
3096 *procp = dlsym(handle, symboln);
3097 }
3098
3099
3100 if(!disp->TexImage3D) {
3101 void ** procp = (void **) &disp->TexImage3D;
3102 snprintf(symboln, sizeof(symboln), "%sTexImage3DEXT", symbol_prefix);
3103 *procp = dlsym(handle, symboln);
3104 }
3105
3106
3107 if(!disp->TexSubImage3D) {
3108 void ** procp = (void **) &disp->TexSubImage3D;
3109 snprintf(symboln, sizeof(symboln), "%sTexSubImage3D", symbol_prefix);
3110 *procp = dlsym(handle, symboln);
3111 }
3112
3113
3114 if(!disp->TexSubImage3D) {
3115 void ** procp = (void **) &disp->TexSubImage3D;
3116 snprintf(symboln, sizeof(symboln), "%sTexSubImage3DEXT", symbol_prefix);
3117 *procp = dlsym(handle, symboln);
3118 }
3119
3120
3121 if(!disp->CopyTexSubImage3D) {
3122 void ** procp = (void **) &disp->CopyTexSubImage3D;
3123 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage3D", symbol_prefix);
3124 *procp = dlsym(handle, symboln);
3125 }
3126
3127
3128 if(!disp->CopyTexSubImage3D) {
3129 void ** procp = (void **) &disp->CopyTexSubImage3D;
3130 snprintf(symboln, sizeof(symboln), "%sCopyTexSubImage3DEXT", symbol_prefix);
3131 *procp = dlsym(handle, symboln);
3132 }
3133
3134
3135 if(!disp->ActiveTextureARB) {
3136 void ** procp = (void **) &disp->ActiveTextureARB;
3137 snprintf(symboln, sizeof(symboln), "%sActiveTexture", symbol_prefix);
3138 *procp = dlsym(handle, symboln);
3139 }
3140
3141
3142 if(!disp->ActiveTextureARB) {
3143 void ** procp = (void **) &disp->ActiveTextureARB;
3144 snprintf(symboln, sizeof(symboln), "%sActiveTextureARB", symbol_prefix);
3145 *procp = dlsym(handle, symboln);
3146 }
3147
3148
3149 if(!disp->ClientActiveTextureARB) {
3150 void ** procp = (void **) &disp->ClientActiveTextureARB;
3151 snprintf(symboln, sizeof(symboln), "%sClientActiveTexture", symbol_prefix);
3152 *procp = dlsym(handle, symboln);
3153 }
3154
3155
3156 if(!disp->ClientActiveTextureARB) {
3157 void ** procp = (void **) &disp->ClientActiveTextureARB;
3158 snprintf(symboln, sizeof(symboln), "%sClientActiveTextureARB", symbol_prefix);
3159 *procp = dlsym(handle, symboln);
3160 }
3161
3162
3163 if(!disp->MultiTexCoord1dARB) {
3164 void ** procp = (void **) &disp->MultiTexCoord1dARB;
3165 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1d", symbol_prefix);
3166 *procp = dlsym(handle, symboln);
3167 }
3168
3169
3170 if(!disp->MultiTexCoord1dARB) {
3171 void ** procp = (void **) &disp->MultiTexCoord1dARB;
3172 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dARB", symbol_prefix);
3173 *procp = dlsym(handle, symboln);
3174 }
3175
3176
3177 if(!disp->MultiTexCoord1dvARB) {
3178 void ** procp = (void **) &disp->MultiTexCoord1dvARB;
3179 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dv", symbol_prefix);
3180 *procp = dlsym(handle, symboln);
3181 }
3182
3183
3184 if(!disp->MultiTexCoord1dvARB) {
3185 void ** procp = (void **) &disp->MultiTexCoord1dvARB;
3186 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1dvARB", symbol_prefix);
3187 *procp = dlsym(handle, symboln);
3188 }
3189
3190
3191 if(!disp->MultiTexCoord1fARB) {
3192 void ** procp = (void **) &disp->MultiTexCoord1fARB;
3193 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1f", symbol_prefix);
3194 *procp = dlsym(handle, symboln);
3195 }
3196
3197
3198 if(!disp->MultiTexCoord1fARB) {
3199 void ** procp = (void **) &disp->MultiTexCoord1fARB;
3200 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fARB", symbol_prefix);
3201 *procp = dlsym(handle, symboln);
3202 }
3203
3204
3205 if(!disp->MultiTexCoord1fvARB) {
3206 void ** procp = (void **) &disp->MultiTexCoord1fvARB;
3207 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fv", symbol_prefix);
3208 *procp = dlsym(handle, symboln);
3209 }
3210
3211
3212 if(!disp->MultiTexCoord1fvARB) {
3213 void ** procp = (void **) &disp->MultiTexCoord1fvARB;
3214 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1fvARB", symbol_prefix);
3215 *procp = dlsym(handle, symboln);
3216 }
3217
3218
3219 if(!disp->MultiTexCoord1iARB) {
3220 void ** procp = (void **) &disp->MultiTexCoord1iARB;
3221 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1i", symbol_prefix);
3222 *procp = dlsym(handle, symboln);
3223 }
3224
3225
3226 if(!disp->MultiTexCoord1iARB) {
3227 void ** procp = (void **) &disp->MultiTexCoord1iARB;
3228 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1iARB", symbol_prefix);
3229 *procp = dlsym(handle, symboln);
3230 }
3231
3232
3233 if(!disp->MultiTexCoord1ivARB) {
3234 void ** procp = (void **) &disp->MultiTexCoord1ivARB;
3235 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1iv", symbol_prefix);
3236 *procp = dlsym(handle, symboln);
3237 }
3238
3239
3240 if(!disp->MultiTexCoord1ivARB) {
3241 void ** procp = (void **) &disp->MultiTexCoord1ivARB;
3242 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1ivARB", symbol_prefix);
3243 *procp = dlsym(handle, symboln);
3244 }
3245
3246
3247 if(!disp->MultiTexCoord1sARB) {
3248 void ** procp = (void **) &disp->MultiTexCoord1sARB;
3249 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1s", symbol_prefix);
3250 *procp = dlsym(handle, symboln);
3251 }
3252
3253
3254 if(!disp->MultiTexCoord1sARB) {
3255 void ** procp = (void **) &disp->MultiTexCoord1sARB;
3256 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1sARB", symbol_prefix);
3257 *procp = dlsym(handle, symboln);
3258 }
3259
3260
3261 if(!disp->MultiTexCoord1svARB) {
3262 void ** procp = (void **) &disp->MultiTexCoord1svARB;
3263 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1sv", symbol_prefix);
3264 *procp = dlsym(handle, symboln);
3265 }
3266
3267
3268 if(!disp->MultiTexCoord1svARB) {
3269 void ** procp = (void **) &disp->MultiTexCoord1svARB;
3270 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord1svARB", symbol_prefix);
3271 *procp = dlsym(handle, symboln);
3272 }
3273
3274
3275 if(!disp->MultiTexCoord2dARB) {
3276 void ** procp = (void **) &disp->MultiTexCoord2dARB;
3277 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2d", symbol_prefix);
3278 *procp = dlsym(handle, symboln);
3279 }
3280
3281
3282 if(!disp->MultiTexCoord2dARB) {
3283 void ** procp = (void **) &disp->MultiTexCoord2dARB;
3284 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dARB", symbol_prefix);
3285 *procp = dlsym(handle, symboln);
3286 }
3287
3288
3289 if(!disp->MultiTexCoord2dvARB) {
3290 void ** procp = (void **) &disp->MultiTexCoord2dvARB;
3291 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dv", symbol_prefix);
3292 *procp = dlsym(handle, symboln);
3293 }
3294
3295
3296 if(!disp->MultiTexCoord2dvARB) {
3297 void ** procp = (void **) &disp->MultiTexCoord2dvARB;
3298 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2dvARB", symbol_prefix);
3299 *procp = dlsym(handle, symboln);
3300 }
3301
3302
3303 if(!disp->MultiTexCoord2fARB) {
3304 void ** procp = (void **) &disp->MultiTexCoord2fARB;
3305 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2f", symbol_prefix);
3306 *procp = dlsym(handle, symboln);
3307 }
3308
3309
3310 if(!disp->MultiTexCoord2fARB) {
3311 void ** procp = (void **) &disp->MultiTexCoord2fARB;
3312 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fARB", symbol_prefix);
3313 *procp = dlsym(handle, symboln);
3314 }
3315
3316
3317 if(!disp->MultiTexCoord2fvARB) {
3318 void ** procp = (void **) &disp->MultiTexCoord2fvARB;
3319 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fv", symbol_prefix);
3320 *procp = dlsym(handle, symboln);
3321 }
3322
3323
3324 if(!disp->MultiTexCoord2fvARB) {
3325 void ** procp = (void **) &disp->MultiTexCoord2fvARB;
3326 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2fvARB", symbol_prefix);
3327 *procp = dlsym(handle, symboln);
3328 }
3329
3330
3331 if(!disp->MultiTexCoord2iARB) {
3332 void ** procp = (void **) &disp->MultiTexCoord2iARB;
3333 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2i", symbol_prefix);
3334 *procp = dlsym(handle, symboln);
3335 }
3336
3337
3338 if(!disp->MultiTexCoord2iARB) {
3339 void ** procp = (void **) &disp->MultiTexCoord2iARB;
3340 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2iARB", symbol_prefix);
3341 *procp = dlsym(handle, symboln);
3342 }
3343
3344
3345 if(!disp->MultiTexCoord2ivARB) {
3346 void ** procp = (void **) &disp->MultiTexCoord2ivARB;
3347 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2iv", symbol_prefix);
3348 *procp = dlsym(handle, symboln);
3349 }
3350
3351
3352 if(!disp->MultiTexCoord2ivARB) {
3353 void ** procp = (void **) &disp->MultiTexCoord2ivARB;
3354 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2ivARB", symbol_prefix);
3355 *procp = dlsym(handle, symboln);
3356 }
3357
3358
3359 if(!disp->MultiTexCoord2sARB) {
3360 void ** procp = (void **) &disp->MultiTexCoord2sARB;
3361 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2s", symbol_prefix);
3362 *procp = dlsym(handle, symboln);
3363 }
3364
3365
3366 if(!disp->MultiTexCoord2sARB) {
3367 void ** procp = (void **) &disp->MultiTexCoord2sARB;
3368 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2sARB", symbol_prefix);
3369 *procp = dlsym(handle, symboln);
3370 }
3371
3372
3373 if(!disp->MultiTexCoord2svARB) {
3374 void ** procp = (void **) &disp->MultiTexCoord2svARB;
3375 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2sv", symbol_prefix);
3376 *procp = dlsym(handle, symboln);
3377 }
3378
3379
3380 if(!disp->MultiTexCoord2svARB) {
3381 void ** procp = (void **) &disp->MultiTexCoord2svARB;
3382 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord2svARB", symbol_prefix);
3383 *procp = dlsym(handle, symboln);
3384 }
3385
3386
3387 if(!disp->MultiTexCoord3dARB) {
3388 void ** procp = (void **) &disp->MultiTexCoord3dARB;
3389 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3d", symbol_prefix);
3390 *procp = dlsym(handle, symboln);
3391 }
3392
3393
3394 if(!disp->MultiTexCoord3dARB) {
3395 void ** procp = (void **) &disp->MultiTexCoord3dARB;
3396 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dARB", symbol_prefix);
3397 *procp = dlsym(handle, symboln);
3398 }
3399
3400
3401 if(!disp->MultiTexCoord3dvARB) {
3402 void ** procp = (void **) &disp->MultiTexCoord3dvARB;
3403 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dv", symbol_prefix);
3404 *procp = dlsym(handle, symboln);
3405 }
3406
3407
3408 if(!disp->MultiTexCoord3dvARB) {
3409 void ** procp = (void **) &disp->MultiTexCoord3dvARB;
3410 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3dvARB", symbol_prefix);
3411 *procp = dlsym(handle, symboln);
3412 }
3413
3414
3415 if(!disp->MultiTexCoord3fARB) {
3416 void ** procp = (void **) &disp->MultiTexCoord3fARB;
3417 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3f", symbol_prefix);
3418 *procp = dlsym(handle, symboln);
3419 }
3420
3421
3422 if(!disp->MultiTexCoord3fARB) {
3423 void ** procp = (void **) &disp->MultiTexCoord3fARB;
3424 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fARB", symbol_prefix);
3425 *procp = dlsym(handle, symboln);
3426 }
3427
3428
3429 if(!disp->MultiTexCoord3fvARB) {
3430 void ** procp = (void **) &disp->MultiTexCoord3fvARB;
3431 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fv", symbol_prefix);
3432 *procp = dlsym(handle, symboln);
3433 }
3434
3435
3436 if(!disp->MultiTexCoord3fvARB) {
3437 void ** procp = (void **) &disp->MultiTexCoord3fvARB;
3438 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3fvARB", symbol_prefix);
3439 *procp = dlsym(handle, symboln);
3440 }
3441
3442
3443 if(!disp->MultiTexCoord3iARB) {
3444 void ** procp = (void **) &disp->MultiTexCoord3iARB;
3445 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3i", symbol_prefix);
3446 *procp = dlsym(handle, symboln);
3447 }
3448
3449
3450 if(!disp->MultiTexCoord3iARB) {
3451 void ** procp = (void **) &disp->MultiTexCoord3iARB;
3452 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3iARB", symbol_prefix);
3453 *procp = dlsym(handle, symboln);
3454 }
3455
3456
3457 if(!disp->MultiTexCoord3ivARB) {
3458 void ** procp = (void **) &disp->MultiTexCoord3ivARB;
3459 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3iv", symbol_prefix);
3460 *procp = dlsym(handle, symboln);
3461 }
3462
3463
3464 if(!disp->MultiTexCoord3ivARB) {
3465 void ** procp = (void **) &disp->MultiTexCoord3ivARB;
3466 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3ivARB", symbol_prefix);
3467 *procp = dlsym(handle, symboln);
3468 }
3469
3470
3471 if(!disp->MultiTexCoord3sARB) {
3472 void ** procp = (void **) &disp->MultiTexCoord3sARB;
3473 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3s", symbol_prefix);
3474 *procp = dlsym(handle, symboln);
3475 }
3476
3477
3478 if(!disp->MultiTexCoord3sARB) {
3479 void ** procp = (void **) &disp->MultiTexCoord3sARB;
3480 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3sARB", symbol_prefix);
3481 *procp = dlsym(handle, symboln);
3482 }
3483
3484
3485 if(!disp->MultiTexCoord3svARB) {
3486 void ** procp = (void **) &disp->MultiTexCoord3svARB;
3487 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3sv", symbol_prefix);
3488 *procp = dlsym(handle, symboln);
3489 }
3490
3491
3492 if(!disp->MultiTexCoord3svARB) {
3493 void ** procp = (void **) &disp->MultiTexCoord3svARB;
3494 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord3svARB", symbol_prefix);
3495 *procp = dlsym(handle, symboln);
3496 }
3497
3498
3499 if(!disp->MultiTexCoord4dARB) {
3500 void ** procp = (void **) &disp->MultiTexCoord4dARB;
3501 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4d", symbol_prefix);
3502 *procp = dlsym(handle, symboln);
3503 }
3504
3505
3506 if(!disp->MultiTexCoord4dARB) {
3507 void ** procp = (void **) &disp->MultiTexCoord4dARB;
3508 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dARB", symbol_prefix);
3509 *procp = dlsym(handle, symboln);
3510 }
3511
3512
3513 if(!disp->MultiTexCoord4dvARB) {
3514 void ** procp = (void **) &disp->MultiTexCoord4dvARB;
3515 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dv", symbol_prefix);
3516 *procp = dlsym(handle, symboln);
3517 }
3518
3519
3520 if(!disp->MultiTexCoord4dvARB) {
3521 void ** procp = (void **) &disp->MultiTexCoord4dvARB;
3522 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4dvARB", symbol_prefix);
3523 *procp = dlsym(handle, symboln);
3524 }
3525
3526
3527 if(!disp->MultiTexCoord4fARB) {
3528 void ** procp = (void **) &disp->MultiTexCoord4fARB;
3529 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4f", symbol_prefix);
3530 *procp = dlsym(handle, symboln);
3531 }
3532
3533
3534 if(!disp->MultiTexCoord4fARB) {
3535 void ** procp = (void **) &disp->MultiTexCoord4fARB;
3536 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fARB", symbol_prefix);
3537 *procp = dlsym(handle, symboln);
3538 }
3539
3540
3541 if(!disp->MultiTexCoord4fvARB) {
3542 void ** procp = (void **) &disp->MultiTexCoord4fvARB;
3543 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fv", symbol_prefix);
3544 *procp = dlsym(handle, symboln);
3545 }
3546
3547
3548 if(!disp->MultiTexCoord4fvARB) {
3549 void ** procp = (void **) &disp->MultiTexCoord4fvARB;
3550 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4fvARB", symbol_prefix);
3551 *procp = dlsym(handle, symboln);
3552 }
3553
3554
3555 if(!disp->MultiTexCoord4iARB) {
3556 void ** procp = (void **) &disp->MultiTexCoord4iARB;
3557 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4i", symbol_prefix);
3558 *procp = dlsym(handle, symboln);
3559 }
3560
3561
3562 if(!disp->MultiTexCoord4iARB) {
3563 void ** procp = (void **) &disp->MultiTexCoord4iARB;
3564 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4iARB", symbol_prefix);
3565 *procp = dlsym(handle, symboln);
3566 }
3567
3568
3569 if(!disp->MultiTexCoord4ivARB) {
3570 void ** procp = (void **) &disp->MultiTexCoord4ivARB;
3571 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4iv", symbol_prefix);
3572 *procp = dlsym(handle, symboln);
3573 }
3574
3575
3576 if(!disp->MultiTexCoord4ivARB) {
3577 void ** procp = (void **) &disp->MultiTexCoord4ivARB;
3578 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4ivARB", symbol_prefix);
3579 *procp = dlsym(handle, symboln);
3580 }
3581
3582
3583 if(!disp->MultiTexCoord4sARB) {
3584 void ** procp = (void **) &disp->MultiTexCoord4sARB;
3585 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4s", symbol_prefix);
3586 *procp = dlsym(handle, symboln);
3587 }
3588
3589
3590 if(!disp->MultiTexCoord4sARB) {
3591 void ** procp = (void **) &disp->MultiTexCoord4sARB;
3592 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4sARB", symbol_prefix);
3593 *procp = dlsym(handle, symboln);
3594 }
3595
3596
3597 if(!disp->MultiTexCoord4svARB) {
3598 void ** procp = (void **) &disp->MultiTexCoord4svARB;
3599 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4sv", symbol_prefix);
3600 *procp = dlsym(handle, symboln);
3601 }
3602
3603
3604 if(!disp->MultiTexCoord4svARB) {
3605 void ** procp = (void **) &disp->MultiTexCoord4svARB;
3606 snprintf(symboln, sizeof(symboln), "%sMultiTexCoord4svARB", symbol_prefix);
3607 *procp = dlsym(handle, symboln);
3608 }
3609
3610
3611 if(!disp->AttachShader) {
3612 void ** procp = (void **) &disp->AttachShader;
3613 snprintf(symboln, sizeof(symboln), "%sAttachShader", symbol_prefix);
3614 *procp = dlsym(handle, symboln);
3615 }
3616
3617
3618 if(!disp->CreateProgram) {
3619 void ** procp = (void **) &disp->CreateProgram;
3620 snprintf(symboln, sizeof(symboln), "%sCreateProgram", symbol_prefix);
3621 *procp = dlsym(handle, symboln);
3622 }
3623
3624
3625 if(!disp->CreateShader) {
3626 void ** procp = (void **) &disp->CreateShader;
3627 snprintf(symboln, sizeof(symboln), "%sCreateShader", symbol_prefix);
3628 *procp = dlsym(handle, symboln);
3629 }
3630
3631
3632 if(!disp->DeleteProgram) {
3633 void ** procp = (void **) &disp->DeleteProgram;
3634 snprintf(symboln, sizeof(symboln), "%sDeleteProgram", symbol_prefix);
3635 *procp = dlsym(handle, symboln);
3636 }
3637
3638
3639 if(!disp->DeleteShader) {
3640 void ** procp = (void **) &disp->DeleteShader;
3641 snprintf(symboln, sizeof(symboln), "%sDeleteShader", symbol_prefix);
3642 *procp = dlsym(handle, symboln);
3643 }
3644
3645
3646 if(!disp->DetachShader) {
3647 void ** procp = (void **) &disp->DetachShader;
3648 snprintf(symboln, sizeof(symboln), "%sDetachShader", symbol_prefix);
3649 *procp = dlsym(handle, symboln);
3650 }
3651
3652
3653 if(!disp->GetAttachedShaders) {
3654 void ** procp = (void **) &disp->GetAttachedShaders;
3655 snprintf(symboln, sizeof(symboln), "%sGetAttachedShaders", symbol_prefix);
3656 *procp = dlsym(handle, symboln);
3657 }
3658
3659
3660 if(!disp->GetProgramInfoLog) {
3661 void ** procp = (void **) &disp->GetProgramInfoLog;
3662 snprintf(symboln, sizeof(symboln), "%sGetProgramInfoLog", symbol_prefix);
3663 *procp = dlsym(handle, symboln);
3664 }
3665
3666
3667 if(!disp->GetProgramiv) {
3668 void ** procp = (void **) &disp->GetProgramiv;
3669 snprintf(symboln, sizeof(symboln), "%sGetProgramiv", symbol_prefix);
3670 *procp = dlsym(handle, symboln);
3671 }
3672
3673
3674 if(!disp->GetShaderInfoLog) {
3675 void ** procp = (void **) &disp->GetShaderInfoLog;
3676 snprintf(symboln, sizeof(symboln), "%sGetShaderInfoLog", symbol_prefix);
3677 *procp = dlsym(handle, symboln);
3678 }
3679
3680
3681 if(!disp->GetShaderiv) {
3682 void ** procp = (void **) &disp->GetShaderiv;
3683 snprintf(symboln, sizeof(symboln), "%sGetShaderiv", symbol_prefix);
3684 *procp = dlsym(handle, symboln);
3685 }
3686
3687
3688 if(!disp->IsProgram) {
3689 void ** procp = (void **) &disp->IsProgram;
3690 snprintf(symboln, sizeof(symboln), "%sIsProgram", symbol_prefix);
3691 *procp = dlsym(handle, symboln);
3692 }
3693
3694
3695 if(!disp->IsShader) {
3696 void ** procp = (void **) &disp->IsShader;
3697 snprintf(symboln, sizeof(symboln), "%sIsShader", symbol_prefix);
3698 *procp = dlsym(handle, symboln);
3699 }
3700
3701
3702 if(!disp->StencilFuncSeparate) {
3703 void ** procp = (void **) &disp->StencilFuncSeparate;
3704 snprintf(symboln, sizeof(symboln), "%sStencilFuncSeparate", symbol_prefix);
3705 *procp = dlsym(handle, symboln);
3706 }
3707
3708
3709 if(!disp->StencilMaskSeparate) {
3710 void ** procp = (void **) &disp->StencilMaskSeparate;
3711 snprintf(symboln, sizeof(symboln), "%sStencilMaskSeparate", symbol_prefix);
3712 *procp = dlsym(handle, symboln);
3713 }
3714
3715
3716 if(!disp->StencilOpSeparate) {
3717 void ** procp = (void **) &disp->StencilOpSeparate;
3718 snprintf(symboln, sizeof(symboln), "%sStencilOpSeparate", symbol_prefix);
3719 *procp = dlsym(handle, symboln);
3720 }
3721
3722
3723 if(!disp->StencilOpSeparate) {
3724 void ** procp = (void **) &disp->StencilOpSeparate;
3725 snprintf(symboln, sizeof(symboln), "%sStencilOpSeparateATI", symbol_prefix);
3726 *procp = dlsym(handle, symboln);
3727 }
3728
3729
3730 if(!disp->UniformMatrix2x3fv) {
3731 void ** procp = (void **) &disp->UniformMatrix2x3fv;
3732 snprintf(symboln, sizeof(symboln), "%sUniformMatrix2x3fv", symbol_prefix);
3733 *procp = dlsym(handle, symboln);
3734 }
3735
3736
3737 if(!disp->UniformMatrix2x4fv) {
3738 void ** procp = (void **) &disp->UniformMatrix2x4fv;
3739 snprintf(symboln, sizeof(symboln), "%sUniformMatrix2x4fv", symbol_prefix);
3740 *procp = dlsym(handle, symboln);
3741 }
3742
3743
3744 if(!disp->UniformMatrix3x2fv) {
3745 void ** procp = (void **) &disp->UniformMatrix3x2fv;
3746 snprintf(symboln, sizeof(symboln), "%sUniformMatrix3x2fv", symbol_prefix);
3747 *procp = dlsym(handle, symboln);
3748 }
3749
3750
3751 if(!disp->UniformMatrix3x4fv) {
3752 void ** procp = (void **) &disp->UniformMatrix3x4fv;
3753 snprintf(symboln, sizeof(symboln), "%sUniformMatrix3x4fv", symbol_prefix);
3754 *procp = dlsym(handle, symboln);
3755 }
3756
3757
3758 if(!disp->UniformMatrix4x2fv) {
3759 void ** procp = (void **) &disp->UniformMatrix4x2fv;
3760 snprintf(symboln, sizeof(symboln), "%sUniformMatrix4x2fv", symbol_prefix);
3761 *procp = dlsym(handle, symboln);
3762 }
3763
3764
3765 if(!disp->UniformMatrix4x3fv) {
3766 void ** procp = (void **) &disp->UniformMatrix4x3fv;
3767 snprintf(symboln, sizeof(symboln), "%sUniformMatrix4x3fv", symbol_prefix);
3768 *procp = dlsym(handle, symboln);
3769 }
3770
3771
3772 if(!disp->ClampColor) {
3773 void ** procp = (void **) &disp->ClampColor;
3774 snprintf(symboln, sizeof(symboln), "%sClampColor", symbol_prefix);
3775 *procp = dlsym(handle, symboln);
3776 }
3777
3778
3779 if(!disp->ClearBufferfi) {
3780 void ** procp = (void **) &disp->ClearBufferfi;
3781 snprintf(symboln, sizeof(symboln), "%sClearBufferfi", symbol_prefix);
3782 *procp = dlsym(handle, symboln);
3783 }
3784
3785
3786 if(!disp->ClearBufferfv) {
3787 void ** procp = (void **) &disp->ClearBufferfv;
3788 snprintf(symboln, sizeof(symboln), "%sClearBufferfv", symbol_prefix);
3789 *procp = dlsym(handle, symboln);
3790 }
3791
3792
3793 if(!disp->ClearBufferiv) {
3794 void ** procp = (void **) &disp->ClearBufferiv;
3795 snprintf(symboln, sizeof(symboln), "%sClearBufferiv", symbol_prefix);
3796 *procp = dlsym(handle, symboln);
3797 }
3798
3799
3800 if(!disp->ClearBufferuiv) {
3801 void ** procp = (void **) &disp->ClearBufferuiv;
3802 snprintf(symboln, sizeof(symboln), "%sClearBufferuiv", symbol_prefix);
3803 *procp = dlsym(handle, symboln);
3804 }
3805
3806
3807 if(!disp->GetStringi) {
3808 void ** procp = (void **) &disp->GetStringi;
3809 snprintf(symboln, sizeof(symboln), "%sGetStringi", symbol_prefix);
3810 *procp = dlsym(handle, symboln);
3811 }
3812
3813
3814 if(!disp->FramebufferTexture) {
3815 void ** procp = (void **) &disp->FramebufferTexture;
3816 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture", symbol_prefix);
3817 *procp = dlsym(handle, symboln);
3818 }
3819
3820
3821 if(!disp->GetBufferParameteri64v) {
3822 void ** procp = (void **) &disp->GetBufferParameteri64v;
3823 snprintf(symboln, sizeof(symboln), "%sGetBufferParameteri64v", symbol_prefix);
3824 *procp = dlsym(handle, symboln);
3825 }
3826
3827
3828 if(!disp->GetInteger64i_v) {
3829 void ** procp = (void **) &disp->GetInteger64i_v;
3830 snprintf(symboln, sizeof(symboln), "%sGetInteger64i_v", symbol_prefix);
3831 *procp = dlsym(handle, symboln);
3832 }
3833
3834
3835 if(!disp->VertexAttribDivisor) {
3836 void ** procp = (void **) &disp->VertexAttribDivisor;
3837 snprintf(symboln, sizeof(symboln), "%sVertexAttribDivisor", symbol_prefix);
3838 *procp = dlsym(handle, symboln);
3839 }
3840
3841
3842 if(!disp->LoadTransposeMatrixdARB) {
3843 void ** procp = (void **) &disp->LoadTransposeMatrixdARB;
3844 snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixd", symbol_prefix);
3845 *procp = dlsym(handle, symboln);
3846 }
3847
3848
3849 if(!disp->LoadTransposeMatrixdARB) {
3850 void ** procp = (void **) &disp->LoadTransposeMatrixdARB;
3851 snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixdARB", symbol_prefix);
3852 *procp = dlsym(handle, symboln);
3853 }
3854
3855
3856 if(!disp->LoadTransposeMatrixfARB) {
3857 void ** procp = (void **) &disp->LoadTransposeMatrixfARB;
3858 snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixf", symbol_prefix);
3859 *procp = dlsym(handle, symboln);
3860 }
3861
3862
3863 if(!disp->LoadTransposeMatrixfARB) {
3864 void ** procp = (void **) &disp->LoadTransposeMatrixfARB;
3865 snprintf(symboln, sizeof(symboln), "%sLoadTransposeMatrixfARB", symbol_prefix);
3866 *procp = dlsym(handle, symboln);
3867 }
3868
3869
3870 if(!disp->MultTransposeMatrixdARB) {
3871 void ** procp = (void **) &disp->MultTransposeMatrixdARB;
3872 snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixd", symbol_prefix);
3873 *procp = dlsym(handle, symboln);
3874 }
3875
3876
3877 if(!disp->MultTransposeMatrixdARB) {
3878 void ** procp = (void **) &disp->MultTransposeMatrixdARB;
3879 snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixdARB", symbol_prefix);
3880 *procp = dlsym(handle, symboln);
3881 }
3882
3883
3884 if(!disp->MultTransposeMatrixfARB) {
3885 void ** procp = (void **) &disp->MultTransposeMatrixfARB;
3886 snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixf", symbol_prefix);
3887 *procp = dlsym(handle, symboln);
3888 }
3889
3890
3891 if(!disp->MultTransposeMatrixfARB) {
3892 void ** procp = (void **) &disp->MultTransposeMatrixfARB;
3893 snprintf(symboln, sizeof(symboln), "%sMultTransposeMatrixfARB", symbol_prefix);
3894 *procp = dlsym(handle, symboln);
3895 }
3896
3897
3898 if(!disp->SampleCoverageARB) {
3899 void ** procp = (void **) &disp->SampleCoverageARB;
3900 snprintf(symboln, sizeof(symboln), "%sSampleCoverage", symbol_prefix);
3901 *procp = dlsym(handle, symboln);
3902 }
3903
3904
3905 if(!disp->SampleCoverageARB) {
3906 void ** procp = (void **) &disp->SampleCoverageARB;
3907 snprintf(symboln, sizeof(symboln), "%sSampleCoverageARB", symbol_prefix);
3908 *procp = dlsym(handle, symboln);
3909 }
3910
3911
3912 if(!disp->CompressedTexImage1DARB) {
3913 void ** procp = (void **) &disp->CompressedTexImage1DARB;
3914 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage1D", symbol_prefix);
3915 *procp = dlsym(handle, symboln);
3916 }
3917
3918
3919 if(!disp->CompressedTexImage1DARB) {
3920 void ** procp = (void **) &disp->CompressedTexImage1DARB;
3921 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage1DARB", symbol_prefix);
3922 *procp = dlsym(handle, symboln);
3923 }
3924
3925
3926 if(!disp->CompressedTexImage2DARB) {
3927 void ** procp = (void **) &disp->CompressedTexImage2DARB;
3928 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage2D", symbol_prefix);
3929 *procp = dlsym(handle, symboln);
3930 }
3931
3932
3933 if(!disp->CompressedTexImage2DARB) {
3934 void ** procp = (void **) &disp->CompressedTexImage2DARB;
3935 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage2DARB", symbol_prefix);
3936 *procp = dlsym(handle, symboln);
3937 }
3938
3939
3940 if(!disp->CompressedTexImage3DARB) {
3941 void ** procp = (void **) &disp->CompressedTexImage3DARB;
3942 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage3D", symbol_prefix);
3943 *procp = dlsym(handle, symboln);
3944 }
3945
3946
3947 if(!disp->CompressedTexImage3DARB) {
3948 void ** procp = (void **) &disp->CompressedTexImage3DARB;
3949 snprintf(symboln, sizeof(symboln), "%sCompressedTexImage3DARB", symbol_prefix);
3950 *procp = dlsym(handle, symboln);
3951 }
3952
3953
3954 if(!disp->CompressedTexSubImage1DARB) {
3955 void ** procp = (void **) &disp->CompressedTexSubImage1DARB;
3956 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage1D", symbol_prefix);
3957 *procp = dlsym(handle, symboln);
3958 }
3959
3960
3961 if(!disp->CompressedTexSubImage1DARB) {
3962 void ** procp = (void **) &disp->CompressedTexSubImage1DARB;
3963 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage1DARB", symbol_prefix);
3964 *procp = dlsym(handle, symboln);
3965 }
3966
3967
3968 if(!disp->CompressedTexSubImage2DARB) {
3969 void ** procp = (void **) &disp->CompressedTexSubImage2DARB;
3970 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage2D", symbol_prefix);
3971 *procp = dlsym(handle, symboln);
3972 }
3973
3974
3975 if(!disp->CompressedTexSubImage2DARB) {
3976 void ** procp = (void **) &disp->CompressedTexSubImage2DARB;
3977 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage2DARB", symbol_prefix);
3978 *procp = dlsym(handle, symboln);
3979 }
3980
3981
3982 if(!disp->CompressedTexSubImage3DARB) {
3983 void ** procp = (void **) &disp->CompressedTexSubImage3DARB;
3984 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage3D", symbol_prefix);
3985 *procp = dlsym(handle, symboln);
3986 }
3987
3988
3989 if(!disp->CompressedTexSubImage3DARB) {
3990 void ** procp = (void **) &disp->CompressedTexSubImage3DARB;
3991 snprintf(symboln, sizeof(symboln), "%sCompressedTexSubImage3DARB", symbol_prefix);
3992 *procp = dlsym(handle, symboln);
3993 }
3994
3995
3996 if(!disp->GetCompressedTexImageARB) {
3997 void ** procp = (void **) &disp->GetCompressedTexImageARB;
3998 snprintf(symboln, sizeof(symboln), "%sGetCompressedTexImage", symbol_prefix);
3999 *procp = dlsym(handle, symboln);
4000 }
4001
4002
4003 if(!disp->GetCompressedTexImageARB) {
4004 void ** procp = (void **) &disp->GetCompressedTexImageARB;
4005 snprintf(symboln, sizeof(symboln), "%sGetCompressedTexImageARB", symbol_prefix);
4006 *procp = dlsym(handle, symboln);
4007 }
4008
4009
4010 if(!disp->DisableVertexAttribArrayARB) {
4011 void ** procp = (void **) &disp->DisableVertexAttribArrayARB;
4012 snprintf(symboln, sizeof(symboln), "%sDisableVertexAttribArray", symbol_prefix);
4013 *procp = dlsym(handle, symboln);
4014 }
4015
4016
4017 if(!disp->DisableVertexAttribArrayARB) {
4018 void ** procp = (void **) &disp->DisableVertexAttribArrayARB;
4019 snprintf(symboln, sizeof(symboln), "%sDisableVertexAttribArrayARB", symbol_prefix);
4020 *procp = dlsym(handle, symboln);
4021 }
4022
4023
4024 if(!disp->EnableVertexAttribArrayARB) {
4025 void ** procp = (void **) &disp->EnableVertexAttribArrayARB;
4026 snprintf(symboln, sizeof(symboln), "%sEnableVertexAttribArray", symbol_prefix);
4027 *procp = dlsym(handle, symboln);
4028 }
4029
4030
4031 if(!disp->EnableVertexAttribArrayARB) {
4032 void ** procp = (void **) &disp->EnableVertexAttribArrayARB;
4033 snprintf(symboln, sizeof(symboln), "%sEnableVertexAttribArrayARB", symbol_prefix);
4034 *procp = dlsym(handle, symboln);
4035 }
4036
4037
4038 if(!disp->GetProgramEnvParameterdvARB) {
4039 void ** procp = (void **) &disp->GetProgramEnvParameterdvARB;
4040 snprintf(symboln, sizeof(symboln), "%sGetProgramEnvParameterdvARB", symbol_prefix);
4041 *procp = dlsym(handle, symboln);
4042 }
4043
4044
4045 if(!disp->GetProgramEnvParameterfvARB) {
4046 void ** procp = (void **) &disp->GetProgramEnvParameterfvARB;
4047 snprintf(symboln, sizeof(symboln), "%sGetProgramEnvParameterfvARB", symbol_prefix);
4048 *procp = dlsym(handle, symboln);
4049 }
4050
4051
4052 if(!disp->GetProgramLocalParameterdvARB) {
4053 void ** procp = (void **) &disp->GetProgramLocalParameterdvARB;
4054 snprintf(symboln, sizeof(symboln), "%sGetProgramLocalParameterdvARB", symbol_prefix);
4055 *procp = dlsym(handle, symboln);
4056 }
4057
4058
4059 if(!disp->GetProgramLocalParameterfvARB) {
4060 void ** procp = (void **) &disp->GetProgramLocalParameterfvARB;
4061 snprintf(symboln, sizeof(symboln), "%sGetProgramLocalParameterfvARB", symbol_prefix);
4062 *procp = dlsym(handle, symboln);
4063 }
4064
4065
4066 if(!disp->GetProgramStringARB) {
4067 void ** procp = (void **) &disp->GetProgramStringARB;
4068 snprintf(symboln, sizeof(symboln), "%sGetProgramStringARB", symbol_prefix);
4069 *procp = dlsym(handle, symboln);
4070 }
4071
4072
4073 if(!disp->GetProgramivARB) {
4074 void ** procp = (void **) &disp->GetProgramivARB;
4075 snprintf(symboln, sizeof(symboln), "%sGetProgramivARB", symbol_prefix);
4076 *procp = dlsym(handle, symboln);
4077 }
4078
4079
4080 if(!disp->GetVertexAttribdvARB) {
4081 void ** procp = (void **) &disp->GetVertexAttribdvARB;
4082 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdv", symbol_prefix);
4083 *procp = dlsym(handle, symboln);
4084 }
4085
4086
4087 if(!disp->GetVertexAttribdvARB) {
4088 void ** procp = (void **) &disp->GetVertexAttribdvARB;
4089 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdvARB", symbol_prefix);
4090 *procp = dlsym(handle, symboln);
4091 }
4092
4093
4094 if(!disp->GetVertexAttribfvARB) {
4095 void ** procp = (void **) &disp->GetVertexAttribfvARB;
4096 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfv", symbol_prefix);
4097 *procp = dlsym(handle, symboln);
4098 }
4099
4100
4101 if(!disp->GetVertexAttribfvARB) {
4102 void ** procp = (void **) &disp->GetVertexAttribfvARB;
4103 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfvARB", symbol_prefix);
4104 *procp = dlsym(handle, symboln);
4105 }
4106
4107
4108 if(!disp->GetVertexAttribivARB) {
4109 void ** procp = (void **) &disp->GetVertexAttribivARB;
4110 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribiv", symbol_prefix);
4111 *procp = dlsym(handle, symboln);
4112 }
4113
4114
4115 if(!disp->GetVertexAttribivARB) {
4116 void ** procp = (void **) &disp->GetVertexAttribivARB;
4117 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribivARB", symbol_prefix);
4118 *procp = dlsym(handle, symboln);
4119 }
4120
4121
4122 if(!disp->ProgramEnvParameter4dARB) {
4123 void ** procp = (void **) &disp->ProgramEnvParameter4dARB;
4124 snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4dARB", symbol_prefix);
4125 *procp = dlsym(handle, symboln);
4126 }
4127
4128
4129 if(!disp->ProgramEnvParameter4dARB) {
4130 void ** procp = (void **) &disp->ProgramEnvParameter4dARB;
4131 snprintf(symboln, sizeof(symboln), "%sProgramParameter4dNV", symbol_prefix);
4132 *procp = dlsym(handle, symboln);
4133 }
4134
4135
4136 if(!disp->ProgramEnvParameter4dvARB) {
4137 void ** procp = (void **) &disp->ProgramEnvParameter4dvARB;
4138 snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4dvARB", symbol_prefix);
4139 *procp = dlsym(handle, symboln);
4140 }
4141
4142
4143 if(!disp->ProgramEnvParameter4dvARB) {
4144 void ** procp = (void **) &disp->ProgramEnvParameter4dvARB;
4145 snprintf(symboln, sizeof(symboln), "%sProgramParameter4dvNV", symbol_prefix);
4146 *procp = dlsym(handle, symboln);
4147 }
4148
4149
4150 if(!disp->ProgramEnvParameter4fARB) {
4151 void ** procp = (void **) &disp->ProgramEnvParameter4fARB;
4152 snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4fARB", symbol_prefix);
4153 *procp = dlsym(handle, symboln);
4154 }
4155
4156
4157 if(!disp->ProgramEnvParameter4fARB) {
4158 void ** procp = (void **) &disp->ProgramEnvParameter4fARB;
4159 snprintf(symboln, sizeof(symboln), "%sProgramParameter4fNV", symbol_prefix);
4160 *procp = dlsym(handle, symboln);
4161 }
4162
4163
4164 if(!disp->ProgramEnvParameter4fvARB) {
4165 void ** procp = (void **) &disp->ProgramEnvParameter4fvARB;
4166 snprintf(symboln, sizeof(symboln), "%sProgramEnvParameter4fvARB", symbol_prefix);
4167 *procp = dlsym(handle, symboln);
4168 }
4169
4170
4171 if(!disp->ProgramEnvParameter4fvARB) {
4172 void ** procp = (void **) &disp->ProgramEnvParameter4fvARB;
4173 snprintf(symboln, sizeof(symboln), "%sProgramParameter4fvNV", symbol_prefix);
4174 *procp = dlsym(handle, symboln);
4175 }
4176
4177
4178 if(!disp->ProgramLocalParameter4dARB) {
4179 void ** procp = (void **) &disp->ProgramLocalParameter4dARB;
4180 snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4dARB", symbol_prefix);
4181 *procp = dlsym(handle, symboln);
4182 }
4183
4184
4185 if(!disp->ProgramLocalParameter4dvARB) {
4186 void ** procp = (void **) &disp->ProgramLocalParameter4dvARB;
4187 snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4dvARB", symbol_prefix);
4188 *procp = dlsym(handle, symboln);
4189 }
4190
4191
4192 if(!disp->ProgramLocalParameter4fARB) {
4193 void ** procp = (void **) &disp->ProgramLocalParameter4fARB;
4194 snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4fARB", symbol_prefix);
4195 *procp = dlsym(handle, symboln);
4196 }
4197
4198
4199 if(!disp->ProgramLocalParameter4fvARB) {
4200 void ** procp = (void **) &disp->ProgramLocalParameter4fvARB;
4201 snprintf(symboln, sizeof(symboln), "%sProgramLocalParameter4fvARB", symbol_prefix);
4202 *procp = dlsym(handle, symboln);
4203 }
4204
4205
4206 if(!disp->ProgramStringARB) {
4207 void ** procp = (void **) &disp->ProgramStringARB;
4208 snprintf(symboln, sizeof(symboln), "%sProgramStringARB", symbol_prefix);
4209 *procp = dlsym(handle, symboln);
4210 }
4211
4212
4213 if(!disp->VertexAttrib1dARB) {
4214 void ** procp = (void **) &disp->VertexAttrib1dARB;
4215 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1d", symbol_prefix);
4216 *procp = dlsym(handle, symboln);
4217 }
4218
4219
4220 if(!disp->VertexAttrib1dARB) {
4221 void ** procp = (void **) &disp->VertexAttrib1dARB;
4222 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dARB", symbol_prefix);
4223 *procp = dlsym(handle, symboln);
4224 }
4225
4226
4227 if(!disp->VertexAttrib1dvARB) {
4228 void ** procp = (void **) &disp->VertexAttrib1dvARB;
4229 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dv", symbol_prefix);
4230 *procp = dlsym(handle, symboln);
4231 }
4232
4233
4234 if(!disp->VertexAttrib1dvARB) {
4235 void ** procp = (void **) &disp->VertexAttrib1dvARB;
4236 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dvARB", symbol_prefix);
4237 *procp = dlsym(handle, symboln);
4238 }
4239
4240
4241 if(!disp->VertexAttrib1fARB) {
4242 void ** procp = (void **) &disp->VertexAttrib1fARB;
4243 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1f", symbol_prefix);
4244 *procp = dlsym(handle, symboln);
4245 }
4246
4247
4248 if(!disp->VertexAttrib1fARB) {
4249 void ** procp = (void **) &disp->VertexAttrib1fARB;
4250 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fARB", symbol_prefix);
4251 *procp = dlsym(handle, symboln);
4252 }
4253
4254
4255 if(!disp->VertexAttrib1fvARB) {
4256 void ** procp = (void **) &disp->VertexAttrib1fvARB;
4257 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fv", symbol_prefix);
4258 *procp = dlsym(handle, symboln);
4259 }
4260
4261
4262 if(!disp->VertexAttrib1fvARB) {
4263 void ** procp = (void **) &disp->VertexAttrib1fvARB;
4264 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fvARB", symbol_prefix);
4265 *procp = dlsym(handle, symboln);
4266 }
4267
4268
4269 if(!disp->VertexAttrib1sARB) {
4270 void ** procp = (void **) &disp->VertexAttrib1sARB;
4271 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1s", symbol_prefix);
4272 *procp = dlsym(handle, symboln);
4273 }
4274
4275
4276 if(!disp->VertexAttrib1sARB) {
4277 void ** procp = (void **) &disp->VertexAttrib1sARB;
4278 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sARB", symbol_prefix);
4279 *procp = dlsym(handle, symboln);
4280 }
4281
4282
4283 if(!disp->VertexAttrib1svARB) {
4284 void ** procp = (void **) &disp->VertexAttrib1svARB;
4285 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sv", symbol_prefix);
4286 *procp = dlsym(handle, symboln);
4287 }
4288
4289
4290 if(!disp->VertexAttrib1svARB) {
4291 void ** procp = (void **) &disp->VertexAttrib1svARB;
4292 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1svARB", symbol_prefix);
4293 *procp = dlsym(handle, symboln);
4294 }
4295
4296
4297 if(!disp->VertexAttrib2dARB) {
4298 void ** procp = (void **) &disp->VertexAttrib2dARB;
4299 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2d", symbol_prefix);
4300 *procp = dlsym(handle, symboln);
4301 }
4302
4303
4304 if(!disp->VertexAttrib2dARB) {
4305 void ** procp = (void **) &disp->VertexAttrib2dARB;
4306 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dARB", symbol_prefix);
4307 *procp = dlsym(handle, symboln);
4308 }
4309
4310
4311 if(!disp->VertexAttrib2dvARB) {
4312 void ** procp = (void **) &disp->VertexAttrib2dvARB;
4313 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dv", symbol_prefix);
4314 *procp = dlsym(handle, symboln);
4315 }
4316
4317
4318 if(!disp->VertexAttrib2dvARB) {
4319 void ** procp = (void **) &disp->VertexAttrib2dvARB;
4320 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dvARB", symbol_prefix);
4321 *procp = dlsym(handle, symboln);
4322 }
4323
4324
4325 if(!disp->VertexAttrib2fARB) {
4326 void ** procp = (void **) &disp->VertexAttrib2fARB;
4327 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2f", symbol_prefix);
4328 *procp = dlsym(handle, symboln);
4329 }
4330
4331
4332 if(!disp->VertexAttrib2fARB) {
4333 void ** procp = (void **) &disp->VertexAttrib2fARB;
4334 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fARB", symbol_prefix);
4335 *procp = dlsym(handle, symboln);
4336 }
4337
4338
4339 if(!disp->VertexAttrib2fvARB) {
4340 void ** procp = (void **) &disp->VertexAttrib2fvARB;
4341 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fv", symbol_prefix);
4342 *procp = dlsym(handle, symboln);
4343 }
4344
4345
4346 if(!disp->VertexAttrib2fvARB) {
4347 void ** procp = (void **) &disp->VertexAttrib2fvARB;
4348 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fvARB", symbol_prefix);
4349 *procp = dlsym(handle, symboln);
4350 }
4351
4352
4353 if(!disp->VertexAttrib2sARB) {
4354 void ** procp = (void **) &disp->VertexAttrib2sARB;
4355 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2s", symbol_prefix);
4356 *procp = dlsym(handle, symboln);
4357 }
4358
4359
4360 if(!disp->VertexAttrib2sARB) {
4361 void ** procp = (void **) &disp->VertexAttrib2sARB;
4362 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sARB", symbol_prefix);
4363 *procp = dlsym(handle, symboln);
4364 }
4365
4366
4367 if(!disp->VertexAttrib2svARB) {
4368 void ** procp = (void **) &disp->VertexAttrib2svARB;
4369 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sv", symbol_prefix);
4370 *procp = dlsym(handle, symboln);
4371 }
4372
4373
4374 if(!disp->VertexAttrib2svARB) {
4375 void ** procp = (void **) &disp->VertexAttrib2svARB;
4376 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2svARB", symbol_prefix);
4377 *procp = dlsym(handle, symboln);
4378 }
4379
4380
4381 if(!disp->VertexAttrib3dARB) {
4382 void ** procp = (void **) &disp->VertexAttrib3dARB;
4383 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3d", symbol_prefix);
4384 *procp = dlsym(handle, symboln);
4385 }
4386
4387
4388 if(!disp->VertexAttrib3dARB) {
4389 void ** procp = (void **) &disp->VertexAttrib3dARB;
4390 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dARB", symbol_prefix);
4391 *procp = dlsym(handle, symboln);
4392 }
4393
4394
4395 if(!disp->VertexAttrib3dvARB) {
4396 void ** procp = (void **) &disp->VertexAttrib3dvARB;
4397 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dv", symbol_prefix);
4398 *procp = dlsym(handle, symboln);
4399 }
4400
4401
4402 if(!disp->VertexAttrib3dvARB) {
4403 void ** procp = (void **) &disp->VertexAttrib3dvARB;
4404 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dvARB", symbol_prefix);
4405 *procp = dlsym(handle, symboln);
4406 }
4407
4408
4409 if(!disp->VertexAttrib3fARB) {
4410 void ** procp = (void **) &disp->VertexAttrib3fARB;
4411 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3f", symbol_prefix);
4412 *procp = dlsym(handle, symboln);
4413 }
4414
4415
4416 if(!disp->VertexAttrib3fARB) {
4417 void ** procp = (void **) &disp->VertexAttrib3fARB;
4418 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fARB", symbol_prefix);
4419 *procp = dlsym(handle, symboln);
4420 }
4421
4422
4423 if(!disp->VertexAttrib3fvARB) {
4424 void ** procp = (void **) &disp->VertexAttrib3fvARB;
4425 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fv", symbol_prefix);
4426 *procp = dlsym(handle, symboln);
4427 }
4428
4429
4430 if(!disp->VertexAttrib3fvARB) {
4431 void ** procp = (void **) &disp->VertexAttrib3fvARB;
4432 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fvARB", symbol_prefix);
4433 *procp = dlsym(handle, symboln);
4434 }
4435
4436
4437 if(!disp->VertexAttrib3sARB) {
4438 void ** procp = (void **) &disp->VertexAttrib3sARB;
4439 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3s", symbol_prefix);
4440 *procp = dlsym(handle, symboln);
4441 }
4442
4443
4444 if(!disp->VertexAttrib3sARB) {
4445 void ** procp = (void **) &disp->VertexAttrib3sARB;
4446 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sARB", symbol_prefix);
4447 *procp = dlsym(handle, symboln);
4448 }
4449
4450
4451 if(!disp->VertexAttrib3svARB) {
4452 void ** procp = (void **) &disp->VertexAttrib3svARB;
4453 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sv", symbol_prefix);
4454 *procp = dlsym(handle, symboln);
4455 }
4456
4457
4458 if(!disp->VertexAttrib3svARB) {
4459 void ** procp = (void **) &disp->VertexAttrib3svARB;
4460 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3svARB", symbol_prefix);
4461 *procp = dlsym(handle, symboln);
4462 }
4463
4464
4465 if(!disp->VertexAttrib4NbvARB) {
4466 void ** procp = (void **) &disp->VertexAttrib4NbvARB;
4467 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nbv", symbol_prefix);
4468 *procp = dlsym(handle, symboln);
4469 }
4470
4471
4472 if(!disp->VertexAttrib4NbvARB) {
4473 void ** procp = (void **) &disp->VertexAttrib4NbvARB;
4474 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NbvARB", symbol_prefix);
4475 *procp = dlsym(handle, symboln);
4476 }
4477
4478
4479 if(!disp->VertexAttrib4NivARB) {
4480 void ** procp = (void **) &disp->VertexAttrib4NivARB;
4481 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Niv", symbol_prefix);
4482 *procp = dlsym(handle, symboln);
4483 }
4484
4485
4486 if(!disp->VertexAttrib4NivARB) {
4487 void ** procp = (void **) &disp->VertexAttrib4NivARB;
4488 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NivARB", symbol_prefix);
4489 *procp = dlsym(handle, symboln);
4490 }
4491
4492
4493 if(!disp->VertexAttrib4NsvARB) {
4494 void ** procp = (void **) &disp->VertexAttrib4NsvARB;
4495 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nsv", symbol_prefix);
4496 *procp = dlsym(handle, symboln);
4497 }
4498
4499
4500 if(!disp->VertexAttrib4NsvARB) {
4501 void ** procp = (void **) &disp->VertexAttrib4NsvARB;
4502 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NsvARB", symbol_prefix);
4503 *procp = dlsym(handle, symboln);
4504 }
4505
4506
4507 if(!disp->VertexAttrib4NubARB) {
4508 void ** procp = (void **) &disp->VertexAttrib4NubARB;
4509 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nub", symbol_prefix);
4510 *procp = dlsym(handle, symboln);
4511 }
4512
4513
4514 if(!disp->VertexAttrib4NubARB) {
4515 void ** procp = (void **) &disp->VertexAttrib4NubARB;
4516 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NubARB", symbol_prefix);
4517 *procp = dlsym(handle, symboln);
4518 }
4519
4520
4521 if(!disp->VertexAttrib4NubvARB) {
4522 void ** procp = (void **) &disp->VertexAttrib4NubvARB;
4523 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nubv", symbol_prefix);
4524 *procp = dlsym(handle, symboln);
4525 }
4526
4527
4528 if(!disp->VertexAttrib4NubvARB) {
4529 void ** procp = (void **) &disp->VertexAttrib4NubvARB;
4530 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NubvARB", symbol_prefix);
4531 *procp = dlsym(handle, symboln);
4532 }
4533
4534
4535 if(!disp->VertexAttrib4NuivARB) {
4536 void ** procp = (void **) &disp->VertexAttrib4NuivARB;
4537 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nuiv", symbol_prefix);
4538 *procp = dlsym(handle, symboln);
4539 }
4540
4541
4542 if(!disp->VertexAttrib4NuivARB) {
4543 void ** procp = (void **) &disp->VertexAttrib4NuivARB;
4544 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NuivARB", symbol_prefix);
4545 *procp = dlsym(handle, symboln);
4546 }
4547
4548
4549 if(!disp->VertexAttrib4NusvARB) {
4550 void ** procp = (void **) &disp->VertexAttrib4NusvARB;
4551 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4Nusv", symbol_prefix);
4552 *procp = dlsym(handle, symboln);
4553 }
4554
4555
4556 if(!disp->VertexAttrib4NusvARB) {
4557 void ** procp = (void **) &disp->VertexAttrib4NusvARB;
4558 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4NusvARB", symbol_prefix);
4559 *procp = dlsym(handle, symboln);
4560 }
4561
4562
4563 if(!disp->VertexAttrib4bvARB) {
4564 void ** procp = (void **) &disp->VertexAttrib4bvARB;
4565 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4bv", symbol_prefix);
4566 *procp = dlsym(handle, symboln);
4567 }
4568
4569
4570 if(!disp->VertexAttrib4bvARB) {
4571 void ** procp = (void **) &disp->VertexAttrib4bvARB;
4572 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4bvARB", symbol_prefix);
4573 *procp = dlsym(handle, symboln);
4574 }
4575
4576
4577 if(!disp->VertexAttrib4dARB) {
4578 void ** procp = (void **) &disp->VertexAttrib4dARB;
4579 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4d", symbol_prefix);
4580 *procp = dlsym(handle, symboln);
4581 }
4582
4583
4584 if(!disp->VertexAttrib4dARB) {
4585 void ** procp = (void **) &disp->VertexAttrib4dARB;
4586 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dARB", symbol_prefix);
4587 *procp = dlsym(handle, symboln);
4588 }
4589
4590
4591 if(!disp->VertexAttrib4dvARB) {
4592 void ** procp = (void **) &disp->VertexAttrib4dvARB;
4593 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dv", symbol_prefix);
4594 *procp = dlsym(handle, symboln);
4595 }
4596
4597
4598 if(!disp->VertexAttrib4dvARB) {
4599 void ** procp = (void **) &disp->VertexAttrib4dvARB;
4600 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dvARB", symbol_prefix);
4601 *procp = dlsym(handle, symboln);
4602 }
4603
4604
4605 if(!disp->VertexAttrib4fARB) {
4606 void ** procp = (void **) &disp->VertexAttrib4fARB;
4607 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4f", symbol_prefix);
4608 *procp = dlsym(handle, symboln);
4609 }
4610
4611
4612 if(!disp->VertexAttrib4fARB) {
4613 void ** procp = (void **) &disp->VertexAttrib4fARB;
4614 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fARB", symbol_prefix);
4615 *procp = dlsym(handle, symboln);
4616 }
4617
4618
4619 if(!disp->VertexAttrib4fvARB) {
4620 void ** procp = (void **) &disp->VertexAttrib4fvARB;
4621 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fv", symbol_prefix);
4622 *procp = dlsym(handle, symboln);
4623 }
4624
4625
4626 if(!disp->VertexAttrib4fvARB) {
4627 void ** procp = (void **) &disp->VertexAttrib4fvARB;
4628 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fvARB", symbol_prefix);
4629 *procp = dlsym(handle, symboln);
4630 }
4631
4632
4633 if(!disp->VertexAttrib4ivARB) {
4634 void ** procp = (void **) &disp->VertexAttrib4ivARB;
4635 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4iv", symbol_prefix);
4636 *procp = dlsym(handle, symboln);
4637 }
4638
4639
4640 if(!disp->VertexAttrib4ivARB) {
4641 void ** procp = (void **) &disp->VertexAttrib4ivARB;
4642 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ivARB", symbol_prefix);
4643 *procp = dlsym(handle, symboln);
4644 }
4645
4646
4647 if(!disp->VertexAttrib4sARB) {
4648 void ** procp = (void **) &disp->VertexAttrib4sARB;
4649 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4s", symbol_prefix);
4650 *procp = dlsym(handle, symboln);
4651 }
4652
4653
4654 if(!disp->VertexAttrib4sARB) {
4655 void ** procp = (void **) &disp->VertexAttrib4sARB;
4656 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sARB", symbol_prefix);
4657 *procp = dlsym(handle, symboln);
4658 }
4659
4660
4661 if(!disp->VertexAttrib4svARB) {
4662 void ** procp = (void **) &disp->VertexAttrib4svARB;
4663 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sv", symbol_prefix);
4664 *procp = dlsym(handle, symboln);
4665 }
4666
4667
4668 if(!disp->VertexAttrib4svARB) {
4669 void ** procp = (void **) &disp->VertexAttrib4svARB;
4670 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4svARB", symbol_prefix);
4671 *procp = dlsym(handle, symboln);
4672 }
4673
4674
4675 if(!disp->VertexAttrib4ubvARB) {
4676 void ** procp = (void **) &disp->VertexAttrib4ubvARB;
4677 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubv", symbol_prefix);
4678 *procp = dlsym(handle, symboln);
4679 }
4680
4681
4682 if(!disp->VertexAttrib4ubvARB) {
4683 void ** procp = (void **) &disp->VertexAttrib4ubvARB;
4684 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubvARB", symbol_prefix);
4685 *procp = dlsym(handle, symboln);
4686 }
4687
4688
4689 if(!disp->VertexAttrib4uivARB) {
4690 void ** procp = (void **) &disp->VertexAttrib4uivARB;
4691 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4uiv", symbol_prefix);
4692 *procp = dlsym(handle, symboln);
4693 }
4694
4695
4696 if(!disp->VertexAttrib4uivARB) {
4697 void ** procp = (void **) &disp->VertexAttrib4uivARB;
4698 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4uivARB", symbol_prefix);
4699 *procp = dlsym(handle, symboln);
4700 }
4701
4702
4703 if(!disp->VertexAttrib4usvARB) {
4704 void ** procp = (void **) &disp->VertexAttrib4usvARB;
4705 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4usv", symbol_prefix);
4706 *procp = dlsym(handle, symboln);
4707 }
4708
4709
4710 if(!disp->VertexAttrib4usvARB) {
4711 void ** procp = (void **) &disp->VertexAttrib4usvARB;
4712 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4usvARB", symbol_prefix);
4713 *procp = dlsym(handle, symboln);
4714 }
4715
4716
4717 if(!disp->VertexAttribPointerARB) {
4718 void ** procp = (void **) &disp->VertexAttribPointerARB;
4719 snprintf(symboln, sizeof(symboln), "%sVertexAttribPointer", symbol_prefix);
4720 *procp = dlsym(handle, symboln);
4721 }
4722
4723
4724 if(!disp->VertexAttribPointerARB) {
4725 void ** procp = (void **) &disp->VertexAttribPointerARB;
4726 snprintf(symboln, sizeof(symboln), "%sVertexAttribPointerARB", symbol_prefix);
4727 *procp = dlsym(handle, symboln);
4728 }
4729
4730
4731 if(!disp->BindBufferARB) {
4732 void ** procp = (void **) &disp->BindBufferARB;
4733 snprintf(symboln, sizeof(symboln), "%sBindBuffer", symbol_prefix);
4734 *procp = dlsym(handle, symboln);
4735 }
4736
4737
4738 if(!disp->BindBufferARB) {
4739 void ** procp = (void **) &disp->BindBufferARB;
4740 snprintf(symboln, sizeof(symboln), "%sBindBufferARB", symbol_prefix);
4741 *procp = dlsym(handle, symboln);
4742 }
4743
4744
4745 if(!disp->BufferDataARB) {
4746 void ** procp = (void **) &disp->BufferDataARB;
4747 snprintf(symboln, sizeof(symboln), "%sBufferData", symbol_prefix);
4748 *procp = dlsym(handle, symboln);
4749 }
4750
4751
4752 if(!disp->BufferDataARB) {
4753 void ** procp = (void **) &disp->BufferDataARB;
4754 snprintf(symboln, sizeof(symboln), "%sBufferDataARB", symbol_prefix);
4755 *procp = dlsym(handle, symboln);
4756 }
4757
4758
4759 if(!disp->BufferSubDataARB) {
4760 void ** procp = (void **) &disp->BufferSubDataARB;
4761 snprintf(symboln, sizeof(symboln), "%sBufferSubData", symbol_prefix);
4762 *procp = dlsym(handle, symboln);
4763 }
4764
4765
4766 if(!disp->BufferSubDataARB) {
4767 void ** procp = (void **) &disp->BufferSubDataARB;
4768 snprintf(symboln, sizeof(symboln), "%sBufferSubDataARB", symbol_prefix);
4769 *procp = dlsym(handle, symboln);
4770 }
4771
4772
4773 if(!disp->DeleteBuffersARB) {
4774 void ** procp = (void **) &disp->DeleteBuffersARB;
4775 snprintf(symboln, sizeof(symboln), "%sDeleteBuffers", symbol_prefix);
4776 *procp = dlsym(handle, symboln);
4777 }
4778
4779
4780 if(!disp->DeleteBuffersARB) {
4781 void ** procp = (void **) &disp->DeleteBuffersARB;
4782 snprintf(symboln, sizeof(symboln), "%sDeleteBuffersARB", symbol_prefix);
4783 *procp = dlsym(handle, symboln);
4784 }
4785
4786
4787 if(!disp->GenBuffersARB) {
4788 void ** procp = (void **) &disp->GenBuffersARB;
4789 snprintf(symboln, sizeof(symboln), "%sGenBuffers", symbol_prefix);
4790 *procp = dlsym(handle, symboln);
4791 }
4792
4793
4794 if(!disp->GenBuffersARB) {
4795 void ** procp = (void **) &disp->GenBuffersARB;
4796 snprintf(symboln, sizeof(symboln), "%sGenBuffersARB", symbol_prefix);
4797 *procp = dlsym(handle, symboln);
4798 }
4799
4800
4801 if(!disp->GetBufferParameterivARB) {
4802 void ** procp = (void **) &disp->GetBufferParameterivARB;
4803 snprintf(symboln, sizeof(symboln), "%sGetBufferParameteriv", symbol_prefix);
4804 *procp = dlsym(handle, symboln);
4805 }
4806
4807
4808 if(!disp->GetBufferParameterivARB) {
4809 void ** procp = (void **) &disp->GetBufferParameterivARB;
4810 snprintf(symboln, sizeof(symboln), "%sGetBufferParameterivARB", symbol_prefix);
4811 *procp = dlsym(handle, symboln);
4812 }
4813
4814
4815 if(!disp->GetBufferPointervARB) {
4816 void ** procp = (void **) &disp->GetBufferPointervARB;
4817 snprintf(symboln, sizeof(symboln), "%sGetBufferPointerv", symbol_prefix);
4818 *procp = dlsym(handle, symboln);
4819 }
4820
4821
4822 if(!disp->GetBufferPointervARB) {
4823 void ** procp = (void **) &disp->GetBufferPointervARB;
4824 snprintf(symboln, sizeof(symboln), "%sGetBufferPointervARB", symbol_prefix);
4825 *procp = dlsym(handle, symboln);
4826 }
4827
4828
4829 if(!disp->GetBufferSubDataARB) {
4830 void ** procp = (void **) &disp->GetBufferSubDataARB;
4831 snprintf(symboln, sizeof(symboln), "%sGetBufferSubData", symbol_prefix);
4832 *procp = dlsym(handle, symboln);
4833 }
4834
4835
4836 if(!disp->GetBufferSubDataARB) {
4837 void ** procp = (void **) &disp->GetBufferSubDataARB;
4838 snprintf(symboln, sizeof(symboln), "%sGetBufferSubDataARB", symbol_prefix);
4839 *procp = dlsym(handle, symboln);
4840 }
4841
4842
4843 if(!disp->IsBufferARB) {
4844 void ** procp = (void **) &disp->IsBufferARB;
4845 snprintf(symboln, sizeof(symboln), "%sIsBuffer", symbol_prefix);
4846 *procp = dlsym(handle, symboln);
4847 }
4848
4849
4850 if(!disp->IsBufferARB) {
4851 void ** procp = (void **) &disp->IsBufferARB;
4852 snprintf(symboln, sizeof(symboln), "%sIsBufferARB", symbol_prefix);
4853 *procp = dlsym(handle, symboln);
4854 }
4855
4856
4857 if(!disp->MapBufferARB) {
4858 void ** procp = (void **) &disp->MapBufferARB;
4859 snprintf(symboln, sizeof(symboln), "%sMapBuffer", symbol_prefix);
4860 *procp = dlsym(handle, symboln);
4861 }
4862
4863
4864 if(!disp->MapBufferARB) {
4865 void ** procp = (void **) &disp->MapBufferARB;
4866 snprintf(symboln, sizeof(symboln), "%sMapBufferARB", symbol_prefix);
4867 *procp = dlsym(handle, symboln);
4868 }
4869
4870
4871 if(!disp->UnmapBufferARB) {
4872 void ** procp = (void **) &disp->UnmapBufferARB;
4873 snprintf(symboln, sizeof(symboln), "%sUnmapBuffer", symbol_prefix);
4874 *procp = dlsym(handle, symboln);
4875 }
4876
4877
4878 if(!disp->UnmapBufferARB) {
4879 void ** procp = (void **) &disp->UnmapBufferARB;
4880 snprintf(symboln, sizeof(symboln), "%sUnmapBufferARB", symbol_prefix);
4881 *procp = dlsym(handle, symboln);
4882 }
4883
4884
4885 if(!disp->BeginQueryARB) {
4886 void ** procp = (void **) &disp->BeginQueryARB;
4887 snprintf(symboln, sizeof(symboln), "%sBeginQuery", symbol_prefix);
4888 *procp = dlsym(handle, symboln);
4889 }
4890
4891
4892 if(!disp->BeginQueryARB) {
4893 void ** procp = (void **) &disp->BeginQueryARB;
4894 snprintf(symboln, sizeof(symboln), "%sBeginQueryARB", symbol_prefix);
4895 *procp = dlsym(handle, symboln);
4896 }
4897
4898
4899 if(!disp->DeleteQueriesARB) {
4900 void ** procp = (void **) &disp->DeleteQueriesARB;
4901 snprintf(symboln, sizeof(symboln), "%sDeleteQueries", symbol_prefix);
4902 *procp = dlsym(handle, symboln);
4903 }
4904
4905
4906 if(!disp->DeleteQueriesARB) {
4907 void ** procp = (void **) &disp->DeleteQueriesARB;
4908 snprintf(symboln, sizeof(symboln), "%sDeleteQueriesARB", symbol_prefix);
4909 *procp = dlsym(handle, symboln);
4910 }
4911
4912
4913 if(!disp->EndQueryARB) {
4914 void ** procp = (void **) &disp->EndQueryARB;
4915 snprintf(symboln, sizeof(symboln), "%sEndQuery", symbol_prefix);
4916 *procp = dlsym(handle, symboln);
4917 }
4918
4919
4920 if(!disp->EndQueryARB) {
4921 void ** procp = (void **) &disp->EndQueryARB;
4922 snprintf(symboln, sizeof(symboln), "%sEndQueryARB", symbol_prefix);
4923 *procp = dlsym(handle, symboln);
4924 }
4925
4926
4927 if(!disp->GenQueriesARB) {
4928 void ** procp = (void **) &disp->GenQueriesARB;
4929 snprintf(symboln, sizeof(symboln), "%sGenQueries", symbol_prefix);
4930 *procp = dlsym(handle, symboln);
4931 }
4932
4933
4934 if(!disp->GenQueriesARB) {
4935 void ** procp = (void **) &disp->GenQueriesARB;
4936 snprintf(symboln, sizeof(symboln), "%sGenQueriesARB", symbol_prefix);
4937 *procp = dlsym(handle, symboln);
4938 }
4939
4940
4941 if(!disp->GetQueryObjectivARB) {
4942 void ** procp = (void **) &disp->GetQueryObjectivARB;
4943 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectiv", symbol_prefix);
4944 *procp = dlsym(handle, symboln);
4945 }
4946
4947
4948 if(!disp->GetQueryObjectivARB) {
4949 void ** procp = (void **) &disp->GetQueryObjectivARB;
4950 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectivARB", symbol_prefix);
4951 *procp = dlsym(handle, symboln);
4952 }
4953
4954
4955 if(!disp->GetQueryObjectuivARB) {
4956 void ** procp = (void **) &disp->GetQueryObjectuivARB;
4957 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectuiv", symbol_prefix);
4958 *procp = dlsym(handle, symboln);
4959 }
4960
4961
4962 if(!disp->GetQueryObjectuivARB) {
4963 void ** procp = (void **) &disp->GetQueryObjectuivARB;
4964 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectuivARB", symbol_prefix);
4965 *procp = dlsym(handle, symboln);
4966 }
4967
4968
4969 if(!disp->GetQueryivARB) {
4970 void ** procp = (void **) &disp->GetQueryivARB;
4971 snprintf(symboln, sizeof(symboln), "%sGetQueryiv", symbol_prefix);
4972 *procp = dlsym(handle, symboln);
4973 }
4974
4975
4976 if(!disp->GetQueryivARB) {
4977 void ** procp = (void **) &disp->GetQueryivARB;
4978 snprintf(symboln, sizeof(symboln), "%sGetQueryivARB", symbol_prefix);
4979 *procp = dlsym(handle, symboln);
4980 }
4981
4982
4983 if(!disp->IsQueryARB) {
4984 void ** procp = (void **) &disp->IsQueryARB;
4985 snprintf(symboln, sizeof(symboln), "%sIsQuery", symbol_prefix);
4986 *procp = dlsym(handle, symboln);
4987 }
4988
4989
4990 if(!disp->IsQueryARB) {
4991 void ** procp = (void **) &disp->IsQueryARB;
4992 snprintf(symboln, sizeof(symboln), "%sIsQueryARB", symbol_prefix);
4993 *procp = dlsym(handle, symboln);
4994 }
4995
4996
4997 if(!disp->AttachObjectARB) {
4998 void ** procp = (void **) &disp->AttachObjectARB;
4999 snprintf(symboln, sizeof(symboln), "%sAttachObjectARB", symbol_prefix);
5000 *procp = dlsym(handle, symboln);
5001 }
5002
5003
5004 if(!disp->CompileShaderARB) {
5005 void ** procp = (void **) &disp->CompileShaderARB;
5006 snprintf(symboln, sizeof(symboln), "%sCompileShader", symbol_prefix);
5007 *procp = dlsym(handle, symboln);
5008 }
5009
5010
5011 if(!disp->CompileShaderARB) {
5012 void ** procp = (void **) &disp->CompileShaderARB;
5013 snprintf(symboln, sizeof(symboln), "%sCompileShaderARB", symbol_prefix);
5014 *procp = dlsym(handle, symboln);
5015 }
5016
5017
5018 if(!disp->CreateProgramObjectARB) {
5019 void ** procp = (void **) &disp->CreateProgramObjectARB;
5020 snprintf(symboln, sizeof(symboln), "%sCreateProgramObjectARB", symbol_prefix);
5021 *procp = dlsym(handle, symboln);
5022 }
5023
5024
5025 if(!disp->CreateShaderObjectARB) {
5026 void ** procp = (void **) &disp->CreateShaderObjectARB;
5027 snprintf(symboln, sizeof(symboln), "%sCreateShaderObjectARB", symbol_prefix);
5028 *procp = dlsym(handle, symboln);
5029 }
5030
5031
5032 if(!disp->DeleteObjectARB) {
5033 void ** procp = (void **) &disp->DeleteObjectARB;
5034 snprintf(symboln, sizeof(symboln), "%sDeleteObjectARB", symbol_prefix);
5035 *procp = dlsym(handle, symboln);
5036 }
5037
5038
5039 if(!disp->DetachObjectARB) {
5040 void ** procp = (void **) &disp->DetachObjectARB;
5041 snprintf(symboln, sizeof(symboln), "%sDetachObjectARB", symbol_prefix);
5042 *procp = dlsym(handle, symboln);
5043 }
5044
5045
5046 if(!disp->GetActiveUniformARB) {
5047 void ** procp = (void **) &disp->GetActiveUniformARB;
5048 snprintf(symboln, sizeof(symboln), "%sGetActiveUniform", symbol_prefix);
5049 *procp = dlsym(handle, symboln);
5050 }
5051
5052
5053 if(!disp->GetActiveUniformARB) {
5054 void ** procp = (void **) &disp->GetActiveUniformARB;
5055 snprintf(symboln, sizeof(symboln), "%sGetActiveUniformARB", symbol_prefix);
5056 *procp = dlsym(handle, symboln);
5057 }
5058
5059
5060 if(!disp->GetAttachedObjectsARB) {
5061 void ** procp = (void **) &disp->GetAttachedObjectsARB;
5062 snprintf(symboln, sizeof(symboln), "%sGetAttachedObjectsARB", symbol_prefix);
5063 *procp = dlsym(handle, symboln);
5064 }
5065
5066
5067 if(!disp->GetHandleARB) {
5068 void ** procp = (void **) &disp->GetHandleARB;
5069 snprintf(symboln, sizeof(symboln), "%sGetHandleARB", symbol_prefix);
5070 *procp = dlsym(handle, symboln);
5071 }
5072
5073
5074 if(!disp->GetInfoLogARB) {
5075 void ** procp = (void **) &disp->GetInfoLogARB;
5076 snprintf(symboln, sizeof(symboln), "%sGetInfoLogARB", symbol_prefix);
5077 *procp = dlsym(handle, symboln);
5078 }
5079
5080
5081 if(!disp->GetObjectParameterfvARB) {
5082 void ** procp = (void **) &disp->GetObjectParameterfvARB;
5083 snprintf(symboln, sizeof(symboln), "%sGetObjectParameterfvARB", symbol_prefix);
5084 *procp = dlsym(handle, symboln);
5085 }
5086
5087
5088 if(!disp->GetObjectParameterivARB) {
5089 void ** procp = (void **) &disp->GetObjectParameterivARB;
5090 snprintf(symboln, sizeof(symboln), "%sGetObjectParameterivARB", symbol_prefix);
5091 *procp = dlsym(handle, symboln);
5092 }
5093
5094
5095 if(!disp->GetShaderSourceARB) {
5096 void ** procp = (void **) &disp->GetShaderSourceARB;
5097 snprintf(symboln, sizeof(symboln), "%sGetShaderSource", symbol_prefix);
5098 *procp = dlsym(handle, symboln);
5099 }
5100
5101
5102 if(!disp->GetShaderSourceARB) {
5103 void ** procp = (void **) &disp->GetShaderSourceARB;
5104 snprintf(symboln, sizeof(symboln), "%sGetShaderSourceARB", symbol_prefix);
5105 *procp = dlsym(handle, symboln);
5106 }
5107
5108
5109 if(!disp->GetUniformLocationARB) {
5110 void ** procp = (void **) &disp->GetUniformLocationARB;
5111 snprintf(symboln, sizeof(symboln), "%sGetUniformLocation", symbol_prefix);
5112 *procp = dlsym(handle, symboln);
5113 }
5114
5115
5116 if(!disp->GetUniformLocationARB) {
5117 void ** procp = (void **) &disp->GetUniformLocationARB;
5118 snprintf(symboln, sizeof(symboln), "%sGetUniformLocationARB", symbol_prefix);
5119 *procp = dlsym(handle, symboln);
5120 }
5121
5122
5123 if(!disp->GetUniformfvARB) {
5124 void ** procp = (void **) &disp->GetUniformfvARB;
5125 snprintf(symboln, sizeof(symboln), "%sGetUniformfv", symbol_prefix);
5126 *procp = dlsym(handle, symboln);
5127 }
5128
5129
5130 if(!disp->GetUniformfvARB) {
5131 void ** procp = (void **) &disp->GetUniformfvARB;
5132 snprintf(symboln, sizeof(symboln), "%sGetUniformfvARB", symbol_prefix);
5133 *procp = dlsym(handle, symboln);
5134 }
5135
5136
5137 if(!disp->GetUniformivARB) {
5138 void ** procp = (void **) &disp->GetUniformivARB;
5139 snprintf(symboln, sizeof(symboln), "%sGetUniformiv", symbol_prefix);
5140 *procp = dlsym(handle, symboln);
5141 }
5142
5143
5144 if(!disp->GetUniformivARB) {
5145 void ** procp = (void **) &disp->GetUniformivARB;
5146 snprintf(symboln, sizeof(symboln), "%sGetUniformivARB", symbol_prefix);
5147 *procp = dlsym(handle, symboln);
5148 }
5149
5150
5151 if(!disp->LinkProgramARB) {
5152 void ** procp = (void **) &disp->LinkProgramARB;
5153 snprintf(symboln, sizeof(symboln), "%sLinkProgram", symbol_prefix);
5154 *procp = dlsym(handle, symboln);
5155 }
5156
5157
5158 if(!disp->LinkProgramARB) {
5159 void ** procp = (void **) &disp->LinkProgramARB;
5160 snprintf(symboln, sizeof(symboln), "%sLinkProgramARB", symbol_prefix);
5161 *procp = dlsym(handle, symboln);
5162 }
5163
5164
5165 if(!disp->ShaderSourceARB) {
5166 void ** procp = (void **) &disp->ShaderSourceARB;
5167 snprintf(symboln, sizeof(symboln), "%sShaderSource", symbol_prefix);
5168 *procp = dlsym(handle, symboln);
5169 }
5170
5171
5172 if(!disp->ShaderSourceARB) {
5173 void ** procp = (void **) &disp->ShaderSourceARB;
5174 snprintf(symboln, sizeof(symboln), "%sShaderSourceARB", symbol_prefix);
5175 *procp = dlsym(handle, symboln);
5176 }
5177
5178
5179 if(!disp->Uniform1fARB) {
5180 void ** procp = (void **) &disp->Uniform1fARB;
5181 snprintf(symboln, sizeof(symboln), "%sUniform1f", symbol_prefix);
5182 *procp = dlsym(handle, symboln);
5183 }
5184
5185
5186 if(!disp->Uniform1fARB) {
5187 void ** procp = (void **) &disp->Uniform1fARB;
5188 snprintf(symboln, sizeof(symboln), "%sUniform1fARB", symbol_prefix);
5189 *procp = dlsym(handle, symboln);
5190 }
5191
5192
5193 if(!disp->Uniform1fvARB) {
5194 void ** procp = (void **) &disp->Uniform1fvARB;
5195 snprintf(symboln, sizeof(symboln), "%sUniform1fv", symbol_prefix);
5196 *procp = dlsym(handle, symboln);
5197 }
5198
5199
5200 if(!disp->Uniform1fvARB) {
5201 void ** procp = (void **) &disp->Uniform1fvARB;
5202 snprintf(symboln, sizeof(symboln), "%sUniform1fvARB", symbol_prefix);
5203 *procp = dlsym(handle, symboln);
5204 }
5205
5206
5207 if(!disp->Uniform1iARB) {
5208 void ** procp = (void **) &disp->Uniform1iARB;
5209 snprintf(symboln, sizeof(symboln), "%sUniform1i", symbol_prefix);
5210 *procp = dlsym(handle, symboln);
5211 }
5212
5213
5214 if(!disp->Uniform1iARB) {
5215 void ** procp = (void **) &disp->Uniform1iARB;
5216 snprintf(symboln, sizeof(symboln), "%sUniform1iARB", symbol_prefix);
5217 *procp = dlsym(handle, symboln);
5218 }
5219
5220
5221 if(!disp->Uniform1ivARB) {
5222 void ** procp = (void **) &disp->Uniform1ivARB;
5223 snprintf(symboln, sizeof(symboln), "%sUniform1iv", symbol_prefix);
5224 *procp = dlsym(handle, symboln);
5225 }
5226
5227
5228 if(!disp->Uniform1ivARB) {
5229 void ** procp = (void **) &disp->Uniform1ivARB;
5230 snprintf(symboln, sizeof(symboln), "%sUniform1ivARB", symbol_prefix);
5231 *procp = dlsym(handle, symboln);
5232 }
5233
5234
5235 if(!disp->Uniform2fARB) {
5236 void ** procp = (void **) &disp->Uniform2fARB;
5237 snprintf(symboln, sizeof(symboln), "%sUniform2f", symbol_prefix);
5238 *procp = dlsym(handle, symboln);
5239 }
5240
5241
5242 if(!disp->Uniform2fARB) {
5243 void ** procp = (void **) &disp->Uniform2fARB;
5244 snprintf(symboln, sizeof(symboln), "%sUniform2fARB", symbol_prefix);
5245 *procp = dlsym(handle, symboln);
5246 }
5247
5248
5249 if(!disp->Uniform2fvARB) {
5250 void ** procp = (void **) &disp->Uniform2fvARB;
5251 snprintf(symboln, sizeof(symboln), "%sUniform2fv", symbol_prefix);
5252 *procp = dlsym(handle, symboln);
5253 }
5254
5255
5256 if(!disp->Uniform2fvARB) {
5257 void ** procp = (void **) &disp->Uniform2fvARB;
5258 snprintf(symboln, sizeof(symboln), "%sUniform2fvARB", symbol_prefix);
5259 *procp = dlsym(handle, symboln);
5260 }
5261
5262
5263 if(!disp->Uniform2iARB) {
5264 void ** procp = (void **) &disp->Uniform2iARB;
5265 snprintf(symboln, sizeof(symboln), "%sUniform2i", symbol_prefix);
5266 *procp = dlsym(handle, symboln);
5267 }
5268
5269
5270 if(!disp->Uniform2iARB) {
5271 void ** procp = (void **) &disp->Uniform2iARB;
5272 snprintf(symboln, sizeof(symboln), "%sUniform2iARB", symbol_prefix);
5273 *procp = dlsym(handle, symboln);
5274 }
5275
5276
5277 if(!disp->Uniform2ivARB) {
5278 void ** procp = (void **) &disp->Uniform2ivARB;
5279 snprintf(symboln, sizeof(symboln), "%sUniform2iv", symbol_prefix);
5280 *procp = dlsym(handle, symboln);
5281 }
5282
5283
5284 if(!disp->Uniform2ivARB) {
5285 void ** procp = (void **) &disp->Uniform2ivARB;
5286 snprintf(symboln, sizeof(symboln), "%sUniform2ivARB", symbol_prefix);
5287 *procp = dlsym(handle, symboln);
5288 }
5289
5290
5291 if(!disp->Uniform3fARB) {
5292 void ** procp = (void **) &disp->Uniform3fARB;
5293 snprintf(symboln, sizeof(symboln), "%sUniform3f", symbol_prefix);
5294 *procp = dlsym(handle, symboln);
5295 }
5296
5297
5298 if(!disp->Uniform3fARB) {
5299 void ** procp = (void **) &disp->Uniform3fARB;
5300 snprintf(symboln, sizeof(symboln), "%sUniform3fARB", symbol_prefix);
5301 *procp = dlsym(handle, symboln);
5302 }
5303
5304
5305 if(!disp->Uniform3fvARB) {
5306 void ** procp = (void **) &disp->Uniform3fvARB;
5307 snprintf(symboln, sizeof(symboln), "%sUniform3fv", symbol_prefix);
5308 *procp = dlsym(handle, symboln);
5309 }
5310
5311
5312 if(!disp->Uniform3fvARB) {
5313 void ** procp = (void **) &disp->Uniform3fvARB;
5314 snprintf(symboln, sizeof(symboln), "%sUniform3fvARB", symbol_prefix);
5315 *procp = dlsym(handle, symboln);
5316 }
5317
5318
5319 if(!disp->Uniform3iARB) {
5320 void ** procp = (void **) &disp->Uniform3iARB;
5321 snprintf(symboln, sizeof(symboln), "%sUniform3i", symbol_prefix);
5322 *procp = dlsym(handle, symboln);
5323 }
5324
5325
5326 if(!disp->Uniform3iARB) {
5327 void ** procp = (void **) &disp->Uniform3iARB;
5328 snprintf(symboln, sizeof(symboln), "%sUniform3iARB", symbol_prefix);
5329 *procp = dlsym(handle, symboln);
5330 }
5331
5332
5333 if(!disp->Uniform3ivARB) {
5334 void ** procp = (void **) &disp->Uniform3ivARB;
5335 snprintf(symboln, sizeof(symboln), "%sUniform3iv", symbol_prefix);
5336 *procp = dlsym(handle, symboln);
5337 }
5338
5339
5340 if(!disp->Uniform3ivARB) {
5341 void ** procp = (void **) &disp->Uniform3ivARB;
5342 snprintf(symboln, sizeof(symboln), "%sUniform3ivARB", symbol_prefix);
5343 *procp = dlsym(handle, symboln);
5344 }
5345
5346
5347 if(!disp->Uniform4fARB) {
5348 void ** procp = (void **) &disp->Uniform4fARB;
5349 snprintf(symboln, sizeof(symboln), "%sUniform4f", symbol_prefix);
5350 *procp = dlsym(handle, symboln);
5351 }
5352
5353
5354 if(!disp->Uniform4fARB) {
5355 void ** procp = (void **) &disp->Uniform4fARB;
5356 snprintf(symboln, sizeof(symboln), "%sUniform4fARB", symbol_prefix);
5357 *procp = dlsym(handle, symboln);
5358 }
5359
5360
5361 if(!disp->Uniform4fvARB) {
5362 void ** procp = (void **) &disp->Uniform4fvARB;
5363 snprintf(symboln, sizeof(symboln), "%sUniform4fv", symbol_prefix);
5364 *procp = dlsym(handle, symboln);
5365 }
5366
5367
5368 if(!disp->Uniform4fvARB) {
5369 void ** procp = (void **) &disp->Uniform4fvARB;
5370 snprintf(symboln, sizeof(symboln), "%sUniform4fvARB", symbol_prefix);
5371 *procp = dlsym(handle, symboln);
5372 }
5373
5374
5375 if(!disp->Uniform4iARB) {
5376 void ** procp = (void **) &disp->Uniform4iARB;
5377 snprintf(symboln, sizeof(symboln), "%sUniform4i", symbol_prefix);
5378 *procp = dlsym(handle, symboln);
5379 }
5380
5381
5382 if(!disp->Uniform4iARB) {
5383 void ** procp = (void **) &disp->Uniform4iARB;
5384 snprintf(symboln, sizeof(symboln), "%sUniform4iARB", symbol_prefix);
5385 *procp = dlsym(handle, symboln);
5386 }
5387
5388
5389 if(!disp->Uniform4ivARB) {
5390 void ** procp = (void **) &disp->Uniform4ivARB;
5391 snprintf(symboln, sizeof(symboln), "%sUniform4iv", symbol_prefix);
5392 *procp = dlsym(handle, symboln);
5393 }
5394
5395
5396 if(!disp->Uniform4ivARB) {
5397 void ** procp = (void **) &disp->Uniform4ivARB;
5398 snprintf(symboln, sizeof(symboln), "%sUniform4ivARB", symbol_prefix);
5399 *procp = dlsym(handle, symboln);
5400 }
5401
5402
5403 if(!disp->UniformMatrix2fvARB) {
5404 void ** procp = (void **) &disp->UniformMatrix2fvARB;
5405 snprintf(symboln, sizeof(symboln), "%sUniformMatrix2fv", symbol_prefix);
5406 *procp = dlsym(handle, symboln);
5407 }
5408
5409
5410 if(!disp->UniformMatrix2fvARB) {
5411 void ** procp = (void **) &disp->UniformMatrix2fvARB;
5412 snprintf(symboln, sizeof(symboln), "%sUniformMatrix2fvARB", symbol_prefix);
5413 *procp = dlsym(handle, symboln);
5414 }
5415
5416
5417 if(!disp->UniformMatrix3fvARB) {
5418 void ** procp = (void **) &disp->UniformMatrix3fvARB;
5419 snprintf(symboln, sizeof(symboln), "%sUniformMatrix3fv", symbol_prefix);
5420 *procp = dlsym(handle, symboln);
5421 }
5422
5423
5424 if(!disp->UniformMatrix3fvARB) {
5425 void ** procp = (void **) &disp->UniformMatrix3fvARB;
5426 snprintf(symboln, sizeof(symboln), "%sUniformMatrix3fvARB", symbol_prefix);
5427 *procp = dlsym(handle, symboln);
5428 }
5429
5430
5431 if(!disp->UniformMatrix4fvARB) {
5432 void ** procp = (void **) &disp->UniformMatrix4fvARB;
5433 snprintf(symboln, sizeof(symboln), "%sUniformMatrix4fv", symbol_prefix);
5434 *procp = dlsym(handle, symboln);
5435 }
5436
5437
5438 if(!disp->UniformMatrix4fvARB) {
5439 void ** procp = (void **) &disp->UniformMatrix4fvARB;
5440 snprintf(symboln, sizeof(symboln), "%sUniformMatrix4fvARB", symbol_prefix);
5441 *procp = dlsym(handle, symboln);
5442 }
5443
5444
5445 if(!disp->UseProgramObjectARB) {
5446 void ** procp = (void **) &disp->UseProgramObjectARB;
5447 snprintf(symboln, sizeof(symboln), "%sUseProgram", symbol_prefix);
5448 *procp = dlsym(handle, symboln);
5449 }
5450
5451
5452 if(!disp->UseProgramObjectARB) {
5453 void ** procp = (void **) &disp->UseProgramObjectARB;
5454 snprintf(symboln, sizeof(symboln), "%sUseProgramObjectARB", symbol_prefix);
5455 *procp = dlsym(handle, symboln);
5456 }
5457
5458
5459 if(!disp->ValidateProgramARB) {
5460 void ** procp = (void **) &disp->ValidateProgramARB;
5461 snprintf(symboln, sizeof(symboln), "%sValidateProgram", symbol_prefix);
5462 *procp = dlsym(handle, symboln);
5463 }
5464
5465
5466 if(!disp->ValidateProgramARB) {
5467 void ** procp = (void **) &disp->ValidateProgramARB;
5468 snprintf(symboln, sizeof(symboln), "%sValidateProgramARB", symbol_prefix);
5469 *procp = dlsym(handle, symboln);
5470 }
5471
5472
5473 if(!disp->BindAttribLocationARB) {
5474 void ** procp = (void **) &disp->BindAttribLocationARB;
5475 snprintf(symboln, sizeof(symboln), "%sBindAttribLocation", symbol_prefix);
5476 *procp = dlsym(handle, symboln);
5477 }
5478
5479
5480 if(!disp->BindAttribLocationARB) {
5481 void ** procp = (void **) &disp->BindAttribLocationARB;
5482 snprintf(symboln, sizeof(symboln), "%sBindAttribLocationARB", symbol_prefix);
5483 *procp = dlsym(handle, symboln);
5484 }
5485
5486
5487 if(!disp->GetActiveAttribARB) {
5488 void ** procp = (void **) &disp->GetActiveAttribARB;
5489 snprintf(symboln, sizeof(symboln), "%sGetActiveAttrib", symbol_prefix);
5490 *procp = dlsym(handle, symboln);
5491 }
5492
5493
5494 if(!disp->GetActiveAttribARB) {
5495 void ** procp = (void **) &disp->GetActiveAttribARB;
5496 snprintf(symboln, sizeof(symboln), "%sGetActiveAttribARB", symbol_prefix);
5497 *procp = dlsym(handle, symboln);
5498 }
5499
5500
5501 if(!disp->GetAttribLocationARB) {
5502 void ** procp = (void **) &disp->GetAttribLocationARB;
5503 snprintf(symboln, sizeof(symboln), "%sGetAttribLocation", symbol_prefix);
5504 *procp = dlsym(handle, symboln);
5505 }
5506
5507
5508 if(!disp->GetAttribLocationARB) {
5509 void ** procp = (void **) &disp->GetAttribLocationARB;
5510 snprintf(symboln, sizeof(symboln), "%sGetAttribLocationARB", symbol_prefix);
5511 *procp = dlsym(handle, symboln);
5512 }
5513
5514
5515 if(!disp->DrawBuffersARB) {
5516 void ** procp = (void **) &disp->DrawBuffersARB;
5517 snprintf(symboln, sizeof(symboln), "%sDrawBuffers", symbol_prefix);
5518 *procp = dlsym(handle, symboln);
5519 }
5520
5521
5522 if(!disp->DrawBuffersARB) {
5523 void ** procp = (void **) &disp->DrawBuffersARB;
5524 snprintf(symboln, sizeof(symboln), "%sDrawBuffersARB", symbol_prefix);
5525 *procp = dlsym(handle, symboln);
5526 }
5527
5528
5529 if(!disp->DrawBuffersARB) {
5530 void ** procp = (void **) &disp->DrawBuffersARB;
5531 snprintf(symboln, sizeof(symboln), "%sDrawBuffersATI", symbol_prefix);
5532 *procp = dlsym(handle, symboln);
5533 }
5534
5535
5536 if(!disp->ClampColorARB) {
5537 void ** procp = (void **) &disp->ClampColorARB;
5538 snprintf(symboln, sizeof(symboln), "%sClampColorARB", symbol_prefix);
5539 *procp = dlsym(handle, symboln);
5540 }
5541
5542
5543 if(!disp->DrawArraysInstancedARB) {
5544 void ** procp = (void **) &disp->DrawArraysInstancedARB;
5545 snprintf(symboln, sizeof(symboln), "%sDrawArraysInstancedARB", symbol_prefix);
5546 *procp = dlsym(handle, symboln);
5547 }
5548
5549
5550 if(!disp->DrawArraysInstancedARB) {
5551 void ** procp = (void **) &disp->DrawArraysInstancedARB;
5552 snprintf(symboln, sizeof(symboln), "%sDrawArraysInstancedEXT", symbol_prefix);
5553 *procp = dlsym(handle, symboln);
5554 }
5555
5556
5557 if(!disp->DrawArraysInstancedARB) {
5558 void ** procp = (void **) &disp->DrawArraysInstancedARB;
5559 snprintf(symboln, sizeof(symboln), "%sDrawArraysInstanced", symbol_prefix);
5560 *procp = dlsym(handle, symboln);
5561 }
5562
5563
5564 if(!disp->DrawElementsInstancedARB) {
5565 void ** procp = (void **) &disp->DrawElementsInstancedARB;
5566 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedARB", symbol_prefix);
5567 *procp = dlsym(handle, symboln);
5568 }
5569
5570
5571 if(!disp->DrawElementsInstancedARB) {
5572 void ** procp = (void **) &disp->DrawElementsInstancedARB;
5573 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedEXT", symbol_prefix);
5574 *procp = dlsym(handle, symboln);
5575 }
5576
5577
5578 if(!disp->DrawElementsInstancedARB) {
5579 void ** procp = (void **) &disp->DrawElementsInstancedARB;
5580 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstanced", symbol_prefix);
5581 *procp = dlsym(handle, symboln);
5582 }
5583
5584
5585 if(!disp->RenderbufferStorageMultisample) {
5586 void ** procp = (void **) &disp->RenderbufferStorageMultisample;
5587 snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageMultisample", symbol_prefix);
5588 *procp = dlsym(handle, symboln);
5589 }
5590
5591
5592 if(!disp->RenderbufferStorageMultisample) {
5593 void ** procp = (void **) &disp->RenderbufferStorageMultisample;
5594 snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageMultisampleEXT", symbol_prefix);
5595 *procp = dlsym(handle, symboln);
5596 }
5597
5598
5599 if(!disp->FramebufferTextureARB) {
5600 void ** procp = (void **) &disp->FramebufferTextureARB;
5601 snprintf(symboln, sizeof(symboln), "%sFramebufferTextureARB", symbol_prefix);
5602 *procp = dlsym(handle, symboln);
5603 }
5604
5605
5606 if(!disp->FramebufferTextureFaceARB) {
5607 void ** procp = (void **) &disp->FramebufferTextureFaceARB;
5608 snprintf(symboln, sizeof(symboln), "%sFramebufferTextureFaceARB", symbol_prefix);
5609 *procp = dlsym(handle, symboln);
5610 }
5611
5612
5613 if(!disp->ProgramParameteriARB) {
5614 void ** procp = (void **) &disp->ProgramParameteriARB;
5615 snprintf(symboln, sizeof(symboln), "%sProgramParameteriARB", symbol_prefix);
5616 *procp = dlsym(handle, symboln);
5617 }
5618
5619
5620 if(!disp->VertexAttribDivisorARB) {
5621 void ** procp = (void **) &disp->VertexAttribDivisorARB;
5622 snprintf(symboln, sizeof(symboln), "%sVertexAttribDivisorARB", symbol_prefix);
5623 *procp = dlsym(handle, symboln);
5624 }
5625
5626
5627 if(!disp->FlushMappedBufferRange) {
5628 void ** procp = (void **) &disp->FlushMappedBufferRange;
5629 snprintf(symboln, sizeof(symboln), "%sFlushMappedBufferRange", symbol_prefix);
5630 *procp = dlsym(handle, symboln);
5631 }
5632
5633
5634 if(!disp->MapBufferRange) {
5635 void ** procp = (void **) &disp->MapBufferRange;
5636 snprintf(symboln, sizeof(symboln), "%sMapBufferRange", symbol_prefix);
5637 *procp = dlsym(handle, symboln);
5638 }
5639
5640
5641 if(!disp->TexBufferARB) {
5642 void ** procp = (void **) &disp->TexBufferARB;
5643 snprintf(symboln, sizeof(symboln), "%sTexBufferARB", symbol_prefix);
5644 *procp = dlsym(handle, symboln);
5645 }
5646
5647
5648 if(!disp->TexBufferARB) {
5649 void ** procp = (void **) &disp->TexBufferARB;
5650 snprintf(symboln, sizeof(symboln), "%sTexBuffer", symbol_prefix);
5651 *procp = dlsym(handle, symboln);
5652 }
5653
5654
5655 if(!disp->BindVertexArray) {
5656 void ** procp = (void **) &disp->BindVertexArray;
5657 snprintf(symboln, sizeof(symboln), "%sBindVertexArray", symbol_prefix);
5658 *procp = dlsym(handle, symboln);
5659 }
5660
5661
5662 if(!disp->GenVertexArrays) {
5663 void ** procp = (void **) &disp->GenVertexArrays;
5664 snprintf(symboln, sizeof(symboln), "%sGenVertexArrays", symbol_prefix);
5665 *procp = dlsym(handle, symboln);
5666 }
5667
5668
5669 if(!disp->GetActiveUniformBlockName) {
5670 void ** procp = (void **) &disp->GetActiveUniformBlockName;
5671 snprintf(symboln, sizeof(symboln), "%sGetActiveUniformBlockName", symbol_prefix);
5672 *procp = dlsym(handle, symboln);
5673 }
5674
5675
5676 if(!disp->GetActiveUniformBlockiv) {
5677 void ** procp = (void **) &disp->GetActiveUniformBlockiv;
5678 snprintf(symboln, sizeof(symboln), "%sGetActiveUniformBlockiv", symbol_prefix);
5679 *procp = dlsym(handle, symboln);
5680 }
5681
5682
5683 if(!disp->GetActiveUniformName) {
5684 void ** procp = (void **) &disp->GetActiveUniformName;
5685 snprintf(symboln, sizeof(symboln), "%sGetActiveUniformName", symbol_prefix);
5686 *procp = dlsym(handle, symboln);
5687 }
5688
5689
5690 if(!disp->GetActiveUniformsiv) {
5691 void ** procp = (void **) &disp->GetActiveUniformsiv;
5692 snprintf(symboln, sizeof(symboln), "%sGetActiveUniformsiv", symbol_prefix);
5693 *procp = dlsym(handle, symboln);
5694 }
5695
5696
5697 if(!disp->GetUniformBlockIndex) {
5698 void ** procp = (void **) &disp->GetUniformBlockIndex;
5699 snprintf(symboln, sizeof(symboln), "%sGetUniformBlockIndex", symbol_prefix);
5700 *procp = dlsym(handle, symboln);
5701 }
5702
5703
5704 if(!disp->GetUniformIndices) {
5705 void ** procp = (void **) &disp->GetUniformIndices;
5706 snprintf(symboln, sizeof(symboln), "%sGetUniformIndices", symbol_prefix);
5707 *procp = dlsym(handle, symboln);
5708 }
5709
5710
5711 if(!disp->UniformBlockBinding) {
5712 void ** procp = (void **) &disp->UniformBlockBinding;
5713 snprintf(symboln, sizeof(symboln), "%sUniformBlockBinding", symbol_prefix);
5714 *procp = dlsym(handle, symboln);
5715 }
5716
5717
5718 if(!disp->CopyBufferSubData) {
5719 void ** procp = (void **) &disp->CopyBufferSubData;
5720 snprintf(symboln, sizeof(symboln), "%sCopyBufferSubData", symbol_prefix);
5721 *procp = dlsym(handle, symboln);
5722 }
5723
5724
5725 if(!disp->ClientWaitSync) {
5726 void ** procp = (void **) &disp->ClientWaitSync;
5727 snprintf(symboln, sizeof(symboln), "%sClientWaitSync", symbol_prefix);
5728 *procp = dlsym(handle, symboln);
5729 }
5730
5731
5732 if(!disp->DeleteSync) {
5733 void ** procp = (void **) &disp->DeleteSync;
5734 snprintf(symboln, sizeof(symboln), "%sDeleteSync", symbol_prefix);
5735 *procp = dlsym(handle, symboln);
5736 }
5737
5738
5739 if(!disp->FenceSync) {
5740 void ** procp = (void **) &disp->FenceSync;
5741 snprintf(symboln, sizeof(symboln), "%sFenceSync", symbol_prefix);
5742 *procp = dlsym(handle, symboln);
5743 }
5744
5745
5746 if(!disp->GetInteger64v) {
5747 void ** procp = (void **) &disp->GetInteger64v;
5748 snprintf(symboln, sizeof(symboln), "%sGetInteger64v", symbol_prefix);
5749 *procp = dlsym(handle, symboln);
5750 }
5751
5752
5753 if(!disp->GetSynciv) {
5754 void ** procp = (void **) &disp->GetSynciv;
5755 snprintf(symboln, sizeof(symboln), "%sGetSynciv", symbol_prefix);
5756 *procp = dlsym(handle, symboln);
5757 }
5758
5759
5760 if(!disp->IsSync) {
5761 void ** procp = (void **) &disp->IsSync;
5762 snprintf(symboln, sizeof(symboln), "%sIsSync", symbol_prefix);
5763 *procp = dlsym(handle, symboln);
5764 }
5765
5766
5767 if(!disp->WaitSync) {
5768 void ** procp = (void **) &disp->WaitSync;
5769 snprintf(symboln, sizeof(symboln), "%sWaitSync", symbol_prefix);
5770 *procp = dlsym(handle, symboln);
5771 }
5772
5773
5774 if(!disp->DrawElementsBaseVertex) {
5775 void ** procp = (void **) &disp->DrawElementsBaseVertex;
5776 snprintf(symboln, sizeof(symboln), "%sDrawElementsBaseVertex", symbol_prefix);
5777 *procp = dlsym(handle, symboln);
5778 }
5779
5780
5781 if(!disp->DrawElementsInstancedBaseVertex) {
5782 void ** procp = (void **) &disp->DrawElementsInstancedBaseVertex;
5783 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedBaseVertex", symbol_prefix);
5784 *procp = dlsym(handle, symboln);
5785 }
5786
5787
5788 if(!disp->DrawRangeElementsBaseVertex) {
5789 void ** procp = (void **) &disp->DrawRangeElementsBaseVertex;
5790 snprintf(symboln, sizeof(symboln), "%sDrawRangeElementsBaseVertex", symbol_prefix);
5791 *procp = dlsym(handle, symboln);
5792 }
5793
5794
5795 if(!disp->MultiDrawElementsBaseVertex) {
5796 void ** procp = (void **) &disp->MultiDrawElementsBaseVertex;
5797 snprintf(symboln, sizeof(symboln), "%sMultiDrawElementsBaseVertex", symbol_prefix);
5798 *procp = dlsym(handle, symboln);
5799 }
5800
5801
5802 if(!disp->BlendEquationSeparateiARB) {
5803 void ** procp = (void **) &disp->BlendEquationSeparateiARB;
5804 snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateiARB", symbol_prefix);
5805 *procp = dlsym(handle, symboln);
5806 }
5807
5808
5809 if(!disp->BlendEquationSeparateiARB) {
5810 void ** procp = (void **) &disp->BlendEquationSeparateiARB;
5811 snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateIndexedAMD", symbol_prefix);
5812 *procp = dlsym(handle, symboln);
5813 }
5814
5815
5816 if(!disp->BlendEquationiARB) {
5817 void ** procp = (void **) &disp->BlendEquationiARB;
5818 snprintf(symboln, sizeof(symboln), "%sBlendEquationiARB", symbol_prefix);
5819 *procp = dlsym(handle, symboln);
5820 }
5821
5822
5823 if(!disp->BlendEquationiARB) {
5824 void ** procp = (void **) &disp->BlendEquationiARB;
5825 snprintf(symboln, sizeof(symboln), "%sBlendEquationIndexedAMD", symbol_prefix);
5826 *procp = dlsym(handle, symboln);
5827 }
5828
5829
5830 if(!disp->BlendFuncSeparateiARB) {
5831 void ** procp = (void **) &disp->BlendFuncSeparateiARB;
5832 snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateiARB", symbol_prefix);
5833 *procp = dlsym(handle, symboln);
5834 }
5835
5836
5837 if(!disp->BlendFuncSeparateiARB) {
5838 void ** procp = (void **) &disp->BlendFuncSeparateiARB;
5839 snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateIndexedAMD", symbol_prefix);
5840 *procp = dlsym(handle, symboln);
5841 }
5842
5843
5844 if(!disp->BlendFunciARB) {
5845 void ** procp = (void **) &disp->BlendFunciARB;
5846 snprintf(symboln, sizeof(symboln), "%sBlendFunciARB", symbol_prefix);
5847 *procp = dlsym(handle, symboln);
5848 }
5849
5850
5851 if(!disp->BlendFunciARB) {
5852 void ** procp = (void **) &disp->BlendFunciARB;
5853 snprintf(symboln, sizeof(symboln), "%sBlendFuncIndexedAMD", symbol_prefix);
5854 *procp = dlsym(handle, symboln);
5855 }
5856
5857
5858 if(!disp->BindFragDataLocationIndexed) {
5859 void ** procp = (void **) &disp->BindFragDataLocationIndexed;
5860 snprintf(symboln, sizeof(symboln), "%sBindFragDataLocationIndexed", symbol_prefix);
5861 *procp = dlsym(handle, symboln);
5862 }
5863
5864
5865 if(!disp->GetFragDataIndex) {
5866 void ** procp = (void **) &disp->GetFragDataIndex;
5867 snprintf(symboln, sizeof(symboln), "%sGetFragDataIndex", symbol_prefix);
5868 *procp = dlsym(handle, symboln);
5869 }
5870
5871
5872 if(!disp->BindSampler) {
5873 void ** procp = (void **) &disp->BindSampler;
5874 snprintf(symboln, sizeof(symboln), "%sBindSampler", symbol_prefix);
5875 *procp = dlsym(handle, symboln);
5876 }
5877
5878
5879 if(!disp->DeleteSamplers) {
5880 void ** procp = (void **) &disp->DeleteSamplers;
5881 snprintf(symboln, sizeof(symboln), "%sDeleteSamplers", symbol_prefix);
5882 *procp = dlsym(handle, symboln);
5883 }
5884
5885
5886 if(!disp->GenSamplers) {
5887 void ** procp = (void **) &disp->GenSamplers;
5888 snprintf(symboln, sizeof(symboln), "%sGenSamplers", symbol_prefix);
5889 *procp = dlsym(handle, symboln);
5890 }
5891
5892
5893 if(!disp->GetSamplerParameterIiv) {
5894 void ** procp = (void **) &disp->GetSamplerParameterIiv;
5895 snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterIiv", symbol_prefix);
5896 *procp = dlsym(handle, symboln);
5897 }
5898
5899
5900 if(!disp->GetSamplerParameterIuiv) {
5901 void ** procp = (void **) &disp->GetSamplerParameterIuiv;
5902 snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterIuiv", symbol_prefix);
5903 *procp = dlsym(handle, symboln);
5904 }
5905
5906
5907 if(!disp->GetSamplerParameterfv) {
5908 void ** procp = (void **) &disp->GetSamplerParameterfv;
5909 snprintf(symboln, sizeof(symboln), "%sGetSamplerParameterfv", symbol_prefix);
5910 *procp = dlsym(handle, symboln);
5911 }
5912
5913
5914 if(!disp->GetSamplerParameteriv) {
5915 void ** procp = (void **) &disp->GetSamplerParameteriv;
5916 snprintf(symboln, sizeof(symboln), "%sGetSamplerParameteriv", symbol_prefix);
5917 *procp = dlsym(handle, symboln);
5918 }
5919
5920
5921 if(!disp->IsSampler) {
5922 void ** procp = (void **) &disp->IsSampler;
5923 snprintf(symboln, sizeof(symboln), "%sIsSampler", symbol_prefix);
5924 *procp = dlsym(handle, symboln);
5925 }
5926
5927
5928 if(!disp->SamplerParameterIiv) {
5929 void ** procp = (void **) &disp->SamplerParameterIiv;
5930 snprintf(symboln, sizeof(symboln), "%sSamplerParameterIiv", symbol_prefix);
5931 *procp = dlsym(handle, symboln);
5932 }
5933
5934
5935 if(!disp->SamplerParameterIuiv) {
5936 void ** procp = (void **) &disp->SamplerParameterIuiv;
5937 snprintf(symboln, sizeof(symboln), "%sSamplerParameterIuiv", symbol_prefix);
5938 *procp = dlsym(handle, symboln);
5939 }
5940
5941
5942 if(!disp->SamplerParameterf) {
5943 void ** procp = (void **) &disp->SamplerParameterf;
5944 snprintf(symboln, sizeof(symboln), "%sSamplerParameterf", symbol_prefix);
5945 *procp = dlsym(handle, symboln);
5946 }
5947
5948
5949 if(!disp->SamplerParameterfv) {
5950 void ** procp = (void **) &disp->SamplerParameterfv;
5951 snprintf(symboln, sizeof(symboln), "%sSamplerParameterfv", symbol_prefix);
5952 *procp = dlsym(handle, symboln);
5953 }
5954
5955
5956 if(!disp->SamplerParameteri) {
5957 void ** procp = (void **) &disp->SamplerParameteri;
5958 snprintf(symboln, sizeof(symboln), "%sSamplerParameteri", symbol_prefix);
5959 *procp = dlsym(handle, symboln);
5960 }
5961
5962
5963 if(!disp->SamplerParameteriv) {
5964 void ** procp = (void **) &disp->SamplerParameteriv;
5965 snprintf(symboln, sizeof(symboln), "%sSamplerParameteriv", symbol_prefix);
5966 *procp = dlsym(handle, symboln);
5967 }
5968
5969
5970 if(!disp->QueryCounter) {
5971 void ** procp = (void **) &disp->QueryCounter;
5972 snprintf(symboln, sizeof(symboln), "%sQueryCounter", symbol_prefix);
5973 *procp = dlsym(handle, symboln);
5974 }
5975
5976
5977 if(!disp->ColorP3ui) {
5978 void ** procp = (void **) &disp->ColorP3ui;
5979 snprintf(symboln, sizeof(symboln), "%sColorP3ui", symbol_prefix);
5980 *procp = dlsym(handle, symboln);
5981 }
5982
5983
5984 if(!disp->ColorP3uiv) {
5985 void ** procp = (void **) &disp->ColorP3uiv;
5986 snprintf(symboln, sizeof(symboln), "%sColorP3uiv", symbol_prefix);
5987 *procp = dlsym(handle, symboln);
5988 }
5989
5990
5991 if(!disp->ColorP4ui) {
5992 void ** procp = (void **) &disp->ColorP4ui;
5993 snprintf(symboln, sizeof(symboln), "%sColorP4ui", symbol_prefix);
5994 *procp = dlsym(handle, symboln);
5995 }
5996
5997
5998 if(!disp->ColorP4uiv) {
5999 void ** procp = (void **) &disp->ColorP4uiv;
6000 snprintf(symboln, sizeof(symboln), "%sColorP4uiv", symbol_prefix);
6001 *procp = dlsym(handle, symboln);
6002 }
6003
6004
6005 if(!disp->MultiTexCoordP1ui) {
6006 void ** procp = (void **) &disp->MultiTexCoordP1ui;
6007 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP1ui", symbol_prefix);
6008 *procp = dlsym(handle, symboln);
6009 }
6010
6011
6012 if(!disp->MultiTexCoordP1uiv) {
6013 void ** procp = (void **) &disp->MultiTexCoordP1uiv;
6014 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP1uiv", symbol_prefix);
6015 *procp = dlsym(handle, symboln);
6016 }
6017
6018
6019 if(!disp->MultiTexCoordP2ui) {
6020 void ** procp = (void **) &disp->MultiTexCoordP2ui;
6021 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP2ui", symbol_prefix);
6022 *procp = dlsym(handle, symboln);
6023 }
6024
6025
6026 if(!disp->MultiTexCoordP2uiv) {
6027 void ** procp = (void **) &disp->MultiTexCoordP2uiv;
6028 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP2uiv", symbol_prefix);
6029 *procp = dlsym(handle, symboln);
6030 }
6031
6032
6033 if(!disp->MultiTexCoordP3ui) {
6034 void ** procp = (void **) &disp->MultiTexCoordP3ui;
6035 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP3ui", symbol_prefix);
6036 *procp = dlsym(handle, symboln);
6037 }
6038
6039
6040 if(!disp->MultiTexCoordP3uiv) {
6041 void ** procp = (void **) &disp->MultiTexCoordP3uiv;
6042 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP3uiv", symbol_prefix);
6043 *procp = dlsym(handle, symboln);
6044 }
6045
6046
6047 if(!disp->MultiTexCoordP4ui) {
6048 void ** procp = (void **) &disp->MultiTexCoordP4ui;
6049 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP4ui", symbol_prefix);
6050 *procp = dlsym(handle, symboln);
6051 }
6052
6053
6054 if(!disp->MultiTexCoordP4uiv) {
6055 void ** procp = (void **) &disp->MultiTexCoordP4uiv;
6056 snprintf(symboln, sizeof(symboln), "%sMultiTexCoordP4uiv", symbol_prefix);
6057 *procp = dlsym(handle, symboln);
6058 }
6059
6060
6061 if(!disp->NormalP3ui) {
6062 void ** procp = (void **) &disp->NormalP3ui;
6063 snprintf(symboln, sizeof(symboln), "%sNormalP3ui", symbol_prefix);
6064 *procp = dlsym(handle, symboln);
6065 }
6066
6067
6068 if(!disp->NormalP3uiv) {
6069 void ** procp = (void **) &disp->NormalP3uiv;
6070 snprintf(symboln, sizeof(symboln), "%sNormalP3uiv", symbol_prefix);
6071 *procp = dlsym(handle, symboln);
6072 }
6073
6074
6075 if(!disp->SecondaryColorP3ui) {
6076 void ** procp = (void **) &disp->SecondaryColorP3ui;
6077 snprintf(symboln, sizeof(symboln), "%sSecondaryColorP3ui", symbol_prefix);
6078 *procp = dlsym(handle, symboln);
6079 }
6080
6081
6082 if(!disp->SecondaryColorP3uiv) {
6083 void ** procp = (void **) &disp->SecondaryColorP3uiv;
6084 snprintf(symboln, sizeof(symboln), "%sSecondaryColorP3uiv", symbol_prefix);
6085 *procp = dlsym(handle, symboln);
6086 }
6087
6088
6089 if(!disp->TexCoordP1ui) {
6090 void ** procp = (void **) &disp->TexCoordP1ui;
6091 snprintf(symboln, sizeof(symboln), "%sTexCoordP1ui", symbol_prefix);
6092 *procp = dlsym(handle, symboln);
6093 }
6094
6095
6096 if(!disp->TexCoordP1uiv) {
6097 void ** procp = (void **) &disp->TexCoordP1uiv;
6098 snprintf(symboln, sizeof(symboln), "%sTexCoordP1uiv", symbol_prefix);
6099 *procp = dlsym(handle, symboln);
6100 }
6101
6102
6103 if(!disp->TexCoordP2ui) {
6104 void ** procp = (void **) &disp->TexCoordP2ui;
6105 snprintf(symboln, sizeof(symboln), "%sTexCoordP2ui", symbol_prefix);
6106 *procp = dlsym(handle, symboln);
6107 }
6108
6109
6110 if(!disp->TexCoordP2uiv) {
6111 void ** procp = (void **) &disp->TexCoordP2uiv;
6112 snprintf(symboln, sizeof(symboln), "%sTexCoordP2uiv", symbol_prefix);
6113 *procp = dlsym(handle, symboln);
6114 }
6115
6116
6117 if(!disp->TexCoordP3ui) {
6118 void ** procp = (void **) &disp->TexCoordP3ui;
6119 snprintf(symboln, sizeof(symboln), "%sTexCoordP3ui", symbol_prefix);
6120 *procp = dlsym(handle, symboln);
6121 }
6122
6123
6124 if(!disp->TexCoordP3uiv) {
6125 void ** procp = (void **) &disp->TexCoordP3uiv;
6126 snprintf(symboln, sizeof(symboln), "%sTexCoordP3uiv", symbol_prefix);
6127 *procp = dlsym(handle, symboln);
6128 }
6129
6130
6131 if(!disp->TexCoordP4ui) {
6132 void ** procp = (void **) &disp->TexCoordP4ui;
6133 snprintf(symboln, sizeof(symboln), "%sTexCoordP4ui", symbol_prefix);
6134 *procp = dlsym(handle, symboln);
6135 }
6136
6137
6138 if(!disp->TexCoordP4uiv) {
6139 void ** procp = (void **) &disp->TexCoordP4uiv;
6140 snprintf(symboln, sizeof(symboln), "%sTexCoordP4uiv", symbol_prefix);
6141 *procp = dlsym(handle, symboln);
6142 }
6143
6144
6145 if(!disp->VertexAttribP1ui) {
6146 void ** procp = (void **) &disp->VertexAttribP1ui;
6147 snprintf(symboln, sizeof(symboln), "%sVertexAttribP1ui", symbol_prefix);
6148 *procp = dlsym(handle, symboln);
6149 }
6150
6151
6152 if(!disp->VertexAttribP1uiv) {
6153 void ** procp = (void **) &disp->VertexAttribP1uiv;
6154 snprintf(symboln, sizeof(symboln), "%sVertexAttribP1uiv", symbol_prefix);
6155 *procp = dlsym(handle, symboln);
6156 }
6157
6158
6159 if(!disp->VertexAttribP2ui) {
6160 void ** procp = (void **) &disp->VertexAttribP2ui;
6161 snprintf(symboln, sizeof(symboln), "%sVertexAttribP2ui", symbol_prefix);
6162 *procp = dlsym(handle, symboln);
6163 }
6164
6165
6166 if(!disp->VertexAttribP2uiv) {
6167 void ** procp = (void **) &disp->VertexAttribP2uiv;
6168 snprintf(symboln, sizeof(symboln), "%sVertexAttribP2uiv", symbol_prefix);
6169 *procp = dlsym(handle, symboln);
6170 }
6171
6172
6173 if(!disp->VertexAttribP3ui) {
6174 void ** procp = (void **) &disp->VertexAttribP3ui;
6175 snprintf(symboln, sizeof(symboln), "%sVertexAttribP3ui", symbol_prefix);
6176 *procp = dlsym(handle, symboln);
6177 }
6178
6179
6180 if(!disp->VertexAttribP3uiv) {
6181 void ** procp = (void **) &disp->VertexAttribP3uiv;
6182 snprintf(symboln, sizeof(symboln), "%sVertexAttribP3uiv", symbol_prefix);
6183 *procp = dlsym(handle, symboln);
6184 }
6185
6186
6187 if(!disp->VertexAttribP4ui) {
6188 void ** procp = (void **) &disp->VertexAttribP4ui;
6189 snprintf(symboln, sizeof(symboln), "%sVertexAttribP4ui", symbol_prefix);
6190 *procp = dlsym(handle, symboln);
6191 }
6192
6193
6194 if(!disp->VertexAttribP4uiv) {
6195 void ** procp = (void **) &disp->VertexAttribP4uiv;
6196 snprintf(symboln, sizeof(symboln), "%sVertexAttribP4uiv", symbol_prefix);
6197 *procp = dlsym(handle, symboln);
6198 }
6199
6200
6201 if(!disp->VertexP2ui) {
6202 void ** procp = (void **) &disp->VertexP2ui;
6203 snprintf(symboln, sizeof(symboln), "%sVertexP2ui", symbol_prefix);
6204 *procp = dlsym(handle, symboln);
6205 }
6206
6207
6208 if(!disp->VertexP2uiv) {
6209 void ** procp = (void **) &disp->VertexP2uiv;
6210 snprintf(symboln, sizeof(symboln), "%sVertexP2uiv", symbol_prefix);
6211 *procp = dlsym(handle, symboln);
6212 }
6213
6214
6215 if(!disp->VertexP3ui) {
6216 void ** procp = (void **) &disp->VertexP3ui;
6217 snprintf(symboln, sizeof(symboln), "%sVertexP3ui", symbol_prefix);
6218 *procp = dlsym(handle, symboln);
6219 }
6220
6221
6222 if(!disp->VertexP3uiv) {
6223 void ** procp = (void **) &disp->VertexP3uiv;
6224 snprintf(symboln, sizeof(symboln), "%sVertexP3uiv", symbol_prefix);
6225 *procp = dlsym(handle, symboln);
6226 }
6227
6228
6229 if(!disp->VertexP4ui) {
6230 void ** procp = (void **) &disp->VertexP4ui;
6231 snprintf(symboln, sizeof(symboln), "%sVertexP4ui", symbol_prefix);
6232 *procp = dlsym(handle, symboln);
6233 }
6234
6235
6236 if(!disp->VertexP4uiv) {
6237 void ** procp = (void **) &disp->VertexP4uiv;
6238 snprintf(symboln, sizeof(symboln), "%sVertexP4uiv", symbol_prefix);
6239 *procp = dlsym(handle, symboln);
6240 }
6241
6242
6243 if(!disp->BindTransformFeedback) {
6244 void ** procp = (void **) &disp->BindTransformFeedback;
6245 snprintf(symboln, sizeof(symboln), "%sBindTransformFeedback", symbol_prefix);
6246 *procp = dlsym(handle, symboln);
6247 }
6248
6249
6250 if(!disp->DeleteTransformFeedbacks) {
6251 void ** procp = (void **) &disp->DeleteTransformFeedbacks;
6252 snprintf(symboln, sizeof(symboln), "%sDeleteTransformFeedbacks", symbol_prefix);
6253 *procp = dlsym(handle, symboln);
6254 }
6255
6256
6257 if(!disp->DrawTransformFeedback) {
6258 void ** procp = (void **) &disp->DrawTransformFeedback;
6259 snprintf(symboln, sizeof(symboln), "%sDrawTransformFeedback", symbol_prefix);
6260 *procp = dlsym(handle, symboln);
6261 }
6262
6263
6264 if(!disp->GenTransformFeedbacks) {
6265 void ** procp = (void **) &disp->GenTransformFeedbacks;
6266 snprintf(symboln, sizeof(symboln), "%sGenTransformFeedbacks", symbol_prefix);
6267 *procp = dlsym(handle, symboln);
6268 }
6269
6270
6271 if(!disp->IsTransformFeedback) {
6272 void ** procp = (void **) &disp->IsTransformFeedback;
6273 snprintf(symboln, sizeof(symboln), "%sIsTransformFeedback", symbol_prefix);
6274 *procp = dlsym(handle, symboln);
6275 }
6276
6277
6278 if(!disp->PauseTransformFeedback) {
6279 void ** procp = (void **) &disp->PauseTransformFeedback;
6280 snprintf(symboln, sizeof(symboln), "%sPauseTransformFeedback", symbol_prefix);
6281 *procp = dlsym(handle, symboln);
6282 }
6283
6284
6285 if(!disp->ResumeTransformFeedback) {
6286 void ** procp = (void **) &disp->ResumeTransformFeedback;
6287 snprintf(symboln, sizeof(symboln), "%sResumeTransformFeedback", symbol_prefix);
6288 *procp = dlsym(handle, symboln);
6289 }
6290
6291
6292 if(!disp->BeginQueryIndexed) {
6293 void ** procp = (void **) &disp->BeginQueryIndexed;
6294 snprintf(symboln, sizeof(symboln), "%sBeginQueryIndexed", symbol_prefix);
6295 *procp = dlsym(handle, symboln);
6296 }
6297
6298
6299 if(!disp->DrawTransformFeedbackStream) {
6300 void ** procp = (void **) &disp->DrawTransformFeedbackStream;
6301 snprintf(symboln, sizeof(symboln), "%sDrawTransformFeedbackStream", symbol_prefix);
6302 *procp = dlsym(handle, symboln);
6303 }
6304
6305
6306 if(!disp->EndQueryIndexed) {
6307 void ** procp = (void **) &disp->EndQueryIndexed;
6308 snprintf(symboln, sizeof(symboln), "%sEndQueryIndexed", symbol_prefix);
6309 *procp = dlsym(handle, symboln);
6310 }
6311
6312
6313 if(!disp->GetQueryIndexediv) {
6314 void ** procp = (void **) &disp->GetQueryIndexediv;
6315 snprintf(symboln, sizeof(symboln), "%sGetQueryIndexediv", symbol_prefix);
6316 *procp = dlsym(handle, symboln);
6317 }
6318
6319
6320 if(!disp->ClearDepthf) {
6321 void ** procp = (void **) &disp->ClearDepthf;
6322 snprintf(symboln, sizeof(symboln), "%sClearDepthf", symbol_prefix);
6323 *procp = dlsym(handle, symboln);
6324 }
6325
6326
6327 if(!disp->DepthRangef) {
6328 void ** procp = (void **) &disp->DepthRangef;
6329 snprintf(symboln, sizeof(symboln), "%sDepthRangef", symbol_prefix);
6330 *procp = dlsym(handle, symboln);
6331 }
6332
6333
6334 if(!disp->GetShaderPrecisionFormat) {
6335 void ** procp = (void **) &disp->GetShaderPrecisionFormat;
6336 snprintf(symboln, sizeof(symboln), "%sGetShaderPrecisionFormat", symbol_prefix);
6337 *procp = dlsym(handle, symboln);
6338 }
6339
6340
6341 if(!disp->ReleaseShaderCompiler) {
6342 void ** procp = (void **) &disp->ReleaseShaderCompiler;
6343 snprintf(symboln, sizeof(symboln), "%sReleaseShaderCompiler", symbol_prefix);
6344 *procp = dlsym(handle, symboln);
6345 }
6346
6347
6348 if(!disp->ShaderBinary) {
6349 void ** procp = (void **) &disp->ShaderBinary;
6350 snprintf(symboln, sizeof(symboln), "%sShaderBinary", symbol_prefix);
6351 *procp = dlsym(handle, symboln);
6352 }
6353
6354
6355 if(!disp->DebugMessageCallbackARB) {
6356 void ** procp = (void **) &disp->DebugMessageCallbackARB;
6357 snprintf(symboln, sizeof(symboln), "%sDebugMessageCallbackARB", symbol_prefix);
6358 *procp = dlsym(handle, symboln);
6359 }
6360
6361
6362 if(!disp->DebugMessageControlARB) {
6363 void ** procp = (void **) &disp->DebugMessageControlARB;
6364 snprintf(symboln, sizeof(symboln), "%sDebugMessageControlARB", symbol_prefix);
6365 *procp = dlsym(handle, symboln);
6366 }
6367
6368
6369 if(!disp->DebugMessageInsertARB) {
6370 void ** procp = (void **) &disp->DebugMessageInsertARB;
6371 snprintf(symboln, sizeof(symboln), "%sDebugMessageInsertARB", symbol_prefix);
6372 *procp = dlsym(handle, symboln);
6373 }
6374
6375
6376 if(!disp->GetDebugMessageLogARB) {
6377 void ** procp = (void **) &disp->GetDebugMessageLogARB;
6378 snprintf(symboln, sizeof(symboln), "%sGetDebugMessageLogARB", symbol_prefix);
6379 *procp = dlsym(handle, symboln);
6380 }
6381
6382
6383 if(!disp->GetGraphicsResetStatusARB) {
6384 void ** procp = (void **) &disp->GetGraphicsResetStatusARB;
6385 snprintf(symboln, sizeof(symboln), "%sGetGraphicsResetStatusARB", symbol_prefix);
6386 *procp = dlsym(handle, symboln);
6387 }
6388
6389
6390 if(!disp->GetnColorTableARB) {
6391 void ** procp = (void **) &disp->GetnColorTableARB;
6392 snprintf(symboln, sizeof(symboln), "%sGetnColorTableARB", symbol_prefix);
6393 *procp = dlsym(handle, symboln);
6394 }
6395
6396
6397 if(!disp->GetnCompressedTexImageARB) {
6398 void ** procp = (void **) &disp->GetnCompressedTexImageARB;
6399 snprintf(symboln, sizeof(symboln), "%sGetnCompressedTexImageARB", symbol_prefix);
6400 *procp = dlsym(handle, symboln);
6401 }
6402
6403
6404 if(!disp->GetnConvolutionFilterARB) {
6405 void ** procp = (void **) &disp->GetnConvolutionFilterARB;
6406 snprintf(symboln, sizeof(symboln), "%sGetnConvolutionFilterARB", symbol_prefix);
6407 *procp = dlsym(handle, symboln);
6408 }
6409
6410
6411 if(!disp->GetnHistogramARB) {
6412 void ** procp = (void **) &disp->GetnHistogramARB;
6413 snprintf(symboln, sizeof(symboln), "%sGetnHistogramARB", symbol_prefix);
6414 *procp = dlsym(handle, symboln);
6415 }
6416
6417
6418 if(!disp->GetnMapdvARB) {
6419 void ** procp = (void **) &disp->GetnMapdvARB;
6420 snprintf(symboln, sizeof(symboln), "%sGetnMapdvARB", symbol_prefix);
6421 *procp = dlsym(handle, symboln);
6422 }
6423
6424
6425 if(!disp->GetnMapfvARB) {
6426 void ** procp = (void **) &disp->GetnMapfvARB;
6427 snprintf(symboln, sizeof(symboln), "%sGetnMapfvARB", symbol_prefix);
6428 *procp = dlsym(handle, symboln);
6429 }
6430
6431
6432 if(!disp->GetnMapivARB) {
6433 void ** procp = (void **) &disp->GetnMapivARB;
6434 snprintf(symboln, sizeof(symboln), "%sGetnMapivARB", symbol_prefix);
6435 *procp = dlsym(handle, symboln);
6436 }
6437
6438
6439 if(!disp->GetnMinmaxARB) {
6440 void ** procp = (void **) &disp->GetnMinmaxARB;
6441 snprintf(symboln, sizeof(symboln), "%sGetnMinmaxARB", symbol_prefix);
6442 *procp = dlsym(handle, symboln);
6443 }
6444
6445
6446 if(!disp->GetnPixelMapfvARB) {
6447 void ** procp = (void **) &disp->GetnPixelMapfvARB;
6448 snprintf(symboln, sizeof(symboln), "%sGetnPixelMapfvARB", symbol_prefix);
6449 *procp = dlsym(handle, symboln);
6450 }
6451
6452
6453 if(!disp->GetnPixelMapuivARB) {
6454 void ** procp = (void **) &disp->GetnPixelMapuivARB;
6455 snprintf(symboln, sizeof(symboln), "%sGetnPixelMapuivARB", symbol_prefix);
6456 *procp = dlsym(handle, symboln);
6457 }
6458
6459
6460 if(!disp->GetnPixelMapusvARB) {
6461 void ** procp = (void **) &disp->GetnPixelMapusvARB;
6462 snprintf(symboln, sizeof(symboln), "%sGetnPixelMapusvARB", symbol_prefix);
6463 *procp = dlsym(handle, symboln);
6464 }
6465
6466
6467 if(!disp->GetnPolygonStippleARB) {
6468 void ** procp = (void **) &disp->GetnPolygonStippleARB;
6469 snprintf(symboln, sizeof(symboln), "%sGetnPolygonStippleARB", symbol_prefix);
6470 *procp = dlsym(handle, symboln);
6471 }
6472
6473
6474 if(!disp->GetnSeparableFilterARB) {
6475 void ** procp = (void **) &disp->GetnSeparableFilterARB;
6476 snprintf(symboln, sizeof(symboln), "%sGetnSeparableFilterARB", symbol_prefix);
6477 *procp = dlsym(handle, symboln);
6478 }
6479
6480
6481 if(!disp->GetnTexImageARB) {
6482 void ** procp = (void **) &disp->GetnTexImageARB;
6483 snprintf(symboln, sizeof(symboln), "%sGetnTexImageARB", symbol_prefix);
6484 *procp = dlsym(handle, symboln);
6485 }
6486
6487
6488 if(!disp->GetnUniformdvARB) {
6489 void ** procp = (void **) &disp->GetnUniformdvARB;
6490 snprintf(symboln, sizeof(symboln), "%sGetnUniformdvARB", symbol_prefix);
6491 *procp = dlsym(handle, symboln);
6492 }
6493
6494
6495 if(!disp->GetnUniformfvARB) {
6496 void ** procp = (void **) &disp->GetnUniformfvARB;
6497 snprintf(symboln, sizeof(symboln), "%sGetnUniformfvARB", symbol_prefix);
6498 *procp = dlsym(handle, symboln);
6499 }
6500
6501
6502 if(!disp->GetnUniformivARB) {
6503 void ** procp = (void **) &disp->GetnUniformivARB;
6504 snprintf(symboln, sizeof(symboln), "%sGetnUniformivARB", symbol_prefix);
6505 *procp = dlsym(handle, symboln);
6506 }
6507
6508
6509 if(!disp->GetnUniformuivARB) {
6510 void ** procp = (void **) &disp->GetnUniformuivARB;
6511 snprintf(symboln, sizeof(symboln), "%sGetnUniformuivARB", symbol_prefix);
6512 *procp = dlsym(handle, symboln);
6513 }
6514
6515
6516 if(!disp->ReadnPixelsARB) {
6517 void ** procp = (void **) &disp->ReadnPixelsARB;
6518 snprintf(symboln, sizeof(symboln), "%sReadnPixelsARB", symbol_prefix);
6519 *procp = dlsym(handle, symboln);
6520 }
6521
6522
6523 if(!disp->DrawArraysInstancedBaseInstance) {
6524 void ** procp = (void **) &disp->DrawArraysInstancedBaseInstance;
6525 snprintf(symboln, sizeof(symboln), "%sDrawArraysInstancedBaseInstance", symbol_prefix);
6526 *procp = dlsym(handle, symboln);
6527 }
6528
6529
6530 if(!disp->DrawElementsInstancedBaseInstance) {
6531 void ** procp = (void **) &disp->DrawElementsInstancedBaseInstance;
6532 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedBaseInstance", symbol_prefix);
6533 *procp = dlsym(handle, symboln);
6534 }
6535
6536
6537 if(!disp->DrawElementsInstancedBaseVertexBaseInstance) {
6538 void ** procp = (void **) &disp->DrawElementsInstancedBaseVertexBaseInstance;
6539 snprintf(symboln, sizeof(symboln), "%sDrawElementsInstancedBaseVertexBaseInstance", symbol_prefix);
6540 *procp = dlsym(handle, symboln);
6541 }
6542
6543
6544 if(!disp->DrawTransformFeedbackInstanced) {
6545 void ** procp = (void **) &disp->DrawTransformFeedbackInstanced;
6546 snprintf(symboln, sizeof(symboln), "%sDrawTransformFeedbackInstanced", symbol_prefix);
6547 *procp = dlsym(handle, symboln);
6548 }
6549
6550
6551 if(!disp->DrawTransformFeedbackStreamInstanced) {
6552 void ** procp = (void **) &disp->DrawTransformFeedbackStreamInstanced;
6553 snprintf(symboln, sizeof(symboln), "%sDrawTransformFeedbackStreamInstanced", symbol_prefix);
6554 *procp = dlsym(handle, symboln);
6555 }
6556
6557
6558 if(!disp->TexStorage1D) {
6559 void ** procp = (void **) &disp->TexStorage1D;
6560 snprintf(symboln, sizeof(symboln), "%sTexStorage1D", symbol_prefix);
6561 *procp = dlsym(handle, symboln);
6562 }
6563
6564
6565 if(!disp->TexStorage2D) {
6566 void ** procp = (void **) &disp->TexStorage2D;
6567 snprintf(symboln, sizeof(symboln), "%sTexStorage2D", symbol_prefix);
6568 *procp = dlsym(handle, symboln);
6569 }
6570
6571
6572 if(!disp->TexStorage3D) {
6573 void ** procp = (void **) &disp->TexStorage3D;
6574 snprintf(symboln, sizeof(symboln), "%sTexStorage3D", symbol_prefix);
6575 *procp = dlsym(handle, symboln);
6576 }
6577
6578
6579 if(!disp->TextureStorage1DEXT) {
6580 void ** procp = (void **) &disp->TextureStorage1DEXT;
6581 snprintf(symboln, sizeof(symboln), "%sTextureStorage1DEXT", symbol_prefix);
6582 *procp = dlsym(handle, symboln);
6583 }
6584
6585
6586 if(!disp->TextureStorage2DEXT) {
6587 void ** procp = (void **) &disp->TextureStorage2DEXT;
6588 snprintf(symboln, sizeof(symboln), "%sTextureStorage2DEXT", symbol_prefix);
6589 *procp = dlsym(handle, symboln);
6590 }
6591
6592
6593 if(!disp->TextureStorage3DEXT) {
6594 void ** procp = (void **) &disp->TextureStorage3DEXT;
6595 snprintf(symboln, sizeof(symboln), "%sTextureStorage3DEXT", symbol_prefix);
6596 *procp = dlsym(handle, symboln);
6597 }
6598
6599
6600 if(!disp->InvalidateBufferData) {
6601 void ** procp = (void **) &disp->InvalidateBufferData;
6602 snprintf(symboln, sizeof(symboln), "%sInvalidateBufferData", symbol_prefix);
6603 *procp = dlsym(handle, symboln);
6604 }
6605
6606
6607 if(!disp->InvalidateBufferSubData) {
6608 void ** procp = (void **) &disp->InvalidateBufferSubData;
6609 snprintf(symboln, sizeof(symboln), "%sInvalidateBufferSubData", symbol_prefix);
6610 *procp = dlsym(handle, symboln);
6611 }
6612
6613
6614 if(!disp->InvalidateFramebuffer) {
6615 void ** procp = (void **) &disp->InvalidateFramebuffer;
6616 snprintf(symboln, sizeof(symboln), "%sInvalidateFramebuffer", symbol_prefix);
6617 *procp = dlsym(handle, symboln);
6618 }
6619
6620
6621 if(!disp->InvalidateSubFramebuffer) {
6622 void ** procp = (void **) &disp->InvalidateSubFramebuffer;
6623 snprintf(symboln, sizeof(symboln), "%sInvalidateSubFramebuffer", symbol_prefix);
6624 *procp = dlsym(handle, symboln);
6625 }
6626
6627
6628 if(!disp->InvalidateTexImage) {
6629 void ** procp = (void **) &disp->InvalidateTexImage;
6630 snprintf(symboln, sizeof(symboln), "%sInvalidateTexImage", symbol_prefix);
6631 *procp = dlsym(handle, symboln);
6632 }
6633
6634
6635 if(!disp->InvalidateTexSubImage) {
6636 void ** procp = (void **) &disp->InvalidateTexSubImage;
6637 snprintf(symboln, sizeof(symboln), "%sInvalidateTexSubImage", symbol_prefix);
6638 *procp = dlsym(handle, symboln);
6639 }
6640
6641
6642 if(!disp->PolygonOffsetEXT) {
6643 void ** procp = (void **) &disp->PolygonOffsetEXT;
6644 snprintf(symboln, sizeof(symboln), "%sPolygonOffsetEXT", symbol_prefix);
6645 *procp = dlsym(handle, symboln);
6646 }
6647
6648
6649 if(!disp->SampleMaskSGIS) {
6650 void ** procp = (void **) &disp->SampleMaskSGIS;
6651 snprintf(symboln, sizeof(symboln), "%sSampleMaskSGIS", symbol_prefix);
6652 *procp = dlsym(handle, symboln);
6653 }
6654
6655
6656 if(!disp->SampleMaskSGIS) {
6657 void ** procp = (void **) &disp->SampleMaskSGIS;
6658 snprintf(symboln, sizeof(symboln), "%sSampleMaskEXT", symbol_prefix);
6659 *procp = dlsym(handle, symboln);
6660 }
6661
6662
6663 if(!disp->SamplePatternSGIS) {
6664 void ** procp = (void **) &disp->SamplePatternSGIS;
6665 snprintf(symboln, sizeof(symboln), "%sSamplePatternSGIS", symbol_prefix);
6666 *procp = dlsym(handle, symboln);
6667 }
6668
6669
6670 if(!disp->SamplePatternSGIS) {
6671 void ** procp = (void **) &disp->SamplePatternSGIS;
6672 snprintf(symboln, sizeof(symboln), "%sSamplePatternEXT", symbol_prefix);
6673 *procp = dlsym(handle, symboln);
6674 }
6675
6676
6677 if(!disp->ColorPointerEXT) {
6678 void ** procp = (void **) &disp->ColorPointerEXT;
6679 snprintf(symboln, sizeof(symboln), "%sColorPointerEXT", symbol_prefix);
6680 *procp = dlsym(handle, symboln);
6681 }
6682
6683
6684 if(!disp->EdgeFlagPointerEXT) {
6685 void ** procp = (void **) &disp->EdgeFlagPointerEXT;
6686 snprintf(symboln, sizeof(symboln), "%sEdgeFlagPointerEXT", symbol_prefix);
6687 *procp = dlsym(handle, symboln);
6688 }
6689
6690
6691 if(!disp->IndexPointerEXT) {
6692 void ** procp = (void **) &disp->IndexPointerEXT;
6693 snprintf(symboln, sizeof(symboln), "%sIndexPointerEXT", symbol_prefix);
6694 *procp = dlsym(handle, symboln);
6695 }
6696
6697
6698 if(!disp->NormalPointerEXT) {
6699 void ** procp = (void **) &disp->NormalPointerEXT;
6700 snprintf(symboln, sizeof(symboln), "%sNormalPointerEXT", symbol_prefix);
6701 *procp = dlsym(handle, symboln);
6702 }
6703
6704
6705 if(!disp->TexCoordPointerEXT) {
6706 void ** procp = (void **) &disp->TexCoordPointerEXT;
6707 snprintf(symboln, sizeof(symboln), "%sTexCoordPointerEXT", symbol_prefix);
6708 *procp = dlsym(handle, symboln);
6709 }
6710
6711
6712 if(!disp->VertexPointerEXT) {
6713 void ** procp = (void **) &disp->VertexPointerEXT;
6714 snprintf(symboln, sizeof(symboln), "%sVertexPointerEXT", symbol_prefix);
6715 *procp = dlsym(handle, symboln);
6716 }
6717
6718
6719 if(!disp->PointParameterfEXT) {
6720 void ** procp = (void **) &disp->PointParameterfEXT;
6721 snprintf(symboln, sizeof(symboln), "%sPointParameterf", symbol_prefix);
6722 *procp = dlsym(handle, symboln);
6723 }
6724
6725
6726 if(!disp->PointParameterfEXT) {
6727 void ** procp = (void **) &disp->PointParameterfEXT;
6728 snprintf(symboln, sizeof(symboln), "%sPointParameterfARB", symbol_prefix);
6729 *procp = dlsym(handle, symboln);
6730 }
6731
6732
6733 if(!disp->PointParameterfEXT) {
6734 void ** procp = (void **) &disp->PointParameterfEXT;
6735 snprintf(symboln, sizeof(symboln), "%sPointParameterfEXT", symbol_prefix);
6736 *procp = dlsym(handle, symboln);
6737 }
6738
6739
6740 if(!disp->PointParameterfEXT) {
6741 void ** procp = (void **) &disp->PointParameterfEXT;
6742 snprintf(symboln, sizeof(symboln), "%sPointParameterfSGIS", symbol_prefix);
6743 *procp = dlsym(handle, symboln);
6744 }
6745
6746
6747 if(!disp->PointParameterfvEXT) {
6748 void ** procp = (void **) &disp->PointParameterfvEXT;
6749 snprintf(symboln, sizeof(symboln), "%sPointParameterfv", symbol_prefix);
6750 *procp = dlsym(handle, symboln);
6751 }
6752
6753
6754 if(!disp->PointParameterfvEXT) {
6755 void ** procp = (void **) &disp->PointParameterfvEXT;
6756 snprintf(symboln, sizeof(symboln), "%sPointParameterfvARB", symbol_prefix);
6757 *procp = dlsym(handle, symboln);
6758 }
6759
6760
6761 if(!disp->PointParameterfvEXT) {
6762 void ** procp = (void **) &disp->PointParameterfvEXT;
6763 snprintf(symboln, sizeof(symboln), "%sPointParameterfvEXT", symbol_prefix);
6764 *procp = dlsym(handle, symboln);
6765 }
6766
6767
6768 if(!disp->PointParameterfvEXT) {
6769 void ** procp = (void **) &disp->PointParameterfvEXT;
6770 snprintf(symboln, sizeof(symboln), "%sPointParameterfvSGIS", symbol_prefix);
6771 *procp = dlsym(handle, symboln);
6772 }
6773
6774
6775 if(!disp->LockArraysEXT) {
6776 void ** procp = (void **) &disp->LockArraysEXT;
6777 snprintf(symboln, sizeof(symboln), "%sLockArraysEXT", symbol_prefix);
6778 *procp = dlsym(handle, symboln);
6779 }
6780
6781
6782 if(!disp->UnlockArraysEXT) {
6783 void ** procp = (void **) &disp->UnlockArraysEXT;
6784 snprintf(symboln, sizeof(symboln), "%sUnlockArraysEXT", symbol_prefix);
6785 *procp = dlsym(handle, symboln);
6786 }
6787
6788
6789 if(!disp->SecondaryColor3bEXT) {
6790 void ** procp = (void **) &disp->SecondaryColor3bEXT;
6791 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3b", symbol_prefix);
6792 *procp = dlsym(handle, symboln);
6793 }
6794
6795
6796 if(!disp->SecondaryColor3bEXT) {
6797 void ** procp = (void **) &disp->SecondaryColor3bEXT;
6798 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bEXT", symbol_prefix);
6799 *procp = dlsym(handle, symboln);
6800 }
6801
6802
6803 if(!disp->SecondaryColor3bvEXT) {
6804 void ** procp = (void **) &disp->SecondaryColor3bvEXT;
6805 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bv", symbol_prefix);
6806 *procp = dlsym(handle, symboln);
6807 }
6808
6809
6810 if(!disp->SecondaryColor3bvEXT) {
6811 void ** procp = (void **) &disp->SecondaryColor3bvEXT;
6812 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3bvEXT", symbol_prefix);
6813 *procp = dlsym(handle, symboln);
6814 }
6815
6816
6817 if(!disp->SecondaryColor3dEXT) {
6818 void ** procp = (void **) &disp->SecondaryColor3dEXT;
6819 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3d", symbol_prefix);
6820 *procp = dlsym(handle, symboln);
6821 }
6822
6823
6824 if(!disp->SecondaryColor3dEXT) {
6825 void ** procp = (void **) &disp->SecondaryColor3dEXT;
6826 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dEXT", symbol_prefix);
6827 *procp = dlsym(handle, symboln);
6828 }
6829
6830
6831 if(!disp->SecondaryColor3dvEXT) {
6832 void ** procp = (void **) &disp->SecondaryColor3dvEXT;
6833 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dv", symbol_prefix);
6834 *procp = dlsym(handle, symboln);
6835 }
6836
6837
6838 if(!disp->SecondaryColor3dvEXT) {
6839 void ** procp = (void **) &disp->SecondaryColor3dvEXT;
6840 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3dvEXT", symbol_prefix);
6841 *procp = dlsym(handle, symboln);
6842 }
6843
6844
6845 if(!disp->SecondaryColor3fEXT) {
6846 void ** procp = (void **) &disp->SecondaryColor3fEXT;
6847 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3f", symbol_prefix);
6848 *procp = dlsym(handle, symboln);
6849 }
6850
6851
6852 if(!disp->SecondaryColor3fEXT) {
6853 void ** procp = (void **) &disp->SecondaryColor3fEXT;
6854 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fEXT", symbol_prefix);
6855 *procp = dlsym(handle, symboln);
6856 }
6857
6858
6859 if(!disp->SecondaryColor3fvEXT) {
6860 void ** procp = (void **) &disp->SecondaryColor3fvEXT;
6861 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fv", symbol_prefix);
6862 *procp = dlsym(handle, symboln);
6863 }
6864
6865
6866 if(!disp->SecondaryColor3fvEXT) {
6867 void ** procp = (void **) &disp->SecondaryColor3fvEXT;
6868 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3fvEXT", symbol_prefix);
6869 *procp = dlsym(handle, symboln);
6870 }
6871
6872
6873 if(!disp->SecondaryColor3iEXT) {
6874 void ** procp = (void **) &disp->SecondaryColor3iEXT;
6875 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3i", symbol_prefix);
6876 *procp = dlsym(handle, symboln);
6877 }
6878
6879
6880 if(!disp->SecondaryColor3iEXT) {
6881 void ** procp = (void **) &disp->SecondaryColor3iEXT;
6882 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3iEXT", symbol_prefix);
6883 *procp = dlsym(handle, symboln);
6884 }
6885
6886
6887 if(!disp->SecondaryColor3ivEXT) {
6888 void ** procp = (void **) &disp->SecondaryColor3ivEXT;
6889 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3iv", symbol_prefix);
6890 *procp = dlsym(handle, symboln);
6891 }
6892
6893
6894 if(!disp->SecondaryColor3ivEXT) {
6895 void ** procp = (void **) &disp->SecondaryColor3ivEXT;
6896 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ivEXT", symbol_prefix);
6897 *procp = dlsym(handle, symboln);
6898 }
6899
6900
6901 if(!disp->SecondaryColor3sEXT) {
6902 void ** procp = (void **) &disp->SecondaryColor3sEXT;
6903 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3s", symbol_prefix);
6904 *procp = dlsym(handle, symboln);
6905 }
6906
6907
6908 if(!disp->SecondaryColor3sEXT) {
6909 void ** procp = (void **) &disp->SecondaryColor3sEXT;
6910 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3sEXT", symbol_prefix);
6911 *procp = dlsym(handle, symboln);
6912 }
6913
6914
6915 if(!disp->SecondaryColor3svEXT) {
6916 void ** procp = (void **) &disp->SecondaryColor3svEXT;
6917 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3sv", symbol_prefix);
6918 *procp = dlsym(handle, symboln);
6919 }
6920
6921
6922 if(!disp->SecondaryColor3svEXT) {
6923 void ** procp = (void **) &disp->SecondaryColor3svEXT;
6924 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3svEXT", symbol_prefix);
6925 *procp = dlsym(handle, symboln);
6926 }
6927
6928
6929 if(!disp->SecondaryColor3ubEXT) {
6930 void ** procp = (void **) &disp->SecondaryColor3ubEXT;
6931 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ub", symbol_prefix);
6932 *procp = dlsym(handle, symboln);
6933 }
6934
6935
6936 if(!disp->SecondaryColor3ubEXT) {
6937 void ** procp = (void **) &disp->SecondaryColor3ubEXT;
6938 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubEXT", symbol_prefix);
6939 *procp = dlsym(handle, symboln);
6940 }
6941
6942
6943 if(!disp->SecondaryColor3ubvEXT) {
6944 void ** procp = (void **) &disp->SecondaryColor3ubvEXT;
6945 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubv", symbol_prefix);
6946 *procp = dlsym(handle, symboln);
6947 }
6948
6949
6950 if(!disp->SecondaryColor3ubvEXT) {
6951 void ** procp = (void **) &disp->SecondaryColor3ubvEXT;
6952 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ubvEXT", symbol_prefix);
6953 *procp = dlsym(handle, symboln);
6954 }
6955
6956
6957 if(!disp->SecondaryColor3uiEXT) {
6958 void ** procp = (void **) &disp->SecondaryColor3uiEXT;
6959 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3ui", symbol_prefix);
6960 *procp = dlsym(handle, symboln);
6961 }
6962
6963
6964 if(!disp->SecondaryColor3uiEXT) {
6965 void ** procp = (void **) &disp->SecondaryColor3uiEXT;
6966 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uiEXT", symbol_prefix);
6967 *procp = dlsym(handle, symboln);
6968 }
6969
6970
6971 if(!disp->SecondaryColor3uivEXT) {
6972 void ** procp = (void **) &disp->SecondaryColor3uivEXT;
6973 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uiv", symbol_prefix);
6974 *procp = dlsym(handle, symboln);
6975 }
6976
6977
6978 if(!disp->SecondaryColor3uivEXT) {
6979 void ** procp = (void **) &disp->SecondaryColor3uivEXT;
6980 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3uivEXT", symbol_prefix);
6981 *procp = dlsym(handle, symboln);
6982 }
6983
6984
6985 if(!disp->SecondaryColor3usEXT) {
6986 void ** procp = (void **) &disp->SecondaryColor3usEXT;
6987 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3us", symbol_prefix);
6988 *procp = dlsym(handle, symboln);
6989 }
6990
6991
6992 if(!disp->SecondaryColor3usEXT) {
6993 void ** procp = (void **) &disp->SecondaryColor3usEXT;
6994 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usEXT", symbol_prefix);
6995 *procp = dlsym(handle, symboln);
6996 }
6997
6998
6999 if(!disp->SecondaryColor3usvEXT) {
7000 void ** procp = (void **) &disp->SecondaryColor3usvEXT;
7001 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usv", symbol_prefix);
7002 *procp = dlsym(handle, symboln);
7003 }
7004
7005
7006 if(!disp->SecondaryColor3usvEXT) {
7007 void ** procp = (void **) &disp->SecondaryColor3usvEXT;
7008 snprintf(symboln, sizeof(symboln), "%sSecondaryColor3usvEXT", symbol_prefix);
7009 *procp = dlsym(handle, symboln);
7010 }
7011
7012
7013 if(!disp->SecondaryColorPointerEXT) {
7014 void ** procp = (void **) &disp->SecondaryColorPointerEXT;
7015 snprintf(symboln, sizeof(symboln), "%sSecondaryColorPointer", symbol_prefix);
7016 *procp = dlsym(handle, symboln);
7017 }
7018
7019
7020 if(!disp->SecondaryColorPointerEXT) {
7021 void ** procp = (void **) &disp->SecondaryColorPointerEXT;
7022 snprintf(symboln, sizeof(symboln), "%sSecondaryColorPointerEXT", symbol_prefix);
7023 *procp = dlsym(handle, symboln);
7024 }
7025
7026
7027 if(!disp->MultiDrawArraysEXT) {
7028 void ** procp = (void **) &disp->MultiDrawArraysEXT;
7029 snprintf(symboln, sizeof(symboln), "%sMultiDrawArrays", symbol_prefix);
7030 *procp = dlsym(handle, symboln);
7031 }
7032
7033
7034 if(!disp->MultiDrawArraysEXT) {
7035 void ** procp = (void **) &disp->MultiDrawArraysEXT;
7036 snprintf(symboln, sizeof(symboln), "%sMultiDrawArraysEXT", symbol_prefix);
7037 *procp = dlsym(handle, symboln);
7038 }
7039
7040
7041 if(!disp->MultiDrawElementsEXT) {
7042 void ** procp = (void **) &disp->MultiDrawElementsEXT;
7043 snprintf(symboln, sizeof(symboln), "%sMultiDrawElements", symbol_prefix);
7044 *procp = dlsym(handle, symboln);
7045 }
7046
7047
7048 if(!disp->MultiDrawElementsEXT) {
7049 void ** procp = (void **) &disp->MultiDrawElementsEXT;
7050 snprintf(symboln, sizeof(symboln), "%sMultiDrawElementsEXT", symbol_prefix);
7051 *procp = dlsym(handle, symboln);
7052 }
7053
7054
7055 if(!disp->FogCoordPointerEXT) {
7056 void ** procp = (void **) &disp->FogCoordPointerEXT;
7057 snprintf(symboln, sizeof(symboln), "%sFogCoordPointer", symbol_prefix);
7058 *procp = dlsym(handle, symboln);
7059 }
7060
7061
7062 if(!disp->FogCoordPointerEXT) {
7063 void ** procp = (void **) &disp->FogCoordPointerEXT;
7064 snprintf(symboln, sizeof(symboln), "%sFogCoordPointerEXT", symbol_prefix);
7065 *procp = dlsym(handle, symboln);
7066 }
7067
7068
7069 if(!disp->FogCoorddEXT) {
7070 void ** procp = (void **) &disp->FogCoorddEXT;
7071 snprintf(symboln, sizeof(symboln), "%sFogCoordd", symbol_prefix);
7072 *procp = dlsym(handle, symboln);
7073 }
7074
7075
7076 if(!disp->FogCoorddEXT) {
7077 void ** procp = (void **) &disp->FogCoorddEXT;
7078 snprintf(symboln, sizeof(symboln), "%sFogCoorddEXT", symbol_prefix);
7079 *procp = dlsym(handle, symboln);
7080 }
7081
7082
7083 if(!disp->FogCoorddvEXT) {
7084 void ** procp = (void **) &disp->FogCoorddvEXT;
7085 snprintf(symboln, sizeof(symboln), "%sFogCoorddv", symbol_prefix);
7086 *procp = dlsym(handle, symboln);
7087 }
7088
7089
7090 if(!disp->FogCoorddvEXT) {
7091 void ** procp = (void **) &disp->FogCoorddvEXT;
7092 snprintf(symboln, sizeof(symboln), "%sFogCoorddvEXT", symbol_prefix);
7093 *procp = dlsym(handle, symboln);
7094 }
7095
7096
7097 if(!disp->FogCoordfEXT) {
7098 void ** procp = (void **) &disp->FogCoordfEXT;
7099 snprintf(symboln, sizeof(symboln), "%sFogCoordf", symbol_prefix);
7100 *procp = dlsym(handle, symboln);
7101 }
7102
7103
7104 if(!disp->FogCoordfEXT) {
7105 void ** procp = (void **) &disp->FogCoordfEXT;
7106 snprintf(symboln, sizeof(symboln), "%sFogCoordfEXT", symbol_prefix);
7107 *procp = dlsym(handle, symboln);
7108 }
7109
7110
7111 if(!disp->FogCoordfvEXT) {
7112 void ** procp = (void **) &disp->FogCoordfvEXT;
7113 snprintf(symboln, sizeof(symboln), "%sFogCoordfv", symbol_prefix);
7114 *procp = dlsym(handle, symboln);
7115 }
7116
7117
7118 if(!disp->FogCoordfvEXT) {
7119 void ** procp = (void **) &disp->FogCoordfvEXT;
7120 snprintf(symboln, sizeof(symboln), "%sFogCoordfvEXT", symbol_prefix);
7121 *procp = dlsym(handle, symboln);
7122 }
7123
7124
7125 if(!disp->BlendFuncSeparateEXT) {
7126 void ** procp = (void **) &disp->BlendFuncSeparateEXT;
7127 snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparate", symbol_prefix);
7128 *procp = dlsym(handle, symboln);
7129 }
7130
7131
7132 if(!disp->BlendFuncSeparateEXT) {
7133 void ** procp = (void **) &disp->BlendFuncSeparateEXT;
7134 snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateEXT", symbol_prefix);
7135 *procp = dlsym(handle, symboln);
7136 }
7137
7138
7139 if(!disp->BlendFuncSeparateEXT) {
7140 void ** procp = (void **) &disp->BlendFuncSeparateEXT;
7141 snprintf(symboln, sizeof(symboln), "%sBlendFuncSeparateINGR", symbol_prefix);
7142 *procp = dlsym(handle, symboln);
7143 }
7144
7145
7146 if(!disp->ResizeBuffersMESA) {
7147 void ** procp = (void **) &disp->ResizeBuffersMESA;
7148 snprintf(symboln, sizeof(symboln), "%sResizeBuffersMESA", symbol_prefix);
7149 *procp = dlsym(handle, symboln);
7150 }
7151
7152
7153 if(!disp->WindowPos2dMESA) {
7154 void ** procp = (void **) &disp->WindowPos2dMESA;
7155 snprintf(symboln, sizeof(symboln), "%sWindowPos2d", symbol_prefix);
7156 *procp = dlsym(handle, symboln);
7157 }
7158
7159
7160 if(!disp->WindowPos2dMESA) {
7161 void ** procp = (void **) &disp->WindowPos2dMESA;
7162 snprintf(symboln, sizeof(symboln), "%sWindowPos2dARB", symbol_prefix);
7163 *procp = dlsym(handle, symboln);
7164 }
7165
7166
7167 if(!disp->WindowPos2dMESA) {
7168 void ** procp = (void **) &disp->WindowPos2dMESA;
7169 snprintf(symboln, sizeof(symboln), "%sWindowPos2dMESA", symbol_prefix);
7170 *procp = dlsym(handle, symboln);
7171 }
7172
7173
7174 if(!disp->WindowPos2dvMESA) {
7175 void ** procp = (void **) &disp->WindowPos2dvMESA;
7176 snprintf(symboln, sizeof(symboln), "%sWindowPos2dv", symbol_prefix);
7177 *procp = dlsym(handle, symboln);
7178 }
7179
7180
7181 if(!disp->WindowPos2dvMESA) {
7182 void ** procp = (void **) &disp->WindowPos2dvMESA;
7183 snprintf(symboln, sizeof(symboln), "%sWindowPos2dvARB", symbol_prefix);
7184 *procp = dlsym(handle, symboln);
7185 }
7186
7187
7188 if(!disp->WindowPos2dvMESA) {
7189 void ** procp = (void **) &disp->WindowPos2dvMESA;
7190 snprintf(symboln, sizeof(symboln), "%sWindowPos2dvMESA", symbol_prefix);
7191 *procp = dlsym(handle, symboln);
7192 }
7193
7194
7195 if(!disp->WindowPos2fMESA) {
7196 void ** procp = (void **) &disp->WindowPos2fMESA;
7197 snprintf(symboln, sizeof(symboln), "%sWindowPos2f", symbol_prefix);
7198 *procp = dlsym(handle, symboln);
7199 }
7200
7201
7202 if(!disp->WindowPos2fMESA) {
7203 void ** procp = (void **) &disp->WindowPos2fMESA;
7204 snprintf(symboln, sizeof(symboln), "%sWindowPos2fARB", symbol_prefix);
7205 *procp = dlsym(handle, symboln);
7206 }
7207
7208
7209 if(!disp->WindowPos2fMESA) {
7210 void ** procp = (void **) &disp->WindowPos2fMESA;
7211 snprintf(symboln, sizeof(symboln), "%sWindowPos2fMESA", symbol_prefix);
7212 *procp = dlsym(handle, symboln);
7213 }
7214
7215
7216 if(!disp->WindowPos2fvMESA) {
7217 void ** procp = (void **) &disp->WindowPos2fvMESA;
7218 snprintf(symboln, sizeof(symboln), "%sWindowPos2fv", symbol_prefix);
7219 *procp = dlsym(handle, symboln);
7220 }
7221
7222
7223 if(!disp->WindowPos2fvMESA) {
7224 void ** procp = (void **) &disp->WindowPos2fvMESA;
7225 snprintf(symboln, sizeof(symboln), "%sWindowPos2fvARB", symbol_prefix);
7226 *procp = dlsym(handle, symboln);
7227 }
7228
7229
7230 if(!disp->WindowPos2fvMESA) {
7231 void ** procp = (void **) &disp->WindowPos2fvMESA;
7232 snprintf(symboln, sizeof(symboln), "%sWindowPos2fvMESA", symbol_prefix);
7233 *procp = dlsym(handle, symboln);
7234 }
7235
7236
7237 if(!disp->WindowPos2iMESA) {
7238 void ** procp = (void **) &disp->WindowPos2iMESA;
7239 snprintf(symboln, sizeof(symboln), "%sWindowPos2i", symbol_prefix);
7240 *procp = dlsym(handle, symboln);
7241 }
7242
7243
7244 if(!disp->WindowPos2iMESA) {
7245 void ** procp = (void **) &disp->WindowPos2iMESA;
7246 snprintf(symboln, sizeof(symboln), "%sWindowPos2iARB", symbol_prefix);
7247 *procp = dlsym(handle, symboln);
7248 }
7249
7250
7251 if(!disp->WindowPos2iMESA) {
7252 void ** procp = (void **) &disp->WindowPos2iMESA;
7253 snprintf(symboln, sizeof(symboln), "%sWindowPos2iMESA", symbol_prefix);
7254 *procp = dlsym(handle, symboln);
7255 }
7256
7257
7258 if(!disp->WindowPos2ivMESA) {
7259 void ** procp = (void **) &disp->WindowPos2ivMESA;
7260 snprintf(symboln, sizeof(symboln), "%sWindowPos2iv", symbol_prefix);
7261 *procp = dlsym(handle, symboln);
7262 }
7263
7264
7265 if(!disp->WindowPos2ivMESA) {
7266 void ** procp = (void **) &disp->WindowPos2ivMESA;
7267 snprintf(symboln, sizeof(symboln), "%sWindowPos2ivARB", symbol_prefix);
7268 *procp = dlsym(handle, symboln);
7269 }
7270
7271
7272 if(!disp->WindowPos2ivMESA) {
7273 void ** procp = (void **) &disp->WindowPos2ivMESA;
7274 snprintf(symboln, sizeof(symboln), "%sWindowPos2ivMESA", symbol_prefix);
7275 *procp = dlsym(handle, symboln);
7276 }
7277
7278
7279 if(!disp->WindowPos2sMESA) {
7280 void ** procp = (void **) &disp->WindowPos2sMESA;
7281 snprintf(symboln, sizeof(symboln), "%sWindowPos2s", symbol_prefix);
7282 *procp = dlsym(handle, symboln);
7283 }
7284
7285
7286 if(!disp->WindowPos2sMESA) {
7287 void ** procp = (void **) &disp->WindowPos2sMESA;
7288 snprintf(symboln, sizeof(symboln), "%sWindowPos2sARB", symbol_prefix);
7289 *procp = dlsym(handle, symboln);
7290 }
7291
7292
7293 if(!disp->WindowPos2sMESA) {
7294 void ** procp = (void **) &disp->WindowPos2sMESA;
7295 snprintf(symboln, sizeof(symboln), "%sWindowPos2sMESA", symbol_prefix);
7296 *procp = dlsym(handle, symboln);
7297 }
7298
7299
7300 if(!disp->WindowPos2svMESA) {
7301 void ** procp = (void **) &disp->WindowPos2svMESA;
7302 snprintf(symboln, sizeof(symboln), "%sWindowPos2sv", symbol_prefix);
7303 *procp = dlsym(handle, symboln);
7304 }
7305
7306
7307 if(!disp->WindowPos2svMESA) {
7308 void ** procp = (void **) &disp->WindowPos2svMESA;
7309 snprintf(symboln, sizeof(symboln), "%sWindowPos2svARB", symbol_prefix);
7310 *procp = dlsym(handle, symboln);
7311 }
7312
7313
7314 if(!disp->WindowPos2svMESA) {
7315 void ** procp = (void **) &disp->WindowPos2svMESA;
7316 snprintf(symboln, sizeof(symboln), "%sWindowPos2svMESA", symbol_prefix);
7317 *procp = dlsym(handle, symboln);
7318 }
7319
7320
7321 if(!disp->WindowPos3dMESA) {
7322 void ** procp = (void **) &disp->WindowPos3dMESA;
7323 snprintf(symboln, sizeof(symboln), "%sWindowPos3d", symbol_prefix);
7324 *procp = dlsym(handle, symboln);
7325 }
7326
7327
7328 if(!disp->WindowPos3dMESA) {
7329 void ** procp = (void **) &disp->WindowPos3dMESA;
7330 snprintf(symboln, sizeof(symboln), "%sWindowPos3dARB", symbol_prefix);
7331 *procp = dlsym(handle, symboln);
7332 }
7333
7334
7335 if(!disp->WindowPos3dMESA) {
7336 void ** procp = (void **) &disp->WindowPos3dMESA;
7337 snprintf(symboln, sizeof(symboln), "%sWindowPos3dMESA", symbol_prefix);
7338 *procp = dlsym(handle, symboln);
7339 }
7340
7341
7342 if(!disp->WindowPos3dvMESA) {
7343 void ** procp = (void **) &disp->WindowPos3dvMESA;
7344 snprintf(symboln, sizeof(symboln), "%sWindowPos3dv", symbol_prefix);
7345 *procp = dlsym(handle, symboln);
7346 }
7347
7348
7349 if(!disp->WindowPos3dvMESA) {
7350 void ** procp = (void **) &disp->WindowPos3dvMESA;
7351 snprintf(symboln, sizeof(symboln), "%sWindowPos3dvARB", symbol_prefix);
7352 *procp = dlsym(handle, symboln);
7353 }
7354
7355
7356 if(!disp->WindowPos3dvMESA) {
7357 void ** procp = (void **) &disp->WindowPos3dvMESA;
7358 snprintf(symboln, sizeof(symboln), "%sWindowPos3dvMESA", symbol_prefix);
7359 *procp = dlsym(handle, symboln);
7360 }
7361
7362
7363 if(!disp->WindowPos3fMESA) {
7364 void ** procp = (void **) &disp->WindowPos3fMESA;
7365 snprintf(symboln, sizeof(symboln), "%sWindowPos3f", symbol_prefix);
7366 *procp = dlsym(handle, symboln);
7367 }
7368
7369
7370 if(!disp->WindowPos3fMESA) {
7371 void ** procp = (void **) &disp->WindowPos3fMESA;
7372 snprintf(symboln, sizeof(symboln), "%sWindowPos3fARB", symbol_prefix);
7373 *procp = dlsym(handle, symboln);
7374 }
7375
7376
7377 if(!disp->WindowPos3fMESA) {
7378 void ** procp = (void **) &disp->WindowPos3fMESA;
7379 snprintf(symboln, sizeof(symboln), "%sWindowPos3fMESA", symbol_prefix);
7380 *procp = dlsym(handle, symboln);
7381 }
7382
7383
7384 if(!disp->WindowPos3fvMESA) {
7385 void ** procp = (void **) &disp->WindowPos3fvMESA;
7386 snprintf(symboln, sizeof(symboln), "%sWindowPos3fv", symbol_prefix);
7387 *procp = dlsym(handle, symboln);
7388 }
7389
7390
7391 if(!disp->WindowPos3fvMESA) {
7392 void ** procp = (void **) &disp->WindowPos3fvMESA;
7393 snprintf(symboln, sizeof(symboln), "%sWindowPos3fvARB", symbol_prefix);
7394 *procp = dlsym(handle, symboln);
7395 }
7396
7397
7398 if(!disp->WindowPos3fvMESA) {
7399 void ** procp = (void **) &disp->WindowPos3fvMESA;
7400 snprintf(symboln, sizeof(symboln), "%sWindowPos3fvMESA", symbol_prefix);
7401 *procp = dlsym(handle, symboln);
7402 }
7403
7404
7405 if(!disp->WindowPos3iMESA) {
7406 void ** procp = (void **) &disp->WindowPos3iMESA;
7407 snprintf(symboln, sizeof(symboln), "%sWindowPos3i", symbol_prefix);
7408 *procp = dlsym(handle, symboln);
7409 }
7410
7411
7412 if(!disp->WindowPos3iMESA) {
7413 void ** procp = (void **) &disp->WindowPos3iMESA;
7414 snprintf(symboln, sizeof(symboln), "%sWindowPos3iARB", symbol_prefix);
7415 *procp = dlsym(handle, symboln);
7416 }
7417
7418
7419 if(!disp->WindowPos3iMESA) {
7420 void ** procp = (void **) &disp->WindowPos3iMESA;
7421 snprintf(symboln, sizeof(symboln), "%sWindowPos3iMESA", symbol_prefix);
7422 *procp = dlsym(handle, symboln);
7423 }
7424
7425
7426 if(!disp->WindowPos3ivMESA) {
7427 void ** procp = (void **) &disp->WindowPos3ivMESA;
7428 snprintf(symboln, sizeof(symboln), "%sWindowPos3iv", symbol_prefix);
7429 *procp = dlsym(handle, symboln);
7430 }
7431
7432
7433 if(!disp->WindowPos3ivMESA) {
7434 void ** procp = (void **) &disp->WindowPos3ivMESA;
7435 snprintf(symboln, sizeof(symboln), "%sWindowPos3ivARB", symbol_prefix);
7436 *procp = dlsym(handle, symboln);
7437 }
7438
7439
7440 if(!disp->WindowPos3ivMESA) {
7441 void ** procp = (void **) &disp->WindowPos3ivMESA;
7442 snprintf(symboln, sizeof(symboln), "%sWindowPos3ivMESA", symbol_prefix);
7443 *procp = dlsym(handle, symboln);
7444 }
7445
7446
7447 if(!disp->WindowPos3sMESA) {
7448 void ** procp = (void **) &disp->WindowPos3sMESA;
7449 snprintf(symboln, sizeof(symboln), "%sWindowPos3s", symbol_prefix);
7450 *procp = dlsym(handle, symboln);
7451 }
7452
7453
7454 if(!disp->WindowPos3sMESA) {
7455 void ** procp = (void **) &disp->WindowPos3sMESA;
7456 snprintf(symboln, sizeof(symboln), "%sWindowPos3sARB", symbol_prefix);
7457 *procp = dlsym(handle, symboln);
7458 }
7459
7460
7461 if(!disp->WindowPos3sMESA) {
7462 void ** procp = (void **) &disp->WindowPos3sMESA;
7463 snprintf(symboln, sizeof(symboln), "%sWindowPos3sMESA", symbol_prefix);
7464 *procp = dlsym(handle, symboln);
7465 }
7466
7467
7468 if(!disp->WindowPos3svMESA) {
7469 void ** procp = (void **) &disp->WindowPos3svMESA;
7470 snprintf(symboln, sizeof(symboln), "%sWindowPos3sv", symbol_prefix);
7471 *procp = dlsym(handle, symboln);
7472 }
7473
7474
7475 if(!disp->WindowPos3svMESA) {
7476 void ** procp = (void **) &disp->WindowPos3svMESA;
7477 snprintf(symboln, sizeof(symboln), "%sWindowPos3svARB", symbol_prefix);
7478 *procp = dlsym(handle, symboln);
7479 }
7480
7481
7482 if(!disp->WindowPos3svMESA) {
7483 void ** procp = (void **) &disp->WindowPos3svMESA;
7484 snprintf(symboln, sizeof(symboln), "%sWindowPos3svMESA", symbol_prefix);
7485 *procp = dlsym(handle, symboln);
7486 }
7487
7488
7489 if(!disp->WindowPos4dMESA) {
7490 void ** procp = (void **) &disp->WindowPos4dMESA;
7491 snprintf(symboln, sizeof(symboln), "%sWindowPos4dMESA", symbol_prefix);
7492 *procp = dlsym(handle, symboln);
7493 }
7494
7495
7496 if(!disp->WindowPos4dvMESA) {
7497 void ** procp = (void **) &disp->WindowPos4dvMESA;
7498 snprintf(symboln, sizeof(symboln), "%sWindowPos4dvMESA", symbol_prefix);
7499 *procp = dlsym(handle, symboln);
7500 }
7501
7502
7503 if(!disp->WindowPos4fMESA) {
7504 void ** procp = (void **) &disp->WindowPos4fMESA;
7505 snprintf(symboln, sizeof(symboln), "%sWindowPos4fMESA", symbol_prefix);
7506 *procp = dlsym(handle, symboln);
7507 }
7508
7509
7510 if(!disp->WindowPos4fvMESA) {
7511 void ** procp = (void **) &disp->WindowPos4fvMESA;
7512 snprintf(symboln, sizeof(symboln), "%sWindowPos4fvMESA", symbol_prefix);
7513 *procp = dlsym(handle, symboln);
7514 }
7515
7516
7517 if(!disp->WindowPos4iMESA) {
7518 void ** procp = (void **) &disp->WindowPos4iMESA;
7519 snprintf(symboln, sizeof(symboln), "%sWindowPos4iMESA", symbol_prefix);
7520 *procp = dlsym(handle, symboln);
7521 }
7522
7523
7524 if(!disp->WindowPos4ivMESA) {
7525 void ** procp = (void **) &disp->WindowPos4ivMESA;
7526 snprintf(symboln, sizeof(symboln), "%sWindowPos4ivMESA", symbol_prefix);
7527 *procp = dlsym(handle, symboln);
7528 }
7529
7530
7531 if(!disp->WindowPos4sMESA) {
7532 void ** procp = (void **) &disp->WindowPos4sMESA;
7533 snprintf(symboln, sizeof(symboln), "%sWindowPos4sMESA", symbol_prefix);
7534 *procp = dlsym(handle, symboln);
7535 }
7536
7537
7538 if(!disp->WindowPos4svMESA) {
7539 void ** procp = (void **) &disp->WindowPos4svMESA;
7540 snprintf(symboln, sizeof(symboln), "%sWindowPos4svMESA", symbol_prefix);
7541 *procp = dlsym(handle, symboln);
7542 }
7543
7544
7545 if(!disp->MultiModeDrawArraysIBM) {
7546 void ** procp = (void **) &disp->MultiModeDrawArraysIBM;
7547 snprintf(symboln, sizeof(symboln), "%sMultiModeDrawArraysIBM", symbol_prefix);
7548 *procp = dlsym(handle, symboln);
7549 }
7550
7551
7552 if(!disp->MultiModeDrawElementsIBM) {
7553 void ** procp = (void **) &disp->MultiModeDrawElementsIBM;
7554 snprintf(symboln, sizeof(symboln), "%sMultiModeDrawElementsIBM", symbol_prefix);
7555 *procp = dlsym(handle, symboln);
7556 }
7557
7558
7559 if(!disp->AreProgramsResidentNV) {
7560 void ** procp = (void **) &disp->AreProgramsResidentNV;
7561 snprintf(symboln, sizeof(symboln), "%sAreProgramsResidentNV", symbol_prefix);
7562 *procp = dlsym(handle, symboln);
7563 }
7564
7565
7566 if(!disp->BindProgramNV) {
7567 void ** procp = (void **) &disp->BindProgramNV;
7568 snprintf(symboln, sizeof(symboln), "%sBindProgramARB", symbol_prefix);
7569 *procp = dlsym(handle, symboln);
7570 }
7571
7572
7573 if(!disp->BindProgramNV) {
7574 void ** procp = (void **) &disp->BindProgramNV;
7575 snprintf(symboln, sizeof(symboln), "%sBindProgramNV", symbol_prefix);
7576 *procp = dlsym(handle, symboln);
7577 }
7578
7579
7580 if(!disp->DeleteProgramsNV) {
7581 void ** procp = (void **) &disp->DeleteProgramsNV;
7582 snprintf(symboln, sizeof(symboln), "%sDeleteProgramsARB", symbol_prefix);
7583 *procp = dlsym(handle, symboln);
7584 }
7585
7586
7587 if(!disp->DeleteProgramsNV) {
7588 void ** procp = (void **) &disp->DeleteProgramsNV;
7589 snprintf(symboln, sizeof(symboln), "%sDeleteProgramsNV", symbol_prefix);
7590 *procp = dlsym(handle, symboln);
7591 }
7592
7593
7594 if(!disp->ExecuteProgramNV) {
7595 void ** procp = (void **) &disp->ExecuteProgramNV;
7596 snprintf(symboln, sizeof(symboln), "%sExecuteProgramNV", symbol_prefix);
7597 *procp = dlsym(handle, symboln);
7598 }
7599
7600
7601 if(!disp->GenProgramsNV) {
7602 void ** procp = (void **) &disp->GenProgramsNV;
7603 snprintf(symboln, sizeof(symboln), "%sGenProgramsARB", symbol_prefix);
7604 *procp = dlsym(handle, symboln);
7605 }
7606
7607
7608 if(!disp->GenProgramsNV) {
7609 void ** procp = (void **) &disp->GenProgramsNV;
7610 snprintf(symboln, sizeof(symboln), "%sGenProgramsNV", symbol_prefix);
7611 *procp = dlsym(handle, symboln);
7612 }
7613
7614
7615 if(!disp->GetProgramParameterdvNV) {
7616 void ** procp = (void **) &disp->GetProgramParameterdvNV;
7617 snprintf(symboln, sizeof(symboln), "%sGetProgramParameterdvNV", symbol_prefix);
7618 *procp = dlsym(handle, symboln);
7619 }
7620
7621
7622 if(!disp->GetProgramParameterfvNV) {
7623 void ** procp = (void **) &disp->GetProgramParameterfvNV;
7624 snprintf(symboln, sizeof(symboln), "%sGetProgramParameterfvNV", symbol_prefix);
7625 *procp = dlsym(handle, symboln);
7626 }
7627
7628
7629 if(!disp->GetProgramStringNV) {
7630 void ** procp = (void **) &disp->GetProgramStringNV;
7631 snprintf(symboln, sizeof(symboln), "%sGetProgramStringNV", symbol_prefix);
7632 *procp = dlsym(handle, symboln);
7633 }
7634
7635
7636 if(!disp->GetProgramivNV) {
7637 void ** procp = (void **) &disp->GetProgramivNV;
7638 snprintf(symboln, sizeof(symboln), "%sGetProgramivNV", symbol_prefix);
7639 *procp = dlsym(handle, symboln);
7640 }
7641
7642
7643 if(!disp->GetTrackMatrixivNV) {
7644 void ** procp = (void **) &disp->GetTrackMatrixivNV;
7645 snprintf(symboln, sizeof(symboln), "%sGetTrackMatrixivNV", symbol_prefix);
7646 *procp = dlsym(handle, symboln);
7647 }
7648
7649
7650 if(!disp->GetVertexAttribPointervNV) {
7651 void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7652 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointerv", symbol_prefix);
7653 *procp = dlsym(handle, symboln);
7654 }
7655
7656
7657 if(!disp->GetVertexAttribPointervNV) {
7658 void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7659 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointervARB", symbol_prefix);
7660 *procp = dlsym(handle, symboln);
7661 }
7662
7663
7664 if(!disp->GetVertexAttribPointervNV) {
7665 void ** procp = (void **) &disp->GetVertexAttribPointervNV;
7666 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribPointervNV", symbol_prefix);
7667 *procp = dlsym(handle, symboln);
7668 }
7669
7670
7671 if(!disp->GetVertexAttribdvNV) {
7672 void ** procp = (void **) &disp->GetVertexAttribdvNV;
7673 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribdvNV", symbol_prefix);
7674 *procp = dlsym(handle, symboln);
7675 }
7676
7677
7678 if(!disp->GetVertexAttribfvNV) {
7679 void ** procp = (void **) &disp->GetVertexAttribfvNV;
7680 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribfvNV", symbol_prefix);
7681 *procp = dlsym(handle, symboln);
7682 }
7683
7684
7685 if(!disp->GetVertexAttribivNV) {
7686 void ** procp = (void **) &disp->GetVertexAttribivNV;
7687 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribivNV", symbol_prefix);
7688 *procp = dlsym(handle, symboln);
7689 }
7690
7691
7692 if(!disp->IsProgramNV) {
7693 void ** procp = (void **) &disp->IsProgramNV;
7694 snprintf(symboln, sizeof(symboln), "%sIsProgramARB", symbol_prefix);
7695 *procp = dlsym(handle, symboln);
7696 }
7697
7698
7699 if(!disp->IsProgramNV) {
7700 void ** procp = (void **) &disp->IsProgramNV;
7701 snprintf(symboln, sizeof(symboln), "%sIsProgramNV", symbol_prefix);
7702 *procp = dlsym(handle, symboln);
7703 }
7704
7705
7706 if(!disp->LoadProgramNV) {
7707 void ** procp = (void **) &disp->LoadProgramNV;
7708 snprintf(symboln, sizeof(symboln), "%sLoadProgramNV", symbol_prefix);
7709 *procp = dlsym(handle, symboln);
7710 }
7711
7712
7713 if(!disp->ProgramParameters4dvNV) {
7714 void ** procp = (void **) &disp->ProgramParameters4dvNV;
7715 snprintf(symboln, sizeof(symboln), "%sProgramParameters4dvNV", symbol_prefix);
7716 *procp = dlsym(handle, symboln);
7717 }
7718
7719
7720 if(!disp->ProgramParameters4fvNV) {
7721 void ** procp = (void **) &disp->ProgramParameters4fvNV;
7722 snprintf(symboln, sizeof(symboln), "%sProgramParameters4fvNV", symbol_prefix);
7723 *procp = dlsym(handle, symboln);
7724 }
7725
7726
7727 if(!disp->RequestResidentProgramsNV) {
7728 void ** procp = (void **) &disp->RequestResidentProgramsNV;
7729 snprintf(symboln, sizeof(symboln), "%sRequestResidentProgramsNV", symbol_prefix);
7730 *procp = dlsym(handle, symboln);
7731 }
7732
7733
7734 if(!disp->TrackMatrixNV) {
7735 void ** procp = (void **) &disp->TrackMatrixNV;
7736 snprintf(symboln, sizeof(symboln), "%sTrackMatrixNV", symbol_prefix);
7737 *procp = dlsym(handle, symboln);
7738 }
7739
7740
7741 if(!disp->VertexAttrib1dNV) {
7742 void ** procp = (void **) &disp->VertexAttrib1dNV;
7743 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dNV", symbol_prefix);
7744 *procp = dlsym(handle, symboln);
7745 }
7746
7747
7748 if(!disp->VertexAttrib1dvNV) {
7749 void ** procp = (void **) &disp->VertexAttrib1dvNV;
7750 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1dvNV", symbol_prefix);
7751 *procp = dlsym(handle, symboln);
7752 }
7753
7754
7755 if(!disp->VertexAttrib1fNV) {
7756 void ** procp = (void **) &disp->VertexAttrib1fNV;
7757 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fNV", symbol_prefix);
7758 *procp = dlsym(handle, symboln);
7759 }
7760
7761
7762 if(!disp->VertexAttrib1fvNV) {
7763 void ** procp = (void **) &disp->VertexAttrib1fvNV;
7764 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1fvNV", symbol_prefix);
7765 *procp = dlsym(handle, symboln);
7766 }
7767
7768
7769 if(!disp->VertexAttrib1sNV) {
7770 void ** procp = (void **) &disp->VertexAttrib1sNV;
7771 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1sNV", symbol_prefix);
7772 *procp = dlsym(handle, symboln);
7773 }
7774
7775
7776 if(!disp->VertexAttrib1svNV) {
7777 void ** procp = (void **) &disp->VertexAttrib1svNV;
7778 snprintf(symboln, sizeof(symboln), "%sVertexAttrib1svNV", symbol_prefix);
7779 *procp = dlsym(handle, symboln);
7780 }
7781
7782
7783 if(!disp->VertexAttrib2dNV) {
7784 void ** procp = (void **) &disp->VertexAttrib2dNV;
7785 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dNV", symbol_prefix);
7786 *procp = dlsym(handle, symboln);
7787 }
7788
7789
7790 if(!disp->VertexAttrib2dvNV) {
7791 void ** procp = (void **) &disp->VertexAttrib2dvNV;
7792 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2dvNV", symbol_prefix);
7793 *procp = dlsym(handle, symboln);
7794 }
7795
7796
7797 if(!disp->VertexAttrib2fNV) {
7798 void ** procp = (void **) &disp->VertexAttrib2fNV;
7799 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fNV", symbol_prefix);
7800 *procp = dlsym(handle, symboln);
7801 }
7802
7803
7804 if(!disp->VertexAttrib2fvNV) {
7805 void ** procp = (void **) &disp->VertexAttrib2fvNV;
7806 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2fvNV", symbol_prefix);
7807 *procp = dlsym(handle, symboln);
7808 }
7809
7810
7811 if(!disp->VertexAttrib2sNV) {
7812 void ** procp = (void **) &disp->VertexAttrib2sNV;
7813 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2sNV", symbol_prefix);
7814 *procp = dlsym(handle, symboln);
7815 }
7816
7817
7818 if(!disp->VertexAttrib2svNV) {
7819 void ** procp = (void **) &disp->VertexAttrib2svNV;
7820 snprintf(symboln, sizeof(symboln), "%sVertexAttrib2svNV", symbol_prefix);
7821 *procp = dlsym(handle, symboln);
7822 }
7823
7824
7825 if(!disp->VertexAttrib3dNV) {
7826 void ** procp = (void **) &disp->VertexAttrib3dNV;
7827 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dNV", symbol_prefix);
7828 *procp = dlsym(handle, symboln);
7829 }
7830
7831
7832 if(!disp->VertexAttrib3dvNV) {
7833 void ** procp = (void **) &disp->VertexAttrib3dvNV;
7834 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3dvNV", symbol_prefix);
7835 *procp = dlsym(handle, symboln);
7836 }
7837
7838
7839 if(!disp->VertexAttrib3fNV) {
7840 void ** procp = (void **) &disp->VertexAttrib3fNV;
7841 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fNV", symbol_prefix);
7842 *procp = dlsym(handle, symboln);
7843 }
7844
7845
7846 if(!disp->VertexAttrib3fvNV) {
7847 void ** procp = (void **) &disp->VertexAttrib3fvNV;
7848 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3fvNV", symbol_prefix);
7849 *procp = dlsym(handle, symboln);
7850 }
7851
7852
7853 if(!disp->VertexAttrib3sNV) {
7854 void ** procp = (void **) &disp->VertexAttrib3sNV;
7855 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3sNV", symbol_prefix);
7856 *procp = dlsym(handle, symboln);
7857 }
7858
7859
7860 if(!disp->VertexAttrib3svNV) {
7861 void ** procp = (void **) &disp->VertexAttrib3svNV;
7862 snprintf(symboln, sizeof(symboln), "%sVertexAttrib3svNV", symbol_prefix);
7863 *procp = dlsym(handle, symboln);
7864 }
7865
7866
7867 if(!disp->VertexAttrib4dNV) {
7868 void ** procp = (void **) &disp->VertexAttrib4dNV;
7869 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dNV", symbol_prefix);
7870 *procp = dlsym(handle, symboln);
7871 }
7872
7873
7874 if(!disp->VertexAttrib4dvNV) {
7875 void ** procp = (void **) &disp->VertexAttrib4dvNV;
7876 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4dvNV", symbol_prefix);
7877 *procp = dlsym(handle, symboln);
7878 }
7879
7880
7881 if(!disp->VertexAttrib4fNV) {
7882 void ** procp = (void **) &disp->VertexAttrib4fNV;
7883 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fNV", symbol_prefix);
7884 *procp = dlsym(handle, symboln);
7885 }
7886
7887
7888 if(!disp->VertexAttrib4fvNV) {
7889 void ** procp = (void **) &disp->VertexAttrib4fvNV;
7890 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4fvNV", symbol_prefix);
7891 *procp = dlsym(handle, symboln);
7892 }
7893
7894
7895 if(!disp->VertexAttrib4sNV) {
7896 void ** procp = (void **) &disp->VertexAttrib4sNV;
7897 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4sNV", symbol_prefix);
7898 *procp = dlsym(handle, symboln);
7899 }
7900
7901
7902 if(!disp->VertexAttrib4svNV) {
7903 void ** procp = (void **) &disp->VertexAttrib4svNV;
7904 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4svNV", symbol_prefix);
7905 *procp = dlsym(handle, symboln);
7906 }
7907
7908
7909 if(!disp->VertexAttrib4ubNV) {
7910 void ** procp = (void **) &disp->VertexAttrib4ubNV;
7911 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubNV", symbol_prefix);
7912 *procp = dlsym(handle, symboln);
7913 }
7914
7915
7916 if(!disp->VertexAttrib4ubvNV) {
7917 void ** procp = (void **) &disp->VertexAttrib4ubvNV;
7918 snprintf(symboln, sizeof(symboln), "%sVertexAttrib4ubvNV", symbol_prefix);
7919 *procp = dlsym(handle, symboln);
7920 }
7921
7922
7923 if(!disp->VertexAttribPointerNV) {
7924 void ** procp = (void **) &disp->VertexAttribPointerNV;
7925 snprintf(symboln, sizeof(symboln), "%sVertexAttribPointerNV", symbol_prefix);
7926 *procp = dlsym(handle, symboln);
7927 }
7928
7929
7930 if(!disp->VertexAttribs1dvNV) {
7931 void ** procp = (void **) &disp->VertexAttribs1dvNV;
7932 snprintf(symboln, sizeof(symboln), "%sVertexAttribs1dvNV", symbol_prefix);
7933 *procp = dlsym(handle, symboln);
7934 }
7935
7936
7937 if(!disp->VertexAttribs1fvNV) {
7938 void ** procp = (void **) &disp->VertexAttribs1fvNV;
7939 snprintf(symboln, sizeof(symboln), "%sVertexAttribs1fvNV", symbol_prefix);
7940 *procp = dlsym(handle, symboln);
7941 }
7942
7943
7944 if(!disp->VertexAttribs1svNV) {
7945 void ** procp = (void **) &disp->VertexAttribs1svNV;
7946 snprintf(symboln, sizeof(symboln), "%sVertexAttribs1svNV", symbol_prefix);
7947 *procp = dlsym(handle, symboln);
7948 }
7949
7950
7951 if(!disp->VertexAttribs2dvNV) {
7952 void ** procp = (void **) &disp->VertexAttribs2dvNV;
7953 snprintf(symboln, sizeof(symboln), "%sVertexAttribs2dvNV", symbol_prefix);
7954 *procp = dlsym(handle, symboln);
7955 }
7956
7957
7958 if(!disp->VertexAttribs2fvNV) {
7959 void ** procp = (void **) &disp->VertexAttribs2fvNV;
7960 snprintf(symboln, sizeof(symboln), "%sVertexAttribs2fvNV", symbol_prefix);
7961 *procp = dlsym(handle, symboln);
7962 }
7963
7964
7965 if(!disp->VertexAttribs2svNV) {
7966 void ** procp = (void **) &disp->VertexAttribs2svNV;
7967 snprintf(symboln, sizeof(symboln), "%sVertexAttribs2svNV", symbol_prefix);
7968 *procp = dlsym(handle, symboln);
7969 }
7970
7971
7972 if(!disp->VertexAttribs3dvNV) {
7973 void ** procp = (void **) &disp->VertexAttribs3dvNV;
7974 snprintf(symboln, sizeof(symboln), "%sVertexAttribs3dvNV", symbol_prefix);
7975 *procp = dlsym(handle, symboln);
7976 }
7977
7978
7979 if(!disp->VertexAttribs3fvNV) {
7980 void ** procp = (void **) &disp->VertexAttribs3fvNV;
7981 snprintf(symboln, sizeof(symboln), "%sVertexAttribs3fvNV", symbol_prefix);
7982 *procp = dlsym(handle, symboln);
7983 }
7984
7985
7986 if(!disp->VertexAttribs3svNV) {
7987 void ** procp = (void **) &disp->VertexAttribs3svNV;
7988 snprintf(symboln, sizeof(symboln), "%sVertexAttribs3svNV", symbol_prefix);
7989 *procp = dlsym(handle, symboln);
7990 }
7991
7992
7993 if(!disp->VertexAttribs4dvNV) {
7994 void ** procp = (void **) &disp->VertexAttribs4dvNV;
7995 snprintf(symboln, sizeof(symboln), "%sVertexAttribs4dvNV", symbol_prefix);
7996 *procp = dlsym(handle, symboln);
7997 }
7998
7999
8000 if(!disp->VertexAttribs4fvNV) {
8001 void ** procp = (void **) &disp->VertexAttribs4fvNV;
8002 snprintf(symboln, sizeof(symboln), "%sVertexAttribs4fvNV", symbol_prefix);
8003 *procp = dlsym(handle, symboln);
8004 }
8005
8006
8007 if(!disp->VertexAttribs4svNV) {
8008 void ** procp = (void **) &disp->VertexAttribs4svNV;
8009 snprintf(symboln, sizeof(symboln), "%sVertexAttribs4svNV", symbol_prefix);
8010 *procp = dlsym(handle, symboln);
8011 }
8012
8013
8014 if(!disp->VertexAttribs4ubvNV) {
8015 void ** procp = (void **) &disp->VertexAttribs4ubvNV;
8016 snprintf(symboln, sizeof(symboln), "%sVertexAttribs4ubvNV", symbol_prefix);
8017 *procp = dlsym(handle, symboln);
8018 }
8019
8020
8021 if(!disp->GetTexBumpParameterfvATI) {
8022 void ** procp = (void **) &disp->GetTexBumpParameterfvATI;
8023 snprintf(symboln, sizeof(symboln), "%sGetTexBumpParameterfvATI", symbol_prefix);
8024 *procp = dlsym(handle, symboln);
8025 }
8026
8027
8028 if(!disp->GetTexBumpParameterivATI) {
8029 void ** procp = (void **) &disp->GetTexBumpParameterivATI;
8030 snprintf(symboln, sizeof(symboln), "%sGetTexBumpParameterivATI", symbol_prefix);
8031 *procp = dlsym(handle, symboln);
8032 }
8033
8034
8035 if(!disp->TexBumpParameterfvATI) {
8036 void ** procp = (void **) &disp->TexBumpParameterfvATI;
8037 snprintf(symboln, sizeof(symboln), "%sTexBumpParameterfvATI", symbol_prefix);
8038 *procp = dlsym(handle, symboln);
8039 }
8040
8041
8042 if(!disp->TexBumpParameterivATI) {
8043 void ** procp = (void **) &disp->TexBumpParameterivATI;
8044 snprintf(symboln, sizeof(symboln), "%sTexBumpParameterivATI", symbol_prefix);
8045 *procp = dlsym(handle, symboln);
8046 }
8047
8048
8049 if(!disp->AlphaFragmentOp1ATI) {
8050 void ** procp = (void **) &disp->AlphaFragmentOp1ATI;
8051 snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp1ATI", symbol_prefix);
8052 *procp = dlsym(handle, symboln);
8053 }
8054
8055
8056 if(!disp->AlphaFragmentOp2ATI) {
8057 void ** procp = (void **) &disp->AlphaFragmentOp2ATI;
8058 snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp2ATI", symbol_prefix);
8059 *procp = dlsym(handle, symboln);
8060 }
8061
8062
8063 if(!disp->AlphaFragmentOp3ATI) {
8064 void ** procp = (void **) &disp->AlphaFragmentOp3ATI;
8065 snprintf(symboln, sizeof(symboln), "%sAlphaFragmentOp3ATI", symbol_prefix);
8066 *procp = dlsym(handle, symboln);
8067 }
8068
8069
8070 if(!disp->BeginFragmentShaderATI) {
8071 void ** procp = (void **) &disp->BeginFragmentShaderATI;
8072 snprintf(symboln, sizeof(symboln), "%sBeginFragmentShaderATI", symbol_prefix);
8073 *procp = dlsym(handle, symboln);
8074 }
8075
8076
8077 if(!disp->BindFragmentShaderATI) {
8078 void ** procp = (void **) &disp->BindFragmentShaderATI;
8079 snprintf(symboln, sizeof(symboln), "%sBindFragmentShaderATI", symbol_prefix);
8080 *procp = dlsym(handle, symboln);
8081 }
8082
8083
8084 if(!disp->ColorFragmentOp1ATI) {
8085 void ** procp = (void **) &disp->ColorFragmentOp1ATI;
8086 snprintf(symboln, sizeof(symboln), "%sColorFragmentOp1ATI", symbol_prefix);
8087 *procp = dlsym(handle, symboln);
8088 }
8089
8090
8091 if(!disp->ColorFragmentOp2ATI) {
8092 void ** procp = (void **) &disp->ColorFragmentOp2ATI;
8093 snprintf(symboln, sizeof(symboln), "%sColorFragmentOp2ATI", symbol_prefix);
8094 *procp = dlsym(handle, symboln);
8095 }
8096
8097
8098 if(!disp->ColorFragmentOp3ATI) {
8099 void ** procp = (void **) &disp->ColorFragmentOp3ATI;
8100 snprintf(symboln, sizeof(symboln), "%sColorFragmentOp3ATI", symbol_prefix);
8101 *procp = dlsym(handle, symboln);
8102 }
8103
8104
8105 if(!disp->DeleteFragmentShaderATI) {
8106 void ** procp = (void **) &disp->DeleteFragmentShaderATI;
8107 snprintf(symboln, sizeof(symboln), "%sDeleteFragmentShaderATI", symbol_prefix);
8108 *procp = dlsym(handle, symboln);
8109 }
8110
8111
8112 if(!disp->EndFragmentShaderATI) {
8113 void ** procp = (void **) &disp->EndFragmentShaderATI;
8114 snprintf(symboln, sizeof(symboln), "%sEndFragmentShaderATI", symbol_prefix);
8115 *procp = dlsym(handle, symboln);
8116 }
8117
8118
8119 if(!disp->GenFragmentShadersATI) {
8120 void ** procp = (void **) &disp->GenFragmentShadersATI;
8121 snprintf(symboln, sizeof(symboln), "%sGenFragmentShadersATI", symbol_prefix);
8122 *procp = dlsym(handle, symboln);
8123 }
8124
8125
8126 if(!disp->PassTexCoordATI) {
8127 void ** procp = (void **) &disp->PassTexCoordATI;
8128 snprintf(symboln, sizeof(symboln), "%sPassTexCoordATI", symbol_prefix);
8129 *procp = dlsym(handle, symboln);
8130 }
8131
8132
8133 if(!disp->SampleMapATI) {
8134 void ** procp = (void **) &disp->SampleMapATI;
8135 snprintf(symboln, sizeof(symboln), "%sSampleMapATI", symbol_prefix);
8136 *procp = dlsym(handle, symboln);
8137 }
8138
8139
8140 if(!disp->SetFragmentShaderConstantATI) {
8141 void ** procp = (void **) &disp->SetFragmentShaderConstantATI;
8142 snprintf(symboln, sizeof(symboln), "%sSetFragmentShaderConstantATI", symbol_prefix);
8143 *procp = dlsym(handle, symboln);
8144 }
8145
8146
8147 if(!disp->PointParameteriNV) {
8148 void ** procp = (void **) &disp->PointParameteriNV;
8149 snprintf(symboln, sizeof(symboln), "%sPointParameteri", symbol_prefix);
8150 *procp = dlsym(handle, symboln);
8151 }
8152
8153
8154 if(!disp->PointParameteriNV) {
8155 void ** procp = (void **) &disp->PointParameteriNV;
8156 snprintf(symboln, sizeof(symboln), "%sPointParameteriNV", symbol_prefix);
8157 *procp = dlsym(handle, symboln);
8158 }
8159
8160
8161 if(!disp->PointParameterivNV) {
8162 void ** procp = (void **) &disp->PointParameterivNV;
8163 snprintf(symboln, sizeof(symboln), "%sPointParameteriv", symbol_prefix);
8164 *procp = dlsym(handle, symboln);
8165 }
8166
8167
8168 if(!disp->PointParameterivNV) {
8169 void ** procp = (void **) &disp->PointParameterivNV;
8170 snprintf(symboln, sizeof(symboln), "%sPointParameterivNV", symbol_prefix);
8171 *procp = dlsym(handle, symboln);
8172 }
8173
8174
8175 if(!disp->ActiveStencilFaceEXT) {
8176 void ** procp = (void **) &disp->ActiveStencilFaceEXT;
8177 snprintf(symboln, sizeof(symboln), "%sActiveStencilFaceEXT", symbol_prefix);
8178 *procp = dlsym(handle, symboln);
8179 }
8180
8181
8182 if(!disp->BindVertexArrayAPPLE) {
8183 void ** procp = (void **) &disp->BindVertexArrayAPPLE;
8184 snprintf(symboln, sizeof(symboln), "%sBindVertexArrayAPPLE", symbol_prefix);
8185 *procp = dlsym(handle, symboln);
8186 }
8187
8188
8189 if(!disp->DeleteVertexArraysAPPLE) {
8190 void ** procp = (void **) &disp->DeleteVertexArraysAPPLE;
8191 snprintf(symboln, sizeof(symboln), "%sDeleteVertexArrays", symbol_prefix);
8192 *procp = dlsym(handle, symboln);
8193 }
8194
8195
8196 if(!disp->DeleteVertexArraysAPPLE) {
8197 void ** procp = (void **) &disp->DeleteVertexArraysAPPLE;
8198 snprintf(symboln, sizeof(symboln), "%sDeleteVertexArraysAPPLE", symbol_prefix);
8199 *procp = dlsym(handle, symboln);
8200 }
8201
8202
8203 if(!disp->GenVertexArraysAPPLE) {
8204 void ** procp = (void **) &disp->GenVertexArraysAPPLE;
8205 snprintf(symboln, sizeof(symboln), "%sGenVertexArraysAPPLE", symbol_prefix);
8206 *procp = dlsym(handle, symboln);
8207 }
8208
8209
8210 if(!disp->IsVertexArrayAPPLE) {
8211 void ** procp = (void **) &disp->IsVertexArrayAPPLE;
8212 snprintf(symboln, sizeof(symboln), "%sIsVertexArray", symbol_prefix);
8213 *procp = dlsym(handle, symboln);
8214 }
8215
8216
8217 if(!disp->IsVertexArrayAPPLE) {
8218 void ** procp = (void **) &disp->IsVertexArrayAPPLE;
8219 snprintf(symboln, sizeof(symboln), "%sIsVertexArrayAPPLE", symbol_prefix);
8220 *procp = dlsym(handle, symboln);
8221 }
8222
8223
8224 if(!disp->GetProgramNamedParameterdvNV) {
8225 void ** procp = (void **) &disp->GetProgramNamedParameterdvNV;
8226 snprintf(symboln, sizeof(symboln), "%sGetProgramNamedParameterdvNV", symbol_prefix);
8227 *procp = dlsym(handle, symboln);
8228 }
8229
8230
8231 if(!disp->GetProgramNamedParameterfvNV) {
8232 void ** procp = (void **) &disp->GetProgramNamedParameterfvNV;
8233 snprintf(symboln, sizeof(symboln), "%sGetProgramNamedParameterfvNV", symbol_prefix);
8234 *procp = dlsym(handle, symboln);
8235 }
8236
8237
8238 if(!disp->ProgramNamedParameter4dNV) {
8239 void ** procp = (void **) &disp->ProgramNamedParameter4dNV;
8240 snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4dNV", symbol_prefix);
8241 *procp = dlsym(handle, symboln);
8242 }
8243
8244
8245 if(!disp->ProgramNamedParameter4dvNV) {
8246 void ** procp = (void **) &disp->ProgramNamedParameter4dvNV;
8247 snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4dvNV", symbol_prefix);
8248 *procp = dlsym(handle, symboln);
8249 }
8250
8251
8252 if(!disp->ProgramNamedParameter4fNV) {
8253 void ** procp = (void **) &disp->ProgramNamedParameter4fNV;
8254 snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4fNV", symbol_prefix);
8255 *procp = dlsym(handle, symboln);
8256 }
8257
8258
8259 if(!disp->ProgramNamedParameter4fvNV) {
8260 void ** procp = (void **) &disp->ProgramNamedParameter4fvNV;
8261 snprintf(symboln, sizeof(symboln), "%sProgramNamedParameter4fvNV", symbol_prefix);
8262 *procp = dlsym(handle, symboln);
8263 }
8264
8265
8266 if(!disp->PrimitiveRestartIndexNV) {
8267 void ** procp = (void **) &disp->PrimitiveRestartIndexNV;
8268 snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartIndex", symbol_prefix);
8269 *procp = dlsym(handle, symboln);
8270 }
8271
8272
8273 if(!disp->PrimitiveRestartIndexNV) {
8274 void ** procp = (void **) &disp->PrimitiveRestartIndexNV;
8275 snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartIndexNV", symbol_prefix);
8276 *procp = dlsym(handle, symboln);
8277 }
8278
8279
8280 if(!disp->PrimitiveRestartNV) {
8281 void ** procp = (void **) &disp->PrimitiveRestartNV;
8282 snprintf(symboln, sizeof(symboln), "%sPrimitiveRestartNV", symbol_prefix);
8283 *procp = dlsym(handle, symboln);
8284 }
8285
8286
8287 if(!disp->DepthBoundsEXT) {
8288 void ** procp = (void **) &disp->DepthBoundsEXT;
8289 snprintf(symboln, sizeof(symboln), "%sDepthBoundsEXT", symbol_prefix);
8290 *procp = dlsym(handle, symboln);
8291 }
8292
8293
8294 if(!disp->BlendEquationSeparateEXT) {
8295 void ** procp = (void **) &disp->BlendEquationSeparateEXT;
8296 snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparate", symbol_prefix);
8297 *procp = dlsym(handle, symboln);
8298 }
8299
8300
8301 if(!disp->BlendEquationSeparateEXT) {
8302 void ** procp = (void **) &disp->BlendEquationSeparateEXT;
8303 snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateEXT", symbol_prefix);
8304 *procp = dlsym(handle, symboln);
8305 }
8306
8307
8308 if(!disp->BlendEquationSeparateEXT) {
8309 void ** procp = (void **) &disp->BlendEquationSeparateEXT;
8310 snprintf(symboln, sizeof(symboln), "%sBlendEquationSeparateATI", symbol_prefix);
8311 *procp = dlsym(handle, symboln);
8312 }
8313
8314
8315 if(!disp->BindFramebufferEXT) {
8316 void ** procp = (void **) &disp->BindFramebufferEXT;
8317 snprintf(symboln, sizeof(symboln), "%sBindFramebuffer", symbol_prefix);
8318 *procp = dlsym(handle, symboln);
8319 }
8320
8321
8322 if(!disp->BindFramebufferEXT) {
8323 void ** procp = (void **) &disp->BindFramebufferEXT;
8324 snprintf(symboln, sizeof(symboln), "%sBindFramebufferEXT", symbol_prefix);
8325 *procp = dlsym(handle, symboln);
8326 }
8327
8328
8329 if(!disp->BindRenderbufferEXT) {
8330 void ** procp = (void **) &disp->BindRenderbufferEXT;
8331 snprintf(symboln, sizeof(symboln), "%sBindRenderbuffer", symbol_prefix);
8332 *procp = dlsym(handle, symboln);
8333 }
8334
8335
8336 if(!disp->BindRenderbufferEXT) {
8337 void ** procp = (void **) &disp->BindRenderbufferEXT;
8338 snprintf(symboln, sizeof(symboln), "%sBindRenderbufferEXT", symbol_prefix);
8339 *procp = dlsym(handle, symboln);
8340 }
8341
8342
8343 if(!disp->CheckFramebufferStatusEXT) {
8344 void ** procp = (void **) &disp->CheckFramebufferStatusEXT;
8345 snprintf(symboln, sizeof(symboln), "%sCheckFramebufferStatus", symbol_prefix);
8346 *procp = dlsym(handle, symboln);
8347 }
8348
8349
8350 if(!disp->CheckFramebufferStatusEXT) {
8351 void ** procp = (void **) &disp->CheckFramebufferStatusEXT;
8352 snprintf(symboln, sizeof(symboln), "%sCheckFramebufferStatusEXT", symbol_prefix);
8353 *procp = dlsym(handle, symboln);
8354 }
8355
8356
8357 if(!disp->DeleteFramebuffersEXT) {
8358 void ** procp = (void **) &disp->DeleteFramebuffersEXT;
8359 snprintf(symboln, sizeof(symboln), "%sDeleteFramebuffers", symbol_prefix);
8360 *procp = dlsym(handle, symboln);
8361 }
8362
8363
8364 if(!disp->DeleteFramebuffersEXT) {
8365 void ** procp = (void **) &disp->DeleteFramebuffersEXT;
8366 snprintf(symboln, sizeof(symboln), "%sDeleteFramebuffersEXT", symbol_prefix);
8367 *procp = dlsym(handle, symboln);
8368 }
8369
8370
8371 if(!disp->DeleteRenderbuffersEXT) {
8372 void ** procp = (void **) &disp->DeleteRenderbuffersEXT;
8373 snprintf(symboln, sizeof(symboln), "%sDeleteRenderbuffers", symbol_prefix);
8374 *procp = dlsym(handle, symboln);
8375 }
8376
8377
8378 if(!disp->DeleteRenderbuffersEXT) {
8379 void ** procp = (void **) &disp->DeleteRenderbuffersEXT;
8380 snprintf(symboln, sizeof(symboln), "%sDeleteRenderbuffersEXT", symbol_prefix);
8381 *procp = dlsym(handle, symboln);
8382 }
8383
8384
8385 if(!disp->FramebufferRenderbufferEXT) {
8386 void ** procp = (void **) &disp->FramebufferRenderbufferEXT;
8387 snprintf(symboln, sizeof(symboln), "%sFramebufferRenderbuffer", symbol_prefix);
8388 *procp = dlsym(handle, symboln);
8389 }
8390
8391
8392 if(!disp->FramebufferRenderbufferEXT) {
8393 void ** procp = (void **) &disp->FramebufferRenderbufferEXT;
8394 snprintf(symboln, sizeof(symboln), "%sFramebufferRenderbufferEXT", symbol_prefix);
8395 *procp = dlsym(handle, symboln);
8396 }
8397
8398
8399 if(!disp->FramebufferTexture1DEXT) {
8400 void ** procp = (void **) &disp->FramebufferTexture1DEXT;
8401 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture1D", symbol_prefix);
8402 *procp = dlsym(handle, symboln);
8403 }
8404
8405
8406 if(!disp->FramebufferTexture1DEXT) {
8407 void ** procp = (void **) &disp->FramebufferTexture1DEXT;
8408 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture1DEXT", symbol_prefix);
8409 *procp = dlsym(handle, symboln);
8410 }
8411
8412
8413 if(!disp->FramebufferTexture2DEXT) {
8414 void ** procp = (void **) &disp->FramebufferTexture2DEXT;
8415 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture2D", symbol_prefix);
8416 *procp = dlsym(handle, symboln);
8417 }
8418
8419
8420 if(!disp->FramebufferTexture2DEXT) {
8421 void ** procp = (void **) &disp->FramebufferTexture2DEXT;
8422 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture2DEXT", symbol_prefix);
8423 *procp = dlsym(handle, symboln);
8424 }
8425
8426
8427 if(!disp->FramebufferTexture3DEXT) {
8428 void ** procp = (void **) &disp->FramebufferTexture3DEXT;
8429 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture3D", symbol_prefix);
8430 *procp = dlsym(handle, symboln);
8431 }
8432
8433
8434 if(!disp->FramebufferTexture3DEXT) {
8435 void ** procp = (void **) &disp->FramebufferTexture3DEXT;
8436 snprintf(symboln, sizeof(symboln), "%sFramebufferTexture3DEXT", symbol_prefix);
8437 *procp = dlsym(handle, symboln);
8438 }
8439
8440
8441 if(!disp->GenFramebuffersEXT) {
8442 void ** procp = (void **) &disp->GenFramebuffersEXT;
8443 snprintf(symboln, sizeof(symboln), "%sGenFramebuffers", symbol_prefix);
8444 *procp = dlsym(handle, symboln);
8445 }
8446
8447
8448 if(!disp->GenFramebuffersEXT) {
8449 void ** procp = (void **) &disp->GenFramebuffersEXT;
8450 snprintf(symboln, sizeof(symboln), "%sGenFramebuffersEXT", symbol_prefix);
8451 *procp = dlsym(handle, symboln);
8452 }
8453
8454
8455 if(!disp->GenRenderbuffersEXT) {
8456 void ** procp = (void **) &disp->GenRenderbuffersEXT;
8457 snprintf(symboln, sizeof(symboln), "%sGenRenderbuffers", symbol_prefix);
8458 *procp = dlsym(handle, symboln);
8459 }
8460
8461
8462 if(!disp->GenRenderbuffersEXT) {
8463 void ** procp = (void **) &disp->GenRenderbuffersEXT;
8464 snprintf(symboln, sizeof(symboln), "%sGenRenderbuffersEXT", symbol_prefix);
8465 *procp = dlsym(handle, symboln);
8466 }
8467
8468
8469 if(!disp->GenerateMipmapEXT) {
8470 void ** procp = (void **) &disp->GenerateMipmapEXT;
8471 snprintf(symboln, sizeof(symboln), "%sGenerateMipmap", symbol_prefix);
8472 *procp = dlsym(handle, symboln);
8473 }
8474
8475
8476 if(!disp->GenerateMipmapEXT) {
8477 void ** procp = (void **) &disp->GenerateMipmapEXT;
8478 snprintf(symboln, sizeof(symboln), "%sGenerateMipmapEXT", symbol_prefix);
8479 *procp = dlsym(handle, symboln);
8480 }
8481
8482
8483 if(!disp->GetFramebufferAttachmentParameterivEXT) {
8484 void ** procp = (void **) &disp->GetFramebufferAttachmentParameterivEXT;
8485 snprintf(symboln, sizeof(symboln), "%sGetFramebufferAttachmentParameteriv", symbol_prefix);
8486 *procp = dlsym(handle, symboln);
8487 }
8488
8489
8490 if(!disp->GetFramebufferAttachmentParameterivEXT) {
8491 void ** procp = (void **) &disp->GetFramebufferAttachmentParameterivEXT;
8492 snprintf(symboln, sizeof(symboln), "%sGetFramebufferAttachmentParameterivEXT", symbol_prefix);
8493 *procp = dlsym(handle, symboln);
8494 }
8495
8496
8497 if(!disp->GetRenderbufferParameterivEXT) {
8498 void ** procp = (void **) &disp->GetRenderbufferParameterivEXT;
8499 snprintf(symboln, sizeof(symboln), "%sGetRenderbufferParameteriv", symbol_prefix);
8500 *procp = dlsym(handle, symboln);
8501 }
8502
8503
8504 if(!disp->GetRenderbufferParameterivEXT) {
8505 void ** procp = (void **) &disp->GetRenderbufferParameterivEXT;
8506 snprintf(symboln, sizeof(symboln), "%sGetRenderbufferParameterivEXT", symbol_prefix);
8507 *procp = dlsym(handle, symboln);
8508 }
8509
8510
8511 if(!disp->IsFramebufferEXT) {
8512 void ** procp = (void **) &disp->IsFramebufferEXT;
8513 snprintf(symboln, sizeof(symboln), "%sIsFramebuffer", symbol_prefix);
8514 *procp = dlsym(handle, symboln);
8515 }
8516
8517
8518 if(!disp->IsFramebufferEXT) {
8519 void ** procp = (void **) &disp->IsFramebufferEXT;
8520 snprintf(symboln, sizeof(symboln), "%sIsFramebufferEXT", symbol_prefix);
8521 *procp = dlsym(handle, symboln);
8522 }
8523
8524
8525 if(!disp->IsRenderbufferEXT) {
8526 void ** procp = (void **) &disp->IsRenderbufferEXT;
8527 snprintf(symboln, sizeof(symboln), "%sIsRenderbuffer", symbol_prefix);
8528 *procp = dlsym(handle, symboln);
8529 }
8530
8531
8532 if(!disp->IsRenderbufferEXT) {
8533 void ** procp = (void **) &disp->IsRenderbufferEXT;
8534 snprintf(symboln, sizeof(symboln), "%sIsRenderbufferEXT", symbol_prefix);
8535 *procp = dlsym(handle, symboln);
8536 }
8537
8538
8539 if(!disp->RenderbufferStorageEXT) {
8540 void ** procp = (void **) &disp->RenderbufferStorageEXT;
8541 snprintf(symboln, sizeof(symboln), "%sRenderbufferStorage", symbol_prefix);
8542 *procp = dlsym(handle, symboln);
8543 }
8544
8545
8546 if(!disp->RenderbufferStorageEXT) {
8547 void ** procp = (void **) &disp->RenderbufferStorageEXT;
8548 snprintf(symboln, sizeof(symboln), "%sRenderbufferStorageEXT", symbol_prefix);
8549 *procp = dlsym(handle, symboln);
8550 }
8551
8552
8553 if(!disp->BlitFramebufferEXT) {
8554 void ** procp = (void **) &disp->BlitFramebufferEXT;
8555 snprintf(symboln, sizeof(symboln), "%sBlitFramebuffer", symbol_prefix);
8556 *procp = dlsym(handle, symboln);
8557 }
8558
8559
8560 if(!disp->BlitFramebufferEXT) {
8561 void ** procp = (void **) &disp->BlitFramebufferEXT;
8562 snprintf(symboln, sizeof(symboln), "%sBlitFramebufferEXT", symbol_prefix);
8563 *procp = dlsym(handle, symboln);
8564 }
8565
8566
8567 if(!disp->BufferParameteriAPPLE) {
8568 void ** procp = (void **) &disp->BufferParameteriAPPLE;
8569 snprintf(symboln, sizeof(symboln), "%sBufferParameteriAPPLE", symbol_prefix);
8570 *procp = dlsym(handle, symboln);
8571 }
8572
8573
8574 if(!disp->FlushMappedBufferRangeAPPLE) {
8575 void ** procp = (void **) &disp->FlushMappedBufferRangeAPPLE;
8576 snprintf(symboln, sizeof(symboln), "%sFlushMappedBufferRangeAPPLE", symbol_prefix);
8577 *procp = dlsym(handle, symboln);
8578 }
8579
8580
8581 if(!disp->BindFragDataLocationEXT) {
8582 void ** procp = (void **) &disp->BindFragDataLocationEXT;
8583 snprintf(symboln, sizeof(symboln), "%sBindFragDataLocationEXT", symbol_prefix);
8584 *procp = dlsym(handle, symboln);
8585 }
8586
8587
8588 if(!disp->BindFragDataLocationEXT) {
8589 void ** procp = (void **) &disp->BindFragDataLocationEXT;
8590 snprintf(symboln, sizeof(symboln), "%sBindFragDataLocation", symbol_prefix);
8591 *procp = dlsym(handle, symboln);
8592 }
8593
8594
8595 if(!disp->GetFragDataLocationEXT) {
8596 void ** procp = (void **) &disp->GetFragDataLocationEXT;
8597 snprintf(symboln, sizeof(symboln), "%sGetFragDataLocationEXT", symbol_prefix);
8598 *procp = dlsym(handle, symboln);
8599 }
8600
8601
8602 if(!disp->GetFragDataLocationEXT) {
8603 void ** procp = (void **) &disp->GetFragDataLocationEXT;
8604 snprintf(symboln, sizeof(symboln), "%sGetFragDataLocation", symbol_prefix);
8605 *procp = dlsym(handle, symboln);
8606 }
8607
8608
8609 if(!disp->GetUniformuivEXT) {
8610 void ** procp = (void **) &disp->GetUniformuivEXT;
8611 snprintf(symboln, sizeof(symboln), "%sGetUniformuivEXT", symbol_prefix);
8612 *procp = dlsym(handle, symboln);
8613 }
8614
8615
8616 if(!disp->GetUniformuivEXT) {
8617 void ** procp = (void **) &disp->GetUniformuivEXT;
8618 snprintf(symboln, sizeof(symboln), "%sGetUniformuiv", symbol_prefix);
8619 *procp = dlsym(handle, symboln);
8620 }
8621
8622
8623 if(!disp->GetVertexAttribIivEXT) {
8624 void ** procp = (void **) &disp->GetVertexAttribIivEXT;
8625 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIivEXT", symbol_prefix);
8626 *procp = dlsym(handle, symboln);
8627 }
8628
8629
8630 if(!disp->GetVertexAttribIivEXT) {
8631 void ** procp = (void **) &disp->GetVertexAttribIivEXT;
8632 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIiv", symbol_prefix);
8633 *procp = dlsym(handle, symboln);
8634 }
8635
8636
8637 if(!disp->GetVertexAttribIuivEXT) {
8638 void ** procp = (void **) &disp->GetVertexAttribIuivEXT;
8639 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIuivEXT", symbol_prefix);
8640 *procp = dlsym(handle, symboln);
8641 }
8642
8643
8644 if(!disp->GetVertexAttribIuivEXT) {
8645 void ** procp = (void **) &disp->GetVertexAttribIuivEXT;
8646 snprintf(symboln, sizeof(symboln), "%sGetVertexAttribIuiv", symbol_prefix);
8647 *procp = dlsym(handle, symboln);
8648 }
8649
8650
8651 if(!disp->Uniform1uiEXT) {
8652 void ** procp = (void **) &disp->Uniform1uiEXT;
8653 snprintf(symboln, sizeof(symboln), "%sUniform1uiEXT", symbol_prefix);
8654 *procp = dlsym(handle, symboln);
8655 }
8656
8657
8658 if(!disp->Uniform1uiEXT) {
8659 void ** procp = (void **) &disp->Uniform1uiEXT;
8660 snprintf(symboln, sizeof(symboln), "%sUniform1ui", symbol_prefix);
8661 *procp = dlsym(handle, symboln);
8662 }
8663
8664
8665 if(!disp->Uniform1uivEXT) {
8666 void ** procp = (void **) &disp->Uniform1uivEXT;
8667 snprintf(symboln, sizeof(symboln), "%sUniform1uivEXT", symbol_prefix);
8668 *procp = dlsym(handle, symboln);
8669 }
8670
8671
8672 if(!disp->Uniform1uivEXT) {
8673 void ** procp = (void **) &disp->Uniform1uivEXT;
8674 snprintf(symboln, sizeof(symboln), "%sUniform1uiv", symbol_prefix);
8675 *procp = dlsym(handle, symboln);
8676 }
8677
8678
8679 if(!disp->Uniform2uiEXT) {
8680 void ** procp = (void **) &disp->Uniform2uiEXT;
8681 snprintf(symboln, sizeof(symboln), "%sUniform2uiEXT", symbol_prefix);
8682 *procp = dlsym(handle, symboln);
8683 }
8684
8685
8686 if(!disp->Uniform2uiEXT) {
8687 void ** procp = (void **) &disp->Uniform2uiEXT;
8688 snprintf(symboln, sizeof(symboln), "%sUniform2ui", symbol_prefix);
8689 *procp = dlsym(handle, symboln);
8690 }
8691
8692
8693 if(!disp->Uniform2uivEXT) {
8694 void ** procp = (void **) &disp->Uniform2uivEXT;
8695 snprintf(symboln, sizeof(symboln), "%sUniform2uivEXT", symbol_prefix);
8696 *procp = dlsym(handle, symboln);
8697 }
8698
8699
8700 if(!disp->Uniform2uivEXT) {
8701 void ** procp = (void **) &disp->Uniform2uivEXT;
8702 snprintf(symboln, sizeof(symboln), "%sUniform2uiv", symbol_prefix);
8703 *procp = dlsym(handle, symboln);
8704 }
8705
8706
8707 if(!disp->Uniform3uiEXT) {
8708 void ** procp = (void **) &disp->Uniform3uiEXT;
8709 snprintf(symboln, sizeof(symboln), "%sUniform3uiEXT", symbol_prefix);
8710 *procp = dlsym(handle, symboln);
8711 }
8712
8713
8714 if(!disp->Uniform3uiEXT) {
8715 void ** procp = (void **) &disp->Uniform3uiEXT;
8716 snprintf(symboln, sizeof(symboln), "%sUniform3ui", symbol_prefix);
8717 *procp = dlsym(handle, symboln);
8718 }
8719
8720
8721 if(!disp->Uniform3uivEXT) {
8722 void ** procp = (void **) &disp->Uniform3uivEXT;
8723 snprintf(symboln, sizeof(symboln), "%sUniform3uivEXT", symbol_prefix);
8724 *procp = dlsym(handle, symboln);
8725 }
8726
8727
8728 if(!disp->Uniform3uivEXT) {
8729 void ** procp = (void **) &disp->Uniform3uivEXT;
8730 snprintf(symboln, sizeof(symboln), "%sUniform3uiv", symbol_prefix);
8731 *procp = dlsym(handle, symboln);
8732 }
8733
8734
8735 if(!disp->Uniform4uiEXT) {
8736 void ** procp = (void **) &disp->Uniform4uiEXT;
8737 snprintf(symboln, sizeof(symboln), "%sUniform4uiEXT", symbol_prefix);
8738 *procp = dlsym(handle, symboln);
8739 }
8740
8741
8742 if(!disp->Uniform4uiEXT) {
8743 void ** procp = (void **) &disp->Uniform4uiEXT;
8744 snprintf(symboln, sizeof(symboln), "%sUniform4ui", symbol_prefix);
8745 *procp = dlsym(handle, symboln);
8746 }
8747
8748
8749 if(!disp->Uniform4uivEXT) {
8750 void ** procp = (void **) &disp->Uniform4uivEXT;
8751 snprintf(symboln, sizeof(symboln), "%sUniform4uivEXT", symbol_prefix);
8752 *procp = dlsym(handle, symboln);
8753 }
8754
8755
8756 if(!disp->Uniform4uivEXT) {
8757 void ** procp = (void **) &disp->Uniform4uivEXT;
8758 snprintf(symboln, sizeof(symboln), "%sUniform4uiv", symbol_prefix);
8759 *procp = dlsym(handle, symboln);
8760 }
8761
8762
8763 if(!disp->VertexAttribI1iEXT) {
8764 void ** procp = (void **) &disp->VertexAttribI1iEXT;
8765 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1iEXT", symbol_prefix);
8766 *procp = dlsym(handle, symboln);
8767 }
8768
8769
8770 if(!disp->VertexAttribI1iEXT) {
8771 void ** procp = (void **) &disp->VertexAttribI1iEXT;
8772 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1i", symbol_prefix);
8773 *procp = dlsym(handle, symboln);
8774 }
8775
8776
8777 if(!disp->VertexAttribI1ivEXT) {
8778 void ** procp = (void **) &disp->VertexAttribI1ivEXT;
8779 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1ivEXT", symbol_prefix);
8780 *procp = dlsym(handle, symboln);
8781 }
8782
8783
8784 if(!disp->VertexAttribI1ivEXT) {
8785 void ** procp = (void **) &disp->VertexAttribI1ivEXT;
8786 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1iv", symbol_prefix);
8787 *procp = dlsym(handle, symboln);
8788 }
8789
8790
8791 if(!disp->VertexAttribI1uiEXT) {
8792 void ** procp = (void **) &disp->VertexAttribI1uiEXT;
8793 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uiEXT", symbol_prefix);
8794 *procp = dlsym(handle, symboln);
8795 }
8796
8797
8798 if(!disp->VertexAttribI1uiEXT) {
8799 void ** procp = (void **) &disp->VertexAttribI1uiEXT;
8800 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1ui", symbol_prefix);
8801 *procp = dlsym(handle, symboln);
8802 }
8803
8804
8805 if(!disp->VertexAttribI1uivEXT) {
8806 void ** procp = (void **) &disp->VertexAttribI1uivEXT;
8807 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uivEXT", symbol_prefix);
8808 *procp = dlsym(handle, symboln);
8809 }
8810
8811
8812 if(!disp->VertexAttribI1uivEXT) {
8813 void ** procp = (void **) &disp->VertexAttribI1uivEXT;
8814 snprintf(symboln, sizeof(symboln), "%sVertexAttribI1uiv", symbol_prefix);
8815 *procp = dlsym(handle, symboln);
8816 }
8817
8818
8819 if(!disp->VertexAttribI2iEXT) {
8820 void ** procp = (void **) &disp->VertexAttribI2iEXT;
8821 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2iEXT", symbol_prefix);
8822 *procp = dlsym(handle, symboln);
8823 }
8824
8825
8826 if(!disp->VertexAttribI2iEXT) {
8827 void ** procp = (void **) &disp->VertexAttribI2iEXT;
8828 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2i", symbol_prefix);
8829 *procp = dlsym(handle, symboln);
8830 }
8831
8832
8833 if(!disp->VertexAttribI2ivEXT) {
8834 void ** procp = (void **) &disp->VertexAttribI2ivEXT;
8835 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2ivEXT", symbol_prefix);
8836 *procp = dlsym(handle, symboln);
8837 }
8838
8839
8840 if(!disp->VertexAttribI2ivEXT) {
8841 void ** procp = (void **) &disp->VertexAttribI2ivEXT;
8842 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2iv", symbol_prefix);
8843 *procp = dlsym(handle, symboln);
8844 }
8845
8846
8847 if(!disp->VertexAttribI2uiEXT) {
8848 void ** procp = (void **) &disp->VertexAttribI2uiEXT;
8849 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uiEXT", symbol_prefix);
8850 *procp = dlsym(handle, symboln);
8851 }
8852
8853
8854 if(!disp->VertexAttribI2uiEXT) {
8855 void ** procp = (void **) &disp->VertexAttribI2uiEXT;
8856 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2ui", symbol_prefix);
8857 *procp = dlsym(handle, symboln);
8858 }
8859
8860
8861 if(!disp->VertexAttribI2uivEXT) {
8862 void ** procp = (void **) &disp->VertexAttribI2uivEXT;
8863 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uivEXT", symbol_prefix);
8864 *procp = dlsym(handle, symboln);
8865 }
8866
8867
8868 if(!disp->VertexAttribI2uivEXT) {
8869 void ** procp = (void **) &disp->VertexAttribI2uivEXT;
8870 snprintf(symboln, sizeof(symboln), "%sVertexAttribI2uiv", symbol_prefix);
8871 *procp = dlsym(handle, symboln);
8872 }
8873
8874
8875 if(!disp->VertexAttribI3iEXT) {
8876 void ** procp = (void **) &disp->VertexAttribI3iEXT;
8877 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3iEXT", symbol_prefix);
8878 *procp = dlsym(handle, symboln);
8879 }
8880
8881
8882 if(!disp->VertexAttribI3iEXT) {
8883 void ** procp = (void **) &disp->VertexAttribI3iEXT;
8884 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3i", symbol_prefix);
8885 *procp = dlsym(handle, symboln);
8886 }
8887
8888
8889 if(!disp->VertexAttribI3ivEXT) {
8890 void ** procp = (void **) &disp->VertexAttribI3ivEXT;
8891 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3ivEXT", symbol_prefix);
8892 *procp = dlsym(handle, symboln);
8893 }
8894
8895
8896 if(!disp->VertexAttribI3ivEXT) {
8897 void ** procp = (void **) &disp->VertexAttribI3ivEXT;
8898 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3iv", symbol_prefix);
8899 *procp = dlsym(handle, symboln);
8900 }
8901
8902
8903 if(!disp->VertexAttribI3uiEXT) {
8904 void ** procp = (void **) &disp->VertexAttribI3uiEXT;
8905 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uiEXT", symbol_prefix);
8906 *procp = dlsym(handle, symboln);
8907 }
8908
8909
8910 if(!disp->VertexAttribI3uiEXT) {
8911 void ** procp = (void **) &disp->VertexAttribI3uiEXT;
8912 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3ui", symbol_prefix);
8913 *procp = dlsym(handle, symboln);
8914 }
8915
8916
8917 if(!disp->VertexAttribI3uivEXT) {
8918 void ** procp = (void **) &disp->VertexAttribI3uivEXT;
8919 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uivEXT", symbol_prefix);
8920 *procp = dlsym(handle, symboln);
8921 }
8922
8923
8924 if(!disp->VertexAttribI3uivEXT) {
8925 void ** procp = (void **) &disp->VertexAttribI3uivEXT;
8926 snprintf(symboln, sizeof(symboln), "%sVertexAttribI3uiv", symbol_prefix);
8927 *procp = dlsym(handle, symboln);
8928 }
8929
8930
8931 if(!disp->VertexAttribI4bvEXT) {
8932 void ** procp = (void **) &disp->VertexAttribI4bvEXT;
8933 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4bvEXT", symbol_prefix);
8934 *procp = dlsym(handle, symboln);
8935 }
8936
8937
8938 if(!disp->VertexAttribI4bvEXT) {
8939 void ** procp = (void **) &disp->VertexAttribI4bvEXT;
8940 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4bv", symbol_prefix);
8941 *procp = dlsym(handle, symboln);
8942 }
8943
8944
8945 if(!disp->VertexAttribI4iEXT) {
8946 void ** procp = (void **) &disp->VertexAttribI4iEXT;
8947 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4iEXT", symbol_prefix);
8948 *procp = dlsym(handle, symboln);
8949 }
8950
8951
8952 if(!disp->VertexAttribI4iEXT) {
8953 void ** procp = (void **) &disp->VertexAttribI4iEXT;
8954 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4i", symbol_prefix);
8955 *procp = dlsym(handle, symboln);
8956 }
8957
8958
8959 if(!disp->VertexAttribI4ivEXT) {
8960 void ** procp = (void **) &disp->VertexAttribI4ivEXT;
8961 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ivEXT", symbol_prefix);
8962 *procp = dlsym(handle, symboln);
8963 }
8964
8965
8966 if(!disp->VertexAttribI4ivEXT) {
8967 void ** procp = (void **) &disp->VertexAttribI4ivEXT;
8968 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4iv", symbol_prefix);
8969 *procp = dlsym(handle, symboln);
8970 }
8971
8972
8973 if(!disp->VertexAttribI4svEXT) {
8974 void ** procp = (void **) &disp->VertexAttribI4svEXT;
8975 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4svEXT", symbol_prefix);
8976 *procp = dlsym(handle, symboln);
8977 }
8978
8979
8980 if(!disp->VertexAttribI4svEXT) {
8981 void ** procp = (void **) &disp->VertexAttribI4svEXT;
8982 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4sv", symbol_prefix);
8983 *procp = dlsym(handle, symboln);
8984 }
8985
8986
8987 if(!disp->VertexAttribI4ubvEXT) {
8988 void ** procp = (void **) &disp->VertexAttribI4ubvEXT;
8989 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ubvEXT", symbol_prefix);
8990 *procp = dlsym(handle, symboln);
8991 }
8992
8993
8994 if(!disp->VertexAttribI4ubvEXT) {
8995 void ** procp = (void **) &disp->VertexAttribI4ubvEXT;
8996 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ubv", symbol_prefix);
8997 *procp = dlsym(handle, symboln);
8998 }
8999
9000
9001 if(!disp->VertexAttribI4uiEXT) {
9002 void ** procp = (void **) &disp->VertexAttribI4uiEXT;
9003 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uiEXT", symbol_prefix);
9004 *procp = dlsym(handle, symboln);
9005 }
9006
9007
9008 if(!disp->VertexAttribI4uiEXT) {
9009 void ** procp = (void **) &disp->VertexAttribI4uiEXT;
9010 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4ui", symbol_prefix);
9011 *procp = dlsym(handle, symboln);
9012 }
9013
9014
9015 if(!disp->VertexAttribI4uivEXT) {
9016 void ** procp = (void **) &disp->VertexAttribI4uivEXT;
9017 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uivEXT", symbol_prefix);
9018 *procp = dlsym(handle, symboln);
9019 }
9020
9021
9022 if(!disp->VertexAttribI4uivEXT) {
9023 void ** procp = (void **) &disp->VertexAttribI4uivEXT;
9024 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4uiv", symbol_prefix);
9025 *procp = dlsym(handle, symboln);
9026 }
9027
9028
9029 if(!disp->VertexAttribI4usvEXT) {
9030 void ** procp = (void **) &disp->VertexAttribI4usvEXT;
9031 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4usvEXT", symbol_prefix);
9032 *procp = dlsym(handle, symboln);
9033 }
9034
9035
9036 if(!disp->VertexAttribI4usvEXT) {
9037 void ** procp = (void **) &disp->VertexAttribI4usvEXT;
9038 snprintf(symboln, sizeof(symboln), "%sVertexAttribI4usv", symbol_prefix);
9039 *procp = dlsym(handle, symboln);
9040 }
9041
9042
9043 if(!disp->VertexAttribIPointerEXT) {
9044 void ** procp = (void **) &disp->VertexAttribIPointerEXT;
9045 snprintf(symboln, sizeof(symboln), "%sVertexAttribIPointerEXT", symbol_prefix);
9046 *procp = dlsym(handle, symboln);
9047 }
9048
9049
9050 if(!disp->VertexAttribIPointerEXT) {
9051 void ** procp = (void **) &disp->VertexAttribIPointerEXT;
9052 snprintf(symboln, sizeof(symboln), "%sVertexAttribIPointer", symbol_prefix);
9053 *procp = dlsym(handle, symboln);
9054 }
9055
9056
9057 if(!disp->FramebufferTextureLayerEXT) {
9058 void ** procp = (void **) &disp->FramebufferTextureLayerEXT;
9059 snprintf(symboln, sizeof(symboln), "%sFramebufferTextureLayer", symbol_prefix);
9060 *procp = dlsym(handle, symboln);
9061 }
9062
9063
9064 if(!disp->FramebufferTextureLayerEXT) {
9065 void ** procp = (void **) &disp->FramebufferTextureLayerEXT;
9066 snprintf(symboln, sizeof(symboln), "%sFramebufferTextureLayerARB", symbol_prefix);
9067 *procp = dlsym(handle, symboln);
9068 }
9069
9070
9071 if(!disp->FramebufferTextureLayerEXT) {
9072 void ** procp = (void **) &disp->FramebufferTextureLayerEXT;
9073 snprintf(symboln, sizeof(symboln), "%sFramebufferTextureLayerEXT", symbol_prefix);
9074 *procp = dlsym(handle, symboln);
9075 }
9076
9077
9078 if(!disp->ColorMaskIndexedEXT) {
9079 void ** procp = (void **) &disp->ColorMaskIndexedEXT;
9080 snprintf(symboln, sizeof(symboln), "%sColorMaskIndexedEXT", symbol_prefix);
9081 *procp = dlsym(handle, symboln);
9082 }
9083
9084
9085 if(!disp->ColorMaskIndexedEXT) {
9086 void ** procp = (void **) &disp->ColorMaskIndexedEXT;
9087 snprintf(symboln, sizeof(symboln), "%sColorMaski", symbol_prefix);
9088 *procp = dlsym(handle, symboln);
9089 }
9090
9091
9092 if(!disp->DisableIndexedEXT) {
9093 void ** procp = (void **) &disp->DisableIndexedEXT;
9094 snprintf(symboln, sizeof(symboln), "%sDisableIndexedEXT", symbol_prefix);
9095 *procp = dlsym(handle, symboln);
9096 }
9097
9098
9099 if(!disp->DisableIndexedEXT) {
9100 void ** procp = (void **) &disp->DisableIndexedEXT;
9101 snprintf(symboln, sizeof(symboln), "%sDisablei", symbol_prefix);
9102 *procp = dlsym(handle, symboln);
9103 }
9104
9105
9106 if(!disp->EnableIndexedEXT) {
9107 void ** procp = (void **) &disp->EnableIndexedEXT;
9108 snprintf(symboln, sizeof(symboln), "%sEnableIndexedEXT", symbol_prefix);
9109 *procp = dlsym(handle, symboln);
9110 }
9111
9112
9113 if(!disp->EnableIndexedEXT) {
9114 void ** procp = (void **) &disp->EnableIndexedEXT;
9115 snprintf(symboln, sizeof(symboln), "%sEnablei", symbol_prefix);
9116 *procp = dlsym(handle, symboln);
9117 }
9118
9119
9120 if(!disp->GetBooleanIndexedvEXT) {
9121 void ** procp = (void **) &disp->GetBooleanIndexedvEXT;
9122 snprintf(symboln, sizeof(symboln), "%sGetBooleanIndexedvEXT", symbol_prefix);
9123 *procp = dlsym(handle, symboln);
9124 }
9125
9126
9127 if(!disp->GetBooleanIndexedvEXT) {
9128 void ** procp = (void **) &disp->GetBooleanIndexedvEXT;
9129 snprintf(symboln, sizeof(symboln), "%sGetBooleani_v", symbol_prefix);
9130 *procp = dlsym(handle, symboln);
9131 }
9132
9133
9134 if(!disp->GetIntegerIndexedvEXT) {
9135 void ** procp = (void **) &disp->GetIntegerIndexedvEXT;
9136 snprintf(symboln, sizeof(symboln), "%sGetIntegerIndexedvEXT", symbol_prefix);
9137 *procp = dlsym(handle, symboln);
9138 }
9139
9140
9141 if(!disp->GetIntegerIndexedvEXT) {
9142 void ** procp = (void **) &disp->GetIntegerIndexedvEXT;
9143 snprintf(symboln, sizeof(symboln), "%sGetIntegeri_v", symbol_prefix);
9144 *procp = dlsym(handle, symboln);
9145 }
9146
9147
9148 if(!disp->IsEnabledIndexedEXT) {
9149 void ** procp = (void **) &disp->IsEnabledIndexedEXT;
9150 snprintf(symboln, sizeof(symboln), "%sIsEnabledIndexedEXT", symbol_prefix);
9151 *procp = dlsym(handle, symboln);
9152 }
9153
9154
9155 if(!disp->IsEnabledIndexedEXT) {
9156 void ** procp = (void **) &disp->IsEnabledIndexedEXT;
9157 snprintf(symboln, sizeof(symboln), "%sIsEnabledi", symbol_prefix);
9158 *procp = dlsym(handle, symboln);
9159 }
9160
9161
9162 if(!disp->ClearColorIiEXT) {
9163 void ** procp = (void **) &disp->ClearColorIiEXT;
9164 snprintf(symboln, sizeof(symboln), "%sClearColorIiEXT", symbol_prefix);
9165 *procp = dlsym(handle, symboln);
9166 }
9167
9168
9169 if(!disp->ClearColorIuiEXT) {
9170 void ** procp = (void **) &disp->ClearColorIuiEXT;
9171 snprintf(symboln, sizeof(symboln), "%sClearColorIuiEXT", symbol_prefix);
9172 *procp = dlsym(handle, symboln);
9173 }
9174
9175
9176 if(!disp->GetTexParameterIivEXT) {
9177 void ** procp = (void **) &disp->GetTexParameterIivEXT;
9178 snprintf(symboln, sizeof(symboln), "%sGetTexParameterIivEXT", symbol_prefix);
9179 *procp = dlsym(handle, symboln);
9180 }
9181
9182
9183 if(!disp->GetTexParameterIivEXT) {
9184 void ** procp = (void **) &disp->GetTexParameterIivEXT;
9185 snprintf(symboln, sizeof(symboln), "%sGetTexParameterIiv", symbol_prefix);
9186 *procp = dlsym(handle, symboln);
9187 }
9188
9189
9190 if(!disp->GetTexParameterIuivEXT) {
9191 void ** procp = (void **) &disp->GetTexParameterIuivEXT;
9192 snprintf(symboln, sizeof(symboln), "%sGetTexParameterIuivEXT", symbol_prefix);
9193 *procp = dlsym(handle, symboln);
9194 }
9195
9196
9197 if(!disp->GetTexParameterIuivEXT) {
9198 void ** procp = (void **) &disp->GetTexParameterIuivEXT;
9199 snprintf(symboln, sizeof(symboln), "%sGetTexParameterIuiv", symbol_prefix);
9200 *procp = dlsym(handle, symboln);
9201 }
9202
9203
9204 if(!disp->TexParameterIivEXT) {
9205 void ** procp = (void **) &disp->TexParameterIivEXT;
9206 snprintf(symboln, sizeof(symboln), "%sTexParameterIivEXT", symbol_prefix);
9207 *procp = dlsym(handle, symboln);
9208 }
9209
9210
9211 if(!disp->TexParameterIivEXT) {
9212 void ** procp = (void **) &disp->TexParameterIivEXT;
9213 snprintf(symboln, sizeof(symboln), "%sTexParameterIiv", symbol_prefix);
9214 *procp = dlsym(handle, symboln);
9215 }
9216
9217
9218 if(!disp->TexParameterIuivEXT) {
9219 void ** procp = (void **) &disp->TexParameterIuivEXT;
9220 snprintf(symboln, sizeof(symboln), "%sTexParameterIuivEXT", symbol_prefix);
9221 *procp = dlsym(handle, symboln);
9222 }
9223
9224
9225 if(!disp->TexParameterIuivEXT) {
9226 void ** procp = (void **) &disp->TexParameterIuivEXT;
9227 snprintf(symboln, sizeof(symboln), "%sTexParameterIuiv", symbol_prefix);
9228 *procp = dlsym(handle, symboln);
9229 }
9230
9231
9232 if(!disp->BeginConditionalRenderNV) {
9233 void ** procp = (void **) &disp->BeginConditionalRenderNV;
9234 snprintf(symboln, sizeof(symboln), "%sBeginConditionalRender", symbol_prefix);
9235 *procp = dlsym(handle, symboln);
9236 }
9237
9238
9239 if(!disp->BeginConditionalRenderNV) {
9240 void ** procp = (void **) &disp->BeginConditionalRenderNV;
9241 snprintf(symboln, sizeof(symboln), "%sBeginConditionalRenderNV", symbol_prefix);
9242 *procp = dlsym(handle, symboln);
9243 }
9244
9245
9246 if(!disp->EndConditionalRenderNV) {
9247 void ** procp = (void **) &disp->EndConditionalRenderNV;
9248 snprintf(symboln, sizeof(symboln), "%sEndConditionalRender", symbol_prefix);
9249 *procp = dlsym(handle, symboln);
9250 }
9251
9252
9253 if(!disp->EndConditionalRenderNV) {
9254 void ** procp = (void **) &disp->EndConditionalRenderNV;
9255 snprintf(symboln, sizeof(symboln), "%sEndConditionalRenderNV", symbol_prefix);
9256 *procp = dlsym(handle, symboln);
9257 }
9258
9259
9260 if(!disp->BeginTransformFeedbackEXT) {
9261 void ** procp = (void **) &disp->BeginTransformFeedbackEXT;
9262 snprintf(symboln, sizeof(symboln), "%sBeginTransformFeedback", symbol_prefix);
9263 *procp = dlsym(handle, symboln);
9264 }
9265
9266
9267 if(!disp->BeginTransformFeedbackEXT) {
9268 void ** procp = (void **) &disp->BeginTransformFeedbackEXT;
9269 snprintf(symboln, sizeof(symboln), "%sBeginTransformFeedbackEXT", symbol_prefix);
9270 *procp = dlsym(handle, symboln);
9271 }
9272
9273
9274 if(!disp->BindBufferBaseEXT) {
9275 void ** procp = (void **) &disp->BindBufferBaseEXT;
9276 snprintf(symboln, sizeof(symboln), "%sBindBufferBase", symbol_prefix);
9277 *procp = dlsym(handle, symboln);
9278 }
9279
9280
9281 if(!disp->BindBufferBaseEXT) {
9282 void ** procp = (void **) &disp->BindBufferBaseEXT;
9283 snprintf(symboln, sizeof(symboln), "%sBindBufferBaseEXT", symbol_prefix);
9284 *procp = dlsym(handle, symboln);
9285 }
9286
9287
9288 if(!disp->BindBufferOffsetEXT) {
9289 void ** procp = (void **) &disp->BindBufferOffsetEXT;
9290 snprintf(symboln, sizeof(symboln), "%sBindBufferOffsetEXT", symbol_prefix);
9291 *procp = dlsym(handle, symboln);
9292 }
9293
9294
9295 if(!disp->BindBufferRangeEXT) {
9296 void ** procp = (void **) &disp->BindBufferRangeEXT;
9297 snprintf(symboln, sizeof(symboln), "%sBindBufferRange", symbol_prefix);
9298 *procp = dlsym(handle, symboln);
9299 }
9300
9301
9302 if(!disp->BindBufferRangeEXT) {
9303 void ** procp = (void **) &disp->BindBufferRangeEXT;
9304 snprintf(symboln, sizeof(symboln), "%sBindBufferRangeEXT", symbol_prefix);
9305 *procp = dlsym(handle, symboln);
9306 }
9307
9308
9309 if(!disp->EndTransformFeedbackEXT) {
9310 void ** procp = (void **) &disp->EndTransformFeedbackEXT;
9311 snprintf(symboln, sizeof(symboln), "%sEndTransformFeedback", symbol_prefix);
9312 *procp = dlsym(handle, symboln);
9313 }
9314
9315
9316 if(!disp->EndTransformFeedbackEXT) {
9317 void ** procp = (void **) &disp->EndTransformFeedbackEXT;
9318 snprintf(symboln, sizeof(symboln), "%sEndTransformFeedbackEXT", symbol_prefix);
9319 *procp = dlsym(handle, symboln);
9320 }
9321
9322
9323 if(!disp->GetTransformFeedbackVaryingEXT) {
9324 void ** procp = (void **) &disp->GetTransformFeedbackVaryingEXT;
9325 snprintf(symboln, sizeof(symboln), "%sGetTransformFeedbackVarying", symbol_prefix);
9326 *procp = dlsym(handle, symboln);
9327 }
9328
9329
9330 if(!disp->GetTransformFeedbackVaryingEXT) {
9331 void ** procp = (void **) &disp->GetTransformFeedbackVaryingEXT;
9332 snprintf(symboln, sizeof(symboln), "%sGetTransformFeedbackVaryingEXT", symbol_prefix);
9333 *procp = dlsym(handle, symboln);
9334 }
9335
9336
9337 if(!disp->TransformFeedbackVaryingsEXT) {
9338 void ** procp = (void **) &disp->TransformFeedbackVaryingsEXT;
9339 snprintf(symboln, sizeof(symboln), "%sTransformFeedbackVaryings", symbol_prefix);
9340 *procp = dlsym(handle, symboln);
9341 }
9342
9343
9344 if(!disp->TransformFeedbackVaryingsEXT) {
9345 void ** procp = (void **) &disp->TransformFeedbackVaryingsEXT;
9346 snprintf(symboln, sizeof(symboln), "%sTransformFeedbackVaryingsEXT", symbol_prefix);
9347 *procp = dlsym(handle, symboln);
9348 }
9349
9350
9351 if(!disp->ProvokingVertexEXT) {
9352 void ** procp = (void **) &disp->ProvokingVertexEXT;
9353 snprintf(symboln, sizeof(symboln), "%sProvokingVertexEXT", symbol_prefix);
9354 *procp = dlsym(handle, symboln);
9355 }
9356
9357
9358 if(!disp->ProvokingVertexEXT) {
9359 void ** procp = (void **) &disp->ProvokingVertexEXT;
9360 snprintf(symboln, sizeof(symboln), "%sProvokingVertex", symbol_prefix);
9361 *procp = dlsym(handle, symboln);
9362 }
9363
9364
9365 if(!disp->GetObjectParameterivAPPLE) {
9366 void ** procp = (void **) &disp->GetObjectParameterivAPPLE;
9367 snprintf(symboln, sizeof(symboln), "%sGetObjectParameterivAPPLE", symbol_prefix);
9368 *procp = dlsym(handle, symboln);
9369 }
9370
9371
9372 if(!disp->ObjectPurgeableAPPLE) {
9373 void ** procp = (void **) &disp->ObjectPurgeableAPPLE;
9374 snprintf(symboln, sizeof(symboln), "%sObjectPurgeableAPPLE", symbol_prefix);
9375 *procp = dlsym(handle, symboln);
9376 }
9377
9378
9379 if(!disp->ObjectUnpurgeableAPPLE) {
9380 void ** procp = (void **) &disp->ObjectUnpurgeableAPPLE;
9381 snprintf(symboln, sizeof(symboln), "%sObjectUnpurgeableAPPLE", symbol_prefix);
9382 *procp = dlsym(handle, symboln);
9383 }
9384
9385
9386 if(!disp->ActiveProgramEXT) {
9387 void ** procp = (void **) &disp->ActiveProgramEXT;
9388 snprintf(symboln, sizeof(symboln), "%sActiveProgramEXT", symbol_prefix);
9389 *procp = dlsym(handle, symboln);
9390 }
9391
9392
9393 if(!disp->CreateShaderProgramEXT) {
9394 void ** procp = (void **) &disp->CreateShaderProgramEXT;
9395 snprintf(symboln, sizeof(symboln), "%sCreateShaderProgramEXT", symbol_prefix);
9396 *procp = dlsym(handle, symboln);
9397 }
9398
9399
9400 if(!disp->UseShaderProgramEXT) {
9401 void ** procp = (void **) &disp->UseShaderProgramEXT;
9402 snprintf(symboln, sizeof(symboln), "%sUseShaderProgramEXT", symbol_prefix);
9403 *procp = dlsym(handle, symboln);
9404 }
9405
9406
9407 if(!disp->TextureBarrierNV) {
9408 void ** procp = (void **) &disp->TextureBarrierNV;
9409 snprintf(symboln, sizeof(symboln), "%sTextureBarrierNV", symbol_prefix);
9410 *procp = dlsym(handle, symboln);
9411 }
9412
9413
9414 if(!disp->StencilFuncSeparateATI) {
9415 void ** procp = (void **) &disp->StencilFuncSeparateATI;
9416 snprintf(symboln, sizeof(symboln), "%sStencilFuncSeparateATI", symbol_prefix);
9417 *procp = dlsym(handle, symboln);
9418 }
9419
9420
9421 if(!disp->ProgramEnvParameters4fvEXT) {
9422 void ** procp = (void **) &disp->ProgramEnvParameters4fvEXT;
9423 snprintf(symboln, sizeof(symboln), "%sProgramEnvParameters4fvEXT", symbol_prefix);
9424 *procp = dlsym(handle, symboln);
9425 }
9426
9427
9428 if(!disp->ProgramLocalParameters4fvEXT) {
9429 void ** procp = (void **) &disp->ProgramLocalParameters4fvEXT;
9430 snprintf(symboln, sizeof(symboln), "%sProgramLocalParameters4fvEXT", symbol_prefix);
9431 *procp = dlsym(handle, symboln);
9432 }
9433
9434
9435 if(!disp->GetQueryObjecti64vEXT) {
9436 void ** procp = (void **) &disp->GetQueryObjecti64vEXT;
9437 snprintf(symboln, sizeof(symboln), "%sGetQueryObjecti64v", symbol_prefix);
9438 *procp = dlsym(handle, symboln);
9439 }
9440
9441
9442 if(!disp->GetQueryObjecti64vEXT) {
9443 void ** procp = (void **) &disp->GetQueryObjecti64vEXT;
9444 snprintf(symboln, sizeof(symboln), "%sGetQueryObjecti64vEXT", symbol_prefix);
9445 *procp = dlsym(handle, symboln);
9446 }
9447
9448
9449 if(!disp->GetQueryObjectui64vEXT) {
9450 void ** procp = (void **) &disp->GetQueryObjectui64vEXT;
9451 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectui64v", symbol_prefix);
9452 *procp = dlsym(handle, symboln);
9453 }
9454
9455
9456 if(!disp->GetQueryObjectui64vEXT) {
9457 void ** procp = (void **) &disp->GetQueryObjectui64vEXT;
9458 snprintf(symboln, sizeof(symboln), "%sGetQueryObjectui64vEXT", symbol_prefix);
9459 *procp = dlsym(handle, symboln);
9460 }
9461
9462
9463 if(!disp->EGLImageTargetRenderbufferStorageOES) {
9464 void ** procp = (void **) &disp->EGLImageTargetRenderbufferStorageOES;
9465 snprintf(symboln, sizeof(symboln), "%sEGLImageTargetRenderbufferStorageOES", symbol_prefix);
9466 *procp = dlsym(handle, symboln);
9467 }
9468
9469
9470 if(!disp->EGLImageTargetTexture2DOES) {
9471 void ** procp = (void **) &disp->EGLImageTargetTexture2DOES;
9472 snprintf(symboln, sizeof(symboln), "%sEGLImageTargetTexture2DOES", symbol_prefix);
9473 *procp = dlsym(handle, symboln);
9474 }
9475
9476
9477 __glapi_gentable_set_remaining_noop(disp);
9478
9479 return disp;
9480 }
9481
9482