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