Merging r50470 through r50477 from trunk into soc-2011-tomato
[blender.git] / source / blender / python / generic / bgl.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * This is a new part of Blender.
22  *
23  * Contributor(s): Willian P. Germano, Campbell Barton
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/python/generic/bgl.c
29  *  \ingroup pygen
30  *
31  * This file is the 'bgl' module which wraps OpenGL functions and constants,
32  * allowing script writers to make OpenGL calls in their Python scripts.
33  *
34  * \note
35  * This module is very similar to 'PyOpenGL' which could replace 'bgl' one day.
36  */
37
38 #include <Python.h>
39
40 #include "bgl.h" /*This must come first */
41 #include <GL/glew.h>
42 #include "MEM_guardedalloc.h"
43
44 #include "BLI_utildefines.h"
45
46 static PyObject *Buffer_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
47 static PyObject *Method_ShaderSource(PyObject *self, PyObject *args);
48
49 /* Buffer sequence methods */
50
51 static int Buffer_len(Buffer *self);
52 static PyObject *Buffer_item(Buffer *self, int i);
53 static PyObject *Buffer_slice(Buffer *self, int begin, int end);
54 static int Buffer_ass_item(Buffer *self, int i, PyObject *v);
55 static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq);
56 static PyObject *Buffer_subscript(Buffer *self, PyObject *item);
57 static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value);
58
59 static PySequenceMethods Buffer_SeqMethods = {
60         (lenfunc) Buffer_len,                       /*sq_length */
61         (binaryfunc) NULL,                          /*sq_concat */
62         (ssizeargfunc) NULL,                        /*sq_repeat */
63         (ssizeargfunc) Buffer_item,                 /*sq_item */
64         (ssizessizeargfunc) NULL,                   /*sq_slice, deprecated, handled in Buffer_item */
65         (ssizeobjargproc) Buffer_ass_item,          /*sq_ass_item */
66         (ssizessizeobjargproc) NULL,                /*sq_ass_slice, deprecated handled in Buffer_ass_item */
67         (objobjproc) NULL,                          /* sq_contains */
68         (binaryfunc) NULL,                          /* sq_inplace_concat */
69         (ssizeargfunc) NULL,                        /* sq_inplace_repeat */
70 };
71
72
73 static PyMappingMethods Buffer_AsMapping = {
74         (lenfunc)Buffer_len,
75         (binaryfunc)Buffer_subscript,
76         (objobjargproc)Buffer_ass_subscript
77 };
78
79 static void Buffer_dealloc(Buffer *self);
80 static PyObject *Buffer_repr(Buffer *self);
81
82 static PyObject *Buffer_to_list(Buffer *self)
83 {
84         int i, len = self->dimensions[0];
85         PyObject *list = PyList_New(len);
86
87         for (i = 0; i < len; i++) {
88                 PyList_SET_ITEM(list, i, Buffer_item(self, i));
89         }
90
91         return list;
92 }
93
94 static PyObject *Buffer_to_list_recursive(Buffer *self)
95 {
96         PyObject *list;
97
98         if (self->ndimensions > 1) {
99                 int i, len = self->dimensions[0];
100                 list = PyList_New(len);
101
102                 for (i = 0; i < len; i++) {
103                         Buffer *sub = (Buffer *)Buffer_item(self, i);
104                         PyList_SET_ITEM(list, i, Buffer_to_list_recursive(sub));
105                         Py_DECREF(sub);
106                 }
107         }
108         else {
109                 list = Buffer_to_list(self);
110         }
111
112         return list;
113 }
114
115 static PyObject *Buffer_dimensions(Buffer *self, void *UNUSED(arg))
116 {
117         PyObject *list = PyList_New(self->ndimensions);
118         int i;
119
120         for (i = 0; i < self->ndimensions; i++) {
121                 PyList_SET_ITEM(list, i, PyLong_FromLong(self->dimensions[i]));
122         }
123
124         return list;
125 }
126
127 static PyMethodDef Buffer_methods[] = {
128         {"to_list", (PyCFunction)Buffer_to_list_recursive, METH_NOARGS,
129          "return the buffer as a list"},
130         {NULL, NULL, 0, NULL}
131 };
132
133 static PyGetSetDef Buffer_getseters[] = {
134         {(char *)"dimensions", (getter)Buffer_dimensions, NULL, NULL, NULL},
135         {NULL, NULL, NULL, NULL, NULL}
136 };
137
138
139 PyTypeObject BGL_bufferType = {
140         PyVarObject_HEAD_INIT(NULL, 0)
141         "bgl.Buffer",               /*tp_name */
142         sizeof(Buffer),             /*tp_basicsize */
143         0,                          /*tp_itemsize */
144         (destructor)Buffer_dealloc, /*tp_dealloc */
145         (printfunc)NULL,            /*tp_print */
146         NULL,                       /*tp_getattr */
147         NULL,                       /*tp_setattr */
148         NULL,                       /*tp_compare */
149         (reprfunc) Buffer_repr,     /*tp_repr */
150         NULL,                       /*tp_as_number */
151         &Buffer_SeqMethods,         /*tp_as_sequence */
152         &Buffer_AsMapping,          /* PyMappingMethods *tp_as_mapping; */
153
154         /* More standard operations (here for binary compatibility) */
155
156         NULL, /* hashfunc tp_hash; */
157         NULL,                       /* ternaryfunc tp_call; */
158         NULL,                       /* reprfunc tp_str; */
159         NULL,                       /* getattrofunc tp_getattro; */
160         NULL,                       /* setattrofunc tp_setattro; */
161
162         /* Functions to access object as input/output buffer */
163         NULL,                       /* PyBufferProcs *tp_as_buffer; */
164
165         /*** Flags to define presence of optional/expanded features ***/
166         Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
167
168         NULL,                       /*  char *tp_doc;  Documentation string */
169         /*** Assigned meaning in release 2.0 ***/
170         /* call function for all accessible objects */
171         NULL,                       /* traverseproc tp_traverse; */
172
173         /* delete references to contained objects */
174         NULL,                       /* inquiry tp_clear; */
175
176         /***  Assigned meaning in release 2.1 ***/
177         /*** rich comparisons ***/
178         NULL,                       /* richcmpfunc tp_richcompare; */
179
180         /***  weak reference enabler ***/
181         0,                          /* long tp_weaklistoffset; */
182
183         /*** Added in release 2.2 ***/
184         /*   Iterators */
185         NULL, /* getiterfunc tp_iter; */
186         NULL,                       /* iternextfunc tp_iternext; */
187         /*** Attribute descriptor and subclassing stuff ***/
188         Buffer_methods,             /* struct PyMethodDef *tp_methods; */
189         NULL,                       /* struct PyMemberDef *tp_members; */
190         Buffer_getseters,           /* struct PyGetSetDef *tp_getset; */
191         NULL,                       /*tp_base*/
192         NULL,                       /*tp_dict*/
193         NULL,                       /*tp_descr_get*/
194         NULL,                       /*tp_descr_set*/
195         0,                          /*tp_dictoffset*/
196         NULL,                       /*tp_init*/
197         NULL,                       /*tp_alloc*/
198         Buffer_new,                 /*tp_new*/
199         NULL,                       /*tp_free*/
200         NULL,                       /*tp_is_gc*/
201         NULL,                       /*tp_bases*/
202         NULL,                       /*tp_mro*/
203         NULL,                       /*tp_cache*/
204         NULL,                       /*tp_subclasses*/
205         NULL,                       /*tp_weaklist*/
206         NULL                        /*tp_del*/
207 };
208
209 #define BGL_Wrap(nargs, funcname, ret, arg_list)                              \
210 static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args)   \
211 {                                                                             \
212         arg_def##nargs arg_list;                                                  \
213         ret_def_##ret;                                                            \
214         if (!PyArg_ParseTuple(args,                                               \
215                               arg_str##nargs arg_list,                            \
216                               arg_ref##nargs arg_list))                           \
217         {                                                                         \
218                 return NULL;                                                          \
219         }                                                                         \
220         ret_set_##ret gl##funcname (arg_var##nargs arg_list);                     \
221         ret_ret_##ret;                                                            \
222 }
223
224 #define BGLU_Wrap(nargs, funcname, ret, arg_list)                             \
225 static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args)   \
226 {                                                                             \
227         arg_def##nargs arg_list;                                                  \
228         ret_def_##ret;                                                            \
229         if (!PyArg_ParseTuple(args,                                               \
230                                                   arg_str##nargs arg_list,                            \
231                                                   arg_ref##nargs arg_list))                           \
232         {                                                                         \
233                 return NULL;                                                          \
234         }                                                                         \
235         ret_set_##ret glu##funcname (arg_var##nargs arg_list);                    \
236         ret_ret_##ret;                                                            \
237 }
238
239 /********/
240 int BGL_typeSize(int type)
241 {
242         switch (type) {
243                 case GL_BYTE:
244                         return sizeof(char);
245                 case GL_SHORT:
246                         return sizeof(short);
247                 case GL_INT:
248                         return sizeof(int);
249                 case GL_FLOAT:
250                         return sizeof(float);
251                 case GL_DOUBLE:
252                         return sizeof(double);
253         }
254         return -1;
255 }
256
257 Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuffer)
258 {
259         Buffer *buffer;
260         void *buf = NULL;
261         int i, size, length;
262
263         length = 1;
264         for (i = 0; i < ndimensions; i++) {
265                 length *= dimensions[i];
266         }
267
268         size = BGL_typeSize(type);
269
270         buf = MEM_mallocN(length * size, "Buffer buffer");
271
272         buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
273         buffer->parent = NULL;
274         buffer->ndimensions = ndimensions;
275         buffer->dimensions = MEM_mallocN(ndimensions * sizeof(int), "Buffer dimensions");
276         memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int));
277         buffer->type = type;
278         buffer->buf.asvoid = buf;
279
280         if (initbuffer) {
281                 memcpy(buffer->buf.asvoid, initbuffer, length * size);
282         }
283         else {
284                 memset(buffer->buf.asvoid, 0, length * size);
285         }
286         return buffer;
287 }
288
289
290 #define MAX_DIMENSIONS  256
291 static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
292 {
293         PyObject *length_ob = NULL, *init = NULL;
294         Buffer *buffer;
295         int dimensions[MAX_DIMENSIONS];
296
297         int type;
298         Py_ssize_t i, ndimensions = 0;
299
300         if (kwds && PyDict_Size(kwds)) {
301                 PyErr_SetString(PyExc_TypeError,
302                                 "bgl.Buffer(): takes no keyword args");
303                 return NULL;
304         }
305
306         if (!PyArg_ParseTuple(args, "iO|O: bgl.Buffer", &type, &length_ob, &init)) {
307                 return NULL;
308         }
309         if (!ELEM5(type, GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE)) {
310                 PyErr_SetString(PyExc_AttributeError,
311                                 "invalid first argument type, should be one of "
312                                 "GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE");
313                 return NULL;
314         }
315
316         if (PyLong_Check(length_ob)) {
317                 ndimensions = 1;
318                 if (((dimensions[0] = PyLong_AsLong(length_ob)) < 1)) {
319                         PyErr_SetString(PyExc_AttributeError,
320                                         "dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
321                         return NULL;
322                 }
323         }
324         else if (PySequence_Check(length_ob)) {
325                 ndimensions = PySequence_Size(length_ob);
326                 if (ndimensions > MAX_DIMENSIONS) {
327                         PyErr_SetString(PyExc_AttributeError,
328                                         "too many dimensions, max is "STRINGIFY(MAX_DIMENSIONS));
329                         return NULL;
330                 }
331                 else if (ndimensions < 1) {
332                         PyErr_SetString(PyExc_AttributeError,
333                                         "sequence must have at least one dimension");
334                         return NULL;
335                 }
336                 for (i = 0; i < ndimensions; i++) {
337                         PyObject *ob = PySequence_GetItem(length_ob, i);
338
339                         if (!PyLong_Check(ob))
340                                 dimensions[i] = 1;
341                         else
342                                 dimensions[i] = PyLong_AsLong(ob);
343                         Py_DECREF(ob);
344
345                         if (dimensions[i] < 1) {
346                                 PyErr_SetString(PyExc_AttributeError,
347                                                 "dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
348                                 return NULL;
349                         }
350                 }
351         }
352         else {
353                 PyErr_Format(PyExc_TypeError,
354                              "invalid second argument argument expected a sequence "
355                              "or an int, not a %.200s", Py_TYPE(length_ob)->tp_name);
356                 return NULL;
357         }
358
359         buffer = BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
360         if (init && ndimensions) {
361                 if (Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
362                         Py_DECREF(buffer);
363                         return NULL;
364                 }
365         }
366
367         return (PyObject *)buffer;
368 }
369
370 /*@ Buffer sequence methods */
371
372 static int Buffer_len(Buffer *self)
373 {
374         return self->dimensions[0];
375 }
376
377 static PyObject *Buffer_item(Buffer *self, int i)
378 {
379         if (i >= self->dimensions[0] || i < 0) {
380                 PyErr_SetString(PyExc_IndexError, "array index out of range");
381                 return NULL;
382         }
383
384         if (self->ndimensions == 1) {
385                 switch (self->type) {
386                         case GL_BYTE:   return Py_BuildValue("b", self->buf.asbyte[i]);
387                         case GL_SHORT:  return Py_BuildValue("h", self->buf.asshort[i]);
388                         case GL_INT:    return Py_BuildValue("i", self->buf.asint[i]);
389                         case GL_FLOAT:  return PyFloat_FromDouble(self->buf.asfloat[i]);
390                         case GL_DOUBLE: return Py_BuildValue("d", self->buf.asdouble[i]);
391                 }
392         }
393         else {
394                 Buffer *newbuf;
395                 int j, length, size;
396
397                 length = 1;
398                 for (j = 1; j < self->ndimensions; j++) {
399                         length *= self->dimensions[j];
400                 }
401                 size = BGL_typeSize(self->type);
402
403                 newbuf = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
404
405                 Py_INCREF(self);
406                 newbuf->parent = (PyObject *)self;
407
408                 newbuf->ndimensions = self->ndimensions - 1;
409                 newbuf->type = self->type;
410                 newbuf->buf.asvoid = self->buf.asbyte + i * length * size;
411                 newbuf->dimensions = MEM_mallocN(newbuf->ndimensions * sizeof(int), "Buffer dimensions");
412                 memcpy(newbuf->dimensions, self->dimensions + 1, newbuf->ndimensions * sizeof(int));
413
414                 return (PyObject *)newbuf;
415         }
416
417         return NULL;
418 }
419
420 static PyObject *Buffer_slice(Buffer *self, int begin, int end)
421 {
422         PyObject *list;
423         int count;
424         
425         if (begin < 0) begin = 0;
426         if (end > self->dimensions[0]) end = self->dimensions[0];
427         if (begin > end) begin = end;
428           
429         list = PyList_New(end - begin);
430
431         for (count = begin; count < end; count++) {
432                 PyList_SET_ITEM(list, count - begin, Buffer_item(self, count));
433         }
434         return list;
435 }
436
437 static int Buffer_ass_item(Buffer *self, int i, PyObject *v)
438 {
439         if (i >= self->dimensions[0] || i < 0) {
440                 PyErr_SetString(PyExc_IndexError,
441                                 "array assignment index out of range");
442                 return -1;
443         }
444
445         if (self->ndimensions != 1) {
446                 Buffer *row = (Buffer *)Buffer_item(self, i);
447
448                 if (row) {
449                         int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v);
450                         Py_DECREF(row);
451                         return ret;
452                 }
453                 else {
454                         return -1;
455                 }
456         }
457
458         switch (self->type) {
459                 case GL_BYTE:   return PyArg_Parse(v, "b:Expected ints",   &self->buf.asbyte[i])   ? 0 : -1;
460                 case GL_SHORT:  return PyArg_Parse(v, "h:Expected ints",   &self->buf.asshort[i])  ? 0 : -1;
461                 case GL_INT:    return PyArg_Parse(v, "i:Expected ints",   &self->buf.asint[i])    ? 0 : -1;
462                 case GL_FLOAT:  return PyArg_Parse(v, "f:Expected floats", &self->buf.asfloat[i])  ? 0 : -1;
463                 case GL_DOUBLE: return PyArg_Parse(v, "d:Expected floats", &self->buf.asdouble[i]) ? 0 : -1;
464                 default:        return 0; /* should never happen */
465         }
466 }
467
468 static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq)
469 {
470         PyObject *item;
471         int count, err = 0;
472         
473         if (begin < 0) begin = 0;
474         if (end > self->dimensions[0]) end = self->dimensions[0];
475         if (begin > end) begin = end;
476         
477         if (!PySequence_Check(seq)) {
478                 PyErr_Format(PyExc_TypeError,
479                              "buffer[:] = value, invalid assignment. "
480                              "Expected a sequence, not an %.200s type",
481                              Py_TYPE(seq)->tp_name);
482                 return -1;
483         }
484
485         /* re-use count var */
486         if ((count = PySequence_Size(seq)) != (end - begin)) {
487                 PyErr_Format(PyExc_TypeError,
488                              "buffer[:] = value, size mismatch in assignment. "
489                              "Expected: %d (given: %d)", count, end - begin);
490                 return -1;
491         }
492         
493         for (count = begin; count < end; count++) {
494                 item = PySequence_GetItem(seq, count - begin);
495                 if (item) {
496                         err = Buffer_ass_item(self, count, item);
497                         Py_DECREF(item);
498                 }
499                 else {
500                         err = -1;
501                 }
502                 if (err) {
503                         break;
504                 }
505         }
506         return err;
507 }
508
509 static PyObject *Buffer_subscript(Buffer *self, PyObject *item)
510 {
511         if (PyIndex_Check(item)) {
512                 Py_ssize_t i;
513                 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
514                 if (i == -1 && PyErr_Occurred())
515                         return NULL;
516                 if (i < 0)
517                         i += self->dimensions[0];
518                 return Buffer_item(self, i);
519         }
520         else if (PySlice_Check(item)) {
521                 Py_ssize_t start, stop, step, slicelength;
522
523                 if (PySlice_GetIndicesEx((void *)item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
524                         return NULL;
525
526                 if (slicelength <= 0) {
527                         return PyTuple_New(0);
528                 }
529                 else if (step == 1) {
530                         return Buffer_slice(self, start, stop);
531                 }
532                 else {
533                         PyErr_SetString(PyExc_IndexError,
534                                         "slice steps not supported with vectors");
535                         return NULL;
536                 }
537         }
538         else {
539                 PyErr_Format(PyExc_TypeError,
540                              "buffer indices must be integers, not %.200s",
541                              Py_TYPE(item)->tp_name);
542                 return NULL;
543         }
544 }
545
546 static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value)
547 {
548         if (PyIndex_Check(item)) {
549                 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
550                 if (i == -1 && PyErr_Occurred())
551                         return -1;
552                 if (i < 0)
553                         i += self->dimensions[0];
554                 return Buffer_ass_item(self, i, value);
555         }
556         else if (PySlice_Check(item)) {
557                 Py_ssize_t start, stop, step, slicelength;
558
559                 if (PySlice_GetIndicesEx((void *)item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
560                         return -1;
561
562                 if (step == 1)
563                         return Buffer_ass_slice(self, start, stop, value);
564                 else {
565                         PyErr_SetString(PyExc_IndexError,
566                                         "slice steps not supported with vectors");
567                         return -1;
568                 }
569         }
570         else {
571                 PyErr_Format(PyExc_TypeError,
572                              "buffer indices must be integers, not %.200s",
573                              Py_TYPE(item)->tp_name);
574                 return -1;
575         }
576 }
577
578
579 static void Buffer_dealloc(Buffer *self)
580 {
581         if (self->parent) {
582                 Py_DECREF(self->parent);
583         }
584         else {
585                 MEM_freeN(self->buf.asvoid);
586         }
587
588         MEM_freeN(self->dimensions);
589
590         PyObject_DEL(self);
591 }
592
593
594 static PyObject *Buffer_repr(Buffer *self)
595 {
596         PyObject *list = Buffer_to_list_recursive(self);
597         PyObject *repr;
598         const char *typestr;
599
600         switch (self->type) {
601                 case GL_BYTE:   typestr = "GL_BYTE"; break;
602                 case GL_SHORT:  typestr = "GL_SHORT"; break;
603                 case GL_INT:    typestr = "GL_BYTE"; break;
604                 case GL_FLOAT:  typestr = "GL_FLOAT"; break;
605                 case GL_DOUBLE: typestr = "GL_DOUBLE"; break;
606                 default:        typestr = "UNKNOWN"; break;
607         }
608
609         repr = PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list);
610         Py_DECREF(list);
611
612         return repr;
613 }
614
615
616 BGL_Wrap(2, Accum,          void,     (GLenum, GLfloat))
617 BGL_Wrap(1, ActiveTexture,  void,     (GLenum))
618 BGL_Wrap(2, AlphaFunc,      void,     (GLenum, GLclampf))
619 BGL_Wrap(3, AreTexturesResident,  GLboolean,  (GLsizei, GLuintP, GLbooleanP))
620 BGL_Wrap(2, AttachShader,   void,       (GLuint, GLuint))
621 BGL_Wrap(1, Begin,          void,     (GLenum))
622 BGL_Wrap(2, BindTexture,    void,   (GLenum, GLuint))
623 BGL_Wrap(7, Bitmap,         void,     (GLsizei, GLsizei, GLfloat,
624                                        GLfloat, GLfloat, GLfloat, GLubyteP))
625 BGL_Wrap(2, BlendFunc,        void,     (GLenum, GLenum))
626 BGL_Wrap(1, CallList,         void,     (GLuint))
627 BGL_Wrap(3, CallLists,        void,     (GLsizei, GLenum, GLvoidP))
628 BGL_Wrap(1, Clear,            void,     (GLbitfield))
629 BGL_Wrap(4, ClearAccum,       void,     (GLfloat, GLfloat, GLfloat, GLfloat))
630 BGL_Wrap(4, ClearColor,       void,     (GLclampf, GLclampf, GLclampf, GLclampf))
631 BGL_Wrap(1, ClearDepth,       void,     (GLclampd))
632 BGL_Wrap(1, ClearIndex,       void,     (GLfloat))
633 BGL_Wrap(1, ClearStencil,     void,     (GLint))
634 BGL_Wrap(2, ClipPlane,        void,     (GLenum, GLdoubleP))
635 BGL_Wrap(3, Color3b,          void,     (GLbyte, GLbyte, GLbyte))
636 BGL_Wrap(1, Color3bv,         void,     (GLbyteP))
637 BGL_Wrap(3, Color3d,          void,     (GLdouble, GLdouble, GLdouble))
638 BGL_Wrap(1, Color3dv,         void,     (GLdoubleP))
639 BGL_Wrap(3, Color3f,          void,     (GLfloat, GLfloat, GLfloat))
640 BGL_Wrap(1, Color3fv,         void,     (GLfloatP))
641 BGL_Wrap(3, Color3i,          void,     (GLint, GLint, GLint))
642 BGL_Wrap(1, Color3iv,         void,     (GLintP))
643 BGL_Wrap(3, Color3s,          void,     (GLshort, GLshort, GLshort))
644 BGL_Wrap(1, Color3sv,         void,     (GLshortP))
645 BGL_Wrap(3, Color3ub,         void,     (GLubyte, GLubyte, GLubyte))
646 BGL_Wrap(1, Color3ubv,        void,     (GLubyteP))
647 BGL_Wrap(3, Color3ui,         void,     (GLuint, GLuint, GLuint))
648 BGL_Wrap(1, Color3uiv,        void,     (GLuintP))
649 BGL_Wrap(3, Color3us,         void,     (GLushort, GLushort, GLushort))
650 BGL_Wrap(1, Color3usv,        void,     (GLushortP))
651 BGL_Wrap(4, Color4b,          void,     (GLbyte, GLbyte, GLbyte, GLbyte))
652 BGL_Wrap(1, Color4bv,         void,     (GLbyteP))
653 BGL_Wrap(4, Color4d,          void,     (GLdouble, GLdouble, GLdouble, GLdouble))
654 BGL_Wrap(1, Color4dv,         void,     (GLdoubleP))
655 BGL_Wrap(4, Color4f,          void,     (GLfloat, GLfloat, GLfloat, GLfloat))
656 BGL_Wrap(1, Color4fv,         void,     (GLfloatP))
657 BGL_Wrap(4, Color4i,          void,     (GLint, GLint, GLint, GLint))
658 BGL_Wrap(1, Color4iv,         void,     (GLintP))
659 BGL_Wrap(4, Color4s,          void,     (GLshort, GLshort, GLshort, GLshort))
660 BGL_Wrap(1, Color4sv,         void,     (GLshortP))
661 BGL_Wrap(4, Color4ub,         void,     (GLubyte, GLubyte, GLubyte, GLubyte))
662 BGL_Wrap(1, Color4ubv,        void,     (GLubyteP))
663 BGL_Wrap(4, Color4ui,         void,     (GLuint, GLuint, GLuint, GLuint))
664 BGL_Wrap(1, Color4uiv,        void,     (GLuintP))
665 BGL_Wrap(4, Color4us,         void,     (GLushort, GLushort, GLushort, GLushort))
666 BGL_Wrap(1, Color4usv,        void,     (GLushortP))
667 BGL_Wrap(4, ColorMask,        void,     (GLboolean, GLboolean, GLboolean, GLboolean))
668 BGL_Wrap(2, ColorMaterial,    void,     (GLenum, GLenum))
669 BGL_Wrap(1, CompileShader,    void,     (GLuint))
670 BGL_Wrap(5, CopyPixels,       void,     (GLint, GLint, GLsizei, GLsizei, GLenum))
671 BGL_Wrap(8, CopyTexImage2D,   void,     (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
672 BGL_Wrap(1, CreateProgram,    GLuint,   (void))
673 BGL_Wrap(1, CreateShader,     GLuint,   (GLenum))
674 BGL_Wrap(1, CullFace,         void,     (GLenum))
675 BGL_Wrap(2, DeleteLists,      void,     (GLuint, GLsizei))
676 BGL_Wrap(1, DeleteProgram,    void,     (GLuint))
677 BGL_Wrap(1, DeleteShader,     void,     (GLuint))
678 BGL_Wrap(2, DeleteTextures,   void,   (GLsizei, GLuintP))
679 BGL_Wrap(1, DepthFunc,        void,     (GLenum))
680 BGL_Wrap(1, DepthMask,        void,     (GLboolean))
681 BGL_Wrap(2, DepthRange,       void,     (GLclampd, GLclampd))
682 BGL_Wrap(2, DetachShader,     void,     (GLuint, GLuint))
683 BGL_Wrap(1, Disable,          void,     (GLenum))
684 BGL_Wrap(1, DrawBuffer,       void,     (GLenum))
685 BGL_Wrap(5, DrawPixels,       void,     (GLsizei, GLsizei, GLenum, GLenum, GLvoidP))
686 BGL_Wrap(1, EdgeFlag,         void,     (GLboolean))
687 BGL_Wrap(1, EdgeFlagv,        void,     (GLbooleanP))
688 BGL_Wrap(1, Enable,           void,     (GLenum))
689 BGL_Wrap(1, End,              void,     (void))
690 BGL_Wrap(1, EndList,          void,     (void))
691 BGL_Wrap(1, EvalCoord1d,      void,     (GLdouble))
692 BGL_Wrap(1, EvalCoord1dv,     void,     (GLdoubleP))
693 BGL_Wrap(1, EvalCoord1f,      void,     (GLfloat))
694 BGL_Wrap(1, EvalCoord1fv,     void,     (GLfloatP))
695 BGL_Wrap(2, EvalCoord2d,      void,     (GLdouble, GLdouble))
696 BGL_Wrap(1, EvalCoord2dv,     void,     (GLdoubleP))
697 BGL_Wrap(2, EvalCoord2f,      void,     (GLfloat, GLfloat))
698 BGL_Wrap(1, EvalCoord2fv,     void,     (GLfloatP))
699 BGL_Wrap(3, EvalMesh1,        void,     (GLenum, GLint, GLint))
700 BGL_Wrap(5, EvalMesh2,        void,     (GLenum, GLint, GLint, GLint, GLint))
701 BGL_Wrap(1, EvalPoint1,       void,     (GLint))
702 BGL_Wrap(2, EvalPoint2,       void,     (GLint, GLint))
703 BGL_Wrap(3, FeedbackBuffer,   void,     (GLsizei, GLenum, GLfloatP))
704 BGL_Wrap(1, Finish,           void,     (void))
705 BGL_Wrap(1, Flush,            void,     (void))
706 BGL_Wrap(2, Fogf,             void,     (GLenum, GLfloat))
707 BGL_Wrap(2, Fogfv,            void,     (GLenum, GLfloatP))
708 BGL_Wrap(2, Fogi,             void,     (GLenum, GLint))
709 BGL_Wrap(2, Fogiv,            void,     (GLenum, GLintP))
710 BGL_Wrap(1, FrontFace,        void,     (GLenum))
711 BGL_Wrap(6, Frustum,          void,     (GLdouble, GLdouble,
712                                          GLdouble, GLdouble, GLdouble, GLdouble))
713 BGL_Wrap(1, GenLists,         GLuint,   (GLsizei))
714 BGL_Wrap(2, GenTextures,      void,   (GLsizei, GLuintP))
715 BGL_Wrap(4, GetAttachedShaders, void,   (GLuint, GLsizei, GLsizeiP, GLuintP))
716 BGL_Wrap(2, GetBooleanv,      void,     (GLenum, GLbooleanP))
717 BGL_Wrap(2, GetClipPlane,     void,     (GLenum, GLdoubleP))
718 BGL_Wrap(2, GetDoublev,       void,     (GLenum, GLdoubleP))
719 BGL_Wrap(1, GetError,         GLenum,   (void))
720 BGL_Wrap(2, GetFloatv,        void,     (GLenum, GLfloatP))
721 BGL_Wrap(2, GetIntegerv,      void,     (GLenum, GLintP))
722 BGL_Wrap(3, GetLightfv,       void,     (GLenum, GLenum, GLfloatP))
723 BGL_Wrap(3, GetLightiv,       void,     (GLenum, GLenum, GLintP))
724 BGL_Wrap(3, GetMapdv,         void,     (GLenum, GLenum, GLdoubleP))
725 BGL_Wrap(3, GetMapfv,         void,     (GLenum, GLenum, GLfloatP))
726 BGL_Wrap(3, GetMapiv,         void,     (GLenum, GLenum, GLintP))
727 BGL_Wrap(3, GetMaterialfv,    void,     (GLenum, GLenum, GLfloatP))
728 BGL_Wrap(3, GetMaterialiv,    void,     (GLenum, GLenum, GLintP))
729 BGL_Wrap(2, GetPixelMapfv,    void,     (GLenum, GLfloatP))
730 BGL_Wrap(2, GetPixelMapuiv,   void,     (GLenum, GLuintP))
731 BGL_Wrap(2, GetPixelMapusv,   void,     (GLenum, GLushortP))
732 BGL_Wrap(1, GetPolygonStipple, void,     (GLubyteP))
733 BGL_Wrap(4, GetProgramInfoLog, void,    (GLuint, GLsizei, GLsizeiP, GLcharP))
734 BGL_Wrap(3, GetProgramiv,     void,     (GLuint, GLenum, GLintP))
735 BGL_Wrap(4, GetShaderInfoLog, void,     (GLuint, GLsizei, GLsizeiP, GLcharP))
736 BGL_Wrap(3, GetShaderiv,      void,     (GLuint, GLenum, GLintP))
737 BGL_Wrap(4, GetShaderSource,  void,     (GLuint, GLsizei, GLsizeiP, GLcharP))
738 BGL_Wrap(1, GetString,        GLstring,   (GLenum))
739 BGL_Wrap(3, GetTexEnvfv,      void,     (GLenum, GLenum, GLfloatP))
740 BGL_Wrap(3, GetTexEnviv,      void,     (GLenum, GLenum, GLintP))
741 BGL_Wrap(3, GetTexGendv,      void,     (GLenum, GLenum, GLdoubleP))
742 BGL_Wrap(3, GetTexGenfv,      void,     (GLenum, GLenum, GLfloatP))
743 BGL_Wrap(3, GetTexGeniv,      void,     (GLenum, GLenum, GLintP))
744 BGL_Wrap(5, GetTexImage,      void,     (GLenum, GLint, GLenum, GLenum, GLvoidP))
745 BGL_Wrap(4, GetTexLevelParameterfv, void,     (GLenum, GLint, GLenum, GLfloatP))
746 BGL_Wrap(4, GetTexLevelParameteriv, void,     (GLenum, GLint, GLenum, GLintP))
747 BGL_Wrap(3, GetTexParameterfv,    void,     (GLenum, GLenum, GLfloatP))
748 BGL_Wrap(3, GetTexParameteriv,    void,     (GLenum, GLenum, GLintP))
749 BGL_Wrap(2, GetUniformLocation, GLint, (GLuint, GLstring))
750 BGL_Wrap(2, Hint,           void,     (GLenum, GLenum))
751 BGL_Wrap(1, IndexMask,      void,     (GLuint))
752 BGL_Wrap(1, Indexd,         void,     (GLdouble))
753 BGL_Wrap(1, Indexdv,        void,     (GLdoubleP))
754 BGL_Wrap(1, Indexf,         void,     (GLfloat))
755 BGL_Wrap(1, Indexfv,        void,     (GLfloatP))
756 BGL_Wrap(1, Indexi,         void,     (GLint))
757 BGL_Wrap(1, Indexiv,        void,     (GLintP))
758 BGL_Wrap(1, Indexs,         void,     (GLshort))
759 BGL_Wrap(1, Indexsv,        void,     (GLshortP))
760 BGL_Wrap(1, InitNames,      void,     (void))
761 BGL_Wrap(1, IsEnabled,      GLboolean,  (GLenum))
762 BGL_Wrap(1, IsList,         GLboolean,  (GLuint))
763 BGL_Wrap(1, IsProgram,      GLboolean,  (GLuint))
764 BGL_Wrap(1, IsShader,       GLboolean,  (GLuint))
765 BGL_Wrap(1, IsTexture,      GLboolean,  (GLuint))
766 BGL_Wrap(2, LightModelf,    void,     (GLenum, GLfloat))
767 BGL_Wrap(2, LightModelfv,   void,     (GLenum, GLfloatP))
768 BGL_Wrap(2, LightModeli,    void,     (GLenum, GLint))
769 BGL_Wrap(2, LightModeliv,   void,     (GLenum, GLintP))
770 BGL_Wrap(3, Lightf,         void,     (GLenum, GLenum, GLfloat))
771 BGL_Wrap(3, Lightfv,        void,     (GLenum, GLenum, GLfloatP))
772 BGL_Wrap(3, Lighti,         void,     (GLenum, GLenum, GLint))
773 BGL_Wrap(3, Lightiv,        void,     (GLenum, GLenum, GLintP))
774 BGL_Wrap(2, LineStipple,    void,     (GLint, GLushort))
775 BGL_Wrap(1, LineWidth,      void,     (GLfloat))
776 BGL_Wrap(1, LinkProgram,   void,      (GLuint))
777 BGL_Wrap(1, ListBase,       void,     (GLuint))
778 BGL_Wrap(1, LoadIdentity,   void,     (void))
779 BGL_Wrap(1, LoadMatrixd,    void,     (GLdoubleP))
780 BGL_Wrap(1, LoadMatrixf,    void,     (GLfloatP))
781 BGL_Wrap(1, LoadName,       void,     (GLuint))
782 BGL_Wrap(1, LogicOp,        void,     (GLenum))
783 BGL_Wrap(6, Map1d,          void,     (GLenum, GLdouble, GLdouble,
784                                        GLint, GLint, GLdoubleP))
785 BGL_Wrap(6, Map1f,          void,     (GLenum, GLfloat, GLfloat,
786                                        GLint, GLint, GLfloatP))
787 BGL_Wrap(10, Map2d,         void,     (GLenum, GLdouble, GLdouble,
788                                        GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdoubleP))
789 BGL_Wrap(10, Map2f,         void,     (GLenum, GLfloat, GLfloat,
790                                        GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloatP))
791 BGL_Wrap(3, MapGrid1d,        void,     (GLint, GLdouble, GLdouble))
792 BGL_Wrap(3, MapGrid1f,        void,     (GLint, GLfloat, GLfloat))
793 BGL_Wrap(6, MapGrid2d,        void,     (GLint, GLdouble, GLdouble,
794                                          GLint, GLdouble, GLdouble))
795 BGL_Wrap(6, MapGrid2f,        void,     (GLint, GLfloat, GLfloat,
796                                          GLint, GLfloat, GLfloat))
797 BGL_Wrap(3, Materialf,        void,     (GLenum, GLenum, GLfloat))
798 BGL_Wrap(3, Materialfv,       void,     (GLenum, GLenum, GLfloatP))
799 BGL_Wrap(3, Materiali,        void,     (GLenum, GLenum, GLint))
800 BGL_Wrap(3, Materialiv,       void,     (GLenum, GLenum, GLintP))
801 BGL_Wrap(1, MatrixMode,       void,     (GLenum))
802 BGL_Wrap(1, MultMatrixd,      void,     (GLdoubleP))
803 BGL_Wrap(1, MultMatrixf,      void,     (GLfloatP))
804 BGL_Wrap(2, NewList,          void,     (GLuint, GLenum))
805 BGL_Wrap(3, Normal3b,         void,     (GLbyte, GLbyte, GLbyte))
806 BGL_Wrap(1, Normal3bv,        void,     (GLbyteP))
807 BGL_Wrap(3, Normal3d,         void,     (GLdouble, GLdouble, GLdouble))
808 BGL_Wrap(1, Normal3dv,        void,     (GLdoubleP))
809 BGL_Wrap(3, Normal3f,         void,     (GLfloat, GLfloat, GLfloat))
810 BGL_Wrap(1, Normal3fv,        void,     (GLfloatP))
811 BGL_Wrap(3, Normal3i,         void,     (GLint, GLint, GLint))
812 BGL_Wrap(1, Normal3iv,        void,     (GLintP))
813 BGL_Wrap(3, Normal3s,         void,     (GLshort, GLshort, GLshort))
814 BGL_Wrap(1, Normal3sv,        void,     (GLshortP))
815 BGL_Wrap(6, Ortho,            void,     (GLdouble, GLdouble,
816                                          GLdouble, GLdouble, GLdouble, GLdouble))
817 BGL_Wrap(1, PassThrough,      void,     (GLfloat))
818 BGL_Wrap(3, PixelMapfv,       void,     (GLenum, GLint, GLfloatP))
819 BGL_Wrap(3, PixelMapuiv,      void,     (GLenum, GLint, GLuintP))
820 BGL_Wrap(3, PixelMapusv,      void,     (GLenum, GLint, GLushortP))
821 BGL_Wrap(2, PixelStoref,      void,     (GLenum, GLfloat))
822 BGL_Wrap(2, PixelStorei,      void,     (GLenum, GLint))
823 BGL_Wrap(2, PixelTransferf,   void,     (GLenum, GLfloat))
824 BGL_Wrap(2, PixelTransferi,   void,     (GLenum, GLint))
825 BGL_Wrap(2, PixelZoom,        void,     (GLfloat, GLfloat))
826 BGL_Wrap(1, PointSize,        void,     (GLfloat))
827 BGL_Wrap(2, PolygonMode,      void,     (GLenum, GLenum))
828 BGL_Wrap(2, PolygonOffset,    void,     (GLfloat, GLfloat))
829 BGL_Wrap(1, PolygonStipple,   void,     (GLubyteP))
830 BGL_Wrap(1, PopAttrib,        void,     (void))
831 BGL_Wrap(1, PopClientAttrib,  void,     (void))
832 BGL_Wrap(1, PopMatrix,        void,     (void))
833 BGL_Wrap(1, PopName,          void,     (void))
834 BGL_Wrap(3, PrioritizeTextures,   void,   (GLsizei, GLuintP, GLclampfP))
835 BGL_Wrap(1, PushAttrib,       void,     (GLbitfield))
836 BGL_Wrap(1, PushClientAttrib, void,     (GLbitfield))
837 BGL_Wrap(1, PushMatrix,       void,     (void))
838 BGL_Wrap(1, PushName,         void,     (GLuint))
839 BGL_Wrap(2, RasterPos2d,      void,     (GLdouble, GLdouble))
840 BGL_Wrap(1, RasterPos2dv,     void,     (GLdoubleP))
841 BGL_Wrap(2, RasterPos2f,      void,     (GLfloat, GLfloat))
842 BGL_Wrap(1, RasterPos2fv,     void,     (GLfloatP))
843 BGL_Wrap(2, RasterPos2i,      void,     (GLint, GLint))
844 BGL_Wrap(1, RasterPos2iv,     void,     (GLintP))
845 BGL_Wrap(2, RasterPos2s,      void,     (GLshort, GLshort))
846 BGL_Wrap(1, RasterPos2sv,     void,     (GLshortP))
847 BGL_Wrap(3, RasterPos3d,      void,     (GLdouble, GLdouble, GLdouble))
848 BGL_Wrap(1, RasterPos3dv,     void,     (GLdoubleP))
849 BGL_Wrap(3, RasterPos3f,      void,     (GLfloat, GLfloat, GLfloat))
850 BGL_Wrap(1, RasterPos3fv,     void,     (GLfloatP))
851 BGL_Wrap(3, RasterPos3i,      void,     (GLint, GLint, GLint))
852 BGL_Wrap(1, RasterPos3iv,     void,     (GLintP))
853 BGL_Wrap(3, RasterPos3s,      void,     (GLshort, GLshort, GLshort))
854 BGL_Wrap(1, RasterPos3sv,     void,     (GLshortP))
855 BGL_Wrap(4, RasterPos4d,      void,     (GLdouble, GLdouble, GLdouble, GLdouble))
856 BGL_Wrap(1, RasterPos4dv,     void,     (GLdoubleP))
857 BGL_Wrap(4, RasterPos4f,      void,     (GLfloat, GLfloat, GLfloat, GLfloat))
858 BGL_Wrap(1, RasterPos4fv,     void,     (GLfloatP))
859 BGL_Wrap(4, RasterPos4i,      void,     (GLint, GLint, GLint, GLint))
860 BGL_Wrap(1, RasterPos4iv,     void,     (GLintP))
861 BGL_Wrap(4, RasterPos4s,      void,     (GLshort, GLshort, GLshort, GLshort))
862 BGL_Wrap(1, RasterPos4sv,     void,     (GLshortP))
863 BGL_Wrap(1, ReadBuffer,       void,     (GLenum))
864 BGL_Wrap(7, ReadPixels,       void,     (GLint, GLint, GLsizei,
865                                          GLsizei, GLenum, GLenum, GLvoidP))
866 BGL_Wrap(4, Rectd,          void,     (GLdouble, GLdouble, GLdouble, GLdouble))
867 BGL_Wrap(2, Rectdv,         void,     (GLdoubleP, GLdoubleP))
868 BGL_Wrap(4, Rectf,          void,     (GLfloat, GLfloat, GLfloat, GLfloat))
869 BGL_Wrap(2, Rectfv,         void,     (GLfloatP, GLfloatP))
870 BGL_Wrap(4, Recti,          void,     (GLint, GLint, GLint, GLint))
871 BGL_Wrap(2, Rectiv,         void,     (GLintP, GLintP))
872 BGL_Wrap(4, Rects,          void,     (GLshort, GLshort, GLshort, GLshort))
873 BGL_Wrap(2, Rectsv,         void,     (GLshortP, GLshortP))
874 BGL_Wrap(1, RenderMode,     GLint,    (GLenum))
875 BGL_Wrap(4, Rotated,        void,     (GLdouble, GLdouble, GLdouble, GLdouble))
876 BGL_Wrap(4, Rotatef,        void,     (GLfloat, GLfloat, GLfloat, GLfloat))
877 BGL_Wrap(3, Scaled,         void,     (GLdouble, GLdouble, GLdouble))
878 BGL_Wrap(3, Scalef,         void,     (GLfloat, GLfloat, GLfloat))
879 BGL_Wrap(4, Scissor,        void,     (GLint, GLint, GLsizei, GLsizei))
880 BGL_Wrap(2, SelectBuffer,   void,     (GLsizei, GLuintP))
881 BGL_Wrap(1, ShadeModel,       void,     (GLenum))
882 BGL_Wrap(3, StencilFunc,      void,     (GLenum, GLint, GLuint))
883 BGL_Wrap(1, StencilMask,      void,     (GLuint))
884 BGL_Wrap(3, StencilOp,        void,     (GLenum, GLenum, GLenum))
885 BGL_Wrap(1, TexCoord1d,       void,     (GLdouble))
886 BGL_Wrap(1, TexCoord1dv,      void,     (GLdoubleP))
887 BGL_Wrap(1, TexCoord1f,       void,     (GLfloat))
888 BGL_Wrap(1, TexCoord1fv,      void,     (GLfloatP))
889 BGL_Wrap(1, TexCoord1i,       void,     (GLint))
890 BGL_Wrap(1, TexCoord1iv,      void,     (GLintP))
891 BGL_Wrap(1, TexCoord1s,       void,     (GLshort))
892 BGL_Wrap(1, TexCoord1sv,      void,     (GLshortP))
893 BGL_Wrap(2, TexCoord2d,       void,     (GLdouble, GLdouble))
894 BGL_Wrap(1, TexCoord2dv,      void,     (GLdoubleP))
895 BGL_Wrap(2, TexCoord2f,       void,     (GLfloat, GLfloat))
896 BGL_Wrap(1, TexCoord2fv,      void,     (GLfloatP))
897 BGL_Wrap(2, TexCoord2i,       void,     (GLint, GLint))
898 BGL_Wrap(1, TexCoord2iv,      void,     (GLintP))
899 BGL_Wrap(2, TexCoord2s,       void,     (GLshort, GLshort))
900 BGL_Wrap(1, TexCoord2sv,      void,     (GLshortP))
901 BGL_Wrap(3, TexCoord3d,       void,     (GLdouble, GLdouble, GLdouble))
902 BGL_Wrap(1, TexCoord3dv,      void,     (GLdoubleP))
903 BGL_Wrap(3, TexCoord3f,       void,     (GLfloat, GLfloat, GLfloat))
904 BGL_Wrap(1, TexCoord3fv,      void,     (GLfloatP))
905 BGL_Wrap(3, TexCoord3i,       void,     (GLint, GLint, GLint))
906 BGL_Wrap(1, TexCoord3iv,      void,     (GLintP))
907 BGL_Wrap(3, TexCoord3s,       void,     (GLshort, GLshort, GLshort))
908 BGL_Wrap(1, TexCoord3sv,      void,     (GLshortP))
909 BGL_Wrap(4, TexCoord4d,       void,     (GLdouble, GLdouble, GLdouble, GLdouble))
910 BGL_Wrap(1, TexCoord4dv,      void,     (GLdoubleP))
911 BGL_Wrap(4, TexCoord4f,       void,     (GLfloat, GLfloat, GLfloat, GLfloat))
912 BGL_Wrap(1, TexCoord4fv,      void,     (GLfloatP))
913 BGL_Wrap(4, TexCoord4i,       void,     (GLint, GLint, GLint, GLint))
914 BGL_Wrap(1, TexCoord4iv,      void,     (GLintP))
915 BGL_Wrap(4, TexCoord4s,       void,     (GLshort, GLshort, GLshort, GLshort))
916 BGL_Wrap(1, TexCoord4sv,      void,     (GLshortP))
917 BGL_Wrap(3, TexEnvf,        void,     (GLenum, GLenum, GLfloat))
918 BGL_Wrap(3, TexEnvfv,       void,     (GLenum, GLenum, GLfloatP))
919 BGL_Wrap(3, TexEnvi,        void,     (GLenum, GLenum, GLint))
920 BGL_Wrap(3, TexEnviv,       void,     (GLenum, GLenum, GLintP))
921 BGL_Wrap(3, TexGend,        void,     (GLenum, GLenum, GLdouble))
922 BGL_Wrap(3, TexGendv,       void,     (GLenum, GLenum, GLdoubleP))
923 BGL_Wrap(3, TexGenf,        void,     (GLenum, GLenum, GLfloat))
924 BGL_Wrap(3, TexGenfv,       void,     (GLenum, GLenum, GLfloatP))
925 BGL_Wrap(3, TexGeni,        void,     (GLenum, GLenum, GLint))
926 BGL_Wrap(3, TexGeniv,       void,     (GLenum, GLenum, GLintP))
927 BGL_Wrap(8, TexImage1D,     void,     (GLenum, GLint, GLint,
928                                        GLsizei, GLint, GLenum, GLenum, GLvoidP))
929 BGL_Wrap(9, TexImage2D,     void,     (GLenum, GLint, GLint,
930                                        GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP))
931 BGL_Wrap(3, TexParameterf,      void,     (GLenum, GLenum, GLfloat))
932 BGL_Wrap(3, TexParameterfv,     void,     (GLenum, GLenum, GLfloatP))
933 BGL_Wrap(3, TexParameteri,      void,     (GLenum, GLenum, GLint))
934 BGL_Wrap(3, TexParameteriv,     void,     (GLenum, GLenum, GLintP))
935 BGL_Wrap(3, Translated,         void,     (GLdouble, GLdouble, GLdouble))
936 BGL_Wrap(3, Translatef,         void,     (GLfloat, GLfloat, GLfloat))
937 BGL_Wrap(2, Uniform1f,          void,     (GLint, GLfloat))
938 BGL_Wrap(3, Uniform2f,          void,     (GLint, GLfloat, GLfloat))
939 BGL_Wrap(4, Uniform3f,          void,     (GLint, GLfloat, GLfloat, GLfloat))
940 BGL_Wrap(5, Uniform4f,          void,     (GLint, GLfloat, GLfloat, GLfloat, GLfloat))
941 BGL_Wrap(3, Uniform1fv,         void,     (GLint, GLsizei, GLfloatP))
942 BGL_Wrap(3, Uniform2fv,         void,     (GLint, GLsizei, GLfloatP))
943 BGL_Wrap(3, Uniform3fv,         void,     (GLint, GLsizei, GLfloatP))
944 BGL_Wrap(3, Uniform4fv,         void,     (GLint, GLsizei, GLfloatP))
945 BGL_Wrap(2, Uniform1i,          void,     (GLint, GLint))
946 BGL_Wrap(3, Uniform2i,          void,     (GLint, GLint, GLint))
947 BGL_Wrap(4, Uniform3i,          void,     (GLint, GLint, GLint, GLint))
948 BGL_Wrap(5, Uniform4i,          void,     (GLint, GLint, GLint, GLint, GLint))
949 BGL_Wrap(3, Uniform1iv,         void,     (GLint, GLsizei, GLintP))
950 BGL_Wrap(3, Uniform2iv,         void,     (GLint, GLsizei, GLintP))
951 BGL_Wrap(3, Uniform3iv,         void,     (GLint, GLsizei, GLintP))
952 BGL_Wrap(3, Uniform4iv,         void,     (GLint, GLsizei, GLintP))
953 BGL_Wrap(4, UniformMatrix2fv,   void,     (GLint, GLsizei, GLboolean, GLfloatP))
954 BGL_Wrap(4, UniformMatrix3fv,   void,     (GLint, GLsizei, GLboolean, GLfloatP))
955 BGL_Wrap(4, UniformMatrix4fv,   void,     (GLint, GLsizei, GLboolean, GLfloatP))
956 BGL_Wrap(4, UniformMatrix2x3fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
957 BGL_Wrap(4, UniformMatrix3x2fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
958 BGL_Wrap(4, UniformMatrix2x4fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
959 BGL_Wrap(4, UniformMatrix4x2fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
960 BGL_Wrap(4, UniformMatrix3x4fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
961 BGL_Wrap(4, UniformMatrix4x3fv, void,     (GLint, GLsizei, GLboolean, GLfloatP))
962 BGL_Wrap(1, UseProgram,         void,     (GLuint))
963 BGL_Wrap(1, ValidateProgram,    void,     (GLuint))
964 BGL_Wrap(2, Vertex2d,           void,     (GLdouble, GLdouble))
965 BGL_Wrap(1, Vertex2dv,          void,     (GLdoubleP))
966 BGL_Wrap(2, Vertex2f,           void,     (GLfloat, GLfloat))
967 BGL_Wrap(1, Vertex2fv,          void,     (GLfloatP))
968 BGL_Wrap(2, Vertex2i,           void,     (GLint, GLint))
969 BGL_Wrap(1, Vertex2iv,          void,     (GLintP))
970 BGL_Wrap(2, Vertex2s,           void,     (GLshort, GLshort))
971 BGL_Wrap(1, Vertex2sv,          void,     (GLshortP))
972 BGL_Wrap(3, Vertex3d,           void,     (GLdouble, GLdouble, GLdouble))
973 BGL_Wrap(1, Vertex3dv,          void,     (GLdoubleP))
974 BGL_Wrap(3, Vertex3f,           void,     (GLfloat, GLfloat, GLfloat))
975 BGL_Wrap(1, Vertex3fv,          void,     (GLfloatP))
976 BGL_Wrap(3, Vertex3i,           void,     (GLint, GLint, GLint))
977 BGL_Wrap(1, Vertex3iv,          void,     (GLintP))
978 BGL_Wrap(3, Vertex3s,           void,     (GLshort, GLshort, GLshort))
979 BGL_Wrap(1, Vertex3sv,          void,     (GLshortP))
980 BGL_Wrap(4, Vertex4d,           void,     (GLdouble, GLdouble, GLdouble, GLdouble))
981 BGL_Wrap(1, Vertex4dv,          void,     (GLdoubleP))
982 BGL_Wrap(4, Vertex4f,           void,     (GLfloat, GLfloat, GLfloat, GLfloat))
983 BGL_Wrap(1, Vertex4fv,          void,     (GLfloatP))
984 BGL_Wrap(4, Vertex4i,           void,     (GLint, GLint, GLint, GLint))
985 BGL_Wrap(1, Vertex4iv,          void,     (GLintP))
986 BGL_Wrap(4, Vertex4s,           void,     (GLshort, GLshort, GLshort, GLshort))
987 BGL_Wrap(1, Vertex4sv,          void,     (GLshortP))
988 BGL_Wrap(4, Viewport,           void,     (GLint, GLint, GLsizei, GLsizei))
989 BGLU_Wrap(4, Perspective,       void,       (GLdouble, GLdouble, GLdouble, GLdouble))
990 BGLU_Wrap(9, LookAt,            void,       (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
991 BGLU_Wrap(4, Ortho2D,           void,       (GLdouble, GLdouble, GLdouble, GLdouble))
992 BGLU_Wrap(5, PickMatrix,        void,       (GLdouble, GLdouble, GLdouble, GLdouble, GLintP))
993 BGLU_Wrap(9, Project,           GLint,      (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP))
994 BGLU_Wrap(9, UnProject,         GLint,      (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP))
995
996 #undef MethodDef
997 #define MethodDef(func) {"gl"#func, Method_##func, METH_VARARGS, "no string"}
998 #define MethodDefu(func) {"glu"#func, Method_##func, METH_VARARGS, "no string"}
999 /* So that MethodDef(Accum) becomes:
1000  * {"glAccum", Method_Accumfunc, METH_VARARGS} */
1001
1002 static struct PyMethodDef BGL_methods[] = {
1003
1004 /* #ifndef __APPLE__ */
1005         MethodDef(Accum),
1006         MethodDef(ActiveTexture),
1007         MethodDef(AlphaFunc),
1008         MethodDef(AreTexturesResident), 
1009         MethodDef(AttachShader),
1010         MethodDef(Begin),
1011         MethodDef(BindTexture), 
1012         MethodDef(Bitmap),
1013         MethodDef(BlendFunc),
1014         MethodDef(CallList),
1015         MethodDef(CallLists),
1016         MethodDef(Clear),
1017         MethodDef(ClearAccum),
1018         MethodDef(ClearColor),
1019         MethodDef(ClearDepth),
1020         MethodDef(ClearIndex),
1021         MethodDef(ClearStencil),
1022         MethodDef(ClipPlane),
1023         MethodDef(Color3b),
1024         MethodDef(Color3bv),
1025         MethodDef(Color3d),
1026         MethodDef(Color3dv),
1027         MethodDef(Color3f),
1028         MethodDef(Color3fv),
1029         MethodDef(Color3i),
1030         MethodDef(Color3iv),
1031         MethodDef(Color3s),
1032         MethodDef(Color3sv),
1033         MethodDef(Color3ub),
1034         MethodDef(Color3ubv),
1035         MethodDef(Color3ui),
1036         MethodDef(Color3uiv),
1037         MethodDef(Color3us),
1038         MethodDef(Color3usv),
1039         MethodDef(Color4b),
1040         MethodDef(Color4bv),
1041         MethodDef(Color4d),
1042         MethodDef(Color4dv),
1043         MethodDef(Color4f),
1044         MethodDef(Color4fv),
1045         MethodDef(Color4i),
1046         MethodDef(Color4iv),
1047         MethodDef(Color4s),
1048         MethodDef(Color4sv),
1049         MethodDef(Color4ub),
1050         MethodDef(Color4ubv),
1051         MethodDef(Color4ui),
1052         MethodDef(Color4uiv),
1053         MethodDef(Color4us),
1054         MethodDef(Color4usv),
1055         MethodDef(ColorMask),
1056         MethodDef(ColorMaterial),
1057         MethodDef(CompileShader),
1058         MethodDef(CopyPixels),
1059         MethodDef(CopyTexImage2D),
1060         MethodDef(CreateProgram),
1061         MethodDef(CreateShader),
1062         MethodDef(CullFace),
1063         MethodDef(DeleteLists),
1064         MethodDef(DeleteProgram),
1065         MethodDef(DeleteShader),
1066         MethodDef(DeleteTextures),
1067         MethodDef(DepthFunc),
1068         MethodDef(DepthMask),
1069         MethodDef(DepthRange),
1070         MethodDef(DetachShader),
1071         MethodDef(Disable),
1072         MethodDef(DrawBuffer),
1073         MethodDef(DrawPixels),
1074         MethodDef(EdgeFlag),
1075         MethodDef(EdgeFlagv),
1076         MethodDef(Enable),
1077         MethodDef(End),
1078         MethodDef(EndList),
1079         MethodDef(EvalCoord1d),
1080         MethodDef(EvalCoord1dv),
1081         MethodDef(EvalCoord1f),
1082         MethodDef(EvalCoord1fv),
1083         MethodDef(EvalCoord2d),
1084         MethodDef(EvalCoord2dv),
1085         MethodDef(EvalCoord2f),
1086         MethodDef(EvalCoord2fv),
1087         MethodDef(EvalMesh1),
1088         MethodDef(EvalMesh2),
1089         MethodDef(EvalPoint1),
1090         MethodDef(EvalPoint2),
1091         MethodDef(FeedbackBuffer),
1092         MethodDef(Finish),
1093         MethodDef(Flush),
1094         MethodDef(Fogf),
1095         MethodDef(Fogfv),
1096         MethodDef(Fogi),
1097         MethodDef(Fogiv),
1098         MethodDef(FrontFace),
1099         MethodDef(Frustum),
1100         MethodDef(GenLists),
1101         MethodDef(GenTextures), 
1102         MethodDef(GetAttachedShaders),
1103         MethodDef(GetBooleanv),
1104         MethodDef(GetClipPlane),
1105         MethodDef(GetDoublev),
1106         MethodDef(GetError),
1107         MethodDef(GetFloatv),
1108         MethodDef(GetIntegerv),
1109         MethodDef(GetLightfv),
1110         MethodDef(GetLightiv),
1111         MethodDef(GetMapdv),
1112         MethodDef(GetMapfv),
1113         MethodDef(GetMapiv),
1114         MethodDef(GetMaterialfv),
1115         MethodDef(GetMaterialiv),
1116         MethodDef(GetPixelMapfv),
1117         MethodDef(GetPixelMapuiv),
1118         MethodDef(GetPixelMapusv),
1119         MethodDef(GetPolygonStipple),
1120         MethodDef(GetProgramInfoLog),
1121         MethodDef(GetProgramiv),
1122         MethodDef(GetShaderInfoLog),
1123         MethodDef(GetShaderiv),
1124         MethodDef(GetShaderSource),
1125         MethodDef(GetString),
1126         MethodDef(GetTexEnvfv),
1127         MethodDef(GetTexEnviv),
1128         MethodDef(GetTexGendv),
1129         MethodDef(GetTexGenfv),
1130         MethodDef(GetTexGeniv),
1131         MethodDef(GetTexImage),
1132         MethodDef(GetTexLevelParameterfv),
1133         MethodDef(GetTexLevelParameteriv),
1134         MethodDef(GetTexParameterfv),
1135         MethodDef(GetTexParameteriv),
1136         MethodDef(GetUniformLocation),
1137         MethodDef(Hint),
1138         MethodDef(IndexMask),
1139         MethodDef(Indexd),
1140         MethodDef(Indexdv),
1141         MethodDef(Indexf),
1142         MethodDef(Indexfv),
1143         MethodDef(Indexi),
1144         MethodDef(Indexiv),
1145         MethodDef(Indexs),
1146         MethodDef(Indexsv),
1147         MethodDef(InitNames),
1148         MethodDef(IsEnabled),
1149         MethodDef(IsList),
1150         MethodDef(IsProgram),
1151         MethodDef(IsShader),
1152         MethodDef(IsTexture), 
1153         MethodDef(LightModelf),
1154         MethodDef(LightModelfv),
1155         MethodDef(LightModeli),
1156         MethodDef(LightModeliv),
1157         MethodDef(Lightf),
1158         MethodDef(Lightfv),
1159         MethodDef(Lighti),
1160         MethodDef(Lightiv),
1161         MethodDef(LineStipple),
1162         MethodDef(LineWidth),
1163         MethodDef(LinkProgram),
1164         MethodDef(ListBase),
1165         MethodDef(LoadIdentity),
1166         MethodDef(LoadMatrixd),
1167         MethodDef(LoadMatrixf),
1168         MethodDef(LoadName),
1169         MethodDef(LogicOp),
1170         MethodDef(Map1d),
1171         MethodDef(Map1f),
1172         MethodDef(Map2d),
1173         MethodDef(Map2f),
1174         MethodDef(MapGrid1d),
1175         MethodDef(MapGrid1f),
1176         MethodDef(MapGrid2d),
1177         MethodDef(MapGrid2f),
1178         MethodDef(Materialf),
1179         MethodDef(Materialfv),
1180         MethodDef(Materiali),
1181         MethodDef(Materialiv),
1182         MethodDef(MatrixMode),
1183         MethodDef(MultMatrixd),
1184         MethodDef(MultMatrixf),
1185         MethodDef(NewList),
1186         MethodDef(Normal3b),
1187         MethodDef(Normal3bv),
1188         MethodDef(Normal3d),
1189         MethodDef(Normal3dv),
1190         MethodDef(Normal3f),
1191         MethodDef(Normal3fv),
1192         MethodDef(Normal3i),
1193         MethodDef(Normal3iv),
1194         MethodDef(Normal3s),
1195         MethodDef(Normal3sv),
1196         MethodDef(Ortho),
1197         MethodDef(PassThrough),
1198         MethodDef(PixelMapfv),
1199         MethodDef(PixelMapuiv),
1200         MethodDef(PixelMapusv),
1201         MethodDef(PixelStoref),
1202         MethodDef(PixelStorei),
1203         MethodDef(PixelTransferf),
1204         MethodDef(PixelTransferi),
1205         MethodDef(PixelZoom),
1206         MethodDef(PointSize),
1207         MethodDef(PolygonMode),
1208         MethodDef(PolygonOffset),
1209         MethodDef(PolygonStipple),
1210         MethodDef(PopAttrib),
1211         MethodDef(PopClientAttrib),
1212         MethodDef(PopMatrix),
1213         MethodDef(PopName),
1214         MethodDef(PrioritizeTextures), 
1215         MethodDef(PushAttrib),
1216         MethodDef(PushClientAttrib),
1217         MethodDef(PushMatrix),
1218         MethodDef(PushName),
1219         MethodDef(RasterPos2d),
1220         MethodDef(RasterPos2dv),
1221         MethodDef(RasterPos2f),
1222         MethodDef(RasterPos2fv),
1223         MethodDef(RasterPos2i),
1224         MethodDef(RasterPos2iv),
1225         MethodDef(RasterPos2s),
1226         MethodDef(RasterPos2sv),
1227         MethodDef(RasterPos3d),
1228         MethodDef(RasterPos3dv),
1229         MethodDef(RasterPos3f),
1230         MethodDef(RasterPos3fv),
1231         MethodDef(RasterPos3i),
1232         MethodDef(RasterPos3iv),
1233         MethodDef(RasterPos3s),
1234         MethodDef(RasterPos3sv),
1235         MethodDef(RasterPos4d),
1236         MethodDef(RasterPos4dv),
1237         MethodDef(RasterPos4f),
1238         MethodDef(RasterPos4fv),
1239         MethodDef(RasterPos4i),
1240         MethodDef(RasterPos4iv),
1241         MethodDef(RasterPos4s),
1242         MethodDef(RasterPos4sv),
1243         MethodDef(ReadBuffer),
1244         MethodDef(ReadPixels),
1245         MethodDef(Rectd),
1246         MethodDef(Rectdv),
1247         MethodDef(Rectf),
1248         MethodDef(Rectfv),
1249         MethodDef(Recti),
1250         MethodDef(Rectiv),
1251         MethodDef(Rects),
1252         MethodDef(Rectsv),
1253         MethodDef(RenderMode),
1254         MethodDef(Rotated),
1255         MethodDef(Rotatef),
1256         MethodDef(Scaled),
1257         MethodDef(Scalef),
1258         MethodDef(Scissor),
1259         MethodDef(SelectBuffer),
1260         MethodDef(ShadeModel),
1261         MethodDef(ShaderSource),
1262         MethodDef(StencilFunc),
1263         MethodDef(StencilMask),
1264         MethodDef(StencilOp),
1265         MethodDef(TexCoord1d),
1266         MethodDef(TexCoord1dv),
1267         MethodDef(TexCoord1f),
1268         MethodDef(TexCoord1fv),
1269         MethodDef(TexCoord1i),
1270         MethodDef(TexCoord1iv),
1271         MethodDef(TexCoord1s),
1272         MethodDef(TexCoord1sv),
1273         MethodDef(TexCoord2d),
1274         MethodDef(TexCoord2dv),
1275         MethodDef(TexCoord2f),
1276         MethodDef(TexCoord2fv),
1277         MethodDef(TexCoord2i),
1278         MethodDef(TexCoord2iv),
1279         MethodDef(TexCoord2s),
1280         MethodDef(TexCoord2sv),
1281         MethodDef(TexCoord3d),
1282         MethodDef(TexCoord3dv),
1283         MethodDef(TexCoord3f),
1284         MethodDef(TexCoord3fv),
1285         MethodDef(TexCoord3i),
1286         MethodDef(TexCoord3iv),
1287         MethodDef(TexCoord3s),
1288         MethodDef(TexCoord3sv),
1289         MethodDef(TexCoord4d),
1290         MethodDef(TexCoord4dv),
1291         MethodDef(TexCoord4f),
1292         MethodDef(TexCoord4fv),
1293         MethodDef(TexCoord4i),
1294         MethodDef(TexCoord4iv),
1295         MethodDef(TexCoord4s),
1296         MethodDef(TexCoord4sv),
1297         MethodDef(TexEnvf),
1298         MethodDef(TexEnvfv),
1299         MethodDef(TexEnvi),
1300         MethodDef(TexEnviv),
1301         MethodDef(TexGend),
1302         MethodDef(TexGendv),
1303         MethodDef(TexGenf),
1304         MethodDef(TexGenfv),
1305         MethodDef(TexGeni),
1306         MethodDef(TexGeniv),
1307         MethodDef(TexImage1D),
1308         MethodDef(TexImage2D),
1309         MethodDef(TexParameterf),
1310         MethodDef(TexParameterfv),
1311         MethodDef(TexParameteri),
1312         MethodDef(TexParameteriv),
1313         MethodDef(Translated),
1314         MethodDef(Translatef),
1315         MethodDef(Uniform1f),
1316         MethodDef(Uniform2f),
1317         MethodDef(Uniform3f),
1318         MethodDef(Uniform4f),
1319         MethodDef(Uniform1fv),
1320         MethodDef(Uniform2fv),
1321         MethodDef(Uniform3fv),
1322         MethodDef(Uniform4fv),
1323         MethodDef(Uniform1i),
1324         MethodDef(Uniform2i),
1325         MethodDef(Uniform3i),
1326         MethodDef(Uniform4i),
1327         MethodDef(Uniform1iv),
1328         MethodDef(Uniform2iv),
1329         MethodDef(Uniform3iv),
1330         MethodDef(Uniform4iv),
1331         MethodDef(UniformMatrix2fv),
1332         MethodDef(UniformMatrix3fv),
1333         MethodDef(UniformMatrix4fv),
1334         MethodDef(UniformMatrix2x3fv),
1335         MethodDef(UniformMatrix3x2fv),
1336         MethodDef(UniformMatrix2x4fv),
1337         MethodDef(UniformMatrix4x2fv),
1338         MethodDef(UniformMatrix3x4fv),
1339         MethodDef(UniformMatrix4x3fv),
1340         MethodDef(UseProgram),
1341         MethodDef(ValidateProgram),
1342         MethodDef(Vertex2d),
1343         MethodDef(Vertex2dv),
1344         MethodDef(Vertex2f),
1345         MethodDef(Vertex2fv),
1346         MethodDef(Vertex2i),
1347         MethodDef(Vertex2iv),
1348         MethodDef(Vertex2s),
1349         MethodDef(Vertex2sv),
1350         MethodDef(Vertex3d),
1351         MethodDef(Vertex3dv),
1352         MethodDef(Vertex3f),
1353         MethodDef(Vertex3fv),
1354         MethodDef(Vertex3i),
1355         MethodDef(Vertex3iv),
1356         MethodDef(Vertex3s),
1357         MethodDef(Vertex3sv),
1358         MethodDef(Vertex4d),
1359         MethodDef(Vertex4dv),
1360         MethodDef(Vertex4f),
1361         MethodDef(Vertex4fv),
1362         MethodDef(Vertex4i),
1363         MethodDef(Vertex4iv),
1364         MethodDef(Vertex4s),
1365         MethodDef(Vertex4sv),
1366         MethodDef(Viewport),
1367         MethodDefu(Perspective),
1368         MethodDefu(LookAt),
1369         MethodDefu(Ortho2D),
1370         MethodDefu(PickMatrix),
1371         MethodDefu(Project),
1372         MethodDefu(UnProject),
1373 /* #endif */
1374         {NULL, NULL, 0, NULL}
1375 };
1376
1377 static struct PyModuleDef BGL_module_def = {
1378         PyModuleDef_HEAD_INIT,
1379         "bgl",  /* m_name */
1380         NULL,  /* m_doc */
1381         0,  /* m_size */
1382         BGL_methods,  /* m_methods */
1383         NULL,  /* m_reload */
1384         NULL,  /* m_traverse */
1385         NULL,  /* m_clear */
1386         NULL,  /* m_free */
1387 };
1388
1389
1390 PyObject *BPyInit_bgl(void)
1391 {
1392         PyObject *submodule, *dict, *item;
1393         submodule = PyModule_Create(&BGL_module_def);
1394         dict = PyModule_GetDict(submodule);
1395
1396         if (PyType_Ready(&BGL_bufferType) < 0)
1397                 return NULL;  /* should never happen */
1398
1399         PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType);
1400         Py_INCREF((PyObject *)&BGL_bufferType);
1401
1402 #define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, item = PyLong_FromLong((int)x)); Py_DECREF(item)
1403
1404 /* So, for example:
1405  * EXPP_ADDCONST(GL_CURRENT_BIT) becomes
1406  * PyDict_SetItemString(dict, "GL_CURRENT_BIT", item = PyLong_FromLong(GL_CURRENT_BIT)); Py_DECREF(item) */
1407
1408         EXPP_ADDCONST(GL_CURRENT_BIT);
1409         EXPP_ADDCONST(GL_POINT_BIT);
1410         EXPP_ADDCONST(GL_LINE_BIT);
1411         EXPP_ADDCONST(GL_POLYGON_BIT);
1412         EXPP_ADDCONST(GL_POLYGON_STIPPLE_BIT);
1413         EXPP_ADDCONST(GL_PIXEL_MODE_BIT);
1414         EXPP_ADDCONST(GL_LIGHTING_BIT);
1415         EXPP_ADDCONST(GL_FOG_BIT);
1416         EXPP_ADDCONST(GL_DEPTH_BUFFER_BIT);
1417         EXPP_ADDCONST(GL_ACCUM_BUFFER_BIT);
1418         EXPP_ADDCONST(GL_STENCIL_BUFFER_BIT);
1419         EXPP_ADDCONST(GL_VIEWPORT_BIT);
1420         EXPP_ADDCONST(GL_TRANSFORM_BIT);
1421         EXPP_ADDCONST(GL_ENABLE_BIT);
1422         EXPP_ADDCONST(GL_COLOR_BUFFER_BIT);
1423         EXPP_ADDCONST(GL_HINT_BIT);
1424         EXPP_ADDCONST(GL_EVAL_BIT);
1425         EXPP_ADDCONST(GL_LIST_BIT);
1426         EXPP_ADDCONST(GL_TEXTURE_BIT);
1427         EXPP_ADDCONST(GL_SCISSOR_BIT);
1428         EXPP_ADDCONST(GL_ALL_ATTRIB_BITS);
1429         EXPP_ADDCONST(GL_CLIENT_ALL_ATTRIB_BITS);
1430         
1431         EXPP_ADDCONST(GL_FALSE);
1432         EXPP_ADDCONST(GL_TRUE);
1433
1434         EXPP_ADDCONST(GL_POINTS);
1435         EXPP_ADDCONST(GL_LINES);
1436         EXPP_ADDCONST(GL_LINE_LOOP);
1437         EXPP_ADDCONST(GL_LINE_STRIP);
1438         EXPP_ADDCONST(GL_TRIANGLES);
1439         EXPP_ADDCONST(GL_TRIANGLE_STRIP);
1440         EXPP_ADDCONST(GL_TRIANGLE_FAN);
1441         EXPP_ADDCONST(GL_QUADS);
1442         EXPP_ADDCONST(GL_QUAD_STRIP);
1443         EXPP_ADDCONST(GL_POLYGON);
1444
1445         EXPP_ADDCONST(GL_ACCUM);
1446         EXPP_ADDCONST(GL_LOAD);
1447         EXPP_ADDCONST(GL_RETURN);
1448         EXPP_ADDCONST(GL_MULT);
1449         EXPP_ADDCONST(GL_ADD);
1450
1451         EXPP_ADDCONST(GL_NEVER);
1452         EXPP_ADDCONST(GL_LESS);
1453         EXPP_ADDCONST(GL_EQUAL);
1454         EXPP_ADDCONST(GL_LEQUAL);
1455         EXPP_ADDCONST(GL_GREATER);
1456         EXPP_ADDCONST(GL_NOTEQUAL);
1457         EXPP_ADDCONST(GL_GEQUAL);
1458         EXPP_ADDCONST(GL_ALWAYS);
1459
1460         EXPP_ADDCONST(GL_ZERO);
1461         EXPP_ADDCONST(GL_ONE);
1462         EXPP_ADDCONST(GL_SRC_COLOR);
1463         EXPP_ADDCONST(GL_ONE_MINUS_SRC_COLOR);
1464         EXPP_ADDCONST(GL_SRC_ALPHA);
1465         EXPP_ADDCONST(GL_ONE_MINUS_SRC_ALPHA);
1466         EXPP_ADDCONST(GL_DST_ALPHA);
1467         EXPP_ADDCONST(GL_ONE_MINUS_DST_ALPHA);
1468
1469         EXPP_ADDCONST(GL_DST_COLOR);
1470         EXPP_ADDCONST(GL_ONE_MINUS_DST_COLOR);
1471         EXPP_ADDCONST(GL_SRC_ALPHA_SATURATE);
1472
1473         EXPP_ADDCONST(GL_NONE);
1474         EXPP_ADDCONST(GL_FRONT_LEFT);
1475         EXPP_ADDCONST(GL_FRONT_RIGHT);
1476         EXPP_ADDCONST(GL_BACK_LEFT);
1477         EXPP_ADDCONST(GL_BACK_RIGHT);
1478         EXPP_ADDCONST(GL_FRONT);
1479         EXPP_ADDCONST(GL_BACK);
1480         EXPP_ADDCONST(GL_LEFT);
1481         EXPP_ADDCONST(GL_RIGHT);
1482         EXPP_ADDCONST(GL_FRONT_AND_BACK);
1483         EXPP_ADDCONST(GL_AUX0);
1484         EXPP_ADDCONST(GL_AUX1);
1485         EXPP_ADDCONST(GL_AUX2);
1486         EXPP_ADDCONST(GL_AUX3);
1487
1488         EXPP_ADDCONST(GL_NO_ERROR);
1489         EXPP_ADDCONST(GL_INVALID_ENUM);
1490         EXPP_ADDCONST(GL_INVALID_VALUE);
1491         EXPP_ADDCONST(GL_INVALID_OPERATION);
1492         EXPP_ADDCONST(GL_STACK_OVERFLOW);
1493         EXPP_ADDCONST(GL_STACK_UNDERFLOW);
1494         EXPP_ADDCONST(GL_OUT_OF_MEMORY);
1495
1496         EXPP_ADDCONST(GL_2D);
1497         EXPP_ADDCONST(GL_3D);
1498         EXPP_ADDCONST(GL_3D_COLOR);
1499         EXPP_ADDCONST(GL_3D_COLOR_TEXTURE);
1500         EXPP_ADDCONST(GL_4D_COLOR_TEXTURE);
1501
1502         EXPP_ADDCONST(GL_PASS_THROUGH_TOKEN);
1503         EXPP_ADDCONST(GL_POINT_TOKEN);
1504         EXPP_ADDCONST(GL_LINE_TOKEN);
1505         EXPP_ADDCONST(GL_POLYGON_TOKEN);
1506         EXPP_ADDCONST(GL_BITMAP_TOKEN);
1507         EXPP_ADDCONST(GL_DRAW_PIXEL_TOKEN);
1508         EXPP_ADDCONST(GL_COPY_PIXEL_TOKEN);
1509         EXPP_ADDCONST(GL_LINE_RESET_TOKEN);
1510
1511         EXPP_ADDCONST(GL_EXP);
1512         EXPP_ADDCONST(GL_EXP2);
1513
1514         EXPP_ADDCONST(GL_CW);
1515         EXPP_ADDCONST(GL_CCW);
1516
1517         EXPP_ADDCONST(GL_COEFF);
1518         EXPP_ADDCONST(GL_ORDER);
1519         EXPP_ADDCONST(GL_DOMAIN);
1520
1521         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_I);
1522         EXPP_ADDCONST(GL_PIXEL_MAP_S_TO_S);
1523         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_R);
1524         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_G);
1525         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_B);
1526         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_A);
1527         EXPP_ADDCONST(GL_PIXEL_MAP_R_TO_R);
1528         EXPP_ADDCONST(GL_PIXEL_MAP_G_TO_G);
1529         EXPP_ADDCONST(GL_PIXEL_MAP_B_TO_B);
1530         EXPP_ADDCONST(GL_PIXEL_MAP_A_TO_A);
1531
1532         EXPP_ADDCONST(GL_CURRENT_COLOR);
1533         EXPP_ADDCONST(GL_CURRENT_INDEX);
1534         EXPP_ADDCONST(GL_CURRENT_NORMAL);
1535         EXPP_ADDCONST(GL_CURRENT_TEXTURE_COORDS);
1536         EXPP_ADDCONST(GL_CURRENT_RASTER_COLOR);
1537         EXPP_ADDCONST(GL_CURRENT_RASTER_INDEX);
1538         EXPP_ADDCONST(GL_CURRENT_RASTER_TEXTURE_COORDS);
1539         EXPP_ADDCONST(GL_CURRENT_RASTER_POSITION);
1540         EXPP_ADDCONST(GL_CURRENT_RASTER_POSITION_VALID);
1541         EXPP_ADDCONST(GL_CURRENT_RASTER_DISTANCE);
1542         EXPP_ADDCONST(GL_POINT_SMOOTH);
1543         EXPP_ADDCONST(GL_POINT_SIZE);
1544         EXPP_ADDCONST(GL_POINT_SIZE_RANGE);
1545         EXPP_ADDCONST(GL_POINT_SIZE_GRANULARITY);
1546         EXPP_ADDCONST(GL_LINE_SMOOTH);
1547         EXPP_ADDCONST(GL_LINE_WIDTH);
1548         EXPP_ADDCONST(GL_LINE_WIDTH_RANGE);
1549         EXPP_ADDCONST(GL_LINE_WIDTH_GRANULARITY);
1550         EXPP_ADDCONST(GL_LINE_STIPPLE);
1551         EXPP_ADDCONST(GL_LINE_STIPPLE_PATTERN);
1552         EXPP_ADDCONST(GL_LINE_STIPPLE_REPEAT);
1553         EXPP_ADDCONST(GL_LIST_MODE);
1554         EXPP_ADDCONST(GL_MAX_LIST_NESTING);
1555         EXPP_ADDCONST(GL_LIST_BASE);
1556         EXPP_ADDCONST(GL_LIST_INDEX);
1557         EXPP_ADDCONST(GL_POLYGON_MODE);
1558         EXPP_ADDCONST(GL_POLYGON_SMOOTH);
1559         EXPP_ADDCONST(GL_POLYGON_STIPPLE);
1560         EXPP_ADDCONST(GL_EDGE_FLAG);
1561         EXPP_ADDCONST(GL_CULL_FACE);
1562         EXPP_ADDCONST(GL_CULL_FACE_MODE);
1563         EXPP_ADDCONST(GL_FRONT_FACE);
1564         EXPP_ADDCONST(GL_LIGHTING);
1565         EXPP_ADDCONST(GL_LIGHT_MODEL_LOCAL_VIEWER);
1566         EXPP_ADDCONST(GL_LIGHT_MODEL_TWO_SIDE);
1567         EXPP_ADDCONST(GL_LIGHT_MODEL_AMBIENT);
1568         EXPP_ADDCONST(GL_SHADE_MODEL);
1569         EXPP_ADDCONST(GL_COLOR_MATERIAL_FACE);
1570         EXPP_ADDCONST(GL_COLOR_MATERIAL_PARAMETER);
1571         EXPP_ADDCONST(GL_COLOR_MATERIAL);
1572         EXPP_ADDCONST(GL_FOG);
1573         EXPP_ADDCONST(GL_FOG_INDEX);
1574         EXPP_ADDCONST(GL_FOG_DENSITY);
1575         EXPP_ADDCONST(GL_FOG_START);
1576         EXPP_ADDCONST(GL_FOG_END);
1577         EXPP_ADDCONST(GL_FOG_MODE);
1578         EXPP_ADDCONST(GL_FOG_COLOR);
1579         EXPP_ADDCONST(GL_DEPTH_RANGE);
1580         EXPP_ADDCONST(GL_DEPTH_TEST);
1581         EXPP_ADDCONST(GL_DEPTH_WRITEMASK);
1582         EXPP_ADDCONST(GL_DEPTH_CLEAR_VALUE);
1583         EXPP_ADDCONST(GL_DEPTH_FUNC);
1584         EXPP_ADDCONST(GL_ACCUM_CLEAR_VALUE);
1585         EXPP_ADDCONST(GL_STENCIL_TEST);
1586         EXPP_ADDCONST(GL_STENCIL_CLEAR_VALUE);
1587         EXPP_ADDCONST(GL_STENCIL_FUNC);
1588         EXPP_ADDCONST(GL_STENCIL_VALUE_MASK);
1589         EXPP_ADDCONST(GL_STENCIL_FAIL);
1590         EXPP_ADDCONST(GL_STENCIL_PASS_DEPTH_FAIL);
1591         EXPP_ADDCONST(GL_STENCIL_PASS_DEPTH_PASS);
1592         EXPP_ADDCONST(GL_STENCIL_REF);
1593         EXPP_ADDCONST(GL_STENCIL_WRITEMASK);
1594         EXPP_ADDCONST(GL_MATRIX_MODE);
1595         EXPP_ADDCONST(GL_NORMALIZE);
1596         EXPP_ADDCONST(GL_VIEWPORT);
1597         EXPP_ADDCONST(GL_MODELVIEW_STACK_DEPTH);
1598         EXPP_ADDCONST(GL_PROJECTION_STACK_DEPTH);
1599         EXPP_ADDCONST(GL_TEXTURE_STACK_DEPTH);
1600         EXPP_ADDCONST(GL_MODELVIEW_MATRIX);
1601         EXPP_ADDCONST(GL_PROJECTION_MATRIX);
1602         EXPP_ADDCONST(GL_TEXTURE_MATRIX);
1603         EXPP_ADDCONST(GL_ATTRIB_STACK_DEPTH);
1604         EXPP_ADDCONST(GL_ALPHA_TEST);
1605         EXPP_ADDCONST(GL_ALPHA_TEST_FUNC);
1606         EXPP_ADDCONST(GL_ALPHA_TEST_REF);
1607         EXPP_ADDCONST(GL_DITHER);
1608         EXPP_ADDCONST(GL_BLEND_DST);
1609         EXPP_ADDCONST(GL_BLEND_SRC);
1610         EXPP_ADDCONST(GL_BLEND);
1611         EXPP_ADDCONST(GL_LOGIC_OP_MODE);
1612         EXPP_ADDCONST(GL_LOGIC_OP);
1613         EXPP_ADDCONST(GL_AUX_BUFFERS);
1614         EXPP_ADDCONST(GL_DRAW_BUFFER);
1615         EXPP_ADDCONST(GL_READ_BUFFER);
1616         EXPP_ADDCONST(GL_SCISSOR_BOX);
1617         EXPP_ADDCONST(GL_SCISSOR_TEST);
1618         EXPP_ADDCONST(GL_INDEX_CLEAR_VALUE);
1619         EXPP_ADDCONST(GL_INDEX_WRITEMASK);
1620         EXPP_ADDCONST(GL_COLOR_CLEAR_VALUE);
1621         EXPP_ADDCONST(GL_COLOR_WRITEMASK);
1622         EXPP_ADDCONST(GL_INDEX_MODE);
1623         EXPP_ADDCONST(GL_RGBA_MODE);
1624         EXPP_ADDCONST(GL_DOUBLEBUFFER);
1625         EXPP_ADDCONST(GL_STEREO);
1626         EXPP_ADDCONST(GL_RENDER_MODE);
1627         EXPP_ADDCONST(GL_PERSPECTIVE_CORRECTION_HINT);
1628         EXPP_ADDCONST(GL_POINT_SMOOTH_HINT);
1629         EXPP_ADDCONST(GL_LINE_SMOOTH_HINT);
1630         EXPP_ADDCONST(GL_POLYGON_SMOOTH_HINT);
1631         EXPP_ADDCONST(GL_FOG_HINT);
1632         EXPP_ADDCONST(GL_TEXTURE_GEN_S);
1633         EXPP_ADDCONST(GL_TEXTURE_GEN_T);
1634         EXPP_ADDCONST(GL_TEXTURE_GEN_R);
1635         EXPP_ADDCONST(GL_TEXTURE_GEN_Q);
1636         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_I_SIZE);
1637         EXPP_ADDCONST(GL_PIXEL_MAP_S_TO_S_SIZE);
1638         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_R_SIZE);
1639         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_G_SIZE);
1640         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_B_SIZE);
1641         EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_A_SIZE);
1642         EXPP_ADDCONST(GL_PIXEL_MAP_R_TO_R_SIZE);
1643         EXPP_ADDCONST(GL_PIXEL_MAP_G_TO_G_SIZE);
1644         EXPP_ADDCONST(GL_PIXEL_MAP_B_TO_B_SIZE);
1645         EXPP_ADDCONST(GL_PIXEL_MAP_A_TO_A_SIZE);
1646         EXPP_ADDCONST(GL_UNPACK_SWAP_BYTES);
1647         EXPP_ADDCONST(GL_UNPACK_LSB_FIRST);
1648         EXPP_ADDCONST(GL_UNPACK_ROW_LENGTH);
1649         EXPP_ADDCONST(GL_UNPACK_SKIP_ROWS);
1650         EXPP_ADDCONST(GL_UNPACK_SKIP_PIXELS);
1651         EXPP_ADDCONST(GL_UNPACK_ALIGNMENT);
1652         EXPP_ADDCONST(GL_PACK_SWAP_BYTES);
1653         EXPP_ADDCONST(GL_PACK_LSB_FIRST);
1654         EXPP_ADDCONST(GL_PACK_ROW_LENGTH);
1655         EXPP_ADDCONST(GL_PACK_SKIP_ROWS);
1656         EXPP_ADDCONST(GL_PACK_SKIP_PIXELS);
1657         EXPP_ADDCONST(GL_PACK_ALIGNMENT);
1658         EXPP_ADDCONST(GL_MAP_COLOR);
1659         EXPP_ADDCONST(GL_MAP_STENCIL);
1660         EXPP_ADDCONST(GL_INDEX_SHIFT);
1661         EXPP_ADDCONST(GL_INDEX_OFFSET);
1662         EXPP_ADDCONST(GL_RED_SCALE);
1663         EXPP_ADDCONST(GL_RED_BIAS);
1664         EXPP_ADDCONST(GL_ZOOM_X);
1665         EXPP_ADDCONST(GL_ZOOM_Y);
1666         EXPP_ADDCONST(GL_GREEN_SCALE);
1667         EXPP_ADDCONST(GL_GREEN_BIAS);
1668         EXPP_ADDCONST(GL_BLUE_SCALE);
1669         EXPP_ADDCONST(GL_BLUE_BIAS);
1670         EXPP_ADDCONST(GL_ALPHA_SCALE);
1671         EXPP_ADDCONST(GL_ALPHA_BIAS);
1672         EXPP_ADDCONST(GL_DEPTH_SCALE);
1673         EXPP_ADDCONST(GL_DEPTH_BIAS);
1674         EXPP_ADDCONST(GL_MAX_EVAL_ORDER);
1675         EXPP_ADDCONST(GL_MAX_LIGHTS);
1676         EXPP_ADDCONST(GL_MAX_CLIP_PLANES);
1677         EXPP_ADDCONST(GL_MAX_TEXTURE_SIZE);
1678         EXPP_ADDCONST(GL_MAX_PIXEL_MAP_TABLE);
1679         EXPP_ADDCONST(GL_MAX_ATTRIB_STACK_DEPTH);
1680         EXPP_ADDCONST(GL_MAX_MODELVIEW_STACK_DEPTH);
1681         EXPP_ADDCONST(GL_MAX_NAME_STACK_DEPTH);
1682         EXPP_ADDCONST(GL_MAX_PROJECTION_STACK_DEPTH);
1683         EXPP_ADDCONST(GL_MAX_TEXTURE_STACK_DEPTH);
1684         EXPP_ADDCONST(GL_MAX_VIEWPORT_DIMS);
1685         EXPP_ADDCONST(GL_SUBPIXEL_BITS);
1686         EXPP_ADDCONST(GL_INDEX_BITS);
1687         EXPP_ADDCONST(GL_RED_BITS);
1688         EXPP_ADDCONST(GL_GREEN_BITS);
1689         EXPP_ADDCONST(GL_BLUE_BITS);
1690         EXPP_ADDCONST(GL_ALPHA_BITS);
1691         EXPP_ADDCONST(GL_DEPTH_BITS);
1692         EXPP_ADDCONST(GL_STENCIL_BITS);
1693         EXPP_ADDCONST(GL_ACCUM_RED_BITS);
1694         EXPP_ADDCONST(GL_ACCUM_GREEN_BITS);
1695         EXPP_ADDCONST(GL_ACCUM_BLUE_BITS);
1696         EXPP_ADDCONST(GL_ACCUM_ALPHA_BITS);
1697         EXPP_ADDCONST(GL_NAME_STACK_DEPTH);
1698         EXPP_ADDCONST(GL_AUTO_NORMAL);
1699         EXPP_ADDCONST(GL_MAP1_COLOR_4);
1700         EXPP_ADDCONST(GL_MAP1_INDEX);
1701         EXPP_ADDCONST(GL_MAP1_NORMAL);
1702         EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_1);
1703         EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_2);
1704         EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_3);
1705         EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_4);
1706         EXPP_ADDCONST(GL_MAP1_VERTEX_3);
1707         EXPP_ADDCONST(GL_MAP1_VERTEX_4);
1708         EXPP_ADDCONST(GL_MAP2_COLOR_4);
1709         EXPP_ADDCONST(GL_MAP2_INDEX);
1710         EXPP_ADDCONST(GL_MAP2_NORMAL);
1711         EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_1);
1712         EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_2);
1713         EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_3);
1714         EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_4);
1715         EXPP_ADDCONST(GL_MAP2_VERTEX_3);
1716         EXPP_ADDCONST(GL_MAP2_VERTEX_4);
1717         EXPP_ADDCONST(GL_MAP1_GRID_DOMAIN);
1718         EXPP_ADDCONST(GL_MAP1_GRID_SEGMENTS);
1719         EXPP_ADDCONST(GL_MAP2_GRID_DOMAIN);
1720         EXPP_ADDCONST(GL_MAP2_GRID_SEGMENTS);
1721         EXPP_ADDCONST(GL_TEXTURE_1D);
1722         EXPP_ADDCONST(GL_TEXTURE_2D);
1723
1724         EXPP_ADDCONST(GL_TEXTURE_WIDTH);
1725         EXPP_ADDCONST(GL_TEXTURE_HEIGHT);
1726         EXPP_ADDCONST(GL_TEXTURE_COMPONENTS);
1727         EXPP_ADDCONST(GL_TEXTURE_BORDER_COLOR);
1728         EXPP_ADDCONST(GL_TEXTURE_BORDER);
1729
1730         EXPP_ADDCONST(GL_DONT_CARE);
1731         EXPP_ADDCONST(GL_FASTEST);
1732         EXPP_ADDCONST(GL_NICEST);
1733
1734         EXPP_ADDCONST(GL_AMBIENT);
1735         EXPP_ADDCONST(GL_DIFFUSE);
1736         EXPP_ADDCONST(GL_SPECULAR);
1737         EXPP_ADDCONST(GL_POSITION);
1738         EXPP_ADDCONST(GL_SPOT_DIRECTION);
1739         EXPP_ADDCONST(GL_SPOT_EXPONENT);
1740         EXPP_ADDCONST(GL_SPOT_CUTOFF);
1741         EXPP_ADDCONST(GL_CONSTANT_ATTENUATION);
1742         EXPP_ADDCONST(GL_LINEAR_ATTENUATION);
1743         EXPP_ADDCONST(GL_QUADRATIC_ATTENUATION);
1744
1745         EXPP_ADDCONST(GL_COMPILE);
1746         EXPP_ADDCONST(GL_COMPILE_AND_EXECUTE);
1747
1748         EXPP_ADDCONST(GL_BYTE);
1749         EXPP_ADDCONST(GL_UNSIGNED_BYTE);
1750         EXPP_ADDCONST(GL_SHORT);
1751         EXPP_ADDCONST(GL_UNSIGNED_SHORT);
1752         EXPP_ADDCONST(GL_INT);
1753         EXPP_ADDCONST(GL_UNSIGNED_INT);
1754         EXPP_ADDCONST(GL_FLOAT);
1755         EXPP_ADDCONST(GL_DOUBLE);
1756         EXPP_ADDCONST(GL_2_BYTES);
1757         EXPP_ADDCONST(GL_3_BYTES);
1758         EXPP_ADDCONST(GL_4_BYTES);
1759
1760         EXPP_ADDCONST(GL_CLEAR);
1761         EXPP_ADDCONST(GL_AND);
1762         EXPP_ADDCONST(GL_AND_REVERSE);
1763         EXPP_ADDCONST(GL_COPY);
1764         EXPP_ADDCONST(GL_AND_INVERTED);
1765         EXPP_ADDCONST(GL_NOOP);
1766         EXPP_ADDCONST(GL_XOR);
1767         EXPP_ADDCONST(GL_OR);
1768         EXPP_ADDCONST(GL_NOR);
1769         EXPP_ADDCONST(GL_EQUIV);
1770         EXPP_ADDCONST(GL_INVERT);
1771         EXPP_ADDCONST(GL_OR_REVERSE);
1772         EXPP_ADDCONST(GL_COPY_INVERTED);
1773         EXPP_ADDCONST(GL_OR_INVERTED);
1774         EXPP_ADDCONST(GL_NAND);
1775         EXPP_ADDCONST(GL_SET);
1776
1777         EXPP_ADDCONST(GL_EMISSION);
1778         EXPP_ADDCONST(GL_SHININESS);
1779         EXPP_ADDCONST(GL_AMBIENT_AND_DIFFUSE);
1780         EXPP_ADDCONST(GL_COLOR_INDEXES);
1781
1782         EXPP_ADDCONST(GL_MODELVIEW);
1783         EXPP_ADDCONST(GL_PROJECTION);
1784         EXPP_ADDCONST(GL_TEXTURE);
1785
1786         EXPP_ADDCONST(GL_COLOR);
1787         EXPP_ADDCONST(GL_DEPTH);
1788         EXPP_ADDCONST(GL_STENCIL);
1789
1790         EXPP_ADDCONST(GL_COLOR_INDEX);
1791         EXPP_ADDCONST(GL_STENCIL_INDEX);
1792         EXPP_ADDCONST(GL_DEPTH_COMPONENT);
1793         EXPP_ADDCONST(GL_RED);
1794         EXPP_ADDCONST(GL_GREEN);
1795         EXPP_ADDCONST(GL_BLUE);
1796         EXPP_ADDCONST(GL_ALPHA);
1797         EXPP_ADDCONST(GL_RGB);
1798         EXPP_ADDCONST(GL_RGBA);
1799         EXPP_ADDCONST(GL_LUMINANCE);
1800         EXPP_ADDCONST(GL_LUMINANCE_ALPHA);
1801
1802         EXPP_ADDCONST(GL_BITMAP);
1803
1804         EXPP_ADDCONST(GL_POINT);
1805         EXPP_ADDCONST(GL_LINE);
1806         EXPP_ADDCONST(GL_FILL);
1807
1808         EXPP_ADDCONST(GL_RENDER);
1809         EXPP_ADDCONST(GL_FEEDBACK);
1810         EXPP_ADDCONST(GL_SELECT);
1811
1812         EXPP_ADDCONST(GL_FLAT);
1813         EXPP_ADDCONST(GL_SMOOTH);
1814
1815         EXPP_ADDCONST(GL_KEEP);
1816         EXPP_ADDCONST(GL_REPLACE);
1817         EXPP_ADDCONST(GL_INCR);
1818         EXPP_ADDCONST(GL_DECR);
1819
1820         EXPP_ADDCONST(GL_VENDOR);
1821         EXPP_ADDCONST(GL_RENDERER);
1822         EXPP_ADDCONST(GL_VERSION);
1823         EXPP_ADDCONST(GL_EXTENSIONS);
1824
1825         EXPP_ADDCONST(GL_S);
1826         EXPP_ADDCONST(GL_T);
1827         EXPP_ADDCONST(GL_R);
1828         EXPP_ADDCONST(GL_Q);
1829
1830         EXPP_ADDCONST(GL_MODULATE);
1831         EXPP_ADDCONST(GL_DECAL);
1832
1833         EXPP_ADDCONST(GL_TEXTURE_ENV_MODE);
1834         EXPP_ADDCONST(GL_TEXTURE_ENV_COLOR);
1835
1836         EXPP_ADDCONST(GL_TEXTURE_ENV);
1837
1838         EXPP_ADDCONST(GL_EYE_LINEAR);
1839         EXPP_ADDCONST(GL_OBJECT_LINEAR);
1840         EXPP_ADDCONST(GL_SPHERE_MAP);
1841
1842         EXPP_ADDCONST(GL_TEXTURE_GEN_MODE);
1843         EXPP_ADDCONST(GL_OBJECT_PLANE);
1844         EXPP_ADDCONST(GL_EYE_PLANE);
1845
1846         EXPP_ADDCONST(GL_NEAREST);
1847         EXPP_ADDCONST(GL_LINEAR);
1848
1849         EXPP_ADDCONST(GL_NEAREST_MIPMAP_NEAREST);
1850         EXPP_ADDCONST(GL_LINEAR_MIPMAP_NEAREST);
1851         EXPP_ADDCONST(GL_NEAREST_MIPMAP_LINEAR);
1852         EXPP_ADDCONST(GL_LINEAR_MIPMAP_LINEAR);
1853
1854         EXPP_ADDCONST(GL_TEXTURE_MAG_FILTER);
1855         EXPP_ADDCONST(GL_TEXTURE_MIN_FILTER);
1856         EXPP_ADDCONST(GL_TEXTURE_WRAP_S);
1857         EXPP_ADDCONST(GL_TEXTURE_WRAP_T);
1858
1859         EXPP_ADDCONST(GL_CLAMP);
1860         EXPP_ADDCONST(GL_REPEAT);
1861
1862         EXPP_ADDCONST(GL_CLIP_PLANE0);
1863         EXPP_ADDCONST(GL_CLIP_PLANE1);
1864         EXPP_ADDCONST(GL_CLIP_PLANE2);
1865         EXPP_ADDCONST(GL_CLIP_PLANE3);
1866         EXPP_ADDCONST(GL_CLIP_PLANE4);
1867         EXPP_ADDCONST(GL_CLIP_PLANE5);
1868
1869         EXPP_ADDCONST(GL_LIGHT0);
1870         EXPP_ADDCONST(GL_LIGHT1);
1871         EXPP_ADDCONST(GL_LIGHT2);
1872         EXPP_ADDCONST(GL_LIGHT3);
1873         EXPP_ADDCONST(GL_LIGHT4);
1874         EXPP_ADDCONST(GL_LIGHT5);
1875         EXPP_ADDCONST(GL_LIGHT6);
1876         EXPP_ADDCONST(GL_LIGHT7);
1877         
1878         EXPP_ADDCONST(GL_POLYGON_OFFSET_UNITS);
1879         EXPP_ADDCONST(GL_POLYGON_OFFSET_POINT);
1880         EXPP_ADDCONST(GL_POLYGON_OFFSET_LINE);
1881         EXPP_ADDCONST(GL_POLYGON_OFFSET_FILL);
1882         EXPP_ADDCONST(GL_POLYGON_OFFSET_FACTOR);
1883         
1884         EXPP_ADDCONST(GL_TEXTURE_PRIORITY);
1885         EXPP_ADDCONST(GL_TEXTURE_RESIDENT);
1886         EXPP_ADDCONST(GL_TEXTURE_BINDING_1D);
1887         EXPP_ADDCONST(GL_TEXTURE_BINDING_2D);
1888
1889         EXPP_ADDCONST(GL_VERTEX_SHADER);
1890         EXPP_ADDCONST(GL_FRAGMENT_SHADER);
1891         EXPP_ADDCONST(GL_COMPILE_STATUS);
1892         EXPP_ADDCONST(GL_ACTIVE_TEXTURE);
1893
1894         EXPP_ADDCONST(GL_TEXTURE0);
1895         EXPP_ADDCONST(GL_TEXTURE1);
1896         EXPP_ADDCONST(GL_TEXTURE2);
1897         EXPP_ADDCONST(GL_TEXTURE3);
1898         EXPP_ADDCONST(GL_TEXTURE4);
1899         EXPP_ADDCONST(GL_TEXTURE5);
1900         EXPP_ADDCONST(GL_TEXTURE6);
1901         EXPP_ADDCONST(GL_TEXTURE7);
1902         EXPP_ADDCONST(GL_TEXTURE8);
1903
1904         EXPP_ADDCONST(GL_DEPTH_COMPONENT32);
1905         EXPP_ADDCONST(GL_TEXTURE_COMPARE_MODE);
1906
1907         return submodule;
1908 }
1909
1910 static PyObject *Method_ShaderSource (PyObject *UNUSED(self), PyObject *args)
1911 {
1912         int shader;
1913         char *source;
1914
1915         if (!PyArg_ParseTuple(args, "Is", &shader, &source))
1916                 return NULL;
1917
1918         glShaderSource(shader, 1, (const char **)&source, NULL);
1919
1920         return Py_INCREF(Py_None), Py_None;
1921 }
1922