source: OGRE/trunk/ogre_dependencies/Dependencies/include/GL/glprocs.c @ 692

Revision 692, 191.3 KB checked in by mattausch, 19 years ago (diff)

adding ogre 1.2 and dependencies

Line 
1/*
2** GLprocs utility for getting function addresses for OpenGL(R) 1.2,
3** OpenGL 1.3 and OpenGL extension functions.
4**
5** Version:  1.0
6**
7** License Applicability. Except to the extent portions of this file are
8** made subject to an alternative license as permitted in the SGI Free
9** Software License B, Version 1.1 (the "License"), the contents of this
10** file are subject only to the provisions of the License. You may not use
11** this file except in compliance with the License. You may obtain a copy
12** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
13** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
14**
15** http://oss.sgi.com/projects/FreeB
16**
17** Note that, as provided in the License, the Software is distributed on an
18** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
19** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
20** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
21** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
22**
23** Original Code. The Original Code is: OpenGL Sample Implementation,
24** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
25** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
26** Copyright in any portions created by third parties is as indicated
27** elsewhere herein. All Rights Reserved.
28**
29** Additional Notice Provisions: This software was created using the
30** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
31** not been independently verified as being compliant with the OpenGL(R)
32** version 1.2.1 Specification.
33**
34** Initial version of glprocs.{c,h} contributed by Intel(R) Corporation.
35*/
36
37#include <assert.h>
38#include <stdlib.h>
39
40#ifdef _WIN32
41  #include <windows.h>
42  #include "gl.h"  /* Include local "gl.h". Don't include vc32 <GL/gl.h>. */
43  #include "glprocs.h"
44#else /* GLX */
45  #include <GL/gl.h>
46  #include <GL/glx.h>
47  #include <GL/glprocs.h>
48  #define wglGetProcAddress glXGetProcAddresARB
49#endif
50
51#define _ASSERT(a) assert(a)
52
53static void APIENTRY InitBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
54{
55        void *extproc;
56
57        extproc = (void *) wglGetProcAddress("glBlendColor");
58
59        if (extproc == NULL) {
60                _ASSERT(0);
61                return;
62        }
63
64        glBlendColor = extproc;
65
66        glBlendColor(red, green, blue, alpha);
67}
68
69static void APIENTRY InitBlendEquation (GLenum mode)
70{
71        void *extproc;
72
73        extproc = (void *) wglGetProcAddress("glBlendEquation");
74
75        if (extproc == NULL) {
76                _ASSERT(0);
77                return;
78        }
79
80        glBlendEquation = extproc;
81
82        glBlendEquation(mode);
83}
84
85static void APIENTRY InitDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
86{
87        void *extproc;
88
89        extproc = (void *) wglGetProcAddress("glDrawRangeElements");
90
91        if (extproc == NULL) {
92                _ASSERT(0);
93                return;
94        }
95
96        glDrawRangeElements = extproc;
97
98        glDrawRangeElements(mode, start, end, count, type, indices);
99}
100
101static void APIENTRY InitColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
102{
103        void *extproc;
104
105        extproc = (void *) wglGetProcAddress("glColorTable");
106
107        if (extproc == NULL) {
108                _ASSERT(0);
109                return;
110        }
111
112        glColorTable = extproc;
113
114        glColorTable(target, internalformat, width, format, type, table);
115}
116
117static void APIENTRY InitColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params)
118{
119        void *extproc;
120
121        extproc = (void *) wglGetProcAddress("glColorTableParameterfv");
122
123        if (extproc == NULL) {
124                _ASSERT(0);
125                return;
126        }
127
128        glColorTableParameterfv = extproc;
129
130        glColorTableParameterfv(target, pname, params);
131}
132
133static void APIENTRY InitColorTableParameteriv (GLenum target, GLenum pname, const GLint *params)
134{
135        void *extproc;
136
137        extproc = (void *) wglGetProcAddress("glColorTableParameteriv");
138
139        if (extproc == NULL) {
140                _ASSERT(0);
141                return;
142        }
143
144        glColorTableParameteriv = extproc;
145
146        glColorTableParameteriv(target, pname, params);
147}
148
149static void APIENTRY InitCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
150{
151        void *extproc;
152
153        extproc = (void *) wglGetProcAddress("glCopyColorTable");
154
155        if (extproc == NULL) {
156                _ASSERT(0);
157                return;
158        }
159
160        glCopyColorTable = extproc;
161
162        glCopyColorTable(target, internalformat, x, y, width);
163}
164
165static void APIENTRY InitGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table)
166{
167        void *extproc;
168
169        extproc = (void *) wglGetProcAddress("glGetColorTable");
170
171        if (extproc == NULL) {
172                _ASSERT(0);
173                return;
174        }
175
176        glGetColorTable = extproc;
177
178        glGetColorTable(target, format, type, table);
179}
180
181static void APIENTRY InitGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params)
182{
183        void *extproc;
184
185        extproc = (void *) wglGetProcAddress("glGetColorTableParameterfv");
186
187        if (extproc == NULL) {
188                _ASSERT(0);
189                return;
190        }
191
192        glGetColorTableParameterfv = extproc;
193
194        glGetColorTableParameterfv(target, pname, params);
195}
196
197static void APIENTRY InitGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params)
198{
199        void *extproc;
200
201        extproc = (void *) wglGetProcAddress("glGetColorTableParameteriv");
202
203        if (extproc == NULL) {
204                _ASSERT(0);
205                return;
206        }
207
208        glGetColorTableParameteriv = extproc;
209
210        glGetColorTableParameteriv(target, pname, params);
211}
212
213static void APIENTRY InitColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
214{
215        void *extproc;
216
217        extproc = (void *) wglGetProcAddress("glColorSubTable");
218
219        if (extproc == NULL) {
220                _ASSERT(0);
221                return;
222        }
223
224        glColorSubTable = extproc;
225
226        glColorSubTable(target, start, count, format, type, data);
227}
228
229static void APIENTRY InitCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
230{
231        void *extproc;
232
233        extproc = (void *) wglGetProcAddress("glCopyColorSubTable");
234
235        if (extproc == NULL) {
236                _ASSERT(0);
237                return;
238        }
239
240        glCopyColorSubTable = extproc;
241
242        glCopyColorSubTable(target, start, x, y, width);
243}
244
245static void APIENTRY InitConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
246{
247        void *extproc;
248
249        extproc = (void *) wglGetProcAddress("glConvolutionFilter1D");
250
251        if (extproc == NULL) {
252                _ASSERT(0);
253                return;
254        }
255
256        glConvolutionFilter1D = extproc;
257
258        glConvolutionFilter1D(target, internalformat, width, format, type, image);
259}
260
261static void APIENTRY InitConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
262{
263        void *extproc;
264
265        extproc = (void *) wglGetProcAddress("glConvolutionFilter2D");
266
267        if (extproc == NULL) {
268                _ASSERT(0);
269                return;
270        }
271
272        glConvolutionFilter2D = extproc;
273
274        glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
275}
276
277static void APIENTRY InitConvolutionParameterf (GLenum target, GLenum pname, GLfloat params)
278{
279        void *extproc;
280
281        extproc = (void *) wglGetProcAddress("glConvolutionParameterf");
282
283        if (extproc == NULL) {
284                _ASSERT(0);
285                return;
286        }
287
288        glConvolutionParameterf = extproc;
289
290        glConvolutionParameterf(target, pname, params);
291}
292
293static void APIENTRY InitConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params)
294{
295        void *extproc;
296
297        extproc = (void *) wglGetProcAddress("glConvolutionParameterfv");
298
299        if (extproc == NULL) {
300                _ASSERT(0);
301                return;
302        }
303
304        glConvolutionParameterfv = extproc;
305
306        glConvolutionParameterfv(target, pname, params);
307}
308
309static void APIENTRY InitConvolutionParameteri (GLenum target, GLenum pname, GLint params)
310{
311        void *extproc;
312
313        extproc = (void *) wglGetProcAddress("glConvolutionParameteri");
314
315        if (extproc == NULL) {
316                _ASSERT(0);
317                return;
318        }
319
320        glConvolutionParameteri = extproc;
321
322        glConvolutionParameteri(target, pname, params);
323}
324
325static void APIENTRY InitConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params)
326{
327        void *extproc;
328
329        extproc = (void *) wglGetProcAddress("glConvolutionParameteriv");
330
331        if (extproc == NULL) {
332                _ASSERT(0);
333                return;
334        }
335
336        glConvolutionParameteriv = extproc;
337
338        glConvolutionParameteriv(target, pname, params);
339}
340
341static void APIENTRY InitCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
342{
343        void *extproc;
344
345        extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter1D");
346
347        if (extproc == NULL) {
348                _ASSERT(0);
349                return;
350        }
351
352        glCopyConvolutionFilter1D = extproc;
353
354        glCopyConvolutionFilter1D(target, internalformat, x, y, width);
355}
356
357static void APIENTRY InitCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
358{
359        void *extproc;
360
361        extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter2D");
362
363        if (extproc == NULL) {
364                _ASSERT(0);
365                return;
366        }
367
368        glCopyConvolutionFilter2D = extproc;
369
370        glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
371}
372
373static void APIENTRY InitGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image)
374{
375        void *extproc;
376
377        extproc = (void *) wglGetProcAddress("glGetConvolutionFilter");
378
379        if (extproc == NULL) {
380                _ASSERT(0);
381                return;
382        }
383
384        glGetConvolutionFilter = extproc;
385
386        glGetConvolutionFilter(target, format, type, image);
387}
388
389static void APIENTRY InitGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params)
390{
391        void *extproc;
392
393        extproc = (void *) wglGetProcAddress("glGetConvolutionParameterfv");
394
395        if (extproc == NULL) {
396                _ASSERT(0);
397                return;
398        }
399
400        glGetConvolutionParameterfv = extproc;
401
402        glGetConvolutionParameterfv(target, pname, params);
403}
404
405static void APIENTRY InitGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params)
406{
407        void *extproc;
408
409        extproc = (void *) wglGetProcAddress("glGetConvolutionParameteriv");
410
411        if (extproc == NULL) {
412                _ASSERT(0);
413                return;
414        }
415
416        glGetConvolutionParameteriv = extproc;
417
418        glGetConvolutionParameteriv(target, pname, params);
419}
420
421static void APIENTRY InitGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
422{
423        void *extproc;
424
425        extproc = (void *) wglGetProcAddress("glGetSeparableFilter");
426
427        if (extproc == NULL) {
428                _ASSERT(0);
429                return;
430        }
431
432        glGetSeparableFilter = extproc;
433
434        glGetSeparableFilter(target, format, type, row, column, span);
435}
436
437static void APIENTRY InitSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
438{
439        void *extproc;
440
441        extproc = (void *) wglGetProcAddress("glSeparableFilter2D");
442
443        if (extproc == NULL) {
444                _ASSERT(0);
445                return;
446        }
447
448        glSeparableFilter2D = extproc;
449
450        glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
451}
452
453static void APIENTRY InitGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
454{
455        void *extproc;
456
457        extproc = (void *) wglGetProcAddress("glGetHistogram");
458
459        if (extproc == NULL) {
460                _ASSERT(0);
461                return;
462        }
463
464        glGetHistogram = extproc;
465
466        glGetHistogram(target, reset, format, type, values);
467}
468
469static void APIENTRY InitGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params)
470{
471        void *extproc;
472
473        extproc = (void *) wglGetProcAddress("glGetHistogramParameterfv");
474
475        if (extproc == NULL) {
476                _ASSERT(0);
477                return;
478        }
479
480        glGetHistogramParameterfv = extproc;
481
482        glGetHistogramParameterfv(target, pname, params);
483}
484
485static void APIENTRY InitGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params)
486{
487        void *extproc;
488
489        extproc = (void *) wglGetProcAddress("glGetHistogramParameteriv");
490
491        if (extproc == NULL) {
492                _ASSERT(0);
493                return;
494        }
495
496        glGetHistogramParameteriv = extproc;
497
498        glGetHistogramParameteriv(target, pname, params);
499}
500
501static void APIENTRY InitGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
502{
503        void *extproc;
504
505        extproc = (void *) wglGetProcAddress("glGetMinmax");
506
507        if (extproc == NULL) {
508                _ASSERT(0);
509                return;
510        }
511
512        glGetMinmax = extproc;
513
514        glGetMinmax(target, reset, format, type, values);
515}
516
517static void APIENTRY InitGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params)
518{
519        void *extproc;
520
521        extproc = (void *) wglGetProcAddress("glGetMinmaxParameterfv");
522
523        if (extproc == NULL) {
524                _ASSERT(0);
525                return;
526        }
527
528        glGetMinmaxParameterfv = extproc;
529
530        glGetMinmaxParameterfv(target, pname, params);
531}
532
533static void APIENTRY InitGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params)
534{
535        void *extproc;
536
537        extproc = (void *) wglGetProcAddress("glGetMinmaxParameteriv");
538
539        if (extproc == NULL) {
540                _ASSERT(0);
541                return;
542        }
543
544        glGetMinmaxParameteriv = extproc;
545
546        glGetMinmaxParameteriv(target, pname, params);
547}
548
549static void APIENTRY InitHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
550{
551        void *extproc;
552
553        extproc = (void *) wglGetProcAddress("glHistogram");
554
555        if (extproc == NULL) {
556                _ASSERT(0);
557                return;
558        }
559
560        glHistogram = extproc;
561
562        glHistogram(target, width, internalformat, sink);
563}
564
565static void APIENTRY InitMinmax (GLenum target, GLenum internalformat, GLboolean sink)
566{
567        void *extproc;
568
569        extproc = (void *) wglGetProcAddress("glMinmax");
570
571        if (extproc == NULL) {
572                _ASSERT(0);
573                return;
574        }
575
576        glMinmax = extproc;
577
578        glMinmax(target, internalformat, sink);
579}
580
581static void APIENTRY InitResetHistogram (GLenum target)
582{
583        void *extproc;
584
585        extproc = (void *) wglGetProcAddress("glResetHistogram");
586
587        if (extproc == NULL) {
588                _ASSERT(0);
589                return;
590        }
591
592        glResetHistogram = extproc;
593
594        glResetHistogram(target);
595}
596
597static void APIENTRY InitResetMinmax (GLenum target)
598{
599        void *extproc;
600
601        extproc = (void *) wglGetProcAddress("glResetMinmax");
602
603        if (extproc == NULL) {
604                _ASSERT(0);
605                return;
606        }
607
608        glResetMinmax = extproc;
609
610        glResetMinmax(target);
611}
612
613static void APIENTRY InitTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
614{
615        void *extproc;
616
617        extproc = (void *) wglGetProcAddress("glTexImage3D");
618
619        if (extproc == NULL) {
620                _ASSERT(0);
621                return;
622        }
623
624        glTexImage3D = extproc;
625
626        glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
627}
628
629static void APIENTRY InitTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
630{
631        void *extproc;
632
633        extproc = (void *) wglGetProcAddress("glTexSubImage3D");
634
635        if (extproc == NULL) {
636                _ASSERT(0);
637                return;
638        }
639
640        glTexSubImage3D = extproc;
641
642        glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
643}
644
645static void APIENTRY InitCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
646{
647        void *extproc;
648
649        extproc = (void *) wglGetProcAddress("glCopyTexSubImage3D");
650
651        if (extproc == NULL) {
652                _ASSERT(0);
653                return;
654        }
655
656        glCopyTexSubImage3D = extproc;
657
658        glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
659}
660
661static void APIENTRY InitActiveTextureARB (GLenum texture)
662{
663        void *extproc;
664
665        extproc = (void *) wglGetProcAddress("glActiveTextureARB");
666
667        if (extproc == NULL) {
668                _ASSERT(0);
669                return;
670        }
671
672        glActiveTextureARB = extproc;
673
674        glActiveTextureARB(texture);
675}
676
677static void APIENTRY InitClientActiveTextureARB (GLenum texture)
678{
679        void *extproc;
680
681        extproc = (void *) wglGetProcAddress("glClientActiveTextureARB");
682
683        if (extproc == NULL) {
684                _ASSERT(0);
685                return;
686        }
687
688        glClientActiveTextureARB = extproc;
689
690        glClientActiveTextureARB(texture);
691}
692
693static void APIENTRY InitMultiTexCoord1dARB (GLenum target, GLdouble s)
694{
695        void *extproc;
696
697        extproc = (void *) wglGetProcAddress("glMultiTexCoord1dARB");
698
699        if (extproc == NULL) {
700                _ASSERT(0);
701                return;
702        }
703
704        glMultiTexCoord1dARB = extproc;
705
706        glMultiTexCoord1dARB(target, s);
707}
708
709static void APIENTRY InitMultiTexCoord1dvARB (GLenum target, const GLdouble *v)
710{
711        void *extproc;
712
713        extproc = (void *) wglGetProcAddress("glMultiTexCoord1dvARB");
714
715        if (extproc == NULL) {
716                _ASSERT(0);
717                return;
718        }
719
720        glMultiTexCoord1dvARB = extproc;
721
722        glMultiTexCoord1dvARB(target, v);
723}
724
725static void APIENTRY InitMultiTexCoord1fARB (GLenum target, GLfloat s)
726{
727        void *extproc;
728
729        extproc = (void *) wglGetProcAddress("glMultiTexCoord1fARB");
730
731        if (extproc == NULL) {
732                _ASSERT(0);
733                return;
734        }
735
736        glMultiTexCoord1fARB = extproc;
737
738        glMultiTexCoord1fARB(target, s);
739}
740
741static void APIENTRY InitMultiTexCoord1fvARB (GLenum target, const GLfloat *v)
742{
743        void *extproc;
744
745        extproc = (void *) wglGetProcAddress("glMultiTexCoord1fvARB");
746
747        if (extproc == NULL) {
748                _ASSERT(0);
749                return;
750        }
751
752        glMultiTexCoord1fvARB = extproc;
753
754        glMultiTexCoord1fvARB(target, v);
755}
756
757static void APIENTRY InitMultiTexCoord1iARB (GLenum target, GLint s)
758{
759        void *extproc;
760
761        extproc = (void *) wglGetProcAddress("glMultiTexCoord1iARB");
762
763        if (extproc == NULL) {
764                _ASSERT(0);
765                return;
766        }
767
768        glMultiTexCoord1iARB = extproc;
769
770        glMultiTexCoord1iARB(target, s);
771}
772
773static void APIENTRY InitMultiTexCoord1ivARB (GLenum target, const GLint *v)
774{
775        void *extproc;
776
777        extproc = (void *) wglGetProcAddress("glMultiTexCoord1ivARB");
778
779        if (extproc == NULL) {
780                _ASSERT(0);
781                return;
782        }
783
784        glMultiTexCoord1ivARB = extproc;
785
786        glMultiTexCoord1ivARB(target, v);
787}
788
789static void APIENTRY InitMultiTexCoord1sARB (GLenum target, GLshort s)
790{
791        void *extproc;
792
793        extproc = (void *) wglGetProcAddress("glMultiTexCoord1sARB");
794
795        if (extproc == NULL) {
796                _ASSERT(0);
797                return;
798        }
799
800        glMultiTexCoord1sARB = extproc;
801
802        glMultiTexCoord1sARB(target, s);
803}
804
805static void APIENTRY InitMultiTexCoord1svARB (GLenum target, const GLshort *v)
806{
807        void *extproc;
808
809        extproc = (void *) wglGetProcAddress("glMultiTexCoord1svARB");
810
811        if (extproc == NULL) {
812                _ASSERT(0);
813                return;
814        }
815
816        glMultiTexCoord1svARB = extproc;
817
818        glMultiTexCoord1svARB(target, v);
819}
820
821static void APIENTRY InitMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t)
822{
823        void *extproc;
824
825        extproc = (void *) wglGetProcAddress("glMultiTexCoord2dARB");
826
827        if (extproc == NULL) {
828                _ASSERT(0);
829                return;
830        }
831
832        glMultiTexCoord2dARB = extproc;
833
834        glMultiTexCoord2dARB(target, s, t);
835}
836
837static void APIENTRY InitMultiTexCoord2dvARB (GLenum target, const GLdouble *v)
838{
839        void *extproc;
840
841        extproc = (void *) wglGetProcAddress("glMultiTexCoord2dvARB");
842
843        if (extproc == NULL) {
844                _ASSERT(0);
845                return;
846        }
847
848        glMultiTexCoord2dvARB = extproc;
849
850        glMultiTexCoord2dvARB(target, v);
851}
852
853static void APIENTRY InitMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t)
854{
855        void *extproc;
856
857        extproc = (void *) wglGetProcAddress("glMultiTexCoord2fARB");
858
859        if (extproc == NULL) {
860                _ASSERT(0);
861                return;
862        }
863
864        glMultiTexCoord2fARB = extproc;
865
866        glMultiTexCoord2fARB(target, s, t);
867}
868
869static void APIENTRY InitMultiTexCoord2fvARB (GLenum target, const GLfloat *v)
870{
871        void *extproc;
872
873        extproc = (void *) wglGetProcAddress("glMultiTexCoord2fvARB");
874
875        if (extproc == NULL) {
876                _ASSERT(0);
877                return;
878        }
879
880        glMultiTexCoord2fvARB = extproc;
881
882        glMultiTexCoord2fvARB(target, v);
883}
884
885static void APIENTRY InitMultiTexCoord2iARB (GLenum target, GLint s, GLint t)
886{
887        void *extproc;
888
889        extproc = (void *) wglGetProcAddress("glMultiTexCoord2iARB");
890
891        if (extproc == NULL) {
892                _ASSERT(0);
893                return;
894        }
895
896        glMultiTexCoord2iARB = extproc;
897
898        glMultiTexCoord2iARB(target, s, t);
899}
900
901static void APIENTRY InitMultiTexCoord2ivARB (GLenum target, const GLint *v)
902{
903        void *extproc;
904
905        extproc = (void *) wglGetProcAddress("glMultiTexCoord2ivARB");
906
907        if (extproc == NULL) {
908                _ASSERT(0);
909                return;
910        }
911
912        glMultiTexCoord2ivARB = extproc;
913
914        glMultiTexCoord2ivARB(target, v);
915}
916
917static void APIENTRY InitMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t)
918{
919        void *extproc;
920
921        extproc = (void *) wglGetProcAddress("glMultiTexCoord2sARB");
922
923        if (extproc == NULL) {
924                _ASSERT(0);
925                return;
926        }
927
928        glMultiTexCoord2sARB = extproc;
929
930        glMultiTexCoord2sARB(target, s, t);
931}
932
933static void APIENTRY InitMultiTexCoord2svARB (GLenum target, const GLshort *v)
934{
935        void *extproc;
936
937        extproc = (void *) wglGetProcAddress("glMultiTexCoord2svARB");
938
939        if (extproc == NULL) {
940                _ASSERT(0);
941                return;
942        }
943
944        glMultiTexCoord2svARB = extproc;
945
946        glMultiTexCoord2svARB(target, v);
947}
948
949static void APIENTRY InitMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r)
950{
951        void *extproc;
952
953        extproc = (void *) wglGetProcAddress("glMultiTexCoord3dARB");
954
955        if (extproc == NULL) {
956                _ASSERT(0);
957                return;
958        }
959
960        glMultiTexCoord3dARB = extproc;
961
962        glMultiTexCoord3dARB(target, s, t, r);
963}
964
965static void APIENTRY InitMultiTexCoord3dvARB (GLenum target, const GLdouble *v)
966{
967        void *extproc;
968
969        extproc = (void *) wglGetProcAddress("glMultiTexCoord3dvARB");
970
971        if (extproc == NULL) {
972                _ASSERT(0);
973                return;
974        }
975
976        glMultiTexCoord3dvARB = extproc;
977
978        glMultiTexCoord3dvARB(target, v);
979}
980
981static void APIENTRY InitMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r)
982{
983        void *extproc;
984
985        extproc = (void *) wglGetProcAddress("glMultiTexCoord3fARB");
986
987        if (extproc == NULL) {
988                _ASSERT(0);
989                return;
990        }
991
992        glMultiTexCoord3fARB = extproc;
993
994        glMultiTexCoord3fARB(target, s, t, r);
995}
996
997static void APIENTRY InitMultiTexCoord3fvARB (GLenum target, const GLfloat *v)
998{
999        void *extproc;
1000
1001        extproc = (void *) wglGetProcAddress("glMultiTexCoord3fvARB");
1002
1003        if (extproc == NULL) {
1004                _ASSERT(0);
1005                return;
1006        }
1007
1008        glMultiTexCoord3fvARB = extproc;
1009
1010        glMultiTexCoord3fvARB(target, v);
1011}
1012
1013static void APIENTRY InitMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r)
1014{
1015        void *extproc;
1016
1017        extproc = (void *) wglGetProcAddress("glMultiTexCoord3iARB");
1018
1019        if (extproc == NULL) {
1020                _ASSERT(0);
1021                return;
1022        }
1023
1024        glMultiTexCoord3iARB = extproc;
1025
1026        glMultiTexCoord3iARB(target, s, t, r);
1027}
1028
1029static void APIENTRY InitMultiTexCoord3ivARB (GLenum target, const GLint *v)
1030{
1031        void *extproc;
1032
1033        extproc = (void *) wglGetProcAddress("glMultiTexCoord3ivARB");
1034
1035        if (extproc == NULL) {
1036                _ASSERT(0);
1037                return;
1038        }
1039
1040        glMultiTexCoord3ivARB = extproc;
1041
1042        glMultiTexCoord3ivARB(target, v);
1043}
1044
1045static void APIENTRY InitMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r)
1046{
1047        void *extproc;
1048
1049        extproc = (void *) wglGetProcAddress("glMultiTexCoord3sARB");
1050
1051        if (extproc == NULL) {
1052                _ASSERT(0);
1053                return;
1054        }
1055
1056        glMultiTexCoord3sARB = extproc;
1057
1058        glMultiTexCoord3sARB(target, s, t, r);
1059}
1060
1061static void APIENTRY InitMultiTexCoord3svARB (GLenum target, const GLshort *v)
1062{
1063        void *extproc;
1064
1065        extproc = (void *) wglGetProcAddress("glMultiTexCoord3svARB");
1066
1067        if (extproc == NULL) {
1068                _ASSERT(0);
1069                return;
1070        }
1071
1072        glMultiTexCoord3svARB = extproc;
1073
1074        glMultiTexCoord3svARB(target, v);
1075}
1076
1077static void APIENTRY InitMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1078{
1079        void *extproc;
1080
1081        extproc = (void *) wglGetProcAddress("glMultiTexCoord4dARB");
1082
1083        if (extproc == NULL) {
1084                _ASSERT(0);
1085                return;
1086        }
1087
1088        glMultiTexCoord4dARB = extproc;
1089
1090        glMultiTexCoord4dARB(target, s, t, r, q);
1091}
1092
1093static void APIENTRY InitMultiTexCoord4dvARB (GLenum target, const GLdouble *v)
1094{
1095        void *extproc;
1096
1097        extproc = (void *) wglGetProcAddress("glMultiTexCoord4dvARB");
1098
1099        if (extproc == NULL) {
1100                _ASSERT(0);
1101                return;
1102        }
1103
1104        glMultiTexCoord4dvARB = extproc;
1105
1106        glMultiTexCoord4dvARB(target, v);
1107}
1108
1109static void APIENTRY InitMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1110{
1111        void *extproc;
1112
1113        extproc = (void *) wglGetProcAddress("glMultiTexCoord4fARB");
1114
1115        if (extproc == NULL) {
1116                _ASSERT(0);
1117                return;
1118        }
1119
1120        glMultiTexCoord4fARB = extproc;
1121
1122        glMultiTexCoord4fARB(target, s, t, r, q);
1123}
1124
1125static void APIENTRY InitMultiTexCoord4fvARB (GLenum target, const GLfloat *v)
1126{
1127        void *extproc;
1128
1129        extproc = (void *) wglGetProcAddress("glMultiTexCoord4fvARB");
1130
1131        if (extproc == NULL) {
1132                _ASSERT(0);
1133                return;
1134        }
1135
1136        glMultiTexCoord4fvARB = extproc;
1137
1138        glMultiTexCoord4fvARB(target, v);
1139}
1140
1141static void APIENTRY InitMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q)
1142{
1143        void *extproc;
1144
1145        extproc = (void *) wglGetProcAddress("glMultiTexCoord4iARB");
1146
1147        if (extproc == NULL) {
1148                _ASSERT(0);
1149                return;
1150        }
1151
1152        glMultiTexCoord4iARB = extproc;
1153
1154        glMultiTexCoord4iARB(target, s, t, r, q);
1155}
1156
1157static void APIENTRY InitMultiTexCoord4ivARB (GLenum target, const GLint *v)
1158{
1159        void *extproc;
1160
1161        extproc = (void *) wglGetProcAddress("glMultiTexCoord4ivARB");
1162
1163        if (extproc == NULL) {
1164                _ASSERT(0);
1165                return;
1166        }
1167
1168        glMultiTexCoord4ivARB = extproc;
1169
1170        glMultiTexCoord4ivARB(target, v);
1171}
1172
1173static void APIENTRY InitMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
1174{
1175        void *extproc;
1176
1177        extproc = (void *) wglGetProcAddress("glMultiTexCoord4sARB");
1178
1179        if (extproc == NULL) {
1180                _ASSERT(0);
1181                return;
1182        }
1183
1184        glMultiTexCoord4sARB = extproc;
1185
1186        glMultiTexCoord4sARB(target, s, t, r, q);
1187}
1188
1189static void APIENTRY InitMultiTexCoord4svARB (GLenum target, const GLshort *v)
1190{
1191        void *extproc;
1192
1193        extproc = (void *) wglGetProcAddress("glMultiTexCoord4svARB");
1194
1195        if (extproc == NULL) {
1196                _ASSERT(0);
1197                return;
1198        }
1199
1200        glMultiTexCoord4svARB = extproc;
1201
1202        glMultiTexCoord4svARB(target, v);
1203}
1204
1205static void APIENTRY InitLoadTransposeMatrixfARB (const GLfloat *m)
1206{
1207        void *extproc;
1208
1209        extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixfARB");
1210
1211        if (extproc == NULL) {
1212                _ASSERT(0);
1213                return;
1214        }
1215
1216        glLoadTransposeMatrixfARB = extproc;
1217
1218        glLoadTransposeMatrixfARB(m);
1219}
1220
1221static void APIENTRY InitLoadTransposeMatrixdARB (const GLdouble *m)
1222{
1223        void *extproc;
1224
1225        extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixdARB");
1226
1227        if (extproc == NULL) {
1228                _ASSERT(0);
1229                return;
1230        }
1231
1232        glLoadTransposeMatrixdARB = extproc;
1233
1234        glLoadTransposeMatrixdARB(m);
1235}
1236
1237static void APIENTRY InitMultTransposeMatrixfARB (const GLfloat *m)
1238{
1239        void *extproc;
1240
1241        extproc = (void *) wglGetProcAddress("glMultTransposeMatrixfARB");
1242
1243        if (extproc == NULL) {
1244                _ASSERT(0);
1245                return;
1246        }
1247
1248        glMultTransposeMatrixfARB = extproc;
1249
1250        glMultTransposeMatrixfARB(m);
1251}
1252
1253static void APIENTRY InitMultTransposeMatrixdARB (const GLdouble *m)
1254{
1255        void *extproc;
1256
1257        extproc = (void *) wglGetProcAddress("glMultTransposeMatrixdARB");
1258
1259        if (extproc == NULL) {
1260                _ASSERT(0);
1261                return;
1262        }
1263
1264        glMultTransposeMatrixdARB = extproc;
1265
1266        glMultTransposeMatrixdARB(m);
1267}
1268
1269static void APIENTRY InitSampleCoverageARB (GLclampf value, GLboolean invert)
1270{
1271        void *extproc;
1272
1273        extproc = (void *) wglGetProcAddress("glSampleCoverageARB");
1274
1275        if (extproc == NULL) {
1276                _ASSERT(0);
1277                return;
1278        }
1279
1280        glSampleCoverageARB = extproc;
1281
1282        glSampleCoverageARB(value, invert);
1283}
1284
1285static void APIENTRY InitCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
1286{
1287        void *extproc;
1288
1289        extproc = (void *) wglGetProcAddress("glCompressedTexImage3DARB");
1290
1291        if (extproc == NULL) {
1292                _ASSERT(0);
1293                return;
1294        }
1295
1296        glCompressedTexImage3DARB = extproc;
1297
1298        glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
1299}
1300
1301static void APIENTRY InitCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
1302{
1303        void *extproc;
1304
1305        extproc = (void *) wglGetProcAddress("glCompressedTexImage2DARB");
1306
1307        if (extproc == NULL) {
1308                _ASSERT(0);
1309                return;
1310        }
1311
1312        glCompressedTexImage2DARB = extproc;
1313
1314        glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);
1315}
1316
1317static void APIENTRY InitCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
1318{
1319        void *extproc;
1320
1321        extproc = (void *) wglGetProcAddress("glCompressedTexImage1DARB");
1322
1323        if (extproc == NULL) {
1324                _ASSERT(0);
1325                return;
1326        }
1327
1328        glCompressedTexImage1DARB = extproc;
1329
1330        glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);
1331}
1332
1333static void APIENTRY InitCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
1334{
1335        void *extproc;
1336
1337        extproc = (void *) wglGetProcAddress("glCompressedTexSubImage3DARB");
1338
1339        if (extproc == NULL) {
1340                _ASSERT(0);
1341                return;
1342        }
1343
1344        glCompressedTexSubImage3DARB = extproc;
1345
1346        glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
1347}
1348
1349static void APIENTRY InitCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
1350{
1351        void *extproc;
1352
1353        extproc = (void *) wglGetProcAddress("glCompressedTexSubImage2DARB");
1354
1355        if (extproc == NULL) {
1356                _ASSERT(0);
1357                return;
1358        }
1359
1360        glCompressedTexSubImage2DARB = extproc;
1361
1362        glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
1363}
1364
1365static void APIENTRY InitCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
1366{
1367        void *extproc;
1368
1369        extproc = (void *) wglGetProcAddress("glCompressedTexSubImage1DARB");
1370
1371        if (extproc == NULL) {
1372                _ASSERT(0);
1373                return;
1374        }
1375
1376        glCompressedTexSubImage1DARB = extproc;
1377
1378        glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);
1379}
1380
1381static void APIENTRY InitGetCompressedTexImageARB (GLenum target, GLint level)
1382{
1383        void *extproc;
1384
1385        extproc = (void *) wglGetProcAddress("glGetCompressedTexImageARB");
1386
1387        if (extproc == NULL) {
1388                _ASSERT(0);
1389                return;
1390        }
1391
1392        glGetCompressedTexImageARB = extproc;
1393
1394        glGetCompressedTexImageARB(target, level);
1395}
1396
1397static void APIENTRY InitWeightbvARB (GLint size, const GLbyte *weights)
1398{
1399        void *extproc;
1400
1401        extproc = (void *) wglGetProcAddress("glWeightbvARB");
1402
1403        if (extproc == NULL) {
1404                _ASSERT(0);
1405                return;
1406        }
1407
1408        glWeightbvARB = extproc;
1409
1410        glWeightbvARB(size, weights);
1411}
1412
1413static void APIENTRY InitWeightsvARB (GLint size, const GLshort *weights)
1414{
1415        void *extproc;
1416
1417        extproc = (void *) wglGetProcAddress("glWeightsvARB");
1418
1419        if (extproc == NULL) {
1420                _ASSERT(0);
1421                return;
1422        }
1423
1424        glWeightsvARB = extproc;
1425
1426        glWeightsvARB(size, weights);
1427}
1428
1429static void APIENTRY InitWeightivARB (GLint size, const GLint *weights)
1430{
1431        void *extproc;
1432
1433        extproc = (void *) wglGetProcAddress("glWeightivARB");
1434
1435        if (extproc == NULL) {
1436                _ASSERT(0);
1437                return;
1438        }
1439
1440        glWeightivARB = extproc;
1441
1442        glWeightivARB(size, weights);
1443}
1444
1445static void APIENTRY InitWeightfvARB (GLint size, const GLfloat *weights)
1446{
1447        void *extproc;
1448
1449        extproc = (void *) wglGetProcAddress("glWeightfvARB");
1450
1451        if (extproc == NULL) {
1452                _ASSERT(0);
1453                return;
1454        }
1455
1456        glWeightfvARB = extproc;
1457
1458        glWeightfvARB(size, weights);
1459}
1460
1461static void APIENTRY InitWeightdvARB (GLint size, const GLdouble *weights)
1462{
1463        void *extproc;
1464
1465        extproc = (void *) wglGetProcAddress("glWeightdvARB");
1466
1467        if (extproc == NULL) {
1468                _ASSERT(0);
1469                return;
1470        }
1471
1472        glWeightdvARB = extproc;
1473
1474        glWeightdvARB(size, weights);
1475}
1476
1477static void APIENTRY InitWeightubvARB (GLint size, const GLubyte *weights)
1478{
1479        void *extproc;
1480
1481        extproc = (void *) wglGetProcAddress("glWeightubvARB");
1482
1483        if (extproc == NULL) {
1484                _ASSERT(0);
1485                return;
1486        }
1487
1488        glWeightubvARB = extproc;
1489
1490        glWeightubvARB(size, weights);
1491}
1492
1493static void APIENTRY InitWeightusvARB (GLint size, const GLushort *weights)
1494{
1495        void *extproc;
1496
1497        extproc = (void *) wglGetProcAddress("glWeightusvARB");
1498
1499        if (extproc == NULL) {
1500                _ASSERT(0);
1501                return;
1502        }
1503
1504        glWeightusvARB = extproc;
1505
1506        glWeightusvARB(size, weights);
1507}
1508
1509static void APIENTRY InitWeightuivARB (GLint size, const GLuint *weights)
1510{
1511        void *extproc;
1512
1513        extproc = (void *) wglGetProcAddress("glWeightuivARB");
1514
1515        if (extproc == NULL) {
1516                _ASSERT(0);
1517                return;
1518        }
1519
1520        glWeightuivARB = extproc;
1521
1522        glWeightuivARB(size, weights);
1523}
1524
1525static void APIENTRY InitWeightPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1526{
1527        void *extproc;
1528
1529        extproc = (void *) wglGetProcAddress("glWeightPointerARB");
1530
1531        if (extproc == NULL) {
1532                _ASSERT(0);
1533                return;
1534        }
1535
1536        glWeightPointerARB = extproc;
1537
1538        glWeightPointerARB(size, type, stride, pointer);
1539}
1540
1541static void APIENTRY InitVertexBlendARB (GLint count)
1542{
1543        void *extproc;
1544
1545        extproc = (void *) wglGetProcAddress("glVertexBlendARB");
1546
1547        if (extproc == NULL) {
1548                _ASSERT(0);
1549                return;
1550        }
1551
1552        glVertexBlendARB = extproc;
1553
1554        glVertexBlendARB(count);
1555}
1556
1557static void APIENTRY InitCurrentPaletteMatrixARB (GLint index)
1558{
1559        void *extproc;
1560
1561        extproc = (void *) wglGetProcAddress("glCurrentPaletteMatrixARB");
1562
1563        if (extproc == NULL) {
1564                _ASSERT(0);
1565                return;
1566        }
1567
1568        glCurrentPaletteMatrixARB = extproc;
1569
1570        glCurrentPaletteMatrixARB(index);
1571}
1572
1573static void APIENTRY InitMatrixIndexubvARB (GLint size, const GLubyte *indices)
1574{
1575        void *extproc;
1576
1577        extproc = (void *) wglGetProcAddress("glMatrixIndexubvARB");
1578
1579        if (extproc == NULL) {
1580                _ASSERT(0);
1581                return;
1582        }
1583
1584        glMatrixIndexubvARB = extproc;
1585
1586        glMatrixIndexubvARB(size, indices);
1587}
1588
1589static void APIENTRY InitMatrixIndexusvARB (GLint size, const GLushort *indices)
1590{
1591        void *extproc;
1592
1593        extproc = (void *) wglGetProcAddress("glMatrixIndexusvARB");
1594
1595        if (extproc == NULL) {
1596                _ASSERT(0);
1597                return;
1598        }
1599
1600        glMatrixIndexusvARB = extproc;
1601
1602        glMatrixIndexusvARB(size, indices);
1603}
1604
1605static void APIENTRY InitMatrixIndexuivARB (GLint size, const GLuint *indices)
1606{
1607        void *extproc;
1608
1609        extproc = (void *) wglGetProcAddress("glMatrixIndexuivARB");
1610
1611        if (extproc == NULL) {
1612                _ASSERT(0);
1613                return;
1614        }
1615
1616        glMatrixIndexuivARB = extproc;
1617
1618        glMatrixIndexuivARB(size, indices);
1619}
1620
1621static void APIENTRY InitMatrixIndexPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
1622{
1623        void *extproc;
1624
1625        extproc = (void *) wglGetProcAddress("glMatrixIndexPointerARB");
1626
1627        if (extproc == NULL) {
1628                _ASSERT(0);
1629                return;
1630        }
1631
1632        glMatrixIndexPointerARB = extproc;
1633
1634        glMatrixIndexPointerARB(size, type, stride, pointer);
1635}
1636
1637static void APIENTRY InitBlendColorEXT (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1638{
1639        void *extproc;
1640
1641        extproc = (void *) wglGetProcAddress("glBlendColorEXT");
1642
1643        if (extproc == NULL) {
1644                _ASSERT(0);
1645                return;
1646        }
1647
1648        glBlendColorEXT = extproc;
1649
1650        glBlendColorEXT(red, green, blue, alpha);
1651}
1652
1653static void APIENTRY InitPolygonOffsetEXT (GLfloat factor, GLfloat bias)
1654{
1655        void *extproc;
1656
1657        extproc = (void *) wglGetProcAddress("glPolygonOffsetEXT");
1658
1659        if (extproc == NULL) {
1660                _ASSERT(0);
1661                return;
1662        }
1663
1664        glPolygonOffsetEXT = extproc;
1665
1666        glPolygonOffsetEXT(factor, bias);
1667}
1668
1669static void APIENTRY InitTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
1670{
1671        void *extproc;
1672
1673        extproc = (void *) wglGetProcAddress("glTexImage3DEXT");
1674
1675        if (extproc == NULL) {
1676                _ASSERT(0);
1677                return;
1678        }
1679
1680        glTexImage3DEXT = extproc;
1681
1682        glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);
1683}
1684
1685static void APIENTRY InitTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
1686{
1687        void *extproc;
1688
1689        extproc = (void *) wglGetProcAddress("glTexSubImage3DEXT");
1690
1691        if (extproc == NULL) {
1692                _ASSERT(0);
1693                return;
1694        }
1695
1696        glTexSubImage3DEXT = extproc;
1697
1698        glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
1699}
1700
1701static void APIENTRY InitGetTexFilterFuncSGIS (GLenum target, GLenum filter, GLfloat *weights)
1702{
1703        void *extproc;
1704
1705        extproc = (void *) wglGetProcAddress("glGetTexFilterFuncSGIS");
1706
1707        if (extproc == NULL) {
1708                _ASSERT(0);
1709                return;
1710        }
1711
1712        glGetTexFilterFuncSGIS = extproc;
1713
1714        glGetTexFilterFuncSGIS(target, filter, weights);
1715}
1716
1717static void APIENTRY InitTexFilterFuncSGIS (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights)
1718{
1719        void *extproc;
1720
1721        extproc = (void *) wglGetProcAddress("glTexFilterFuncSGIS");
1722
1723        if (extproc == NULL) {
1724                _ASSERT(0);
1725                return;
1726        }
1727
1728        glTexFilterFuncSGIS = extproc;
1729
1730        glTexFilterFuncSGIS(target, filter, n, weights);
1731}
1732
1733static void APIENTRY InitTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
1734{
1735        void *extproc;
1736
1737        extproc = (void *) wglGetProcAddress("glTexSubImage1DEXT");
1738
1739        if (extproc == NULL) {
1740                _ASSERT(0);
1741                return;
1742        }
1743
1744        glTexSubImage1DEXT = extproc;
1745
1746        glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);
1747}
1748
1749static void APIENTRY InitTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
1750{
1751        void *extproc;
1752
1753        extproc = (void *) wglGetProcAddress("glTexSubImage2DEXT");
1754
1755        if (extproc == NULL) {
1756                _ASSERT(0);
1757                return;
1758        }
1759
1760        glTexSubImage2DEXT = extproc;
1761
1762        glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
1763}
1764
1765static void APIENTRY InitCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
1766{
1767        void *extproc;
1768
1769        extproc = (void *) wglGetProcAddress("glCopyTexImage1DEXT");
1770
1771        if (extproc == NULL) {
1772                _ASSERT(0);
1773                return;
1774        }
1775
1776        glCopyTexImage1DEXT = extproc;
1777
1778        glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);
1779}
1780
1781static void APIENTRY InitCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1782{
1783        void *extproc;
1784
1785        extproc = (void *) wglGetProcAddress("glCopyTexImage2DEXT");
1786
1787        if (extproc == NULL) {
1788                _ASSERT(0);
1789                return;
1790        }
1791
1792        glCopyTexImage2DEXT = extproc;
1793
1794        glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);
1795}
1796
1797static void APIENTRY InitCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
1798{
1799        void *extproc;
1800
1801        extproc = (void *) wglGetProcAddress("glCopyTexSubImage1DEXT");
1802
1803        if (extproc == NULL) {
1804                _ASSERT(0);
1805                return;
1806        }
1807
1808        glCopyTexSubImage1DEXT = extproc;
1809
1810        glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);
1811}
1812
1813static void APIENTRY InitCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1814{
1815        void *extproc;
1816
1817        extproc = (void *) wglGetProcAddress("glCopyTexSubImage2DEXT");
1818
1819        if (extproc == NULL) {
1820                _ASSERT(0);
1821                return;
1822        }
1823
1824        glCopyTexSubImage2DEXT = extproc;
1825
1826        glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);
1827}
1828
1829static void APIENTRY InitCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1830{
1831        void *extproc;
1832
1833        extproc = (void *) wglGetProcAddress("glCopyTexSubImage3DEXT");
1834
1835        if (extproc == NULL) {
1836                _ASSERT(0);
1837                return;
1838        }
1839
1840        glCopyTexSubImage3DEXT = extproc;
1841
1842        glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);
1843}
1844
1845static void APIENTRY InitGetHistogramEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
1846{
1847        void *extproc;
1848
1849        extproc = (void *) wglGetProcAddress("glGetHistogramEXT");
1850
1851        if (extproc == NULL) {
1852                _ASSERT(0);
1853                return;
1854        }
1855
1856        glGetHistogramEXT = extproc;
1857
1858        glGetHistogramEXT(target, reset, format, type, values);
1859}
1860
1861static void APIENTRY InitGetHistogramParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
1862{
1863        void *extproc;
1864
1865        extproc = (void *) wglGetProcAddress("glGetHistogramParameterfvEXT");
1866
1867        if (extproc == NULL) {
1868                _ASSERT(0);
1869                return;
1870        }
1871
1872        glGetHistogramParameterfvEXT = extproc;
1873
1874        glGetHistogramParameterfvEXT(target, pname, params);
1875}
1876
1877static void APIENTRY InitGetHistogramParameterivEXT (GLenum target, GLenum pname, GLint *params)
1878{
1879        void *extproc;
1880
1881        extproc = (void *) wglGetProcAddress("glGetHistogramParameterivEXT");
1882
1883        if (extproc == NULL) {
1884                _ASSERT(0);
1885                return;
1886        }
1887
1888        glGetHistogramParameterivEXT = extproc;
1889
1890        glGetHistogramParameterivEXT(target, pname, params);
1891}
1892
1893static void APIENTRY InitGetMinmaxEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
1894{
1895        void *extproc;
1896
1897        extproc = (void *) wglGetProcAddress("glGetMinmaxEXT");
1898
1899        if (extproc == NULL) {
1900                _ASSERT(0);
1901                return;
1902        }
1903
1904        glGetMinmaxEXT = extproc;
1905
1906        glGetMinmaxEXT(target, reset, format, type, values);
1907}
1908
1909static void APIENTRY InitGetMinmaxParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
1910{
1911        void *extproc;
1912
1913        extproc = (void *) wglGetProcAddress("glGetMinmaxParameterfvEXT");
1914
1915        if (extproc == NULL) {
1916                _ASSERT(0);
1917                return;
1918        }
1919
1920        glGetMinmaxParameterfvEXT = extproc;
1921
1922        glGetMinmaxParameterfvEXT(target, pname, params);
1923}
1924
1925static void APIENTRY InitGetMinmaxParameterivEXT (GLenum target, GLenum pname, GLint *params)
1926{
1927        void *extproc;
1928
1929        extproc = (void *) wglGetProcAddress("glGetMinmaxParameterivEXT");
1930
1931        if (extproc == NULL) {
1932                _ASSERT(0);
1933                return;
1934        }
1935
1936        glGetMinmaxParameterivEXT = extproc;
1937
1938        glGetMinmaxParameterivEXT(target, pname, params);
1939}
1940
1941static void APIENTRY InitHistogramEXT (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
1942{
1943        void *extproc;
1944
1945        extproc = (void *) wglGetProcAddress("glHistogramEXT");
1946
1947        if (extproc == NULL) {
1948                _ASSERT(0);
1949                return;
1950        }
1951
1952        glHistogramEXT = extproc;
1953
1954        glHistogramEXT(target, width, internalformat, sink);
1955}
1956
1957static void APIENTRY InitMinmaxEXT (GLenum target, GLenum internalformat, GLboolean sink)
1958{
1959        void *extproc;
1960
1961        extproc = (void *) wglGetProcAddress("glMinmaxEXT");
1962
1963        if (extproc == NULL) {
1964                _ASSERT(0);
1965                return;
1966        }
1967
1968        glMinmaxEXT = extproc;
1969
1970        glMinmaxEXT(target, internalformat, sink);
1971}
1972
1973static void APIENTRY InitResetHistogramEXT (GLenum target)
1974{
1975        void *extproc;
1976
1977        extproc = (void *) wglGetProcAddress("glResetHistogramEXT");
1978
1979        if (extproc == NULL) {
1980                _ASSERT(0);
1981                return;
1982        }
1983
1984        glResetHistogramEXT = extproc;
1985
1986        glResetHistogramEXT(target);
1987}
1988
1989static void APIENTRY InitResetMinmaxEXT (GLenum target)
1990{
1991        void *extproc;
1992
1993        extproc = (void *) wglGetProcAddress("glResetMinmaxEXT");
1994
1995        if (extproc == NULL) {
1996                _ASSERT(0);
1997                return;
1998        }
1999
2000        glResetMinmaxEXT = extproc;
2001
2002        glResetMinmaxEXT(target);
2003}
2004
2005static void APIENTRY InitConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
2006{
2007        void *extproc;
2008
2009        extproc = (void *) wglGetProcAddress("glConvolutionFilter1DEXT");
2010
2011        if (extproc == NULL) {
2012                _ASSERT(0);
2013                return;
2014        }
2015
2016        glConvolutionFilter1DEXT = extproc;
2017
2018        glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);
2019}
2020
2021static void APIENTRY InitConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
2022{
2023        void *extproc;
2024
2025        extproc = (void *) wglGetProcAddress("glConvolutionFilter2DEXT");
2026
2027        if (extproc == NULL) {
2028                _ASSERT(0);
2029                return;
2030        }
2031
2032        glConvolutionFilter2DEXT = extproc;
2033
2034        glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);
2035}
2036
2037static void APIENTRY InitConvolutionParameterfEXT (GLenum target, GLenum pname, GLfloat params)
2038{
2039        void *extproc;
2040
2041        extproc = (void *) wglGetProcAddress("glConvolutionParameterfEXT");
2042
2043        if (extproc == NULL) {
2044                _ASSERT(0);
2045                return;
2046        }
2047
2048        glConvolutionParameterfEXT = extproc;
2049
2050        glConvolutionParameterfEXT(target, pname, params);
2051}
2052
2053static void APIENTRY InitConvolutionParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params)
2054{
2055        void *extproc;
2056
2057        extproc = (void *) wglGetProcAddress("glConvolutionParameterfvEXT");
2058
2059        if (extproc == NULL) {
2060                _ASSERT(0);
2061                return;
2062        }
2063
2064        glConvolutionParameterfvEXT = extproc;
2065
2066        glConvolutionParameterfvEXT(target, pname, params);
2067}
2068
2069static void APIENTRY InitConvolutionParameteriEXT (GLenum target, GLenum pname, GLint params)
2070{
2071        void *extproc;
2072
2073        extproc = (void *) wglGetProcAddress("glConvolutionParameteriEXT");
2074
2075        if (extproc == NULL) {
2076                _ASSERT(0);
2077                return;
2078        }
2079
2080        glConvolutionParameteriEXT = extproc;
2081
2082        glConvolutionParameteriEXT(target, pname, params);
2083}
2084
2085static void APIENTRY InitConvolutionParameterivEXT (GLenum target, GLenum pname, const GLint *params)
2086{
2087        void *extproc;
2088
2089        extproc = (void *) wglGetProcAddress("glConvolutionParameterivEXT");
2090
2091        if (extproc == NULL) {
2092                _ASSERT(0);
2093                return;
2094        }
2095
2096        glConvolutionParameterivEXT = extproc;
2097
2098        glConvolutionParameterivEXT(target, pname, params);
2099}
2100
2101static void APIENTRY InitCopyConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
2102{
2103        void *extproc;
2104
2105        extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter1DEXT");
2106
2107        if (extproc == NULL) {
2108                _ASSERT(0);
2109                return;
2110        }
2111
2112        glCopyConvolutionFilter1DEXT = extproc;
2113
2114        glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);
2115}
2116
2117static void APIENTRY InitCopyConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
2118{
2119        void *extproc;
2120
2121        extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter2DEXT");
2122
2123        if (extproc == NULL) {
2124                _ASSERT(0);
2125                return;
2126        }
2127
2128        glCopyConvolutionFilter2DEXT = extproc;
2129
2130        glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);
2131}
2132
2133static void APIENTRY InitGetConvolutionFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *image)
2134{
2135        void *extproc;
2136
2137        extproc = (void *) wglGetProcAddress("glGetConvolutionFilterEXT");
2138
2139        if (extproc == NULL) {
2140                _ASSERT(0);
2141                return;
2142        }
2143
2144        glGetConvolutionFilterEXT = extproc;
2145
2146        glGetConvolutionFilterEXT(target, format, type, image);
2147}
2148
2149static void APIENTRY InitGetConvolutionParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
2150{
2151        void *extproc;
2152
2153        extproc = (void *) wglGetProcAddress("glGetConvolutionParameterfvEXT");
2154
2155        if (extproc == NULL) {
2156                _ASSERT(0);
2157                return;
2158        }
2159
2160        glGetConvolutionParameterfvEXT = extproc;
2161
2162        glGetConvolutionParameterfvEXT(target, pname, params);
2163}
2164
2165static void APIENTRY InitGetConvolutionParameterivEXT (GLenum target, GLenum pname, GLint *params)
2166{
2167        void *extproc;
2168
2169        extproc = (void *) wglGetProcAddress("glGetConvolutionParameterivEXT");
2170
2171        if (extproc == NULL) {
2172                _ASSERT(0);
2173                return;
2174        }
2175
2176        glGetConvolutionParameterivEXT = extproc;
2177
2178        glGetConvolutionParameterivEXT(target, pname, params);
2179}
2180
2181static void APIENTRY InitGetSeparableFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
2182{
2183        void *extproc;
2184
2185        extproc = (void *) wglGetProcAddress("glGetSeparableFilterEXT");
2186
2187        if (extproc == NULL) {
2188                _ASSERT(0);
2189                return;
2190        }
2191
2192        glGetSeparableFilterEXT = extproc;
2193
2194        glGetSeparableFilterEXT(target, format, type, row, column, span);
2195}
2196
2197static void APIENTRY InitSeparableFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
2198{
2199        void *extproc;
2200
2201        extproc = (void *) wglGetProcAddress("glSeparableFilter2DEXT");
2202
2203        if (extproc == NULL) {
2204                _ASSERT(0);
2205                return;
2206        }
2207
2208        glSeparableFilter2DEXT = extproc;
2209
2210        glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);
2211}
2212
2213static void APIENTRY InitColorTableSGI (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
2214{
2215        void *extproc;
2216
2217        extproc = (void *) wglGetProcAddress("glColorTableSGI");
2218
2219        if (extproc == NULL) {
2220                _ASSERT(0);
2221                return;
2222        }
2223
2224        glColorTableSGI = extproc;
2225
2226        glColorTableSGI(target, internalformat, width, format, type, table);
2227}
2228
2229static void APIENTRY InitColorTableParameterfvSGI (GLenum target, GLenum pname, const GLfloat *params)
2230{
2231        void *extproc;
2232
2233        extproc = (void *) wglGetProcAddress("glColorTableParameterfvSGI");
2234
2235        if (extproc == NULL) {
2236                _ASSERT(0);
2237                return;
2238        }
2239
2240        glColorTableParameterfvSGI = extproc;
2241
2242        glColorTableParameterfvSGI(target, pname, params);
2243}
2244
2245static void APIENTRY InitColorTableParameterivSGI (GLenum target, GLenum pname, const GLint *params)
2246{
2247        void *extproc;
2248
2249        extproc = (void *) wglGetProcAddress("glColorTableParameterivSGI");
2250
2251        if (extproc == NULL) {
2252                _ASSERT(0);
2253                return;
2254        }
2255
2256        glColorTableParameterivSGI = extproc;
2257
2258        glColorTableParameterivSGI(target, pname, params);
2259}
2260
2261static void APIENTRY InitCopyColorTableSGI (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
2262{
2263        void *extproc;
2264
2265        extproc = (void *) wglGetProcAddress("glCopyColorTableSGI");
2266
2267        if (extproc == NULL) {
2268                _ASSERT(0);
2269                return;
2270        }
2271
2272        glCopyColorTableSGI = extproc;
2273
2274        glCopyColorTableSGI(target, internalformat, x, y, width);
2275}
2276
2277static void APIENTRY InitGetColorTableSGI (GLenum target, GLenum format, GLenum type, GLvoid *table)
2278{
2279        void *extproc;
2280
2281        extproc = (void *) wglGetProcAddress("glGetColorTableSGI");
2282
2283        if (extproc == NULL) {
2284                _ASSERT(0);
2285                return;
2286        }
2287
2288        glGetColorTableSGI = extproc;
2289
2290        glGetColorTableSGI(target, format, type, table);
2291}
2292
2293static void APIENTRY InitGetColorTableParameterfvSGI (GLenum target, GLenum pname, GLfloat *params)
2294{
2295        void *extproc;
2296
2297        extproc = (void *) wglGetProcAddress("glGetColorTableParameterfvSGI");
2298
2299        if (extproc == NULL) {
2300                _ASSERT(0);
2301                return;
2302        }
2303
2304        glGetColorTableParameterfvSGI = extproc;
2305
2306        glGetColorTableParameterfvSGI(target, pname, params);
2307}
2308
2309static void APIENTRY InitGetColorTableParameterivSGI (GLenum target, GLenum pname, GLint *params)
2310{
2311        void *extproc;
2312
2313        extproc = (void *) wglGetProcAddress("glGetColorTableParameterivSGI");
2314
2315        if (extproc == NULL) {
2316                _ASSERT(0);
2317                return;
2318        }
2319
2320        glGetColorTableParameterivSGI = extproc;
2321
2322        glGetColorTableParameterivSGI(target, pname, params);
2323}
2324
2325static void APIENTRY InitPixelTexGenSGIX (GLenum mode)
2326{
2327        void *extproc;
2328
2329        extproc = (void *) wglGetProcAddress("glPixelTexGenSGIX");
2330
2331        if (extproc == NULL) {
2332                _ASSERT(0);
2333                return;
2334        }
2335
2336        glPixelTexGenSGIX = extproc;
2337
2338        glPixelTexGenSGIX(mode);
2339}
2340
2341static void APIENTRY InitPixelTexGenParameteriSGIS (GLenum pname, GLint param)
2342{
2343        void *extproc;
2344
2345        extproc = (void *) wglGetProcAddress("glPixelTexGenParameteriSGIS");
2346
2347        if (extproc == NULL) {
2348                _ASSERT(0);
2349                return;
2350        }
2351
2352        glPixelTexGenParameteriSGIS = extproc;
2353
2354        glPixelTexGenParameteriSGIS(pname, param);
2355}
2356
2357static void APIENTRY InitPixelTexGenParameterivSGIS (GLenum pname, const GLint *params)
2358{
2359        void *extproc;
2360
2361        extproc = (void *) wglGetProcAddress("glPixelTexGenParameterivSGIS");
2362
2363        if (extproc == NULL) {
2364                _ASSERT(0);
2365                return;
2366        }
2367
2368        glPixelTexGenParameterivSGIS = extproc;
2369
2370        glPixelTexGenParameterivSGIS(pname, params);
2371}
2372
2373static void APIENTRY InitPixelTexGenParameterfSGIS (GLenum pname, GLfloat param)
2374{
2375        void *extproc;
2376
2377        extproc = (void *) wglGetProcAddress("glPixelTexGenParameterfSGIS");
2378
2379        if (extproc == NULL) {
2380                _ASSERT(0);
2381                return;
2382        }
2383
2384        glPixelTexGenParameterfSGIS = extproc;
2385
2386        glPixelTexGenParameterfSGIS(pname, param);
2387}
2388
2389static void APIENTRY InitPixelTexGenParameterfvSGIS (GLenum pname, const GLfloat *params)
2390{
2391        void *extproc;
2392
2393        extproc = (void *) wglGetProcAddress("glPixelTexGenParameterfvSGIS");
2394
2395        if (extproc == NULL) {
2396                _ASSERT(0);
2397                return;
2398        }
2399
2400        glPixelTexGenParameterfvSGIS = extproc;
2401
2402        glPixelTexGenParameterfvSGIS(pname, params);
2403}
2404
2405static void APIENTRY InitGetPixelTexGenParameterivSGIS (GLenum pname, GLint *params)
2406{
2407        void *extproc;
2408
2409        extproc = (void *) wglGetProcAddress("glGetPixelTexGenParameterivSGIS");
2410
2411        if (extproc == NULL) {
2412                _ASSERT(0);
2413                return;
2414        }
2415
2416        glGetPixelTexGenParameterivSGIS = extproc;
2417
2418        glGetPixelTexGenParameterivSGIS(pname, params);
2419}
2420
2421static void APIENTRY InitGetPixelTexGenParameterfvSGIS (GLenum pname, GLfloat *params)
2422{
2423        void *extproc;
2424
2425        extproc = (void *) wglGetProcAddress("glGetPixelTexGenParameterfvSGIS");
2426
2427        if (extproc == NULL) {
2428                _ASSERT(0);
2429                return;
2430        }
2431
2432        glGetPixelTexGenParameterfvSGIS = extproc;
2433
2434        glGetPixelTexGenParameterfvSGIS(pname, params);
2435}
2436
2437static void APIENTRY InitTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2438{
2439        void *extproc;
2440
2441        extproc = (void *) wglGetProcAddress("glTexImage4DSGIS");
2442
2443        if (extproc == NULL) {
2444                _ASSERT(0);
2445                return;
2446        }
2447
2448        glTexImage4DSGIS = extproc;
2449
2450        glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
2451}
2452
2453static void APIENTRY InitTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels)
2454{
2455        void *extproc;
2456
2457        extproc = (void *) wglGetProcAddress("glTexSubImage4DSGIS");
2458
2459        if (extproc == NULL) {
2460                _ASSERT(0);
2461                return;
2462        }
2463
2464        glTexSubImage4DSGIS = extproc;
2465
2466        glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
2467}
2468
2469static GLboolean APIENTRY InitAreTexturesResidentEXT (GLsizei n, const GLuint *textures, GLboolean *residences)
2470{
2471        void *extproc;
2472
2473        extproc = (void *) wglGetProcAddress("glAreTexturesResidentEXT");
2474
2475        if (extproc == NULL) {
2476                _ASSERT(0);
2477                return 0;
2478        }
2479
2480        glAreTexturesResidentEXT = extproc;
2481
2482        return glAreTexturesResidentEXT(n, textures, residences);
2483}
2484
2485static void APIENTRY InitBindTextureEXT (GLenum target, GLuint texture)
2486{
2487        void *extproc;
2488
2489        extproc = (void *) wglGetProcAddress("glBindTextureEXT");
2490
2491        if (extproc == NULL) {
2492                _ASSERT(0);
2493                return;
2494        }
2495
2496        glBindTextureEXT = extproc;
2497
2498        glBindTextureEXT(target, texture);
2499}
2500
2501static void APIENTRY InitDeleteTexturesEXT (GLsizei n, const GLuint *textures)
2502{
2503        void *extproc;
2504
2505        extproc = (void *) wglGetProcAddress("glDeleteTexturesEXT");
2506
2507        if (extproc == NULL) {
2508                _ASSERT(0);
2509                return;
2510        }
2511
2512        glDeleteTexturesEXT = extproc;
2513
2514        glDeleteTexturesEXT(n, textures);
2515}
2516
2517static void APIENTRY InitGenTexturesEXT (GLsizei n, GLuint *textures)
2518{
2519        void *extproc;
2520
2521        extproc = (void *) wglGetProcAddress("glGenTexturesEXT");
2522
2523        if (extproc == NULL) {
2524                _ASSERT(0);
2525                return;
2526        }
2527
2528        glGenTexturesEXT = extproc;
2529
2530        glGenTexturesEXT(n, textures);
2531}
2532
2533static GLboolean APIENTRY InitIsTextureEXT (GLuint texture)
2534{
2535        void *extproc;
2536
2537        extproc = (void *) wglGetProcAddress("glIsTextureEXT");
2538
2539        if (extproc == NULL) {
2540                _ASSERT(0);
2541                return 0;
2542        }
2543
2544        glIsTextureEXT = extproc;
2545
2546        return glIsTextureEXT(texture);
2547}
2548
2549static void APIENTRY InitPrioritizeTexturesEXT (GLsizei n, const GLuint *textures, const GLclampf *priorities)
2550{
2551        void *extproc;
2552
2553        extproc = (void *) wglGetProcAddress("glPrioritizeTexturesEXT");
2554
2555        if (extproc == NULL) {
2556                _ASSERT(0);
2557                return;
2558        }
2559
2560        glPrioritizeTexturesEXT = extproc;
2561
2562        glPrioritizeTexturesEXT(n, textures, priorities);
2563}
2564
2565static void APIENTRY InitDetailTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points)
2566{
2567        void *extproc;
2568
2569        extproc = (void *) wglGetProcAddress("glDetailTexFuncSGIS");
2570
2571        if (extproc == NULL) {
2572                _ASSERT(0);
2573                return;
2574        }
2575
2576        glDetailTexFuncSGIS = extproc;
2577
2578        glDetailTexFuncSGIS(target, n, points);
2579}
2580
2581static void APIENTRY InitGetDetailTexFuncSGIS (GLenum target, GLfloat *points)
2582{
2583        void *extproc;
2584
2585        extproc = (void *) wglGetProcAddress("glGetDetailTexFuncSGIS");
2586
2587        if (extproc == NULL) {
2588                _ASSERT(0);
2589                return;
2590        }
2591
2592        glGetDetailTexFuncSGIS = extproc;
2593
2594        glGetDetailTexFuncSGIS(target, points);
2595}
2596
2597static void APIENTRY InitSharpenTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points)
2598{
2599        void *extproc;
2600
2601        extproc = (void *) wglGetProcAddress("glSharpenTexFuncSGIS");
2602
2603        if (extproc == NULL) {
2604                _ASSERT(0);
2605                return;
2606        }
2607
2608        glSharpenTexFuncSGIS = extproc;
2609
2610        glSharpenTexFuncSGIS(target, n, points);
2611}
2612
2613static void APIENTRY InitGetSharpenTexFuncSGIS (GLenum target, GLfloat *points)
2614{
2615        void *extproc;
2616
2617        extproc = (void *) wglGetProcAddress("glGetSharpenTexFuncSGIS");
2618
2619        if (extproc == NULL) {
2620                _ASSERT(0);
2621                return;
2622        }
2623
2624        glGetSharpenTexFuncSGIS = extproc;
2625
2626        glGetSharpenTexFuncSGIS(target, points);
2627}
2628
2629static void APIENTRY InitSampleMaskSGIS (GLclampf value, GLboolean invert)
2630{
2631        void *extproc;
2632
2633        extproc = (void *) wglGetProcAddress("glSampleMaskSGIS");
2634
2635        if (extproc == NULL) {
2636                _ASSERT(0);
2637                return;
2638        }
2639
2640        glSampleMaskSGIS = extproc;
2641
2642        glSampleMaskSGIS(value, invert);
2643}
2644
2645static void APIENTRY InitSamplePatternSGIS (GLenum pattern)
2646{
2647        void *extproc;
2648
2649        extproc = (void *) wglGetProcAddress("glSamplePatternSGIS");
2650
2651        if (extproc == NULL) {
2652                _ASSERT(0);
2653                return;
2654        }
2655
2656        glSamplePatternSGIS = extproc;
2657
2658        glSamplePatternSGIS(pattern);
2659}
2660
2661static void APIENTRY InitArrayElementEXT (GLint i)
2662{
2663        void *extproc;
2664
2665        extproc = (void *) wglGetProcAddress("glArrayElementEXT");
2666
2667        if (extproc == NULL) {
2668                _ASSERT(0);
2669                return;
2670        }
2671
2672        glArrayElementEXT = extproc;
2673
2674        glArrayElementEXT(i);
2675}
2676
2677static void APIENTRY InitColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
2678{
2679        void *extproc;
2680
2681        extproc = (void *) wglGetProcAddress("glColorPointerEXT");
2682
2683        if (extproc == NULL) {
2684                _ASSERT(0);
2685                return;
2686        }
2687
2688        glColorPointerEXT = extproc;
2689
2690        glColorPointerEXT(size, type, stride, count, pointer);
2691}
2692
2693static void APIENTRY InitDrawArraysEXT (GLenum mode, GLint first, GLsizei count)
2694{
2695        void *extproc;
2696
2697        extproc = (void *) wglGetProcAddress("glDrawArraysEXT");
2698
2699        if (extproc == NULL) {
2700                _ASSERT(0);
2701                return;
2702        }
2703
2704        glDrawArraysEXT = extproc;
2705
2706        glDrawArraysEXT(mode, first, count);
2707}
2708
2709static void APIENTRY InitEdgeFlagPointerEXT (GLsizei stride, GLsizei count, const GLboolean *pointer)
2710{
2711        void *extproc;
2712
2713        extproc = (void *) wglGetProcAddress("glEdgeFlagPointerEXT");
2714
2715        if (extproc == NULL) {
2716                _ASSERT(0);
2717                return;
2718        }
2719
2720        glEdgeFlagPointerEXT = extproc;
2721
2722        glEdgeFlagPointerEXT(stride, count, pointer);
2723}
2724
2725static void APIENTRY InitGetPointervEXT (GLenum pname, GLvoid* *params)
2726{
2727        void *extproc;
2728
2729        extproc = (void *) wglGetProcAddress("glGetPointervEXT");
2730
2731        if (extproc == NULL) {
2732                _ASSERT(0);
2733                return;
2734        }
2735
2736        glGetPointervEXT = extproc;
2737
2738        glGetPointervEXT(pname, params);
2739}
2740
2741static void APIENTRY InitIndexPointerEXT (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
2742{
2743        void *extproc;
2744
2745        extproc = (void *) wglGetProcAddress("glIndexPointerEXT");
2746
2747        if (extproc == NULL) {
2748                _ASSERT(0);
2749                return;
2750        }
2751
2752        glIndexPointerEXT = extproc;
2753
2754        glIndexPointerEXT(type, stride, count, pointer);
2755}
2756
2757static void APIENTRY InitNormalPointerEXT (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
2758{
2759        void *extproc;
2760
2761        extproc = (void *) wglGetProcAddress("glNormalPointerEXT");
2762
2763        if (extproc == NULL) {
2764                _ASSERT(0);
2765                return;
2766        }
2767
2768        glNormalPointerEXT = extproc;
2769
2770        glNormalPointerEXT(type, stride, count, pointer);
2771}
2772
2773static void APIENTRY InitTexCoordPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
2774{
2775        void *extproc;
2776
2777        extproc = (void *) wglGetProcAddress("glTexCoordPointerEXT");
2778
2779        if (extproc == NULL) {
2780                _ASSERT(0);
2781                return;
2782        }
2783
2784        glTexCoordPointerEXT = extproc;
2785
2786        glTexCoordPointerEXT(size, type, stride, count, pointer);
2787}
2788
2789static void APIENTRY InitVertexPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
2790{
2791        void *extproc;
2792
2793        extproc = (void *) wglGetProcAddress("glVertexPointerEXT");
2794
2795        if (extproc == NULL) {
2796                _ASSERT(0);
2797                return;
2798        }
2799
2800        glVertexPointerEXT = extproc;
2801
2802        glVertexPointerEXT(size, type, stride, count, pointer);
2803}
2804
2805static void APIENTRY InitBlendEquationEXT (GLenum mode)
2806{
2807        void *extproc;
2808
2809        extproc = (void *) wglGetProcAddress("glBlendEquationEXT");
2810
2811        if (extproc == NULL) {
2812                _ASSERT(0);
2813                return;
2814        }
2815
2816        glBlendEquationEXT = extproc;
2817
2818        glBlendEquationEXT(mode);
2819}
2820
2821static void APIENTRY InitSpriteParameterfSGIX (GLenum pname, GLfloat param)
2822{
2823        void *extproc;
2824
2825        extproc = (void *) wglGetProcAddress("glSpriteParameterfSGIX");
2826
2827        if (extproc == NULL) {
2828                _ASSERT(0);
2829                return;
2830        }
2831
2832        glSpriteParameterfSGIX = extproc;
2833
2834        glSpriteParameterfSGIX(pname, param);
2835}
2836
2837static void APIENTRY InitSpriteParameterfvSGIX (GLenum pname, const GLfloat *params)
2838{
2839        void *extproc;
2840
2841        extproc = (void *) wglGetProcAddress("glSpriteParameterfvSGIX");
2842
2843        if (extproc == NULL) {
2844                _ASSERT(0);
2845                return;
2846        }
2847
2848        glSpriteParameterfvSGIX = extproc;
2849
2850        glSpriteParameterfvSGIX(pname, params);
2851}
2852
2853static void APIENTRY InitSpriteParameteriSGIX (GLenum pname, GLint param)
2854{
2855        void *extproc;
2856
2857        extproc = (void *) wglGetProcAddress("glSpriteParameteriSGIX");
2858
2859        if (extproc == NULL) {
2860                _ASSERT(0);
2861                return;
2862        }
2863
2864        glSpriteParameteriSGIX = extproc;
2865
2866        glSpriteParameteriSGIX(pname, param);
2867}
2868
2869static void APIENTRY InitSpriteParameterivSGIX (GLenum pname, const GLint *params)
2870{
2871        void *extproc;
2872
2873        extproc = (void *) wglGetProcAddress("glSpriteParameterivSGIX");
2874
2875        if (extproc == NULL) {
2876                _ASSERT(0);
2877                return;
2878        }
2879
2880        glSpriteParameterivSGIX = extproc;
2881
2882        glSpriteParameterivSGIX(pname, params);
2883}
2884
2885static void APIENTRY InitPointParameterfARB (GLenum pname, GLfloat param)
2886{
2887        void *extproc;
2888
2889        extproc = (void *) wglGetProcAddress("glPointParameterfARB");
2890
2891        if (extproc == NULL) {
2892                _ASSERT(0);
2893                return;
2894        }
2895
2896        glPointParameterfARB = extproc;
2897
2898        glPointParameterfARB(pname, param);
2899}
2900
2901static void APIENTRY InitPointParameterfvARB (GLenum pname, const GLfloat *params)
2902{
2903        void *extproc;
2904
2905        extproc = (void *) wglGetProcAddress("glPointParameterfvARB");
2906
2907        if (extproc == NULL) {
2908                _ASSERT(0);
2909                return;
2910        }
2911
2912        glPointParameterfvARB = extproc;
2913
2914        glPointParameterfvARB(pname, params);
2915}
2916
2917static void APIENTRY InitPointParameterfEXT (GLenum pname, GLfloat param)
2918{
2919        void *extproc;
2920
2921        extproc = (void *) wglGetProcAddress("glPointParameterfEXT");
2922
2923        if (extproc == NULL) {
2924                _ASSERT(0);
2925                return;
2926        }
2927
2928        glPointParameterfEXT = extproc;
2929
2930        glPointParameterfEXT(pname, param);
2931}
2932
2933static void APIENTRY InitPointParameterfvEXT (GLenum pname, const GLfloat *params)
2934{
2935        void *extproc;
2936
2937        extproc = (void *) wglGetProcAddress("glPointParameterfvEXT");
2938
2939        if (extproc == NULL) {
2940                _ASSERT(0);
2941                return;
2942        }
2943
2944        glPointParameterfvEXT = extproc;
2945
2946        glPointParameterfvEXT(pname, params);
2947}
2948
2949static void APIENTRY InitPointParameterfSGIS (GLenum pname, GLfloat param)
2950{
2951        void *extproc;
2952
2953        extproc = (void *) wglGetProcAddress("glPointParameterfSGIS");
2954
2955        if (extproc == NULL) {
2956                _ASSERT(0);
2957                return;
2958        }
2959
2960        glPointParameterfSGIS = extproc;
2961
2962        glPointParameterfSGIS(pname, param);
2963}
2964
2965static void APIENTRY InitPointParameterfvSGIS (GLenum pname, const GLfloat *params)
2966{
2967        void *extproc;
2968
2969        extproc = (void *) wglGetProcAddress("glPointParameterfvSGIS");
2970
2971        if (extproc == NULL) {
2972                _ASSERT(0);
2973                return;
2974        }
2975
2976        glPointParameterfvSGIS = extproc;
2977
2978        glPointParameterfvSGIS(pname, params);
2979}
2980
2981static GLint APIENTRY InitGetInstrumentsSGIX (void)
2982{
2983        void *extproc;
2984
2985        extproc = (void *) wglGetProcAddress("glGetInstrumentsSGIX");
2986
2987        if (extproc == NULL) {
2988                _ASSERT(0);
2989                return 0;
2990        }
2991
2992        glGetInstrumentsSGIX = extproc;
2993
2994        return glGetInstrumentsSGIX();
2995}
2996
2997static void APIENTRY InitInstrumentsBufferSGIX (GLsizei size, GLint *buffer)
2998{
2999        void *extproc;
3000
3001        extproc = (void *) wglGetProcAddress("glInstrumentsBufferSGIX");
3002
3003        if (extproc == NULL) {
3004                _ASSERT(0);
3005                return;
3006        }
3007
3008        glInstrumentsBufferSGIX = extproc;
3009
3010        glInstrumentsBufferSGIX(size, buffer);
3011}
3012
3013static GLint APIENTRY InitPollInstrumentsSGIX (GLint *marker_p)
3014{
3015        void *extproc;
3016
3017        extproc = (void *) wglGetProcAddress("glPollInstrumentsSGIX");
3018
3019        if (extproc == NULL) {
3020                _ASSERT(0);
3021                return 0;
3022        }
3023
3024        glPollInstrumentsSGIX = extproc;
3025
3026        return glPollInstrumentsSGIX(marker_p);
3027}
3028
3029static void APIENTRY InitReadInstrumentsSGIX (GLint marker)
3030{
3031        void *extproc;
3032
3033        extproc = (void *) wglGetProcAddress("glReadInstrumentsSGIX");
3034
3035        if (extproc == NULL) {
3036                _ASSERT(0);
3037                return;
3038        }
3039
3040        glReadInstrumentsSGIX = extproc;
3041
3042        glReadInstrumentsSGIX(marker);
3043}
3044
3045static void APIENTRY InitStartInstrumentsSGIX (void)
3046{
3047        void *extproc;
3048
3049        extproc = (void *) wglGetProcAddress("glStartInstrumentsSGIX");
3050
3051        if (extproc == NULL) {
3052                _ASSERT(0);
3053                return;
3054        }
3055
3056        glStartInstrumentsSGIX = extproc;
3057
3058        glStartInstrumentsSGIX();
3059}
3060
3061static void APIENTRY InitStopInstrumentsSGIX (GLint marker)
3062{
3063        void *extproc;
3064
3065        extproc = (void *) wglGetProcAddress("glStopInstrumentsSGIX");
3066
3067        if (extproc == NULL) {
3068                _ASSERT(0);
3069                return;
3070        }
3071
3072        glStopInstrumentsSGIX = extproc;
3073
3074        glStopInstrumentsSGIX(marker);
3075}
3076
3077static void APIENTRY InitFrameZoomSGIX (GLint factor)
3078{
3079        void *extproc;
3080
3081        extproc = (void *) wglGetProcAddress("glFrameZoomSGIX");
3082
3083        if (extproc == NULL) {
3084                _ASSERT(0);
3085                return;
3086        }
3087
3088        glFrameZoomSGIX = extproc;
3089
3090        glFrameZoomSGIX(factor);
3091}
3092
3093static void APIENTRY InitTagSampleBufferSGIX (void)
3094{
3095        void *extproc;
3096
3097        extproc = (void *) wglGetProcAddress("glTagSampleBufferSGIX");
3098
3099        if (extproc == NULL) {
3100                _ASSERT(0);
3101                return;
3102        }
3103
3104        glTagSampleBufferSGIX = extproc;
3105
3106        glTagSampleBufferSGIX();
3107}
3108
3109static void APIENTRY InitDeformationMap3dSGIX (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points)
3110{
3111        void *extproc;
3112
3113        extproc = (void *) wglGetProcAddress("glDeformationMap3dSGIX");
3114
3115        if (extproc == NULL) {
3116                _ASSERT(0);
3117                return;
3118        }
3119
3120        glDeformationMap3dSGIX = extproc;
3121
3122        glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
3123}
3124
3125static void APIENTRY InitDeformationMap3fSGIX (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points)
3126{
3127        void *extproc;
3128
3129        extproc = (void *) wglGetProcAddress("glDeformationMap3fSGIX");
3130
3131        if (extproc == NULL) {
3132                _ASSERT(0);
3133                return;
3134        }
3135
3136        glDeformationMap3fSGIX = extproc;
3137
3138        glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
3139}
3140
3141static void APIENTRY InitDeformSGIX (GLbitfield mask)
3142{
3143        void *extproc;
3144
3145        extproc = (void *) wglGetProcAddress("glDeformSGIX");
3146
3147        if (extproc == NULL) {
3148                _ASSERT(0);
3149                return;
3150        }
3151
3152        glDeformSGIX = extproc;
3153
3154        glDeformSGIX(mask);
3155}
3156
3157static void APIENTRY InitLoadIdentityDeformationMapSGIX (GLbitfield mask)
3158{
3159        void *extproc;
3160
3161        extproc = (void *) wglGetProcAddress("glLoadIdentityDeformationMapSGIX");
3162
3163        if (extproc == NULL) {
3164                _ASSERT(0);
3165                return;
3166        }
3167
3168        glLoadIdentityDeformationMapSGIX = extproc;
3169
3170        glLoadIdentityDeformationMapSGIX(mask);
3171}
3172
3173static void APIENTRY InitReferencePlaneSGIX (const GLdouble *equation)
3174{
3175        void *extproc;
3176
3177        extproc = (void *) wglGetProcAddress("glReferencePlaneSGIX");
3178
3179        if (extproc == NULL) {
3180                _ASSERT(0);
3181                return;
3182        }
3183
3184        glReferencePlaneSGIX = extproc;
3185
3186        glReferencePlaneSGIX(equation);
3187}
3188
3189static void APIENTRY InitFlushRasterSGIX (void)
3190{
3191        void *extproc;
3192
3193        extproc = (void *) wglGetProcAddress("glFlushRasterSGIX");
3194
3195        if (extproc == NULL) {
3196                _ASSERT(0);
3197                return;
3198        }
3199
3200        glFlushRasterSGIX = extproc;
3201
3202        glFlushRasterSGIX();
3203}
3204
3205static void APIENTRY InitFogFuncSGIS (GLsizei n, const GLfloat *points)
3206{
3207        void *extproc;
3208
3209        extproc = (void *) wglGetProcAddress("glFogFuncSGIS");
3210
3211        if (extproc == NULL) {
3212                _ASSERT(0);
3213                return;
3214        }
3215
3216        glFogFuncSGIS = extproc;
3217
3218        glFogFuncSGIS(n, points);
3219}
3220
3221static void APIENTRY InitGetFogFuncSGIS (GLfloat *points)
3222{
3223        void *extproc;
3224
3225        extproc = (void *) wglGetProcAddress("glGetFogFuncSGIS");
3226
3227        if (extproc == NULL) {
3228                _ASSERT(0);
3229                return;
3230        }
3231
3232        glGetFogFuncSGIS = extproc;
3233
3234        glGetFogFuncSGIS(points);
3235}
3236
3237static void APIENTRY InitImageTransformParameteriHP (GLenum target, GLenum pname, GLint param)
3238{
3239        void *extproc;
3240
3241        extproc = (void *) wglGetProcAddress("glImageTransformParameteriHP");
3242
3243        if (extproc == NULL) {
3244                _ASSERT(0);
3245                return;
3246        }
3247
3248        glImageTransformParameteriHP = extproc;
3249
3250        glImageTransformParameteriHP(target, pname, param);
3251}
3252
3253static void APIENTRY InitImageTransformParameterfHP (GLenum target, GLenum pname, GLfloat param)
3254{
3255        void *extproc;
3256
3257        extproc = (void *) wglGetProcAddress("glImageTransformParameterfHP");
3258
3259        if (extproc == NULL) {
3260                _ASSERT(0);
3261                return;
3262        }
3263
3264        glImageTransformParameterfHP = extproc;
3265
3266        glImageTransformParameterfHP(target, pname, param);
3267}
3268
3269static void APIENTRY InitImageTransformParameterivHP (GLenum target, GLenum pname, const GLint *params)
3270{
3271        void *extproc;
3272
3273        extproc = (void *) wglGetProcAddress("glImageTransformParameterivHP");
3274
3275        if (extproc == NULL) {
3276                _ASSERT(0);
3277                return;
3278        }
3279
3280        glImageTransformParameterivHP = extproc;
3281
3282        glImageTransformParameterivHP(target, pname, params);
3283}
3284
3285static void APIENTRY InitImageTransformParameterfvHP (GLenum target, GLenum pname, const GLfloat *params)
3286{
3287        void *extproc;
3288
3289        extproc = (void *) wglGetProcAddress("glImageTransformParameterfvHP");
3290
3291        if (extproc == NULL) {
3292                _ASSERT(0);
3293                return;
3294        }
3295
3296        glImageTransformParameterfvHP = extproc;
3297
3298        glImageTransformParameterfvHP(target, pname, params);
3299}
3300
3301static void APIENTRY InitGetImageTransformParameterivHP (GLenum target, GLenum pname, GLint *params)
3302{
3303        void *extproc;
3304
3305        extproc = (void *) wglGetProcAddress("glGetImageTransformParameterivHP");
3306
3307        if (extproc == NULL) {
3308                _ASSERT(0);
3309                return;
3310        }
3311
3312        glGetImageTransformParameterivHP = extproc;
3313
3314        glGetImageTransformParameterivHP(target, pname, params);
3315}
3316
3317static void APIENTRY InitGetImageTransformParameterfvHP (GLenum target, GLenum pname, GLfloat *params)
3318{
3319        void *extproc;
3320
3321        extproc = (void *) wglGetProcAddress("glGetImageTransformParameterfvHP");
3322
3323        if (extproc == NULL) {
3324                _ASSERT(0);
3325                return;
3326        }
3327
3328        glGetImageTransformParameterfvHP = extproc;
3329
3330        glGetImageTransformParameterfvHP(target, pname, params);
3331}
3332
3333static void APIENTRY InitColorSubTableEXT (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
3334{
3335        void *extproc;
3336
3337        extproc = (void *) wglGetProcAddress("glColorSubTableEXT");
3338
3339        if (extproc == NULL) {
3340                _ASSERT(0);
3341                return;
3342        }
3343
3344        glColorSubTableEXT = extproc;
3345
3346        glColorSubTableEXT(target, start, count, format, type, data);
3347}
3348
3349static void APIENTRY InitCopyColorSubTableEXT (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
3350{
3351        void *extproc;
3352
3353        extproc = (void *) wglGetProcAddress("glCopyColorSubTableEXT");
3354
3355        if (extproc == NULL) {
3356                _ASSERT(0);
3357                return;
3358        }
3359
3360        glCopyColorSubTableEXT = extproc;
3361
3362        glCopyColorSubTableEXT(target, start, x, y, width);
3363}
3364
3365static void APIENTRY InitHintPGI (GLenum target, GLint mode)
3366{
3367        void *extproc;
3368
3369        extproc = (void *) wglGetProcAddress("glHintPGI");
3370
3371        if (extproc == NULL) {
3372                _ASSERT(0);
3373                return;
3374        }
3375
3376        glHintPGI = extproc;
3377
3378        glHintPGI(target, mode);
3379}
3380
3381static void APIENTRY InitColorTableEXT (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
3382{
3383        void *extproc;
3384
3385        extproc = (void *) wglGetProcAddress("glColorTableEXT");
3386
3387        if (extproc == NULL) {
3388                _ASSERT(0);
3389                return;
3390        }
3391
3392        glColorTableEXT = extproc;
3393
3394        glColorTableEXT(target, internalFormat, width, format, type, table);
3395}
3396
3397static void APIENTRY InitGetColorTableEXT (GLenum target, GLenum format, GLenum type, GLvoid *data)
3398{
3399        void *extproc;
3400
3401        extproc = (void *) wglGetProcAddress("glGetColorTableEXT");
3402
3403        if (extproc == NULL) {
3404                _ASSERT(0);
3405                return;
3406        }
3407
3408        glGetColorTableEXT = extproc;
3409
3410        glGetColorTableEXT(target, format, type, data);
3411}
3412
3413static void APIENTRY InitGetColorTableParameterivEXT (GLenum target, GLenum pname, GLint *params)
3414{
3415        void *extproc;
3416
3417        extproc = (void *) wglGetProcAddress("glGetColorTableParameterivEXT");
3418
3419        if (extproc == NULL) {
3420                _ASSERT(0);
3421                return;
3422        }
3423
3424        glGetColorTableParameterivEXT = extproc;
3425
3426        glGetColorTableParameterivEXT(target, pname, params);
3427}
3428
3429static void APIENTRY InitGetColorTableParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
3430{
3431        void *extproc;
3432
3433        extproc = (void *) wglGetProcAddress("glGetColorTableParameterfvEXT");
3434
3435        if (extproc == NULL) {
3436                _ASSERT(0);
3437                return;
3438        }
3439
3440        glGetColorTableParameterfvEXT = extproc;
3441
3442        glGetColorTableParameterfvEXT(target, pname, params);
3443}
3444
3445static void APIENTRY InitGetListParameterfvSGIX (GLuint list, GLenum pname, GLfloat *params)
3446{
3447        void *extproc;
3448
3449        extproc = (void *) wglGetProcAddress("glGetListParameterfvSGIX");
3450
3451        if (extproc == NULL) {
3452                _ASSERT(0);
3453                return;
3454        }
3455
3456        glGetListParameterfvSGIX = extproc;
3457
3458        glGetListParameterfvSGIX(list, pname, params);
3459}
3460
3461static void APIENTRY InitGetListParameterivSGIX (GLuint list, GLenum pname, GLint *params)
3462{
3463        void *extproc;
3464
3465        extproc = (void *) wglGetProcAddress("glGetListParameterivSGIX");
3466
3467        if (extproc == NULL) {
3468                _ASSERT(0);
3469                return;
3470        }
3471
3472        glGetListParameterivSGIX = extproc;
3473
3474        glGetListParameterivSGIX(list, pname, params);
3475}
3476
3477static void APIENTRY InitListParameterfSGIX (GLuint list, GLenum pname, GLfloat param)
3478{
3479        void *extproc;
3480
3481        extproc = (void *) wglGetProcAddress("glListParameterfSGIX");
3482
3483        if (extproc == NULL) {
3484                _ASSERT(0);
3485                return;
3486        }
3487
3488        glListParameterfSGIX = extproc;
3489
3490        glListParameterfSGIX(list, pname, param);
3491}
3492
3493static void APIENTRY InitListParameterfvSGIX (GLuint list, GLenum pname, const GLfloat *params)
3494{
3495        void *extproc;
3496
3497        extproc = (void *) wglGetProcAddress("glListParameterfvSGIX");
3498
3499        if (extproc == NULL) {
3500                _ASSERT(0);
3501                return;
3502        }
3503
3504        glListParameterfvSGIX = extproc;
3505
3506        glListParameterfvSGIX(list, pname, params);
3507}
3508
3509static void APIENTRY InitListParameteriSGIX (GLuint list, GLenum pname, GLint param)
3510{
3511        void *extproc;
3512
3513        extproc = (void *) wglGetProcAddress("glListParameteriSGIX");
3514
3515        if (extproc == NULL) {
3516                _ASSERT(0);
3517                return;
3518        }
3519
3520        glListParameteriSGIX = extproc;
3521
3522        glListParameteriSGIX(list, pname, param);
3523}
3524
3525static void APIENTRY InitListParameterivSGIX (GLuint list, GLenum pname, const GLint *params)
3526{
3527        void *extproc;
3528
3529        extproc = (void *) wglGetProcAddress("glListParameterivSGIX");
3530
3531        if (extproc == NULL) {
3532                _ASSERT(0);
3533                return;
3534        }
3535
3536        glListParameterivSGIX = extproc;
3537
3538        glListParameterivSGIX(list, pname, params);
3539}
3540
3541static void APIENTRY InitIndexMaterialEXT (GLenum face, GLenum mode)
3542{
3543        void *extproc;
3544
3545        extproc = (void *) wglGetProcAddress("glIndexMaterialEXT");
3546
3547        if (extproc == NULL) {
3548                _ASSERT(0);
3549                return;
3550        }
3551
3552        glIndexMaterialEXT = extproc;
3553
3554        glIndexMaterialEXT(face, mode);
3555}
3556
3557static void APIENTRY InitIndexFuncEXT (GLenum func, GLclampf ref)
3558{
3559        void *extproc;
3560
3561        extproc = (void *) wglGetProcAddress("glIndexFuncEXT");
3562
3563        if (extproc == NULL) {
3564                _ASSERT(0);
3565                return;
3566        }
3567
3568        glIndexFuncEXT = extproc;
3569
3570        glIndexFuncEXT(func, ref);
3571}
3572
3573static void APIENTRY InitLockArraysEXT (GLint first, GLsizei count)
3574{
3575        void *extproc;
3576
3577        extproc = (void *) wglGetProcAddress("glLockArraysEXT");
3578
3579        if (extproc == NULL) {
3580                _ASSERT(0);
3581                return;
3582        }
3583
3584        glLockArraysEXT = extproc;
3585
3586        glLockArraysEXT(first, count);
3587}
3588
3589static void APIENTRY InitUnlockArraysEXT (void)
3590{
3591        void *extproc;
3592
3593        extproc = (void *) wglGetProcAddress("glUnlockArraysEXT");
3594
3595        if (extproc == NULL) {
3596                _ASSERT(0);
3597                return;
3598        }
3599
3600        glUnlockArraysEXT = extproc;
3601
3602        glUnlockArraysEXT();
3603}
3604
3605static void APIENTRY InitCullParameterdvEXT (GLenum pname, GLdouble *params)
3606{
3607        void *extproc;
3608
3609        extproc = (void *) wglGetProcAddress("glCullParameterdvEXT");
3610
3611        if (extproc == NULL) {
3612                _ASSERT(0);
3613                return;
3614        }
3615
3616        glCullParameterdvEXT = extproc;
3617
3618        glCullParameterdvEXT(pname, params);
3619}
3620
3621static void APIENTRY InitCullParameterfvEXT (GLenum pname, GLfloat *params)
3622{
3623        void *extproc;
3624
3625        extproc = (void *) wglGetProcAddress("glCullParameterfvEXT");
3626
3627        if (extproc == NULL) {
3628                _ASSERT(0);
3629                return;
3630        }
3631
3632        glCullParameterfvEXT = extproc;
3633
3634        glCullParameterfvEXT(pname, params);
3635}
3636
3637static void APIENTRY InitFragmentColorMaterialSGIX (GLenum face, GLenum mode)
3638{
3639        void *extproc;
3640
3641        extproc = (void *) wglGetProcAddress("glFragmentColorMaterialSGIX");
3642
3643        if (extproc == NULL) {
3644                _ASSERT(0);
3645                return;
3646        }
3647
3648        glFragmentColorMaterialSGIX = extproc;
3649
3650        glFragmentColorMaterialSGIX(face, mode);
3651}
3652
3653static void APIENTRY InitFragmentLightfSGIX (GLenum light, GLenum pname, GLfloat param)
3654{
3655        void *extproc;
3656
3657        extproc = (void *) wglGetProcAddress("glFragmentLightfSGIX");
3658
3659        if (extproc == NULL) {
3660                _ASSERT(0);
3661                return;
3662        }
3663
3664        glFragmentLightfSGIX = extproc;
3665
3666        glFragmentLightfSGIX(light, pname, param);
3667}
3668
3669static void APIENTRY InitFragmentLightfvSGIX (GLenum light, GLenum pname, const GLfloat *params)
3670{
3671        void *extproc;
3672
3673        extproc = (void *) wglGetProcAddress("glFragmentLightfvSGIX");
3674
3675        if (extproc == NULL) {
3676                _ASSERT(0);
3677                return;
3678        }
3679
3680        glFragmentLightfvSGIX = extproc;
3681
3682        glFragmentLightfvSGIX(light, pname, params);
3683}
3684
3685static void APIENTRY InitFragmentLightiSGIX (GLenum light, GLenum pname, GLint param)
3686{
3687        void *extproc;
3688
3689        extproc = (void *) wglGetProcAddress("glFragmentLightiSGIX");
3690
3691        if (extproc == NULL) {
3692                _ASSERT(0);
3693                return;
3694        }
3695
3696        glFragmentLightiSGIX = extproc;
3697
3698        glFragmentLightiSGIX(light, pname, param);
3699}
3700
3701static void APIENTRY InitFragmentLightivSGIX (GLenum light, GLenum pname, const GLint *params)
3702{
3703        void *extproc;
3704
3705        extproc = (void *) wglGetProcAddress("glFragmentLightivSGIX");
3706
3707        if (extproc == NULL) {
3708                _ASSERT(0);
3709                return;
3710        }
3711
3712        glFragmentLightivSGIX = extproc;
3713
3714        glFragmentLightivSGIX(light, pname, params);
3715}
3716
3717static void APIENTRY InitFragmentLightModelfSGIX (GLenum pname, GLfloat param)
3718{
3719        void *extproc;
3720
3721        extproc = (void *) wglGetProcAddress("glFragmentLightModelfSGIX");
3722
3723        if (extproc == NULL) {
3724                _ASSERT(0);
3725                return;
3726        }
3727
3728        glFragmentLightModelfSGIX = extproc;
3729
3730        glFragmentLightModelfSGIX(pname, param);
3731}
3732
3733static void APIENTRY InitFragmentLightModelfvSGIX (GLenum pname, const GLfloat *params)
3734{
3735        void *extproc;
3736
3737        extproc = (void *) wglGetProcAddress("glFragmentLightModelfvSGIX");
3738
3739        if (extproc == NULL) {
3740                _ASSERT(0);
3741                return;
3742        }
3743
3744        glFragmentLightModelfvSGIX = extproc;
3745
3746        glFragmentLightModelfvSGIX(pname, params);
3747}
3748
3749static void APIENTRY InitFragmentLightModeliSGIX (GLenum pname, GLint param)
3750{
3751        void *extproc;
3752
3753        extproc = (void *) wglGetProcAddress("glFragmentLightModeliSGIX");
3754
3755        if (extproc == NULL) {
3756                _ASSERT(0);
3757                return;
3758        }
3759
3760        glFragmentLightModeliSGIX = extproc;
3761
3762        glFragmentLightModeliSGIX(pname, param);
3763}
3764
3765static void APIENTRY InitFragmentLightModelivSGIX (GLenum pname, const GLint *params)
3766{
3767        void *extproc;
3768
3769        extproc = (void *) wglGetProcAddress("glFragmentLightModelivSGIX");
3770
3771        if (extproc == NULL) {
3772                _ASSERT(0);
3773                return;
3774        }
3775
3776        glFragmentLightModelivSGIX = extproc;
3777
3778        glFragmentLightModelivSGIX(pname, params);
3779}
3780
3781static void APIENTRY InitFragmentMaterialfSGIX (GLenum face, GLenum pname, GLfloat param)
3782{
3783        void *extproc;
3784
3785        extproc = (void *) wglGetProcAddress("glFragmentMaterialfSGIX");
3786
3787        if (extproc == NULL) {
3788                _ASSERT(0);
3789                return;
3790        }
3791
3792        glFragmentMaterialfSGIX = extproc;
3793
3794        glFragmentMaterialfSGIX(face, pname, param);
3795}
3796
3797static void APIENTRY InitFragmentMaterialfvSGIX (GLenum face, GLenum pname, const GLfloat *params)
3798{
3799        void *extproc;
3800
3801        extproc = (void *) wglGetProcAddress("glFragmentMaterialfvSGIX");
3802
3803        if (extproc == NULL) {
3804                _ASSERT(0);
3805                return;
3806        }
3807
3808        glFragmentMaterialfvSGIX = extproc;
3809
3810        glFragmentMaterialfvSGIX(face, pname, params);
3811}
3812
3813static void APIENTRY InitFragmentMaterialiSGIX (GLenum face, GLenum pname, GLint param)
3814{
3815        void *extproc;
3816
3817        extproc = (void *) wglGetProcAddress("glFragmentMaterialiSGIX");
3818
3819        if (extproc == NULL) {
3820                _ASSERT(0);
3821                return;
3822        }
3823
3824        glFragmentMaterialiSGIX = extproc;
3825
3826        glFragmentMaterialiSGIX(face, pname, param);
3827}
3828
3829static void APIENTRY InitFragmentMaterialivSGIX (GLenum face, GLenum pname, const GLint *params)
3830{
3831        void *extproc;
3832
3833        extproc = (void *) wglGetProcAddress("glFragmentMaterialivSGIX");
3834
3835        if (extproc == NULL) {
3836                _ASSERT(0);
3837                return;
3838        }
3839
3840        glFragmentMaterialivSGIX = extproc;
3841
3842        glFragmentMaterialivSGIX(face, pname, params);
3843}
3844
3845static void APIENTRY InitGetFragmentLightfvSGIX (GLenum light, GLenum pname, GLfloat *params)
3846{
3847        void *extproc;
3848
3849        extproc = (void *) wglGetProcAddress("glGetFragmentLightfvSGIX");
3850
3851        if (extproc == NULL) {
3852                _ASSERT(0);
3853                return;
3854        }
3855
3856        glGetFragmentLightfvSGIX = extproc;
3857
3858        glGetFragmentLightfvSGIX(light, pname, params);
3859}
3860
3861static void APIENTRY InitGetFragmentLightivSGIX (GLenum light, GLenum pname, GLint *params)
3862{
3863        void *extproc;
3864
3865        extproc = (void *) wglGetProcAddress("glGetFragmentLightivSGIX");
3866
3867        if (extproc == NULL) {
3868                _ASSERT(0);
3869                return;
3870        }
3871
3872        glGetFragmentLightivSGIX = extproc;
3873
3874        glGetFragmentLightivSGIX(light, pname, params);
3875}
3876
3877static void APIENTRY InitGetFragmentMaterialfvSGIX (GLenum face, GLenum pname, GLfloat *params)
3878{
3879        void *extproc;
3880
3881        extproc = (void *) wglGetProcAddress("glGetFragmentMaterialfvSGIX");
3882
3883        if (extproc == NULL) {
3884                _ASSERT(0);
3885                return;
3886        }
3887
3888        glGetFragmentMaterialfvSGIX = extproc;
3889
3890        glGetFragmentMaterialfvSGIX(face, pname, params);
3891}
3892
3893static void APIENTRY InitGetFragmentMaterialivSGIX (GLenum face, GLenum pname, GLint *params)
3894{
3895        void *extproc;
3896
3897        extproc = (void *) wglGetProcAddress("glGetFragmentMaterialivSGIX");
3898
3899        if (extproc == NULL) {
3900                _ASSERT(0);
3901                return;
3902        }
3903
3904        glGetFragmentMaterialivSGIX = extproc;
3905
3906        glGetFragmentMaterialivSGIX(face, pname, params);
3907}
3908
3909static void APIENTRY InitLightEnviSGIX (GLenum pname, GLint param)
3910{
3911        void *extproc;
3912
3913        extproc = (void *) wglGetProcAddress("glLightEnviSGIX");
3914
3915        if (extproc == NULL) {
3916                _ASSERT(0);
3917                return;
3918        }
3919
3920        glLightEnviSGIX = extproc;
3921
3922        glLightEnviSGIX(pname, param);
3923}
3924
3925static void APIENTRY InitDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
3926{
3927        void *extproc;
3928
3929        extproc = (void *) wglGetProcAddress("glDrawRangeElementsEXT");
3930
3931        if (extproc == NULL) {
3932                _ASSERT(0);
3933                return;
3934        }
3935
3936        glDrawRangeElementsEXT = extproc;
3937
3938        glDrawRangeElementsEXT(mode, start, end, count, type, indices);
3939}
3940
3941static void APIENTRY InitApplyTextureEXT (GLenum mode)
3942{
3943        void *extproc;
3944
3945        extproc = (void *) wglGetProcAddress("glApplyTextureEXT");
3946
3947        if (extproc == NULL) {
3948                _ASSERT(0);
3949                return;
3950        }
3951
3952        glApplyTextureEXT = extproc;
3953
3954        glApplyTextureEXT(mode);
3955}
3956
3957static void APIENTRY InitTextureLightEXT (GLenum pname)
3958{
3959        void *extproc;
3960
3961        extproc = (void *) wglGetProcAddress("glTextureLightEXT");
3962
3963        if (extproc == NULL) {
3964                _ASSERT(0);
3965                return;
3966        }
3967
3968        glTextureLightEXT = extproc;
3969
3970        glTextureLightEXT(pname);
3971}
3972
3973static void APIENTRY InitTextureMaterialEXT (GLenum face, GLenum mode)
3974{
3975        void *extproc;
3976
3977        extproc = (void *) wglGetProcAddress("glTextureMaterialEXT");
3978
3979        if (extproc == NULL) {
3980                _ASSERT(0);
3981                return;
3982        }
3983
3984        glTextureMaterialEXT = extproc;
3985
3986        glTextureMaterialEXT(face, mode);
3987}
3988
3989static void APIENTRY InitAsyncMarkerSGIX (GLuint marker)
3990{
3991        void *extproc;
3992
3993        extproc = (void *) wglGetProcAddress("glAsyncMarkerSGIX");
3994
3995        if (extproc == NULL) {
3996                _ASSERT(0);
3997                return;
3998        }
3999
4000        glAsyncMarkerSGIX = extproc;
4001
4002        glAsyncMarkerSGIX(marker);
4003}
4004
4005static GLint APIENTRY InitFinishAsyncSGIX (GLuint *markerp)
4006{
4007        void *extproc;
4008
4009        extproc = (void *) wglGetProcAddress("glFinishAsyncSGIX");
4010
4011        if (extproc == NULL) {
4012                _ASSERT(0);
4013                return 0;
4014        }
4015
4016        glFinishAsyncSGIX = extproc;
4017
4018        return glFinishAsyncSGIX(markerp);
4019}
4020
4021static GLint APIENTRY InitPollAsyncSGIX (GLuint *markerp)
4022{
4023        void *extproc;
4024
4025        extproc = (void *) wglGetProcAddress("glPollAsyncSGIX");
4026
4027        if (extproc == NULL) {
4028                _ASSERT(0);
4029                return 0;
4030        }
4031
4032        glPollAsyncSGIX = extproc;
4033
4034        return glPollAsyncSGIX(markerp);
4035}
4036
4037static GLuint APIENTRY InitGenAsyncMarkersSGIX (GLsizei range)
4038{
4039        void *extproc;
4040
4041        extproc = (void *) wglGetProcAddress("glGenAsyncMarkersSGIX");
4042
4043        if (extproc == NULL) {
4044                _ASSERT(0);
4045                return 0;
4046        }
4047
4048        glGenAsyncMarkersSGIX = extproc;
4049
4050        return glGenAsyncMarkersSGIX(range);
4051}
4052
4053static void APIENTRY InitDeleteAsyncMarkersSGIX (GLuint marker, GLsizei range)
4054{
4055        void *extproc;
4056
4057        extproc = (void *) wglGetProcAddress("glDeleteAsyncMarkersSGIX");
4058
4059        if (extproc == NULL) {
4060                _ASSERT(0);
4061                return;
4062        }
4063
4064        glDeleteAsyncMarkersSGIX = extproc;
4065
4066        glDeleteAsyncMarkersSGIX(marker, range);
4067}
4068
4069static GLboolean APIENTRY InitIsAsyncMarkerSGIX (GLuint marker)
4070{
4071        void *extproc;
4072
4073        extproc = (void *) wglGetProcAddress("glIsAsyncMarkerSGIX");
4074
4075        if (extproc == NULL) {
4076                _ASSERT(0);
4077                return 0;
4078        }
4079
4080        glIsAsyncMarkerSGIX = extproc;
4081
4082        return glIsAsyncMarkerSGIX(marker);
4083}
4084
4085static void APIENTRY InitVertexPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer)
4086{
4087        void *extproc;
4088
4089        extproc = (void *) wglGetProcAddress("glVertexPointervINTEL");
4090
4091        if (extproc == NULL) {
4092                _ASSERT(0);
4093                return;
4094        }
4095
4096        glVertexPointervINTEL = extproc;
4097
4098        glVertexPointervINTEL(size, type, pointer);
4099}
4100
4101static void APIENTRY InitNormalPointervINTEL (GLenum type, const GLvoid* *pointer)
4102{
4103        void *extproc;
4104
4105        extproc = (void *) wglGetProcAddress("glNormalPointervINTEL");
4106
4107        if (extproc == NULL) {
4108                _ASSERT(0);
4109                return;
4110        }
4111
4112        glNormalPointervINTEL = extproc;
4113
4114        glNormalPointervINTEL(type, pointer);
4115}
4116
4117static void APIENTRY InitColorPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer)
4118{
4119        void *extproc;
4120
4121        extproc = (void *) wglGetProcAddress("glColorPointervINTEL");
4122
4123        if (extproc == NULL) {
4124                _ASSERT(0);
4125                return;
4126        }
4127
4128        glColorPointervINTEL = extproc;
4129
4130        glColorPointervINTEL(size, type, pointer);
4131}
4132
4133static void APIENTRY InitTexCoordPointervINTEL (GLint size, GLenum type, const GLvoid* *pointer)
4134{
4135        void *extproc;
4136
4137        extproc = (void *) wglGetProcAddress("glTexCoordPointervINTEL");
4138
4139        if (extproc == NULL) {
4140                _ASSERT(0);
4141                return;
4142        }
4143
4144        glTexCoordPointervINTEL = extproc;
4145
4146        glTexCoordPointervINTEL(size, type, pointer);
4147}
4148
4149static void APIENTRY InitPixelTransformParameteriEXT (GLenum target, GLenum pname, GLint param)
4150{
4151        void *extproc;
4152
4153        extproc = (void *) wglGetProcAddress("glPixelTransformParameteriEXT");
4154
4155        if (extproc == NULL) {
4156                _ASSERT(0);
4157                return;
4158        }
4159
4160        glPixelTransformParameteriEXT = extproc;
4161
4162        glPixelTransformParameteriEXT(target, pname, param);
4163}
4164
4165static void APIENTRY InitPixelTransformParameterfEXT (GLenum target, GLenum pname, GLfloat param)
4166{
4167        void *extproc;
4168
4169        extproc = (void *) wglGetProcAddress("glPixelTransformParameterfEXT");
4170
4171        if (extproc == NULL) {
4172                _ASSERT(0);
4173                return;
4174        }
4175
4176        glPixelTransformParameterfEXT = extproc;
4177
4178        glPixelTransformParameterfEXT(target, pname, param);
4179}
4180
4181static void APIENTRY InitPixelTransformParameterivEXT (GLenum target, GLenum pname, const GLint *params)
4182{
4183        void *extproc;
4184
4185        extproc = (void *) wglGetProcAddress("glPixelTransformParameterivEXT");
4186
4187        if (extproc == NULL) {
4188                _ASSERT(0);
4189                return;
4190        }
4191
4192        glPixelTransformParameterivEXT = extproc;
4193
4194        glPixelTransformParameterivEXT(target, pname, params);
4195}
4196
4197static void APIENTRY InitPixelTransformParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params)
4198{
4199        void *extproc;
4200
4201        extproc = (void *) wglGetProcAddress("glPixelTransformParameterfvEXT");
4202
4203        if (extproc == NULL) {
4204                _ASSERT(0);
4205                return;
4206        }
4207
4208        glPixelTransformParameterfvEXT = extproc;
4209
4210        glPixelTransformParameterfvEXT(target, pname, params);
4211}
4212
4213static void APIENTRY InitSecondaryColor3bEXT (GLbyte red, GLbyte green, GLbyte blue)
4214{
4215        void *extproc;
4216
4217        extproc = (void *) wglGetProcAddress("glSecondaryColor3bEXT");
4218
4219        if (extproc == NULL) {
4220                _ASSERT(0);
4221                return;
4222        }
4223
4224        glSecondaryColor3bEXT = extproc;
4225
4226        glSecondaryColor3bEXT(red, green, blue);
4227}
4228
4229static void APIENTRY InitSecondaryColor3bvEXT (const GLbyte *v)
4230{
4231        void *extproc;
4232
4233        extproc = (void *) wglGetProcAddress("glSecondaryColor3bvEXT");
4234
4235        if (extproc == NULL) {
4236                _ASSERT(0);
4237                return;
4238        }
4239
4240        glSecondaryColor3bvEXT = extproc;
4241
4242        glSecondaryColor3bvEXT(v);
4243}
4244
4245static void APIENTRY InitSecondaryColor3dEXT (GLdouble red, GLdouble green, GLdouble blue)
4246{
4247        void *extproc;
4248
4249        extproc = (void *) wglGetProcAddress("glSecondaryColor3dEXT");
4250
4251        if (extproc == NULL) {
4252                _ASSERT(0);
4253                return;
4254        }
4255
4256        glSecondaryColor3dEXT = extproc;
4257
4258        glSecondaryColor3dEXT(red, green, blue);
4259}
4260
4261static void APIENTRY InitSecondaryColor3dvEXT (const GLdouble *v)
4262{
4263        void *extproc;
4264
4265        extproc = (void *) wglGetProcAddress("glSecondaryColor3dvEXT");
4266
4267        if (extproc == NULL) {
4268                _ASSERT(0);
4269                return;
4270        }
4271
4272        glSecondaryColor3dvEXT = extproc;
4273
4274        glSecondaryColor3dvEXT(v);
4275}
4276
4277static void APIENTRY InitSecondaryColor3fEXT (GLfloat red, GLfloat green, GLfloat blue)
4278{
4279        void *extproc;
4280
4281        extproc = (void *) wglGetProcAddress("glSecondaryColor3fEXT");
4282
4283        if (extproc == NULL) {
4284                _ASSERT(0);
4285                return;
4286        }
4287
4288        glSecondaryColor3fEXT = extproc;
4289
4290        glSecondaryColor3fEXT(red, green, blue);
4291}
4292
4293static void APIENTRY InitSecondaryColor3fvEXT (const GLfloat *v)
4294{
4295        void *extproc;
4296
4297        extproc = (void *) wglGetProcAddress("glSecondaryColor3fvEXT");
4298
4299        if (extproc == NULL) {
4300                _ASSERT(0);
4301                return;
4302        }
4303
4304        glSecondaryColor3fvEXT = extproc;
4305
4306        glSecondaryColor3fvEXT(v);
4307}
4308
4309static void APIENTRY InitSecondaryColor3iEXT (GLint red, GLint green, GLint blue)
4310{
4311        void *extproc;
4312
4313        extproc = (void *) wglGetProcAddress("glSecondaryColor3iEXT");
4314
4315        if (extproc == NULL) {
4316                _ASSERT(0);
4317                return;
4318        }
4319
4320        glSecondaryColor3iEXT = extproc;
4321
4322        glSecondaryColor3iEXT(red, green, blue);
4323}
4324
4325static void APIENTRY InitSecondaryColor3ivEXT (const GLint *v)
4326{
4327        void *extproc;
4328
4329        extproc = (void *) wglGetProcAddress("glSecondaryColor3ivEXT");
4330
4331        if (extproc == NULL) {
4332                _ASSERT(0);
4333                return;
4334        }
4335
4336        glSecondaryColor3ivEXT = extproc;
4337
4338        glSecondaryColor3ivEXT(v);
4339}
4340
4341static void APIENTRY InitSecondaryColor3sEXT (GLshort red, GLshort green, GLshort blue)
4342{
4343        void *extproc;
4344
4345        extproc = (void *) wglGetProcAddress("glSecondaryColor3sEXT");
4346
4347        if (extproc == NULL) {
4348                _ASSERT(0);
4349                return;
4350        }
4351
4352        glSecondaryColor3sEXT = extproc;
4353
4354        glSecondaryColor3sEXT(red, green, blue);
4355}
4356
4357static void APIENTRY InitSecondaryColor3svEXT (const GLshort *v)
4358{
4359        void *extproc;
4360
4361        extproc = (void *) wglGetProcAddress("glSecondaryColor3svEXT");
4362
4363        if (extproc == NULL) {
4364                _ASSERT(0);
4365                return;
4366        }
4367
4368        glSecondaryColor3svEXT = extproc;
4369
4370        glSecondaryColor3svEXT(v);
4371}
4372
4373static void APIENTRY InitSecondaryColor3ubEXT (GLubyte red, GLubyte green, GLubyte blue)
4374{
4375        void *extproc;
4376
4377        extproc = (void *) wglGetProcAddress("glSecondaryColor3ubEXT");
4378
4379        if (extproc == NULL) {
4380                _ASSERT(0);
4381                return;
4382        }
4383
4384        glSecondaryColor3ubEXT = extproc;
4385
4386        glSecondaryColor3ubEXT(red, green, blue);
4387}
4388
4389static void APIENTRY InitSecondaryColor3ubvEXT (const GLubyte *v)
4390{
4391        void *extproc;
4392
4393        extproc = (void *) wglGetProcAddress("glSecondaryColor3ubvEXT");
4394
4395        if (extproc == NULL) {
4396                _ASSERT(0);
4397                return;
4398        }
4399
4400        glSecondaryColor3ubvEXT = extproc;
4401
4402        glSecondaryColor3ubvEXT(v);
4403}
4404
4405static void APIENTRY InitSecondaryColor3uiEXT (GLuint red, GLuint green, GLuint blue)
4406{
4407        void *extproc;
4408
4409        extproc = (void *) wglGetProcAddress("glSecondaryColor3uiEXT");
4410
4411        if (extproc == NULL) {
4412                _ASSERT(0);
4413                return;
4414        }
4415
4416        glSecondaryColor3uiEXT = extproc;
4417
4418        glSecondaryColor3uiEXT(red, green, blue);
4419}
4420
4421static void APIENTRY InitSecondaryColor3uivEXT (const GLuint *v)
4422{
4423        void *extproc;
4424
4425        extproc = (void *) wglGetProcAddress("glSecondaryColor3uivEXT");
4426
4427        if (extproc == NULL) {
4428                _ASSERT(0);
4429                return;
4430        }
4431
4432        glSecondaryColor3uivEXT = extproc;
4433
4434        glSecondaryColor3uivEXT(v);
4435}
4436
4437static void APIENTRY InitSecondaryColor3usEXT (GLushort red, GLushort green, GLushort blue)
4438{
4439        void *extproc;
4440
4441        extproc = (void *) wglGetProcAddress("glSecondaryColor3usEXT");
4442
4443        if (extproc == NULL) {
4444                _ASSERT(0);
4445                return;
4446        }
4447
4448        glSecondaryColor3usEXT = extproc;
4449
4450        glSecondaryColor3usEXT(red, green, blue);
4451}
4452
4453static void APIENTRY InitSecondaryColor3usvEXT (const GLushort *v)
4454{
4455        void *extproc;
4456
4457        extproc = (void *) wglGetProcAddress("glSecondaryColor3usvEXT");
4458
4459        if (extproc == NULL) {
4460                _ASSERT(0);
4461                return;
4462        }
4463
4464        glSecondaryColor3usvEXT = extproc;
4465
4466        glSecondaryColor3usvEXT(v);
4467}
4468
4469static void APIENTRY InitSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
4470{
4471        void *extproc;
4472
4473        extproc = (void *) wglGetProcAddress("glSecondaryColorPointerEXT");
4474
4475        if (extproc == NULL) {
4476                _ASSERT(0);
4477                return;
4478        }
4479
4480        glSecondaryColorPointerEXT = extproc;
4481
4482        glSecondaryColorPointerEXT(size, type, stride, pointer);
4483}
4484
4485static void APIENTRY InitTextureNormalEXT (GLenum mode)
4486{
4487        void *extproc;
4488
4489        extproc = (void *) wglGetProcAddress("glTextureNormalEXT");
4490
4491        if (extproc == NULL) {
4492                _ASSERT(0);
4493                return;
4494        }
4495
4496        glTextureNormalEXT = extproc;
4497
4498        glTextureNormalEXT(mode);
4499}
4500
4501static void APIENTRY InitMultiDrawArraysEXT (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)
4502{
4503        void *extproc;
4504
4505        extproc = (void *) wglGetProcAddress("glMultiDrawArraysEXT");
4506
4507        if (extproc == NULL) {
4508                _ASSERT(0);
4509                return;
4510        }
4511
4512        glMultiDrawArraysEXT = extproc;
4513
4514        glMultiDrawArraysEXT(mode, first, count, primcount);
4515}
4516
4517static void APIENTRY InitMultiDrawElementsEXT (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount)
4518{
4519        void *extproc;
4520
4521        extproc = (void *) wglGetProcAddress("glMultiDrawElementsEXT");
4522
4523        if (extproc == NULL) {
4524                _ASSERT(0);
4525                return;
4526        }
4527
4528        glMultiDrawElementsEXT = extproc;
4529
4530        glMultiDrawElementsEXT(mode, count, type, indices, primcount);
4531}
4532
4533static void APIENTRY InitFogCoordfEXT (GLfloat coord)
4534{
4535        void *extproc;
4536
4537        extproc = (void *) wglGetProcAddress("glFogCoordfEXT");
4538
4539        if (extproc == NULL) {
4540                _ASSERT(0);
4541                return;
4542        }
4543
4544        glFogCoordfEXT = extproc;
4545
4546        glFogCoordfEXT(coord);
4547}
4548
4549static void APIENTRY InitFogCoordfvEXT (const GLfloat *coord)
4550{
4551        void *extproc;
4552
4553        extproc = (void *) wglGetProcAddress("glFogCoordfvEXT");
4554
4555        if (extproc == NULL) {
4556                _ASSERT(0);
4557                return;
4558        }
4559
4560        glFogCoordfvEXT = extproc;
4561
4562        glFogCoordfvEXT(coord);
4563}
4564
4565static void APIENTRY InitFogCoorddEXT (GLdouble coord)
4566{
4567        void *extproc;
4568
4569        extproc = (void *) wglGetProcAddress("glFogCoorddEXT");
4570
4571        if (extproc == NULL) {
4572                _ASSERT(0);
4573                return;
4574        }
4575
4576        glFogCoorddEXT = extproc;
4577
4578        glFogCoorddEXT(coord);
4579}
4580
4581static void APIENTRY InitFogCoorddvEXT (const GLdouble *coord)
4582{
4583        void *extproc;
4584
4585        extproc = (void *) wglGetProcAddress("glFogCoorddvEXT");
4586
4587        if (extproc == NULL) {
4588                _ASSERT(0);
4589                return;
4590        }
4591
4592        glFogCoorddvEXT = extproc;
4593
4594        glFogCoorddvEXT(coord);
4595}
4596
4597static void APIENTRY InitFogCoordPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer)
4598{
4599        void *extproc;
4600
4601        extproc = (void *) wglGetProcAddress("glFogCoordPointerEXT");
4602
4603        if (extproc == NULL) {
4604                _ASSERT(0);
4605                return;
4606        }
4607
4608        glFogCoordPointerEXT = extproc;
4609
4610        glFogCoordPointerEXT(type, stride, pointer);
4611}
4612
4613static void APIENTRY InitTangent3bEXT (GLbyte tx, GLbyte ty, GLbyte tz)
4614{
4615        void *extproc;
4616
4617        extproc = (void *) wglGetProcAddress("glTangent3bEXT");
4618
4619        if (extproc == NULL) {
4620                _ASSERT(0);
4621                return;
4622        }
4623
4624        glTangent3bEXT = extproc;
4625
4626        glTangent3bEXT(tx, ty, tz);
4627}
4628
4629static void APIENTRY InitTangent3bvEXT (const GLbyte *v)
4630{
4631        void *extproc;
4632
4633        extproc = (void *) wglGetProcAddress("glTangent3bvEXT");
4634
4635        if (extproc == NULL) {
4636                _ASSERT(0);
4637                return;
4638        }
4639
4640        glTangent3bvEXT = extproc;
4641
4642        glTangent3bvEXT(v);
4643}
4644
4645static void APIENTRY InitTangent3dEXT (GLdouble tx, GLdouble ty, GLdouble tz)
4646{
4647        void *extproc;
4648
4649        extproc = (void *) wglGetProcAddress("glTangent3dEXT");
4650
4651        if (extproc == NULL) {
4652                _ASSERT(0);
4653                return;
4654        }
4655
4656        glTangent3dEXT = extproc;
4657
4658        glTangent3dEXT(tx, ty, tz);
4659}
4660
4661static void APIENTRY InitTangent3dvEXT (const GLdouble *v)
4662{
4663        void *extproc;
4664
4665        extproc = (void *) wglGetProcAddress("glTangent3dvEXT");
4666
4667        if (extproc == NULL) {
4668                _ASSERT(0);
4669                return;
4670        }
4671
4672        glTangent3dvEXT = extproc;
4673
4674        glTangent3dvEXT(v);
4675}
4676
4677static void APIENTRY InitTangent3fEXT (GLfloat tx, GLfloat ty, GLfloat tz)
4678{
4679        void *extproc;
4680
4681        extproc = (void *) wglGetProcAddress("glTangent3fEXT");
4682
4683        if (extproc == NULL) {
4684                _ASSERT(0);
4685                return;
4686        }
4687
4688        glTangent3fEXT = extproc;
4689
4690        glTangent3fEXT(tx, ty, tz);
4691}
4692
4693static void APIENTRY InitTangent3fvEXT (const GLfloat *v)
4694{
4695        void *extproc;
4696
4697        extproc = (void *) wglGetProcAddress("glTangent3fvEXT");
4698
4699        if (extproc == NULL) {
4700                _ASSERT(0);
4701                return;
4702        }
4703
4704        glTangent3fvEXT = extproc;
4705
4706        glTangent3fvEXT(v);
4707}
4708
4709static void APIENTRY InitTangent3iEXT (GLint tx, GLint ty, GLint tz)
4710{
4711        void *extproc;
4712
4713        extproc = (void *) wglGetProcAddress("glTangent3iEXT");
4714
4715        if (extproc == NULL) {
4716                _ASSERT(0);
4717                return;
4718        }
4719
4720        glTangent3iEXT = extproc;
4721
4722        glTangent3iEXT(tx, ty, tz);
4723}
4724
4725static void APIENTRY InitTangent3ivEXT (const GLint *v)
4726{
4727        void *extproc;
4728
4729        extproc = (void *) wglGetProcAddress("glTangent3ivEXT");
4730
4731        if (extproc == NULL) {
4732                _ASSERT(0);
4733                return;
4734        }
4735
4736        glTangent3ivEXT = extproc;
4737
4738        glTangent3ivEXT(v);
4739}
4740
4741static void APIENTRY InitTangent3sEXT (GLshort tx, GLshort ty, GLshort tz)
4742{
4743        void *extproc;
4744
4745        extproc = (void *) wglGetProcAddress("glTangent3sEXT");
4746
4747        if (extproc == NULL) {
4748                _ASSERT(0);
4749                return;
4750        }
4751
4752        glTangent3sEXT = extproc;
4753
4754        glTangent3sEXT(tx, ty, tz);
4755}
4756
4757static void APIENTRY InitTangent3svEXT (const GLshort *v)
4758{
4759        void *extproc;
4760
4761        extproc = (void *) wglGetProcAddress("glTangent3svEXT");
4762
4763        if (extproc == NULL) {
4764                _ASSERT(0);
4765                return;
4766        }
4767
4768        glTangent3svEXT = extproc;
4769
4770        glTangent3svEXT(v);
4771}
4772
4773static void APIENTRY InitBinormal3bEXT (GLbyte bx, GLbyte by, GLbyte bz)
4774{
4775        void *extproc;
4776
4777        extproc = (void *) wglGetProcAddress("glBinormal3bEXT");
4778
4779        if (extproc == NULL) {
4780                _ASSERT(0);
4781                return;
4782        }
4783
4784        glBinormal3bEXT = extproc;
4785
4786        glBinormal3bEXT(bx, by, bz);
4787}
4788
4789static void APIENTRY InitBinormal3bvEXT (const GLbyte *v)
4790{
4791        void *extproc;
4792
4793        extproc = (void *) wglGetProcAddress("glBinormal3bvEXT");
4794
4795        if (extproc == NULL) {
4796                _ASSERT(0);
4797                return;
4798        }
4799
4800        glBinormal3bvEXT = extproc;
4801
4802        glBinormal3bvEXT(v);
4803}
4804
4805static void APIENTRY InitBinormal3dEXT (GLdouble bx, GLdouble by, GLdouble bz)
4806{
4807        void *extproc;
4808
4809        extproc = (void *) wglGetProcAddress("glBinormal3dEXT");
4810
4811        if (extproc == NULL) {
4812                _ASSERT(0);
4813                return;
4814        }
4815
4816        glBinormal3dEXT = extproc;
4817
4818        glBinormal3dEXT(bx, by, bz);
4819}
4820
4821static void APIENTRY InitBinormal3dvEXT (const GLdouble *v)
4822{
4823        void *extproc;
4824
4825        extproc = (void *) wglGetProcAddress("glBinormal3dvEXT");
4826
4827        if (extproc == NULL) {
4828                _ASSERT(0);
4829                return;
4830        }
4831
4832        glBinormal3dvEXT = extproc;
4833
4834        glBinormal3dvEXT(v);
4835}
4836
4837static void APIENTRY InitBinormal3fEXT (GLfloat bx, GLfloat by, GLfloat bz)
4838{
4839        void *extproc;
4840
4841        extproc = (void *) wglGetProcAddress("glBinormal3fEXT");
4842
4843        if (extproc == NULL) {
4844                _ASSERT(0);
4845                return;
4846        }
4847
4848        glBinormal3fEXT = extproc;
4849
4850        glBinormal3fEXT(bx, by, bz);
4851}
4852
4853static void APIENTRY InitBinormal3fvEXT (const GLfloat *v)
4854{
4855        void *extproc;
4856
4857        extproc = (void *) wglGetProcAddress("glBinormal3fvEXT");
4858
4859        if (extproc == NULL) {
4860                _ASSERT(0);
4861                return;
4862        }
4863
4864        glBinormal3fvEXT = extproc;
4865
4866        glBinormal3fvEXT(v);
4867}
4868
4869static void APIENTRY InitBinormal3iEXT (GLint bx, GLint by, GLint bz)
4870{
4871        void *extproc;
4872
4873        extproc = (void *) wglGetProcAddress("glBinormal3iEXT");
4874
4875        if (extproc == NULL) {
4876                _ASSERT(0);
4877                return;
4878        }
4879
4880        glBinormal3iEXT = extproc;
4881
4882        glBinormal3iEXT(bx, by, bz);
4883}
4884
4885static void APIENTRY InitBinormal3ivEXT (const GLint *v)
4886{
4887        void *extproc;
4888
4889        extproc = (void *) wglGetProcAddress("glBinormal3ivEXT");
4890
4891        if (extproc == NULL) {
4892                _ASSERT(0);
4893                return;
4894        }
4895
4896        glBinormal3ivEXT = extproc;
4897
4898        glBinormal3ivEXT(v);
4899}
4900
4901static void APIENTRY InitBinormal3sEXT (GLshort bx, GLshort by, GLshort bz)
4902{
4903        void *extproc;
4904
4905        extproc = (void *) wglGetProcAddress("glBinormal3sEXT");
4906
4907        if (extproc == NULL) {
4908                _ASSERT(0);
4909                return;
4910        }
4911
4912        glBinormal3sEXT = extproc;
4913
4914        glBinormal3sEXT(bx, by, bz);
4915}
4916
4917static void APIENTRY InitBinormal3svEXT (const GLshort *v)
4918{
4919        void *extproc;
4920
4921        extproc = (void *) wglGetProcAddress("glBinormal3svEXT");
4922
4923        if (extproc == NULL) {
4924                _ASSERT(0);
4925                return;
4926        }
4927
4928        glBinormal3svEXT = extproc;
4929
4930        glBinormal3svEXT(v);
4931}
4932
4933static void APIENTRY InitTangentPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer)
4934{
4935        void *extproc;
4936
4937        extproc = (void *) wglGetProcAddress("glTangentPointerEXT");
4938
4939        if (extproc == NULL) {
4940                _ASSERT(0);
4941                return;
4942        }
4943
4944        glTangentPointerEXT = extproc;
4945
4946        glTangentPointerEXT(type, stride, pointer);
4947}
4948
4949static void APIENTRY InitBinormalPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer)
4950{
4951        void *extproc;
4952
4953        extproc = (void *) wglGetProcAddress("glBinormalPointerEXT");
4954
4955        if (extproc == NULL) {
4956                _ASSERT(0);
4957                return;
4958        }
4959
4960        glBinormalPointerEXT = extproc;
4961
4962        glBinormalPointerEXT(type, stride, pointer);
4963}
4964
4965static void APIENTRY InitFinishTextureSUNX (void)
4966{
4967        void *extproc;
4968
4969        extproc = (void *) wglGetProcAddress("glFinishTextureSUNX");
4970
4971        if (extproc == NULL) {
4972                _ASSERT(0);
4973                return;
4974        }
4975
4976        glFinishTextureSUNX = extproc;
4977
4978        glFinishTextureSUNX();
4979}
4980
4981static void APIENTRY InitGlobalAlphaFactorbSUN (GLbyte factor)
4982{
4983        void *extproc;
4984
4985        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactorbSUN");
4986
4987        if (extproc == NULL) {
4988                _ASSERT(0);
4989                return;
4990        }
4991
4992        glGlobalAlphaFactorbSUN = extproc;
4993
4994        glGlobalAlphaFactorbSUN(factor);
4995}
4996
4997static void APIENTRY InitGlobalAlphaFactorsSUN (GLshort factor)
4998{
4999        void *extproc;
5000
5001        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactorsSUN");
5002
5003        if (extproc == NULL) {
5004                _ASSERT(0);
5005                return;
5006        }
5007
5008        glGlobalAlphaFactorsSUN = extproc;
5009
5010        glGlobalAlphaFactorsSUN(factor);
5011}
5012
5013static void APIENTRY InitGlobalAlphaFactoriSUN (GLint factor)
5014{
5015        void *extproc;
5016
5017        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactoriSUN");
5018
5019        if (extproc == NULL) {
5020                _ASSERT(0);
5021                return;
5022        }
5023
5024        glGlobalAlphaFactoriSUN = extproc;
5025
5026        glGlobalAlphaFactoriSUN(factor);
5027}
5028
5029static void APIENTRY InitGlobalAlphaFactorfSUN (GLfloat factor)
5030{
5031        void *extproc;
5032
5033        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactorfSUN");
5034
5035        if (extproc == NULL) {
5036                _ASSERT(0);
5037                return;
5038        }
5039
5040        glGlobalAlphaFactorfSUN = extproc;
5041
5042        glGlobalAlphaFactorfSUN(factor);
5043}
5044
5045static void APIENTRY InitGlobalAlphaFactordSUN (GLdouble factor)
5046{
5047        void *extproc;
5048
5049        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactordSUN");
5050
5051        if (extproc == NULL) {
5052                _ASSERT(0);
5053                return;
5054        }
5055
5056        glGlobalAlphaFactordSUN = extproc;
5057
5058        glGlobalAlphaFactordSUN(factor);
5059}
5060
5061static void APIENTRY InitGlobalAlphaFactorubSUN (GLubyte factor)
5062{
5063        void *extproc;
5064
5065        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactorubSUN");
5066
5067        if (extproc == NULL) {
5068                _ASSERT(0);
5069                return;
5070        }
5071
5072        glGlobalAlphaFactorubSUN = extproc;
5073
5074        glGlobalAlphaFactorubSUN(factor);
5075}
5076
5077static void APIENTRY InitGlobalAlphaFactorusSUN (GLushort factor)
5078{
5079        void *extproc;
5080
5081        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactorusSUN");
5082
5083        if (extproc == NULL) {
5084                _ASSERT(0);
5085                return;
5086        }
5087
5088        glGlobalAlphaFactorusSUN = extproc;
5089
5090        glGlobalAlphaFactorusSUN(factor);
5091}
5092
5093static void APIENTRY InitGlobalAlphaFactoruiSUN (GLuint factor)
5094{
5095        void *extproc;
5096
5097        extproc = (void *) wglGetProcAddress("glGlobalAlphaFactoruiSUN");
5098
5099        if (extproc == NULL) {
5100                _ASSERT(0);
5101                return;
5102        }
5103
5104        glGlobalAlphaFactoruiSUN = extproc;
5105
5106        glGlobalAlphaFactoruiSUN(factor);
5107}
5108
5109static void APIENTRY InitReplacementCodeuiSUN (GLuint code)
5110{
5111        void *extproc;
5112
5113        extproc = (void *) wglGetProcAddress("glReplacementCodeuiSUN");
5114
5115        if (extproc == NULL) {
5116                _ASSERT(0);
5117                return;
5118        }
5119
5120        glReplacementCodeuiSUN = extproc;
5121
5122        glReplacementCodeuiSUN(code);
5123}
5124
5125static void APIENTRY InitReplacementCodeusSUN (GLushort code)
5126{
5127        void *extproc;
5128
5129        extproc = (void *) wglGetProcAddress("glReplacementCodeusSUN");
5130
5131        if (extproc == NULL) {
5132                _ASSERT(0);
5133                return;
5134        }
5135
5136        glReplacementCodeusSUN = extproc;
5137
5138        glReplacementCodeusSUN(code);
5139}
5140
5141static void APIENTRY InitReplacementCodeubSUN (GLubyte code)
5142{
5143        void *extproc;
5144
5145        extproc = (void *) wglGetProcAddress("glReplacementCodeubSUN");
5146
5147        if (extproc == NULL) {
5148                _ASSERT(0);
5149                return;
5150        }
5151
5152        glReplacementCodeubSUN = extproc;
5153
5154        glReplacementCodeubSUN(code);
5155}
5156
5157static void APIENTRY InitReplacementCodeuivSUN (const GLuint *code)
5158{
5159        void *extproc;
5160
5161        extproc = (void *) wglGetProcAddress("glReplacementCodeuivSUN");
5162
5163        if (extproc == NULL) {
5164                _ASSERT(0);
5165                return;
5166        }
5167
5168        glReplacementCodeuivSUN = extproc;
5169
5170        glReplacementCodeuivSUN(code);
5171}
5172
5173static void APIENTRY InitReplacementCodeusvSUN (const GLushort *code)
5174{
5175        void *extproc;
5176
5177        extproc = (void *) wglGetProcAddress("glReplacementCodeusvSUN");
5178
5179        if (extproc == NULL) {
5180                _ASSERT(0);
5181                return;
5182        }
5183
5184        glReplacementCodeusvSUN = extproc;
5185
5186        glReplacementCodeusvSUN(code);
5187}
5188
5189static void APIENTRY InitReplacementCodeubvSUN (const GLubyte *code)
5190{
5191        void *extproc;
5192
5193        extproc = (void *) wglGetProcAddress("glReplacementCodeubvSUN");
5194
5195        if (extproc == NULL) {
5196                _ASSERT(0);
5197                return;
5198        }
5199
5200        glReplacementCodeubvSUN = extproc;
5201
5202        glReplacementCodeubvSUN(code);
5203}
5204
5205static void APIENTRY InitReplacementCodePointerSUN (GLenum type, GLsizei stride, const GLvoid* *pointer)
5206{
5207        void *extproc;
5208
5209        extproc = (void *) wglGetProcAddress("glReplacementCodePointerSUN");
5210
5211        if (extproc == NULL) {
5212                _ASSERT(0);
5213                return;
5214        }
5215
5216        glReplacementCodePointerSUN = extproc;
5217
5218        glReplacementCodePointerSUN(type, stride, pointer);
5219}
5220
5221static void APIENTRY InitColor4ubVertex2fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)
5222{
5223        void *extproc;
5224
5225        extproc = (void *) wglGetProcAddress("glColor4ubVertex2fSUN");
5226
5227        if (extproc == NULL) {
5228                _ASSERT(0);
5229                return;
5230        }
5231
5232        glColor4ubVertex2fSUN = extproc;
5233
5234        glColor4ubVertex2fSUN(r, g, b, a, x, y);
5235}
5236
5237static void APIENTRY InitColor4ubVertex2fvSUN (const GLubyte *c, const GLfloat *v)
5238{
5239        void *extproc;
5240
5241        extproc = (void *) wglGetProcAddress("glColor4ubVertex2fvSUN");
5242
5243        if (extproc == NULL) {
5244                _ASSERT(0);
5245                return;
5246        }
5247
5248        glColor4ubVertex2fvSUN = extproc;
5249
5250        glColor4ubVertex2fvSUN(c, v);
5251}
5252
5253static void APIENTRY InitColor4ubVertex3fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
5254{
5255        void *extproc;
5256
5257        extproc = (void *) wglGetProcAddress("glColor4ubVertex3fSUN");
5258
5259        if (extproc == NULL) {
5260                _ASSERT(0);
5261                return;
5262        }
5263
5264        glColor4ubVertex3fSUN = extproc;
5265
5266        glColor4ubVertex3fSUN(r, g, b, a, x, y, z);
5267}
5268
5269static void APIENTRY InitColor4ubVertex3fvSUN (const GLubyte *c, const GLfloat *v)
5270{
5271        void *extproc;
5272
5273        extproc = (void *) wglGetProcAddress("glColor4ubVertex3fvSUN");
5274
5275        if (extproc == NULL) {
5276                _ASSERT(0);
5277                return;
5278        }
5279
5280        glColor4ubVertex3fvSUN = extproc;
5281
5282        glColor4ubVertex3fvSUN(c, v);
5283}
5284
5285static void APIENTRY InitColor3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
5286{
5287        void *extproc;
5288
5289        extproc = (void *) wglGetProcAddress("glColor3fVertex3fSUN");
5290
5291        if (extproc == NULL) {
5292                _ASSERT(0);
5293                return;
5294        }
5295
5296        glColor3fVertex3fSUN = extproc;
5297
5298        glColor3fVertex3fSUN(r, g, b, x, y, z);
5299}
5300
5301static void APIENTRY InitColor3fVertex3fvSUN (const GLfloat *c, const GLfloat *v)
5302{
5303        void *extproc;
5304
5305        extproc = (void *) wglGetProcAddress("glColor3fVertex3fvSUN");
5306
5307        if (extproc == NULL) {
5308                _ASSERT(0);
5309                return;
5310        }
5311
5312        glColor3fVertex3fvSUN = extproc;
5313
5314        glColor3fVertex3fvSUN(c, v);
5315}
5316
5317static void APIENTRY InitNormal3fVertex3fSUN (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5318{
5319        void *extproc;
5320
5321        extproc = (void *) wglGetProcAddress("glNormal3fVertex3fSUN");
5322
5323        if (extproc == NULL) {
5324                _ASSERT(0);
5325                return;
5326        }
5327
5328        glNormal3fVertex3fSUN = extproc;
5329
5330        glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);
5331}
5332
5333static void APIENTRY InitNormal3fVertex3fvSUN (const GLfloat *n, const GLfloat *v)
5334{
5335        void *extproc;
5336
5337        extproc = (void *) wglGetProcAddress("glNormal3fVertex3fvSUN");
5338
5339        if (extproc == NULL) {
5340                _ASSERT(0);
5341                return;
5342        }
5343
5344        glNormal3fVertex3fvSUN = extproc;
5345
5346        glNormal3fVertex3fvSUN(n, v);
5347}
5348
5349static void APIENTRY InitColor4fNormal3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5350{
5351        void *extproc;
5352
5353        extproc = (void *) wglGetProcAddress("glColor4fNormal3fVertex3fSUN");
5354
5355        if (extproc == NULL) {
5356                _ASSERT(0);
5357                return;
5358        }
5359
5360        glColor4fNormal3fVertex3fSUN = extproc;
5361
5362        glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
5363}
5364
5365static void APIENTRY InitColor4fNormal3fVertex3fvSUN (const GLfloat *c, const GLfloat *n, const GLfloat *v)
5366{
5367        void *extproc;
5368
5369        extproc = (void *) wglGetProcAddress("glColor4fNormal3fVertex3fvSUN");
5370
5371        if (extproc == NULL) {
5372                _ASSERT(0);
5373                return;
5374        }
5375
5376        glColor4fNormal3fVertex3fvSUN = extproc;
5377
5378        glColor4fNormal3fVertex3fvSUN(c, n, v);
5379}
5380
5381static void APIENTRY InitTexCoord2fVertex3fSUN (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
5382{
5383        void *extproc;
5384
5385        extproc = (void *) wglGetProcAddress("glTexCoord2fVertex3fSUN");
5386
5387        if (extproc == NULL) {
5388                _ASSERT(0);
5389                return;
5390        }
5391
5392        glTexCoord2fVertex3fSUN = extproc;
5393
5394        glTexCoord2fVertex3fSUN(s, t, x, y, z);
5395}
5396
5397static void APIENTRY InitTexCoord2fVertex3fvSUN (const GLfloat *tc, const GLfloat *v)
5398{
5399        void *extproc;
5400
5401        extproc = (void *) wglGetProcAddress("glTexCoord2fVertex3fvSUN");
5402
5403        if (extproc == NULL) {
5404                _ASSERT(0);
5405                return;
5406        }
5407
5408        glTexCoord2fVertex3fvSUN = extproc;
5409
5410        glTexCoord2fVertex3fvSUN(tc, v);
5411}
5412
5413static void APIENTRY InitTexCoord4fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5414{
5415        void *extproc;
5416
5417        extproc = (void *) wglGetProcAddress("glTexCoord4fVertex4fSUN");
5418
5419        if (extproc == NULL) {
5420                _ASSERT(0);
5421                return;
5422        }
5423
5424        glTexCoord4fVertex4fSUN = extproc;
5425
5426        glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
5427}
5428
5429static void APIENTRY InitTexCoord4fVertex4fvSUN (const GLfloat *tc, const GLfloat *v)
5430{
5431        void *extproc;
5432
5433        extproc = (void *) wglGetProcAddress("glTexCoord4fVertex4fvSUN");
5434
5435        if (extproc == NULL) {
5436                _ASSERT(0);
5437                return;
5438        }
5439
5440        glTexCoord4fVertex4fvSUN = extproc;
5441
5442        glTexCoord4fVertex4fvSUN(tc, v);
5443}
5444
5445static void APIENTRY InitTexCoord2fColor4ubVertex3fSUN (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
5446{
5447        void *extproc;
5448
5449        extproc = (void *) wglGetProcAddress("glTexCoord2fColor4ubVertex3fSUN");
5450
5451        if (extproc == NULL) {
5452                _ASSERT(0);
5453                return;
5454        }
5455
5456        glTexCoord2fColor4ubVertex3fSUN = extproc;
5457
5458        glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
5459}
5460
5461static void APIENTRY InitTexCoord2fColor4ubVertex3fvSUN (const GLfloat *tc, const GLubyte *c, const GLfloat *v)
5462{
5463        void *extproc;
5464
5465        extproc = (void *) wglGetProcAddress("glTexCoord2fColor4ubVertex3fvSUN");
5466
5467        if (extproc == NULL) {
5468                _ASSERT(0);
5469                return;
5470        }
5471
5472        glTexCoord2fColor4ubVertex3fvSUN = extproc;
5473
5474        glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);
5475}
5476
5477static void APIENTRY InitTexCoord2fColor3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
5478{
5479        void *extproc;
5480
5481        extproc = (void *) wglGetProcAddress("glTexCoord2fColor3fVertex3fSUN");
5482
5483        if (extproc == NULL) {
5484                _ASSERT(0);
5485                return;
5486        }
5487
5488        glTexCoord2fColor3fVertex3fSUN = extproc;
5489
5490        glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
5491}
5492
5493static void APIENTRY InitTexCoord2fColor3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *v)
5494{
5495        void *extproc;
5496
5497        extproc = (void *) wglGetProcAddress("glTexCoord2fColor3fVertex3fvSUN");
5498
5499        if (extproc == NULL) {
5500                _ASSERT(0);
5501                return;
5502        }
5503
5504        glTexCoord2fColor3fVertex3fvSUN = extproc;
5505
5506        glTexCoord2fColor3fVertex3fvSUN(tc, c, v);
5507}
5508
5509static void APIENTRY InitTexCoord2fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5510{
5511        void *extproc;
5512
5513        extproc = (void *) wglGetProcAddress("glTexCoord2fNormal3fVertex3fSUN");
5514
5515        if (extproc == NULL) {
5516                _ASSERT(0);
5517                return;
5518        }
5519
5520        glTexCoord2fNormal3fVertex3fSUN = extproc;
5521
5522        glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
5523}
5524
5525static void APIENTRY InitTexCoord2fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *n, const GLfloat *v)
5526{
5527        void *extproc;
5528
5529        extproc = (void *) wglGetProcAddress("glTexCoord2fNormal3fVertex3fvSUN");
5530
5531        if (extproc == NULL) {
5532                _ASSERT(0);
5533                return;
5534        }
5535
5536        glTexCoord2fNormal3fVertex3fvSUN = extproc;
5537
5538        glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);
5539}
5540
5541static void APIENTRY InitTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5542{
5543        void *extproc;
5544
5545        extproc = (void *) wglGetProcAddress("glTexCoord2fColor4fNormal3fVertex3fSUN");
5546
5547        if (extproc == NULL) {
5548                _ASSERT(0);
5549                return;
5550        }
5551
5552        glTexCoord2fColor4fNormal3fVertex3fSUN = extproc;
5553
5554        glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
5555}
5556
5557static void APIENTRY InitTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
5558{
5559        void *extproc;
5560
5561        extproc = (void *) wglGetProcAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN");
5562
5563        if (extproc == NULL) {
5564                _ASSERT(0);
5565                return;
5566        }
5567
5568        glTexCoord2fColor4fNormal3fVertex3fvSUN = extproc;
5569
5570        glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);
5571}
5572
5573static void APIENTRY InitTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5574{
5575        void *extproc;
5576
5577        extproc = (void *) wglGetProcAddress("glTexCoord4fColor4fNormal3fVertex4fSUN");
5578
5579        if (extproc == NULL) {
5580                _ASSERT(0);
5581                return;
5582        }
5583
5584        glTexCoord4fColor4fNormal3fVertex4fSUN = extproc;
5585
5586        glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
5587}
5588
5589static void APIENTRY InitTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
5590{
5591        void *extproc;
5592
5593        extproc = (void *) wglGetProcAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN");
5594
5595        if (extproc == NULL) {
5596                _ASSERT(0);
5597                return;
5598        }
5599
5600        glTexCoord4fColor4fNormal3fVertex4fvSUN = extproc;
5601
5602        glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);
5603}
5604
5605static void APIENTRY InitReplacementCodeuiVertex3fSUN (GLenum rc, GLfloat x, GLfloat y, GLfloat z)
5606{
5607        void *extproc;
5608
5609        extproc = (void *) wglGetProcAddress("glReplacementCodeuiVertex3fSUN");
5610
5611        if (extproc == NULL) {
5612                _ASSERT(0);
5613                return;
5614        }
5615
5616        glReplacementCodeuiVertex3fSUN = extproc;
5617
5618        glReplacementCodeuiVertex3fSUN(rc, x, y, z);
5619}
5620
5621static void APIENTRY InitReplacementCodeuiVertex3fvSUN (const GLenum *rc, const GLfloat *v)
5622{
5623        void *extproc;
5624
5625        extproc = (void *) wglGetProcAddress("glReplacementCodeuiVertex3fvSUN");
5626
5627        if (extproc == NULL) {
5628                _ASSERT(0);
5629                return;
5630        }
5631
5632        glReplacementCodeuiVertex3fvSUN = extproc;
5633
5634        glReplacementCodeuiVertex3fvSUN(rc, v);
5635}
5636
5637static void APIENTRY InitReplacementCodeuiColor4ubVertex3fSUN (GLenum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
5638{
5639        void *extproc;
5640
5641        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor4ubVertex3fSUN");
5642
5643        if (extproc == NULL) {
5644                _ASSERT(0);
5645                return;
5646        }
5647
5648        glReplacementCodeuiColor4ubVertex3fSUN = extproc;
5649
5650        glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
5651}
5652
5653static void APIENTRY InitReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *rc, const GLubyte *c, const GLfloat *v)
5654{
5655        void *extproc;
5656
5657        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor4ubVertex3fvSUN");
5658
5659        if (extproc == NULL) {
5660                _ASSERT(0);
5661                return;
5662        }
5663
5664        glReplacementCodeuiColor4ubVertex3fvSUN = extproc;
5665
5666        glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);
5667}
5668
5669static void APIENTRY InitReplacementCodeuiColor3fVertex3fSUN (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
5670{
5671        void *extproc;
5672
5673        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor3fVertex3fSUN");
5674
5675        if (extproc == NULL) {
5676                _ASSERT(0);
5677                return;
5678        }
5679
5680        glReplacementCodeuiColor3fVertex3fSUN = extproc;
5681
5682        glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
5683}
5684
5685static void APIENTRY InitReplacementCodeuiColor3fVertex3fvSUN (const GLenum *rc, const GLfloat *c, const GLfloat *v)
5686{
5687        void *extproc;
5688
5689        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor3fVertex3fvSUN");
5690
5691        if (extproc == NULL) {
5692                _ASSERT(0);
5693                return;
5694        }
5695
5696        glReplacementCodeuiColor3fVertex3fvSUN = extproc;
5697
5698        glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);
5699}
5700
5701static void APIENTRY InitReplacementCodeuiNormal3fVertex3fSUN (GLenum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5702{
5703        void *extproc;
5704
5705        extproc = (void *) wglGetProcAddress("glReplacementCodeuiNormal3fVertex3fSUN");
5706
5707        if (extproc == NULL) {
5708                _ASSERT(0);
5709                return;
5710        }
5711
5712        glReplacementCodeuiNormal3fVertex3fSUN = extproc;
5713
5714        glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
5715}
5716
5717static void APIENTRY InitReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *rc, const GLfloat *n, const GLfloat *v)
5718{
5719        void *extproc;
5720
5721        extproc = (void *) wglGetProcAddress("glReplacementCodeuiNormal3fVertex3fvSUN");
5722
5723        if (extproc == NULL) {
5724                _ASSERT(0);
5725                return;
5726        }
5727
5728        glReplacementCodeuiNormal3fVertex3fvSUN = extproc;
5729
5730        glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);
5731}
5732
5733static void APIENTRY InitReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5734{
5735        void *extproc;
5736
5737        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN");
5738
5739        if (extproc == NULL) {
5740                _ASSERT(0);
5741                return;
5742        }
5743
5744        glReplacementCodeuiColor4fNormal3fVertex3fSUN = extproc;
5745
5746        glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
5747}
5748
5749static void APIENTRY InitReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
5750{
5751        void *extproc;
5752
5753        extproc = (void *) wglGetProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN");
5754
5755        if (extproc == NULL) {
5756                _ASSERT(0);
5757                return;
5758        }
5759
5760        glReplacementCodeuiColor4fNormal3fVertex3fvSUN = extproc;
5761
5762        glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);
5763}
5764
5765static void APIENTRY InitReplacementCodeuiTexCoord2fVertex3fSUN (GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
5766{
5767        void *extproc;
5768
5769        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fVertex3fSUN");
5770
5771        if (extproc == NULL) {
5772                _ASSERT(0);
5773                return;
5774        }
5775
5776        glReplacementCodeuiTexCoord2fVertex3fSUN = extproc;
5777
5778        glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
5779}
5780
5781static void APIENTRY InitReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *rc, const GLfloat *tc, const GLfloat *v)
5782{
5783        void *extproc;
5784
5785        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN");
5786
5787        if (extproc == NULL) {
5788                _ASSERT(0);
5789                return;
5790        }
5791
5792        glReplacementCodeuiTexCoord2fVertex3fvSUN = extproc;
5793
5794        glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);
5795}
5796
5797static void APIENTRY InitReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5798{
5799        void *extproc;
5800
5801        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN");
5802
5803        if (extproc == NULL) {
5804                _ASSERT(0);
5805                return;
5806        }
5807
5808        glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = extproc;
5809
5810        glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
5811}
5812
5813static void APIENTRY InitReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v)
5814{
5815        void *extproc;
5816
5817        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN");
5818
5819        if (extproc == NULL) {
5820                _ASSERT(0);
5821                return;
5822        }
5823
5824        glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = extproc;
5825
5826        glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);
5827}
5828
5829static void APIENTRY InitReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
5830{
5831        void *extproc;
5832
5833        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN");
5834
5835        if (extproc == NULL) {
5836                _ASSERT(0);
5837                return;
5838        }
5839
5840        glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = extproc;
5841
5842        glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
5843}
5844
5845static void APIENTRY InitReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
5846{
5847        void *extproc;
5848
5849        extproc = (void *) wglGetProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN");
5850
5851        if (extproc == NULL) {
5852                _ASSERT(0);
5853                return;
5854        }
5855
5856        glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = extproc;
5857
5858        glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);
5859}
5860
5861static void APIENTRY InitBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5862{
5863        void *extproc;
5864
5865        extproc = (void *) wglGetProcAddress("glBlendFuncSeparateEXT");
5866
5867        if (extproc == NULL) {
5868                _ASSERT(0);
5869                return;
5870        }
5871
5872        glBlendFuncSeparateEXT = extproc;
5873
5874        glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
5875}
5876
5877static void APIENTRY InitBlendFuncSeparateINGR (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5878{
5879        void *extproc;
5880
5881        extproc = (void *) wglGetProcAddress("glBlendFuncSeparateINGR");
5882
5883        if (extproc == NULL) {
5884                _ASSERT(0);
5885                return;
5886        }
5887
5888        glBlendFuncSeparateINGR = extproc;
5889
5890        glBlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
5891}
5892
5893static void APIENTRY InitVertexWeightfEXT (GLfloat weight)
5894{
5895        void *extproc;
5896
5897        extproc = (void *) wglGetProcAddress("glVertexWeightfEXT");
5898
5899        if (extproc == NULL) {
5900                _ASSERT(0);
5901                return;
5902        }
5903
5904        glVertexWeightfEXT = extproc;
5905
5906        glVertexWeightfEXT(weight);
5907}
5908
5909static void APIENTRY InitVertexWeightfvEXT (const GLfloat *weight)
5910{
5911        void *extproc;
5912
5913        extproc = (void *) wglGetProcAddress("glVertexWeightfvEXT");
5914
5915        if (extproc == NULL) {
5916                _ASSERT(0);
5917                return;
5918        }
5919
5920        glVertexWeightfvEXT = extproc;
5921
5922        glVertexWeightfvEXT(weight);
5923}
5924
5925static void APIENTRY InitVertexWeightPointerEXT (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer)
5926{
5927        void *extproc;
5928
5929        extproc = (void *) wglGetProcAddress("glVertexWeightPointerEXT");
5930
5931        if (extproc == NULL) {
5932                _ASSERT(0);
5933                return;
5934        }
5935
5936        glVertexWeightPointerEXT = extproc;
5937
5938        glVertexWeightPointerEXT(size, type, stride, pointer);
5939}
5940
5941static void APIENTRY InitFlushVertexArrayRangeNV (void)
5942{
5943        void *extproc;
5944
5945        extproc = (void *) wglGetProcAddress("glFlushVertexArrayRangeNV");
5946
5947        if (extproc == NULL) {
5948                _ASSERT(0);
5949                return;
5950        }
5951
5952        glFlushVertexArrayRangeNV = extproc;
5953
5954        glFlushVertexArrayRangeNV();
5955}
5956
5957static void APIENTRY InitVertexArrayRangeNV (GLsizei length, const GLvoid *pointer)
5958{
5959        void *extproc;
5960
5961        extproc = (void *) wglGetProcAddress("glVertexArrayRangeNV");
5962
5963        if (extproc == NULL) {
5964                _ASSERT(0);
5965                return;
5966        }
5967
5968        glVertexArrayRangeNV = extproc;
5969
5970        glVertexArrayRangeNV(length, pointer);
5971}
5972
5973static void APIENTRY InitCombinerParameterfvNV (GLenum pname, const GLfloat *params)
5974{
5975        void *extproc;
5976
5977        extproc = (void *) wglGetProcAddress("glCombinerParameterfvNV");
5978
5979        if (extproc == NULL) {
5980                _ASSERT(0);
5981                return;
5982        }
5983
5984        glCombinerParameterfvNV = extproc;
5985
5986        glCombinerParameterfvNV(pname, params);
5987}
5988
5989static void APIENTRY InitCombinerParameterfNV (GLenum pname, GLfloat param)
5990{
5991        void *extproc;
5992
5993        extproc = (void *) wglGetProcAddress("glCombinerParameterfNV");
5994
5995        if (extproc == NULL) {
5996                _ASSERT(0);
5997                return;
5998        }
5999
6000        glCombinerParameterfNV = extproc;
6001
6002        glCombinerParameterfNV(pname, param);
6003}
6004
6005static void APIENTRY InitCombinerParameterivNV (GLenum pname, const GLint *params)
6006{
6007        void *extproc;
6008
6009        extproc = (void *) wglGetProcAddress("glCombinerParameterivNV");
6010
6011        if (extproc == NULL) {
6012                _ASSERT(0);
6013                return;
6014        }
6015
6016        glCombinerParameterivNV = extproc;
6017
6018        glCombinerParameterivNV(pname, params);
6019}
6020
6021static void APIENTRY InitCombinerParameteriNV (GLenum pname, GLint param)
6022{
6023        void *extproc;
6024
6025        extproc = (void *) wglGetProcAddress("glCombinerParameteriNV");
6026
6027        if (extproc == NULL) {
6028                _ASSERT(0);
6029                return;
6030        }
6031
6032        glCombinerParameteriNV = extproc;
6033
6034        glCombinerParameteriNV(pname, param);
6035}
6036
6037static void APIENTRY InitCombinerInputNV (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
6038{
6039        void *extproc;
6040
6041        extproc = (void *) wglGetProcAddress("glCombinerInputNV");
6042
6043        if (extproc == NULL) {
6044                _ASSERT(0);
6045                return;
6046        }
6047
6048        glCombinerInputNV = extproc;
6049
6050        glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
6051}
6052
6053static void APIENTRY InitCombinerOutputNV (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
6054{
6055        void *extproc;
6056
6057        extproc = (void *) wglGetProcAddress("glCombinerOutputNV");
6058
6059        if (extproc == NULL) {
6060                _ASSERT(0);
6061                return;
6062        }
6063
6064        glCombinerOutputNV = extproc;
6065
6066        glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
6067}
6068
6069static void APIENTRY InitFinalCombinerInputNV (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
6070{
6071        void *extproc;
6072
6073        extproc = (void *) wglGetProcAddress("glFinalCombinerInputNV");
6074
6075        if (extproc == NULL) {
6076                _ASSERT(0);
6077                return;
6078        }
6079
6080        glFinalCombinerInputNV = extproc;
6081
6082        glFinalCombinerInputNV(variable, input, mapping, componentUsage);
6083}
6084
6085static void APIENTRY InitGetCombinerInputParameterfvNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
6086{
6087        void *extproc;
6088
6089        extproc = (void *) wglGetProcAddress("glGetCombinerInputParameterfvNV");
6090
6091        if (extproc == NULL) {
6092                _ASSERT(0);
6093                return;
6094        }
6095
6096        glGetCombinerInputParameterfvNV = extproc;
6097
6098        glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);
6099}
6100
6101static void APIENTRY InitGetCombinerInputParameterivNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
6102{
6103        void *extproc;
6104
6105        extproc = (void *) wglGetProcAddress("glGetCombinerInputParameterivNV");
6106
6107        if (extproc == NULL) {
6108                _ASSERT(0);
6109                return;
6110        }
6111
6112        glGetCombinerInputParameterivNV = extproc;
6113
6114        glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);
6115}
6116
6117static void APIENTRY InitGetCombinerOutputParameterfvNV (GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
6118{
6119        void *extproc;
6120
6121        extproc = (void *) wglGetProcAddress("glGetCombinerOutputParameterfvNV");
6122
6123        if (extproc == NULL) {
6124                _ASSERT(0);
6125                return;
6126        }
6127
6128        glGetCombinerOutputParameterfvNV = extproc;
6129
6130        glGetCombinerOutputParameterfvNV(stage, portion, pname, params);
6131}
6132
6133static void APIENTRY InitGetCombinerOutputParameterivNV (GLenum stage, GLenum portion, GLenum pname, GLint *params)
6134{
6135        void *extproc;
6136
6137        extproc = (void *) wglGetProcAddress("glGetCombinerOutputParameterivNV");
6138
6139        if (extproc == NULL) {
6140                _ASSERT(0);
6141                return;
6142        }
6143
6144        glGetCombinerOutputParameterivNV = extproc;
6145
6146        glGetCombinerOutputParameterivNV(stage, portion, pname, params);
6147}
6148
6149static void APIENTRY InitGetFinalCombinerInputParameterfvNV (GLenum variable, GLenum pname, GLfloat *params)
6150{
6151        void *extproc;
6152
6153        extproc = (void *) wglGetProcAddress("glGetFinalCombinerInputParameterfvNV");
6154
6155        if (extproc == NULL) {
6156                _ASSERT(0);
6157                return;
6158        }
6159
6160        glGetFinalCombinerInputParameterfvNV = extproc;
6161
6162        glGetFinalCombinerInputParameterfvNV(variable, pname, params);
6163}
6164
6165static void APIENTRY InitGetFinalCombinerInputParameterivNV (GLenum variable, GLenum pname, GLint *params)
6166{
6167        void *extproc;
6168
6169        extproc = (void *) wglGetProcAddress("glGetFinalCombinerInputParameterivNV");
6170
6171        if (extproc == NULL) {
6172                _ASSERT(0);
6173                return;
6174        }
6175
6176        glGetFinalCombinerInputParameterivNV = extproc;
6177
6178        glGetFinalCombinerInputParameterivNV(variable, pname, params);
6179}
6180
6181static void APIENTRY InitResizeBuffersMESA (void)
6182{
6183        void *extproc;
6184
6185        extproc = (void *) wglGetProcAddress("glResizeBuffersMESA");
6186
6187        if (extproc == NULL) {
6188                _ASSERT(0);
6189                return;
6190        }
6191
6192        glResizeBuffersMESA = extproc;
6193
6194        glResizeBuffersMESA();
6195}
6196
6197static void APIENTRY InitWindowPos2dMESA (GLdouble x, GLdouble y)
6198{
6199        void *extproc;
6200
6201        extproc = (void *) wglGetProcAddress("glWindowPos2dMESA");
6202
6203        if (extproc == NULL) {
6204                _ASSERT(0);
6205                return;
6206        }
6207
6208        glWindowPos2dMESA = extproc;
6209
6210        glWindowPos2dMESA(x, y);
6211}
6212
6213static void APIENTRY InitWindowPos2dvMESA (const GLdouble *v)
6214{
6215        void *extproc;
6216
6217        extproc = (void *) wglGetProcAddress("glWindowPos2dvMESA");
6218
6219        if (extproc == NULL) {
6220                _ASSERT(0);
6221                return;
6222        }
6223
6224        glWindowPos2dvMESA = extproc;
6225
6226        glWindowPos2dvMESA(v);
6227}
6228
6229static void APIENTRY InitWindowPos2fMESA (GLfloat x, GLfloat y)
6230{
6231        void *extproc;
6232
6233        extproc = (void *) wglGetProcAddress("glWindowPos2fMESA");
6234
6235        if (extproc == NULL) {
6236                _ASSERT(0);
6237                return;
6238        }
6239
6240        glWindowPos2fMESA = extproc;
6241
6242        glWindowPos2fMESA(x, y);
6243}
6244
6245static void APIENTRY InitWindowPos2fvMESA (const GLfloat *v)
6246{
6247        void *extproc;
6248
6249        extproc = (void *) wglGetProcAddress("glWindowPos2fvMESA");
6250
6251        if (extproc == NULL) {
6252                _ASSERT(0);
6253                return;
6254        }
6255
6256        glWindowPos2fvMESA = extproc;
6257
6258        glWindowPos2fvMESA(v);
6259}
6260
6261static void APIENTRY InitWindowPos2iMESA (GLint x, GLint y)
6262{
6263        void *extproc;
6264
6265        extproc = (void *) wglGetProcAddress("glWindowPos2iMESA");
6266
6267        if (extproc == NULL) {
6268                _ASSERT(0);
6269                return;
6270        }
6271
6272        glWindowPos2iMESA = extproc;
6273
6274        glWindowPos2iMESA(x, y);
6275}
6276
6277static void APIENTRY InitWindowPos2ivMESA (const GLint *v)
6278{
6279        void *extproc;
6280
6281        extproc = (void *) wglGetProcAddress("glWindowPos2ivMESA");
6282
6283        if (extproc == NULL) {
6284                _ASSERT(0);
6285                return;
6286        }
6287
6288        glWindowPos2ivMESA = extproc;
6289
6290        glWindowPos2ivMESA(v);
6291}
6292
6293static void APIENTRY InitWindowPos2sMESA (GLshort x, GLshort y)
6294{
6295        void *extproc;
6296
6297        extproc = (void *) wglGetProcAddress("glWindowPos2sMESA");
6298
6299        if (extproc == NULL) {
6300                _ASSERT(0);
6301                return;
6302        }
6303
6304        glWindowPos2sMESA = extproc;
6305
6306        glWindowPos2sMESA(x, y);
6307}
6308
6309static void APIENTRY InitWindowPos2svMESA (const GLshort *v)
6310{
6311        void *extproc;
6312
6313        extproc = (void *) wglGetProcAddress("glWindowPos2svMESA");
6314
6315        if (extproc == NULL) {
6316                _ASSERT(0);
6317                return;
6318        }
6319
6320        glWindowPos2svMESA = extproc;
6321
6322        glWindowPos2svMESA(v);
6323}
6324
6325static void APIENTRY InitWindowPos3dMESA (GLdouble x, GLdouble y, GLdouble z)
6326{
6327        void *extproc;
6328
6329        extproc = (void *) wglGetProcAddress("glWindowPos3dMESA");
6330
6331        if (extproc == NULL) {
6332                _ASSERT(0);
6333                return;
6334        }
6335
6336        glWindowPos3dMESA = extproc;
6337
6338        glWindowPos3dMESA(x, y, z);
6339}
6340
6341static void APIENTRY InitWindowPos3dvMESA (const GLdouble *v)
6342{
6343        void *extproc;
6344
6345        extproc = (void *) wglGetProcAddress("glWindowPos3dvMESA");
6346
6347        if (extproc == NULL) {
6348                _ASSERT(0);
6349                return;
6350        }
6351
6352        glWindowPos3dvMESA = extproc;
6353
6354        glWindowPos3dvMESA(v);
6355}
6356
6357static void APIENTRY InitWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z)
6358{
6359        void *extproc;
6360
6361        extproc = (void *) wglGetProcAddress("glWindowPos3fMESA");
6362
6363        if (extproc == NULL) {
6364                _ASSERT(0);
6365                return;
6366        }
6367
6368        glWindowPos3fMESA = extproc;
6369
6370        glWindowPos3fMESA(x, y, z);
6371}
6372
6373static void APIENTRY InitWindowPos3fvMESA (const GLfloat *v)
6374{
6375        void *extproc;
6376
6377        extproc = (void *) wglGetProcAddress("glWindowPos3fvMESA");
6378
6379        if (extproc == NULL) {
6380                _ASSERT(0);
6381                return;
6382        }
6383
6384        glWindowPos3fvMESA = extproc;
6385
6386        glWindowPos3fvMESA(v);
6387}
6388
6389static void APIENTRY InitWindowPos3iMESA (GLint x, GLint y, GLint z)
6390{
6391        void *extproc;
6392
6393        extproc = (void *) wglGetProcAddress("glWindowPos3iMESA");
6394
6395        if (extproc == NULL) {
6396                _ASSERT(0);
6397                return;
6398        }
6399
6400        glWindowPos3iMESA = extproc;
6401
6402        glWindowPos3iMESA(x, y, z);
6403}
6404
6405static void APIENTRY InitWindowPos3ivMESA (const GLint *v)
6406{
6407        void *extproc;
6408
6409        extproc = (void *) wglGetProcAddress("glWindowPos3ivMESA");
6410
6411        if (extproc == NULL) {
6412                _ASSERT(0);
6413                return;
6414        }
6415
6416        glWindowPos3ivMESA = extproc;
6417
6418        glWindowPos3ivMESA(v);
6419}
6420
6421static void APIENTRY InitWindowPos3sMESA (GLshort x, GLshort y, GLshort z)
6422{
6423        void *extproc;
6424
6425        extproc = (void *) wglGetProcAddress("glWindowPos3sMESA");
6426
6427        if (extproc == NULL) {
6428                _ASSERT(0);
6429                return;
6430        }
6431
6432        glWindowPos3sMESA = extproc;
6433
6434        glWindowPos3sMESA(x, y, z);
6435}
6436
6437static void APIENTRY InitWindowPos3svMESA (const GLshort *v)
6438{
6439        void *extproc;
6440
6441        extproc = (void *) wglGetProcAddress("glWindowPos3svMESA");
6442
6443        if (extproc == NULL) {
6444                _ASSERT(0);
6445                return;
6446        }
6447
6448        glWindowPos3svMESA = extproc;
6449
6450        glWindowPos3svMESA(v);
6451}
6452
6453static void APIENTRY InitWindowPos4dMESA (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6454{
6455        void *extproc;
6456
6457        extproc = (void *) wglGetProcAddress("glWindowPos4dMESA");
6458
6459        if (extproc == NULL) {
6460                _ASSERT(0);
6461                return;
6462        }
6463
6464        glWindowPos4dMESA = extproc;
6465
6466        glWindowPos4dMESA(x, y, z, w);
6467}
6468
6469static void APIENTRY InitWindowPos4dvMESA (const GLdouble *v)
6470{
6471        void *extproc;
6472
6473        extproc = (void *) wglGetProcAddress("glWindowPos4dvMESA");
6474
6475        if (extproc == NULL) {
6476                _ASSERT(0);
6477                return;
6478        }
6479
6480        glWindowPos4dvMESA = extproc;
6481
6482        glWindowPos4dvMESA(v);
6483}
6484
6485static void APIENTRY InitWindowPos4fMESA (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6486{
6487        void *extproc;
6488
6489        extproc = (void *) wglGetProcAddress("glWindowPos4fMESA");
6490
6491        if (extproc == NULL) {
6492                _ASSERT(0);
6493                return;
6494        }
6495
6496        glWindowPos4fMESA = extproc;
6497
6498        glWindowPos4fMESA(x, y, z, w);
6499}
6500
6501static void APIENTRY InitWindowPos4fvMESA (const GLfloat *v)
6502{
6503        void *extproc;
6504
6505        extproc = (void *) wglGetProcAddress("glWindowPos4fvMESA");
6506
6507        if (extproc == NULL) {
6508                _ASSERT(0);
6509                return;
6510        }
6511
6512        glWindowPos4fvMESA = extproc;
6513
6514        glWindowPos4fvMESA(v);
6515}
6516
6517static void APIENTRY InitWindowPos4iMESA (GLint x, GLint y, GLint z, GLint w)
6518{
6519        void *extproc;
6520
6521        extproc = (void *) wglGetProcAddress("glWindowPos4iMESA");
6522
6523        if (extproc == NULL) {
6524                _ASSERT(0);
6525                return;
6526        }
6527
6528        glWindowPos4iMESA = extproc;
6529
6530        glWindowPos4iMESA(x, y, z, w);
6531}
6532
6533static void APIENTRY InitWindowPos4ivMESA (const GLint *v)
6534{
6535        void *extproc;
6536
6537        extproc = (void *) wglGetProcAddress("glWindowPos4ivMESA");
6538
6539        if (extproc == NULL) {
6540                _ASSERT(0);
6541                return;
6542        }
6543
6544        glWindowPos4ivMESA = extproc;
6545
6546        glWindowPos4ivMESA(v);
6547}
6548
6549static void APIENTRY InitWindowPos4sMESA (GLshort x, GLshort y, GLshort z, GLshort w)
6550{
6551        void *extproc;
6552
6553        extproc = (void *) wglGetProcAddress("glWindowPos4sMESA");
6554
6555        if (extproc == NULL) {
6556                _ASSERT(0);
6557                return;
6558        }
6559
6560        glWindowPos4sMESA = extproc;
6561
6562        glWindowPos4sMESA(x, y, z, w);
6563}
6564
6565static void APIENTRY InitWindowPos4svMESA (const GLshort *v)
6566{
6567        void *extproc;
6568
6569        extproc = (void *) wglGetProcAddress("glWindowPos4svMESA");
6570
6571        if (extproc == NULL) {
6572                _ASSERT(0);
6573                return;
6574        }
6575
6576        glWindowPos4svMESA = extproc;
6577
6578        glWindowPos4svMESA(v);
6579}
6580
6581static void APIENTRY InitMultiModeDrawArraysIBM (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride)
6582{
6583        void *extproc;
6584
6585        extproc = (void *) wglGetProcAddress("glMultiModeDrawArraysIBM");
6586
6587        if (extproc == NULL) {
6588                _ASSERT(0);
6589                return;
6590        }
6591
6592        glMultiModeDrawArraysIBM = extproc;
6593
6594        glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
6595}
6596
6597static void APIENTRY InitMultiModeDrawElementsIBM (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, GLint modestride)
6598{
6599        void *extproc;
6600
6601        extproc = (void *) wglGetProcAddress("glMultiModeDrawElementsIBM");
6602
6603        if (extproc == NULL) {
6604                _ASSERT(0);
6605                return;
6606        }
6607
6608        glMultiModeDrawElementsIBM = extproc;
6609
6610        glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);
6611}
6612
6613static void APIENTRY InitColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6614{
6615        void *extproc;
6616
6617        extproc = (void *) wglGetProcAddress("glColorPointerListIBM");
6618
6619        if (extproc == NULL) {
6620                _ASSERT(0);
6621                return;
6622        }
6623
6624        glColorPointerListIBM = extproc;
6625
6626        glColorPointerListIBM(size, type, stride, pointer, ptrstride);
6627}
6628
6629static void APIENTRY InitSecondaryColorPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6630{
6631        void *extproc;
6632
6633        extproc = (void *) wglGetProcAddress("glSecondaryColorPointerListIBM");
6634
6635        if (extproc == NULL) {
6636                _ASSERT(0);
6637                return;
6638        }
6639
6640        glSecondaryColorPointerListIBM = extproc;
6641
6642        glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);
6643}
6644
6645static void APIENTRY InitEdgeFlagPointerListIBM (GLint stride, const GLboolean* *pointer, GLint ptrstride)
6646{
6647        void *extproc;
6648
6649        extproc = (void *) wglGetProcAddress("glEdgeFlagPointerListIBM");
6650
6651        if (extproc == NULL) {
6652                _ASSERT(0);
6653                return;
6654        }
6655
6656        glEdgeFlagPointerListIBM = extproc;
6657
6658        glEdgeFlagPointerListIBM(stride, pointer, ptrstride);
6659}
6660
6661static void APIENTRY InitFogCoordPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6662{
6663        void *extproc;
6664
6665        extproc = (void *) wglGetProcAddress("glFogCoordPointerListIBM");
6666
6667        if (extproc == NULL) {
6668                _ASSERT(0);
6669                return;
6670        }
6671
6672        glFogCoordPointerListIBM = extproc;
6673
6674        glFogCoordPointerListIBM(type, stride, pointer, ptrstride);
6675}
6676
6677static void APIENTRY InitIndexPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6678{
6679        void *extproc;
6680
6681        extproc = (void *) wglGetProcAddress("glIndexPointerListIBM");
6682
6683        if (extproc == NULL) {
6684                _ASSERT(0);
6685                return;
6686        }
6687
6688        glIndexPointerListIBM = extproc;
6689
6690        glIndexPointerListIBM(type, stride, pointer, ptrstride);
6691}
6692
6693static void APIENTRY InitNormalPointerListIBM (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6694{
6695        void *extproc;
6696
6697        extproc = (void *) wglGetProcAddress("glNormalPointerListIBM");
6698
6699        if (extproc == NULL) {
6700                _ASSERT(0);
6701                return;
6702        }
6703
6704        glNormalPointerListIBM = extproc;
6705
6706        glNormalPointerListIBM(type, stride, pointer, ptrstride);
6707}
6708
6709static void APIENTRY InitTexCoordPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6710{
6711        void *extproc;
6712
6713        extproc = (void *) wglGetProcAddress("glTexCoordPointerListIBM");
6714
6715        if (extproc == NULL) {
6716                _ASSERT(0);
6717                return;
6718        }
6719
6720        glTexCoordPointerListIBM = extproc;
6721
6722        glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);
6723}
6724
6725static void APIENTRY InitVertexPointerListIBM (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride)
6726{
6727        void *extproc;
6728
6729        extproc = (void *) wglGetProcAddress("glVertexPointerListIBM");
6730
6731        if (extproc == NULL) {
6732                _ASSERT(0);
6733                return;
6734        }
6735
6736        glVertexPointerListIBM = extproc;
6737
6738        glVertexPointerListIBM(size, type, stride, pointer, ptrstride);
6739}
6740
6741static void APIENTRY InitTbufferMask3DFX (GLuint mask)
6742{
6743        void *extproc;
6744
6745        extproc = (void *) wglGetProcAddress("glTbufferMask3DFX");
6746
6747        if (extproc == NULL) {
6748                _ASSERT(0);
6749                return;
6750        }
6751
6752        glTbufferMask3DFX = extproc;
6753
6754        glTbufferMask3DFX(mask);
6755}
6756
6757static void APIENTRY InitSampleMaskEXT (GLclampf value, GLboolean invert)
6758{
6759        void *extproc;
6760
6761        extproc = (void *) wglGetProcAddress("glSampleMaskEXT");
6762
6763        if (extproc == NULL) {
6764                _ASSERT(0);
6765                return;
6766        }
6767
6768        glSampleMaskEXT = extproc;
6769
6770        glSampleMaskEXT(value, invert);
6771}
6772
6773static void APIENTRY InitSamplePatternEXT (GLenum pattern)
6774{
6775        void *extproc;
6776
6777        extproc = (void *) wglGetProcAddress("glSamplePatternEXT");
6778
6779        if (extproc == NULL) {
6780                _ASSERT(0);
6781                return;
6782        }
6783
6784        glSamplePatternEXT = extproc;
6785
6786        glSamplePatternEXT(pattern);
6787}
6788
6789static void APIENTRY InitTextureColorMaskSGIS (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
6790{
6791        void *extproc;
6792
6793        extproc = (void *) wglGetProcAddress("glTextureColorMaskSGIS");
6794
6795        if (extproc == NULL) {
6796                _ASSERT(0);
6797                return;
6798        }
6799
6800        glTextureColorMaskSGIS = extproc;
6801
6802        glTextureColorMaskSGIS(red, green, blue, alpha);
6803}
6804
6805static void APIENTRY InitIglooInterfaceSGIX (GLenum pname, const GLvoid *params)
6806{
6807        void *extproc;
6808
6809        extproc = (void *) wglGetProcAddress("glIglooInterfaceSGIX");
6810
6811        if (extproc == NULL) {
6812                _ASSERT(0);
6813                return;
6814        }
6815
6816        glIglooInterfaceSGIX = extproc;
6817
6818        glIglooInterfaceSGIX(pname, params);
6819}
6820
6821static void APIENTRY InitGenFencesNV (GLsizei n, GLuint *fences)
6822{
6823        void *extproc;
6824
6825        extproc = (void *) wglGetProcAddress("glGenFencesNV");
6826
6827        if (extproc == NULL) {
6828                _ASSERT(0);
6829                return;
6830        }
6831
6832        glGenFencesNV = extproc;
6833
6834        glGenFencesNV(n, fences);
6835}
6836
6837static void APIENTRY InitDeleteFencesNV (GLsizei n, const GLuint *fences)
6838{
6839        void *extproc;
6840
6841        extproc = (void *) wglGetProcAddress("glDeleteFencesNV");
6842
6843        if (extproc == NULL) {
6844                _ASSERT(0);
6845                return;
6846        }
6847
6848        glDeleteFencesNV = extproc;
6849
6850        glDeleteFencesNV(n, fences);
6851}
6852
6853static void APIENTRY InitSetFenceNV (GLuint fence, GLenum condition)
6854{
6855        void *extproc;
6856
6857        extproc = (void *) wglGetProcAddress("glSetFenceNV");
6858
6859        if (extproc == NULL) {
6860                _ASSERT(0);
6861                return;
6862        }
6863
6864        glSetFenceNV = extproc;
6865
6866        glSetFenceNV(fence, condition);
6867}
6868
6869static GLboolean APIENTRY InitTestFenceNV (GLuint fence)
6870{
6871        void *extproc;
6872
6873        extproc = (void *) wglGetProcAddress("glTestFenceNV");
6874
6875        if (extproc == NULL) {
6876                _ASSERT(0);
6877                return 0;
6878        }
6879
6880        glTestFenceNV = extproc;
6881
6882        return glTestFenceNV(fence);
6883}
6884
6885static void APIENTRY InitFinishFenceNV (GLuint fence)
6886{
6887        void *extproc;
6888
6889        extproc = (void *) wglGetProcAddress("glFinishFenceNV");
6890
6891        if (extproc == NULL) {
6892                _ASSERT(0);
6893                return;
6894        }
6895
6896        glFinishFenceNV = extproc;
6897
6898        glFinishFenceNV(fence);
6899}
6900
6901static GLboolean APIENTRY InitIsFenceNV (GLuint fence)
6902{
6903        void *extproc;
6904
6905        extproc = (void *) wglGetProcAddress("glIsFenceNV");
6906
6907        if (extproc == NULL) {
6908                _ASSERT(0);
6909                return 0;
6910        }
6911
6912        glIsFenceNV = extproc;
6913
6914        return glIsFenceNV(fence);
6915}
6916
6917static void APIENTRY InitGetFenceivNV (GLuint fence, GLenum pname, GLint *params)
6918{
6919        void *extproc;
6920
6921        extproc = (void *) wglGetProcAddress("glGetFenceivNV");
6922
6923        if (extproc == NULL) {
6924                _ASSERT(0);
6925                return;
6926        }
6927
6928        glGetFenceivNV = extproc;
6929
6930        glGetFenceivNV(fence, pname, params);
6931}
6932
6933static void APIENTRY InitMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points)
6934{
6935        void *extproc;
6936
6937        extproc = (void *) wglGetProcAddress("glMapControlPointsNV");
6938
6939        if (extproc == NULL) {
6940                _ASSERT(0);
6941                return;
6942        }
6943
6944        glMapControlPointsNV = extproc;
6945
6946        glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);
6947}
6948
6949static void APIENTRY InitMapParameterivNV (GLenum target, GLenum pname, const GLint *params)
6950{
6951        void *extproc;
6952
6953        extproc = (void *) wglGetProcAddress("glMapParameterivNV");
6954
6955        if (extproc == NULL) {
6956                _ASSERT(0);
6957                return;
6958        }
6959
6960        glMapParameterivNV = extproc;
6961
6962        glMapParameterivNV(target, pname, params);
6963}
6964
6965static void APIENTRY InitMapParameterfvNV (GLenum target, GLenum pname, const GLfloat *params)
6966{
6967        void *extproc;
6968
6969        extproc = (void *) wglGetProcAddress("glMapParameterfvNV");
6970
6971        if (extproc == NULL) {
6972                _ASSERT(0);
6973                return;
6974        }
6975
6976        glMapParameterfvNV = extproc;
6977
6978        glMapParameterfvNV(target, pname, params);
6979}
6980
6981static void APIENTRY InitGetMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points)
6982{
6983        void *extproc;
6984
6985        extproc = (void *) wglGetProcAddress("glGetMapControlPointsNV");
6986
6987        if (extproc == NULL) {
6988                _ASSERT(0);
6989                return;
6990        }
6991
6992        glGetMapControlPointsNV = extproc;
6993
6994        glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);
6995}
6996
6997static void APIENTRY InitGetMapParameterivNV (GLenum target, GLenum pname, GLint *params)
6998{
6999        void *extproc;
7000
7001        extproc = (void *) wglGetProcAddress("glGetMapParameterivNV");
7002
7003        if (extproc == NULL) {
7004                _ASSERT(0);
7005                return;
7006        }
7007
7008        glGetMapParameterivNV = extproc;
7009
7010        glGetMapParameterivNV(target, pname, params);
7011}
7012
7013static void APIENTRY InitGetMapParameterfvNV (GLenum target, GLenum pname, GLfloat *params)
7014{
7015        void *extproc;
7016
7017        extproc = (void *) wglGetProcAddress("glGetMapParameterfvNV");
7018
7019        if (extproc == NULL) {
7020                _ASSERT(0);
7021                return;
7022        }
7023
7024        glGetMapParameterfvNV = extproc;
7025
7026        glGetMapParameterfvNV(target, pname, params);
7027}
7028
7029static void APIENTRY InitGetMapAttribParameterivNV (GLenum target, GLuint index, GLenum pname, GLint *params)
7030{
7031        void *extproc;
7032
7033        extproc = (void *) wglGetProcAddress("glGetMapAttribParameterivNV");
7034
7035        if (extproc == NULL) {
7036                _ASSERT(0);
7037                return;
7038        }
7039
7040        glGetMapAttribParameterivNV = extproc;
7041
7042        glGetMapAttribParameterivNV(target, index, pname, params);
7043}
7044
7045static void APIENTRY InitGetMapAttribParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params)
7046{
7047        void *extproc;
7048
7049        extproc = (void *) wglGetProcAddress("glGetMapAttribParameterfvNV");
7050
7051        if (extproc == NULL) {
7052                _ASSERT(0);
7053                return;
7054        }
7055
7056        glGetMapAttribParameterfvNV = extproc;
7057
7058        glGetMapAttribParameterfvNV(target, index, pname, params);
7059}
7060
7061static void APIENTRY InitEvalMapsNV (GLenum target, GLenum mode)
7062{
7063        void *extproc;
7064
7065        extproc = (void *) wglGetProcAddress("glEvalMapsNV");
7066
7067        if (extproc == NULL) {
7068                _ASSERT(0);
7069                return;
7070        }
7071
7072        glEvalMapsNV = extproc;
7073
7074        glEvalMapsNV(target, mode);
7075}
7076
7077static void APIENTRY InitCombinerStageParameterfvNV (GLenum stage, GLenum pname, const GLfloat *params)
7078{
7079        void *extproc;
7080
7081        extproc = (void *) wglGetProcAddress("glCombinerStageParameterfvNV");
7082
7083        if (extproc == NULL) {
7084                _ASSERT(0);
7085                return;
7086        }
7087
7088        glCombinerStageParameterfvNV = extproc;
7089
7090        glCombinerStageParameterfvNV(stage, pname, params);
7091}
7092
7093static void APIENTRY InitGetCombinerStageParameterfvNV (GLenum stage, GLenum pname, GLfloat *params)
7094{
7095        void *extproc;
7096
7097        extproc = (void *) wglGetProcAddress("glGetCombinerStageParameterfvNV");
7098
7099        if (extproc == NULL) {
7100                _ASSERT(0);
7101                return;
7102        }
7103
7104        glGetCombinerStageParameterfvNV = extproc;
7105
7106        glGetCombinerStageParameterfvNV(stage, pname, params);
7107}
7108
7109static void APIENTRY InitBindProgramNV (GLenum target, GLuint id)
7110{
7111        void *extproc;
7112
7113        extproc = (void *) wglGetProcAddress("glBindProgramNV");
7114
7115        if (extproc == NULL) {
7116                _ASSERT(0);
7117                return;
7118        }
7119
7120        glBindProgramNV = extproc;
7121
7122        glBindProgramNV(target, id);
7123}
7124
7125static void APIENTRY InitDeleteProgramsNV (GLsizei n, const GLuint *ids)
7126{
7127        void *extproc;
7128
7129        extproc = (void *) wglGetProcAddress("glDeleteProgramsNV");
7130
7131        if (extproc == NULL) {
7132                _ASSERT(0);
7133                return;
7134        }
7135
7136        glDeleteProgramsNV = extproc;
7137
7138        glDeleteProgramsNV(n, ids);
7139}
7140
7141static void APIENTRY InitExecuteProgramNV (GLenum target, GLuint id, const GLfloat *params)
7142{
7143        void *extproc;
7144
7145        extproc = (void *) wglGetProcAddress("glExecuteProgramNV");
7146
7147        if (extproc == NULL) {
7148                _ASSERT(0);
7149                return;
7150        }
7151
7152        glExecuteProgramNV = extproc;
7153
7154        glExecuteProgramNV(target, id, params);
7155}
7156
7157static void APIENTRY InitGenProgramsNV (GLsizei n, GLuint *ids)
7158{
7159        void *extproc;
7160
7161        extproc = (void *) wglGetProcAddress("glGenProgramsNV");
7162
7163        if (extproc == NULL) {
7164                _ASSERT(0);
7165                return;
7166        }
7167
7168        glGenProgramsNV = extproc;
7169
7170        glGenProgramsNV(n, ids);
7171}
7172
7173static GLboolean APIENTRY InitAreProgramsResidentNV (GLsizei n, const GLuint *ids, GLboolean *residences)
7174{
7175        void *extproc;
7176
7177        extproc = (void *) wglGetProcAddress("glAreProgramsResidentNV");
7178
7179        if (extproc == NULL) {
7180                _ASSERT(0);
7181                return 0;
7182        }
7183
7184        glAreProgramsResidentNV = extproc;
7185
7186        return glAreProgramsResidentNV(n, ids, residences);
7187}
7188
7189static void APIENTRY InitRequestResidentProgramsNV (GLsizei n, const GLuint *ids)
7190{
7191        void *extproc;
7192
7193        extproc = (void *) wglGetProcAddress("glRequestResidentProgramsNV");
7194
7195        if (extproc == NULL) {
7196                _ASSERT(0);
7197                return;
7198        }
7199
7200        glRequestResidentProgramsNV = extproc;
7201
7202        glRequestResidentProgramsNV(n, ids);
7203}
7204
7205static void APIENTRY InitGetProgramParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params)
7206{
7207        void *extproc;
7208
7209        extproc = (void *) wglGetProcAddress("glGetProgramParameterfvNV");
7210
7211        if (extproc == NULL) {
7212                _ASSERT(0);
7213                return;
7214        }
7215
7216        glGetProgramParameterfvNV = extproc;
7217
7218        glGetProgramParameterfvNV(target, index, pname, params);
7219}
7220
7221static void APIENTRY InitGetProgramParameterdvNV (GLenum target, GLuint index, GLenum pname, GLdouble *params)
7222{
7223        void *extproc;
7224
7225        extproc = (void *) wglGetProcAddress("glGetProgramParameterdvNV");
7226
7227        if (extproc == NULL) {
7228                _ASSERT(0);
7229                return;
7230        }
7231
7232        glGetProgramParameterdvNV = extproc;
7233
7234        glGetProgramParameterdvNV(target, index, pname, params);
7235}
7236
7237static void APIENTRY InitGetProgramivNV (GLuint id, GLenum pname, GLint *params)
7238{
7239        void *extproc;
7240
7241        extproc = (void *) wglGetProcAddress("glGetProgramivNV");
7242
7243        if (extproc == NULL) {
7244                _ASSERT(0);
7245                return;
7246        }
7247
7248        glGetProgramivNV = extproc;
7249
7250        glGetProgramivNV(id, pname, params);
7251}
7252
7253static void APIENTRY InitGetProgramStringNV (GLuint id, GLenum pname, GLubyte *program)
7254{
7255        void *extproc;
7256
7257        extproc = (void *) wglGetProcAddress("glGetProgramStringNV");
7258
7259        if (extproc == NULL) {
7260                _ASSERT(0);
7261                return;
7262        }
7263
7264        glGetProgramStringNV = extproc;
7265
7266        glGetProgramStringNV(id, pname, program);
7267}
7268
7269static void APIENTRY InitGetTrackMatrixivNV (GLenum target, GLuint address, GLenum pname, GLint *params)
7270{
7271        void *extproc;
7272
7273        extproc = (void *) wglGetProcAddress("glGetTrackMatrixivNV");
7274
7275        if (extproc == NULL) {
7276                _ASSERT(0);
7277                return;
7278        }
7279
7280        glGetTrackMatrixivNV = extproc;
7281
7282        glGetTrackMatrixivNV(target, address, pname, params);
7283}
7284
7285static void APIENTRY InitGetVertexAttribdvNV (GLuint index, GLenum pname, GLdouble *params)
7286{
7287        void *extproc;
7288
7289        extproc = (void *) wglGetProcAddress("glGetVertexAttribdvNV");
7290
7291        if (extproc == NULL) {
7292                _ASSERT(0);
7293                return;
7294        }
7295
7296        glGetVertexAttribdvNV = extproc;
7297
7298        glGetVertexAttribdvNV(index, pname, params);
7299}
7300
7301static void APIENTRY InitGetVertexAttribfvNV (GLuint index, GLenum pname, GLfloat *params)
7302{
7303        void *extproc;
7304
7305        extproc = (void *) wglGetProcAddress("glGetVertexAttribfvNV");
7306
7307        if (extproc == NULL) {
7308                _ASSERT(0);
7309                return;
7310        }
7311
7312        glGetVertexAttribfvNV = extproc;
7313
7314        glGetVertexAttribfvNV(index, pname, params);
7315}
7316
7317static void APIENTRY InitGetVertexAttribivNV (GLuint index, GLenum pname, GLint *params)
7318{
7319        void *extproc;
7320
7321        extproc = (void *) wglGetProcAddress("glGetVertexAttribivNV");
7322
7323        if (extproc == NULL) {
7324                _ASSERT(0);
7325                return;
7326        }
7327
7328        glGetVertexAttribivNV = extproc;
7329
7330        glGetVertexAttribivNV(index, pname, params);
7331}
7332
7333static void APIENTRY InitGetVertexAttribPointervNV (GLuint index, GLenum pname, GLvoid* *pointer)
7334{
7335        void *extproc;
7336
7337        extproc = (void *) wglGetProcAddress("glGetVertexAttribPointervNV");
7338
7339        if (extproc == NULL) {
7340                _ASSERT(0);
7341                return;
7342        }
7343
7344        glGetVertexAttribPointervNV = extproc;
7345
7346        glGetVertexAttribPointervNV(index, pname, pointer);
7347}
7348
7349static GLboolean APIENTRY InitIsProgramNV (GLuint id)
7350{
7351        void *extproc;
7352
7353        extproc = (void *) wglGetProcAddress("glIsProgramNV");
7354
7355        if (extproc == NULL) {
7356                _ASSERT(0);
7357                return 0;
7358        }
7359
7360        glIsProgramNV = extproc;
7361
7362        return glIsProgramNV(id);
7363}
7364
7365static void APIENTRY InitLoadProgramNV (GLenum target, GLuint id, GLsizei len, const GLubyte *program)
7366{
7367        void *extproc;
7368
7369        extproc = (void *) wglGetProcAddress("glLoadProgramNV");
7370
7371        if (extproc == NULL) {
7372                _ASSERT(0);
7373                return;
7374        }
7375
7376        glLoadProgramNV = extproc;
7377
7378        glLoadProgramNV(target, id, len, program);
7379}
7380
7381static void APIENTRY InitProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7382{
7383        void *extproc;
7384
7385        extproc = (void *) wglGetProcAddress("glProgramParameter4fNV");
7386
7387        if (extproc == NULL) {
7388                _ASSERT(0);
7389                return;
7390        }
7391
7392        glProgramParameter4fNV = extproc;
7393
7394        glProgramParameter4fNV(target, index, x, y, z, w);
7395}
7396
7397static void APIENTRY InitProgramParameter4dNV (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7398{
7399        void *extproc;
7400
7401        extproc = (void *) wglGetProcAddress("glProgramParameter4dNV");
7402
7403        if (extproc == NULL) {
7404                _ASSERT(0);
7405                return;
7406        }
7407
7408        glProgramParameter4dNV = extproc;
7409
7410        glProgramParameter4dNV(target, index, x, y, z, w);
7411}
7412
7413static void APIENTRY InitProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble *params)
7414{
7415        void *extproc;
7416
7417        extproc = (void *) wglGetProcAddress("glProgramParameter4dvNV");
7418
7419        if (extproc == NULL) {
7420                _ASSERT(0);
7421                return;
7422        }
7423
7424        glProgramParameter4dvNV = extproc;
7425
7426        glProgramParameter4dvNV(target, index, params);
7427}
7428
7429static void APIENTRY InitProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat *params)
7430{
7431        void *extproc;
7432
7433        extproc = (void *) wglGetProcAddress("glProgramParameter4fvNV");
7434
7435        if (extproc == NULL) {
7436                _ASSERT(0);
7437                return;
7438        }
7439
7440        glProgramParameter4fvNV = extproc;
7441
7442        glProgramParameter4fvNV(target, index, params);
7443}
7444
7445static void APIENTRY InitProgramParameters4dvNV (GLenum target, GLuint index, GLuint num, const GLdouble *params)
7446{
7447        void *extproc;
7448
7449        extproc = (void *) wglGetProcAddress("glProgramParameters4dvNV");
7450
7451        if (extproc == NULL) {
7452                _ASSERT(0);
7453                return;
7454        }
7455
7456        glProgramParameters4dvNV = extproc;
7457
7458        glProgramParameters4dvNV(target, index, num, params);
7459}
7460
7461static void APIENTRY InitProgramParameters4fvNV (GLenum target, GLuint index, GLuint num, const GLfloat *params)
7462{
7463        void *extproc;
7464
7465        extproc = (void *) wglGetProcAddress("glProgramParameters4fvNV");
7466
7467        if (extproc == NULL) {
7468                _ASSERT(0);
7469                return;
7470        }
7471
7472        glProgramParameters4fvNV = extproc;
7473
7474        glProgramParameters4fvNV(target, index, num, params);
7475}
7476
7477static void APIENTRY InitTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform)
7478{
7479        void *extproc;
7480
7481        extproc = (void *) wglGetProcAddress("glTrackMatrixNV");
7482
7483        if (extproc == NULL) {
7484                _ASSERT(0);
7485                return;
7486        }
7487
7488        glTrackMatrixNV = extproc;
7489
7490        glTrackMatrixNV(target, address, matrix, transform);
7491}
7492
7493static void APIENTRY InitVertexAttribPointerNV (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
7494{
7495        void *extproc;
7496
7497        extproc = (void *) wglGetProcAddress("glVertexAttribPointerNV");
7498
7499        if (extproc == NULL) {
7500                _ASSERT(0);
7501                return;
7502        }
7503
7504        glVertexAttribPointerNV = extproc;
7505
7506        glVertexAttribPointerNV(index, size, type, stride, pointer);
7507}
7508
7509static void APIENTRY InitVertexAttrib1sNV (GLuint index, GLshort x)
7510{
7511        void *extproc;
7512
7513        extproc = (void *) wglGetProcAddress("glVertexAttrib1sNV");
7514
7515        if (extproc == NULL) {
7516                _ASSERT(0);
7517                return;
7518        }
7519
7520        glVertexAttrib1sNV = extproc;
7521
7522        glVertexAttrib1sNV(index, x);
7523}
7524
7525static void APIENTRY InitVertexAttrib1fNV (GLuint index, GLfloat x)
7526{
7527        void *extproc;
7528
7529        extproc = (void *) wglGetProcAddress("glVertexAttrib1fNV");
7530
7531        if (extproc == NULL) {
7532                _ASSERT(0);
7533                return;
7534        }
7535
7536        glVertexAttrib1fNV = extproc;
7537
7538        glVertexAttrib1fNV(index, x);
7539}
7540
7541static void APIENTRY InitVertexAttrib1dNV (GLuint index, GLdouble x)
7542{
7543        void *extproc;
7544
7545        extproc = (void *) wglGetProcAddress("glVertexAttrib1dNV");
7546
7547        if (extproc == NULL) {
7548                _ASSERT(0);
7549                return;
7550        }
7551
7552        glVertexAttrib1dNV = extproc;
7553
7554        glVertexAttrib1dNV(index, x);
7555}
7556
7557static void APIENTRY InitVertexAttrib2sNV (GLuint index, GLshort x, GLshort y)
7558{
7559        void *extproc;
7560
7561        extproc = (void *) wglGetProcAddress("glVertexAttrib2sNV");
7562
7563        if (extproc == NULL) {
7564                _ASSERT(0);
7565                return;
7566        }
7567
7568        glVertexAttrib2sNV = extproc;
7569
7570        glVertexAttrib2sNV(index, x, y);
7571}
7572
7573static void APIENTRY InitVertexAttrib2fNV (GLuint index, GLfloat x, GLfloat y)
7574{
7575        void *extproc;
7576
7577        extproc = (void *) wglGetProcAddress("glVertexAttrib2fNV");
7578
7579        if (extproc == NULL) {
7580                _ASSERT(0);
7581                return;
7582        }
7583
7584        glVertexAttrib2fNV = extproc;
7585
7586        glVertexAttrib2fNV(index, x, y);
7587}
7588
7589static void APIENTRY InitVertexAttrib2dNV (GLuint index, GLdouble x, GLdouble y)
7590{
7591        void *extproc;
7592
7593        extproc = (void *) wglGetProcAddress("glVertexAttrib2dNV");
7594
7595        if (extproc == NULL) {
7596                _ASSERT(0);
7597                return;
7598        }
7599
7600        glVertexAttrib2dNV = extproc;
7601
7602        glVertexAttrib2dNV(index, x, y);
7603}
7604
7605static void APIENTRY InitVertexAttrib3sNV (GLuint index, GLshort x, GLshort y, GLshort z)
7606{
7607        void *extproc;
7608
7609        extproc = (void *) wglGetProcAddress("glVertexAttrib3sNV");
7610
7611        if (extproc == NULL) {
7612                _ASSERT(0);
7613                return;
7614        }
7615
7616        glVertexAttrib3sNV = extproc;
7617
7618        glVertexAttrib3sNV(index, x, y, z);
7619}
7620
7621static void APIENTRY InitVertexAttrib3fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z)
7622{
7623        void *extproc;
7624
7625        extproc = (void *) wglGetProcAddress("glVertexAttrib3fNV");
7626
7627        if (extproc == NULL) {
7628                _ASSERT(0);
7629                return;
7630        }
7631
7632        glVertexAttrib3fNV = extproc;
7633
7634        glVertexAttrib3fNV(index, x, y, z);
7635}
7636
7637static void APIENTRY InitVertexAttrib3dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z)
7638{
7639        void *extproc;
7640
7641        extproc = (void *) wglGetProcAddress("glVertexAttrib3dNV");
7642
7643        if (extproc == NULL) {
7644                _ASSERT(0);
7645                return;
7646        }
7647
7648        glVertexAttrib3dNV = extproc;
7649
7650        glVertexAttrib3dNV(index, x, y, z);
7651}
7652
7653static void APIENTRY InitVertexAttrib4sNV (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
7654{
7655        void *extproc;
7656
7657        extproc = (void *) wglGetProcAddress("glVertexAttrib4sNV");
7658
7659        if (extproc == NULL) {
7660                _ASSERT(0);
7661                return;
7662        }
7663
7664        glVertexAttrib4sNV = extproc;
7665
7666        glVertexAttrib4sNV(index, x, y, z, w);
7667}
7668
7669static void APIENTRY InitVertexAttrib4fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
7670{
7671        void *extproc;
7672
7673        extproc = (void *) wglGetProcAddress("glVertexAttrib4fNV");
7674
7675        if (extproc == NULL) {
7676                _ASSERT(0);
7677                return;
7678        }
7679
7680        glVertexAttrib4fNV = extproc;
7681
7682        glVertexAttrib4fNV(index, x, y, z, w);
7683}
7684
7685static void APIENTRY InitVertexAttrib4dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
7686{
7687        void *extproc;
7688
7689        extproc = (void *) wglGetProcAddress("glVertexAttrib4dNV");
7690
7691        if (extproc == NULL) {
7692                _ASSERT(0);
7693                return;
7694        }
7695
7696        glVertexAttrib4dNV = extproc;
7697
7698        glVertexAttrib4dNV(index, x, y, z, w);
7699}
7700
7701static void APIENTRY InitVertexAttrib4ubNV (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
7702{
7703        void *extproc;
7704
7705        extproc = (void *) wglGetProcAddress("glVertexAttrib4ubNV");
7706
7707        if (extproc == NULL) {
7708                _ASSERT(0);
7709                return;
7710        }
7711
7712        glVertexAttrib4ubNV = extproc;
7713
7714        glVertexAttrib4ubNV(index, x, y, z, w);
7715}
7716
7717static void APIENTRY InitVertexAttrib1svNV (GLuint index, const GLshort *v)
7718{
7719        void *extproc;
7720
7721        extproc = (void *) wglGetProcAddress("glVertexAttrib1svNV");
7722
7723        if (extproc == NULL) {
7724                _ASSERT(0);
7725                return;
7726        }
7727
7728        glVertexAttrib1svNV = extproc;
7729
7730        glVertexAttrib1svNV(index, v);
7731}
7732
7733static void APIENTRY InitVertexAttrib1fvNV (GLuint index, const GLfloat *v)
7734{
7735        void *extproc;
7736
7737        extproc = (void *) wglGetProcAddress("glVertexAttrib1fvNV");
7738
7739        if (extproc == NULL) {
7740                _ASSERT(0);
7741                return;
7742        }
7743
7744        glVertexAttrib1fvNV = extproc;
7745
7746        glVertexAttrib1fvNV(index, v);
7747}
7748
7749static void APIENTRY InitVertexAttrib1dvNV (GLuint index, const GLdouble *v)
7750{
7751        void *extproc;
7752
7753        extproc = (void *) wglGetProcAddress("glVertexAttrib1dvNV");
7754
7755        if (extproc == NULL) {
7756                _ASSERT(0);
7757                return;
7758        }
7759
7760        glVertexAttrib1dvNV = extproc;
7761
7762        glVertexAttrib1dvNV(index, v);
7763}
7764
7765static void APIENTRY InitVertexAttrib2svNV (GLuint index, const GLshort *v)
7766{
7767        void *extproc;
7768
7769        extproc = (void *) wglGetProcAddress("glVertexAttrib2svNV");
7770
7771        if (extproc == NULL) {
7772                _ASSERT(0);
7773                return;
7774        }
7775
7776        glVertexAttrib2svNV = extproc;
7777
7778        glVertexAttrib2svNV(index, v);
7779}
7780
7781static void APIENTRY InitVertexAttrib2fvNV (GLuint index, const GLfloat *v)
7782{
7783        void *extproc;
7784
7785        extproc = (void *) wglGetProcAddress("glVertexAttrib2fvNV");
7786
7787        if (extproc == NULL) {
7788                _ASSERT(0);
7789                return;
7790        }
7791
7792        glVertexAttrib2fvNV = extproc;
7793
7794        glVertexAttrib2fvNV(index, v);
7795}
7796
7797static void APIENTRY InitVertexAttrib2dvNV (GLuint index, const GLdouble *v)
7798{
7799        void *extproc;
7800
7801        extproc = (void *) wglGetProcAddress("glVertexAttrib2dvNV");
7802
7803        if (extproc == NULL) {
7804                _ASSERT(0);
7805                return;
7806        }
7807
7808        glVertexAttrib2dvNV = extproc;
7809
7810        glVertexAttrib2dvNV(index, v);
7811}
7812
7813static void APIENTRY InitVertexAttrib3svNV (GLuint index, const GLshort *v)
7814{
7815        void *extproc;
7816
7817        extproc = (void *) wglGetProcAddress("glVertexAttrib3svNV");
7818
7819        if (extproc == NULL) {
7820                _ASSERT(0);
7821                return;
7822        }
7823
7824        glVertexAttrib3svNV = extproc;
7825
7826        glVertexAttrib3svNV(index, v);
7827}
7828
7829static void APIENTRY InitVertexAttrib3fvNV (GLuint index, const GLfloat *v)
7830{
7831        void *extproc;
7832
7833        extproc = (void *) wglGetProcAddress("glVertexAttrib3fvNV");
7834
7835        if (extproc == NULL) {
7836                _ASSERT(0);
7837                return;
7838        }
7839
7840        glVertexAttrib3fvNV = extproc;
7841
7842        glVertexAttrib3fvNV(index, v);
7843}
7844
7845static void APIENTRY InitVertexAttrib3dvNV (GLuint index, const GLdouble *v)
7846{
7847        void *extproc;
7848
7849        extproc = (void *) wglGetProcAddress("glVertexAttrib3dvNV");
7850
7851        if (extproc == NULL) {
7852                _ASSERT(0);
7853                return;
7854        }
7855
7856        glVertexAttrib3dvNV = extproc;
7857
7858        glVertexAttrib3dvNV(index, v);
7859}
7860
7861static void APIENTRY InitVertexAttrib4svNV (GLuint index, const GLshort *v)
7862{
7863        void *extproc;
7864
7865        extproc = (void *) wglGetProcAddress("glVertexAttrib4svNV");
7866
7867        if (extproc == NULL) {
7868                _ASSERT(0);
7869                return;
7870        }
7871
7872        glVertexAttrib4svNV = extproc;
7873
7874        glVertexAttrib4svNV(index, v);
7875}
7876
7877static void APIENTRY InitVertexAttrib4fvNV (GLuint index, const GLfloat *v)
7878{
7879        void *extproc;
7880
7881        extproc = (void *) wglGetProcAddress("glVertexAttrib4fvNV");
7882
7883        if (extproc == NULL) {
7884                _ASSERT(0);
7885                return;
7886        }
7887
7888        glVertexAttrib4fvNV = extproc;
7889
7890        glVertexAttrib4fvNV(index, v);
7891}
7892
7893static void APIENTRY InitVertexAttrib4dvNV (GLuint index, const GLdouble *v)
7894{
7895        void *extproc;
7896
7897        extproc = (void *) wglGetProcAddress("glVertexAttrib4dvNV");
7898
7899        if (extproc == NULL) {
7900                _ASSERT(0);
7901                return;
7902        }
7903
7904        glVertexAttrib4dvNV = extproc;
7905
7906        glVertexAttrib4dvNV(index, v);
7907}
7908
7909static void APIENTRY InitVertexAttrib4ubvNV (GLuint index, const GLubyte *v)
7910{
7911        void *extproc;
7912
7913        extproc = (void *) wglGetProcAddress("glVertexAttrib4ubvNV");
7914
7915        if (extproc == NULL) {
7916                _ASSERT(0);
7917                return;
7918        }
7919
7920        glVertexAttrib4ubvNV = extproc;
7921
7922        glVertexAttrib4ubvNV(index, v);
7923}
7924
7925static void APIENTRY InitVertexAttribs1svNV (GLuint index, GLsizei n, const GLshort *v)
7926{
7927        void *extproc;
7928
7929        extproc = (void *) wglGetProcAddress("glVertexAttribs1svNV");
7930
7931        if (extproc == NULL) {
7932                _ASSERT(0);
7933                return;
7934        }
7935
7936        glVertexAttribs1svNV = extproc;
7937
7938        glVertexAttribs1svNV(index, n, v);
7939}
7940
7941static void APIENTRY InitVertexAttribs1fvNV (GLuint index, GLsizei n, const GLfloat *v)
7942{
7943        void *extproc;
7944
7945        extproc = (void *) wglGetProcAddress("glVertexAttribs1fvNV");
7946
7947        if (extproc == NULL) {
7948                _ASSERT(0);
7949                return;
7950        }
7951
7952        glVertexAttribs1fvNV = extproc;
7953
7954        glVertexAttribs1fvNV(index, n, v);
7955}
7956
7957static void APIENTRY InitVertexAttribs1dvNV (GLuint index, GLsizei n, const GLdouble *v)
7958{
7959        void *extproc;
7960
7961        extproc = (void *) wglGetProcAddress("glVertexAttribs1dvNV");
7962
7963        if (extproc == NULL) {
7964                _ASSERT(0);
7965                return;
7966        }
7967
7968        glVertexAttribs1dvNV = extproc;
7969
7970        glVertexAttribs1dvNV(index, n, v);
7971}
7972
7973static void APIENTRY InitVertexAttribs2svNV (GLuint index, GLsizei n, const GLshort *v)
7974{
7975        void *extproc;
7976
7977        extproc = (void *) wglGetProcAddress("glVertexAttribs2svNV");
7978
7979        if (extproc == NULL) {
7980                _ASSERT(0);
7981                return;
7982        }
7983
7984        glVertexAttribs2svNV = extproc;
7985
7986        glVertexAttribs2svNV(index, n, v);
7987}
7988
7989static void APIENTRY InitVertexAttribs2fvNV (GLuint index, GLsizei n, const GLfloat *v)
7990{
7991        void *extproc;
7992
7993        extproc = (void *) wglGetProcAddress("glVertexAttribs2fvNV");
7994
7995        if (extproc == NULL) {
7996                _ASSERT(0);
7997                return;
7998        }
7999
8000        glVertexAttribs2fvNV = extproc;
8001
8002        glVertexAttribs2fvNV(index, n, v);
8003}
8004
8005static void APIENTRY InitVertexAttribs2dvNV (GLuint index, GLsizei n, const GLdouble *v)
8006{
8007        void *extproc;
8008
8009        extproc = (void *) wglGetProcAddress("glVertexAttribs2dvNV");
8010
8011        if (extproc == NULL) {
8012                _ASSERT(0);
8013                return;
8014        }
8015
8016        glVertexAttribs2dvNV = extproc;
8017
8018        glVertexAttribs2dvNV(index, n, v);
8019}
8020
8021static void APIENTRY InitVertexAttribs3svNV (GLuint index, GLsizei n, const GLshort *v)
8022{
8023        void *extproc;
8024
8025        extproc = (void *) wglGetProcAddress("glVertexAttribs3svNV");
8026
8027        if (extproc == NULL) {
8028                _ASSERT(0);
8029                return;
8030        }
8031
8032        glVertexAttribs3svNV = extproc;
8033
8034        glVertexAttribs3svNV(index, n, v);
8035}
8036
8037static void APIENTRY InitVertexAttribs3fvNV (GLuint index, GLsizei n, const GLfloat *v)
8038{
8039        void *extproc;
8040
8041        extproc = (void *) wglGetProcAddress("glVertexAttribs3fvNV");
8042
8043        if (extproc == NULL) {
8044                _ASSERT(0);
8045                return;
8046        }
8047
8048        glVertexAttribs3fvNV = extproc;
8049
8050        glVertexAttribs3fvNV(index, n, v);
8051}
8052
8053static void APIENTRY InitVertexAttribs3dvNV (GLuint index, GLsizei n, const GLdouble *v)
8054{
8055        void *extproc;
8056
8057        extproc = (void *) wglGetProcAddress("glVertexAttribs3dvNV");
8058
8059        if (extproc == NULL) {
8060                _ASSERT(0);
8061                return;
8062        }
8063
8064        glVertexAttribs3dvNV = extproc;
8065
8066        glVertexAttribs3dvNV(index, n, v);
8067}
8068
8069static void APIENTRY InitVertexAttribs4svNV (GLuint index, GLsizei n, const GLshort *v)
8070{
8071        void *extproc;
8072
8073        extproc = (void *) wglGetProcAddress("glVertexAttribs4svNV");
8074
8075        if (extproc == NULL) {
8076                _ASSERT(0);
8077                return;
8078        }
8079
8080        glVertexAttribs4svNV = extproc;
8081
8082        glVertexAttribs4svNV(index, n, v);
8083}
8084
8085static void APIENTRY InitVertexAttribs4fvNV (GLuint index, GLsizei n, const GLfloat *v)
8086{
8087        void *extproc;
8088
8089        extproc = (void *) wglGetProcAddress("glVertexAttribs4fvNV");
8090
8091        if (extproc == NULL) {
8092                _ASSERT(0);
8093                return;
8094        }
8095
8096        glVertexAttribs4fvNV = extproc;
8097
8098        glVertexAttribs4fvNV(index, n, v);
8099}
8100
8101static void APIENTRY InitVertexAttribs4dvNV (GLuint index, GLsizei n, const GLdouble *v)
8102{
8103        void *extproc;
8104
8105        extproc = (void *) wglGetProcAddress("glVertexAttribs4dvNV");
8106
8107        if (extproc == NULL) {
8108                _ASSERT(0);
8109                return;
8110        }
8111
8112        glVertexAttribs4dvNV = extproc;
8113
8114        glVertexAttribs4dvNV(index, n, v);
8115}
8116
8117static void APIENTRY InitVertexAttribs4ubvNV (GLuint index, GLsizei n, const GLubyte *v)
8118{
8119        void *extproc;
8120
8121        extproc = (void *) wglGetProcAddress("glVertexAttribs4ubvNV");
8122
8123        if (extproc == NULL) {
8124                _ASSERT(0);
8125                return;
8126        }
8127
8128        glVertexAttribs4ubvNV = extproc;
8129
8130        glVertexAttribs4ubvNV(index, n, v);
8131}
8132
8133static void APIENTRY InitAddSwapHintRectWIN (GLint x, GLint y, GLsizei width, GLsizei height)
8134{
8135        void *extproc;
8136
8137        extproc = (void *) wglGetProcAddress("glAddSwapHintRectWIN");
8138
8139        if (extproc == NULL) {
8140                _ASSERT(0);
8141                return;
8142        }
8143
8144        glAddSwapHintRectWIN = extproc;
8145
8146        glAddSwapHintRectWIN(x, y, width, height);
8147}
8148
8149#ifdef _WIN32
8150
8151static HANDLE WINAPI InitCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType)
8152{
8153        void *extproc;
8154
8155        extproc = (void *) wglGetProcAddress("wglCreateBufferRegionARB");
8156
8157        if (extproc == NULL) {
8158                _ASSERT(0);
8159                return 0;
8160        }
8161
8162        wglCreateBufferRegionARB = extproc;
8163
8164        return wglCreateBufferRegionARB(hDC, iLayerPlane, uType);
8165}
8166
8167static VOID WINAPI InitDeleteBufferRegionARB (HANDLE hRegion)
8168{
8169        void *extproc;
8170
8171        extproc = (void *) wglGetProcAddress("wglDeleteBufferRegionARB");
8172
8173        if (extproc == NULL) {
8174                _ASSERT(0);
8175                return;
8176        }
8177
8178        wglDeleteBufferRegionARB = extproc;
8179
8180        wglDeleteBufferRegionARB(hRegion);
8181}
8182
8183static BOOL WINAPI InitSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height)
8184{
8185        void *extproc;
8186
8187        extproc = (void *) wglGetProcAddress("wglSaveBufferRegionARB");
8188
8189        if (extproc == NULL) {
8190                _ASSERT(0);
8191                return 0;
8192        }
8193
8194        wglSaveBufferRegionARB = extproc;
8195
8196        return wglSaveBufferRegionARB(hRegion, x, y, width, height);
8197}
8198
8199static BOOL WINAPI InitRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc)
8200{
8201        void *extproc;
8202
8203        extproc = (void *) wglGetProcAddress("wglRestoreBufferRegionARB");
8204
8205        if (extproc == NULL) {
8206                _ASSERT(0);
8207                return 0;
8208        }
8209
8210        wglRestoreBufferRegionARB = extproc;
8211
8212        return wglRestoreBufferRegionARB(hRegion, x, y, width, height, xSrc, ySrc);
8213}
8214
8215static const WINAPI InitGetExtensionsStringARB (HDC hdc)
8216{
8217        void *extproc;
8218
8219        extproc = (void *) wglGetProcAddress("wglGetExtensionsStringARB");
8220
8221        if (extproc == NULL) {
8222                _ASSERT(0);
8223                return 0;
8224        }
8225
8226        wglGetExtensionsStringARB = extproc;
8227
8228        return wglGetExtensionsStringARB(hdc);
8229}
8230
8231static BOOL WINAPI InitGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
8232{
8233        void *extproc;
8234
8235        extproc = (void *) wglGetProcAddress("wglGetPixelFormatAttribivARB");
8236
8237        if (extproc == NULL) {
8238                _ASSERT(0);
8239                return 0;
8240        }
8241
8242        wglGetPixelFormatAttribivARB = extproc;
8243
8244        return wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
8245}
8246
8247static BOOL WINAPI InitGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
8248{
8249        void *extproc;
8250
8251        extproc = (void *) wglGetProcAddress("wglGetPixelFormatAttribfvARB");
8252
8253        if (extproc == NULL) {
8254                _ASSERT(0);
8255                return 0;
8256        }
8257
8258        wglGetPixelFormatAttribfvARB = extproc;
8259
8260        return wglGetPixelFormatAttribfvARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
8261}
8262
8263static BOOL WINAPI InitChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
8264{
8265        void *extproc;
8266
8267        extproc = (void *) wglGetProcAddress("wglChoosePixelFormatARB");
8268
8269        if (extproc == NULL) {
8270                _ASSERT(0);
8271                return 0;
8272        }
8273
8274        wglChoosePixelFormatARB = extproc;
8275
8276        return wglChoosePixelFormatARB(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
8277}
8278
8279static BOOL WINAPI InitMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
8280{
8281        void *extproc;
8282
8283        extproc = (void *) wglGetProcAddress("wglMakeContextCurrentARB");
8284
8285        if (extproc == NULL) {
8286                _ASSERT(0);
8287                return 0;
8288        }
8289
8290        wglMakeContextCurrentARB = extproc;
8291
8292        return wglMakeContextCurrentARB(hDrawDC, hReadDC, hglrc);
8293}
8294
8295static HDC WINAPI InitGetCurrentReadDCARB (void)
8296{
8297        void *extproc;
8298
8299        extproc = (void *) wglGetProcAddress("wglGetCurrentReadDCARB");
8300
8301        if (extproc == NULL) {
8302                _ASSERT(0);
8303                return 0;
8304        }
8305
8306        wglGetCurrentReadDCARB = extproc;
8307
8308        return wglGetCurrentReadDCARB();
8309}
8310
8311static HPBUFFERARB WINAPI InitCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
8312{
8313        void *extproc;
8314
8315        extproc = (void *) wglGetProcAddress("wglCreatePbufferARB");
8316
8317        if (extproc == NULL) {
8318                _ASSERT(0);
8319                return 0;
8320        }
8321
8322        wglCreatePbufferARB = extproc;
8323
8324        return wglCreatePbufferARB(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
8325}
8326
8327static HDC WINAPI InitGetPbufferDCARB (HPBUFFERARB hPbuffer)
8328{
8329        void *extproc;
8330
8331        extproc = (void *) wglGetProcAddress("wglGetPbufferDCARB");
8332
8333        if (extproc == NULL) {
8334                _ASSERT(0);
8335                return 0;
8336        }
8337
8338        wglGetPbufferDCARB = extproc;
8339
8340        return wglGetPbufferDCARB(hPbuffer);
8341}
8342
8343static int WINAPI InitReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC)
8344{
8345        void *extproc;
8346
8347        extproc = (void *) wglGetProcAddress("wglReleasePbufferDCARB");
8348
8349        if (extproc == NULL) {
8350                _ASSERT(0);
8351                return 0;
8352        }
8353
8354        wglReleasePbufferDCARB = extproc;
8355
8356        return wglReleasePbufferDCARB(hPbuffer, hDC);
8357}
8358
8359static BOOL WINAPI InitDestroyPbufferARB (HPBUFFERARB hPbuffer)
8360{
8361        void *extproc;
8362
8363        extproc = (void *) wglGetProcAddress("wglDestroyPbufferARB");
8364
8365        if (extproc == NULL) {
8366                _ASSERT(0);
8367                return 0;
8368        }
8369
8370        wglDestroyPbufferARB = extproc;
8371
8372        return wglDestroyPbufferARB(hPbuffer);
8373}
8374
8375static BOOL WINAPI InitQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue)
8376{
8377        void *extproc;
8378
8379        extproc = (void *) wglGetProcAddress("wglQueryPbufferARB");
8380
8381        if (extproc == NULL) {
8382                _ASSERT(0);
8383                return 0;
8384        }
8385
8386        wglQueryPbufferARB = extproc;
8387
8388        return wglQueryPbufferARB(hPbuffer, iAttribute, piValue);
8389}
8390
8391static GLboolean WINAPI InitCreateDisplayColorTableEXT (GLushort id)
8392{
8393        void *extproc;
8394
8395        extproc = (void *) wglGetProcAddress("wglCreateDisplayColorTableEXT");
8396
8397        if (extproc == NULL) {
8398                _ASSERT(0);
8399                return 0;
8400        }
8401
8402        wglCreateDisplayColorTableEXT = extproc;
8403
8404        return wglCreateDisplayColorTableEXT(id);
8405}
8406
8407static GLboolean WINAPI InitLoadDisplayColorTableEXT (const GLushort *table, GLuint length)
8408{
8409        void *extproc;
8410
8411        extproc = (void *) wglGetProcAddress("wglLoadDisplayColorTableEXT");
8412
8413        if (extproc == NULL) {
8414                _ASSERT(0);
8415                return 0;
8416        }
8417
8418        wglLoadDisplayColorTableEXT = extproc;
8419
8420        return wglLoadDisplayColorTableEXT(table, length);
8421}
8422
8423static GLboolean WINAPI InitBindDisplayColorTableEXT (GLushort id)
8424{
8425        void *extproc;
8426
8427        extproc = (void *) wglGetProcAddress("wglBindDisplayColorTableEXT");
8428
8429        if (extproc == NULL) {
8430                _ASSERT(0);
8431                return 0;
8432        }
8433
8434        wglBindDisplayColorTableEXT = extproc;
8435
8436        return wglBindDisplayColorTableEXT(id);
8437}
8438
8439static VOID WINAPI InitDestroyDisplayColorTableEXT (GLushort id)
8440{
8441        void *extproc;
8442
8443        extproc = (void *) wglGetProcAddress("wglDestroyDisplayColorTableEXT");
8444
8445        if (extproc == NULL) {
8446                _ASSERT(0);
8447                return;
8448        }
8449
8450        wglDestroyDisplayColorTableEXT = extproc;
8451
8452        wglDestroyDisplayColorTableEXT(id);
8453}
8454
8455static const WINAPI InitGetExtensionsStringEXT (void)
8456{
8457        void *extproc;
8458
8459        extproc = (void *) wglGetProcAddress("wglGetExtensionsStringEXT");
8460
8461        if (extproc == NULL) {
8462                _ASSERT(0);
8463                return 0;
8464        }
8465
8466        wglGetExtensionsStringEXT = extproc;
8467
8468        return wglGetExtensionsStringEXT();
8469}
8470
8471static BOOL WINAPI InitMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
8472{
8473        void *extproc;
8474
8475        extproc = (void *) wglGetProcAddress("wglMakeContextCurrentEXT");
8476
8477        if (extproc == NULL) {
8478                _ASSERT(0);
8479                return 0;
8480        }
8481
8482        wglMakeContextCurrentEXT = extproc;
8483
8484        return wglMakeContextCurrentEXT(hDrawDC, hReadDC, hglrc);
8485}
8486
8487static HDC WINAPI InitGetCurrentReadDCEXT (void)
8488{
8489        void *extproc;
8490
8491        extproc = (void *) wglGetProcAddress("wglGetCurrentReadDCEXT");
8492
8493        if (extproc == NULL) {
8494                _ASSERT(0);
8495                return 0;
8496        }
8497
8498        wglGetCurrentReadDCEXT = extproc;
8499
8500        return wglGetCurrentReadDCEXT();
8501}
8502
8503static HPBUFFEREXT WINAPI InitCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
8504{
8505        void *extproc;
8506
8507        extproc = (void *) wglGetProcAddress("wglCreatePbufferEXT");
8508
8509        if (extproc == NULL) {
8510                _ASSERT(0);
8511                return 0;
8512        }
8513
8514        wglCreatePbufferEXT = extproc;
8515
8516        return wglCreatePbufferEXT(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
8517}
8518
8519static HDC WINAPI InitGetPbufferDCEXT (HPBUFFEREXT hPbuffer)
8520{
8521        void *extproc;
8522
8523        extproc = (void *) wglGetProcAddress("wglGetPbufferDCEXT");
8524
8525        if (extproc == NULL) {
8526                _ASSERT(0);
8527                return 0;
8528        }
8529
8530        wglGetPbufferDCEXT = extproc;
8531
8532        return wglGetPbufferDCEXT(hPbuffer);
8533}
8534
8535static int WINAPI InitReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC)
8536{
8537        void *extproc;
8538
8539        extproc = (void *) wglGetProcAddress("wglReleasePbufferDCEXT");
8540
8541        if (extproc == NULL) {
8542                _ASSERT(0);
8543                return 0;
8544        }
8545
8546        wglReleasePbufferDCEXT = extproc;
8547
8548        return wglReleasePbufferDCEXT(hPbuffer, hDC);
8549}
8550
8551static BOOL WINAPI InitDestroyPbufferEXT (HPBUFFEREXT hPbuffer)
8552{
8553        void *extproc;
8554
8555        extproc = (void *) wglGetProcAddress("wglDestroyPbufferEXT");
8556
8557        if (extproc == NULL) {
8558                _ASSERT(0);
8559                return 0;
8560        }
8561
8562        wglDestroyPbufferEXT = extproc;
8563
8564        return wglDestroyPbufferEXT(hPbuffer);
8565}
8566
8567static BOOL WINAPI InitQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue)
8568{
8569        void *extproc;
8570
8571        extproc = (void *) wglGetProcAddress("wglQueryPbufferEXT");
8572
8573        if (extproc == NULL) {
8574                _ASSERT(0);
8575                return 0;
8576        }
8577
8578        wglQueryPbufferEXT = extproc;
8579
8580        return wglQueryPbufferEXT(hPbuffer, iAttribute, piValue);
8581}
8582
8583static BOOL WINAPI InitGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues)
8584{
8585        void *extproc;
8586
8587        extproc = (void *) wglGetProcAddress("wglGetPixelFormatAttribivEXT");
8588
8589        if (extproc == NULL) {
8590                _ASSERT(0);
8591                return 0;
8592        }
8593
8594        wglGetPixelFormatAttribivEXT = extproc;
8595
8596        return wglGetPixelFormatAttribivEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
8597}
8598
8599static BOOL WINAPI InitGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues)
8600{
8601        void *extproc;
8602
8603        extproc = (void *) wglGetProcAddress("wglGetPixelFormatAttribfvEXT");
8604
8605        if (extproc == NULL) {
8606                _ASSERT(0);
8607                return 0;
8608        }
8609
8610        wglGetPixelFormatAttribfvEXT = extproc;
8611
8612        return wglGetPixelFormatAttribfvEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
8613}
8614
8615static BOOL WINAPI InitChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
8616{
8617        void *extproc;
8618
8619        extproc = (void *) wglGetProcAddress("wglChoosePixelFormatEXT");
8620
8621        if (extproc == NULL) {
8622                _ASSERT(0);
8623                return 0;
8624        }
8625
8626        wglChoosePixelFormatEXT = extproc;
8627
8628        return wglChoosePixelFormatEXT(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
8629}
8630
8631static BOOL WINAPI InitSwapIntervalEXT (int interval)
8632{
8633        void *extproc;
8634
8635        extproc = (void *) wglGetProcAddress("wglSwapIntervalEXT");
8636
8637        if (extproc == NULL) {
8638                _ASSERT(0);
8639                return 0;
8640        }
8641
8642        wglSwapIntervalEXT = extproc;
8643
8644        return wglSwapIntervalEXT(interval);
8645}
8646
8647static int WINAPI InitGetSwapIntervalEXT (void)
8648{
8649        void *extproc;
8650
8651        extproc = (void *) wglGetProcAddress("wglGetSwapIntervalEXT");
8652
8653        if (extproc == NULL) {
8654                _ASSERT(0);
8655                return 0;
8656        }
8657
8658        wglGetSwapIntervalEXT = extproc;
8659
8660        return wglGetSwapIntervalEXT();
8661}
8662
8663#endif /* _WIN32 */
8664
8665_GLextensionProcs _extensionProcs = {
8666        InitBlendColor,
8667        InitBlendEquation,
8668        InitDrawRangeElements,
8669        InitColorTable,
8670        InitColorTableParameterfv,
8671        InitColorTableParameteriv,
8672        InitCopyColorTable,
8673        InitGetColorTable,
8674        InitGetColorTableParameterfv,
8675        InitGetColorTableParameteriv,
8676        InitColorSubTable,
8677        InitCopyColorSubTable,
8678        InitConvolutionFilter1D,
8679        InitConvolutionFilter2D,
8680        InitConvolutionParameterf,
8681        InitConvolutionParameterfv,
8682        InitConvolutionParameteri,
8683        InitConvolutionParameteriv,
8684        InitCopyConvolutionFilter1D,
8685        InitCopyConvolutionFilter2D,
8686        InitGetConvolutionFilter,
8687        InitGetConvolutionParameterfv,
8688        InitGetConvolutionParameteriv,
8689        InitGetSeparableFilter,
8690        InitSeparableFilter2D,
8691        InitGetHistogram,
8692        InitGetHistogramParameterfv,
8693        InitGetHistogramParameteriv,
8694        InitGetMinmax,
8695        InitGetMinmaxParameterfv,
8696        InitGetMinmaxParameteriv,
8697        InitHistogram,
8698        InitMinmax,
8699        InitResetHistogram,
8700        InitResetMinmax,
8701        InitTexImage3D,
8702        InitTexSubImage3D,
8703        InitCopyTexSubImage3D,
8704        InitActiveTextureARB,
8705        InitClientActiveTextureARB,
8706        InitMultiTexCoord1dARB,
8707        InitMultiTexCoord1dvARB,
8708        InitMultiTexCoord1fARB,
8709        InitMultiTexCoord1fvARB,
8710        InitMultiTexCoord1iARB,
8711        InitMultiTexCoord1ivARB,
8712        InitMultiTexCoord1sARB,
8713        InitMultiTexCoord1svARB,
8714        InitMultiTexCoord2dARB,
8715        InitMultiTexCoord2dvARB,
8716        InitMultiTexCoord2fARB,
8717        InitMultiTexCoord2fvARB,
8718        InitMultiTexCoord2iARB,
8719        InitMultiTexCoord2ivARB,
8720        InitMultiTexCoord2sARB,
8721        InitMultiTexCoord2svARB,
8722        InitMultiTexCoord3dARB,
8723        InitMultiTexCoord3dvARB,
8724        InitMultiTexCoord3fARB,
8725        InitMultiTexCoord3fvARB,
8726        InitMultiTexCoord3iARB,
8727        InitMultiTexCoord3ivARB,
8728        InitMultiTexCoord3sARB,
8729        InitMultiTexCoord3svARB,
8730        InitMultiTexCoord4dARB,
8731        InitMultiTexCoord4dvARB,
8732        InitMultiTexCoord4fARB,
8733        InitMultiTexCoord4fvARB,
8734        InitMultiTexCoord4iARB,
8735        InitMultiTexCoord4ivARB,
8736        InitMultiTexCoord4sARB,
8737        InitMultiTexCoord4svARB,
8738        InitLoadTransposeMatrixfARB,
8739        InitLoadTransposeMatrixdARB,
8740        InitMultTransposeMatrixfARB,
8741        InitMultTransposeMatrixdARB,
8742        InitSampleCoverageARB,
8743        InitCompressedTexImage3DARB,
8744        InitCompressedTexImage2DARB,
8745        InitCompressedTexImage1DARB,
8746        InitCompressedTexSubImage3DARB,
8747        InitCompressedTexSubImage2DARB,
8748        InitCompressedTexSubImage1DARB,
8749        InitGetCompressedTexImageARB,
8750        InitWeightbvARB,
8751        InitWeightsvARB,
8752        InitWeightivARB,
8753        InitWeightfvARB,
8754        InitWeightdvARB,
8755        InitWeightubvARB,
8756        InitWeightusvARB,
8757        InitWeightuivARB,
8758        InitWeightPointerARB,
8759        InitVertexBlendARB,
8760        InitCurrentPaletteMatrixARB,
8761        InitMatrixIndexubvARB,
8762        InitMatrixIndexusvARB,
8763        InitMatrixIndexuivARB,
8764        InitMatrixIndexPointerARB,
8765        InitBlendColorEXT,
8766        InitPolygonOffsetEXT,
8767        InitTexImage3DEXT,
8768        InitTexSubImage3DEXT,
8769        InitGetTexFilterFuncSGIS,
8770        InitTexFilterFuncSGIS,
8771        InitTexSubImage1DEXT,
8772        InitTexSubImage2DEXT,
8773        InitCopyTexImage1DEXT,
8774        InitCopyTexImage2DEXT,
8775        InitCopyTexSubImage1DEXT,
8776        InitCopyTexSubImage2DEXT,
8777        InitCopyTexSubImage3DEXT,
8778        InitGetHistogramEXT,
8779        InitGetHistogramParameterfvEXT,
8780        InitGetHistogramParameterivEXT,
8781        InitGetMinmaxEXT,
8782        InitGetMinmaxParameterfvEXT,
8783        InitGetMinmaxParameterivEXT,
8784        InitHistogramEXT,
8785        InitMinmaxEXT,
8786        InitResetHistogramEXT,
8787        InitResetMinmaxEXT,
8788        InitConvolutionFilter1DEXT,
8789        InitConvolutionFilter2DEXT,
8790        InitConvolutionParameterfEXT,
8791        InitConvolutionParameterfvEXT,
8792        InitConvolutionParameteriEXT,
8793        InitConvolutionParameterivEXT,
8794        InitCopyConvolutionFilter1DEXT,
8795        InitCopyConvolutionFilter2DEXT,
8796        InitGetConvolutionFilterEXT,
8797        InitGetConvolutionParameterfvEXT,
8798        InitGetConvolutionParameterivEXT,
8799        InitGetSeparableFilterEXT,
8800        InitSeparableFilter2DEXT,
8801        InitColorTableSGI,
8802        InitColorTableParameterfvSGI,
8803        InitColorTableParameterivSGI,
8804        InitCopyColorTableSGI,
8805        InitGetColorTableSGI,
8806        InitGetColorTableParameterfvSGI,
8807        InitGetColorTableParameterivSGI,
8808        InitPixelTexGenSGIX,
8809        InitPixelTexGenParameteriSGIS,
8810        InitPixelTexGenParameterivSGIS,
8811        InitPixelTexGenParameterfSGIS,
8812        InitPixelTexGenParameterfvSGIS,
8813        InitGetPixelTexGenParameterivSGIS,
8814        InitGetPixelTexGenParameterfvSGIS,
8815        InitTexImage4DSGIS,
8816        InitTexSubImage4DSGIS,
8817        InitAreTexturesResidentEXT,
8818        InitBindTextureEXT,
8819        InitDeleteTexturesEXT,
8820        InitGenTexturesEXT,
8821        InitIsTextureEXT,
8822        InitPrioritizeTexturesEXT,
8823        InitDetailTexFuncSGIS,
8824        InitGetDetailTexFuncSGIS,
8825        InitSharpenTexFuncSGIS,
8826        InitGetSharpenTexFuncSGIS,
8827        InitSampleMaskSGIS,
8828        InitSamplePatternSGIS,
8829        InitArrayElementEXT,
8830        InitColorPointerEXT,
8831        InitDrawArraysEXT,
8832        InitEdgeFlagPointerEXT,
8833        InitGetPointervEXT,
8834        InitIndexPointerEXT,
8835        InitNormalPointerEXT,
8836        InitTexCoordPointerEXT,
8837        InitVertexPointerEXT,
8838        InitBlendEquationEXT,
8839        InitSpriteParameterfSGIX,
8840        InitSpriteParameterfvSGIX,
8841        InitSpriteParameteriSGIX,
8842        InitSpriteParameterivSGIX,
8843        InitPointParameterfARB,
8844        InitPointParameterfvARB,
8845        InitPointParameterfEXT,
8846        InitPointParameterfvEXT,
8847        InitPointParameterfSGIS,
8848        InitPointParameterfvSGIS,
8849        InitGetInstrumentsSGIX,
8850        InitInstrumentsBufferSGIX,
8851        InitPollInstrumentsSGIX,
8852        InitReadInstrumentsSGIX,
8853        InitStartInstrumentsSGIX,
8854        InitStopInstrumentsSGIX,
8855        InitFrameZoomSGIX,
8856        InitTagSampleBufferSGIX,
8857        InitDeformationMap3dSGIX,
8858        InitDeformationMap3fSGIX,
8859        InitDeformSGIX,
8860        InitLoadIdentityDeformationMapSGIX,
8861        InitReferencePlaneSGIX,
8862        InitFlushRasterSGIX,
8863        InitFogFuncSGIS,
8864        InitGetFogFuncSGIS,
8865        InitImageTransformParameteriHP,
8866        InitImageTransformParameterfHP,
8867        InitImageTransformParameterivHP,
8868        InitImageTransformParameterfvHP,
8869        InitGetImageTransformParameterivHP,
8870        InitGetImageTransformParameterfvHP,
8871        InitColorSubTableEXT,
8872        InitCopyColorSubTableEXT,
8873        InitHintPGI,
8874        InitColorTableEXT,
8875        InitGetColorTableEXT,
8876        InitGetColorTableParameterivEXT,
8877        InitGetColorTableParameterfvEXT,
8878        InitGetListParameterfvSGIX,
8879        InitGetListParameterivSGIX,
8880        InitListParameterfSGIX,
8881        InitListParameterfvSGIX,
8882        InitListParameteriSGIX,
8883        InitListParameterivSGIX,
8884        InitIndexMaterialEXT,
8885        InitIndexFuncEXT,
8886        InitLockArraysEXT,
8887        InitUnlockArraysEXT,
8888        InitCullParameterdvEXT,
8889        InitCullParameterfvEXT,
8890        InitFragmentColorMaterialSGIX,
8891        InitFragmentLightfSGIX,
8892        InitFragmentLightfvSGIX,
8893        InitFragmentLightiSGIX,
8894        InitFragmentLightivSGIX,
8895        InitFragmentLightModelfSGIX,
8896        InitFragmentLightModelfvSGIX,
8897        InitFragmentLightModeliSGIX,
8898        InitFragmentLightModelivSGIX,
8899        InitFragmentMaterialfSGIX,
8900        InitFragmentMaterialfvSGIX,
8901        InitFragmentMaterialiSGIX,
8902        InitFragmentMaterialivSGIX,
8903        InitGetFragmentLightfvSGIX,
8904        InitGetFragmentLightivSGIX,
8905        InitGetFragmentMaterialfvSGIX,
8906        InitGetFragmentMaterialivSGIX,
8907        InitLightEnviSGIX,
8908        InitDrawRangeElementsEXT,
8909        InitApplyTextureEXT,
8910        InitTextureLightEXT,
8911        InitTextureMaterialEXT,
8912        InitAsyncMarkerSGIX,
8913        InitFinishAsyncSGIX,
8914        InitPollAsyncSGIX,
8915        InitGenAsyncMarkersSGIX,
8916        InitDeleteAsyncMarkersSGIX,
8917        InitIsAsyncMarkerSGIX,
8918        InitVertexPointervINTEL,
8919        InitNormalPointervINTEL,
8920        InitColorPointervINTEL,
8921        InitTexCoordPointervINTEL,
8922        InitPixelTransformParameteriEXT,
8923        InitPixelTransformParameterfEXT,
8924        InitPixelTransformParameterivEXT,
8925        InitPixelTransformParameterfvEXT,
8926        InitSecondaryColor3bEXT,
8927        InitSecondaryColor3bvEXT,
8928        InitSecondaryColor3dEXT,
8929        InitSecondaryColor3dvEXT,
8930        InitSecondaryColor3fEXT,
8931        InitSecondaryColor3fvEXT,
8932        InitSecondaryColor3iEXT,
8933        InitSecondaryColor3ivEXT,
8934        InitSecondaryColor3sEXT,
8935        InitSecondaryColor3svEXT,
8936        InitSecondaryColor3ubEXT,
8937        InitSecondaryColor3ubvEXT,
8938        InitSecondaryColor3uiEXT,
8939        InitSecondaryColor3uivEXT,
8940        InitSecondaryColor3usEXT,
8941        InitSecondaryColor3usvEXT,
8942        InitSecondaryColorPointerEXT,
8943        InitTextureNormalEXT,
8944        InitMultiDrawArraysEXT,
8945        InitMultiDrawElementsEXT,
8946        InitFogCoordfEXT,
8947        InitFogCoordfvEXT,
8948        InitFogCoorddEXT,
8949        InitFogCoorddvEXT,
8950        InitFogCoordPointerEXT,
8951        InitTangent3bEXT,
8952        InitTangent3bvEXT,
8953        InitTangent3dEXT,
8954        InitTangent3dvEXT,
8955        InitTangent3fEXT,
8956        InitTangent3fvEXT,
8957        InitTangent3iEXT,
8958        InitTangent3ivEXT,
8959        InitTangent3sEXT,
8960        InitTangent3svEXT,
8961        InitBinormal3bEXT,
8962        InitBinormal3bvEXT,
8963        InitBinormal3dEXT,
8964        InitBinormal3dvEXT,
8965        InitBinormal3fEXT,
8966        InitBinormal3fvEXT,
8967        InitBinormal3iEXT,
8968        InitBinormal3ivEXT,
8969        InitBinormal3sEXT,
8970        InitBinormal3svEXT,
8971        InitTangentPointerEXT,
8972        InitBinormalPointerEXT,
8973        InitFinishTextureSUNX,
8974        InitGlobalAlphaFactorbSUN,
8975        InitGlobalAlphaFactorsSUN,
8976        InitGlobalAlphaFactoriSUN,
8977        InitGlobalAlphaFactorfSUN,
8978        InitGlobalAlphaFactordSUN,
8979        InitGlobalAlphaFactorubSUN,
8980        InitGlobalAlphaFactorusSUN,
8981        InitGlobalAlphaFactoruiSUN,
8982        InitReplacementCodeuiSUN,
8983        InitReplacementCodeusSUN,
8984        InitReplacementCodeubSUN,
8985        InitReplacementCodeuivSUN,
8986        InitReplacementCodeusvSUN,
8987        InitReplacementCodeubvSUN,
8988        InitReplacementCodePointerSUN,
8989        InitColor4ubVertex2fSUN,
8990        InitColor4ubVertex2fvSUN,
8991        InitColor4ubVertex3fSUN,
8992        InitColor4ubVertex3fvSUN,
8993        InitColor3fVertex3fSUN,
8994        InitColor3fVertex3fvSUN,
8995        InitNormal3fVertex3fSUN,
8996        InitNormal3fVertex3fvSUN,
8997        InitColor4fNormal3fVertex3fSUN,
8998        InitColor4fNormal3fVertex3fvSUN,
8999        InitTexCoord2fVertex3fSUN,
9000        InitTexCoord2fVertex3fvSUN,
9001        InitTexCoord4fVertex4fSUN,
9002        InitTexCoord4fVertex4fvSUN,
9003        InitTexCoord2fColor4ubVertex3fSUN,
9004        InitTexCoord2fColor4ubVertex3fvSUN,
9005        InitTexCoord2fColor3fVertex3fSUN,
9006        InitTexCoord2fColor3fVertex3fvSUN,
9007        InitTexCoord2fNormal3fVertex3fSUN,
9008        InitTexCoord2fNormal3fVertex3fvSUN,
9009        InitTexCoord2fColor4fNormal3fVertex3fSUN,
9010        InitTexCoord2fColor4fNormal3fVertex3fvSUN,
9011        InitTexCoord4fColor4fNormal3fVertex4fSUN,
9012        InitTexCoord4fColor4fNormal3fVertex4fvSUN,
9013        InitReplacementCodeuiVertex3fSUN,
9014        InitReplacementCodeuiVertex3fvSUN,
9015        InitReplacementCodeuiColor4ubVertex3fSUN,
9016        InitReplacementCodeuiColor4ubVertex3fvSUN,
9017        InitReplacementCodeuiColor3fVertex3fSUN,
9018        InitReplacementCodeuiColor3fVertex3fvSUN,
9019        InitReplacementCodeuiNormal3fVertex3fSUN,
9020        InitReplacementCodeuiNormal3fVertex3fvSUN,
9021        InitReplacementCodeuiColor4fNormal3fVertex3fSUN,
9022        InitReplacementCodeuiColor4fNormal3fVertex3fvSUN,
9023        InitReplacementCodeuiTexCoord2fVertex3fSUN,
9024        InitReplacementCodeuiTexCoord2fVertex3fvSUN,
9025        InitReplacementCodeuiTexCoord2fNormal3fVertex3fSUN,
9026        InitReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,
9027        InitReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,
9028        InitReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,
9029        InitBlendFuncSeparateEXT,
9030        InitBlendFuncSeparateINGR,
9031        InitVertexWeightfEXT,
9032        InitVertexWeightfvEXT,
9033        InitVertexWeightPointerEXT,
9034        InitFlushVertexArrayRangeNV,
9035        InitVertexArrayRangeNV,
9036        InitCombinerParameterfvNV,
9037        InitCombinerParameterfNV,
9038        InitCombinerParameterivNV,
9039        InitCombinerParameteriNV,
9040        InitCombinerInputNV,
9041        InitCombinerOutputNV,
9042        InitFinalCombinerInputNV,
9043        InitGetCombinerInputParameterfvNV,
9044        InitGetCombinerInputParameterivNV,
9045        InitGetCombinerOutputParameterfvNV,
9046        InitGetCombinerOutputParameterivNV,
9047        InitGetFinalCombinerInputParameterfvNV,
9048        InitGetFinalCombinerInputParameterivNV,
9049        InitResizeBuffersMESA,
9050        InitWindowPos2dMESA,
9051        InitWindowPos2dvMESA,
9052        InitWindowPos2fMESA,
9053        InitWindowPos2fvMESA,
9054        InitWindowPos2iMESA,
9055        InitWindowPos2ivMESA,
9056        InitWindowPos2sMESA,
9057        InitWindowPos2svMESA,
9058        InitWindowPos3dMESA,
9059        InitWindowPos3dvMESA,
9060        InitWindowPos3fMESA,
9061        InitWindowPos3fvMESA,
9062        InitWindowPos3iMESA,
9063        InitWindowPos3ivMESA,
9064        InitWindowPos3sMESA,
9065        InitWindowPos3svMESA,
9066        InitWindowPos4dMESA,
9067        InitWindowPos4dvMESA,
9068        InitWindowPos4fMESA,
9069        InitWindowPos4fvMESA,
9070        InitWindowPos4iMESA,
9071        InitWindowPos4ivMESA,
9072        InitWindowPos4sMESA,
9073        InitWindowPos4svMESA,
9074        InitMultiModeDrawArraysIBM,
9075        InitMultiModeDrawElementsIBM,
9076        InitColorPointerListIBM,
9077        InitSecondaryColorPointerListIBM,
9078        InitEdgeFlagPointerListIBM,
9079        InitFogCoordPointerListIBM,
9080        InitIndexPointerListIBM,
9081        InitNormalPointerListIBM,
9082        InitTexCoordPointerListIBM,
9083        InitVertexPointerListIBM,
9084        InitTbufferMask3DFX,
9085        InitSampleMaskEXT,
9086        InitSamplePatternEXT,
9087        InitTextureColorMaskSGIS,
9088        InitIglooInterfaceSGIX,
9089        InitGenFencesNV,
9090        InitDeleteFencesNV,
9091        InitSetFenceNV,
9092        InitTestFenceNV,
9093        InitFinishFenceNV,
9094        InitIsFenceNV,
9095        InitGetFenceivNV,
9096        InitMapControlPointsNV,
9097        InitMapParameterivNV,
9098        InitMapParameterfvNV,
9099        InitGetMapControlPointsNV,
9100        InitGetMapParameterivNV,
9101        InitGetMapParameterfvNV,
9102        InitGetMapAttribParameterivNV,
9103        InitGetMapAttribParameterfvNV,
9104        InitEvalMapsNV,
9105        InitCombinerStageParameterfvNV,
9106        InitGetCombinerStageParameterfvNV,
9107        InitBindProgramNV,
9108        InitDeleteProgramsNV,
9109        InitExecuteProgramNV,
9110        InitGenProgramsNV,
9111        InitAreProgramsResidentNV,
9112        InitRequestResidentProgramsNV,
9113        InitGetProgramParameterfvNV,
9114        InitGetProgramParameterdvNV,
9115        InitGetProgramivNV,
9116        InitGetProgramStringNV,
9117        InitGetTrackMatrixivNV,
9118        InitGetVertexAttribdvNV,
9119        InitGetVertexAttribfvNV,
9120        InitGetVertexAttribivNV,
9121        InitGetVertexAttribPointervNV,
9122        InitIsProgramNV,
9123        InitLoadProgramNV,
9124        InitProgramParameter4fNV,
9125        InitProgramParameter4dNV,
9126        InitProgramParameter4dvNV,
9127        InitProgramParameter4fvNV,
9128        InitProgramParameters4dvNV,
9129        InitProgramParameters4fvNV,
9130        InitTrackMatrixNV,
9131        InitVertexAttribPointerNV,
9132        InitVertexAttrib1sNV,
9133        InitVertexAttrib1fNV,
9134        InitVertexAttrib1dNV,
9135        InitVertexAttrib2sNV,
9136        InitVertexAttrib2fNV,
9137        InitVertexAttrib2dNV,
9138        InitVertexAttrib3sNV,
9139        InitVertexAttrib3fNV,
9140        InitVertexAttrib3dNV,
9141        InitVertexAttrib4sNV,
9142        InitVertexAttrib4fNV,
9143        InitVertexAttrib4dNV,
9144        InitVertexAttrib4ubNV,
9145        InitVertexAttrib1svNV,
9146        InitVertexAttrib1fvNV,
9147        InitVertexAttrib1dvNV,
9148        InitVertexAttrib2svNV,
9149        InitVertexAttrib2fvNV,
9150        InitVertexAttrib2dvNV,
9151        InitVertexAttrib3svNV,
9152        InitVertexAttrib3fvNV,
9153        InitVertexAttrib3dvNV,
9154        InitVertexAttrib4svNV,
9155        InitVertexAttrib4fvNV,
9156        InitVertexAttrib4dvNV,
9157        InitVertexAttrib4ubvNV,
9158        InitVertexAttribs1svNV,
9159        InitVertexAttribs1fvNV,
9160        InitVertexAttribs1dvNV,
9161        InitVertexAttribs2svNV,
9162        InitVertexAttribs2fvNV,
9163        InitVertexAttribs2dvNV,
9164        InitVertexAttribs3svNV,
9165        InitVertexAttribs3fvNV,
9166        InitVertexAttribs3dvNV,
9167        InitVertexAttribs4svNV,
9168        InitVertexAttribs4fvNV,
9169        InitVertexAttribs4dvNV,
9170        InitVertexAttribs4ubvNV,
9171        InitAddSwapHintRectWIN,
9172#ifdef _WIN32
9173        InitCreateBufferRegionARB,
9174        InitDeleteBufferRegionARB,
9175        InitSaveBufferRegionARB,
9176        InitRestoreBufferRegionARB,
9177        InitGetExtensionsStringARB,
9178        InitGetPixelFormatAttribivARB,
9179        InitGetPixelFormatAttribfvARB,
9180        InitChoosePixelFormatARB,
9181        InitMakeContextCurrentARB,
9182        InitGetCurrentReadDCARB,
9183        InitCreatePbufferARB,
9184        InitGetPbufferDCARB,
9185        InitReleasePbufferDCARB,
9186        InitDestroyPbufferARB,
9187        InitQueryPbufferARB,
9188        InitCreateDisplayColorTableEXT,
9189        InitLoadDisplayColorTableEXT,
9190        InitBindDisplayColorTableEXT,
9191        InitDestroyDisplayColorTableEXT,
9192        InitGetExtensionsStringEXT,
9193        InitMakeContextCurrentEXT,
9194        InitGetCurrentReadDCEXT,
9195        InitCreatePbufferEXT,
9196        InitGetPbufferDCEXT,
9197        InitReleasePbufferDCEXT,
9198        InitDestroyPbufferEXT,
9199        InitQueryPbufferEXT,
9200        InitGetPixelFormatAttribivEXT,
9201        InitGetPixelFormatAttribfvEXT,
9202        InitChoosePixelFormatEXT,
9203        InitSwapIntervalEXT,
9204        InitGetSwapIntervalEXT,
9205#endif /* _WIN32 */
9206};
Note: See TracBrowser for help on using the repository browser.