Industry Compat keymap: Some curve edit keymap entries were using Click events
[blender.git] / source / blender / python / generic / bgl.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup pygen
19  *
20  * This file is the 'bgl' module which wraps OpenGL functions and constants,
21  * allowing script writers to make OpenGL calls in their Python scripts.
22  *
23  * \note
24  * This module is very similar to 'PyOpenGL' which could replace 'bgl' one day.
25  */
26
27 #include <Python.h>
28
29 #include "BLI_utildefines.h"
30
31 #include "GPU_glew.h"
32 #include "MEM_guardedalloc.h"
33
34 #include "../generic/py_capi_utils.h"
35
36 #include "bgl.h"
37
38 /* -------------------------------------------------------------------- */
39 /** \name Local utility defines for wrapping OpenGL
40  * \{ */
41
42 /*@ By golly George! It looks like fancy pants macro time!!! */
43
44 /* TYPE_str is the string to pass to Py_ArgParse (for the format) */
45 /* TYPE_var is the name to pass to the GL function */
46 /* TYPE_ref is the pointer to pass to Py_ArgParse (to store in) */
47 /* TYPE_def is the C initialization of the variable */
48
49 #define void_str ""
50 #define void_var(num)
51 #define void_ref(num) &bgl_var##num
52 #define void_def(num) char bgl_var##num
53
54 #if 0
55 #  define buffer_str "O!"
56 #  define buffer_var(number) (bgl_buffer##number)->buf.asvoid
57 #  define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number
58 #  define buffer_def(number) Buffer *bgl_buffer##number
59 #endif
60
61 /* GL Pointer fields, handled by buffer type */
62 /* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP, GLsizeiP, GLcharP */
63
64 #define GLbooleanP_str "O!"
65 #define GLbooleanP_var(number) (bgl_buffer##number)->buf.asvoid
66 #define GLbooleanP_ref(number) &BGL_bufferType, &bgl_buffer##number
67 #define GLbooleanP_def(number) Buffer *bgl_buffer##number
68
69 #define GLbyteP_str "O!"
70 #define GLbyteP_var(number) (bgl_buffer##number)->buf.asvoid
71 #define GLbyteP_ref(number) &BGL_bufferType, &bgl_buffer##number
72 #define GLbyteP_def(number) Buffer *bgl_buffer##number
73
74 #define GLubyteP_str "O!"
75 #define GLubyteP_var(number) (bgl_buffer##number)->buf.asvoid
76 #define GLubyteP_ref(number) &BGL_bufferType, &bgl_buffer##number
77 #define GLubyteP_def(number) Buffer *bgl_buffer##number
78
79 #define GLintP_str "O!"
80 #define GLintP_var(number) (bgl_buffer##number)->buf.asvoid
81 #define GLintP_ref(number) &BGL_bufferType, &bgl_buffer##number
82 #define GLintP_def(number) Buffer *bgl_buffer##number
83
84 #define GLint64P_str "O!"
85 #define GLint64P_var(number) (bgl_buffer##number)->buf.asvoid
86 #define GLint64P_ref(number) &BGL_bufferType, &bgl_buffer##number
87 #define GLint64P_def(number) Buffer *bgl_buffer##number
88
89 #define GLenumP_str "O!"
90 #define GLenumP_var(number) (bgl_buffer##number)->buf.asvoid
91 #define GLenumP_ref(number) &BGL_bufferType, &bgl_buffer##number
92 #define GLenumP_def(number) Buffer *bgl_buffer##number
93
94 #define GLuintP_str "O!"
95 #define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid
96 #define GLuintP_ref(number) &BGL_bufferType, &bgl_buffer##number
97 #define GLuintP_def(number) Buffer *bgl_buffer##number
98
99 #if 0
100 #  define GLuint64P_str "O!"
101 #  define GLuint64P_var(number) (bgl_buffer##number)->buf.asvoid
102 #  define GLuint64P_ref(number) &BGL_bufferType, &bgl_buffer##number
103 #  define GLuint64P_def(number) Buffer *bgl_buffer##number
104 #endif
105
106 #define GLshortP_str "O!"
107 #define GLshortP_var(number) (bgl_buffer##number)->buf.asvoid
108 #define GLshortP_ref(number) &BGL_bufferType, &bgl_buffer##number
109 #define GLshortP_def(number) Buffer *bgl_buffer##number
110
111 #define GLushortP_str "O!"
112 #define GLushortP_var(number) (bgl_buffer##number)->buf.asvoid
113 #define GLushortP_ref(number) &BGL_bufferType, &bgl_buffer##number
114 #define GLushortP_def(number) Buffer *bgl_buffer##number
115
116 #define GLfloatP_str "O!"
117 #define GLfloatP_var(number) (bgl_buffer##number)->buf.asvoid
118 #define GLfloatP_ref(number) &BGL_bufferType, &bgl_buffer##number
119 #define GLfloatP_def(number) Buffer *bgl_buffer##number
120
121 #define GLdoubleP_str "O!"
122 #define GLdoubleP_var(number) (bgl_buffer##number)->buf.asvoid
123 #define GLdoubleP_ref(number) &BGL_bufferType, &bgl_buffer##number
124 #define GLdoubleP_def(number) Buffer *bgl_buffer##number
125
126 #if 0
127 #  define GLclampfP_str "O!"
128 #  define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid
129 #  define GLclampfP_ref(number) &BGL_bufferType, &bgl_buffer##number
130 #  define GLclampfP_def(number) Buffer *bgl_buffer##number
131 #endif
132
133 typedef struct BufferOrOffset {
134   Buffer *buffer;
135   void *offset;
136 } BufferOrOffset;
137
138 #define GLvoidP_str "O&"
139 #define GLvoidP_var(number) \
140   ((bgl_buffer##number.buffer) ? (bgl_buffer##number.buffer)->buf.asvoid : \
141                                  (bgl_buffer##number.offset))
142 #define GLvoidP_ref(number) BGL_BufferOrOffsetConverter, &bgl_buffer##number
143 #define GLvoidP_def(number) BufferOrOffset bgl_buffer##number
144
145 #define GLsizeiP_str "O!"
146 #define GLsizeiP_var(number) (bgl_buffer##number)->buf.asvoid
147 #define GLsizeiP_ref(number) &BGL_bufferType, &bgl_buffer##number
148 #define GLsizeiP_def(number) Buffer *bgl_buffer##number
149
150 #define GLcharP_str "O!"
151 #define GLcharP_var(number) (bgl_buffer##number)->buf.asvoid
152 #define GLcharP_ref(number) &BGL_bufferType, &bgl_buffer##number
153 #define GLcharP_def(number) Buffer *bgl_buffer##number
154
155 #if 0
156 #  define buffer_str "O!"
157 #  define buffer_var(number) (bgl_buffer##number)->buf.asvoid
158 #  define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number
159 #  define buffer_def(number) Buffer *bgl_buffer##number
160 #endif
161
162 /*@The standard GL typedefs are used as prototypes, we can't
163  * use the GL type directly because Py_ArgParse expects normal
164  * C types.
165  *
166  * Py_ArgParse doesn't grok writing into unsigned variables,
167  * so we use signed everything (even stuff that should be unsigned.
168  */
169
170 /* typedef unsigned int GLenum; */
171 #define GLenum_str "i"
172 #define GLenum_var(num) bgl_var##num
173 #define GLenum_ref(num) &bgl_var##num
174 #define GLenum_def(num) /* unsigned */ int GLenum_var(num)
175
176 /* typedef unsigned int GLboolean; */
177 #define GLboolean_str "b"
178 #define GLboolean_var(num) bgl_var##num
179 #define GLboolean_ref(num) &bgl_var##num
180 #define GLboolean_def(num) /* unsigned */ char GLboolean_var(num)
181
182 /* typedef unsigned int GLbitfield; */
183 #define GLbitfield_str "i"
184 #define GLbitfield_var(num) bgl_var##num
185 #define GLbitfield_ref(num) &bgl_var##num
186 #define GLbitfield_def(num) /* unsigned */ int GLbitfield_var(num)
187
188 #if 0
189 /* typedef signed char GLbyte; */
190 #  define GLbyte_str "b"
191 #  define GLbyte_var(num) bgl_var##num
192 #  define GLbyte_ref(num) &bgl_var##num
193 #  define GLbyte_def(num) signed char GLbyte_var(num)
194 #endif
195
196 /* typedef short GLshort; */
197 #define GLshort_str "h"
198 #define GLshort_var(num) bgl_var##num
199 #define GLshort_ref(num) &bgl_var##num
200 #define GLshort_def(num) short GLshort_var(num)
201
202 /* typedef int GLint; */
203 #define GLint_str "i"
204 #define GLint_var(num) bgl_var##num
205 #define GLint_ref(num) &bgl_var##num
206 #define GLint_def(num) int GLint_var(num)
207
208 /* typedef int GLsizei; */
209 #define GLsizei_str "n"
210 #define GLsizei_var(num) bgl_var##num
211 #define GLsizei_ref(num) &bgl_var##num
212 #define GLsizei_def(num) size_t GLsizei_var(num)
213
214 /* typedef int GLsizeiptr; */
215 #define GLsizeiptr_str "n"
216 #define GLsizeiptr_var(num) bgl_var##num
217 #define GLsizeiptr_ref(num) &bgl_var##num
218 #define GLsizeiptr_def(num) size_t GLsizeiptr_var(num)
219
220 /* typedef int GLintptr; */
221 #define GLintptr_str "n"
222 #define GLintptr_var(num) bgl_var##num
223 #define GLintptr_ref(num) &bgl_var##num
224 #define GLintptr_def(num) size_t GLintptr_var(num)
225
226 /* typedef unsigned char GLubyte; */
227 #define GLubyte_str "B"
228 #define GLubyte_var(num) bgl_var##num
229 #define GLubyte_ref(num) &bgl_var##num
230 #define GLubyte_def(num) /* unsigned */ char GLubyte_var(num)
231
232 #if 0
233 /* typedef unsigned short GLushort; */
234 #  define GLushort_str "H"
235 #  define GLushort_var(num) bgl_var##num
236 #  define GLushort_ref(num) &bgl_var##num
237 #  define GLushort_def(num) /* unsigned */ short GLushort_var(num)
238 #endif
239
240 /* typedef unsigned int GLuint; */
241 #define GLuint_str "I"
242 #define GLuint_var(num) bgl_var##num
243 #define GLuint_ref(num) &bgl_var##num
244 #define GLuint_def(num) /* unsigned */ int GLuint_var(num)
245
246 /* typedef unsigned int GLuint64; */
247 #if 0
248 #  define GLuint64_str "Q"
249 #  define GLuint64_var(num) bgl_var##num
250 #  define GLuint64_ref(num) &bgl_var##num
251 #  define GLuint64_def(num) /* unsigned */ int GLuint64_var(num)
252 #endif
253
254 /* typedef unsigned int GLsync; */
255 #if 0
256 #  define GLsync_str "I"
257 #  define GLsync_var(num) bgl_var##num
258 #  define GLsync_ref(num) &bgl_var##num
259 #  define GLsync_def(num) /* unsigned */ int GLsync_var(num)
260 #endif
261
262 /* typedef float GLfloat; */
263 #define GLfloat_str "f"
264 #define GLfloat_var(num) bgl_var##num
265 #define GLfloat_ref(num) &bgl_var##num
266 #define GLfloat_def(num) float GLfloat_var(num)
267
268 /* typedef char *GLstring; */
269 #define GLstring_str "s"
270 #define GLstring_var(number) bgl_var##number
271 #define GLstring_ref(number) &bgl_var##number
272 #define GLstring_def(number) char *GLstring_var(number)
273
274 /* typedef float GLclampf; */
275 #if 0
276 #  define GLclampf_str "f"
277 #  define GLclampf_var(num) bgl_var##num
278 #  define GLclampf_ref(num) &bgl_var##num
279 #  define GLclampf_def(num) float GLclampf_var(num)
280 #endif
281
282 /* typedef double GLdouble; */
283 #define GLdouble_str "d"
284 #define GLdouble_var(num) bgl_var##num
285 #define GLdouble_ref(num) &bgl_var##num
286 #define GLdouble_def(num) double GLdouble_var(num)
287
288 /* typedef double GLclampd; */
289 #if 0
290 #  define GLclampd_str "d"
291 #  define GLclampd_var(num) bgl_var##num
292 #  define GLclampd_ref(num) &bgl_var##num
293 #  define GLclampd_def(num) double GLclampd_var(num)
294 #endif
295
296 #define _arg_def1(a1) a1##_def(1)
297 #define _arg_def2(a1, a2) \
298   _arg_def1(a1); \
299   a2##_def(2)
300 #define _arg_def3(a1, a2, a3) \
301   _arg_def2(a1, a2); \
302   a3##_def(3)
303 #define _arg_def4(a1, a2, a3, a4) \
304   _arg_def3(a1, a2, a3); \
305   a4##_def(4)
306 #define _arg_def5(a1, a2, a3, a4, a5) \
307   _arg_def4(a1, a2, a3, a4); \
308   a5##_def(5)
309 #define _arg_def6(a1, a2, a3, a4, a5, a6) \
310   _arg_def5(a1, a2, a3, a4, a5); \
311   a6##_def(6)
312 #define _arg_def7(a1, a2, a3, a4, a5, a6, a7) \
313   _arg_def6(a1, a2, a3, a4, a5, a6); \
314   a7##_def(7)
315 #define _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8) \
316   _arg_def7(a1, a2, a3, a4, a5, a6, a7); \
317   a8##_def(8)
318 #define _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \
319   _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8); \
320   a9##_def(9)
321 #define _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
322   _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9); \
323   a10##_def(10)
324 #define _arg_def11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
325   _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); \
326   a11##_def(11)
327 #define arg_def(...) VA_NARGS_CALL_OVERLOAD(_arg_def, __VA_ARGS__)
328
329 #define _arg_var1(a1) a1##_var(1)
330 #define _arg_var2(a1, a2) _arg_var1(a1), a2##_var(2)
331 #define _arg_var3(a1, a2, a3) _arg_var2(a1, a2), a3##_var(3)
332 #define _arg_var4(a1, a2, a3, a4) _arg_var3(a1, a2, a3), a4##_var(4)
333 #define _arg_var5(a1, a2, a3, a4, a5) _arg_var4(a1, a2, a3, a4), a5##_var(5)
334 #define _arg_var6(a1, a2, a3, a4, a5, a6) _arg_var5(a1, a2, a3, a4, a5), a6##_var(6)
335 #define _arg_var7(a1, a2, a3, a4, a5, a6, a7) _arg_var6(a1, a2, a3, a4, a5, a6), a7##_var(7)
336 #define _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8) \
337   _arg_var7(a1, a2, a3, a4, a5, a6, a7), a8##_var(8)
338 #define _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \
339   _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_var(9)
340 #define _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
341   _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_var(10)
342 #define _arg_var11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
343   _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_var(11)
344 #define arg_var(...) VA_NARGS_CALL_OVERLOAD(_arg_var, __VA_ARGS__)
345
346 #define _arg_ref1(a1) a1##_ref(1)
347 #define _arg_ref2(a1, a2) _arg_ref1(a1), a2##_ref(2)
348 #define _arg_ref3(a1, a2, a3) _arg_ref2(a1, a2), a3##_ref(3)
349 #define _arg_ref4(a1, a2, a3, a4) _arg_ref3(a1, a2, a3), a4##_ref(4)
350 #define _arg_ref5(a1, a2, a3, a4, a5) _arg_ref4(a1, a2, a3, a4), a5##_ref(5)
351 #define _arg_ref6(a1, a2, a3, a4, a5, a6) _arg_ref5(a1, a2, a3, a4, a5), a6##_ref(6)
352 #define _arg_ref7(a1, a2, a3, a4, a5, a6, a7) _arg_ref6(a1, a2, a3, a4, a5, a6), a7##_ref(7)
353 #define _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8) \
354   _arg_ref7(a1, a2, a3, a4, a5, a6, a7), a8##_ref(8)
355 #define _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \
356   _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_ref(9)
357 #define _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
358   _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_ref(10)
359 #define _arg_ref11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
360   _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_ref(11)
361 #define arg_ref(...) VA_NARGS_CALL_OVERLOAD(_arg_ref, __VA_ARGS__)
362
363 #define _arg_str1(a1) a1##_str
364 #define _arg_str2(a1, a2) _arg_str1(a1) a2##_str
365 #define _arg_str3(a1, a2, a3) _arg_str2(a1, a2) a3##_str
366 #define _arg_str4(a1, a2, a3, a4) _arg_str3(a1, a2, a3) a4##_str
367 #define _arg_str5(a1, a2, a3, a4, a5) _arg_str4(a1, a2, a3, a4) a5##_str
368 #define _arg_str6(a1, a2, a3, a4, a5, a6) _arg_str5(a1, a2, a3, a4, a5) a6##_str
369 #define _arg_str7(a1, a2, a3, a4, a5, a6, a7) _arg_str6(a1, a2, a3, a4, a5, a6) a7##_str
370 #define _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) _arg_str7(a1, a2, a3, a4, a5, a6, a7) a8##_str
371 #define _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \
372   _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) a9##_str
373 #define _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
374   _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) a10##_str
375 #define _arg_str11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
376   _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) a11##_str
377 #define arg_str(...) VA_NARGS_CALL_OVERLOAD(_arg_str, __VA_ARGS__)
378
379 #define ret_def_void
380 #define ret_set_void
381 #define ret_ret_void return Py_INCREF(Py_None), Py_None
382
383 #define ret_def_GLint int ret_int
384 #define ret_set_GLint ret_int =
385 #define ret_ret_GLint return PyLong_FromLong(ret_int)
386
387 #define ret_def_GLuint unsigned int ret_uint
388 #define ret_set_GLuint ret_uint =
389 #define ret_ret_GLuint return PyLong_FromLong((long)ret_uint)
390
391 #if 0
392 #  define ret_def_GLsizei size_t ret_size_t
393 #  define ret_set_GLsizei ret_size_t =
394 #  define ret_ret_GLsizei return PyLong_FromSsize_t(ret_size_t)
395 #endif
396
397 #if 0
398 #  define ret_def_GLsync unsigned int ret_sync
399 #  define ret_set_GLsync ret_sync =
400 #  define ret_ret_GLsync return PyLong_FromLong((long)ret_sync)
401 #endif
402
403 #define ret_def_GLenum unsigned int ret_uint
404 #define ret_set_GLenum ret_uint =
405 #define ret_ret_GLenum return PyLong_FromLong((long)ret_uint)
406
407 #define ret_def_GLboolean unsigned char ret_bool
408 #define ret_set_GLboolean ret_bool =
409 #define ret_ret_GLboolean return PyLong_FromLong((long)ret_bool)
410
411 #define ret_def_GLstring const unsigned char *ret_str
412 #define ret_set_GLstring ret_str =
413
414 #define ret_ret_GLstring \
415   if (ret_str) { \
416     return PyUnicode_FromString((const char *)ret_str); \
417   } \
418   else { \
419     PyErr_SetString(PyExc_AttributeError, "could not get opengl string"); \
420     return NULL; \
421   }
422
423 /** \} */
424
425 /* -------------------------------------------------------------------- */
426 /* Forward Declarations */
427
428 static PyObject *Buffer_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
429 static PyObject *Method_ShaderSource(PyObject *self, PyObject *args);
430
431 /* Buffer sequence methods */
432
433 static int Buffer_len(Buffer *self);
434 static PyObject *Buffer_item(Buffer *self, int i);
435 static PyObject *Buffer_slice(Buffer *self, int begin, int end);
436 static int Buffer_ass_item(Buffer *self, int i, PyObject *v);
437 static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq);
438 static PyObject *Buffer_subscript(Buffer *self, PyObject *item);
439 static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value);
440
441 /* -------------------------------------------------------------------- */
442 /** \name Utility Functions
443  * \{ */
444
445 int BGL_typeSize(int type)
446 {
447   switch (type) {
448     case GL_BYTE:
449       return sizeof(char);
450     case GL_SHORT:
451       return sizeof(short);
452     case GL_INT:
453       return sizeof(int);
454     case GL_FLOAT:
455       return sizeof(float);
456     case GL_DOUBLE:
457       return sizeof(double);
458   }
459   return -1;
460 }
461
462 static int gl_buffer_type_from_py_buffer(Py_buffer *pybuffer)
463 {
464   const char format = PyC_StructFmt_type_from_str(pybuffer->format);
465   Py_ssize_t itemsize = pybuffer->itemsize;
466
467   if (PyC_StructFmt_type_is_float_any(format)) {
468     if (itemsize == 4) {
469       return GL_FLOAT;
470     }
471     if (itemsize == 8) {
472       return GL_DOUBLE;
473     }
474   }
475   if (PyC_StructFmt_type_is_byte(format) || PyC_StructFmt_type_is_int_any(format)) {
476     if (itemsize == 1) {
477       return GL_BYTE;
478     }
479     if (itemsize == 2) {
480       return GL_SHORT;
481     }
482     if (itemsize == 4) {
483       return GL_INT;
484     }
485   }
486
487   return -1; /* UNKNOWN */
488 }
489
490 static bool compare_dimensions(int ndim, int *dim1, Py_ssize_t *dim2)
491 {
492   for (int i = 0; i < ndim; i++) {
493     if (dim1[i] != dim2[i]) {
494       return false;
495     }
496   }
497   return true;
498 }
499
500 /** \} */
501
502 /* -------------------------------------------------------------------- */
503 /** \name Buffer API
504  * \{ */
505
506 static PySequenceMethods Buffer_SeqMethods = {
507     (lenfunc)Buffer_len,              /*sq_length */
508     (binaryfunc)NULL,                 /*sq_concat */
509     (ssizeargfunc)NULL,               /*sq_repeat */
510     (ssizeargfunc)Buffer_item,        /*sq_item */
511     (ssizessizeargfunc)NULL,          /*sq_slice, deprecated, handled in Buffer_item */
512     (ssizeobjargproc)Buffer_ass_item, /*sq_ass_item */
513     (ssizessizeobjargproc)NULL,       /*sq_ass_slice, deprecated handled in Buffer_ass_item */
514     (objobjproc)NULL,                 /* sq_contains */
515     (binaryfunc)NULL,                 /* sq_inplace_concat */
516     (ssizeargfunc)NULL,               /* sq_inplace_repeat */
517 };
518
519 static PyMappingMethods Buffer_AsMapping = {
520     (lenfunc)Buffer_len,
521     (binaryfunc)Buffer_subscript,
522     (objobjargproc)Buffer_ass_subscript,
523 };
524
525 static void Buffer_dealloc(Buffer *self);
526 static PyObject *Buffer_repr(Buffer *self);
527
528 static PyObject *Buffer_to_list(Buffer *self)
529 {
530   int i, len = self->dimensions[0];
531   PyObject *list = PyList_New(len);
532
533   for (i = 0; i < len; i++) {
534     PyList_SET_ITEM(list, i, Buffer_item(self, i));
535   }
536
537   return list;
538 }
539
540 static PyObject *Buffer_to_list_recursive(Buffer *self)
541 {
542   PyObject *list;
543
544   if (self->ndimensions > 1) {
545     int i, len = self->dimensions[0];
546     list = PyList_New(len);
547
548     for (i = 0; i < len; i++) {
549       Buffer *sub = (Buffer *)Buffer_item(self, i);
550       PyList_SET_ITEM(list, i, Buffer_to_list_recursive(sub));
551       Py_DECREF(sub);
552     }
553   }
554   else {
555     list = Buffer_to_list(self);
556   }
557
558   return list;
559 }
560
561 static PyObject *Buffer_dimensions(Buffer *self, void *UNUSED(arg))
562 {
563   PyObject *list = PyList_New(self->ndimensions);
564   int i;
565
566   for (i = 0; i < self->ndimensions; i++) {
567     PyList_SET_ITEM(list, i, PyLong_FromLong(self->dimensions[i]));
568   }
569
570   return list;
571 }
572
573 static PyMethodDef Buffer_methods[] = {
574     {"to_list", (PyCFunction)Buffer_to_list_recursive, METH_NOARGS, "return the buffer as a list"},
575     {NULL, NULL, 0, NULL},
576 };
577
578 static PyGetSetDef Buffer_getseters[] = {
579     {(char *)"dimensions", (getter)Buffer_dimensions, NULL, NULL, NULL},
580     {NULL, NULL, NULL, NULL, NULL},
581 };
582
583 PyTypeObject BGL_bufferType = {
584     PyVarObject_HEAD_INIT(NULL, 0) "bgl.Buffer", /*tp_name */
585     sizeof(Buffer),                              /*tp_basicsize */
586     0,                                           /*tp_itemsize */
587     (destructor)Buffer_dealloc,                  /*tp_dealloc */
588     (printfunc)NULL,                             /*tp_print */
589     NULL,                                        /*tp_getattr */
590     NULL,                                        /*tp_setattr */
591     NULL,                                        /*tp_compare */
592     (reprfunc)Buffer_repr,                       /*tp_repr */
593     NULL,                                        /*tp_as_number */
594     &Buffer_SeqMethods,                          /*tp_as_sequence */
595     &Buffer_AsMapping,                           /* PyMappingMethods *tp_as_mapping; */
596
597     /* More standard operations (here for binary compatibility) */
598
599     NULL, /* hashfunc tp_hash; */
600     NULL, /* ternaryfunc tp_call; */
601     NULL, /* reprfunc tp_str; */
602     NULL, /* getattrofunc tp_getattro; */
603     NULL, /* setattrofunc tp_setattro; */
604
605     /* Functions to access object as input/output buffer */
606     NULL, /* PyBufferProcs *tp_as_buffer; */
607
608     /*** Flags to define presence of optional/expanded features ***/
609     Py_TPFLAGS_DEFAULT, /* long tp_flags; */
610
611     NULL, /*  char *tp_doc;  Documentation string */
612     /*** Assigned meaning in release 2.0 ***/
613     /* call function for all accessible objects */
614     NULL, /* traverseproc tp_traverse; */
615
616     /* delete references to contained objects */
617     NULL, /* inquiry tp_clear; */
618
619     /***  Assigned meaning in release 2.1 ***/
620     /*** rich comparisons ***/
621     NULL, /* richcmpfunc tp_richcompare; */
622
623     /***  weak reference enabler ***/
624     0, /* long tp_weaklistoffset; */
625
626     /*** Added in release 2.2 ***/
627     /*   Iterators */
628     NULL, /* getiterfunc tp_iter; */
629     NULL, /* iternextfunc tp_iternext; */
630     /*** Attribute descriptor and subclassing stuff ***/
631     Buffer_methods,   /* struct PyMethodDef *tp_methods; */
632     NULL,             /* struct PyMemberDef *tp_members; */
633     Buffer_getseters, /* struct PyGetSetDef *tp_getset; */
634     NULL,             /*tp_base*/
635     NULL,             /*tp_dict*/
636     NULL,             /*tp_descr_get*/
637     NULL,             /*tp_descr_set*/
638     0,                /*tp_dictoffset*/
639     NULL,             /*tp_init*/
640     NULL,             /*tp_alloc*/
641     Buffer_new,       /*tp_new*/
642     NULL,             /*tp_free*/
643     NULL,             /*tp_is_gc*/
644     NULL,             /*tp_bases*/
645     NULL,             /*tp_mro*/
646     NULL,             /*tp_cache*/
647     NULL,             /*tp_subclasses*/
648     NULL,             /*tp_weaklist*/
649     NULL,             /*tp_del*/
650 };
651
652 static Buffer *BGL_MakeBuffer_FromData(
653     PyObject *parent, int type, int ndimensions, int *dimensions, void *buf)
654 {
655   Buffer *buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
656
657   Py_XINCREF(parent);
658   buffer->parent = parent;
659   buffer->ndimensions = ndimensions;
660   buffer->dimensions = MEM_mallocN(ndimensions * sizeof(int), "Buffer dimensions");
661   memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int));
662   buffer->type = type;
663   buffer->buf.asvoid = buf;
664
665   return buffer;
666 }
667
668 /**
669  * Create a buffer object
670  *
671  * \param dimensions: An array of ndimensions integers representing the size of each dimension.
672  * \param initbuffer: When not NULL holds a contiguous buffer
673  * with the correct format from which the buffer will be initialized
674  */
675 Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuffer)
676 {
677   Buffer *buffer;
678   void *buf = NULL;
679   int i, size = BGL_typeSize(type);
680
681   for (i = 0; i < ndimensions; i++) {
682     size *= dimensions[i];
683   }
684
685   buf = MEM_mallocN(size, "Buffer buffer");
686
687   buffer = BGL_MakeBuffer_FromData(NULL, type, ndimensions, dimensions, buf);
688
689   if (initbuffer) {
690     memcpy(buffer->buf.asvoid, initbuffer, size);
691   }
692   else {
693     memset(buffer->buf.asvoid, 0, size);
694   }
695   return buffer;
696 }
697
698 /* Custom converter function so we can support a buffer, an integer or NULL.
699  * Many OpenGL API functions can accept both an actual pointer or an offset
700  * into a buffer that is already bound. */
701 static int BGL_BufferOrOffsetConverter(PyObject *object, BufferOrOffset *buffer)
702 {
703   if (object == Py_None) {
704     buffer->buffer = NULL;
705     buffer->offset = NULL;
706     return 1;
707   }
708   else if (PyNumber_Check(object)) {
709     Py_ssize_t offset = PyNumber_AsSsize_t(object, PyExc_IndexError);
710     if (offset == -1 && PyErr_Occurred()) {
711       return 0;
712     }
713
714     buffer->buffer = NULL;
715     buffer->offset = (void *)offset;
716     return 1;
717   }
718   else if (PyObject_TypeCheck(object, &BGL_bufferType)) {
719     buffer->buffer = (Buffer *)object;
720     buffer->offset = NULL;
721     return 1;
722   }
723   else {
724     PyErr_SetString(PyExc_TypeError, "expected a bgl.Buffer or None");
725     return 0;
726   }
727 }
728
729 #define MAX_DIMENSIONS 256
730 static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
731 {
732   PyObject *length_ob = NULL, *init = NULL;
733   Buffer *buffer = NULL;
734   int dimensions[MAX_DIMENSIONS];
735
736   int type;
737   Py_ssize_t i, ndimensions = 0;
738
739   if (kwds && PyDict_Size(kwds)) {
740     PyErr_SetString(PyExc_TypeError, "bgl.Buffer(): takes no keyword args");
741     return NULL;
742   }
743
744   if (!PyArg_ParseTuple(args, "iO|O: bgl.Buffer", &type, &length_ob, &init)) {
745     return NULL;
746   }
747   if (!ELEM(type, GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE)) {
748     PyErr_SetString(PyExc_AttributeError,
749                     "invalid first argument type, should be one of "
750                     "GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE");
751     return NULL;
752   }
753
754   if (PyLong_Check(length_ob)) {
755     ndimensions = 1;
756     if (((dimensions[0] = PyLong_AsLong(length_ob)) < 1)) {
757       PyErr_SetString(PyExc_AttributeError,
758                       "dimensions must be between 1 and " STRINGIFY(MAX_DIMENSIONS));
759       return NULL;
760     }
761   }
762   else if (PySequence_Check(length_ob)) {
763     ndimensions = PySequence_Size(length_ob);
764     if (ndimensions > MAX_DIMENSIONS) {
765       PyErr_SetString(PyExc_AttributeError,
766                       "too many dimensions, max is " STRINGIFY(MAX_DIMENSIONS));
767       return NULL;
768     }
769     else if (ndimensions < 1) {
770       PyErr_SetString(PyExc_AttributeError, "sequence must have at least one dimension");
771       return NULL;
772     }
773     for (i = 0; i < ndimensions; i++) {
774       PyObject *ob = PySequence_GetItem(length_ob, i);
775
776       if (!PyLong_Check(ob)) {
777         dimensions[i] = 1;
778       }
779       else {
780         dimensions[i] = PyLong_AsLong(ob);
781       }
782       Py_DECREF(ob);
783
784       if (dimensions[i] < 1) {
785         PyErr_SetString(PyExc_AttributeError,
786                         "dimensions must be between 1 and " STRINGIFY(MAX_DIMENSIONS));
787         return NULL;
788       }
789     }
790   }
791   else {
792     PyErr_Format(PyExc_TypeError,
793                  "invalid second argument argument expected a sequence "
794                  "or an int, not a %.200s",
795                  Py_TYPE(length_ob)->tp_name);
796     return NULL;
797   }
798
799   if (init && PyObject_CheckBuffer(init)) {
800     Py_buffer pybuffer;
801
802     if (PyObject_GetBuffer(init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) {
803       /* PyObject_GetBuffer raise a PyExc_BufferError */
804       return NULL;
805     }
806
807     if (type != gl_buffer_type_from_py_buffer(&pybuffer)) {
808       PyErr_Format(PyExc_TypeError,
809                    "`GL_TYPE` and `typestr` of object with buffer interface do not match. '%s'",
810                    pybuffer.format);
811     }
812     else if (ndimensions != pybuffer.ndim ||
813              !compare_dimensions(ndimensions, dimensions, pybuffer.shape)) {
814       PyErr_Format(PyExc_TypeError, "array size does not match");
815     }
816     else {
817       buffer = BGL_MakeBuffer_FromData(init, type, pybuffer.ndim, dimensions, pybuffer.buf);
818     }
819
820     PyBuffer_Release(&pybuffer);
821   }
822   else {
823     buffer = BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
824     if (init && Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
825       Py_DECREF(buffer);
826       return NULL;
827     }
828   }
829
830   return (PyObject *)buffer;
831 }
832
833 /* Buffer sequence methods */
834
835 static int Buffer_len(Buffer *self)
836 {
837   return self->dimensions[0];
838 }
839
840 static PyObject *Buffer_item(Buffer *self, int i)
841 {
842   if (i >= self->dimensions[0] || i < 0) {
843     PyErr_SetString(PyExc_IndexError, "array index out of range");
844     return NULL;
845   }
846
847   if (self->ndimensions == 1) {
848     switch (self->type) {
849       case GL_BYTE:
850         return Py_BuildValue("b", self->buf.asbyte[i]);
851       case GL_SHORT:
852         return Py_BuildValue("h", self->buf.asshort[i]);
853       case GL_INT:
854         return Py_BuildValue("i", self->buf.asint[i]);
855       case GL_FLOAT:
856         return PyFloat_FromDouble(self->buf.asfloat[i]);
857       case GL_DOUBLE:
858         return Py_BuildValue("d", self->buf.asdouble[i]);
859     }
860   }
861   else {
862     int j, offset = i * BGL_typeSize(self->type);
863
864     for (j = 1; j < self->ndimensions; j++) {
865       offset *= self->dimensions[j];
866     }
867
868     return (PyObject *)BGL_MakeBuffer_FromData((PyObject *)self,
869                                                self->type,
870                                                self->ndimensions - 1,
871                                                self->dimensions + 1,
872                                                self->buf.asbyte + offset);
873   }
874
875   return NULL;
876 }
877
878 static PyObject *Buffer_slice(Buffer *self, int begin, int end)
879 {
880   PyObject *list;
881   int count;
882
883   if (begin < 0) {
884     begin = 0;
885   }
886   if (end > self->dimensions[0]) {
887     end = self->dimensions[0];
888   }
889   if (begin > end) {
890     begin = end;
891   }
892
893   list = PyList_New(end - begin);
894
895   for (count = begin; count < end; count++) {
896     PyList_SET_ITEM(list, count - begin, Buffer_item(self, count));
897   }
898   return list;
899 }
900
901 static int Buffer_ass_item(Buffer *self, int i, PyObject *v)
902 {
903   if (i >= self->dimensions[0] || i < 0) {
904     PyErr_SetString(PyExc_IndexError, "array assignment index out of range");
905     return -1;
906   }
907
908   if (self->ndimensions != 1) {
909     Buffer *row = (Buffer *)Buffer_item(self, i);
910
911     if (row) {
912       int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v);
913       Py_DECREF(row);
914       return ret;
915     }
916     else {
917       return -1;
918     }
919   }
920
921   switch (self->type) {
922     case GL_BYTE:
923       return PyArg_Parse(v, "b:Expected ints", &self->buf.asbyte[i]) ? 0 : -1;
924     case GL_SHORT:
925       return PyArg_Parse(v, "h:Expected ints", &self->buf.asshort[i]) ? 0 : -1;
926     case GL_INT:
927       return PyArg_Parse(v, "i:Expected ints", &self->buf.asint[i]) ? 0 : -1;
928     case GL_FLOAT:
929       return PyArg_Parse(v, "f:Expected floats", &self->buf.asfloat[i]) ? 0 : -1;
930     case GL_DOUBLE:
931       return PyArg_Parse(v, "d:Expected floats", &self->buf.asdouble[i]) ? 0 : -1;
932     default:
933       return 0; /* should never happen */
934   }
935 }
936
937 static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq)
938 {
939   PyObject *item;
940   int count, err = 0;
941
942   if (begin < 0) {
943     begin = 0;
944   }
945   if (end > self->dimensions[0]) {
946     end = self->dimensions[0];
947   }
948   if (begin > end) {
949     begin = end;
950   }
951
952   if (!PySequence_Check(seq)) {
953     PyErr_Format(PyExc_TypeError,
954                  "buffer[:] = value, invalid assignment. "
955                  "Expected a sequence, not an %.200s type",
956                  Py_TYPE(seq)->tp_name);
957     return -1;
958   }
959
960   /* re-use count var */
961   if ((count = PySequence_Size(seq)) != (end - begin)) {
962     PyErr_Format(PyExc_TypeError,
963                  "buffer[:] = value, size mismatch in assignment. "
964                  "Expected: %d (given: %d)",
965                  count,
966                  end - begin);
967     return -1;
968   }
969
970   for (count = begin; count < end; count++) {
971     item = PySequence_GetItem(seq, count - begin);
972     if (item) {
973       err = Buffer_ass_item(self, count, item);
974       Py_DECREF(item);
975     }
976     else {
977       err = -1;
978     }
979     if (err) {
980       break;
981     }
982   }
983   return err;
984 }
985
986 static PyObject *Buffer_subscript(Buffer *self, PyObject *item)
987 {
988   if (PyIndex_Check(item)) {
989     Py_ssize_t i;
990     i = PyNumber_AsSsize_t(item, PyExc_IndexError);
991     if (i == -1 && PyErr_Occurred()) {
992       return NULL;
993     }
994     if (i < 0) {
995       i += self->dimensions[0];
996     }
997     return Buffer_item(self, i);
998   }
999   else if (PySlice_Check(item)) {
1000     Py_ssize_t start, stop, step, slicelength;
1001
1002     if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) {
1003       return NULL;
1004     }
1005
1006     if (slicelength <= 0) {
1007       return PyTuple_New(0);
1008     }
1009     else if (step == 1) {
1010       return Buffer_slice(self, start, stop);
1011     }
1012     else {
1013       PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
1014       return NULL;
1015     }
1016   }
1017   else {
1018     PyErr_Format(
1019         PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
1020     return NULL;
1021   }
1022 }
1023
1024 static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value)
1025 {
1026   if (PyIndex_Check(item)) {
1027     Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1028     if (i == -1 && PyErr_Occurred()) {
1029       return -1;
1030     }
1031     if (i < 0) {
1032       i += self->dimensions[0];
1033     }
1034     return Buffer_ass_item(self, i, value);
1035   }
1036   else if (PySlice_Check(item)) {
1037     Py_ssize_t start, stop, step, slicelength;
1038
1039     if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) {
1040       return -1;
1041     }
1042
1043     if (step == 1) {
1044       return Buffer_ass_slice(self, start, stop, value);
1045     }
1046     else {
1047       PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
1048       return -1;
1049     }
1050   }
1051   else {
1052     PyErr_Format(
1053         PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
1054     return -1;
1055   }
1056 }
1057
1058 static void Buffer_dealloc(Buffer *self)
1059 {
1060   if (self->parent) {
1061     Py_DECREF(self->parent);
1062   }
1063   else {
1064     MEM_freeN(self->buf.asvoid);
1065   }
1066
1067   MEM_freeN(self->dimensions);
1068
1069   PyObject_DEL(self);
1070 }
1071
1072 static PyObject *Buffer_repr(Buffer *self)
1073 {
1074   PyObject *list = Buffer_to_list_recursive(self);
1075   PyObject *repr;
1076   const char *typestr;
1077
1078   switch (self->type) {
1079     case GL_BYTE:
1080       typestr = "GL_BYTE";
1081       break;
1082     case GL_SHORT:
1083       typestr = "GL_SHORT";
1084       break;
1085     case GL_INT:
1086       typestr = "GL_INT";
1087       break;
1088     case GL_FLOAT:
1089       typestr = "GL_FLOAT";
1090       break;
1091     case GL_DOUBLE:
1092       typestr = "GL_DOUBLE";
1093       break;
1094     default:
1095       typestr = "UNKNOWN";
1096       break;
1097   }
1098
1099   repr = PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list);
1100   Py_DECREF(list);
1101
1102   return repr;
1103 }
1104
1105 /** \} */
1106
1107 /* -------------------------------------------------------------------- */
1108 /** \name OpenGL API Wrapping
1109  * \{ */
1110
1111 #define BGL_Wrap(funcname, ret, arg_list) \
1112   static PyObject *Method_##funcname(PyObject *UNUSED(self), PyObject *args) \
1113   { \
1114     arg_def arg_list; \
1115     ret_def_##ret; \
1116     if (!PyArg_ParseTuple(args, arg_str arg_list, arg_ref arg_list)) { \
1117       return NULL; \
1118     } \
1119     ret_set_##ret gl##funcname(arg_var arg_list); \
1120     ret_ret_##ret; \
1121   }
1122
1123 /* GL_VERSION_1_0 */
1124 BGL_Wrap(BlendFunc, void, (GLenum, GLenum));
1125 BGL_Wrap(Clear, void, (GLbitfield));
1126 BGL_Wrap(ClearColor, void, (GLfloat, GLfloat, GLfloat, GLfloat));
1127 BGL_Wrap(ClearDepth, void, (GLdouble));
1128 BGL_Wrap(ClearStencil, void, (GLint));
1129 BGL_Wrap(ColorMask, void, (GLboolean, GLboolean, GLboolean, GLboolean));
1130 BGL_Wrap(CullFace, void, (GLenum));
1131 BGL_Wrap(DepthFunc, void, (GLenum));
1132 BGL_Wrap(DepthMask, void, (GLboolean));
1133 BGL_Wrap(DepthRange, void, (GLdouble, GLdouble));
1134 BGL_Wrap(Disable, void, (GLenum));
1135 BGL_Wrap(DrawBuffer, void, (GLenum));
1136 BGL_Wrap(Enable, void, (GLenum));
1137 BGL_Wrap(Finish, void, (void));
1138 BGL_Wrap(Flush, void, (void));
1139 BGL_Wrap(FrontFace, void, (GLenum));
1140 BGL_Wrap(GetBooleanv, void, (GLenum, GLbooleanP));
1141 BGL_Wrap(GetDoublev, void, (GLenum, GLdoubleP));
1142 BGL_Wrap(GetError, GLenum, (void));
1143 BGL_Wrap(GetFloatv, void, (GLenum, GLfloatP));
1144 BGL_Wrap(GetIntegerv, void, (GLenum, GLintP));
1145 BGL_Wrap(GetString, GLstring, (GLenum));
1146 BGL_Wrap(GetTexImage, void, (GLenum, GLint, GLenum, GLenum, GLvoidP));
1147 BGL_Wrap(GetTexLevelParameterfv, void, (GLenum, GLint, GLenum, GLfloatP));
1148 BGL_Wrap(GetTexLevelParameteriv, void, (GLenum, GLint, GLenum, GLintP));
1149 BGL_Wrap(GetTexParameterfv, void, (GLenum, GLenum, GLfloatP));
1150 BGL_Wrap(GetTexParameteriv, void, (GLenum, GLenum, GLintP));
1151 BGL_Wrap(Hint, void, (GLenum, GLenum));
1152 BGL_Wrap(IsEnabled, GLboolean, (GLenum));
1153 BGL_Wrap(LineWidth, void, (GLfloat));
1154 BGL_Wrap(LogicOp, void, (GLenum));
1155 BGL_Wrap(PixelStoref, void, (GLenum, GLfloat));
1156 BGL_Wrap(PixelStorei, void, (GLenum, GLint));
1157 BGL_Wrap(PointSize, void, (GLfloat));
1158 BGL_Wrap(PolygonMode, void, (GLenum, GLenum));
1159 BGL_Wrap(ReadBuffer, void, (GLenum));
1160 BGL_Wrap(ReadPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP));
1161 BGL_Wrap(Scissor, void, (GLint, GLint, GLsizei, GLsizei));
1162 BGL_Wrap(StencilFunc, void, (GLenum, GLint, GLuint));
1163 BGL_Wrap(StencilMask, void, (GLuint));
1164 BGL_Wrap(StencilOp, void, (GLenum, GLenum, GLenum));
1165 BGL_Wrap(TexImage1D, void, (GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, GLvoidP));
1166 BGL_Wrap(TexImage2D,
1167          void,
1168          (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP));
1169 BGL_Wrap(TexParameterf, void, (GLenum, GLenum, GLfloat));
1170 BGL_Wrap(TexParameterfv, void, (GLenum, GLenum, GLfloatP));
1171 BGL_Wrap(TexParameteri, void, (GLenum, GLenum, GLint));
1172 BGL_Wrap(TexParameteriv, void, (GLenum, GLenum, GLintP));
1173 BGL_Wrap(Viewport, void, (GLint, GLint, GLsizei, GLsizei));
1174
1175 /* GL_VERSION_1_1 */
1176 BGL_Wrap(BindTexture, void, (GLenum, GLuint));
1177 BGL_Wrap(CopyTexImage1D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint));
1178 BGL_Wrap(CopyTexImage2D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint));
1179 BGL_Wrap(CopyTexSubImage1D, void, (GLenum, GLint, GLint, GLint, GLint, GLsizei));
1180 BGL_Wrap(CopyTexSubImage2D, void, (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei));
1181 BGL_Wrap(DeleteTextures, void, (GLsizei, GLuintP));
1182 BGL_Wrap(DrawArrays, void, (GLenum, GLint, GLsizei));
1183 BGL_Wrap(DrawElements, void, (GLenum, GLsizei, GLenum, GLvoidP));
1184 BGL_Wrap(GenTextures, void, (GLsizei, GLuintP));
1185 BGL_Wrap(IsTexture, GLboolean, (GLuint));
1186 BGL_Wrap(PolygonOffset, void, (GLfloat, GLfloat));
1187 BGL_Wrap(TexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoidP));
1188 BGL_Wrap(TexSubImage2D,
1189          void,
1190          (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP));
1191
1192 /* GL_VERSION_1_2 */
1193 BGL_Wrap(CopyTexSubImage3D,
1194          void,
1195          (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei));
1196 BGL_Wrap(DrawRangeElements, void, (GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoidP));
1197 BGL_Wrap(TexImage3D,
1198          void,
1199          (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP));
1200 BGL_Wrap(TexSubImage3D,
1201          void,
1202          (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoidP));
1203
1204 /* GL_VERSION_1_3 */
1205 BGL_Wrap(ActiveTexture, void, (GLenum));
1206 BGL_Wrap(CompressedTexImage1D, void, (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoidP));
1207 BGL_Wrap(CompressedTexImage2D,
1208          void,
1209          (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoidP));
1210 BGL_Wrap(CompressedTexImage3D,
1211          void,
1212          (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoidP));
1213 BGL_Wrap(CompressedTexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoidP));
1214 BGL_Wrap(CompressedTexSubImage2D,
1215          void,
1216          (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP));
1217 BGL_Wrap(
1218     CompressedTexSubImage3D,
1219     void,
1220     (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP));
1221 BGL_Wrap(GetCompressedTexImage, void, (GLenum, GLint, GLvoidP));
1222 BGL_Wrap(SampleCoverage, void, (GLfloat, GLboolean));
1223
1224 /* GL_VERSION_1_4 */
1225 BGL_Wrap(BlendColor, void, (GLfloat, GLfloat, GLfloat, GLfloat));
1226 BGL_Wrap(BlendEquation, void, (GLenum));
1227
1228 /* GL_VERSION_1_5 */
1229 BGL_Wrap(BeginQuery, void, (GLenum, GLuint));
1230 BGL_Wrap(BindBuffer, void, (GLenum, GLuint));
1231 BGL_Wrap(BufferData, void, (GLenum, GLsizeiptr, GLvoidP, GLenum));
1232 BGL_Wrap(BufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP));
1233 BGL_Wrap(DeleteBuffers, void, (GLsizei, GLuintP));
1234 BGL_Wrap(DeleteQueries, void, (GLsizei, GLuintP));
1235 BGL_Wrap(EndQuery, void, (GLenum));
1236 BGL_Wrap(GenBuffers, void, (GLsizei, GLuintP));
1237 BGL_Wrap(GenQueries, void, (GLsizei, GLuintP));
1238 BGL_Wrap(GetBufferParameteriv, void, (GLenum, GLenum, GLintP));
1239 BGL_Wrap(GetBufferPointerv, void, (GLenum, GLenum, GLvoidP));
1240 BGL_Wrap(GetBufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP));
1241 BGL_Wrap(GetQueryObjectiv, void, (GLuint, GLenum, GLintP));
1242 BGL_Wrap(GetQueryObjectuiv, void, (GLuint, GLenum, GLuintP));
1243 BGL_Wrap(GetQueryiv, void, (GLenum, GLenum, GLintP));
1244 BGL_Wrap(IsBuffer, GLboolean, (GLuint));
1245 BGL_Wrap(IsQuery, GLboolean, (GLuint));
1246 BGL_Wrap(MapBuffer, void, (GLenum, GLenum));
1247 BGL_Wrap(UnmapBuffer, GLboolean, (GLenum));
1248
1249 /* GL_VERSION_2_0 */
1250 BGL_Wrap(AttachShader, void, (GLuint, GLuint));
1251 BGL_Wrap(BindAttribLocation, void, (GLuint, GLuint, GLstring));
1252 BGL_Wrap(BlendEquationSeparate, void, (GLenum, GLenum));
1253 BGL_Wrap(CompileShader, void, (GLuint));
1254 BGL_Wrap(CreateProgram, GLuint, (void));
1255 BGL_Wrap(CreateShader, GLuint, (GLenum));
1256 BGL_Wrap(DeleteProgram, void, (GLuint));
1257 BGL_Wrap(DeleteShader, void, (GLuint));
1258 BGL_Wrap(DetachShader, void, (GLuint, GLuint));
1259 BGL_Wrap(DisableVertexAttribArray, void, (GLuint));
1260 BGL_Wrap(DrawBuffers, void, (GLsizei, GLenumP));
1261 BGL_Wrap(EnableVertexAttribArray, void, (GLuint));
1262 BGL_Wrap(GetActiveAttrib, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP));
1263 BGL_Wrap(GetActiveUniform, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP));
1264 BGL_Wrap(GetAttachedShaders, void, (GLuint, GLsizei, GLsizeiP, GLuintP));
1265 BGL_Wrap(GetAttribLocation, GLint, (GLuint, GLstring));
1266 BGL_Wrap(GetProgramInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP));
1267 BGL_Wrap(GetProgramiv, void, (GLuint, GLenum, GLintP));
1268 BGL_Wrap(GetShaderInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP));
1269 BGL_Wrap(GetShaderSource, void, (GLuint, GLsizei, GLsizeiP, GLcharP));
1270 BGL_Wrap(GetShaderiv, void, (GLuint, GLenum, GLintP));
1271 BGL_Wrap(GetUniformLocation, GLint, (GLuint, GLstring));
1272 BGL_Wrap(GetUniformfv, void, (GLuint, GLint, GLfloatP));
1273 BGL_Wrap(GetUniformiv, void, (GLuint, GLint, GLintP));
1274 BGL_Wrap(GetVertexAttribPointerv, void, (GLuint, GLenum, GLvoidP));
1275 BGL_Wrap(GetVertexAttribdv, void, (GLuint, GLenum, GLdoubleP));
1276 BGL_Wrap(GetVertexAttribfv, void, (GLuint, GLenum, GLfloatP));
1277 BGL_Wrap(GetVertexAttribiv, void, (GLuint, GLenum, GLintP));
1278 BGL_Wrap(IsProgram, GLboolean, (GLuint));
1279 BGL_Wrap(IsShader, GLboolean, (GLuint));
1280 BGL_Wrap(LinkProgram, void, (GLuint));
1281 BGL_Wrap(StencilFuncSeparate, void, (GLenum, GLenum, GLint, GLuint));
1282 BGL_Wrap(StencilMaskSeparate, void, (GLenum, GLuint));
1283 BGL_Wrap(StencilOpSeparate, void, (GLenum, GLenum, GLenum, GLenum));
1284 BGL_Wrap(Uniform1f, void, (GLint, GLfloat));
1285 BGL_Wrap(Uniform1fv, void, (GLint, GLsizei, GLfloatP));
1286 BGL_Wrap(Uniform1i, void, (GLint, GLint));
1287 BGL_Wrap(Uniform1iv, void, (GLint, GLsizei, GLintP));
1288 BGL_Wrap(Uniform2f, void, (GLint, GLfloat, GLfloat));
1289 BGL_Wrap(Uniform2fv, void, (GLint, GLsizei, GLfloatP));
1290 BGL_Wrap(Uniform2i, void, (GLint, GLint, GLint));
1291 BGL_Wrap(Uniform2iv, void, (GLint, GLsizei, GLintP));
1292 BGL_Wrap(Uniform3f, void, (GLint, GLfloat, GLfloat, GLfloat));
1293 BGL_Wrap(Uniform3fv, void, (GLint, GLsizei, GLfloatP));
1294 BGL_Wrap(Uniform3i, void, (GLint, GLint, GLint, GLint));
1295 BGL_Wrap(Uniform3iv, void, (GLint, GLsizei, GLintP));
1296 BGL_Wrap(Uniform4f, void, (GLint, GLfloat, GLfloat, GLfloat, GLfloat));
1297 BGL_Wrap(Uniform4fv, void, (GLint, GLsizei, GLfloatP));
1298 BGL_Wrap(Uniform4i, void, (GLint, GLint, GLint, GLint, GLint));
1299 BGL_Wrap(Uniform4iv, void, (GLint, GLsizei, GLintP));
1300 BGL_Wrap(UniformMatrix2fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1301 BGL_Wrap(UniformMatrix3fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1302 BGL_Wrap(UniformMatrix4fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1303 BGL_Wrap(UseProgram, void, (GLuint));
1304 BGL_Wrap(ValidateProgram, void, (GLuint));
1305 BGL_Wrap(VertexAttrib1d, void, (GLuint, GLdouble));
1306 BGL_Wrap(VertexAttrib1dv, void, (GLuint, GLdoubleP));
1307 BGL_Wrap(VertexAttrib1f, void, (GLuint, GLfloat));
1308 BGL_Wrap(VertexAttrib1fv, void, (GLuint, GLfloatP));
1309 BGL_Wrap(VertexAttrib1s, void, (GLuint, GLshort));
1310 BGL_Wrap(VertexAttrib1sv, void, (GLuint, GLshortP));
1311 BGL_Wrap(VertexAttrib2d, void, (GLuint, GLdouble, GLdouble));
1312 BGL_Wrap(VertexAttrib2dv, void, (GLuint, GLdoubleP));
1313 BGL_Wrap(VertexAttrib2f, void, (GLuint, GLfloat, GLfloat));
1314 BGL_Wrap(VertexAttrib2fv, void, (GLuint, GLfloatP));
1315 BGL_Wrap(VertexAttrib2s, void, (GLuint, GLshort, GLshort));
1316 BGL_Wrap(VertexAttrib2sv, void, (GLuint, GLshortP));
1317 BGL_Wrap(VertexAttrib3d, void, (GLuint, GLdouble, GLdouble, GLdouble));
1318 BGL_Wrap(VertexAttrib3dv, void, (GLuint, GLdoubleP));
1319 BGL_Wrap(VertexAttrib3f, void, (GLuint, GLfloat, GLfloat, GLfloat));
1320 BGL_Wrap(VertexAttrib3fv, void, (GLuint, GLfloatP));
1321 BGL_Wrap(VertexAttrib3s, void, (GLuint, GLshort, GLshort, GLshort));
1322 BGL_Wrap(VertexAttrib3sv, void, (GLuint, GLshortP));
1323 BGL_Wrap(VertexAttrib4Nbv, void, (GLuint, GLbyteP));
1324 BGL_Wrap(VertexAttrib4Niv, void, (GLuint, GLintP));
1325 BGL_Wrap(VertexAttrib4Nsv, void, (GLuint, GLshortP));
1326 BGL_Wrap(VertexAttrib4Nub, void, (GLuint, GLubyte, GLubyte, GLubyte, GLubyte));
1327 BGL_Wrap(VertexAttrib4Nubv, void, (GLuint, GLubyteP));
1328 BGL_Wrap(VertexAttrib4Nuiv, void, (GLuint, GLuintP));
1329 BGL_Wrap(VertexAttrib4Nusv, void, (GLuint, GLushortP));
1330 BGL_Wrap(VertexAttrib4bv, void, (GLuint, GLbyteP));
1331 BGL_Wrap(VertexAttrib4d, void, (GLuint, GLdouble, GLdouble, GLdouble, GLdouble));
1332 BGL_Wrap(VertexAttrib4dv, void, (GLuint, GLdoubleP));
1333 BGL_Wrap(VertexAttrib4f, void, (GLuint, GLfloat, GLfloat, GLfloat, GLfloat));
1334 BGL_Wrap(VertexAttrib4fv, void, (GLuint, GLfloatP));
1335 BGL_Wrap(VertexAttrib4iv, void, (GLuint, GLintP));
1336 BGL_Wrap(VertexAttrib4s, void, (GLuint, GLshort, GLshort, GLshort, GLshort));
1337 BGL_Wrap(VertexAttrib4sv, void, (GLuint, GLshortP));
1338 BGL_Wrap(VertexAttrib4ubv, void, (GLuint, GLubyteP));
1339 BGL_Wrap(VertexAttrib4uiv, void, (GLuint, GLuintP));
1340 BGL_Wrap(VertexAttrib4usv, void, (GLuint, GLushortP));
1341 BGL_Wrap(VertexAttribPointer, void, (GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoidP));
1342
1343 /* GL_VERSION_2_1 */
1344 BGL_Wrap(UniformMatrix2x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1345 BGL_Wrap(UniformMatrix2x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1346 BGL_Wrap(UniformMatrix3x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1347 BGL_Wrap(UniformMatrix3x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1348 BGL_Wrap(UniformMatrix4x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1349 BGL_Wrap(UniformMatrix4x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP));
1350
1351 /* GL_VERSION_3_0 */
1352 BGL_Wrap(BindFramebuffer, void, (GLenum, GLuint));
1353 BGL_Wrap(BindRenderbuffer, void, (GLenum, GLuint));
1354 BGL_Wrap(BindVertexArray, void, (GLuint));
1355 BGL_Wrap(BlitFramebuffer,
1356          void,
1357          (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum));
1358 BGL_Wrap(CheckFramebufferStatus, GLenum, (GLenum));
1359 BGL_Wrap(DeleteFramebuffers, void, (GLsizei, GLuintP));
1360 BGL_Wrap(DeleteRenderbuffers, void, (GLsizei, GLuintP));
1361 BGL_Wrap(DeleteVertexArrays, void, (GLsizei, GLuintP));
1362 BGL_Wrap(FramebufferRenderbuffer, void, (GLenum, GLenum, GLenum, GLuint));
1363 BGL_Wrap(GenFramebuffers, void, (GLsizei, GLuintP));
1364 BGL_Wrap(GenRenderbuffers, void, (GLsizei, GLuintP));
1365 BGL_Wrap(GenVertexArrays, void, (GLsizei, GLuintP));
1366 BGL_Wrap(GetStringi, GLstring, (GLenum, GLuint));
1367 BGL_Wrap(IsVertexArray, GLboolean, (GLuint));
1368 BGL_Wrap(RenderbufferStorage, void, (GLenum, GLenum, GLsizei, GLsizei));
1369
1370 /* GL_VERSION_3_1 */
1371 BGL_Wrap(BindBufferBase, void, (GLenum, GLuint, GLuint));
1372 BGL_Wrap(BindBufferRange, void, (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr));
1373 BGL_Wrap(GetActiveUniformBlockName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP));
1374 BGL_Wrap(GetActiveUniformBlockiv, void, (GLuint, GLuint, GLenum, GLintP));
1375 BGL_Wrap(GetActiveUniformName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP));
1376 BGL_Wrap(GetActiveUniformsiv, void, (GLuint, GLsizei, GLuintP, GLenum, GLintP));
1377 BGL_Wrap(GetIntegeri_v, void, (GLenum, GLuint, GLintP));
1378 BGL_Wrap(GetUniformBlockIndex, GLuint, (GLuint, GLstring));
1379 BGL_Wrap(GetUniformIndices, void, (GLuint, GLsizei, GLcharP, GLuintP));
1380 BGL_Wrap(UniformBlockBinding, void, (GLuint, GLuint, GLuint));
1381
1382 /* GL_VERSION_3_2 */
1383 BGL_Wrap(FramebufferTexture, void, (GLenum, GLenum, GLuint, GLint));
1384 BGL_Wrap(GetBufferParameteri64v, void, (GLenum, GLenum, GLint64P));
1385 BGL_Wrap(GetInteger64i_v, void, (GLenum, GLuint, GLint64P));
1386 BGL_Wrap(GetMultisamplefv, void, (GLenum, GLuint, GLfloatP));
1387 BGL_Wrap(SampleMaski, void, (GLuint, GLbitfield));
1388 BGL_Wrap(TexImage2DMultisample, void, (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean));
1389 BGL_Wrap(TexImage3DMultisample,
1390          void,
1391          (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean));
1392
1393 /* GL_VERSION_3_3 */
1394 /* no new functions besides packed immediate mode (not part of core profile) */
1395
1396 /** \} */
1397
1398 /* -------------------------------------------------------------------- */
1399 /** \name Module Definition
1400  * \{ */
1401
1402 static struct PyModuleDef BGL_module_def = {
1403     PyModuleDef_HEAD_INIT,
1404     "bgl", /* m_name */
1405     NULL,  /* m_doc */
1406     0,     /* m_size */
1407     NULL,  /* m_methods */
1408     NULL,  /* m_reload */
1409     NULL,  /* m_traverse */
1410     NULL,  /* m_clear */
1411     NULL,  /* m_free */
1412 };
1413
1414 static void py_module_dict_add_int(PyObject *dict, const char *name, int value)
1415 {
1416   PyObject *item;
1417   PyDict_SetItemString(dict, name, item = PyLong_FromLong(value));
1418   Py_DECREF(item);
1419 }
1420
1421 static void py_module_dict_add_int64(PyObject *dict, const char *name, int64_t value)
1422 {
1423   PyObject *item;
1424   PyDict_SetItemString(dict, name, item = PyLong_FromLongLong(value));
1425   Py_DECREF(item);
1426 }
1427
1428 static void py_module_dict_add_method(PyObject *submodule,
1429                                       PyObject *dict,
1430                                       PyMethodDef *method_def,
1431                                       bool is_valid)
1432 {
1433   if (is_valid) {
1434     PyObject *m;
1435     m = PyCFunction_NewEx(method_def, NULL, submodule);
1436     PyDict_SetItemString(dict, method_def->ml_name, m);
1437     Py_DECREF(m);
1438   }
1439   else {
1440     PyDict_SetItemString(dict, method_def->ml_name, Py_None);
1441   }
1442 }
1443
1444 PyObject *BPyInit_bgl(void)
1445 {
1446   PyObject *submodule, *dict;
1447   submodule = PyModule_Create(&BGL_module_def);
1448   dict = PyModule_GetDict(submodule);
1449
1450   if (PyType_Ready(&BGL_bufferType) < 0) {
1451     return NULL; /* should never happen */
1452   }
1453
1454   PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType);
1455   Py_INCREF((PyObject *)&BGL_bufferType);
1456
1457 /* needed since some function pointers won't be NULL */
1458 #ifdef __GNUC__
1459 #  pragma GCC diagnostic ignored "-Waddress"
1460 #endif
1461
1462 #define PY_MOD_ADD_METHOD(func) \
1463   { \
1464     static PyMethodDef method_def = {"gl" #func, Method_##func, METH_VARARGS}; \
1465     py_module_dict_add_method(submodule, dict, &method_def, (gl##func != NULL)); \
1466   } \
1467   ((void)0)
1468
1469   /* GL_VERSION_1_0 */
1470   {
1471     PY_MOD_ADD_METHOD(BlendFunc);
1472     PY_MOD_ADD_METHOD(Clear);
1473     PY_MOD_ADD_METHOD(ClearColor);
1474     PY_MOD_ADD_METHOD(ClearDepth);
1475     PY_MOD_ADD_METHOD(ClearStencil);
1476     PY_MOD_ADD_METHOD(ColorMask);
1477     PY_MOD_ADD_METHOD(CullFace);
1478     PY_MOD_ADD_METHOD(DepthFunc);
1479     PY_MOD_ADD_METHOD(DepthMask);
1480     PY_MOD_ADD_METHOD(DepthRange);
1481     PY_MOD_ADD_METHOD(Disable);
1482     PY_MOD_ADD_METHOD(DrawBuffer);
1483     PY_MOD_ADD_METHOD(Enable);
1484     PY_MOD_ADD_METHOD(Finish);
1485     PY_MOD_ADD_METHOD(Flush);
1486     PY_MOD_ADD_METHOD(FrontFace);
1487     PY_MOD_ADD_METHOD(GetBooleanv);
1488     PY_MOD_ADD_METHOD(GetDoublev);
1489     PY_MOD_ADD_METHOD(GetError);
1490     PY_MOD_ADD_METHOD(GetFloatv);
1491     PY_MOD_ADD_METHOD(GetIntegerv);
1492     PY_MOD_ADD_METHOD(GetString);
1493     PY_MOD_ADD_METHOD(GetTexImage);
1494     PY_MOD_ADD_METHOD(GetTexLevelParameterfv);
1495     PY_MOD_ADD_METHOD(GetTexLevelParameteriv);
1496     PY_MOD_ADD_METHOD(GetTexParameterfv);
1497     PY_MOD_ADD_METHOD(GetTexParameteriv);
1498     PY_MOD_ADD_METHOD(Hint);
1499     PY_MOD_ADD_METHOD(IsEnabled);
1500     PY_MOD_ADD_METHOD(LineWidth);
1501     PY_MOD_ADD_METHOD(LogicOp);
1502     PY_MOD_ADD_METHOD(PixelStoref);
1503     PY_MOD_ADD_METHOD(PixelStorei);
1504     PY_MOD_ADD_METHOD(PointSize);
1505     PY_MOD_ADD_METHOD(PolygonMode);
1506     PY_MOD_ADD_METHOD(ReadBuffer);
1507     PY_MOD_ADD_METHOD(ReadPixels);
1508     PY_MOD_ADD_METHOD(Scissor);
1509     PY_MOD_ADD_METHOD(StencilFunc);
1510     PY_MOD_ADD_METHOD(StencilMask);
1511     PY_MOD_ADD_METHOD(StencilOp);
1512     PY_MOD_ADD_METHOD(TexImage1D);
1513     PY_MOD_ADD_METHOD(TexImage2D);
1514     PY_MOD_ADD_METHOD(TexParameterf);
1515     PY_MOD_ADD_METHOD(TexParameterfv);
1516     PY_MOD_ADD_METHOD(TexParameteri);
1517     PY_MOD_ADD_METHOD(TexParameteriv);
1518     PY_MOD_ADD_METHOD(Viewport);
1519   }
1520
1521   /* GL_VERSION_1_1 */
1522   {
1523     PY_MOD_ADD_METHOD(BindTexture);
1524     PY_MOD_ADD_METHOD(CopyTexImage1D);
1525     PY_MOD_ADD_METHOD(CopyTexImage2D);
1526     PY_MOD_ADD_METHOD(CopyTexSubImage1D);
1527     PY_MOD_ADD_METHOD(CopyTexSubImage2D);
1528     PY_MOD_ADD_METHOD(DeleteTextures);
1529     PY_MOD_ADD_METHOD(DrawArrays);
1530     PY_MOD_ADD_METHOD(DrawElements);
1531     PY_MOD_ADD_METHOD(GenTextures);
1532     PY_MOD_ADD_METHOD(IsTexture);
1533     PY_MOD_ADD_METHOD(PolygonOffset);
1534     PY_MOD_ADD_METHOD(TexSubImage1D);
1535     PY_MOD_ADD_METHOD(TexSubImage2D);
1536   }
1537
1538   /* GL_VERSION_1_2 */
1539   {
1540     PY_MOD_ADD_METHOD(CopyTexSubImage3D);
1541     PY_MOD_ADD_METHOD(DrawRangeElements);
1542     PY_MOD_ADD_METHOD(TexImage3D);
1543     PY_MOD_ADD_METHOD(TexSubImage3D);
1544   }
1545
1546   /* GL_VERSION_1_3 */
1547   {
1548     PY_MOD_ADD_METHOD(ActiveTexture);
1549     PY_MOD_ADD_METHOD(CompressedTexImage1D);
1550     PY_MOD_ADD_METHOD(CompressedTexImage2D);
1551     PY_MOD_ADD_METHOD(CompressedTexImage3D);
1552     PY_MOD_ADD_METHOD(CompressedTexSubImage1D);
1553     PY_MOD_ADD_METHOD(CompressedTexSubImage2D);
1554     PY_MOD_ADD_METHOD(CompressedTexSubImage3D);
1555     PY_MOD_ADD_METHOD(GetCompressedTexImage);
1556     PY_MOD_ADD_METHOD(SampleCoverage);
1557   }
1558
1559   /* GL_VERSION_1_4 */
1560   {
1561     PY_MOD_ADD_METHOD(BlendColor);
1562     PY_MOD_ADD_METHOD(BlendEquation);
1563   }
1564
1565   /* GL_VERSION_1_5 */
1566   {
1567     PY_MOD_ADD_METHOD(BeginQuery);
1568     PY_MOD_ADD_METHOD(BindBuffer);
1569     PY_MOD_ADD_METHOD(BufferData);
1570     PY_MOD_ADD_METHOD(BufferSubData);
1571     PY_MOD_ADD_METHOD(DeleteBuffers);
1572     PY_MOD_ADD_METHOD(DeleteQueries);
1573     PY_MOD_ADD_METHOD(EndQuery);
1574     PY_MOD_ADD_METHOD(GenBuffers);
1575     PY_MOD_ADD_METHOD(GenQueries);
1576     PY_MOD_ADD_METHOD(GetBufferParameteriv);
1577     PY_MOD_ADD_METHOD(GetBufferPointerv);
1578     PY_MOD_ADD_METHOD(GetBufferSubData);
1579     PY_MOD_ADD_METHOD(GetQueryObjectiv);
1580     PY_MOD_ADD_METHOD(GetQueryObjectuiv);
1581     PY_MOD_ADD_METHOD(GetQueryiv);
1582     PY_MOD_ADD_METHOD(IsBuffer);
1583     PY_MOD_ADD_METHOD(IsQuery);
1584     PY_MOD_ADD_METHOD(MapBuffer);
1585     PY_MOD_ADD_METHOD(UnmapBuffer);
1586   }
1587
1588   /* GL_VERSION_2_0 */
1589   {
1590     PY_MOD_ADD_METHOD(AttachShader);
1591     PY_MOD_ADD_METHOD(BindAttribLocation);
1592     PY_MOD_ADD_METHOD(BlendEquationSeparate);
1593     PY_MOD_ADD_METHOD(CompileShader);
1594     PY_MOD_ADD_METHOD(CreateProgram);
1595     PY_MOD_ADD_METHOD(CreateShader);
1596     PY_MOD_ADD_METHOD(DeleteProgram);
1597     PY_MOD_ADD_METHOD(DeleteShader);
1598     PY_MOD_ADD_METHOD(DetachShader);
1599     PY_MOD_ADD_METHOD(DisableVertexAttribArray);
1600     PY_MOD_ADD_METHOD(DrawBuffers);
1601     PY_MOD_ADD_METHOD(EnableVertexAttribArray);
1602     PY_MOD_ADD_METHOD(GetActiveAttrib);
1603     PY_MOD_ADD_METHOD(GetActiveUniform);
1604     PY_MOD_ADD_METHOD(GetAttachedShaders);
1605     PY_MOD_ADD_METHOD(GetAttribLocation);
1606     PY_MOD_ADD_METHOD(GetProgramInfoLog);
1607     PY_MOD_ADD_METHOD(GetProgramiv);
1608     PY_MOD_ADD_METHOD(GetShaderInfoLog);
1609     PY_MOD_ADD_METHOD(GetShaderSource);
1610     PY_MOD_ADD_METHOD(GetShaderiv);
1611     PY_MOD_ADD_METHOD(GetUniformLocation);
1612     PY_MOD_ADD_METHOD(GetUniformfv);
1613     PY_MOD_ADD_METHOD(GetUniformiv);
1614     PY_MOD_ADD_METHOD(GetVertexAttribPointerv);
1615     PY_MOD_ADD_METHOD(GetVertexAttribdv);
1616     PY_MOD_ADD_METHOD(GetVertexAttribfv);
1617     PY_MOD_ADD_METHOD(GetVertexAttribiv);
1618     PY_MOD_ADD_METHOD(IsProgram);
1619     PY_MOD_ADD_METHOD(IsShader);
1620     PY_MOD_ADD_METHOD(LinkProgram);
1621     PY_MOD_ADD_METHOD(ShaderSource);
1622     PY_MOD_ADD_METHOD(StencilFuncSeparate);
1623     PY_MOD_ADD_METHOD(StencilMaskSeparate);
1624     PY_MOD_ADD_METHOD(StencilOpSeparate);
1625     PY_MOD_ADD_METHOD(Uniform1f);
1626     PY_MOD_ADD_METHOD(Uniform1fv);
1627     PY_MOD_ADD_METHOD(Uniform1i);
1628     PY_MOD_ADD_METHOD(Uniform1iv);
1629     PY_MOD_ADD_METHOD(Uniform2f);
1630     PY_MOD_ADD_METHOD(Uniform2fv);
1631     PY_MOD_ADD_METHOD(Uniform2i);
1632     PY_MOD_ADD_METHOD(Uniform2iv);
1633     PY_MOD_ADD_METHOD(Uniform3f);
1634     PY_MOD_ADD_METHOD(Uniform3fv);
1635     PY_MOD_ADD_METHOD(Uniform3i);
1636     PY_MOD_ADD_METHOD(Uniform3iv);
1637     PY_MOD_ADD_METHOD(Uniform4f);
1638     PY_MOD_ADD_METHOD(Uniform4fv);
1639     PY_MOD_ADD_METHOD(Uniform4i);
1640     PY_MOD_ADD_METHOD(Uniform4iv);
1641     PY_MOD_ADD_METHOD(UniformMatrix2fv);
1642     PY_MOD_ADD_METHOD(UniformMatrix3fv);
1643     PY_MOD_ADD_METHOD(UniformMatrix4fv);
1644     PY_MOD_ADD_METHOD(UseProgram);
1645     PY_MOD_ADD_METHOD(ValidateProgram);
1646     PY_MOD_ADD_METHOD(VertexAttrib1d);
1647     PY_MOD_ADD_METHOD(VertexAttrib1dv);
1648     PY_MOD_ADD_METHOD(VertexAttrib1f);
1649     PY_MOD_ADD_METHOD(VertexAttrib1fv);
1650     PY_MOD_ADD_METHOD(VertexAttrib1s);
1651     PY_MOD_ADD_METHOD(VertexAttrib1sv);
1652     PY_MOD_ADD_METHOD(VertexAttrib2d);
1653     PY_MOD_ADD_METHOD(VertexAttrib2dv);
1654     PY_MOD_ADD_METHOD(VertexAttrib2f);
1655     PY_MOD_ADD_METHOD(VertexAttrib2fv);
1656     PY_MOD_ADD_METHOD(VertexAttrib2s);
1657     PY_MOD_ADD_METHOD(VertexAttrib2sv);
1658     PY_MOD_ADD_METHOD(VertexAttrib3d);
1659     PY_MOD_ADD_METHOD(VertexAttrib3dv);
1660     PY_MOD_ADD_METHOD(VertexAttrib3f);
1661     PY_MOD_ADD_METHOD(VertexAttrib3fv);
1662     PY_MOD_ADD_METHOD(VertexAttrib3s);
1663     PY_MOD_ADD_METHOD(VertexAttrib3sv);
1664     PY_MOD_ADD_METHOD(VertexAttrib4Nbv);
1665     PY_MOD_ADD_METHOD(VertexAttrib4Niv);
1666     PY_MOD_ADD_METHOD(VertexAttrib4Nsv);
1667     PY_MOD_ADD_METHOD(VertexAttrib4Nub);
1668     PY_MOD_ADD_METHOD(VertexAttrib4Nubv);
1669     PY_MOD_ADD_METHOD(VertexAttrib4Nuiv);
1670     PY_MOD_ADD_METHOD(VertexAttrib4Nusv);
1671     PY_MOD_ADD_METHOD(VertexAttrib4bv);
1672     PY_MOD_ADD_METHOD(VertexAttrib4d);
1673     PY_MOD_ADD_METHOD(VertexAttrib4dv);
1674     PY_MOD_ADD_METHOD(VertexAttrib4f);
1675     PY_MOD_ADD_METHOD(VertexAttrib4fv);
1676     PY_MOD_ADD_METHOD(VertexAttrib4iv);
1677     PY_MOD_ADD_METHOD(VertexAttrib4s);
1678     PY_MOD_ADD_METHOD(VertexAttrib4sv);
1679     PY_MOD_ADD_METHOD(VertexAttrib4ubv);
1680     PY_MOD_ADD_METHOD(VertexAttrib4uiv);
1681     PY_MOD_ADD_METHOD(VertexAttrib4usv);
1682     PY_MOD_ADD_METHOD(VertexAttribPointer);
1683   }
1684
1685   /* GL_VERSION_2_1 */
1686   {
1687     PY_MOD_ADD_METHOD(UniformMatrix2x3fv);
1688     PY_MOD_ADD_METHOD(UniformMatrix2x4fv);
1689     PY_MOD_ADD_METHOD(UniformMatrix3x2fv);
1690     PY_MOD_ADD_METHOD(UniformMatrix3x4fv);
1691     PY_MOD_ADD_METHOD(UniformMatrix4x2fv);
1692     PY_MOD_ADD_METHOD(UniformMatrix4x3fv);
1693   }
1694
1695   /* GL_VERSION_3_0 */
1696   {
1697     PY_MOD_ADD_METHOD(BindFramebuffer);
1698     PY_MOD_ADD_METHOD(BindRenderbuffer);
1699     PY_MOD_ADD_METHOD(BindVertexArray);
1700     PY_MOD_ADD_METHOD(BlitFramebuffer);
1701     PY_MOD_ADD_METHOD(CheckFramebufferStatus);
1702     PY_MOD_ADD_METHOD(DeleteFramebuffers);
1703     PY_MOD_ADD_METHOD(DeleteRenderbuffers);
1704     PY_MOD_ADD_METHOD(DeleteVertexArrays);
1705     PY_MOD_ADD_METHOD(FramebufferRenderbuffer);
1706     PY_MOD_ADD_METHOD(GenFramebuffers);
1707     PY_MOD_ADD_METHOD(GenRenderbuffers);
1708     PY_MOD_ADD_METHOD(GenVertexArrays);
1709     PY_MOD_ADD_METHOD(GetStringi);
1710     PY_MOD_ADD_METHOD(IsVertexArray);
1711     PY_MOD_ADD_METHOD(RenderbufferStorage);
1712   }
1713
1714   /* GL_VERSION_3_1 */
1715   {
1716     PY_MOD_ADD_METHOD(BindBufferBase);
1717     PY_MOD_ADD_METHOD(BindBufferRange);
1718     PY_MOD_ADD_METHOD(GetActiveUniformBlockName);
1719     PY_MOD_ADD_METHOD(GetActiveUniformBlockiv);
1720     PY_MOD_ADD_METHOD(GetActiveUniformName);
1721     PY_MOD_ADD_METHOD(GetActiveUniformsiv);
1722     PY_MOD_ADD_METHOD(GetIntegeri_v);
1723     PY_MOD_ADD_METHOD(GetUniformBlockIndex);
1724     PY_MOD_ADD_METHOD(GetUniformIndices);
1725     PY_MOD_ADD_METHOD(UniformBlockBinding);
1726   }
1727
1728   /* GL_VERSION_3_2 */
1729   {
1730     PY_MOD_ADD_METHOD(FramebufferTexture);
1731     PY_MOD_ADD_METHOD(GetBufferParameteri64v);
1732     PY_MOD_ADD_METHOD(GetInteger64i_v);
1733     PY_MOD_ADD_METHOD(GetMultisamplefv);
1734     PY_MOD_ADD_METHOD(SampleMaski);
1735     PY_MOD_ADD_METHOD(TexImage2DMultisample);
1736     PY_MOD_ADD_METHOD(TexImage3DMultisample);
1737   }
1738
1739   /* GL_VERSION_3_3 */
1740   {
1741   }
1742
1743 #define PY_DICT_ADD_INT(x) py_module_dict_add_int(dict, #x, x)
1744 #define PY_DICT_ADD_INT64(x) py_module_dict_add_int64(dict, #x, x)
1745
1746   /* GL_VERSION_1_1 */
1747   {
1748     PY_DICT_ADD_INT(GL_ALPHA);
1749     PY_DICT_ADD_INT(GL_ALWAYS);
1750     PY_DICT_ADD_INT(GL_AND);
1751     PY_DICT_ADD_INT(GL_AND_INVERTED);
1752     PY_DICT_ADD_INT(GL_AND_REVERSE);
1753     PY_DICT_ADD_INT(GL_BACK);
1754     PY_DICT_ADD_INT(GL_BACK_LEFT);
1755     PY_DICT_ADD_INT(GL_BACK_RIGHT);
1756     PY_DICT_ADD_INT(GL_BLEND);
1757     PY_DICT_ADD_INT(GL_BLEND_DST);
1758     PY_DICT_ADD_INT(GL_BLEND_SRC);
1759     PY_DICT_ADD_INT(GL_BLUE);
1760     PY_DICT_ADD_INT(GL_BYTE);
1761     PY_DICT_ADD_INT(GL_CCW);
1762     PY_DICT_ADD_INT(GL_CLEAR);
1763     PY_DICT_ADD_INT(GL_COLOR);
1764     PY_DICT_ADD_INT(GL_COLOR_BUFFER_BIT);
1765     PY_DICT_ADD_INT(GL_COLOR_CLEAR_VALUE);
1766     PY_DICT_ADD_INT(GL_COLOR_LOGIC_OP);
1767     PY_DICT_ADD_INT(GL_COLOR_WRITEMASK);
1768     PY_DICT_ADD_INT(GL_COPY);
1769     PY_DICT_ADD_INT(GL_COPY_INVERTED);
1770     PY_DICT_ADD_INT(GL_CULL_FACE);
1771     PY_DICT_ADD_INT(GL_CULL_FACE_MODE);
1772     PY_DICT_ADD_INT(GL_CW);
1773     PY_DICT_ADD_INT(GL_DECR);
1774     PY_DICT_ADD_INT(GL_DEPTH);
1775     PY_DICT_ADD_INT(GL_DEPTH_BUFFER_BIT);
1776     PY_DICT_ADD_INT(GL_DEPTH_CLEAR_VALUE);
1777     PY_DICT_ADD_INT(GL_DEPTH_COMPONENT);
1778     PY_DICT_ADD_INT(GL_DEPTH_FUNC);
1779     PY_DICT_ADD_INT(GL_DEPTH_RANGE);
1780     PY_DICT_ADD_INT(GL_DEPTH_TEST);
1781     PY_DICT_ADD_INT(GL_DEPTH_WRITEMASK);
1782     PY_DICT_ADD_INT(GL_DITHER);
1783     PY_DICT_ADD_INT(GL_DONT_CARE);
1784     PY_DICT_ADD_INT(GL_DOUBLE);
1785     PY_DICT_ADD_INT(GL_DOUBLEBUFFER);
1786     PY_DICT_ADD_INT(GL_DRAW_BUFFER);
1787     PY_DICT_ADD_INT(GL_DST_ALPHA);
1788     PY_DICT_ADD_INT(GL_DST_COLOR);
1789     PY_DICT_ADD_INT(GL_EQUAL);
1790     PY_DICT_ADD_INT(GL_EQUIV);
1791     PY_DICT_ADD_INT(GL_EXTENSIONS);
1792     PY_DICT_ADD_INT(GL_FALSE);
1793     PY_DICT_ADD_INT(GL_FASTEST);
1794     PY_DICT_ADD_INT(GL_FILL);
1795     PY_DICT_ADD_INT(GL_FLOAT);
1796     PY_DICT_ADD_INT(GL_FRONT);
1797     PY_DICT_ADD_INT(GL_FRONT_AND_BACK);
1798     PY_DICT_ADD_INT(GL_FRONT_FACE);
1799     PY_DICT_ADD_INT(GL_FRONT_LEFT);
1800     PY_DICT_ADD_INT(GL_FRONT_RIGHT);
1801     PY_DICT_ADD_INT(GL_GEQUAL);
1802     PY_DICT_ADD_INT(GL_GREATER);
1803     PY_DICT_ADD_INT(GL_GREEN);
1804     PY_DICT_ADD_INT(GL_INCR);
1805     PY_DICT_ADD_INT(GL_INT);
1806     PY_DICT_ADD_INT(GL_INVALID_ENUM);
1807     PY_DICT_ADD_INT(GL_INVALID_OPERATION);
1808     PY_DICT_ADD_INT(GL_INVALID_VALUE);
1809     PY_DICT_ADD_INT(GL_INVERT);
1810     PY_DICT_ADD_INT(GL_KEEP);
1811     PY_DICT_ADD_INT(GL_LEFT);
1812     PY_DICT_ADD_INT(GL_LEQUAL);
1813     PY_DICT_ADD_INT(GL_LESS);
1814     PY_DICT_ADD_INT(GL_LINE);
1815     PY_DICT_ADD_INT(GL_LINEAR);
1816     PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_LINEAR);
1817     PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_NEAREST);
1818     PY_DICT_ADD_INT(GL_LINES);
1819     PY_DICT_ADD_INT(GL_LINE_LOOP);
1820     PY_DICT_ADD_INT(GL_LINE_SMOOTH);
1821     PY_DICT_ADD_INT(GL_LINE_SMOOTH_HINT);
1822     PY_DICT_ADD_INT(GL_LINE_STRIP);
1823     PY_DICT_ADD_INT(GL_LINE_WIDTH);
1824     PY_DICT_ADD_INT(GL_LINE_WIDTH_GRANULARITY);
1825     PY_DICT_ADD_INT(GL_LINE_WIDTH_RANGE);
1826     PY_DICT_ADD_INT(GL_LOGIC_OP_MODE);
1827     PY_DICT_ADD_INT(GL_MAX_TEXTURE_SIZE);
1828     PY_DICT_ADD_INT(GL_MAX_VIEWPORT_DIMS);
1829     PY_DICT_ADD_INT(GL_NAND);
1830     PY_DICT_ADD_INT(GL_NEAREST);
1831     PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_LINEAR);
1832     PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_NEAREST);
1833     PY_DICT_ADD_INT(GL_NEVER);
1834     PY_DICT_ADD_INT(GL_NICEST);
1835     PY_DICT_ADD_INT(GL_NONE);
1836     PY_DICT_ADD_INT(GL_NOOP);
1837     PY_DICT_ADD_INT(GL_NOR);
1838     PY_DICT_ADD_INT(GL_NOTEQUAL);
1839     PY_DICT_ADD_INT(GL_NO_ERROR);
1840     PY_DICT_ADD_INT(GL_ONE);
1841     PY_DICT_ADD_INT(GL_ONE_MINUS_DST_ALPHA);
1842     PY_DICT_ADD_INT(GL_ONE_MINUS_DST_COLOR);
1843     PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_ALPHA);
1844     PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_COLOR);
1845     PY_DICT_ADD_INT(GL_OR);
1846     PY_DICT_ADD_INT(GL_OR_INVERTED);
1847     PY_DICT_ADD_INT(GL_OR_REVERSE);
1848     PY_DICT_ADD_INT(GL_OUT_OF_MEMORY);
1849     PY_DICT_ADD_INT(GL_PACK_ALIGNMENT);
1850     PY_DICT_ADD_INT(GL_PACK_LSB_FIRST);
1851     PY_DICT_ADD_INT(GL_PACK_ROW_LENGTH);
1852     PY_DICT_ADD_INT(GL_PACK_SKIP_PIXELS);
1853     PY_DICT_ADD_INT(GL_PACK_SKIP_ROWS);
1854     PY_DICT_ADD_INT(GL_PACK_SWAP_BYTES);
1855     PY_DICT_ADD_INT(GL_POINT);
1856     PY_DICT_ADD_INT(GL_POINTS);
1857     PY_DICT_ADD_INT(GL_POINT_SIZE);
1858     PY_DICT_ADD_INT(GL_POLYGON_MODE);
1859     PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FACTOR);
1860     PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FILL);
1861     PY_DICT_ADD_INT(GL_POLYGON_OFFSET_LINE);
1862     PY_DICT_ADD_INT(GL_POLYGON_OFFSET_POINT);
1863     PY_DICT_ADD_INT(GL_POLYGON_OFFSET_UNITS);
1864     PY_DICT_ADD_INT(GL_POLYGON_SMOOTH);
1865     PY_DICT_ADD_INT(GL_POLYGON_SMOOTH_HINT);
1866     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D);
1867     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D);
1868     PY_DICT_ADD_INT(GL_R3_G3_B2);
1869     PY_DICT_ADD_INT(GL_READ_BUFFER);
1870     PY_DICT_ADD_INT(GL_RED);
1871     PY_DICT_ADD_INT(GL_RENDERER);
1872     PY_DICT_ADD_INT(GL_REPEAT);
1873     PY_DICT_ADD_INT(GL_REPLACE);
1874     PY_DICT_ADD_INT(GL_RGB);
1875     PY_DICT_ADD_INT(GL_RGB10);
1876     PY_DICT_ADD_INT(GL_RGB10_A2);
1877     PY_DICT_ADD_INT(GL_RGB12);
1878     PY_DICT_ADD_INT(GL_RGB16);
1879     PY_DICT_ADD_INT(GL_RGB4);
1880     PY_DICT_ADD_INT(GL_RGB5);
1881     PY_DICT_ADD_INT(GL_RGB5_A1);
1882     PY_DICT_ADD_INT(GL_RGB8);
1883     PY_DICT_ADD_INT(GL_RGBA);
1884     PY_DICT_ADD_INT(GL_RGBA12);
1885     PY_DICT_ADD_INT(GL_RGBA16);
1886     PY_DICT_ADD_INT(GL_RGBA2);
1887     PY_DICT_ADD_INT(GL_RGBA4);
1888     PY_DICT_ADD_INT(GL_RGBA8);
1889     PY_DICT_ADD_INT(GL_RIGHT);
1890     PY_DICT_ADD_INT(GL_SCISSOR_BOX);
1891     PY_DICT_ADD_INT(GL_SCISSOR_TEST);
1892     PY_DICT_ADD_INT(GL_SET);
1893     PY_DICT_ADD_INT(GL_SHORT);
1894     PY_DICT_ADD_INT(GL_SRC_ALPHA);
1895     PY_DICT_ADD_INT(GL_SRC_ALPHA_SATURATE);
1896     PY_DICT_ADD_INT(GL_SRC_COLOR);
1897     PY_DICT_ADD_INT(GL_STENCIL);
1898     PY_DICT_ADD_INT(GL_STENCIL_BUFFER_BIT);
1899     PY_DICT_ADD_INT(GL_STENCIL_CLEAR_VALUE);
1900     PY_DICT_ADD_INT(GL_STENCIL_FAIL);
1901     PY_DICT_ADD_INT(GL_STENCIL_FUNC);
1902     PY_DICT_ADD_INT(GL_STENCIL_INDEX);
1903     PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_FAIL);
1904     PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_PASS);
1905     PY_DICT_ADD_INT(GL_STENCIL_REF);
1906     PY_DICT_ADD_INT(GL_STENCIL_TEST);
1907     PY_DICT_ADD_INT(GL_STENCIL_VALUE_MASK);
1908     PY_DICT_ADD_INT(GL_STENCIL_WRITEMASK);
1909     PY_DICT_ADD_INT(GL_STEREO);
1910     PY_DICT_ADD_INT(GL_SUBPIXEL_BITS);
1911     PY_DICT_ADD_INT(GL_TEXTURE);
1912     PY_DICT_ADD_INT(GL_TEXTURE_1D);
1913     PY_DICT_ADD_INT(GL_TEXTURE_2D);
1914     PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_SIZE);
1915     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D);
1916     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D);
1917     PY_DICT_ADD_INT(GL_TEXTURE_BLUE_SIZE);
1918     PY_DICT_ADD_INT(GL_TEXTURE_BORDER_COLOR);
1919     PY_DICT_ADD_INT(GL_TEXTURE_GREEN_SIZE);
1920     PY_DICT_ADD_INT(GL_TEXTURE_HEIGHT);
1921     PY_DICT_ADD_INT(GL_TEXTURE_INTERNAL_FORMAT);
1922     PY_DICT_ADD_INT(GL_TEXTURE_MAG_FILTER);
1923     PY_DICT_ADD_INT(GL_TEXTURE_MIN_FILTER);
1924     PY_DICT_ADD_INT(GL_TEXTURE_RED_SIZE);
1925     PY_DICT_ADD_INT(GL_TEXTURE_WIDTH);
1926     PY_DICT_ADD_INT(GL_TEXTURE_WRAP_S);
1927     PY_DICT_ADD_INT(GL_TEXTURE_WRAP_T);
1928     PY_DICT_ADD_INT(GL_TRIANGLES);
1929     PY_DICT_ADD_INT(GL_TRIANGLE_FAN);
1930     PY_DICT_ADD_INT(GL_TRIANGLE_STRIP);
1931     PY_DICT_ADD_INT(GL_TRUE);
1932     PY_DICT_ADD_INT(GL_UNPACK_ALIGNMENT);
1933     PY_DICT_ADD_INT(GL_UNPACK_LSB_FIRST);
1934     PY_DICT_ADD_INT(GL_UNPACK_ROW_LENGTH);
1935     PY_DICT_ADD_INT(GL_UNPACK_SKIP_PIXELS);
1936     PY_DICT_ADD_INT(GL_UNPACK_SKIP_ROWS);
1937     PY_DICT_ADD_INT(GL_UNPACK_SWAP_BYTES);
1938     PY_DICT_ADD_INT(GL_UNSIGNED_BYTE);
1939     PY_DICT_ADD_INT(GL_UNSIGNED_INT);
1940     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT);
1941     PY_DICT_ADD_INT(GL_VENDOR);
1942     PY_DICT_ADD_INT(GL_VERSION);
1943     PY_DICT_ADD_INT(GL_VIEWPORT);
1944     PY_DICT_ADD_INT(GL_XOR);
1945     PY_DICT_ADD_INT(GL_ZERO);
1946   }
1947
1948   /* GL_VERSION_1_2 */
1949   {
1950     PY_DICT_ADD_INT(GL_ALIASED_LINE_WIDTH_RANGE);
1951     PY_DICT_ADD_INT(GL_BGR);
1952     PY_DICT_ADD_INT(GL_BGRA);
1953     PY_DICT_ADD_INT(GL_CLAMP_TO_EDGE);
1954     PY_DICT_ADD_INT(GL_MAX_3D_TEXTURE_SIZE);
1955     PY_DICT_ADD_INT(GL_MAX_ELEMENTS_INDICES);
1956     PY_DICT_ADD_INT(GL_MAX_ELEMENTS_VERTICES);
1957     PY_DICT_ADD_INT(GL_PACK_IMAGE_HEIGHT);
1958     PY_DICT_ADD_INT(GL_PACK_SKIP_IMAGES);
1959     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_3D);
1960     PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_GRANULARITY);
1961     PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_RANGE);
1962     PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_GRANULARITY);
1963     PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_RANGE);
1964     PY_DICT_ADD_INT(GL_TEXTURE_3D);
1965     PY_DICT_ADD_INT(GL_TEXTURE_BASE_LEVEL);
1966     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_3D);
1967     PY_DICT_ADD_INT(GL_TEXTURE_DEPTH);
1968     PY_DICT_ADD_INT(GL_TEXTURE_MAX_LEVEL);
1969     PY_DICT_ADD_INT(GL_TEXTURE_MAX_LOD);
1970     PY_DICT_ADD_INT(GL_TEXTURE_MIN_LOD);
1971     PY_DICT_ADD_INT(GL_TEXTURE_WRAP_R);
1972     PY_DICT_ADD_INT(GL_UNPACK_IMAGE_HEIGHT);
1973     PY_DICT_ADD_INT(GL_UNPACK_SKIP_IMAGES);
1974     PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_2_3_3_REV);
1975     PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_3_3_2);
1976     PY_DICT_ADD_INT(GL_UNSIGNED_INT_10_10_10_2);
1977     PY_DICT_ADD_INT(GL_UNSIGNED_INT_2_10_10_10_REV);
1978     PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8);
1979     PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8_REV);
1980     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_1_5_5_5_REV);
1981     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4);
1982     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4_REV);
1983     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_5_5_1);
1984     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5);
1985     PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5_REV);
1986   }
1987
1988   /* GL_VERSION_1_3 */
1989   {
1990     PY_DICT_ADD_INT(GL_ACTIVE_TEXTURE);
1991     PY_DICT_ADD_INT(GL_CLAMP_TO_BORDER);
1992     PY_DICT_ADD_INT(GL_COMPRESSED_RGB);
1993     PY_DICT_ADD_INT(GL_COMPRESSED_RGBA);
1994     PY_DICT_ADD_INT(GL_COMPRESSED_TEXTURE_FORMATS);
1995     PY_DICT_ADD_INT(GL_MAX_CUBE_MAP_TEXTURE_SIZE);
1996     PY_DICT_ADD_INT(GL_MULTISAMPLE);
1997     PY_DICT_ADD_INT(GL_NUM_COMPRESSED_TEXTURE_FORMATS);
1998     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_CUBE_MAP);
1999     PY_DICT_ADD_INT(GL_SAMPLES);
2000     PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_COVERAGE);
2001     PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_ONE);
2002     PY_DICT_ADD_INT(GL_SAMPLE_BUFFERS);
2003     PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE);
2004     PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_INVERT);
2005     PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_VALUE);
2006     PY_DICT_ADD_INT(GL_TEXTURE0);
2007     PY_DICT_ADD_INT(GL_TEXTURE1);
2008     PY_DICT_ADD_INT(GL_TEXTURE10);
2009     PY_DICT_ADD_INT(GL_TEXTURE11);
2010     PY_DICT_ADD_INT(GL_TEXTURE12);
2011     PY_DICT_ADD_INT(GL_TEXTURE13);
2012     PY_DICT_ADD_INT(GL_TEXTURE14);
2013     PY_DICT_ADD_INT(GL_TEXTURE15);
2014     PY_DICT_ADD_INT(GL_TEXTURE16);
2015     PY_DICT_ADD_INT(GL_TEXTURE17);
2016     PY_DICT_ADD_INT(GL_TEXTURE18);
2017     PY_DICT_ADD_INT(GL_TEXTURE19);
2018     PY_DICT_ADD_INT(GL_TEXTURE2);
2019     PY_DICT_ADD_INT(GL_TEXTURE20);
2020     PY_DICT_ADD_INT(GL_TEXTURE21);
2021     PY_DICT_ADD_INT(GL_TEXTURE22);
2022     PY_DICT_ADD_INT(GL_TEXTURE23);
2023     PY_DICT_ADD_INT(GL_TEXTURE24);
2024     PY_DICT_ADD_INT(GL_TEXTURE25);
2025     PY_DICT_ADD_INT(GL_TEXTURE26);
2026     PY_DICT_ADD_INT(GL_TEXTURE27);
2027     PY_DICT_ADD_INT(GL_TEXTURE28);
2028     PY_DICT_ADD_INT(GL_TEXTURE29);
2029     PY_DICT_ADD_INT(GL_TEXTURE3);
2030     PY_DICT_ADD_INT(GL_TEXTURE30);
2031     PY_DICT_ADD_INT(GL_TEXTURE31);
2032     PY_DICT_ADD_INT(GL_TEXTURE4);
2033     PY_DICT_ADD_INT(GL_TEXTURE5);
2034     PY_DICT_ADD_INT(GL_TEXTURE6);
2035     PY_DICT_ADD_INT(GL_TEXTURE7);
2036     PY_DICT_ADD_INT(GL_TEXTURE8);
2037     PY_DICT_ADD_INT(GL_TEXTURE9);
2038     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_CUBE_MAP);
2039     PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED);
2040     PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED_IMAGE_SIZE);
2041     PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSION_HINT);
2042     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP);
2043     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X);
2044     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y);
2045     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
2046     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
2047     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y);
2048     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z);
2049   }
2050
2051   /* GL_VERSION_1_4 */
2052   {
2053     PY_DICT_ADD_INT(GL_BLEND_DST_ALPHA);
2054     PY_DICT_ADD_INT(GL_BLEND_DST_RGB);
2055     PY_DICT_ADD_INT(GL_BLEND_SRC_ALPHA);
2056     PY_DICT_ADD_INT(GL_BLEND_SRC_RGB);
2057     PY_DICT_ADD_INT(GL_CONSTANT_ALPHA);
2058     PY_DICT_ADD_INT(GL_CONSTANT_COLOR);
2059     PY_DICT_ADD_INT(GL_DECR_WRAP);
2060     PY_DICT_ADD_INT(GL_DEPTH_COMPONENT16);
2061     PY_DICT_ADD_INT(GL_DEPTH_COMPONENT24);
2062     PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32);
2063     PY_DICT_ADD_INT(GL_FUNC_ADD);
2064     PY_DICT_ADD_INT(GL_FUNC_REVERSE_SUBTRACT);
2065     PY_DICT_ADD_INT(GL_FUNC_SUBTRACT);
2066     PY_DICT_ADD_INT(GL_INCR_WRAP);
2067     PY_DICT_ADD_INT(GL_MAX);
2068     PY_DICT_ADD_INT(GL_MAX_TEXTURE_LOD_BIAS);
2069     PY_DICT_ADD_INT(GL_MIN);
2070     PY_DICT_ADD_INT(GL_MIRRORED_REPEAT);
2071     PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_ALPHA);
2072     PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_COLOR);
2073     PY_DICT_ADD_INT(GL_POINT_FADE_THRESHOLD_SIZE);
2074     PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_FUNC);
2075     PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_MODE);
2076     PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_SIZE);
2077     PY_DICT_ADD_INT(GL_TEXTURE_LOD_BIAS);
2078   }
2079
2080   /* GL_VERSION_1_5 */
2081   {
2082     PY_DICT_ADD_INT(GL_ARRAY_BUFFER);
2083     PY_DICT_ADD_INT(GL_ARRAY_BUFFER_BINDING);
2084     PY_DICT_ADD_INT(GL_BUFFER_ACCESS);
2085     PY_DICT_ADD_INT(GL_BUFFER_MAPPED);
2086     PY_DICT_ADD_INT(GL_BUFFER_MAP_POINTER);
2087     PY_DICT_ADD_INT(GL_BUFFER_SIZE);
2088     PY_DICT_ADD_INT(GL_BUFFER_USAGE);
2089     PY_DICT_ADD_INT(GL_CURRENT_QUERY);
2090     PY_DICT_ADD_INT(GL_DYNAMIC_COPY);
2091     PY_DICT_ADD_INT(GL_DYNAMIC_DRAW);
2092     PY_DICT_ADD_INT(GL_DYNAMIC_READ);
2093     PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER);
2094     PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER_BINDING);
2095     PY_DICT_ADD_INT(GL_QUERY_COUNTER_BITS);
2096     PY_DICT_ADD_INT(GL_QUERY_RESULT);
2097     PY_DICT_ADD_INT(GL_QUERY_RESULT_AVAILABLE);
2098     PY_DICT_ADD_INT(GL_READ_ONLY);
2099     PY_DICT_ADD_INT(GL_READ_WRITE);
2100     PY_DICT_ADD_INT(GL_SAMPLES_PASSED);
2101     PY_DICT_ADD_INT(GL_STATIC_COPY);
2102     PY_DICT_ADD_INT(GL_STATIC_DRAW);
2103     PY_DICT_ADD_INT(GL_STATIC_READ);
2104     PY_DICT_ADD_INT(GL_STREAM_COPY);
2105     PY_DICT_ADD_INT(GL_STREAM_DRAW);
2106     PY_DICT_ADD_INT(GL_STREAM_READ);
2107     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING);
2108     PY_DICT_ADD_INT(GL_WRITE_ONLY);
2109   }
2110
2111   /* GL_VERSION_2_0 */
2112   {
2113     PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTES);
2114     PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH);
2115     PY_DICT_ADD_INT(GL_ACTIVE_UNIFORMS);
2116     PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_MAX_LENGTH);
2117     PY_DICT_ADD_INT(GL_ATTACHED_SHADERS);
2118     PY_DICT_ADD_INT(GL_BLEND_EQUATION_ALPHA);
2119     PY_DICT_ADD_INT(GL_BLEND_EQUATION_RGB);
2120     PY_DICT_ADD_INT(GL_BOOL);
2121     PY_DICT_ADD_INT(GL_BOOL_VEC2);
2122     PY_DICT_ADD_INT(GL_BOOL_VEC3);
2123     PY_DICT_ADD_INT(GL_BOOL_VEC4);
2124     PY_DICT_ADD_INT(GL_COMPILE_STATUS);
2125     PY_DICT_ADD_INT(GL_CURRENT_PROGRAM);
2126     PY_DICT_ADD_INT(GL_CURRENT_VERTEX_ATTRIB);
2127     PY_DICT_ADD_INT(GL_DELETE_STATUS);
2128     PY_DICT_ADD_INT(GL_DRAW_BUFFER0);
2129     PY_DICT_ADD_INT(GL_DRAW_BUFFER1);
2130     PY_DICT_ADD_INT(GL_DRAW_BUFFER10);
2131     PY_DICT_ADD_INT(GL_DRAW_BUFFER11);
2132     PY_DICT_ADD_INT(GL_DRAW_BUFFER12);
2133     PY_DICT_ADD_INT(GL_DRAW_BUFFER13);
2134     PY_DICT_ADD_INT(GL_DRAW_BUFFER14);
2135     PY_DICT_ADD_INT(GL_DRAW_BUFFER15);
2136     PY_DICT_ADD_INT(GL_DRAW_BUFFER2);
2137     PY_DICT_ADD_INT(GL_DRAW_BUFFER3);
2138     PY_DICT_ADD_INT(GL_DRAW_BUFFER4);
2139     PY_DICT_ADD_INT(GL_DRAW_BUFFER5);
2140     PY_DICT_ADD_INT(GL_DRAW_BUFFER6);
2141     PY_DICT_ADD_INT(GL_DRAW_BUFFER7);
2142     PY_DICT_ADD_INT(GL_DRAW_BUFFER8);
2143     PY_DICT_ADD_INT(GL_DRAW_BUFFER9);
2144     PY_DICT_ADD_INT(GL_FLOAT_MAT2);
2145     PY_DICT_ADD_INT(GL_FLOAT_MAT3);
2146     PY_DICT_ADD_INT(GL_FLOAT_MAT4);
2147     PY_DICT_ADD_INT(GL_FLOAT_VEC2);
2148     PY_DICT_ADD_INT(GL_FLOAT_VEC3);
2149     PY_DICT_ADD_INT(GL_FLOAT_VEC4);
2150     PY_DICT_ADD_INT(GL_FRAGMENT_SHADER);
2151     PY_DICT_ADD_INT(GL_FRAGMENT_SHADER_DERIVATIVE_HINT);
2152     PY_DICT_ADD_INT(GL_INFO_LOG_LENGTH);
2153     PY_DICT_ADD_INT(GL_INT_VEC2);
2154     PY_DICT_ADD_INT(GL_INT_VEC3);
2155     PY_DICT_ADD_INT(GL_INT_VEC4);
2156     PY_DICT_ADD_INT(GL_LINK_STATUS);
2157     PY_DICT_ADD_INT(GL_LOWER_LEFT);
2158     PY_DICT_ADD_INT(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
2159     PY_DICT_ADD_INT(GL_MAX_DRAW_BUFFERS);
2160     PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS);
2161     PY_DICT_ADD_INT(GL_MAX_TEXTURE_IMAGE_UNITS);
2162     PY_DICT_ADD_INT(GL_MAX_VARYING_FLOATS);
2163     PY_DICT_ADD_INT(GL_MAX_VERTEX_ATTRIBS);
2164     PY_DICT_ADD_INT(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
2165     PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_COMPONENTS);
2166     PY_DICT_ADD_INT(GL_POINT_SPRITE_COORD_ORIGIN);
2167     PY_DICT_ADD_INT(GL_SAMPLER_1D);
2168     PY_DICT_ADD_INT(GL_SAMPLER_1D_SHADOW);
2169     PY_DICT_ADD_INT(GL_SAMPLER_2D);
2170     PY_DICT_ADD_INT(GL_SAMPLER_2D_SHADOW);
2171     PY_DICT_ADD_INT(GL_SAMPLER_3D);
2172     PY_DICT_ADD_INT(GL_SAMPLER_CUBE);
2173     PY_DICT_ADD_INT(GL_SHADER_SOURCE_LENGTH);
2174     PY_DICT_ADD_INT(GL_SHADER_TYPE);
2175     PY_DICT_ADD_INT(GL_SHADING_LANGUAGE_VERSION);
2176     PY_DICT_ADD_INT(GL_STENCIL_BACK_FAIL);
2177     PY_DICT_ADD_INT(GL_STENCIL_BACK_FUNC);
2178     PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_FAIL);
2179     PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_PASS);
2180     PY_DICT_ADD_INT(GL_STENCIL_BACK_REF);
2181     PY_DICT_ADD_INT(GL_STENCIL_BACK_VALUE_MASK);
2182     PY_DICT_ADD_INT(GL_STENCIL_BACK_WRITEMASK);
2183     PY_DICT_ADD_INT(GL_UPPER_LEFT);
2184     PY_DICT_ADD_INT(GL_VALIDATE_STATUS);
2185     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_ENABLED);
2186     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED);
2187     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_POINTER);
2188     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_SIZE);
2189     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_STRIDE);
2190     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_TYPE);
2191     PY_DICT_ADD_INT(GL_VERTEX_PROGRAM_POINT_SIZE);
2192     PY_DICT_ADD_INT(GL_VERTEX_SHADER);
2193   }
2194
2195   /* GL_VERSION_2_1 */
2196   {
2197     PY_DICT_ADD_INT(GL_COMPRESSED_SRGB);
2198     PY_DICT_ADD_INT(GL_COMPRESSED_SRGB_ALPHA);
2199     PY_DICT_ADD_INT(GL_FLOAT_MAT2x3);
2200     PY_DICT_ADD_INT(GL_FLOAT_MAT2x4);
2201     PY_DICT_ADD_INT(GL_FLOAT_MAT3x2);
2202     PY_DICT_ADD_INT(GL_FLOAT_MAT3x4);
2203     PY_DICT_ADD_INT(GL_FLOAT_MAT4x2);
2204     PY_DICT_ADD_INT(GL_FLOAT_MAT4x3);
2205     PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER);
2206     PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER_BINDING);
2207     PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER);
2208     PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER_BINDING);
2209     PY_DICT_ADD_INT(GL_SRGB);
2210     PY_DICT_ADD_INT(GL_SRGB8);
2211     PY_DICT_ADD_INT(GL_SRGB8_ALPHA8);
2212     PY_DICT_ADD_INT(GL_SRGB_ALPHA);
2213   }
2214
2215   /* GL_VERSION_3_0 */
2216   {
2217     PY_DICT_ADD_INT(GL_BGRA_INTEGER);
2218     PY_DICT_ADD_INT(GL_BGR_INTEGER);
2219     PY_DICT_ADD_INT(GL_BLUE_INTEGER);
2220     PY_DICT_ADD_INT(GL_BUFFER_ACCESS_FLAGS);
2221     PY_DICT_ADD_INT(GL_BUFFER_MAP_LENGTH);
2222     PY_DICT_ADD_INT(GL_BUFFER_MAP_OFFSET);
2223     PY_DICT_ADD_INT(GL_CLAMP_READ_COLOR);
2224     PY_DICT_ADD_INT(GL_CLIP_DISTANCE0);
2225     PY_DICT_ADD_INT(GL_CLIP_DISTANCE1);
2226     PY_DICT_ADD_INT(GL_CLIP_DISTANCE2);
2227     PY_DICT_ADD_INT(GL_CLIP_DISTANCE3);
2228     PY_DICT_ADD_INT(GL_CLIP_DISTANCE4);
2229     PY_DICT_ADD_INT(GL_CLIP_DISTANCE5);
2230 #if 0
2231     PY_DICT_ADD_INT(GL_CLIP_DISTANCE6);
2232     PY_DICT_ADD_INT(GL_CLIP_DISTANCE7);
2233 #endif
2234     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT0);
2235     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT1);
2236     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT2);
2237     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT3);
2238     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT4);
2239     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT5);
2240     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT6);
2241     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT7);
2242     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT8);
2243     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT9);
2244     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT10);
2245     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT11);
2246     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT12);
2247     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT13);
2248     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT14);
2249     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT15);
2250 #if 0
2251     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT16);
2252     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT17);
2253     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT18);
2254     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT19);
2255     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT20);
2256     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT21);
2257     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT22);
2258     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT23);
2259     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT24);
2260     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT25);
2261     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT26);
2262     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT27);
2263     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT28);
2264     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT29);
2265     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT30);
2266     PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT31);
2267 #endif
2268     PY_DICT_ADD_INT(GL_COMPARE_REF_TO_TEXTURE);
2269     PY_DICT_ADD_INT(GL_COMPRESSED_RED);
2270     PY_DICT_ADD_INT(GL_COMPRESSED_RED_RGTC1);
2271     PY_DICT_ADD_INT(GL_COMPRESSED_RG);
2272     PY_DICT_ADD_INT(GL_COMPRESSED_RG_RGTC2);
2273     PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RED_RGTC1);
2274     PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RG_RGTC2);
2275     PY_DICT_ADD_INT(GL_CONTEXT_FLAGS);
2276     PY_DICT_ADD_INT(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT);
2277     PY_DICT_ADD_INT(GL_DEPTH24_STENCIL8);
2278     PY_DICT_ADD_INT(GL_DEPTH32F_STENCIL8);
2279     PY_DICT_ADD_INT(GL_DEPTH_ATTACHMENT);
2280     PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32F);
2281     PY_DICT_ADD_INT(GL_DEPTH_STENCIL);
2282     PY_DICT_ADD_INT(GL_DEPTH_STENCIL_ATTACHMENT);
2283     PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER);
2284     PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER_BINDING);
2285     PY_DICT_ADD_INT(GL_FIXED_ONLY);
2286     PY_DICT_ADD_INT(GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
2287     PY_DICT_ADD_INT(GL_FRAMEBUFFER);
2288     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE);
2289     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE);
2290     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING);
2291     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE);
2292     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
2293     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE);
2294     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME);
2295     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
2296     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE);
2297     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
2298     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE);
2299     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER);
2300     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL);
2301     PY_DICT_ADD_INT(GL_FRAMEBUFFER_BINDING);
2302     PY_DICT_ADD_INT(GL_FRAMEBUFFER_COMPLETE);
2303     PY_DICT_ADD_INT(GL_FRAMEBUFFER_DEFAULT);
2304     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
2305     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
2306     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
2307     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
2308     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
2309     PY_DICT_ADD_INT(GL_FRAMEBUFFER_SRGB);
2310     PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNDEFINED);
2311     PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNSUPPORTED);
2312     PY_DICT_ADD_INT(GL_GREEN_INTEGER);
2313     PY_DICT_ADD_INT(GL_HALF_FLOAT);
2314     PY_DICT_ADD_INT(GL_INDEX);
2315     PY_DICT_ADD_INT(GL_INTERLEAVED_ATTRIBS);
2316     PY_DICT_ADD_INT(GL_INT_SAMPLER_1D);
2317     PY_DICT_ADD_INT(GL_INT_SAMPLER_1D_ARRAY);
2318     PY_DICT_ADD_INT(GL_INT_SAMPLER_2D);
2319     PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_ARRAY);
2320     PY_DICT_ADD_INT(GL_INT_SAMPLER_3D);
2321     PY_DICT_ADD_INT(GL_INT_SAMPLER_CUBE);
2322     PY_DICT_ADD_INT(GL_INVALID_FRAMEBUFFER_OPERATION);
2323     PY_DICT_ADD_INT(GL_MAJOR_VERSION);
2324     PY_DICT_ADD_INT(GL_MAP_FLUSH_EXPLICIT_BIT);
2325     PY_DICT_ADD_INT(GL_MAP_INVALIDATE_BUFFER_BIT);
2326     PY_DICT_ADD_INT(GL_MAP_INVALIDATE_RANGE_BIT);
2327     PY_DICT_ADD_INT(GL_MAP_READ_BIT);
2328     PY_DICT_ADD_INT(GL_MAP_UNSYNCHRONIZED_BIT);
2329     PY_DICT_ADD_INT(GL_MAP_WRITE_BIT);
2330     PY_DICT_ADD_INT(GL_MAX_ARRAY_TEXTURE_LAYERS);
2331     PY_DICT_ADD_INT(GL_MAX_CLIP_DISTANCES);
2332     PY_DICT_ADD_INT(GL_MAX_COLOR_ATTACHMENTS);
2333     PY_DICT_ADD_INT(GL_MAX_PROGRAM_TEXEL_OFFSET);
2334     PY_DICT_ADD_INT(GL_MAX_RENDERBUFFER_SIZE);
2335     PY_DICT_ADD_INT(GL_MAX_SAMPLES);
2336     PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
2337     PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
2338     PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
2339     PY_DICT_ADD_INT(GL_MAX_VARYING_COMPONENTS);
2340     PY_DICT_ADD_INT(GL_MINOR_VERSION);
2341     PY_DICT_ADD_INT(GL_MIN_PROGRAM_TEXEL_OFFSET);
2342     PY_DICT_ADD_INT(GL_NUM_EXTENSIONS);
2343     PY_DICT_ADD_INT(GL_PRIMITIVES_GENERATED);
2344     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D_ARRAY);
2345     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_ARRAY);
2346     PY_DICT_ADD_INT(GL_QUERY_BY_REGION_NO_WAIT);
2347     PY_DICT_ADD_INT(GL_QUERY_BY_REGION_WAIT);
2348     PY_DICT_ADD_INT(GL_QUERY_NO_WAIT);
2349     PY_DICT_ADD_INT(GL_QUERY_WAIT);
2350     PY_DICT_ADD_INT(GL_R11F_G11F_B10F);
2351     PY_DICT_ADD_INT(GL_R16);
2352     PY_DICT_ADD_INT(GL_R16F);
2353     PY_DICT_ADD_INT(GL_R16I);
2354     PY_DICT_ADD_INT(GL_R16UI);
2355     PY_DICT_ADD_INT(GL_R32F);
2356     PY_DICT_ADD_INT(GL_R32I);
2357     PY_DICT_ADD_INT(GL_R32UI);
2358     PY_DICT_ADD_INT(GL_R8);
2359     PY_DICT_ADD_INT(GL_R8I);
2360     PY_DICT_ADD_INT(GL_R8UI);
2361     PY_DICT_ADD_INT(GL_RASTERIZER_DISCARD);
2362     PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER);
2363     PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER_BINDING);
2364     PY_DICT_ADD_INT(GL_RED_INTEGER);
2365     PY_DICT_ADD_INT(GL_RENDERBUFFER);
2366     PY_DICT_ADD_INT(GL_RENDERBUFFER_ALPHA_SIZE);
2367     PY_DICT_ADD_INT(GL_RENDERBUFFER_BINDING);
2368     PY_DICT_ADD_INT(GL_RENDERBUFFER_BLUE_SIZE);
2369     PY_DICT_ADD_INT(GL_RENDERBUFFER_DEPTH_SIZE);
2370     PY_DICT_ADD_INT(GL_RENDERBUFFER_GREEN_SIZE);
2371     PY_DICT_ADD_INT(GL_RENDERBUFFER_HEIGHT);
2372     PY_DICT_ADD_INT(GL_RENDERBUFFER_INTERNAL_FORMAT);
2373     PY_DICT_ADD_INT(GL_RENDERBUFFER_RED_SIZE);
2374     PY_DICT_ADD_INT(GL_RENDERBUFFER_SAMPLES);
2375     PY_DICT_ADD_INT(GL_RENDERBUFFER_STENCIL_SIZE);
2376     PY_DICT_ADD_INT(GL_RENDERBUFFER_WIDTH);
2377     PY_DICT_ADD_INT(GL_RG);
2378     PY_DICT_ADD_INT(GL_RG16);
2379     PY_DICT_ADD_INT(GL_RG16F);
2380     PY_DICT_ADD_INT(GL_RG16I);
2381     PY_DICT_ADD_INT(GL_RG16UI);
2382     PY_DICT_ADD_INT(GL_RG32F);
2383     PY_DICT_ADD_INT(GL_RG32I);
2384     PY_DICT_ADD_INT(GL_RG32UI);
2385     PY_DICT_ADD_INT(GL_RG8);
2386     PY_DICT_ADD_INT(GL_RG8I);
2387     PY_DICT_ADD_INT(GL_RG8UI);
2388     PY_DICT_ADD_INT(GL_RGB16F);
2389     PY_DICT_ADD_INT(GL_RGB16I);
2390     PY_DICT_ADD_INT(GL_RGB16UI);
2391     PY_DICT_ADD_INT(GL_RGB32F);
2392     PY_DICT_ADD_INT(GL_RGB32I);
2393     PY_DICT_ADD_INT(GL_RGB32UI);
2394     PY_DICT_ADD_INT(GL_RGB8I);
2395     PY_DICT_ADD_INT(GL_RGB8UI);
2396     PY_DICT_ADD_INT(GL_RGB9_E5);
2397     PY_DICT_ADD_INT(GL_RGBA16F);
2398     PY_DICT_ADD_INT(GL_RGBA16I);
2399     PY_DICT_ADD_INT(GL_RGBA16UI);
2400     PY_DICT_ADD_INT(GL_RGBA32F);
2401     PY_DICT_ADD_INT(GL_RGBA32I);
2402     PY_DICT_ADD_INT(GL_RGBA32UI);
2403     PY_DICT_ADD_INT(GL_RGBA8I);
2404     PY_DICT_ADD_INT(GL_RGBA8UI);
2405     PY_DICT_ADD_INT(GL_RGBA_INTEGER);
2406     PY_DICT_ADD_INT(GL_RGB_INTEGER);
2407     PY_DICT_ADD_INT(GL_RG_INTEGER);
2408     PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY);
2409     PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY_SHADOW);
2410     PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY);
2411     PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY_SHADOW);
2412     PY_DICT_ADD_INT(GL_SAMPLER_CUBE_SHADOW);
2413     PY_DICT_ADD_INT(GL_SEPARATE_ATTRIBS);
2414     PY_DICT_ADD_INT(GL_STENCIL_ATTACHMENT);
2415     PY_DICT_ADD_INT(GL_STENCIL_INDEX1);
2416     PY_DICT_ADD_INT(GL_STENCIL_INDEX16);
2417     PY_DICT_ADD_INT(GL_STENCIL_INDEX4);
2418     PY_DICT_ADD_INT(GL_STENCIL_INDEX8);
2419     PY_DICT_ADD_INT(GL_TEXTURE_1D_ARRAY);
2420     PY_DICT_ADD_INT(GL_TEXTURE_2D_ARRAY);
2421     PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_TYPE);
2422     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D_ARRAY);
2423     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_ARRAY);
2424     PY_DICT_ADD_INT(GL_TEXTURE_BLUE_TYPE);
2425     PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_TYPE);
2426     PY_DICT_ADD_INT(GL_TEXTURE_GREEN_TYPE);
2427     PY_DICT_ADD_INT(GL_TEXTURE_RED_TYPE);
2428     PY_DICT_ADD_INT(GL_TEXTURE_SHARED_SIZE);
2429     PY_DICT_ADD_INT(GL_TEXTURE_STENCIL_SIZE);
2430     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER);
2431     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING);
2432     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_MODE);
2433     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE);
2434     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_START);
2435     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
2436     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYINGS);
2437     PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH);
2438     PY_DICT_ADD_INT(GL_UNSIGNED_INT_10F_11F_11F_REV);
2439     PY_DICT_ADD_INT(GL_UNSIGNED_INT_24_8);
2440     PY_DICT_ADD_INT(GL_UNSIGNED_INT_5_9_9_9_REV);
2441     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D);
2442     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D_ARRAY);
2443     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D);
2444     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_ARRAY);
2445     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_3D);
2446     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_CUBE);
2447     PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC2);
2448     PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC3);
2449     PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC4);
2450     PY_DICT_ADD_INT(GL_UNSIGNED_NORMALIZED);
2451     PY_DICT_ADD_INT(GL_VERTEX_ARRAY_BINDING);
2452     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_INTEGER);
2453   }
2454
2455   /* GL_VERSION_3_1 */
2456   {
2457     PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCKS);
2458     PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH);
2459     PY_DICT_ADD_INT(GL_COPY_READ_BUFFER);
2460     PY_DICT_ADD_INT(GL_COPY_WRITE_BUFFER);
2461     PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_RECT);
2462     PY_DICT_ADD_INT(GL_INT_SAMPLER_BUFFER);
2463     PY_DICT_ADD_INT(GL_INVALID_INDEX);
2464     PY_DICT_ADD_INT(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS);
2465     PY_DICT_ADD_INT(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS);
2466     PY_DICT_ADD_INT(GL_MAX_COMBINED_UNIFORM_BLOCKS);
2467     PY_DICT_ADD_INT(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS);
2468     PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_BLOCKS);
2469     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_BLOCKS);
2470     PY_DICT_ADD_INT(GL_MAX_RECTANGLE_TEXTURE_SIZE);
2471     PY_DICT_ADD_INT(GL_MAX_TEXTURE_BUFFER_SIZE);
2472     PY_DICT_ADD_INT(GL_MAX_UNIFORM_BLOCK_SIZE);
2473     PY_DICT_ADD_INT(GL_MAX_UNIFORM_BUFFER_BINDINGS);
2474     PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_BLOCKS);
2475     PY_DICT_ADD_INT(GL_PRIMITIVE_RESTART);
2476     PY_DICT_ADD_INT(GL_PRIMITIVE_RESTART_INDEX);
2477     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_RECTANGLE);
2478     PY_DICT_ADD_INT(GL_R16_SNORM);
2479     PY_DICT_ADD_INT(GL_R8_SNORM);
2480     PY_DICT_ADD_INT(GL_RG16_SNORM);
2481     PY_DICT_ADD_INT(GL_RG8_SNORM);
2482     PY_DICT_ADD_INT(GL_RGB16_SNORM);
2483     PY_DICT_ADD_INT(GL_RGB8_SNORM);
2484     PY_DICT_ADD_INT(GL_RGBA16_SNORM);
2485     PY_DICT_ADD_INT(GL_RGBA8_SNORM);
2486     PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT);
2487     PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT_SHADOW);
2488     PY_DICT_ADD_INT(GL_SAMPLER_BUFFER);
2489     PY_DICT_ADD_INT(GL_SIGNED_NORMALIZED);
2490     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_BUFFER);
2491     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_RECTANGLE);
2492     PY_DICT_ADD_INT(GL_TEXTURE_BUFFER);
2493     PY_DICT_ADD_INT(GL_TEXTURE_BUFFER_DATA_STORE_BINDING);
2494     PY_DICT_ADD_INT(GL_TEXTURE_RECTANGLE);
2495     PY_DICT_ADD_INT(GL_UNIFORM_ARRAY_STRIDE);
2496     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS);
2497     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
2498     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_BINDING);
2499     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_DATA_SIZE);
2500     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_INDEX);
2501     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_NAME_LENGTH);
2502     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER);
2503     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER);
2504     PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER);
2505     PY_DICT_ADD_INT(GL_UNIFORM_BUFFER);
2506     PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_BINDING);
2507     PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
2508     PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_SIZE);
2509     PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_START);
2510     PY_DICT_ADD_INT(GL_UNIFORM_IS_ROW_MAJOR);
2511     PY_DICT_ADD_INT(GL_UNIFORM_MATRIX_STRIDE);
2512     PY_DICT_ADD_INT(GL_UNIFORM_NAME_LENGTH);
2513     PY_DICT_ADD_INT(GL_UNIFORM_OFFSET);
2514     PY_DICT_ADD_INT(GL_UNIFORM_SIZE);
2515     PY_DICT_ADD_INT(GL_UNIFORM_TYPE);
2516     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_RECT);
2517     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_BUFFER);
2518   }
2519
2520   /* GL_VERSION_3_2 */
2521   {
2522     PY_DICT_ADD_INT(GL_ALREADY_SIGNALED);
2523     PY_DICT_ADD_INT(GL_CONDITION_SATISFIED);
2524     PY_DICT_ADD_INT(GL_CONTEXT_COMPATIBILITY_PROFILE_BIT);
2525     PY_DICT_ADD_INT(GL_CONTEXT_CORE_PROFILE_BIT);
2526     PY_DICT_ADD_INT(GL_CONTEXT_PROFILE_MASK);
2527     PY_DICT_ADD_INT(GL_DEPTH_CLAMP);
2528     PY_DICT_ADD_INT(GL_FIRST_VERTEX_CONVENTION);
2529     PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_LAYERED);
2530     PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS);
2531     PY_DICT_ADD_INT(GL_GEOMETRY_INPUT_TYPE);
2532     PY_DICT_ADD_INT(GL_GEOMETRY_OUTPUT_TYPE);
2533     PY_DICT_ADD_INT(GL_GEOMETRY_SHADER);
2534     PY_DICT_ADD_INT(GL_GEOMETRY_VERTICES_OUT);
2535     PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE);
2536     PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY);
2537     PY_DICT_ADD_INT(GL_LAST_VERTEX_CONVENTION);
2538     PY_DICT_ADD_INT(GL_LINES_ADJACENCY);
2539     PY_DICT_ADD_INT(GL_LINE_STRIP_ADJACENCY);
2540     PY_DICT_ADD_INT(GL_MAX_COLOR_TEXTURE_SAMPLES);
2541     PY_DICT_ADD_INT(GL_MAX_DEPTH_TEXTURE_SAMPLES);
2542     PY_DICT_ADD_INT(GL_MAX_FRAGMENT_INPUT_COMPONENTS);
2543     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_INPUT_COMPONENTS);
2544     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS);
2545     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_VERTICES);
2546     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS);
2547     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS);
2548     PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS);
2549     PY_DICT_ADD_INT(GL_MAX_INTEGER_SAMPLES);
2550     PY_DICT_ADD_INT(GL_MAX_SAMPLE_MASK_WORDS);
2551     PY_DICT_ADD_INT(GL_MAX_SERVER_WAIT_TIMEOUT);
2552     PY_DICT_ADD_INT(GL_MAX_VERTEX_OUTPUT_COMPONENTS);
2553     PY_DICT_ADD_INT(GL_OBJECT_TYPE);
2554     PY_DICT_ADD_INT(GL_PROGRAM_POINT_SIZE);
2555     PY_DICT_ADD_INT(GL_PROVOKING_VERTEX);
2556     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE);
2557     PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY);
2558     PY_DICT_ADD_INT(GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
2559     PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE);
2560     PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE_ARRAY);
2561     PY_DICT_ADD_INT(GL_SAMPLE_MASK);
2562     PY_DICT_ADD_INT(GL_SAMPLE_MASK_VALUE);
2563     PY_DICT_ADD_INT(GL_SAMPLE_POSITION);
2564     PY_DICT_ADD_INT(GL_SIGNALED);
2565     PY_DICT_ADD_INT(GL_SYNC_CONDITION);
2566     PY_DICT_ADD_INT(GL_SYNC_FENCE);
2567     PY_DICT_ADD_INT(GL_SYNC_FLAGS);
2568     PY_DICT_ADD_INT(GL_SYNC_FLUSH_COMMANDS_BIT);
2569     PY_DICT_ADD_INT(GL_SYNC_GPU_COMMANDS_COMPLETE);
2570     PY_DICT_ADD_INT(GL_SYNC_STATUS);
2571     PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE);
2572     PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
2573     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE);
2574     PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY);
2575     PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_SEAMLESS);
2576     PY_DICT_ADD_INT(GL_TEXTURE_FIXED_SAMPLE_LOCATIONS);
2577     PY_DICT_ADD_INT(GL_TEXTURE_SAMPLES);
2578     PY_DICT_ADD_INT(GL_TIMEOUT_EXPIRED);
2579     PY_DICT_ADD_INT64(GL_TIMEOUT_IGNORED);
2580     PY_DICT_ADD_INT(GL_TRIANGLES_ADJACENCY);
2581     PY_DICT_ADD_INT(GL_TRIANGLE_STRIP_ADJACENCY);
2582     PY_DICT_ADD_INT(GL_UNSIGNALED);
2583     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE);
2584     PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY);
2585     PY_DICT_ADD_INT(GL_WAIT_FAILED);
2586   }
2587
2588   /* GL_VERSION_3_3 */
2589   {
2590     PY_DICT_ADD_INT(GL_ANY_SAMPLES_PASSED);
2591     PY_DICT_ADD_INT(GL_INT_2_10_10_10_REV);
2592     PY_DICT_ADD_INT(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS);
2593     PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_ALPHA);
2594     PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_COLOR);
2595     PY_DICT_ADD_INT(GL_RGB10_A2UI);
2596     PY_DICT_ADD_INT(GL_SAMPLER_BINDING);
2597     PY_DICT_ADD_INT(GL_SRC1_COLOR);
2598     PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_A);
2599     PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_B);
2600     PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_G);
2601     PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_R);
2602     PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_RGBA);
2603     PY_DICT_ADD_INT(GL_TIMESTAMP);
2604     PY_DICT_ADD_INT(GL_TIME_ELAPSED);
2605     PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR);
2606   }
2607
2608   return submodule;
2609 }
2610
2611 static PyObject *Method_ShaderSource(PyObject *UNUSED(self), PyObject *args)
2612 {
2613   unsigned int shader;
2614   const char *source;
2615
2616   if (!PyArg_ParseTuple(args, "Is", &shader, &source)) {
2617     return NULL;
2618   }
2619
2620   glShaderSource(shader, 1, (const char **)&source, NULL);
2621
2622   Py_RETURN_NONE;
2623 }
2624
2625 /** \} */