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