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