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