diff options
| author | Julian Eisel <eiseljulian@gmail.com> | 2015-08-01 22:06:58 +0300 |
|---|---|---|
| committer | Julian Eisel <eiseljulian@gmail.com> | 2015-08-01 22:06:58 +0300 |
| commit | 4ade467fc6adfc13ce9e21d7e50b366fce70ea5f (patch) | |
| tree | 968418721b08baacd47bab95877bc08812f3046a /source/blender/python/generic/bgl.c | |
| parent | 7759782ee7c4e654641c9f7abb51631c86e3f29c (diff) | |
| parent | a3c5de3e3ca82d8ad5a28029f3ee9207929318a1 (diff) | |
Merge branch 'master' into UI-graphical-redesign
Conflicts:
source/blender/blenkernel/BKE_blender.h
source/blender/blenloader/intern/versioning_270.c
source/blender/editors/interface/resources.c
source/blender/makesdna/DNA_userdef_types.h
Diffstat (limited to 'source/blender/python/generic/bgl.c')
| -rw-r--r-- | source/blender/python/generic/bgl.c | 4009 |
1 files changed, 2696 insertions, 1313 deletions
diff --git a/source/blender/python/generic/bgl.c b/source/blender/python/generic/bgl.c index c599ce26f6c..8682b860fe3 100644 --- a/source/blender/python/generic/bgl.c +++ b/source/blender/python/generic/bgl.c @@ -32,11 +32,410 @@ #include <Python.h> -#include "bgl.h" /*This must come first */ +#include "BLI_utildefines.h" + #include "GPU_glew.h" #include "MEM_guardedalloc.h" -#include "BLI_utildefines.h" +#include "bgl.h" + + +/* -------------------------------------------------------------------- */ + +/** \name Local utility defines for wrapping OpenGL + * \{ */ + +/*@ By golly George! It looks like fancy pants macro time!!! */ + + +/* TYPE_str is the string to pass to Py_ArgParse (for the format) */ +/* TYPE_var is the name to pass to the GL function */ +/* TYPE_ref is the pointer to pass to Py_ArgParse (to store in) */ +/* TYPE_def is the C initialization of the variable */ + +#define void_str "" +#define void_var(num) +#define void_ref(num) &bgl_var##num +#define void_def(num) char bgl_var##num + +#if 0 +#define buffer_str "O!" +#define buffer_var(number) (bgl_buffer##number)->buf.asvoid +#define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number +#define buffer_def(number) Buffer *bgl_buffer##number +#endif + +/* GL Pointer fields, handled by buffer type */ +/* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP, GLsizeiP, GLcharP */ + +#define GLbooleanP_str "O!" +#define GLbooleanP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLbooleanP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLbooleanP_def(number) Buffer *bgl_buffer##number + +#define GLbyteP_str "O!" +#define GLbyteP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLbyteP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLbyteP_def(number) Buffer *bgl_buffer##number + +#define GLubyteP_str "O!" +#define GLubyteP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLubyteP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLubyteP_def(number) Buffer *bgl_buffer##number + +#define GLintP_str "O!" +#define GLintP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLintP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLintP_def(number) Buffer *bgl_buffer##number + +#define GLint64P_str "O!" +#define GLint64P_var(number) (bgl_buffer##number)->buf.asvoid +#define GLint64P_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLint64P_def(number) Buffer *bgl_buffer##number + +#define GLenumP_str "O!" +#define GLenumP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLenumP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLenumP_def(number) Buffer *bgl_buffer##number + +#define GLuintP_str "O!" +#define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLuintP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLuintP_def(number) Buffer *bgl_buffer##number + +#if 0 +#define GLuint64P_str "O!" +#define GLuint64P_var(number) (bgl_buffer##number)->buf.asvoid +#define GLuint64P_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLuint64P_def(number) Buffer *bgl_buffer##number +#endif + +#define GLshortP_str "O!" +#define GLshortP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLshortP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLshortP_def(number) Buffer *bgl_buffer##number + +#define GLushortP_str "O!" +#define GLushortP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLushortP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLushortP_def(number) Buffer *bgl_buffer##number + +#define GLfloatP_str "O!" +#define GLfloatP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLfloatP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLfloatP_def(number) Buffer *bgl_buffer##number + +#define GLdoubleP_str "O!" +#define GLdoubleP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLdoubleP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLdoubleP_def(number) Buffer *bgl_buffer##number + +#if 0 +#define GLclampfP_str "O!" +#define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLclampfP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLclampfP_def(number) Buffer *bgl_buffer##number +#endif + +#define GLvoidP_str "O!" +#define GLvoidP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLvoidP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLvoidP_def(number) Buffer *bgl_buffer##number + +#define GLsizeiP_str "O!" +#define GLsizeiP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLsizeiP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLsizeiP_def(number) Buffer *bgl_buffer##number + +#define GLcharP_str "O!" +#define GLcharP_var(number) (bgl_buffer##number)->buf.asvoid +#define GLcharP_ref(number) &BGL_bufferType, &bgl_buffer##number +#define GLcharP_def(number) Buffer *bgl_buffer##number + +#if 0 +#define buffer_str "O!" +#define buffer_var(number) (bgl_buffer##number)->buf.asvoid +#define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number +#define buffer_def(number) Buffer *bgl_buffer##number +#endif + +/*@The standard GL typedefs are used as prototypes, we can't + * use the GL type directly because Py_ArgParse expects normal + * C types. + * + * Py_ArgParse doesn't grok writing into unsigned variables, + * so we use signed everything (even stuff that should be unsigned. + */ + +/* typedef unsigned int GLenum; */ +#define GLenum_str "i" +#define GLenum_var(num) bgl_var##num +#define GLenum_ref(num) &bgl_var##num +#define GLenum_def(num) /* unsigned */ int GLenum_var(num) + +/* typedef unsigned int GLboolean; */ +#define GLboolean_str "b" +#define GLboolean_var(num) bgl_var##num +#define GLboolean_ref(num) &bgl_var##num +#define GLboolean_def(num) /* unsigned */ char GLboolean_var(num) + +/* typedef unsigned int GLbitfield; */ +#define GLbitfield_str "i" +#define GLbitfield_var(num) bgl_var##num +#define GLbitfield_ref(num) &bgl_var##num +#define GLbitfield_def(num) /* unsigned */ int GLbitfield_var(num) + +/* typedef signed char GLbyte; */ +#define GLbyte_str "b" +#define GLbyte_var(num) bgl_var##num +#define GLbyte_ref(num) &bgl_var##num +#define GLbyte_def(num) signed char GLbyte_var(num) + +/* typedef short GLshort; */ +#define GLshort_str "h" +#define GLshort_var(num) bgl_var##num +#define GLshort_ref(num) &bgl_var##num +#define GLshort_def(num) short GLshort_var(num) + +/* typedef int GLint; */ +#define GLint_str "i" +#define GLint_var(num) bgl_var##num +#define GLint_ref(num) &bgl_var##num +#define GLint_def(num) int GLint_var(num) + +/* typedef int GLsizei; */ +#define GLsizei_str "n" +#define GLsizei_var(num) bgl_var##num +#define GLsizei_ref(num) &bgl_var##num +#define GLsizei_def(num) size_t GLsizei_var(num) + +/* typedef int GLsizeiptr; */ +#define GLsizeiptr_str "n" +#define GLsizeiptr_var(num) bgl_var##num +#define GLsizeiptr_ref(num) &bgl_var##num +#define GLsizeiptr_def(num) size_t GLsizeiptr_var(num) + +/* typedef int GLintptr; */ +#define GLintptr_str "n" +#define GLintptr_var(num) bgl_var##num +#define GLintptr_ref(num) &bgl_var##num +#define GLintptr_def(num) size_t GLintptr_var(num) + +/* typedef unsigned char GLubyte; */ +#define GLubyte_str "B" +#define GLubyte_var(num) bgl_var##num +#define GLubyte_ref(num) &bgl_var##num +#define GLubyte_def(num) /* unsigned */ char GLubyte_var(num) + +/* typedef unsigned short GLushort; */ +#define GLushort_str "H" +#define GLushort_var(num) bgl_var##num +#define GLushort_ref(num) &bgl_var##num +#define GLushort_def(num) /* unsigned */ short GLushort_var(num) + +/* typedef unsigned int GLuint; */ +#define GLuint_str "I" +#define GLuint_var(num) bgl_var##num +#define GLuint_ref(num) &bgl_var##num +#define GLuint_def(num) /* unsigned */ int GLuint_var(num) + +/* typedef unsigned int GLuint64; */ +#if 0 +#define GLuint64_str "Q" +#define GLuint64_var(num) bgl_var##num +#define GLuint64_ref(num) &bgl_var##num +#define GLuint64_def(num) /* unsigned */ int GLuint64_var(num) +#endif + +/* typedef unsigned int GLsync; */ +#if 0 +#define GLsync_str "I" +#define GLsync_var(num) bgl_var##num +#define GLsync_ref(num) &bgl_var##num +#define GLsync_def(num) /* unsigned */ int GLsync_var(num) +#endif + +/* typedef float GLfloat; */ +#define GLfloat_str "f" +#define GLfloat_var(num) bgl_var##num +#define GLfloat_ref(num) &bgl_var##num +#define GLfloat_def(num) float GLfloat_var(num) + +/* typedef char *GLstring; */ +#if 0 +#define GLstring_str "s" +#define GLstring_var(number) bgl_var##number +#define GLstring_ref(number) &bgl_var##number +#define GLstring_def(number) char *GLstring_var(number) +#endif + +/* typedef float GLclampf; */ +#if 0 +#define GLclampf_str "f" +#define GLclampf_var(num) bgl_var##num +#define GLclampf_ref(num) &bgl_var##num +#define GLclampf_def(num) float GLclampf_var(num) +#endif + +/* typedef double GLdouble; */ +#define GLdouble_str "d" +#define GLdouble_var(num) bgl_var##num +#define GLdouble_ref(num) &bgl_var##num +#define GLdouble_def(num) double GLdouble_var(num) + +/* typedef double GLclampd; */ +#if 0 +#define GLclampd_str "d" +#define GLclampd_var(num) bgl_var##num +#define GLclampd_ref(num) &bgl_var##num +#define GLclampd_def(num) double GLclampd_var(num) +#endif + +#define _arg_def1(a1) \ + a1##_def(1) +#define _arg_def2(a1, a2) \ + _arg_def1(a1); a2##_def(2) +#define _arg_def3(a1, a2, a3) \ + _arg_def2(a1, a2); a3##_def(3) +#define _arg_def4(a1, a2, a3, a4) \ + _arg_def3(a1, a2, a3); a4##_def(4) +#define _arg_def5(a1, a2, a3, a4, a5) \ + _arg_def4(a1, a2, a3, a4); a5##_def(5) +#define _arg_def6(a1, a2, a3, a4, a5, a6) \ + _arg_def5(a1, a2, a3, a4, a5); a6##_def(6) +#define _arg_def7(a1, a2, a3, a4, a5, a6, a7) \ + _arg_def6(a1, a2, a3, a4, a5, a6); a7##_def(7) +#define _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8) \ + _arg_def7(a1, a2, a3, a4, a5, a6, a7); a8##_def(8) +#define _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ + _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8); a9##_def(9) +#define _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ + _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9); a10##_def(10) +#define _arg_def11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ + _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); a11##_def(11) +#define arg_def(...) VA_NARGS_CALL_OVERLOAD(_arg_def, __VA_ARGS__) + +#define _arg_var1(a1) \ + a1##_var(1) +#define _arg_var2(a1, a2) \ + _arg_var1(a1), a2##_var(2) +#define _arg_var3(a1, a2, a3) \ + _arg_var2(a1, a2), a3##_var(3) +#define _arg_var4(a1, a2, a3, a4) \ + _arg_var3(a1, a2, a3), a4##_var(4) +#define _arg_var5(a1, a2, a3, a4, a5) \ + _arg_var4(a1, a2, a3, a4), a5##_var(5) +#define _arg_var6(a1, a2, a3, a4, a5, a6) \ + _arg_var5(a1, a2, a3, a4, a5), a6##_var(6) +#define _arg_var7(a1, a2, a3, a4, a5, a6, a7) \ + _arg_var6(a1, a2, a3, a4, a5, a6), a7##_var(7) +#define _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8) \ + _arg_var7(a1, a2, a3, a4, a5, a6, a7), a8##_var(8) +#define _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ + _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_var(9) +#define _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ + _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_var(10) +#define _arg_var11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ + _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_var(11) +#define arg_var(...) VA_NARGS_CALL_OVERLOAD(_arg_var, __VA_ARGS__) + +#define _arg_ref1(a1) \ + a1##_ref(1) +#define _arg_ref2(a1, a2) \ + _arg_ref1(a1), a2##_ref(2) +#define _arg_ref3(a1, a2, a3) \ + _arg_ref2(a1, a2), a3##_ref(3) +#define _arg_ref4(a1, a2, a3, a4) \ + _arg_ref3(a1, a2, a3), a4##_ref(4) +#define _arg_ref5(a1, a2, a3, a4, a5) \ + _arg_ref4(a1, a2, a3, a4), a5##_ref(5) +#define _arg_ref6(a1, a2, a3, a4, a5, a6) \ + _arg_ref5(a1, a2, a3, a4, a5), a6##_ref(6) +#define _arg_ref7(a1, a2, a3, a4, a5, a6, a7) \ + _arg_ref6(a1, a2, a3, a4, a5, a6), a7##_ref(7) +#define _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8) \ + _arg_ref7(a1, a2, a3, a4, a5, a6, a7), a8##_ref(8) +#define _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ + _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_ref(9) +#define _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ + _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_ref(10) +#define _arg_ref11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ + _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_ref(11) +#define arg_ref(...) VA_NARGS_CALL_OVERLOAD(_arg_ref, __VA_ARGS__) + +#define _arg_str1(a1) \ + a1##_str +#define _arg_str2(a1, a2) \ + _arg_str1(a1) a2##_str +#define _arg_str3(a1, a2, a3) \ + _arg_str2(a1, a2) a3##_str +#define _arg_str4(a1, a2, a3, a4) \ + _arg_str3(a1, a2, a3) a4##_str +#define _arg_str5(a1, a2, a3, a4, a5) \ + _arg_str4(a1, a2, a3, a4) a5##_str +#define _arg_str6(a1, a2, a3, a4, a5, a6) \ + _arg_str5(a1, a2, a3, a4, a5) a6##_str +#define _arg_str7(a1, a2, a3, a4, a5, a6, a7) \ + _arg_str6(a1, a2, a3, a4, a5, a6) a7##_str +#define _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) \ + _arg_str7(a1, a2, a3, a4, a5, a6, a7) a8##_str +#define _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ + _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) a9##_str +#define _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ + _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) a10##_str +#define _arg_str11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ + _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) a11##_str +#define arg_str(...) VA_NARGS_CALL_OVERLOAD(_arg_str, __VA_ARGS__) + +#define ret_def_void +#define ret_set_void +#define ret_ret_void return Py_INCREF(Py_None), Py_None + +#define ret_def_GLint int ret_int +#define ret_set_GLint ret_int = +#define ret_ret_GLint return PyLong_FromLong(ret_int) + +#define ret_def_GLuint unsigned int ret_uint +#define ret_set_GLuint ret_uint = +#define ret_ret_GLuint return PyLong_FromLong((long) ret_uint) + +#if 0 +#define ret_def_GLsizei size_t ret_size_t +#define ret_set_GLsizei ret_size_t = +#define ret_ret_GLsizei return PyLong_FromSsize_t(ret_size_t) +#endif + +#if 0 +#define ret_def_GLsync unsigned int ret_sync +#define ret_set_GLsync ret_sync = +#define ret_ret_GLsync return PyLong_FromLong((long) ret_sync) +#endif + +#define ret_def_GLenum unsigned int ret_uint +#define ret_set_GLenum ret_uint = +#define ret_ret_GLenum return PyLong_FromLong((long) ret_uint) + +#define ret_def_GLboolean unsigned char ret_bool +#define ret_set_GLboolean ret_bool = +#define ret_ret_GLboolean return PyLong_FromLong((long) ret_bool) + +#define ret_def_GLstring const unsigned char *ret_str +#define ret_set_GLstring ret_str = + +#define ret_ret_GLstring \ + if (ret_str) { \ + return PyUnicode_FromString((const char *)ret_str); \ + } \ + else { \ + PyErr_SetString(PyExc_AttributeError, "could not get opengl string"); \ + return NULL; \ + } \ + +/** \} */ + + +/* -------------------------------------------------------------------- */ +/* Forward Declarations */ static PyObject *Buffer_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static PyObject *Method_ShaderSource(PyObject *self, PyObject *args); @@ -51,6 +450,38 @@ static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq); static PyObject *Buffer_subscript(Buffer *self, PyObject *item); static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value); + +/* -------------------------------------------------------------------- */ + +/** \name Utility Functions + * \{ */ + + +int BGL_typeSize(int type) +{ + switch (type) { + case GL_BYTE: + return sizeof(char); + case GL_SHORT: + return sizeof(short); + case GL_INT: + return sizeof(int); + case GL_FLOAT: + return sizeof(float); + case GL_DOUBLE: + return sizeof(double); + } + return -1; +} + +/** \} */ + + +/* -------------------------------------------------------------------- */ + +/** \name Buffer API + * \{ */ + static PySequenceMethods Buffer_SeqMethods = { (lenfunc) Buffer_len, /*sq_length */ (binaryfunc) NULL, /*sq_concat */ @@ -201,54 +632,13 @@ PyTypeObject BGL_bufferType = { NULL /*tp_del*/ }; -#define BGL_Wrap(nargs, funcname, ret, arg_list) \ -static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args) \ -{ \ - arg_def##nargs arg_list; \ - ret_def_##ret; \ - if (!PyArg_ParseTuple(args, \ - arg_str##nargs arg_list, \ - arg_ref##nargs arg_list)) \ - { \ - return NULL; \ - } \ - ret_set_##ret gl##funcname (arg_var##nargs arg_list); \ - ret_ret_##ret; \ -} - -#define BGLU_Wrap(nargs, funcname, ret, arg_list) \ -static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args) \ -{ \ - arg_def##nargs arg_list; \ - ret_def_##ret; \ - if (!PyArg_ParseTuple(args, \ - arg_str##nargs arg_list, \ - arg_ref##nargs arg_list)) \ - { \ - return NULL; \ - } \ - ret_set_##ret glu##funcname (arg_var##nargs arg_list); \ - ret_ret_##ret; \ -} - -/********/ -int BGL_typeSize(int type) -{ - switch (type) { - case GL_BYTE: - return sizeof(char); - case GL_SHORT: - return sizeof(short); - case GL_INT: - return sizeof(int); - case GL_FLOAT: - return sizeof(float); - case GL_DOUBLE: - return sizeof(double); - } - return -1; -} - +/** + * Create a buffer object + * + * \param dimensions: An array of ndimensions integers representing the size of each dimension. + * \param initbuffer: When not NULL holds a contiguous buffer + * with the correct format from which the buffer will be initialized + */ Buffer *BGL_MakeBuffer(int type, int ndimensions, int *dimensions, void *initbuffer) { Buffer *buffer; @@ -362,7 +752,7 @@ static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject return (PyObject *)buffer; } -/*@ Buffer sequence methods */ +/* Buffer sequence methods */ static int Buffer_len(Buffer *self) { @@ -607,768 +997,659 @@ static PyObject *Buffer_repr(Buffer *self) return repr; } +/** \} */ -BGL_Wrap(2, Accum, void, (GLenum, GLfloat)) -BGL_Wrap(1, ActiveTexture, void, (GLenum)) -BGL_Wrap(2, AlphaFunc, void, (GLenum, GLclampf)) -BGL_Wrap(3, AreTexturesResident, GLboolean, (GLsizei, GLuintP, GLbooleanP)) -BGL_Wrap(2, AttachShader, void, (GLuint, GLuint)) -BGL_Wrap(1, Begin, void, (GLenum)) -BGL_Wrap(2, BindTexture, void, (GLenum, GLuint)) -BGL_Wrap(7, Bitmap, void, (GLsizei, GLsizei, GLfloat, - GLfloat, GLfloat, GLfloat, GLubyteP)) -BGL_Wrap(2, BlendFunc, void, (GLenum, GLenum)) -BGL_Wrap(1, CallList, void, (GLuint)) -BGL_Wrap(3, CallLists, void, (GLsizei, GLenum, GLvoidP)) -BGL_Wrap(1, Clear, void, (GLbitfield)) -BGL_Wrap(4, ClearAccum, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(4, ClearColor, void, (GLclampf, GLclampf, GLclampf, GLclampf)) -BGL_Wrap(1, ClearDepth, void, (GLclampd)) -BGL_Wrap(1, ClearIndex, void, (GLfloat)) -BGL_Wrap(1, ClearStencil, void, (GLint)) -BGL_Wrap(2, ClipPlane, void, (GLenum, GLdoubleP)) -BGL_Wrap(3, Color3b, void, (GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Color3bv, void, (GLbyteP)) -BGL_Wrap(3, Color3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Color3dv, void, (GLdoubleP)) -BGL_Wrap(3, Color3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Color3fv, void, (GLfloatP)) -BGL_Wrap(3, Color3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Color3iv, void, (GLintP)) -BGL_Wrap(3, Color3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Color3sv, void, (GLshortP)) -BGL_Wrap(3, Color3ub, void, (GLubyte, GLubyte, GLubyte)) -BGL_Wrap(1, Color3ubv, void, (GLubyteP)) -BGL_Wrap(3, Color3ui, void, (GLuint, GLuint, GLuint)) -BGL_Wrap(1, Color3uiv, void, (GLuintP)) -BGL_Wrap(3, Color3us, void, (GLushort, GLushort, GLushort)) -BGL_Wrap(1, Color3usv, void, (GLushortP)) -BGL_Wrap(4, Color4b, void, (GLbyte, GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Color4bv, void, (GLbyteP)) -BGL_Wrap(4, Color4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Color4dv, void, (GLdoubleP)) -BGL_Wrap(4, Color4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Color4fv, void, (GLfloatP)) -BGL_Wrap(4, Color4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, Color4iv, void, (GLintP)) -BGL_Wrap(4, Color4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, Color4sv, void, (GLshortP)) -BGL_Wrap(4, Color4ub, void, (GLubyte, GLubyte, GLubyte, GLubyte)) -BGL_Wrap(1, Color4ubv, void, (GLubyteP)) -BGL_Wrap(4, Color4ui, void, (GLuint, GLuint, GLuint, GLuint)) -BGL_Wrap(1, Color4uiv, void, (GLuintP)) -BGL_Wrap(4, Color4us, void, (GLushort, GLushort, GLushort, GLushort)) -BGL_Wrap(1, Color4usv, void, (GLushortP)) -BGL_Wrap(4, ColorMask, void, (GLboolean, GLboolean, GLboolean, GLboolean)) -BGL_Wrap(2, ColorMaterial, void, (GLenum, GLenum)) -BGL_Wrap(1, CompileShader, void, (GLuint)) -BGL_Wrap(5, CopyPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum)) -BGL_Wrap(8, CopyTexImage2D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint)) -BGL_Wrap(1, CreateProgram, GLuint, (void)) -BGL_Wrap(1, CreateShader, GLuint, (GLenum)) -BGL_Wrap(1, CullFace, void, (GLenum)) -BGL_Wrap(2, DeleteLists, void, (GLuint, GLsizei)) -BGL_Wrap(1, DeleteProgram, void, (GLuint)) -BGL_Wrap(1, DeleteShader, void, (GLuint)) -BGL_Wrap(2, DeleteTextures, void, (GLsizei, GLuintP)) -BGL_Wrap(1, DepthFunc, void, (GLenum)) -BGL_Wrap(1, DepthMask, void, (GLboolean)) -BGL_Wrap(2, DepthRange, void, (GLclampd, GLclampd)) -BGL_Wrap(2, DetachShader, void, (GLuint, GLuint)) -BGL_Wrap(1, Disable, void, (GLenum)) -BGL_Wrap(1, DrawBuffer, void, (GLenum)) -BGL_Wrap(5, DrawPixels, void, (GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) -BGL_Wrap(1, EdgeFlag, void, (GLboolean)) -BGL_Wrap(1, EdgeFlagv, void, (GLbooleanP)) -BGL_Wrap(1, Enable, void, (GLenum)) -BGL_Wrap(1, End, void, (void)) -BGL_Wrap(1, EndList, void, (void)) -BGL_Wrap(1, EvalCoord1d, void, (GLdouble)) -BGL_Wrap(1, EvalCoord1dv, void, (GLdoubleP)) -BGL_Wrap(1, EvalCoord1f, void, (GLfloat)) -BGL_Wrap(1, EvalCoord1fv, void, (GLfloatP)) -BGL_Wrap(2, EvalCoord2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, EvalCoord2dv, void, (GLdoubleP)) -BGL_Wrap(2, EvalCoord2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, EvalCoord2fv, void, (GLfloatP)) -BGL_Wrap(3, EvalMesh1, void, (GLenum, GLint, GLint)) -BGL_Wrap(5, EvalMesh2, void, (GLenum, GLint, GLint, GLint, GLint)) -BGL_Wrap(1, EvalPoint1, void, (GLint)) -BGL_Wrap(2, EvalPoint2, void, (GLint, GLint)) -BGL_Wrap(3, FeedbackBuffer, void, (GLsizei, GLenum, GLfloatP)) -BGL_Wrap(1, Finish, void, (void)) -BGL_Wrap(1, Flush, void, (void)) -BGL_Wrap(2, Fogf, void, (GLenum, GLfloat)) -BGL_Wrap(2, Fogfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, Fogi, void, (GLenum, GLint)) -BGL_Wrap(2, Fogiv, void, (GLenum, GLintP)) -BGL_Wrap(1, FrontFace, void, (GLenum)) -BGL_Wrap(6, Frustum, void, (GLdouble, GLdouble, - GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, GenLists, GLuint, (GLsizei)) -BGL_Wrap(2, GenTextures, void, (GLsizei, GLuintP)) -BGL_Wrap(4, GetAttachedShaders, void, (GLuint, GLsizei, GLsizeiP, GLuintP)) -BGL_Wrap(2, GetBooleanv, void, (GLenum, GLbooleanP)) -BGL_Wrap(2, GetClipPlane, void, (GLenum, GLdoubleP)) -BGL_Wrap(2, GetDoublev, void, (GLenum, GLdoubleP)) -BGL_Wrap(1, GetError, GLenum, (void)) -BGL_Wrap(2, GetFloatv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, GetIntegerv, void, (GLenum, GLintP)) -BGL_Wrap(3, GetLightfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetLightiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetMapdv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, GetMapfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetMapiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetMaterialfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetMaterialiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, GetPixelMapfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, GetPixelMapuiv, void, (GLenum, GLuintP)) -BGL_Wrap(2, GetPixelMapusv, void, (GLenum, GLushortP)) -BGL_Wrap(1, GetPolygonStipple, void, (GLubyteP)) -BGL_Wrap(4, GetProgramInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) -BGL_Wrap(3, GetProgramiv, void, (GLuint, GLenum, GLintP)) -BGL_Wrap(4, GetShaderInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) -BGL_Wrap(3, GetShaderiv, void, (GLuint, GLenum, GLintP)) -BGL_Wrap(4, GetShaderSource, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) -BGL_Wrap(1, GetString, GLstring, (GLenum)) -BGL_Wrap(3, GetTexEnvfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexEnviv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetTexGendv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, GetTexGenfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexGeniv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(5, GetTexImage, void, (GLenum, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(4, GetTexLevelParameterfv, void, (GLenum, GLint, GLenum, GLfloatP)) -BGL_Wrap(4, GetTexLevelParameteriv, void, (GLenum, GLint, GLenum, GLintP)) -BGL_Wrap(3, GetTexParameterfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexParameteriv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, GetUniformLocation, GLint, (GLuint, GLstring)) -BGL_Wrap(2, Hint, void, (GLenum, GLenum)) -BGL_Wrap(1, IndexMask, void, (GLuint)) -BGL_Wrap(1, Indexd, void, (GLdouble)) -BGL_Wrap(1, Indexdv, void, (GLdoubleP)) -BGL_Wrap(1, Indexf, void, (GLfloat)) -BGL_Wrap(1, Indexfv, void, (GLfloatP)) -BGL_Wrap(1, Indexi, void, (GLint)) -BGL_Wrap(1, Indexiv, void, (GLintP)) -BGL_Wrap(1, Indexs, void, (GLshort)) -BGL_Wrap(1, Indexsv, void, (GLshortP)) -BGL_Wrap(1, InitNames, void, (void)) -BGL_Wrap(1, IsEnabled, GLboolean, (GLenum)) -BGL_Wrap(1, IsList, GLboolean, (GLuint)) -BGL_Wrap(1, IsProgram, GLboolean, (GLuint)) -BGL_Wrap(1, IsShader, GLboolean, (GLuint)) -BGL_Wrap(1, IsTexture, GLboolean, (GLuint)) -BGL_Wrap(2, LightModelf, void, (GLenum, GLfloat)) -BGL_Wrap(2, LightModelfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, LightModeli, void, (GLenum, GLint)) -BGL_Wrap(2, LightModeliv, void, (GLenum, GLintP)) -BGL_Wrap(3, Lightf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, Lightfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, Lighti, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, Lightiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, LineStipple, void, (GLint, GLushort)) -BGL_Wrap(1, LineWidth, void, (GLfloat)) -BGL_Wrap(1, LinkProgram, void, (GLuint)) -BGL_Wrap(1, ListBase, void, (GLuint)) -BGL_Wrap(1, LoadIdentity, void, (void)) -BGL_Wrap(1, LoadMatrixd, void, (GLdoubleP)) -BGL_Wrap(1, LoadMatrixf, void, (GLfloatP)) -BGL_Wrap(1, LoadName, void, (GLuint)) -BGL_Wrap(1, LogicOp, void, (GLenum)) -BGL_Wrap(6, Map1d, void, (GLenum, GLdouble, GLdouble, - GLint, GLint, GLdoubleP)) -BGL_Wrap(6, Map1f, void, (GLenum, GLfloat, GLfloat, - GLint, GLint, GLfloatP)) -BGL_Wrap(10, Map2d, void, (GLenum, GLdouble, GLdouble, - GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdoubleP)) -BGL_Wrap(10, Map2f, void, (GLenum, GLfloat, GLfloat, - GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloatP)) -BGL_Wrap(3, MapGrid1d, void, (GLint, GLdouble, GLdouble)) -BGL_Wrap(3, MapGrid1f, void, (GLint, GLfloat, GLfloat)) -BGL_Wrap(6, MapGrid2d, void, (GLint, GLdouble, GLdouble, - GLint, GLdouble, GLdouble)) -BGL_Wrap(6, MapGrid2f, void, (GLint, GLfloat, GLfloat, - GLint, GLfloat, GLfloat)) -BGL_Wrap(3, Materialf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, Materialfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, Materiali, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, Materialiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(1, MatrixMode, void, (GLenum)) -BGL_Wrap(1, MultMatrixd, void, (GLdoubleP)) -BGL_Wrap(1, MultMatrixf, void, (GLfloatP)) -BGL_Wrap(2, NewList, void, (GLuint, GLenum)) -BGL_Wrap(3, Normal3b, void, (GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Normal3bv, void, (GLbyteP)) -BGL_Wrap(3, Normal3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Normal3dv, void, (GLdoubleP)) -BGL_Wrap(3, Normal3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Normal3fv, void, (GLfloatP)) -BGL_Wrap(3, Normal3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Normal3iv, void, (GLintP)) -BGL_Wrap(3, Normal3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Normal3sv, void, (GLshortP)) -BGL_Wrap(6, Ortho, void, (GLdouble, GLdouble, - GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, PassThrough, void, (GLfloat)) -BGL_Wrap(3, PixelMapfv, void, (GLenum, GLint, GLfloatP)) -BGL_Wrap(3, PixelMapuiv, void, (GLenum, GLint, GLuintP)) -BGL_Wrap(3, PixelMapusv, void, (GLenum, GLint, GLushortP)) -BGL_Wrap(2, PixelStoref, void, (GLenum, GLfloat)) -BGL_Wrap(2, PixelStorei, void, (GLenum, GLint)) -BGL_Wrap(2, PixelTransferf, void, (GLenum, GLfloat)) -BGL_Wrap(2, PixelTransferi, void, (GLenum, GLint)) -BGL_Wrap(2, PixelZoom, void, (GLfloat, GLfloat)) -BGL_Wrap(1, PointSize, void, (GLfloat)) -BGL_Wrap(2, PolygonMode, void, (GLenum, GLenum)) -BGL_Wrap(2, PolygonOffset, void, (GLfloat, GLfloat)) -BGL_Wrap(1, PolygonStipple, void, (GLubyteP)) -BGL_Wrap(1, PopAttrib, void, (void)) -BGL_Wrap(1, PopClientAttrib, void, (void)) -BGL_Wrap(1, PopMatrix, void, (void)) -BGL_Wrap(1, PopName, void, (void)) -BGL_Wrap(3, PrioritizeTextures, void, (GLsizei, GLuintP, GLclampfP)) -BGL_Wrap(1, PushAttrib, void, (GLbitfield)) -BGL_Wrap(1, PushClientAttrib, void, (GLbitfield)) -BGL_Wrap(1, PushMatrix, void, (void)) -BGL_Wrap(1, PushName, void, (GLuint)) -BGL_Wrap(2, RasterPos2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos2dv, void, (GLdoubleP)) -BGL_Wrap(2, RasterPos2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos2fv, void, (GLfloatP)) -BGL_Wrap(2, RasterPos2i, void, (GLint, GLint)) -BGL_Wrap(1, RasterPos2iv, void, (GLintP)) -BGL_Wrap(2, RasterPos2s, void, (GLshort, GLshort)) -BGL_Wrap(1, RasterPos2sv, void, (GLshortP)) -BGL_Wrap(3, RasterPos3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos3dv, void, (GLdoubleP)) -BGL_Wrap(3, RasterPos3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos3fv, void, (GLfloatP)) -BGL_Wrap(3, RasterPos3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, RasterPos3iv, void, (GLintP)) -BGL_Wrap(3, RasterPos3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, RasterPos3sv, void, (GLshortP)) -BGL_Wrap(4, RasterPos4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos4dv, void, (GLdoubleP)) -BGL_Wrap(4, RasterPos4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos4fv, void, (GLfloatP)) -BGL_Wrap(4, RasterPos4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, RasterPos4iv, void, (GLintP)) -BGL_Wrap(4, RasterPos4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, RasterPos4sv, void, (GLshortP)) -BGL_Wrap(1, ReadBuffer, void, (GLenum)) -BGL_Wrap(7, ReadPixels, void, (GLint, GLint, GLsizei, - GLsizei, GLenum, GLenum, GLvoidP)) -BGL_Wrap(4, Rectd, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(2, Rectdv, void, (GLdoubleP, GLdoubleP)) -BGL_Wrap(4, Rectf, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(2, Rectfv, void, (GLfloatP, GLfloatP)) -BGL_Wrap(4, Recti, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(2, Rectiv, void, (GLintP, GLintP)) -BGL_Wrap(4, Rects, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(2, Rectsv, void, (GLshortP, GLshortP)) -BGL_Wrap(1, RenderMode, GLint, (GLenum)) -BGL_Wrap(4, Rotated, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(4, Rotatef, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(3, Scaled, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(3, Scalef, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(4, Scissor, void, (GLint, GLint, GLsizei, GLsizei)) -BGL_Wrap(2, SelectBuffer, void, (GLsizei, GLuintP)) -BGL_Wrap(1, ShadeModel, void, (GLenum)) -BGL_Wrap(3, StencilFunc, void, (GLenum, GLint, GLuint)) -BGL_Wrap(1, StencilMask, void, (GLuint)) -BGL_Wrap(3, StencilOp, void, (GLenum, GLenum, GLenum)) -BGL_Wrap(1, TexCoord1d, void, (GLdouble)) -BGL_Wrap(1, TexCoord1dv, void, (GLdoubleP)) -BGL_Wrap(1, TexCoord1f, void, (GLfloat)) -BGL_Wrap(1, TexCoord1fv, void, (GLfloatP)) -BGL_Wrap(1, TexCoord1i, void, (GLint)) -BGL_Wrap(1, TexCoord1iv, void, (GLintP)) -BGL_Wrap(1, TexCoord1s, void, (GLshort)) -BGL_Wrap(1, TexCoord1sv, void, (GLshortP)) -BGL_Wrap(2, TexCoord2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord2dv, void, (GLdoubleP)) -BGL_Wrap(2, TexCoord2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord2fv, void, (GLfloatP)) -BGL_Wrap(2, TexCoord2i, void, (GLint, GLint)) -BGL_Wrap(1, TexCoord2iv, void, (GLintP)) -BGL_Wrap(2, TexCoord2s, void, (GLshort, GLshort)) -BGL_Wrap(1, TexCoord2sv, void, (GLshortP)) -BGL_Wrap(3, TexCoord3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord3dv, void, (GLdoubleP)) -BGL_Wrap(3, TexCoord3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord3fv, void, (GLfloatP)) -BGL_Wrap(3, TexCoord3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, TexCoord3iv, void, (GLintP)) -BGL_Wrap(3, TexCoord3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, TexCoord3sv, void, (GLshortP)) -BGL_Wrap(4, TexCoord4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord4dv, void, (GLdoubleP)) -BGL_Wrap(4, TexCoord4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord4fv, void, (GLfloatP)) -BGL_Wrap(4, TexCoord4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, TexCoord4iv, void, (GLintP)) -BGL_Wrap(4, TexCoord4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, TexCoord4sv, void, (GLshortP)) -BGL_Wrap(3, TexEnvf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexEnvfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexEnvi, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexEnviv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, TexGend, void, (GLenum, GLenum, GLdouble)) -BGL_Wrap(3, TexGendv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, TexGenf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexGenfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexGeni, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexGeniv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(8, TexImage1D, void, (GLenum, GLint, GLint, - GLsizei, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(9, TexImage2D, void, (GLenum, GLint, GLint, - GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(3, TexParameterf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexParameterfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexParameteri, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexParameteriv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, Translated, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(3, Translatef, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(2, Uniform1f, void, (GLint, GLfloat)) -BGL_Wrap(3, Uniform2f, void, (GLint, GLfloat, GLfloat)) -BGL_Wrap(4, Uniform3f, void, (GLint, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(5, Uniform4f, void, (GLint, GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(3, Uniform1fv, void, (GLint, GLsizei, GLfloatP)) -BGL_Wrap(3, Uniform2fv, void, (GLint, GLsizei, GLfloatP)) -BGL_Wrap(3, Uniform3fv, void, (GLint, GLsizei, GLfloatP)) -BGL_Wrap(3, Uniform4fv, void, (GLint, GLsizei, GLfloatP)) -BGL_Wrap(2, Uniform1i, void, (GLint, GLint)) -BGL_Wrap(3, Uniform2i, void, (GLint, GLint, GLint)) -BGL_Wrap(4, Uniform3i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(5, Uniform4i, void, (GLint, GLint, GLint, GLint, GLint)) -BGL_Wrap(3, Uniform1iv, void, (GLint, GLsizei, GLintP)) -BGL_Wrap(3, Uniform2iv, void, (GLint, GLsizei, GLintP)) -BGL_Wrap(3, Uniform3iv, void, (GLint, GLsizei, GLintP)) -BGL_Wrap(3, Uniform4iv, void, (GLint, GLsizei, GLintP)) -BGL_Wrap(4, UniformMatrix2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix2x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix3x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix2x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix4x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix3x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(4, UniformMatrix4x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) -BGL_Wrap(1, UseProgram, void, (GLuint)) -BGL_Wrap(1, ValidateProgram, void, (GLuint)) -BGL_Wrap(2, Vertex2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, Vertex2dv, void, (GLdoubleP)) -BGL_Wrap(2, Vertex2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, Vertex2fv, void, (GLfloatP)) -BGL_Wrap(2, Vertex2i, void, (GLint, GLint)) -BGL_Wrap(1, Vertex2iv, void, (GLintP)) -BGL_Wrap(2, Vertex2s, void, (GLshort, GLshort)) -BGL_Wrap(1, Vertex2sv, void, (GLshortP)) -BGL_Wrap(3, Vertex3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Vertex3dv, void, (GLdoubleP)) -BGL_Wrap(3, Vertex3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Vertex3fv, void, (GLfloatP)) -BGL_Wrap(3, Vertex3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Vertex3iv, void, (GLintP)) -BGL_Wrap(3, Vertex3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Vertex3sv, void, (GLshortP)) -BGL_Wrap(4, Vertex4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Vertex4dv, void, (GLdoubleP)) -BGL_Wrap(4, Vertex4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Vertex4fv, void, (GLfloatP)) -BGL_Wrap(4, Vertex4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, Vertex4iv, void, (GLintP)) -BGL_Wrap(4, Vertex4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, Vertex4sv, void, (GLshortP)) -BGL_Wrap(4, Viewport, void, (GLint, GLint, GLsizei, GLsizei)) -BGLU_Wrap(4, Perspective, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGLU_Wrap(9, LookAt, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) -BGLU_Wrap(4, Ortho2D, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGLU_Wrap(5, PickMatrix, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLintP)) -BGLU_Wrap(9, Project, GLint, (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP)) -BGLU_Wrap(9, UnProject, GLint, (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP)) - -#undef MethodDef -#define MethodDef(func) {"gl"#func, Method_##func, METH_VARARGS, "no string"} -#define MethodDefu(func) {"glu"#func, Method_##func, METH_VARARGS, "no string"} -/* So that MethodDef(Accum) becomes: - * {"glAccum", Method_Accumfunc, METH_VARARGS} */ -static struct PyMethodDef BGL_methods[] = { +/* -------------------------------------------------------------------- */ + +/** \name OpenGL API Wrapping + * \{ */ + +#define BGL_Wrap(funcname, ret, arg_list) \ +static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args) \ +{ \ + arg_def arg_list; \ + ret_def_##ret; \ + if (!PyArg_ParseTuple(args, arg_str arg_list, arg_ref arg_list)) { \ + return NULL; \ + } \ + ret_set_##ret gl##funcname (arg_var arg_list); \ + ret_ret_##ret; \ +} + +#define BGLU_Wrap(funcname, ret, arg_list) \ +static PyObject *Method_##funcname (PyObject *UNUSED(self), PyObject *args) \ +{ \ + arg_def arg_list; \ + ret_def_##ret; \ + if (!PyArg_ParseTuple(args, arg_str arg_list, arg_ref arg_list)) { \ + return NULL; \ + } \ + ret_set_##ret glu##funcname (arg_var arg_list); \ + ret_ret_##ret; \ +} + +/* GL_VERSION_1_0 */ +BGL_Wrap(Accum, void, (GLenum, GLfloat)) +BGL_Wrap(AlphaFunc, void, (GLenum, GLfloat)) +BGL_Wrap(Begin, void, (GLenum)) +BGL_Wrap(Bitmap, void, (GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, GLubyteP)) +BGL_Wrap(BlendFunc, void, (GLenum, GLenum)) +BGL_Wrap(CallList, void, (GLuint)) +BGL_Wrap(CallLists, void, (GLsizei, GLenum, GLvoidP)) +BGL_Wrap(Clear, void, (GLbitfield)) +BGL_Wrap(ClearAccum, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(ClearColor, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(ClearDepth, void, (GLdouble)) +BGL_Wrap(ClearIndex, void, (GLfloat)) +BGL_Wrap(ClearStencil, void, (GLint)) +BGL_Wrap(ClipPlane, void, (GLenum, GLdoubleP)) +BGL_Wrap(Color3b, void, (GLbyte, GLbyte, GLbyte)) +BGL_Wrap(Color3bv, void, (GLbyteP)) +BGL_Wrap(Color3d, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Color3dv, void, (GLdoubleP)) +BGL_Wrap(Color3f, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Color3fv, void, (GLfloatP)) +BGL_Wrap(Color3i, void, (GLint, GLint, GLint)) +BGL_Wrap(Color3iv, void, (GLintP)) +BGL_Wrap(Color3s, void, (GLshort, GLshort, GLshort)) +BGL_Wrap(Color3sv, void, (GLshortP)) +BGL_Wrap(Color3ub, void, (GLubyte, GLubyte, GLubyte)) +BGL_Wrap(Color3ubv, void, (GLubyteP)) +BGL_Wrap(Color3ui, void, (GLuint, GLuint, GLuint)) +BGL_Wrap(Color3uiv, void, (GLuintP)) +BGL_Wrap(Color3us, void, (GLushort, GLushort, GLushort)) +BGL_Wrap(Color3usv, void, (GLushortP)) +BGL_Wrap(Color4b, void, (GLbyte, GLbyte, GLbyte, GLbyte)) +BGL_Wrap(Color4bv, void, (GLbyteP)) +BGL_Wrap(Color4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Color4dv, void, (GLdoubleP)) +BGL_Wrap(Color4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Color4fv, void, (GLfloatP)) +BGL_Wrap(Color4i, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(Color4iv, void, (GLintP)) +BGL_Wrap(Color4s, void, (GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(Color4sv, void, (GLshortP)) +BGL_Wrap(Color4ub, void, (GLubyte, GLubyte, GLubyte, GLubyte)) +BGL_Wrap(Color4ubv, void, (GLubyteP)) +BGL_Wrap(Color4ui, void, (GLuint, GLuint, GLuint, GLuint)) +BGL_Wrap(Color4uiv, void, (GLuintP)) +BGL_Wrap(Color4us, void, (GLushort, GLushort, GLushort, GLushort)) +BGL_Wrap(Color4usv, void, (GLushortP)) +BGL_Wrap(ColorMask, void, (GLboolean, GLboolean, GLboolean, GLboolean)) +BGL_Wrap(ColorMaterial, void, (GLenum, GLenum)) +BGL_Wrap(CopyPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum)) +BGL_Wrap(CullFace, void, (GLenum)) +BGL_Wrap(DeleteLists, void, (GLuint, GLsizei)) +BGL_Wrap(DepthFunc, void, (GLenum)) +BGL_Wrap(DepthMask, void, (GLboolean)) +BGL_Wrap(DepthRange, void, (GLdouble, GLdouble)) +BGL_Wrap(Disable, void, (GLenum)) +BGL_Wrap(DrawBuffer, void, (GLenum)) +BGL_Wrap(DrawPixels, void, (GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) +BGL_Wrap(EdgeFlag, void, (GLboolean)) +BGL_Wrap(EdgeFlagv, void, (GLbooleanP)) +BGL_Wrap(Enable, void, (GLenum)) +BGL_Wrap(End, void, (void)) +BGL_Wrap(EndList, void, (void)) +BGL_Wrap(EvalCoord1d, void, (GLdouble)) +BGL_Wrap(EvalCoord1dv, void, (GLdoubleP)) +BGL_Wrap(EvalCoord1f, void, (GLfloat)) +BGL_Wrap(EvalCoord1fv, void, (GLfloatP)) +BGL_Wrap(EvalCoord2d, void, (GLdouble, GLdouble)) +BGL_Wrap(EvalCoord2dv, void, (GLdoubleP)) +BGL_Wrap(EvalCoord2f, void, (GLfloat, GLfloat)) +BGL_Wrap(EvalCoord2fv, void, (GLfloatP)) +BGL_Wrap(EvalMesh1, void, (GLenum, GLint, GLint)) +BGL_Wrap(EvalMesh2, void, (GLenum, GLint, GLint, GLint, GLint)) +BGL_Wrap(EvalPoint1, void, (GLint)) +BGL_Wrap(EvalPoint2, void, (GLint, GLint)) +BGL_Wrap(FeedbackBuffer, void, (GLsizei, GLenum, GLfloatP)) +BGL_Wrap(Finish, void, (void)) +BGL_Wrap(Flush, void, (void)) +BGL_Wrap(Fogf, void, (GLenum, GLfloat)) +BGL_Wrap(Fogfv, void, (GLenum, GLfloatP)) +BGL_Wrap(Fogi, void, (GLenum, GLint)) +BGL_Wrap(Fogiv, void, (GLenum, GLintP)) +BGL_Wrap(FrontFace, void, (GLenum)) +BGL_Wrap(Frustum, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(GenLists, GLuint, (GLsizei)) +BGL_Wrap(GetBooleanv, void, (GLenum, GLbooleanP)) +BGL_Wrap(GetClipPlane, void, (GLenum, GLdoubleP)) +BGL_Wrap(GetDoublev, void, (GLenum, GLdoubleP)) +BGL_Wrap(GetError, GLenum, (void)) +BGL_Wrap(GetFloatv, void, (GLenum, GLfloatP)) +BGL_Wrap(GetIntegerv, void, (GLenum, GLintP)) +BGL_Wrap(GetLightfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetLightiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetMapdv, void, (GLenum, GLenum, GLdoubleP)) +BGL_Wrap(GetMapfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetMapiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetMaterialfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetMaterialiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetPixelMapfv, void, (GLenum, GLfloatP)) +BGL_Wrap(GetPixelMapuiv, void, (GLenum, GLuintP)) +BGL_Wrap(GetPixelMapusv, void, (GLenum, GLushortP)) +BGL_Wrap(GetPolygonStipple, void, (GLubyteP)) +BGL_Wrap(GetString, GLstring, (GLenum)) +BGL_Wrap(GetTexEnvfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetTexEnviv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetTexGendv, void, (GLenum, GLenum, GLdoubleP)) +BGL_Wrap(GetTexGenfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetTexGeniv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetTexImage, void, (GLenum, GLint, GLenum, GLenum, GLvoidP)) +BGL_Wrap(GetTexLevelParameterfv, void, (GLenum, GLint, GLenum, GLfloatP)) +BGL_Wrap(GetTexLevelParameteriv, void, (GLenum, GLint, GLenum, GLintP)) +BGL_Wrap(GetTexParameterfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(GetTexParameteriv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(Hint, void, (GLenum, GLenum)) +BGL_Wrap(IndexMask, void, (GLuint)) +BGL_Wrap(Indexd, void, (GLdouble)) +BGL_Wrap(Indexdv, void, (GLdoubleP)) +BGL_Wrap(Indexf, void, (GLfloat)) +BGL_Wrap(Indexfv, void, (GLfloatP)) +BGL_Wrap(Indexi, void, (GLint)) +BGL_Wrap(Indexiv, void, (GLintP)) +BGL_Wrap(Indexs, void, (GLshort)) +BGL_Wrap(Indexsv, void, (GLshortP)) +BGL_Wrap(InitNames, void, (void)) +BGL_Wrap(IsEnabled, GLboolean, (GLenum)) +BGL_Wrap(IsList, GLboolean, (GLuint)) +BGL_Wrap(LightModelf, void, (GLenum, GLfloat)) +BGL_Wrap(LightModelfv, void, (GLenum, GLfloatP)) +BGL_Wrap(LightModeli, void, (GLenum, GLint)) +BGL_Wrap(LightModeliv, void, (GLenum, GLintP)) +BGL_Wrap(Lightf, void, (GLenum, GLenum, GLfloat)) +BGL_Wrap(Lightfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(Lighti, void, (GLenum, GLenum, GLint)) +BGL_Wrap(Lightiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(LineStipple, void, (GLint, GLushort)) +BGL_Wrap(LineWidth, void, (GLfloat)) +BGL_Wrap(ListBase, void, (GLuint)) +BGL_Wrap(LoadIdentity, void, (void)) +BGL_Wrap(LoadMatrixd, void, (GLdoubleP)) +BGL_Wrap(LoadMatrixf, void, (GLfloatP)) +BGL_Wrap(LoadName, void, (GLuint)) +BGL_Wrap(LogicOp, void, (GLenum)) +BGL_Wrap(Map1d, void, (GLenum, GLdouble, GLdouble, GLint, GLint, GLdoubleP)) +BGL_Wrap(Map1f, void, (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloatP)) +BGL_Wrap(Map2d, void, (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdoubleP)) +BGL_Wrap(Map2f, void, (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloatP)) +BGL_Wrap(MapGrid1d, void, (GLint, GLdouble, GLdouble)) +BGL_Wrap(MapGrid1f, void, (GLint, GLfloat, GLfloat)) +BGL_Wrap(MapGrid2d, void, (GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble)) +BGL_Wrap(MapGrid2f, void, (GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat)) +BGL_Wrap(Materialf, void, (GLenum, GLenum, GLfloat)) +BGL_Wrap(Materialfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(Materiali, void, (GLenum, GLenum, GLint)) +BGL_Wrap(Materialiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(MatrixMode, void, (GLenum)) +BGL_Wrap(MultMatrixd, void, (GLdoubleP)) +BGL_Wrap(MultMatrixf, void, (GLfloatP)) +BGL_Wrap(NewList, void, (GLuint, GLenum)) +BGL_Wrap(Normal3b, void, (GLbyte, GLbyte, GLbyte)) +BGL_Wrap(Normal3bv, void, (GLbyteP)) +BGL_Wrap(Normal3d, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Normal3dv, void, (GLdoubleP)) +BGL_Wrap(Normal3f, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Normal3fv, void, (GLfloatP)) +BGL_Wrap(Normal3i, void, (GLint, GLint, GLint)) +BGL_Wrap(Normal3iv, void, (GLintP)) +BGL_Wrap(Normal3s, void, (GLshort, GLshort, GLshort)) +BGL_Wrap(Normal3sv, void, (GLshortP)) +BGL_Wrap(Ortho, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(PassThrough, void, (GLfloat)) +BGL_Wrap(PixelMapfv, void, (GLenum, GLsizei, GLfloatP)) +BGL_Wrap(PixelMapuiv, void, (GLenum, GLsizei, GLuintP)) +BGL_Wrap(PixelMapusv, void, (GLenum, GLsizei, GLushortP)) +BGL_Wrap(PixelStoref, void, (GLenum, GLfloat)) +BGL_Wrap(PixelStorei, void, (GLenum, GLint)) +BGL_Wrap(PixelTransferf, void, (GLenum, GLfloat)) +BGL_Wrap(PixelTransferi, void, (GLenum, GLint)) +BGL_Wrap(PixelZoom, void, (GLfloat, GLfloat)) +BGL_Wrap(PointSize, void, (GLfloat)) +BGL_Wrap(PolygonMode, void, (GLenum, GLenum)) +BGL_Wrap(PolygonStipple, void, (GLubyteP)) +BGL_Wrap(PopAttrib, void, (void)) +BGL_Wrap(PopMatrix, void, (void)) +BGL_Wrap(PopName, void, (void)) +BGL_Wrap(PushAttrib, void, (GLbitfield)) +BGL_Wrap(PushMatrix, void, (void)) +BGL_Wrap(PushName, void, (GLuint)) +BGL_Wrap(RasterPos2d, void, (GLdouble, GLdouble)) +BGL_Wrap(RasterPos2dv, void, (GLdoubleP)) +BGL_Wrap(RasterPos2f, void, (GLfloat, GLfloat)) +BGL_Wrap(RasterPos2fv, void, (GLfloatP)) +BGL_Wrap(RasterPos2i, void, (GLint, GLint)) +BGL_Wrap(RasterPos2iv, void, (GLintP)) +BGL_Wrap(RasterPos2s, void, (GLshort, GLshort)) +BGL_Wrap(RasterPos2sv, void, (GLshortP)) +BGL_Wrap(RasterPos3d, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(RasterPos3dv, void, (GLdoubleP)) +BGL_Wrap(RasterPos3f, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(RasterPos3fv, void, (GLfloatP)) +BGL_Wrap(RasterPos3i, void, (GLint, GLint, GLint)) +BGL_Wrap(RasterPos3iv, void, (GLintP)) +BGL_Wrap(RasterPos3s, void, (GLshort, GLshort, GLshort)) +BGL_Wrap(RasterPos3sv, void, (GLshortP)) +BGL_Wrap(RasterPos4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(RasterPos4dv, void, (GLdoubleP)) +BGL_Wrap(RasterPos4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(RasterPos4fv, void, (GLfloatP)) +BGL_Wrap(RasterPos4i, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(RasterPos4iv, void, (GLintP)) +BGL_Wrap(RasterPos4s, void, (GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(RasterPos4sv, void, (GLshortP)) +BGL_Wrap(ReadBuffer, void, (GLenum)) +BGL_Wrap(ReadPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) +BGL_Wrap(Rectd, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Rectdv, void, (GLdoubleP, GLdoubleP)) +BGL_Wrap(Rectf, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Rectfv, void, (GLfloatP, GLfloatP)) +BGL_Wrap(Recti, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(Rectiv, void, (GLintP, GLintP)) +BGL_Wrap(Rects, void, (GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(Rectsv, void, (GLshortP, GLshortP)) +BGL_Wrap(RenderMode, GLint, (GLenum)) +BGL_Wrap(Rotated, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Rotatef, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Scaled, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Scalef, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Scissor, void, (GLint, GLint, GLsizei, GLsizei)) +BGL_Wrap(SelectBuffer, void, (GLsizei, GLuintP)) +BGL_Wrap(ShadeModel, void, (GLenum)) +BGL_Wrap(StencilFunc, void, (GLenum, GLint, GLuint)) +BGL_Wrap(StencilMask, void, (GLuint)) +BGL_Wrap(StencilOp, void, (GLenum, GLenum, GLenum)) +BGL_Wrap(TexCoord1d, void, (GLdouble)) +BGL_Wrap(TexCoord1dv, void, (GLdoubleP)) +BGL_Wrap(TexCoord1f, void, (GLfloat)) +BGL_Wrap(TexCoord1fv, void, (GLfloatP)) +BGL_Wrap(TexCoord1i, void, (GLint)) +BGL_Wrap(TexCoord1iv, void, (GLintP)) +BGL_Wrap(TexCoord1s, void, (GLshort)) +BGL_Wrap(TexCoord1sv, void, (GLshortP)) +BGL_Wrap(TexCoord2d, void, (GLdouble, GLdouble)) +BGL_Wrap(TexCoord2dv, void, (GLdoubleP)) +BGL_Wrap(TexCoord2f, void, (GLfloat, GLfloat)) +BGL_Wrap(TexCoord2fv, void, (GLfloatP)) +BGL_Wrap(TexCoord2i, void, (GLint, GLint)) +BGL_Wrap(TexCoord2iv, void, (GLintP)) +BGL_Wrap(TexCoord2s, void, (GLshort, GLshort)) +BGL_Wrap(TexCoord2sv, void, (GLshortP)) +BGL_Wrap(TexCoord3d, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(TexCoord3dv, void, (GLdoubleP)) +BGL_Wrap(TexCoord3f, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(TexCoord3fv, void, (GLfloatP)) +BGL_Wrap(TexCoord3i, void, (GLint, GLint, GLint)) +BGL_Wrap(TexCoord3iv, void, (GLintP)) +BGL_Wrap(TexCoord3s, void, (GLshort, GLshort, GLshort)) +BGL_Wrap(TexCoord3sv, void, (GLshortP)) +BGL_Wrap(TexCoord4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(TexCoord4dv, void, (GLdoubleP)) +BGL_Wrap(TexCoord4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(TexCoord4fv, void, (GLfloatP)) +BGL_Wrap(TexCoord4i, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(TexCoord4iv, void, (GLintP)) +BGL_Wrap(TexCoord4s, void, (GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(TexCoord4sv, void, (GLshortP)) +BGL_Wrap(TexEnvf, void, (GLenum, GLenum, GLfloat)) +BGL_Wrap(TexEnvfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(TexEnvi, void, (GLenum, GLenum, GLint)) +BGL_Wrap(TexEnviv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(TexGend, void, (GLenum, GLenum, GLdouble)) +BGL_Wrap(TexGendv, void, (GLenum, GLenum, GLdoubleP)) +BGL_Wrap(TexGenf, void, (GLenum, GLenum, GLfloat)) +BGL_Wrap(TexGenfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(TexGeni, void, (GLenum, GLenum, GLint)) +BGL_Wrap(TexGeniv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(TexImage1D, void, (GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, GLvoidP)) +BGL_Wrap(TexImage2D, void, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)) +BGL_Wrap(TexParameterf, void, (GLenum, GLenum, GLfloat)) +BGL_Wrap(TexParameterfv, void, (GLenum, GLenum, GLfloatP)) +BGL_Wrap(TexParameteri, void, (GLenum, GLenum, GLint)) +BGL_Wrap(TexParameteriv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(Translated, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Translatef, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Vertex2d, void, (GLdouble, GLdouble)) +BGL_Wrap(Vertex2dv, void, (GLdoubleP)) +BGL_Wrap(Vertex2f, void, (GLfloat, GLfloat)) +BGL_Wrap(Vertex2fv, void, (GLfloatP)) +BGL_Wrap(Vertex2i, void, (GLint, GLint)) +BGL_Wrap(Vertex2iv, void, (GLintP)) +BGL_Wrap(Vertex2s, void, (GLshort, GLshort)) +BGL_Wrap(Vertex2sv, void, (GLshortP)) +BGL_Wrap(Vertex3d, void, (GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Vertex3dv, void, (GLdoubleP)) +BGL_Wrap(Vertex3f, void, (GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Vertex3fv, void, (GLfloatP)) +BGL_Wrap(Vertex3i, void, (GLint, GLint, GLint)) +BGL_Wrap(Vertex3iv, void, (GLintP)) +BGL_Wrap(Vertex3s, void, (GLshort, GLshort, GLshort)) +BGL_Wrap(Vertex3sv, void, (GLshortP)) +BGL_Wrap(Vertex4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(Vertex4dv, void, (GLdoubleP)) +BGL_Wrap(Vertex4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Vertex4fv, void, (GLfloatP)) +BGL_Wrap(Vertex4i, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(Vertex4iv, void, (GLintP)) +BGL_Wrap(Vertex4s, void, (GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(Vertex4sv, void, (GLshortP)) +BGL_Wrap(Viewport, void, (GLint, GLint, GLsizei, GLsizei)) + + +/* GL_VERSION_1_1 */ +BGL_Wrap(AreTexturesResident, GLboolean, (GLsizei, GLuintP, GLbooleanP)) +BGL_Wrap(ArrayElement, void, (GLint)) +BGL_Wrap(BindTexture, void, (GLenum, GLuint)) +BGL_Wrap(ColorPointer, void, (GLint, GLenum, GLsizei, GLvoidP)) +BGL_Wrap(CopyTexImage1D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint)) +BGL_Wrap(CopyTexImage2D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint)) +BGL_Wrap(CopyTexSubImage1D, void, (GLenum, GLint, GLint, GLint, GLint, GLsizei)) +BGL_Wrap(CopyTexSubImage2D, void, (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)) +BGL_Wrap(DeleteTextures, void, (GLsizei, GLuintP)) +BGL_Wrap(DisableClientState, void, (GLenum)) +BGL_Wrap(DrawArrays, void, (GLenum, GLint, GLsizei)) +BGL_Wrap(DrawElements, void, (GLenum, GLsizei, GLenum, GLvoidP)) +BGL_Wrap(EdgeFlagPointer, void, (GLsizei, GLvoidP)) +BGL_Wrap(EnableClientState, void, (GLenum)) +BGL_Wrap(GenTextures, void, (GLsizei, GLuintP)) +BGL_Wrap(GetPointerv, void, (GLenum, GLvoidP)) +BGL_Wrap(IndexPointer, void, (GLenum, GLsizei, GLvoidP)) +BGL_Wrap(Indexub, void, (GLubyte)) +BGL_Wrap(Indexubv, void, (GLubyteP)) +BGL_Wrap(InterleavedArrays, void, (GLenum, GLsizei, GLvoidP)) +BGL_Wrap(IsTexture, GLboolean, (GLuint)) +BGL_Wrap(NormalPointer, void, (GLenum, GLsizei, GLvoidP)) +BGL_Wrap(PolygonOffset, void, (GLfloat, GLfloat)) +BGL_Wrap(PopClientAttrib, void, (void)) +BGL_Wrap(PrioritizeTextures, void, (GLsizei, GLuintP, GLfloatP)) +BGL_Wrap(PushClientAttrib, void, (GLbitfield)) +BGL_Wrap(TexCoordPointer, void, (GLint, GLenum, GLsizei, GLvoidP)) +BGL_Wrap(TexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoidP)) +BGL_Wrap(TexSubImage2D, void, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) +BGL_Wrap(VertexPointer, void, (GLint, GLenum, GLsizei, GLvoidP)) + + +/* GL_VERSION_1_2 */ +BGL_Wrap(CopyTexSubImage3D, void, (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)) +BGL_Wrap(DrawRangeElements, void, (GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoidP)) +BGL_Wrap(TexImage3D, void, (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)) +BGL_Wrap(TexSubImage3D, void, (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) + + +/* GL_VERSION_1_3 */ +BGL_Wrap(ActiveTexture, void, (GLenum)) +BGL_Wrap(ClientActiveTexture, void, (GLenum)) +BGL_Wrap(CompressedTexImage1D, void, (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoidP)) +BGL_Wrap(CompressedTexImage2D, void, (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoidP)) +BGL_Wrap(CompressedTexImage3D, void, (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoidP)) +BGL_Wrap(CompressedTexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoidP)) +BGL_Wrap(CompressedTexSubImage2D, void, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP)) +BGL_Wrap(CompressedTexSubImage3D, void, (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP)) +BGL_Wrap(GetCompressedTexImage, void, (GLenum, GLint, GLvoidP)) +BGL_Wrap(LoadTransposeMatrixd, void, (GLdoubleP)) +BGL_Wrap(LoadTransposeMatrixf, void, (GLfloatP)) +BGL_Wrap(MultTransposeMatrixd, void, (GLdoubleP)) +BGL_Wrap(MultTransposeMatrixf, void, (GLfloatP)) +BGL_Wrap(MultiTexCoord1d, void, (GLenum, GLdouble)) +BGL_Wrap(MultiTexCoord1dv, void, (GLenum, GLdoubleP)) +BGL_Wrap(MultiTexCoord1f, void, (GLenum, GLfloat)) +BGL_Wrap(MultiTexCoord1fv, void, (GLenum, GLfloatP)) +BGL_Wrap(MultiTexCoord1i, void, (GLenum, GLint)) +BGL_Wrap(MultiTexCoord1iv, void, (GLenum, GLintP)) +BGL_Wrap(MultiTexCoord1s, void, (GLenum, GLshort)) +BGL_Wrap(MultiTexCoord1sv, void, (GLenum, GLshortP)) +BGL_Wrap(MultiTexCoord2d, void, (GLenum, GLdouble, GLdouble)) +BGL_Wrap(MultiTexCoord2dv, void, (GLenum, GLdoubleP)) +BGL_Wrap(MultiTexCoord2f, void, (GLenum, GLfloat, GLfloat)) +BGL_Wrap(MultiTexCoord2fv, void, (GLenum, GLfloatP)) +BGL_Wrap(MultiTexCoord2i, void, (GLenum, GLint, GLint)) +BGL_Wrap(MultiTexCoord2iv, void, (GLenum, GLintP)) +BGL_Wrap(MultiTexCoord2s, void, (GLenum, GLshort, GLshort)) +BGL_Wrap(MultiTexCoord2sv, void, (GLenum, GLshortP)) +BGL_Wrap(MultiTexCoord3d, void, (GLenum, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(MultiTexCoord3dv, void, (GLenum, GLdoubleP)) +BGL_Wrap(MultiTexCoord3f, void, (GLenum, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(MultiTexCoord3fv, void, (GLenum, GLfloatP)) +BGL_Wrap(MultiTexCoord3i, void, (GLenum, GLint, GLint, GLint)) +BGL_Wrap(MultiTexCoord3iv, void, (GLenum, GLintP)) +BGL_Wrap(MultiTexCoord3s, void, (GLenum, GLshort, GLshort, GLshort)) +BGL_Wrap(MultiTexCoord3sv, void, (GLenum, GLshortP)) +BGL_Wrap(MultiTexCoord4d, void, (GLenum, GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(MultiTexCoord4dv, void, (GLenum, GLdoubleP)) +BGL_Wrap(MultiTexCoord4f, void, (GLenum, GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(MultiTexCoord4fv, void, (GLenum, GLfloatP)) +BGL_Wrap(MultiTexCoord4i, void, (GLenum, GLint, GLint, GLint, GLint)) +BGL_Wrap(MultiTexCoord4iv, void, (GLenum, GLintP)) +BGL_Wrap(MultiTexCoord4s, void, (GLenum, GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(MultiTexCoord4sv, void, (GLenum, GLshortP)) +BGL_Wrap(SampleCoverage, void, (GLfloat, GLboolean)) + + +/* GL_VERSION_1_4 */ +BGL_Wrap(BlendColor, void, (GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(BlendEquation, void, (GLenum)) + + +/* GL_VERSION_1_5 */ +BGL_Wrap(BeginQuery, void, (GLenum, GLuint)) +BGL_Wrap(BindBuffer, void, (GLenum, GLuint)) +BGL_Wrap(BufferData, void, (GLenum, GLsizeiptr, GLvoidP, GLenum)) +BGL_Wrap(BufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP)) +BGL_Wrap(DeleteBuffers, void, (GLsizei, GLuintP)) +BGL_Wrap(DeleteQueries, void, (GLsizei, GLuintP)) +BGL_Wrap(EndQuery, void, (GLenum)) +BGL_Wrap(GenBuffers, void, (GLsizei, GLuintP)) +BGL_Wrap(GenQueries, void, (GLsizei, GLuintP)) +BGL_Wrap(GetBufferParameteriv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(GetBufferPointerv, void, (GLenum, GLenum, GLvoidP)) +BGL_Wrap(GetBufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP)) +BGL_Wrap(GetQueryObjectiv, void, (GLuint, GLenum, GLintP)) +BGL_Wrap(GetQueryObjectuiv, void, (GLuint, GLenum, GLuintP)) +BGL_Wrap(GetQueryiv, void, (GLenum, GLenum, GLintP)) +BGL_Wrap(IsBuffer, GLboolean, (GLuint)) +BGL_Wrap(IsQuery, GLboolean, (GLuint)) +BGL_Wrap(MapBuffer, void, (GLenum, GLenum)) +BGL_Wrap(UnmapBuffer, GLboolean, (GLenum)) + + +/* GL_VERSION_2_0 */ +BGL_Wrap(AttachShader, void, (GLuint, GLuint)) +BGL_Wrap(BindAttribLocation, void, (GLuint, GLuint, GLcharP)) +BGL_Wrap(BlendEquationSeparate, void, (GLenum, GLenum)) +BGL_Wrap(CompileShader, void, (GLuint)) +BGL_Wrap(CreateProgram, GLuint, (void)) +BGL_Wrap(CreateShader, GLuint, (GLenum)) +BGL_Wrap(DeleteProgram, void, (GLuint)) +BGL_Wrap(DeleteShader, void, (GLuint)) +BGL_Wrap(DetachShader, void, (GLuint, GLuint)) +BGL_Wrap(DisableVertexAttribArray, void, (GLuint)) +BGL_Wrap(DrawBuffers, void, (GLsizei, GLenumP)) +BGL_Wrap(EnableVertexAttribArray, void, (GLuint)) +BGL_Wrap(GetActiveAttrib, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP)) +BGL_Wrap(GetActiveUniform, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP)) +BGL_Wrap(GetAttachedShaders, void, (GLuint, GLsizei, GLsizeiP, GLuintP)) +BGL_Wrap(GetAttribLocation, GLint, (GLuint, GLcharP)) +BGL_Wrap(GetProgramInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) +BGL_Wrap(GetProgramiv, void, (GLuint, GLenum, GLintP)) +BGL_Wrap(GetShaderInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) +BGL_Wrap(GetShaderSource, void, (GLuint, GLsizei, GLsizeiP, GLcharP)) +BGL_Wrap(GetShaderiv, void, (GLuint, GLenum, GLintP)) +BGL_Wrap(GetUniformLocation, GLint, (GLuint, GLcharP)) +BGL_Wrap(GetUniformfv, void, (GLuint, GLint, GLfloatP)) +BGL_Wrap(GetUniformiv, void, (GLuint, GLint, GLintP)) +BGL_Wrap(GetVertexAttribPointerv, void, (GLuint, GLenum, GLvoidP)) +BGL_Wrap(GetVertexAttribdv, void, (GLuint, GLenum, GLdoubleP)) +BGL_Wrap(GetVertexAttribfv, void, (GLuint, GLenum, GLfloatP)) +BGL_Wrap(GetVertexAttribiv, void, (GLuint, GLenum, GLintP)) +BGL_Wrap(IsProgram, GLboolean, (GLuint)) +BGL_Wrap(IsShader, GLboolean, (GLuint)) +BGL_Wrap(LinkProgram, void, (GLuint)) +BGL_Wrap(StencilFuncSeparate, void, (GLenum, GLenum, GLint, GLuint)) +BGL_Wrap(StencilMaskSeparate, void, (GLenum, GLuint)) +BGL_Wrap(StencilOpSeparate, void, (GLenum, GLenum, GLenum, GLenum)) +BGL_Wrap(Uniform1f, void, (GLint, GLfloat)) +BGL_Wrap(Uniform1fv, void, (GLint, GLsizei, GLfloatP)) +BGL_Wrap(Uniform1i, void, (GLint, GLint)) +BGL_Wrap(Uniform1iv, void, (GLint, GLsizei, GLintP)) +BGL_Wrap(Uniform2f, void, (GLint, GLfloat, GLfloat)) +BGL_Wrap(Uniform2fv, void, (GLint, GLsizei, GLfloatP)) +BGL_Wrap(Uniform2i, void, (GLint, GLint, GLint)) +BGL_Wrap(Uniform2iv, void, (GLint, GLsizei, GLintP)) +BGL_Wrap(Uniform3f, void, (GLint, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Uniform3fv, void, (GLint, GLsizei, GLfloatP)) +BGL_Wrap(Uniform3i, void, (GLint, GLint, GLint, GLint)) +BGL_Wrap(Uniform3iv, void, (GLint, GLsizei, GLintP)) +BGL_Wrap(Uniform4f, void, (GLint, GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(Uniform4fv, void, (GLint, GLsizei, GLfloatP)) +BGL_Wrap(Uniform4i, void, (GLint, GLint, GLint, GLint, GLint)) +BGL_Wrap(Uniform4iv, void, (GLint, GLsizei, GLintP)) +BGL_Wrap(UniformMatrix2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UseProgram, void, (GLuint)) +BGL_Wrap(ValidateProgram, void, (GLuint)) +BGL_Wrap(VertexAttrib1d, void, (GLuint, GLdouble)) +BGL_Wrap(VertexAttrib1dv, void, (GLuint, GLdoubleP)) +BGL_Wrap(VertexAttrib1f, void, (GLuint, GLfloat)) +BGL_Wrap(VertexAttrib1fv, void, (GLuint, GLfloatP)) +BGL_Wrap(VertexAttrib1s, void, (GLuint, GLshort)) +BGL_Wrap(VertexAttrib1sv, void, (GLuint, GLshortP)) +BGL_Wrap(VertexAttrib2d, void, (GLuint, GLdouble, GLdouble)) +BGL_Wrap(VertexAttrib2dv, void, (GLuint, GLdoubleP)) +BGL_Wrap(VertexAttrib2f, void, (GLuint, GLfloat, GLfloat)) +BGL_Wrap(VertexAttrib2fv, void, (GLuint, GLfloatP)) +BGL_Wrap(VertexAttrib2s, void, (GLuint, GLshort, GLshort)) +BGL_Wrap(VertexAttrib2sv, void, (GLuint, GLshortP)) +BGL_Wrap(VertexAttrib3d, void, (GLuint, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(VertexAttrib3dv, void, (GLuint, GLdoubleP)) +BGL_Wrap(VertexAttrib3f, void, (GLuint, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(VertexAttrib3fv, void, (GLuint, GLfloatP)) +BGL_Wrap(VertexAttrib3s, void, (GLuint, GLshort, GLshort, GLshort)) +BGL_Wrap(VertexAttrib3sv, void, (GLuint, GLshortP)) +BGL_Wrap(VertexAttrib4Nbv, void, (GLuint, GLbyteP)) +BGL_Wrap(VertexAttrib4Niv, void, (GLuint, GLintP)) +BGL_Wrap(VertexAttrib4Nsv, void, (GLuint, GLshortP)) +BGL_Wrap(VertexAttrib4Nub, void, (GLuint, GLubyte, GLubyte, GLubyte, GLubyte)) +BGL_Wrap(VertexAttrib4Nubv, void, (GLuint, GLubyteP)) +BGL_Wrap(VertexAttrib4Nuiv, void, (GLuint, GLuintP)) +BGL_Wrap(VertexAttrib4Nusv, void, (GLuint, GLushortP)) +BGL_Wrap(VertexAttrib4bv, void, (GLuint, GLbyteP)) +BGL_Wrap(VertexAttrib4d, void, (GLuint, GLdouble, GLdouble, GLdouble, GLdouble)) +BGL_Wrap(VertexAttrib4dv, void, (GLuint, GLdoubleP)) +BGL_Wrap(VertexAttrib4f, void, (GLuint, GLfloat, GLfloat, GLfloat, GLfloat)) +BGL_Wrap(VertexAttrib4fv, void, (GLuint, GLfloatP)) +BGL_Wrap(VertexAttrib4iv, void, (GLuint, GLintP)) +BGL_Wrap(VertexAttrib4s, void, (GLuint, GLshort, GLshort, GLshort, GLshort)) +BGL_Wrap(VertexAttrib4sv, void, (GLuint, GLshortP)) +BGL_Wrap(VertexAttrib4ubv, void, (GLuint, GLubyteP)) +BGL_Wrap(VertexAttrib4uiv, void, (GLuint, GLuintP)) +BGL_Wrap(VertexAttrib4usv, void, (GLuint, GLushortP)) +BGL_Wrap(VertexAttribPointer, void, (GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoidP)) + + +/* GL_VERSION_2_1 */ +BGL_Wrap(UniformMatrix2x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix2x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix3x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix3x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix4x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) +BGL_Wrap(UniformMatrix4x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)) + + +/* GL_VERSION_3_0 */ +BGL_Wrap(BindVertexArray, void, (GLuint)) +BGL_Wrap(DeleteVertexArrays, void, (GLsizei, GLuintP)) +BGL_Wrap(GenVertexArrays, void, (GLsizei, GLuintP)) +BGL_Wrap(IsVertexArray, GLboolean, (GLuint)) + + +/* GL_VERSION_3_1 */ +BGL_Wrap(BindBufferBase, void, (GLenum, GLuint, GLuint)) +BGL_Wrap(BindBufferRange, void, (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr)) +BGL_Wrap(GetActiveUniformBlockName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP)) +BGL_Wrap(GetActiveUniformBlockiv, void, (GLuint, GLuint, GLenum, GLintP)) +BGL_Wrap(GetActiveUniformName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP)) +BGL_Wrap(GetActiveUniformsiv, void, (GLuint, GLsizei, GLuintP, GLenum, GLintP)) +BGL_Wrap(GetIntegeri_v, void, (GLenum, GLuint, GLintP)) +BGL_Wrap(GetUniformBlockIndex, GLuint, (GLuint, GLcharP)) +BGL_Wrap(GetUniformIndices, void, (GLuint, GLsizei, GLcharP, GLuintP)) +BGL_Wrap(UniformBlockBinding, void, (GLuint, GLuint, GLuint)) + + +/* GL_VERSION_3_2 */ +BGL_Wrap(FramebufferTexture, void, (GLenum, GLenum, GLuint, GLint)) +BGL_Wrap(GetBufferParameteri64v, void, (GLenum, GLenum, GLint64P)) +BGL_Wrap(GetInteger64i_v, void, (GLenum, GLuint, GLint64P)) +BGL_Wrap(GetMultisamplefv, void, (GLenum, GLuint, GLfloatP)) +BGL_Wrap(SampleMaski, void, (GLuint, GLbitfield)) +BGL_Wrap(TexImage2DMultisample, void, (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean)) +BGL_Wrap(TexImage3DMultisample, void, (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean)) + + +/* GL_VERSION_3_3 */ +BGL_Wrap(ColorP3ui, void, (GLenum, GLuint)) +BGL_Wrap(ColorP3uiv, void, (GLenum, GLuintP)) +BGL_Wrap(ColorP4ui, void, (GLenum, GLuint)) +BGL_Wrap(ColorP4uiv, void, (GLenum, GLuintP)) +BGL_Wrap(MultiTexCoordP1ui, void, (GLenum, GLenum, GLuint)) +BGL_Wrap(MultiTexCoordP1uiv, void, (GLenum, GLenum, GLuintP)) +BGL_Wrap(MultiTexCoordP2ui, void, (GLenum, GLenum, GLuint)) +BGL_Wrap(MultiTexCoordP2uiv, void, (GLenum, GLenum, GLuintP)) +BGL_Wrap(MultiTexCoordP3ui, void, (GLenum, GLenum, GLuint)) +BGL_Wrap(MultiTexCoordP3uiv, void, (GLenum, GLenum, GLuintP)) +BGL_Wrap(MultiTexCoordP4ui, void, (GLenum, GLenum, GLuint)) +BGL_Wrap(MultiTexCoordP4uiv, void, (GLenum, GLenum, GLuintP)) +BGL_Wrap(NormalP3ui, void, (GLenum, GLuint)) +BGL_Wrap(NormalP3uiv, void, (GLenum, GLuintP)) +BGL_Wrap(SecondaryColorP3ui, void, (GLenum, GLuint)) +BGL_Wrap(SecondaryColorP3uiv, void, (GLenum, GLuintP)) +BGL_Wrap(TexCoordP1ui, void, (GLenum, GLuint)) +BGL_Wrap(TexCoordP1uiv, void, (GLenum, GLuintP)) +BGL_Wrap(TexCoordP2ui, void, (GLenum, GLuint)) +BGL_Wrap(TexCoordP2uiv, void, (GLenum, GLuintP)) +BGL_Wrap(TexCoordP3ui, void, (GLenum, GLuint)) +BGL_Wrap(TexCoordP3uiv, void, (GLenum, GLuintP)) +BGL_Wrap(TexCoordP4ui, void, (GLenum, GLuint)) +BGL_Wrap(TexCoordP4uiv, void, (GLenum, GLuintP)) +BGL_Wrap(VertexP2ui, void, (GLenum, GLuint)) +BGL_Wrap(VertexP2uiv, void, (GLenum, GLuintP)) +BGL_Wrap(VertexP3ui, void, (GLenum, GLuint)) +BGL_Wrap(VertexP3uiv, void, (GLenum, GLuintP)) +BGL_Wrap(VertexP4ui, void, (GLenum, GLuint)) +BGL_Wrap(VertexP4uiv, void, (GLenum, GLuintP)) + + +BGLU_Wrap(Perspective, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGLU_Wrap(LookAt, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) +BGLU_Wrap(Ortho2D, void, (GLdouble, GLdouble, GLdouble, GLdouble)) +BGLU_Wrap(PickMatrix, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLintP)) +BGLU_Wrap(Project, GLint, (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP)) +BGLU_Wrap(UnProject, GLint, (GLdouble, GLdouble, GLdouble, GLdoubleP, GLdoubleP, GLintP, GLdoubleP, GLdoubleP, GLdoubleP)) + +/** \} */ + + +/* -------------------------------------------------------------------- */ + +/** \name Module Definition + * \{ */ + +#define MethodDefu(func) {"glu"#func, Method_##func, METH_VARARGS, NULL} -/* #ifndef __APPLE__ */ - MethodDef(Accum), - MethodDef(ActiveTexture), - MethodDef(AlphaFunc), - MethodDef(AreTexturesResident), - MethodDef(AttachShader), - MethodDef(Begin), - MethodDef(BindTexture), - MethodDef(Bitmap), - MethodDef(BlendFunc), - MethodDef(CallList), - MethodDef(CallLists), - MethodDef(Clear), - MethodDef(ClearAccum), - MethodDef(ClearColor), - MethodDef(ClearDepth), - MethodDef(ClearIndex), - MethodDef(ClearStencil), - MethodDef(ClipPlane), - MethodDef(Color3b), - MethodDef(Color3bv), - MethodDef(Color3d), - MethodDef(Color3dv), - MethodDef(Color3f), - MethodDef(Color3fv), - MethodDef(Color3i), - MethodDef(Color3iv), - MethodDef(Color3s), - MethodDef(Color3sv), - MethodDef(Color3ub), - MethodDef(Color3ubv), - MethodDef(Color3ui), - MethodDef(Color3uiv), - MethodDef(Color3us), - MethodDef(Color3usv), - MethodDef(Color4b), - MethodDef(Color4bv), - MethodDef(Color4d), - MethodDef(Color4dv), - MethodDef(Color4f), - MethodDef(Color4fv), - MethodDef(Color4i), - MethodDef(Color4iv), - MethodDef(Color4s), - MethodDef(Color4sv), - MethodDef(Color4ub), - MethodDef(Color4ubv), - MethodDef(Color4ui), - MethodDef(Color4uiv), - MethodDef(Color4us), - MethodDef(Color4usv), - MethodDef(ColorMask), - MethodDef(ColorMaterial), - MethodDef(CompileShader), - MethodDef(CopyPixels), - MethodDef(CopyTexImage2D), - MethodDef(CreateProgram), - MethodDef(CreateShader), - MethodDef(CullFace), - MethodDef(DeleteLists), - MethodDef(DeleteProgram), - MethodDef(DeleteShader), - MethodDef(DeleteTextures), - MethodDef(DepthFunc), - MethodDef(DepthMask), - MethodDef(DepthRange), - MethodDef(DetachShader), - MethodDef(Disable), - MethodDef(DrawBuffer), - MethodDef(DrawPixels), - MethodDef(EdgeFlag), - MethodDef(EdgeFlagv), - MethodDef(Enable), - MethodDef(End), - MethodDef(EndList), - MethodDef(EvalCoord1d), - MethodDef(EvalCoord1dv), - MethodDef(EvalCoord1f), - MethodDef(EvalCoord1fv), - MethodDef(EvalCoord2d), - MethodDef(EvalCoord2dv), - MethodDef(EvalCoord2f), - MethodDef(EvalCoord2fv), - MethodDef(EvalMesh1), - MethodDef(EvalMesh2), - MethodDef(EvalPoint1), - MethodDef(EvalPoint2), - MethodDef(FeedbackBuffer), - MethodDef(Finish), - MethodDef(Flush), - MethodDef(Fogf), - MethodDef(Fogfv), - MethodDef(Fogi), - MethodDef(Fogiv), - MethodDef(FrontFace), - MethodDef(Frustum), - MethodDef(GenLists), - MethodDef(GenTextures), - MethodDef(GetAttachedShaders), - MethodDef(GetBooleanv), - MethodDef(GetClipPlane), - MethodDef(GetDoublev), - MethodDef(GetError), - MethodDef(GetFloatv), - MethodDef(GetIntegerv), - MethodDef(GetLightfv), - MethodDef(GetLightiv), - MethodDef(GetMapdv), - MethodDef(GetMapfv), - MethodDef(GetMapiv), - MethodDef(GetMaterialfv), - MethodDef(GetMaterialiv), - MethodDef(GetPixelMapfv), - MethodDef(GetPixelMapuiv), - MethodDef(GetPixelMapusv), - MethodDef(GetPolygonStipple), - MethodDef(GetProgramInfoLog), - MethodDef(GetProgramiv), - MethodDef(GetShaderInfoLog), - MethodDef(GetShaderiv), - MethodDef(GetShaderSource), - MethodDef(GetString), - MethodDef(GetTexEnvfv), - MethodDef(GetTexEnviv), - MethodDef(GetTexGendv), - MethodDef(GetTexGenfv), - MethodDef(GetTexGeniv), - MethodDef(GetTexImage), - MethodDef(GetTexLevelParameterfv), - MethodDef(GetTexLevelParameteriv), - MethodDef(GetTexParameterfv), - MethodDef(GetTexParameteriv), - MethodDef(GetUniformLocation), - MethodDef(Hint), - MethodDef(IndexMask), - MethodDef(Indexd), - MethodDef(Indexdv), - MethodDef(Indexf), - MethodDef(Indexfv), - MethodDef(Indexi), - MethodDef(Indexiv), - MethodDef(Indexs), - MethodDef(Indexsv), - MethodDef(InitNames), - MethodDef(IsEnabled), - MethodDef(IsList), - MethodDef(IsProgram), - MethodDef(IsShader), - MethodDef(IsTexture), - MethodDef(LightModelf), - MethodDef(LightModelfv), - MethodDef(LightModeli), - MethodDef(LightModeliv), - MethodDef(Lightf), - MethodDef(Lightfv), - MethodDef(Lighti), - MethodDef(Lightiv), - MethodDef(LineStipple), - MethodDef(LineWidth), - MethodDef(LinkProgram), - MethodDef(ListBase), - MethodDef(LoadIdentity), - MethodDef(LoadMatrixd), - MethodDef(LoadMatrixf), - MethodDef(LoadName), - MethodDef(LogicOp), - MethodDef(Map1d), - MethodDef(Map1f), - MethodDef(Map2d), - MethodDef(Map2f), - MethodDef(MapGrid1d), - MethodDef(MapGrid1f), - MethodDef(MapGrid2d), - MethodDef(MapGrid2f), - MethodDef(Materialf), - MethodDef(Materialfv), - MethodDef(Materiali), - MethodDef(Materialiv), - MethodDef(MatrixMode), - MethodDef(MultMatrixd), - MethodDef(MultMatrixf), - MethodDef(NewList), - MethodDef(Normal3b), - MethodDef(Normal3bv), - MethodDef(Normal3d), - MethodDef(Normal3dv), - MethodDef(Normal3f), - MethodDef(Normal3fv), - MethodDef(Normal3i), - MethodDef(Normal3iv), - MethodDef(Normal3s), - MethodDef(Normal3sv), - MethodDef(Ortho), - MethodDef(PassThrough), - MethodDef(PixelMapfv), - MethodDef(PixelMapuiv), - MethodDef(PixelMapusv), - MethodDef(PixelStoref), - MethodDef(PixelStorei), - MethodDef(PixelTransferf), - MethodDef(PixelTransferi), - MethodDef(PixelZoom), - MethodDef(PointSize), - MethodDef(PolygonMode), - MethodDef(PolygonOffset), - MethodDef(PolygonStipple), - MethodDef(PopAttrib), - MethodDef(PopClientAttrib), - MethodDef(PopMatrix), - MethodDef(PopName), - MethodDef(PrioritizeTextures), - MethodDef(PushAttrib), - MethodDef(PushClientAttrib), - MethodDef(PushMatrix), - MethodDef(PushName), - MethodDef(RasterPos2d), - MethodDef(RasterPos2dv), - MethodDef(RasterPos2f), - MethodDef(RasterPos2fv), - MethodDef(RasterPos2i), - MethodDef(RasterPos2iv), - MethodDef(RasterPos2s), - MethodDef(RasterPos2sv), - MethodDef(RasterPos3d), - MethodDef(RasterPos3dv), - MethodDef(RasterPos3f), - MethodDef(RasterPos3fv), - MethodDef(RasterPos3i), - MethodDef(RasterPos3iv), - MethodDef(RasterPos3s), - MethodDef(RasterPos3sv), - MethodDef(RasterPos4d), - MethodDef(RasterPos4dv), - MethodDef(RasterPos4f), - MethodDef(RasterPos4fv), - MethodDef(RasterPos4i), - MethodDef(RasterPos4iv), - MethodDef(RasterPos4s), - MethodDef(RasterPos4sv), - MethodDef(ReadBuffer), - MethodDef(ReadPixels), - MethodDef(Rectd), - MethodDef(Rectdv), - MethodDef(Rectf), - MethodDef(Rectfv), - MethodDef(Recti), - MethodDef(Rectiv), - MethodDef(Rects), - MethodDef(Rectsv), - MethodDef(RenderMode), - MethodDef(Rotated), - MethodDef(Rotatef), - MethodDef(Scaled), - MethodDef(Scalef), - MethodDef(Scissor), - MethodDef(SelectBuffer), - MethodDef(ShadeModel), - MethodDef(ShaderSource), - MethodDef(StencilFunc), - MethodDef(StencilMask), - MethodDef(StencilOp), - MethodDef(TexCoord1d), - MethodDef(TexCoord1dv), - MethodDef(TexCoord1f), - MethodDef(TexCoord1fv), - MethodDef(TexCoord1i), - MethodDef(TexCoord1iv), - MethodDef(TexCoord1s), - MethodDef(TexCoord1sv), - MethodDef(TexCoord2d), - MethodDef(TexCoord2dv), - MethodDef(TexCoord2f), - MethodDef(TexCoord2fv), - MethodDef(TexCoord2i), - MethodDef(TexCoord2iv), - MethodDef(TexCoord2s), - MethodDef(TexCoord2sv), - MethodDef(TexCoord3d), - MethodDef(TexCoord3dv), - MethodDef(TexCoord3f), - MethodDef(TexCoord3fv), - MethodDef(TexCoord3i), - MethodDef(TexCoord3iv), - MethodDef(TexCoord3s), - MethodDef(TexCoord3sv), - MethodDef(TexCoord4d), - MethodDef(TexCoord4dv), - MethodDef(TexCoord4f), - MethodDef(TexCoord4fv), - MethodDef(TexCoord4i), - MethodDef(TexCoord4iv), - MethodDef(TexCoord4s), - MethodDef(TexCoord4sv), - MethodDef(TexEnvf), - MethodDef(TexEnvfv), - MethodDef(TexEnvi), - MethodDef(TexEnviv), - MethodDef(TexGend), - MethodDef(TexGendv), - MethodDef(TexGenf), - MethodDef(TexGenfv), - MethodDef(TexGeni), - MethodDef(TexGeniv), - MethodDef(TexImage1D), - MethodDef(TexImage2D), - MethodDef(TexParameterf), - MethodDef(TexParameterfv), - MethodDef(TexParameteri), - MethodDef(TexParameteriv), - MethodDef(Translated), - MethodDef(Translatef), - MethodDef(Uniform1f), - MethodDef(Uniform2f), - MethodDef(Uniform3f), - MethodDef(Uniform4f), - MethodDef(Uniform1fv), - MethodDef(Uniform2fv), - MethodDef(Uniform3fv), - MethodDef(Uniform4fv), - MethodDef(Uniform1i), - MethodDef(Uniform2i), - MethodDef(Uniform3i), - MethodDef(Uniform4i), - MethodDef(Uniform1iv), - MethodDef(Uniform2iv), - MethodDef(Uniform3iv), - MethodDef(Uniform4iv), - MethodDef(UniformMatrix2fv), - MethodDef(UniformMatrix3fv), - MethodDef(UniformMatrix4fv), - MethodDef(UniformMatrix2x3fv), - MethodDef(UniformMatrix3x2fv), - MethodDef(UniformMatrix2x4fv), - MethodDef(UniformMatrix4x2fv), - MethodDef(UniformMatrix3x4fv), - MethodDef(UniformMatrix4x3fv), - MethodDef(UseProgram), - MethodDef(ValidateProgram), - MethodDef(Vertex2d), - MethodDef(Vertex2dv), - MethodDef(Vertex2f), - MethodDef(Vertex2fv), - MethodDef(Vertex2i), - MethodDef(Vertex2iv), - MethodDef(Vertex2s), - MethodDef(Vertex2sv), - MethodDef(Vertex3d), - MethodDef(Vertex3dv), - MethodDef(Vertex3f), - MethodDef(Vertex3fv), - MethodDef(Vertex3i), - MethodDef(Vertex3iv), - MethodDef(Vertex3s), - MethodDef(Vertex3sv), - MethodDef(Vertex4d), - MethodDef(Vertex4dv), - MethodDef(Vertex4f), - MethodDef(Vertex4fv), - MethodDef(Vertex4i), - MethodDef(Vertex4iv), - MethodDef(Vertex4s), - MethodDef(Vertex4sv), - MethodDef(Viewport), +static struct PyMethodDef BGL_methods[] = { MethodDefu(Perspective), MethodDefu(LookAt), MethodDefu(Ortho2D), MethodDefu(PickMatrix), MethodDefu(Project), MethodDefu(UnProject), -/* #endif */ {NULL, NULL, 0, NULL} }; +#undef MethodDefu + static struct PyModuleDef BGL_module_def = { PyModuleDef_HEAD_INIT, "bgl", /* m_name */ @@ -1381,13 +1662,29 @@ static struct PyModuleDef BGL_module_def = { NULL, /* m_free */ }; -static void expp_addconst_int(PyObject *dict, const char *name, int value) +static void py_module_dict_add_int(PyObject *dict, const char *name, int value) { PyObject *item; PyDict_SetItemString(dict, name, item = PyLong_FromLong(value)); Py_DECREF(item); } +static void py_module_dict_add_method(PyObject *submodule, PyObject *dict, PyMethodDef *method_def, bool is_valid) +{ + if (is_valid) { + PyObject *m; + m = PyCFunction_NewEx(method_def, NULL, submodule); + PyDict_SetItemString(dict, method_def->ml_name, m); + Py_DECREF(m); + } + else { + PyDict_SetItemString(dict, method_def->ml_name, Py_None); + } +} + +/* TODO, expose to users */ +static bool use_deprecated = true; + PyObject *BPyInit_bgl(void) { PyObject *submodule, *dict; @@ -1400,517 +1697,1601 @@ PyObject *BPyInit_bgl(void) PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType); Py_INCREF((PyObject *)&BGL_bufferType); -#define EXPP_ADDCONST(x) expp_addconst_int(dict, #x, x) - - EXPP_ADDCONST(GL_CURRENT_BIT); - EXPP_ADDCONST(GL_POINT_BIT); - EXPP_ADDCONST(GL_LINE_BIT); - EXPP_ADDCONST(GL_POLYGON_BIT); - EXPP_ADDCONST(GL_POLYGON_STIPPLE_BIT); - EXPP_ADDCONST(GL_PIXEL_MODE_BIT); - EXPP_ADDCONST(GL_LIGHTING_BIT); - EXPP_ADDCONST(GL_FOG_BIT); - EXPP_ADDCONST(GL_DEPTH_BUFFER_BIT); - EXPP_ADDCONST(GL_ACCUM_BUFFER_BIT); - EXPP_ADDCONST(GL_STENCIL_BUFFER_BIT); - EXPP_ADDCONST(GL_VIEWPORT_BIT); - EXPP_ADDCONST(GL_TRANSFORM_BIT); - EXPP_ADDCONST(GL_ENABLE_BIT); - EXPP_ADDCONST(GL_COLOR_BUFFER_BIT); - EXPP_ADDCONST(GL_HINT_BIT); - EXPP_ADDCONST(GL_EVAL_BIT); - EXPP_ADDCONST(GL_LIST_BIT); - EXPP_ADDCONST(GL_TEXTURE_BIT); - EXPP_ADDCONST(GL_SCISSOR_BIT); - EXPP_ADDCONST(GL_ALL_ATTRIB_BITS); - EXPP_ADDCONST(GL_CLIENT_ALL_ATTRIB_BITS); - - EXPP_ADDCONST(GL_FALSE); - EXPP_ADDCONST(GL_TRUE); - - EXPP_ADDCONST(GL_POINTS); - EXPP_ADDCONST(GL_LINES); - EXPP_ADDCONST(GL_LINE_LOOP); - EXPP_ADDCONST(GL_LINE_STRIP); - EXPP_ADDCONST(GL_TRIANGLES); - EXPP_ADDCONST(GL_TRIANGLE_STRIP); - EXPP_ADDCONST(GL_TRIANGLE_FAN); - EXPP_ADDCONST(GL_QUADS); - EXPP_ADDCONST(GL_QUAD_STRIP); - EXPP_ADDCONST(GL_POLYGON); - - EXPP_ADDCONST(GL_ACCUM); - EXPP_ADDCONST(GL_LOAD); - EXPP_ADDCONST(GL_RETURN); - EXPP_ADDCONST(GL_MULT); - EXPP_ADDCONST(GL_ADD); - - EXPP_ADDCONST(GL_NEVER); - EXPP_ADDCONST(GL_LESS); - EXPP_ADDCONST(GL_EQUAL); - EXPP_ADDCONST(GL_LEQUAL); - EXPP_ADDCONST(GL_GREATER); - EXPP_ADDCONST(GL_NOTEQUAL); - EXPP_ADDCONST(GL_GEQUAL); - EXPP_ADDCONST(GL_ALWAYS); - - EXPP_ADDCONST(GL_ZERO); - EXPP_ADDCONST(GL_ONE); - EXPP_ADDCONST(GL_SRC_COLOR); - EXPP_ADDCONST(GL_ONE_MINUS_SRC_COLOR); - EXPP_ADDCONST(GL_SRC_ALPHA); - EXPP_ADDCONST(GL_ONE_MINUS_SRC_ALPHA); - EXPP_ADDCONST(GL_DST_ALPHA); - EXPP_ADDCONST(GL_ONE_MINUS_DST_ALPHA); - - EXPP_ADDCONST(GL_DST_COLOR); - EXPP_ADDCONST(GL_ONE_MINUS_DST_COLOR); - EXPP_ADDCONST(GL_SRC_ALPHA_SATURATE); - - EXPP_ADDCONST(GL_NONE); - EXPP_ADDCONST(GL_FRONT_LEFT); - EXPP_ADDCONST(GL_FRONT_RIGHT); - EXPP_ADDCONST(GL_BACK_LEFT); - EXPP_ADDCONST(GL_BACK_RIGHT); - EXPP_ADDCONST(GL_FRONT); - EXPP_ADDCONST(GL_BACK); - EXPP_ADDCONST(GL_LEFT); - EXPP_ADDCONST(GL_RIGHT); - EXPP_ADDCONST(GL_FRONT_AND_BACK); - EXPP_ADDCONST(GL_AUX0); - EXPP_ADDCONST(GL_AUX1); - EXPP_ADDCONST(GL_AUX2); - EXPP_ADDCONST(GL_AUX3); - - EXPP_ADDCONST(GL_NO_ERROR); - EXPP_ADDCONST(GL_INVALID_ENUM); - EXPP_ADDCONST(GL_INVALID_VALUE); - EXPP_ADDCONST(GL_INVALID_OPERATION); - EXPP_ADDCONST(GL_STACK_OVERFLOW); - EXPP_ADDCONST(GL_STACK_UNDERFLOW); - EXPP_ADDCONST(GL_OUT_OF_MEMORY); - - EXPP_ADDCONST(GL_2D); - EXPP_ADDCONST(GL_3D); - EXPP_ADDCONST(GL_3D_COLOR); - EXPP_ADDCONST(GL_3D_COLOR_TEXTURE); - EXPP_ADDCONST(GL_4D_COLOR_TEXTURE); - - EXPP_ADDCONST(GL_PASS_THROUGH_TOKEN); - EXPP_ADDCONST(GL_POINT_TOKEN); - EXPP_ADDCONST(GL_LINE_TOKEN); - EXPP_ADDCONST(GL_POLYGON_TOKEN); - EXPP_ADDCONST(GL_BITMAP_TOKEN); - EXPP_ADDCONST(GL_DRAW_PIXEL_TOKEN); - EXPP_ADDCONST(GL_COPY_PIXEL_TOKEN); - EXPP_ADDCONST(GL_LINE_RESET_TOKEN); - - EXPP_ADDCONST(GL_EXP); - EXPP_ADDCONST(GL_EXP2); - - EXPP_ADDCONST(GL_CW); - EXPP_ADDCONST(GL_CCW); - - EXPP_ADDCONST(GL_COEFF); - EXPP_ADDCONST(GL_ORDER); - EXPP_ADDCONST(GL_DOMAIN); - - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_I); - EXPP_ADDCONST(GL_PIXEL_MAP_S_TO_S); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_R); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_G); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_B); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_A); - EXPP_ADDCONST(GL_PIXEL_MAP_R_TO_R); - EXPP_ADDCONST(GL_PIXEL_MAP_G_TO_G); - EXPP_ADDCONST(GL_PIXEL_MAP_B_TO_B); - EXPP_ADDCONST(GL_PIXEL_MAP_A_TO_A); - - EXPP_ADDCONST(GL_CURRENT_COLOR); - EXPP_ADDCONST(GL_CURRENT_INDEX); - EXPP_ADDCONST(GL_CURRENT_NORMAL); - EXPP_ADDCONST(GL_CURRENT_TEXTURE_COORDS); - EXPP_ADDCONST(GL_CURRENT_RASTER_COLOR); - EXPP_ADDCONST(GL_CURRENT_RASTER_INDEX); - EXPP_ADDCONST(GL_CURRENT_RASTER_TEXTURE_COORDS); - EXPP_ADDCONST(GL_CURRENT_RASTER_POSITION); - EXPP_ADDCONST(GL_CURRENT_RASTER_POSITION_VALID); - EXPP_ADDCONST(GL_CURRENT_RASTER_DISTANCE); - EXPP_ADDCONST(GL_POINT_SMOOTH); - EXPP_ADDCONST(GL_POINT_SIZE); - EXPP_ADDCONST(GL_POINT_SIZE_RANGE); - EXPP_ADDCONST(GL_POINT_SIZE_GRANULARITY); - EXPP_ADDCONST(GL_LINE_SMOOTH); - EXPP_ADDCONST(GL_LINE_WIDTH); - EXPP_ADDCONST(GL_LINE_WIDTH_RANGE); - EXPP_ADDCONST(GL_LINE_WIDTH_GRANULARITY); - EXPP_ADDCONST(GL_LINE_STIPPLE); - EXPP_ADDCONST(GL_LINE_STIPPLE_PATTERN); - EXPP_ADDCONST(GL_LINE_STIPPLE_REPEAT); - EXPP_ADDCONST(GL_LIST_MODE); - EXPP_ADDCONST(GL_MAX_LIST_NESTING); - EXPP_ADDCONST(GL_LIST_BASE); - EXPP_ADDCONST(GL_LIST_INDEX); - EXPP_ADDCONST(GL_POLYGON_MODE); - EXPP_ADDCONST(GL_POLYGON_SMOOTH); - EXPP_ADDCONST(GL_POLYGON_STIPPLE); - EXPP_ADDCONST(GL_EDGE_FLAG); - EXPP_ADDCONST(GL_CULL_FACE); - EXPP_ADDCONST(GL_CULL_FACE_MODE); - EXPP_ADDCONST(GL_FRONT_FACE); - EXPP_ADDCONST(GL_LIGHTING); - EXPP_ADDCONST(GL_LIGHT_MODEL_LOCAL_VIEWER); - EXPP_ADDCONST(GL_LIGHT_MODEL_TWO_SIDE); - EXPP_ADDCONST(GL_LIGHT_MODEL_AMBIENT); - EXPP_ADDCONST(GL_SHADE_MODEL); - EXPP_ADDCONST(GL_COLOR_MATERIAL_FACE); - EXPP_ADDCONST(GL_COLOR_MATERIAL_PARAMETER); - EXPP_ADDCONST(GL_COLOR_MATERIAL); - EXPP_ADDCONST(GL_FOG); - EXPP_ADDCONST(GL_FOG_INDEX); - EXPP_ADDCONST(GL_FOG_DENSITY); - EXPP_ADDCONST(GL_FOG_START); - EXPP_ADDCONST(GL_FOG_END); - EXPP_ADDCONST(GL_FOG_MODE); - EXPP_ADDCONST(GL_FOG_COLOR); - EXPP_ADDCONST(GL_DEPTH_RANGE); - EXPP_ADDCONST(GL_DEPTH_TEST); - EXPP_ADDCONST(GL_DEPTH_WRITEMASK); - EXPP_ADDCONST(GL_DEPTH_CLEAR_VALUE); - EXPP_ADDCONST(GL_DEPTH_FUNC); - EXPP_ADDCONST(GL_ACCUM_CLEAR_VALUE); - EXPP_ADDCONST(GL_STENCIL_TEST); - EXPP_ADDCONST(GL_STENCIL_CLEAR_VALUE); - EXPP_ADDCONST(GL_STENCIL_FUNC); - EXPP_ADDCONST(GL_STENCIL_VALUE_MASK); - EXPP_ADDCONST(GL_STENCIL_FAIL); - EXPP_ADDCONST(GL_STENCIL_PASS_DEPTH_FAIL); - EXPP_ADDCONST(GL_STENCIL_PASS_DEPTH_PASS); - EXPP_ADDCONST(GL_STENCIL_REF); - EXPP_ADDCONST(GL_STENCIL_WRITEMASK); - EXPP_ADDCONST(GL_MATRIX_MODE); - EXPP_ADDCONST(GL_NORMALIZE); - EXPP_ADDCONST(GL_VIEWPORT); - EXPP_ADDCONST(GL_MODELVIEW_STACK_DEPTH); - EXPP_ADDCONST(GL_PROJECTION_STACK_DEPTH); - EXPP_ADDCONST(GL_TEXTURE_STACK_DEPTH); - EXPP_ADDCONST(GL_MODELVIEW_MATRIX); - EXPP_ADDCONST(GL_PROJECTION_MATRIX); - EXPP_ADDCONST(GL_TEXTURE_MATRIX); - EXPP_ADDCONST(GL_ATTRIB_STACK_DEPTH); - EXPP_ADDCONST(GL_ALPHA_TEST); - EXPP_ADDCONST(GL_ALPHA_TEST_FUNC); - EXPP_ADDCONST(GL_ALPHA_TEST_REF); - EXPP_ADDCONST(GL_DITHER); - EXPP_ADDCONST(GL_BLEND_DST); - EXPP_ADDCONST(GL_BLEND_SRC); - EXPP_ADDCONST(GL_BLEND); - EXPP_ADDCONST(GL_LOGIC_OP_MODE); - EXPP_ADDCONST(GL_LOGIC_OP); - EXPP_ADDCONST(GL_AUX_BUFFERS); - EXPP_ADDCONST(GL_DRAW_BUFFER); - EXPP_ADDCONST(GL_READ_BUFFER); - EXPP_ADDCONST(GL_SCISSOR_BOX); - EXPP_ADDCONST(GL_SCISSOR_TEST); - EXPP_ADDCONST(GL_INDEX_CLEAR_VALUE); - EXPP_ADDCONST(GL_INDEX_WRITEMASK); - EXPP_ADDCONST(GL_COLOR_CLEAR_VALUE); - EXPP_ADDCONST(GL_COLOR_WRITEMASK); - EXPP_ADDCONST(GL_INDEX_MODE); - EXPP_ADDCONST(GL_RGBA_MODE); - EXPP_ADDCONST(GL_DOUBLEBUFFER); - EXPP_ADDCONST(GL_STEREO); - EXPP_ADDCONST(GL_RENDER_MODE); - EXPP_ADDCONST(GL_PERSPECTIVE_CORRECTION_HINT); - EXPP_ADDCONST(GL_POINT_SMOOTH_HINT); - EXPP_ADDCONST(GL_LINE_SMOOTH_HINT); - EXPP_ADDCONST(GL_POLYGON_SMOOTH_HINT); - EXPP_ADDCONST(GL_FOG_HINT); - EXPP_ADDCONST(GL_TEXTURE_GEN_S); - EXPP_ADDCONST(GL_TEXTURE_GEN_T); - EXPP_ADDCONST(GL_TEXTURE_GEN_R); - EXPP_ADDCONST(GL_TEXTURE_GEN_Q); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_I_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_S_TO_S_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_R_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_G_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_B_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_I_TO_A_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_R_TO_R_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_G_TO_G_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_B_TO_B_SIZE); - EXPP_ADDCONST(GL_PIXEL_MAP_A_TO_A_SIZE); - EXPP_ADDCONST(GL_UNPACK_SWAP_BYTES); - EXPP_ADDCONST(GL_UNPACK_LSB_FIRST); - EXPP_ADDCONST(GL_UNPACK_ROW_LENGTH); - EXPP_ADDCONST(GL_UNPACK_SKIP_ROWS); - EXPP_ADDCONST(GL_UNPACK_SKIP_PIXELS); - EXPP_ADDCONST(GL_UNPACK_ALIGNMENT); - EXPP_ADDCONST(GL_PACK_SWAP_BYTES); - EXPP_ADDCONST(GL_PACK_LSB_FIRST); - EXPP_ADDCONST(GL_PACK_ROW_LENGTH); - EXPP_ADDCONST(GL_PACK_SKIP_ROWS); - EXPP_ADDCONST(GL_PACK_SKIP_PIXELS); - EXPP_ADDCONST(GL_PACK_ALIGNMENT); - EXPP_ADDCONST(GL_MAP_COLOR); - EXPP_ADDCONST(GL_MAP_STENCIL); - EXPP_ADDCONST(GL_INDEX_SHIFT); - EXPP_ADDCONST(GL_INDEX_OFFSET); - EXPP_ADDCONST(GL_RED_SCALE); - EXPP_ADDCONST(GL_RED_BIAS); - EXPP_ADDCONST(GL_ZOOM_X); - EXPP_ADDCONST(GL_ZOOM_Y); - EXPP_ADDCONST(GL_GREEN_SCALE); - EXPP_ADDCONST(GL_GREEN_BIAS); - EXPP_ADDCONST(GL_BLUE_SCALE); - EXPP_ADDCONST(GL_BLUE_BIAS); - EXPP_ADDCONST(GL_ALPHA_SCALE); - EXPP_ADDCONST(GL_ALPHA_BIAS); - EXPP_ADDCONST(GL_DEPTH_SCALE); - EXPP_ADDCONST(GL_DEPTH_BIAS); - EXPP_ADDCONST(GL_MAX_EVAL_ORDER); - EXPP_ADDCONST(GL_MAX_LIGHTS); - EXPP_ADDCONST(GL_MAX_CLIP_PLANES); - EXPP_ADDCONST(GL_MAX_TEXTURE_SIZE); - EXPP_ADDCONST(GL_MAX_PIXEL_MAP_TABLE); - EXPP_ADDCONST(GL_MAX_ATTRIB_STACK_DEPTH); - EXPP_ADDCONST(GL_MAX_MODELVIEW_STACK_DEPTH); - EXPP_ADDCONST(GL_MAX_NAME_STACK_DEPTH); - EXPP_ADDCONST(GL_MAX_PROJECTION_STACK_DEPTH); - EXPP_ADDCONST(GL_MAX_TEXTURE_STACK_DEPTH); - EXPP_ADDCONST(GL_MAX_VIEWPORT_DIMS); - EXPP_ADDCONST(GL_SUBPIXEL_BITS); - EXPP_ADDCONST(GL_INDEX_BITS); - EXPP_ADDCONST(GL_RED_BITS); - EXPP_ADDCONST(GL_GREEN_BITS); - EXPP_ADDCONST(GL_BLUE_BITS); - EXPP_ADDCONST(GL_ALPHA_BITS); - EXPP_ADDCONST(GL_DEPTH_BITS); - EXPP_ADDCONST(GL_STENCIL_BITS); - EXPP_ADDCONST(GL_ACCUM_RED_BITS); - EXPP_ADDCONST(GL_ACCUM_GREEN_BITS); - EXPP_ADDCONST(GL_ACCUM_BLUE_BITS); - EXPP_ADDCONST(GL_ACCUM_ALPHA_BITS); - EXPP_ADDCONST(GL_NAME_STACK_DEPTH); - EXPP_ADDCONST(GL_AUTO_NORMAL); - EXPP_ADDCONST(GL_MAP1_COLOR_4); - EXPP_ADDCONST(GL_MAP1_INDEX); - EXPP_ADDCONST(GL_MAP1_NORMAL); - EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_1); - EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_2); - EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_3); - EXPP_ADDCONST(GL_MAP1_TEXTURE_COORD_4); - EXPP_ADDCONST(GL_MAP1_VERTEX_3); - EXPP_ADDCONST(GL_MAP1_VERTEX_4); - EXPP_ADDCONST(GL_MAP2_COLOR_4); - EXPP_ADDCONST(GL_MAP2_INDEX); - EXPP_ADDCONST(GL_MAP2_NORMAL); - EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_1); - EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_2); - EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_3); - EXPP_ADDCONST(GL_MAP2_TEXTURE_COORD_4); - EXPP_ADDCONST(GL_MAP2_VERTEX_3); - EXPP_ADDCONST(GL_MAP2_VERTEX_4); - EXPP_ADDCONST(GL_MAP1_GRID_DOMAIN); - EXPP_ADDCONST(GL_MAP1_GRID_SEGMENTS); - EXPP_ADDCONST(GL_MAP2_GRID_DOMAIN); - EXPP_ADDCONST(GL_MAP2_GRID_SEGMENTS); - EXPP_ADDCONST(GL_TEXTURE_1D); - EXPP_ADDCONST(GL_TEXTURE_2D); - - EXPP_ADDCONST(GL_TEXTURE_WIDTH); - EXPP_ADDCONST(GL_TEXTURE_HEIGHT); - EXPP_ADDCONST(GL_TEXTURE_COMPONENTS); - EXPP_ADDCONST(GL_TEXTURE_BORDER_COLOR); - EXPP_ADDCONST(GL_TEXTURE_BORDER); - - EXPP_ADDCONST(GL_DONT_CARE); - EXPP_ADDCONST(GL_FASTEST); - EXPP_ADDCONST(GL_NICEST); - - EXPP_ADDCONST(GL_AMBIENT); - EXPP_ADDCONST(GL_DIFFUSE); - EXPP_ADDCONST(GL_SPECULAR); - EXPP_ADDCONST(GL_POSITION); - EXPP_ADDCONST(GL_SPOT_DIRECTION); - EXPP_ADDCONST(GL_SPOT_EXPONENT); - EXPP_ADDCONST(GL_SPOT_CUTOFF); - EXPP_ADDCONST(GL_CONSTANT_ATTENUATION); - EXPP_ADDCONST(GL_LINEAR_ATTENUATION); - EXPP_ADDCONST(GL_QUADRATIC_ATTENUATION); - - EXPP_ADDCONST(GL_COMPILE); - EXPP_ADDCONST(GL_COMPILE_AND_EXECUTE); - - EXPP_ADDCONST(GL_BYTE); - EXPP_ADDCONST(GL_UNSIGNED_BYTE); - EXPP_ADDCONST(GL_SHORT); - EXPP_ADDCONST(GL_UNSIGNED_SHORT); - EXPP_ADDCONST(GL_INT); - EXPP_ADDCONST(GL_UNSIGNED_INT); - EXPP_ADDCONST(GL_FLOAT); - EXPP_ADDCONST(GL_DOUBLE); - EXPP_ADDCONST(GL_2_BYTES); - EXPP_ADDCONST(GL_3_BYTES); - EXPP_ADDCONST(GL_4_BYTES); - - EXPP_ADDCONST(GL_CLEAR); - EXPP_ADDCONST(GL_AND); - EXPP_ADDCONST(GL_AND_REVERSE); - EXPP_ADDCONST(GL_COPY); - EXPP_ADDCONST(GL_AND_INVERTED); - EXPP_ADDCONST(GL_NOOP); - EXPP_ADDCONST(GL_XOR); - EXPP_ADDCONST(GL_OR); - EXPP_ADDCONST(GL_NOR); - EXPP_ADDCONST(GL_EQUIV); - EXPP_ADDCONST(GL_INVERT); - EXPP_ADDCONST(GL_OR_REVERSE); - EXPP_ADDCONST(GL_COPY_INVERTED); - EXPP_ADDCONST(GL_OR_INVERTED); - EXPP_ADDCONST(GL_NAND); - EXPP_ADDCONST(GL_SET); - - EXPP_ADDCONST(GL_EMISSION); - EXPP_ADDCONST(GL_SHININESS); - EXPP_ADDCONST(GL_AMBIENT_AND_DIFFUSE); - EXPP_ADDCONST(GL_COLOR_INDEXES); - - EXPP_ADDCONST(GL_MODELVIEW); - EXPP_ADDCONST(GL_PROJECTION); - EXPP_ADDCONST(GL_TEXTURE); - - EXPP_ADDCONST(GL_COLOR); - EXPP_ADDCONST(GL_DEPTH); - EXPP_ADDCONST(GL_STENCIL); - - EXPP_ADDCONST(GL_COLOR_INDEX); - EXPP_ADDCONST(GL_STENCIL_INDEX); - EXPP_ADDCONST(GL_DEPTH_COMPONENT); - EXPP_ADDCONST(GL_RED); - EXPP_ADDCONST(GL_GREEN); - EXPP_ADDCONST(GL_BLUE); - EXPP_ADDCONST(GL_ALPHA); - EXPP_ADDCONST(GL_RGB); - EXPP_ADDCONST(GL_RGBA); - EXPP_ADDCONST(GL_LUMINANCE); - EXPP_ADDCONST(GL_LUMINANCE_ALPHA); - - EXPP_ADDCONST(GL_BITMAP); - - EXPP_ADDCONST(GL_POINT); - EXPP_ADDCONST(GL_LINE); - EXPP_ADDCONST(GL_FILL); - - EXPP_ADDCONST(GL_RENDER); - EXPP_ADDCONST(GL_FEEDBACK); - EXPP_ADDCONST(GL_SELECT); - - EXPP_ADDCONST(GL_FLAT); - EXPP_ADDCONST(GL_SMOOTH); - - EXPP_ADDCONST(GL_KEEP); - EXPP_ADDCONST(GL_REPLACE); - EXPP_ADDCONST(GL_INCR); - EXPP_ADDCONST(GL_DECR); - - EXPP_ADDCONST(GL_VENDOR); - EXPP_ADDCONST(GL_RENDERER); - EXPP_ADDCONST(GL_VERSION); - EXPP_ADDCONST(GL_EXTENSIONS); - - EXPP_ADDCONST(GL_S); - EXPP_ADDCONST(GL_T); - EXPP_ADDCONST(GL_R); - EXPP_ADDCONST(GL_Q); - - EXPP_ADDCONST(GL_MODULATE); - EXPP_ADDCONST(GL_DECAL); - - EXPP_ADDCONST(GL_TEXTURE_ENV_MODE); - EXPP_ADDCONST(GL_TEXTURE_ENV_COLOR); - - EXPP_ADDCONST(GL_TEXTURE_ENV); - - EXPP_ADDCONST(GL_EYE_LINEAR); - EXPP_ADDCONST(GL_OBJECT_LINEAR); - EXPP_ADDCONST(GL_SPHERE_MAP); - - EXPP_ADDCONST(GL_TEXTURE_GEN_MODE); - EXPP_ADDCONST(GL_OBJECT_PLANE); - EXPP_ADDCONST(GL_EYE_PLANE); - - EXPP_ADDCONST(GL_NEAREST); - EXPP_ADDCONST(GL_LINEAR); - - EXPP_ADDCONST(GL_NEAREST_MIPMAP_NEAREST); - EXPP_ADDCONST(GL_LINEAR_MIPMAP_NEAREST); - EXPP_ADDCONST(GL_NEAREST_MIPMAP_LINEAR); - EXPP_ADDCONST(GL_LINEAR_MIPMAP_LINEAR); - - EXPP_ADDCONST(GL_TEXTURE_MAG_FILTER); - EXPP_ADDCONST(GL_TEXTURE_MIN_FILTER); - EXPP_ADDCONST(GL_TEXTURE_WRAP_S); - EXPP_ADDCONST(GL_TEXTURE_WRAP_T); - - EXPP_ADDCONST(GL_CLAMP); - EXPP_ADDCONST(GL_REPEAT); - - EXPP_ADDCONST(GL_CLIP_PLANE0); - EXPP_ADDCONST(GL_CLIP_PLANE1); - EXPP_ADDCONST(GL_CLIP_PLANE2); - EXPP_ADDCONST(GL_CLIP_PLANE3); - EXPP_ADDCONST(GL_CLIP_PLANE4); - EXPP_ADDCONST(GL_CLIP_PLANE5); - - EXPP_ADDCONST(GL_LIGHT0); - EXPP_ADDCONST(GL_LIGHT1); - EXPP_ADDCONST(GL_LIGHT2); - EXPP_ADDCONST(GL_LIGHT3); - EXPP_ADDCONST(GL_LIGHT4); - EXPP_ADDCONST(GL_LIGHT5); - EXPP_ADDCONST(GL_LIGHT6); - EXPP_ADDCONST(GL_LIGHT7); - - EXPP_ADDCONST(GL_POLYGON_OFFSET_UNITS); - EXPP_ADDCONST(GL_POLYGON_OFFSET_POINT); - EXPP_ADDCONST(GL_POLYGON_OFFSET_LINE); - EXPP_ADDCONST(GL_POLYGON_OFFSET_FILL); - EXPP_ADDCONST(GL_POLYGON_OFFSET_FACTOR); - - EXPP_ADDCONST(GL_TEXTURE_PRIORITY); - EXPP_ADDCONST(GL_TEXTURE_RESIDENT); - EXPP_ADDCONST(GL_TEXTURE_BINDING_1D); - EXPP_ADDCONST(GL_TEXTURE_BINDING_2D); - - EXPP_ADDCONST(GL_VERTEX_SHADER); - EXPP_ADDCONST(GL_FRAGMENT_SHADER); - EXPP_ADDCONST(GL_COMPILE_STATUS); - EXPP_ADDCONST(GL_ACTIVE_TEXTURE); - - EXPP_ADDCONST(GL_TEXTURE0); - EXPP_ADDCONST(GL_TEXTURE1); - EXPP_ADDCONST(GL_TEXTURE2); - EXPP_ADDCONST(GL_TEXTURE3); - EXPP_ADDCONST(GL_TEXTURE4); - EXPP_ADDCONST(GL_TEXTURE5); - EXPP_ADDCONST(GL_TEXTURE6); - EXPP_ADDCONST(GL_TEXTURE7); - EXPP_ADDCONST(GL_TEXTURE8); - - EXPP_ADDCONST(GL_MAX_TEXTURE_UNITS); - - EXPP_ADDCONST(GL_DEPTH_COMPONENT32); - EXPP_ADDCONST(GL_TEXTURE_COMPARE_MODE); - - EXPP_ADDCONST(GL_MAX_VARYING_FLOATS); - EXPP_ADDCONST(GL_MAX_VERTEX_ATTRIBS); - EXPP_ADDCONST(GL_MAX_VARYING_FLOATS); - EXPP_ADDCONST(GL_MAX_VERTEX_UNIFORM_COMPONENTS); - EXPP_ADDCONST(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS); - EXPP_ADDCONST(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); - EXPP_ADDCONST(GL_MAX_TEXTURE_IMAGE_UNITS); - EXPP_ADDCONST(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); +/* needed since some function pointers won't be NULL */ +#pragma GCC diagnostic ignored "-Waddress" + +#define PY_MOD_ADD_METHOD(func) \ + { \ + static PyMethodDef method_def = {"gl"#func, Method_##func, METH_VARARGS}; \ + py_module_dict_add_method(submodule, dict, &method_def, (gl##func != NULL)); \ + } ((void)0) + + /* GL_VERSION_1_0 */ + { + PY_MOD_ADD_METHOD(BlendFunc); + PY_MOD_ADD_METHOD(Clear); + PY_MOD_ADD_METHOD(ClearColor); + PY_MOD_ADD_METHOD(ClearDepth); + PY_MOD_ADD_METHOD(ClearStencil); + PY_MOD_ADD_METHOD(ColorMask); + PY_MOD_ADD_METHOD(CullFace); + PY_MOD_ADD_METHOD(DepthFunc); + PY_MOD_ADD_METHOD(DepthMask); + PY_MOD_ADD_METHOD(DepthRange); + PY_MOD_ADD_METHOD(Disable); + PY_MOD_ADD_METHOD(DrawBuffer); + PY_MOD_ADD_METHOD(Enable); + PY_MOD_ADD_METHOD(Finish); + PY_MOD_ADD_METHOD(Flush); + PY_MOD_ADD_METHOD(FrontFace); + PY_MOD_ADD_METHOD(GetBooleanv); + PY_MOD_ADD_METHOD(GetDoublev); + PY_MOD_ADD_METHOD(GetError); + PY_MOD_ADD_METHOD(GetFloatv); + PY_MOD_ADD_METHOD(GetIntegerv); + PY_MOD_ADD_METHOD(GetString); + PY_MOD_ADD_METHOD(GetTexImage); + PY_MOD_ADD_METHOD(GetTexLevelParameterfv); + PY_MOD_ADD_METHOD(GetTexLevelParameteriv); + PY_MOD_ADD_METHOD(GetTexParameterfv); + PY_MOD_ADD_METHOD(GetTexParameteriv); + PY_MOD_ADD_METHOD(Hint); + PY_MOD_ADD_METHOD(IsEnabled); + PY_MOD_ADD_METHOD(LineWidth); + PY_MOD_ADD_METHOD(LogicOp); + PY_MOD_ADD_METHOD(PixelStoref); + PY_MOD_ADD_METHOD(PixelStorei); + PY_MOD_ADD_METHOD(PointSize); + PY_MOD_ADD_METHOD(PolygonMode); + PY_MOD_ADD_METHOD(ReadBuffer); + PY_MOD_ADD_METHOD(ReadPixels); + PY_MOD_ADD_METHOD(Scissor); + PY_MOD_ADD_METHOD(StencilFunc); + PY_MOD_ADD_METHOD(StencilMask); + PY_MOD_ADD_METHOD(StencilOp); + PY_MOD_ADD_METHOD(TexImage1D); + PY_MOD_ADD_METHOD(TexImage2D); + PY_MOD_ADD_METHOD(TexParameterf); + PY_MOD_ADD_METHOD(TexParameterfv); + PY_MOD_ADD_METHOD(TexParameteri); + PY_MOD_ADD_METHOD(TexParameteriv); + PY_MOD_ADD_METHOD(Viewport); + } + /* adding in GL_VERSION_1_0 removed from core profile */ + if (use_deprecated == true) { + PY_MOD_ADD_METHOD(Accum); + PY_MOD_ADD_METHOD(AlphaFunc); + PY_MOD_ADD_METHOD(Begin); + PY_MOD_ADD_METHOD(Bitmap); + PY_MOD_ADD_METHOD(CallList); + PY_MOD_ADD_METHOD(CallLists); + PY_MOD_ADD_METHOD(ClearAccum); + PY_MOD_ADD_METHOD(ClearIndex); + PY_MOD_ADD_METHOD(ClipPlane); + PY_MOD_ADD_METHOD(Color3b); + PY_MOD_ADD_METHOD(Color3bv); + PY_MOD_ADD_METHOD(Color3d); + PY_MOD_ADD_METHOD(Color3dv); + PY_MOD_ADD_METHOD(Color3f); + PY_MOD_ADD_METHOD(Color3fv); + PY_MOD_ADD_METHOD(Color3i); + PY_MOD_ADD_METHOD(Color3iv); + PY_MOD_ADD_METHOD(Color3s); + PY_MOD_ADD_METHOD(Color3sv); + PY_MOD_ADD_METHOD(Color3ub); + PY_MOD_ADD_METHOD(Color3ubv); + PY_MOD_ADD_METHOD(Color3ui); + PY_MOD_ADD_METHOD(Color3uiv); + PY_MOD_ADD_METHOD(Color3us); + PY_MOD_ADD_METHOD(Color3usv); + PY_MOD_ADD_METHOD(Color4b); + PY_MOD_ADD_METHOD(Color4bv); + PY_MOD_ADD_METHOD(Color4d); + PY_MOD_ADD_METHOD(Color4dv); + PY_MOD_ADD_METHOD(Color4f); + PY_MOD_ADD_METHOD(Color4fv); + PY_MOD_ADD_METHOD(Color4i); + PY_MOD_ADD_METHOD(Color4iv); + PY_MOD_ADD_METHOD(Color4s); + PY_MOD_ADD_METHOD(Color4sv); + PY_MOD_ADD_METHOD(Color4ub); + PY_MOD_ADD_METHOD(Color4ubv); + PY_MOD_ADD_METHOD(Color4ui); + PY_MOD_ADD_METHOD(Color4uiv); + PY_MOD_ADD_METHOD(Color4us); + PY_MOD_ADD_METHOD(Color4usv); + PY_MOD_ADD_METHOD(ColorMaterial); + PY_MOD_ADD_METHOD(CopyPixels); + PY_MOD_ADD_METHOD(DeleteLists); + PY_MOD_ADD_METHOD(DrawPixels); + PY_MOD_ADD_METHOD(EdgeFlag); + PY_MOD_ADD_METHOD(EdgeFlagv); + PY_MOD_ADD_METHOD(End); + PY_MOD_ADD_METHOD(EndList); + PY_MOD_ADD_METHOD(EvalCoord1d); + PY_MOD_ADD_METHOD(EvalCoord1dv); + PY_MOD_ADD_METHOD(EvalCoord1f); + PY_MOD_ADD_METHOD(EvalCoord1fv); + PY_MOD_ADD_METHOD(EvalCoord2d); + PY_MOD_ADD_METHOD(EvalCoord2dv); + PY_MOD_ADD_METHOD(EvalCoord2f); + PY_MOD_ADD_METHOD(EvalCoord2fv); + PY_MOD_ADD_METHOD(EvalMesh1); + PY_MOD_ADD_METHOD(EvalMesh2); + PY_MOD_ADD_METHOD(EvalPoint1); + PY_MOD_ADD_METHOD(EvalPoint2); + PY_MOD_ADD_METHOD(FeedbackBuffer); + PY_MOD_ADD_METHOD(Fogf); + PY_MOD_ADD_METHOD(Fogfv); + PY_MOD_ADD_METHOD(Fogi); + PY_MOD_ADD_METHOD(Fogiv); + PY_MOD_ADD_METHOD(Frustum); + PY_MOD_ADD_METHOD(GenLists); + PY_MOD_ADD_METHOD(GetClipPlane); + PY_MOD_ADD_METHOD(GetLightfv); + PY_MOD_ADD_METHOD(GetLightiv); + PY_MOD_ADD_METHOD(GetMapdv); + PY_MOD_ADD_METHOD(GetMapfv); + PY_MOD_ADD_METHOD(GetMapiv); + PY_MOD_ADD_METHOD(GetMaterialfv); + PY_MOD_ADD_METHOD(GetMaterialiv); + PY_MOD_ADD_METHOD(GetPixelMapfv); + PY_MOD_ADD_METHOD(GetPixelMapuiv); + PY_MOD_ADD_METHOD(GetPixelMapusv); + PY_MOD_ADD_METHOD(GetPolygonStipple); + PY_MOD_ADD_METHOD(GetTexEnvfv); + PY_MOD_ADD_METHOD(GetTexEnviv); + PY_MOD_ADD_METHOD(GetTexGendv); + PY_MOD_ADD_METHOD(GetTexGenfv); + PY_MOD_ADD_METHOD(GetTexGeniv); + PY_MOD_ADD_METHOD(IndexMask); + PY_MOD_ADD_METHOD(Indexd); + PY_MOD_ADD_METHOD(Indexdv); + PY_MOD_ADD_METHOD(Indexf); + PY_MOD_ADD_METHOD(Indexfv); + PY_MOD_ADD_METHOD(Indexi); + PY_MOD_ADD_METHOD(Indexiv); + PY_MOD_ADD_METHOD(Indexs); + PY_MOD_ADD_METHOD(Indexsv); + PY_MOD_ADD_METHOD(InitNames); + PY_MOD_ADD_METHOD(IsList); + PY_MOD_ADD_METHOD(LightModelf); + PY_MOD_ADD_METHOD(LightModelfv); + PY_MOD_ADD_METHOD(LightModeli); + PY_MOD_ADD_METHOD(LightModeliv); + PY_MOD_ADD_METHOD(Lightf); + PY_MOD_ADD_METHOD(Lightfv); + PY_MOD_ADD_METHOD(Lighti); + PY_MOD_ADD_METHOD(Lightiv); + PY_MOD_ADD_METHOD(LineStipple); + PY_MOD_ADD_METHOD(ListBase); + PY_MOD_ADD_METHOD(LoadIdentity); + PY_MOD_ADD_METHOD(LoadMatrixd); + PY_MOD_ADD_METHOD(LoadMatrixf); + PY_MOD_ADD_METHOD(LoadName); + PY_MOD_ADD_METHOD(Map1d); + PY_MOD_ADD_METHOD(Map1f); + PY_MOD_ADD_METHOD(Map2d); + PY_MOD_ADD_METHOD(Map2f); + PY_MOD_ADD_METHOD(MapGrid1d); + PY_MOD_ADD_METHOD(MapGrid1f); + PY_MOD_ADD_METHOD(MapGrid2d); + PY_MOD_ADD_METHOD(MapGrid2f); + PY_MOD_ADD_METHOD(Materialf); + PY_MOD_ADD_METHOD(Materialfv); + PY_MOD_ADD_METHOD(Materiali); + PY_MOD_ADD_METHOD(Materialiv); + PY_MOD_ADD_METHOD(MatrixMode); + PY_MOD_ADD_METHOD(MultMatrixd); + PY_MOD_ADD_METHOD(MultMatrixf); + PY_MOD_ADD_METHOD(NewList); + PY_MOD_ADD_METHOD(Normal3b); + PY_MOD_ADD_METHOD(Normal3bv); + PY_MOD_ADD_METHOD(Normal3d); + PY_MOD_ADD_METHOD(Normal3dv); + PY_MOD_ADD_METHOD(Normal3f); + PY_MOD_ADD_METHOD(Normal3fv); + PY_MOD_ADD_METHOD(Normal3i); + PY_MOD_ADD_METHOD(Normal3iv); + PY_MOD_ADD_METHOD(Normal3s); + PY_MOD_ADD_METHOD(Normal3sv); + PY_MOD_ADD_METHOD(Ortho); + PY_MOD_ADD_METHOD(PassThrough); + PY_MOD_ADD_METHOD(PixelMapfv); + PY_MOD_ADD_METHOD(PixelMapuiv); + PY_MOD_ADD_METHOD(PixelMapusv); + PY_MOD_ADD_METHOD(PixelTransferf); + PY_MOD_ADD_METHOD(PixelTransferi); + PY_MOD_ADD_METHOD(PixelZoom); + PY_MOD_ADD_METHOD(PolygonStipple); + PY_MOD_ADD_METHOD(PopAttrib); + PY_MOD_ADD_METHOD(PopMatrix); + PY_MOD_ADD_METHOD(PopName); + PY_MOD_ADD_METHOD(PushAttrib); + PY_MOD_ADD_METHOD(PushMatrix); + PY_MOD_ADD_METHOD(PushName); + PY_MOD_ADD_METHOD(RasterPos2d); + PY_MOD_ADD_METHOD(RasterPos2dv); + PY_MOD_ADD_METHOD(RasterPos2f); + PY_MOD_ADD_METHOD(RasterPos2fv); + PY_MOD_ADD_METHOD(RasterPos2i); + PY_MOD_ADD_METHOD(RasterPos2iv); + PY_MOD_ADD_METHOD(RasterPos2s); + PY_MOD_ADD_METHOD(RasterPos2sv); + PY_MOD_ADD_METHOD(RasterPos3d); + PY_MOD_ADD_METHOD(RasterPos3dv); + PY_MOD_ADD_METHOD(RasterPos3f); + PY_MOD_ADD_METHOD(RasterPos3fv); + PY_MOD_ADD_METHOD(RasterPos3i); + PY_MOD_ADD_METHOD(RasterPos3iv); + PY_MOD_ADD_METHOD(RasterPos3s); + PY_MOD_ADD_METHOD(RasterPos3sv); + PY_MOD_ADD_METHOD(RasterPos4d); + PY_MOD_ADD_METHOD(RasterPos4dv); + PY_MOD_ADD_METHOD(RasterPos4f); + PY_MOD_ADD_METHOD(RasterPos4fv); + PY_MOD_ADD_METHOD(RasterPos4i); + PY_MOD_ADD_METHOD(RasterPos4iv); + PY_MOD_ADD_METHOD(RasterPos4s); + PY_MOD_ADD_METHOD(RasterPos4sv); + PY_MOD_ADD_METHOD(Rectd); + PY_MOD_ADD_METHOD(Rectdv); + PY_MOD_ADD_METHOD(Rectf); + PY_MOD_ADD_METHOD(Rectfv); + PY_MOD_ADD_METHOD(Recti); + PY_MOD_ADD_METHOD(Rectiv); + PY_MOD_ADD_METHOD(Rects); + PY_MOD_ADD_METHOD(Rectsv); + PY_MOD_ADD_METHOD(RenderMode); + PY_MOD_ADD_METHOD(Rotated); + PY_MOD_ADD_METHOD(Rotatef); + PY_MOD_ADD_METHOD(Scaled); + PY_MOD_ADD_METHOD(Scalef); + PY_MOD_ADD_METHOD(SelectBuffer); + PY_MOD_ADD_METHOD(ShadeModel); + PY_MOD_ADD_METHOD(TexCoord1d); + PY_MOD_ADD_METHOD(TexCoord1dv); + PY_MOD_ADD_METHOD(TexCoord1f); + PY_MOD_ADD_METHOD(TexCoord1fv); + PY_MOD_ADD_METHOD(TexCoord1i); + PY_MOD_ADD_METHOD(TexCoord1iv); + PY_MOD_ADD_METHOD(TexCoord1s); + PY_MOD_ADD_METHOD(TexCoord1sv); + PY_MOD_ADD_METHOD(TexCoord2d); + PY_MOD_ADD_METHOD(TexCoord2dv); + PY_MOD_ADD_METHOD(TexCoord2f); + PY_MOD_ADD_METHOD(TexCoord2fv); + PY_MOD_ADD_METHOD(TexCoord2i); + PY_MOD_ADD_METHOD(TexCoord2iv); + PY_MOD_ADD_METHOD(TexCoord2s); + PY_MOD_ADD_METHOD(TexCoord2sv); + PY_MOD_ADD_METHOD(TexCoord3d); + PY_MOD_ADD_METHOD(TexCoord3dv); + PY_MOD_ADD_METHOD(TexCoord3f); + PY_MOD_ADD_METHOD(TexCoord3fv); + PY_MOD_ADD_METHOD(TexCoord3i); + PY_MOD_ADD_METHOD(TexCoord3iv); + PY_MOD_ADD_METHOD(TexCoord3s); + PY_MOD_ADD_METHOD(TexCoord3sv); + PY_MOD_ADD_METHOD(TexCoord4d); + PY_MOD_ADD_METHOD(TexCoord4dv); + PY_MOD_ADD_METHOD(TexCoord4f); + PY_MOD_ADD_METHOD(TexCoord4fv); + PY_MOD_ADD_METHOD(TexCoord4i); + PY_MOD_ADD_METHOD(TexCoord4iv); + PY_MOD_ADD_METHOD(TexCoord4s); + PY_MOD_ADD_METHOD(TexCoord4sv); + PY_MOD_ADD_METHOD(TexEnvf); + PY_MOD_ADD_METHOD(TexEnvfv); + PY_MOD_ADD_METHOD(TexEnvi); + PY_MOD_ADD_METHOD(TexEnviv); + PY_MOD_ADD_METHOD(TexGend); + PY_MOD_ADD_METHOD(TexGendv); + PY_MOD_ADD_METHOD(TexGenf); + PY_MOD_ADD_METHOD(TexGenfv); + PY_MOD_ADD_METHOD(TexGeni); + PY_MOD_ADD_METHOD(TexGeniv); + PY_MOD_ADD_METHOD(Translated); + PY_MOD_ADD_METHOD(Translatef); + PY_MOD_ADD_METHOD(Vertex2d); + PY_MOD_ADD_METHOD(Vertex2dv); + PY_MOD_ADD_METHOD(Vertex2f); + PY_MOD_ADD_METHOD(Vertex2fv); + PY_MOD_ADD_METHOD(Vertex2i); + PY_MOD_ADD_METHOD(Vertex2iv); + PY_MOD_ADD_METHOD(Vertex2s); + PY_MOD_ADD_METHOD(Vertex2sv); + PY_MOD_ADD_METHOD(Vertex3d); + PY_MOD_ADD_METHOD(Vertex3dv); + PY_MOD_ADD_METHOD(Vertex3f); + PY_MOD_ADD_METHOD(Vertex3fv); + PY_MOD_ADD_METHOD(Vertex3i); + PY_MOD_ADD_METHOD(Vertex3iv); + PY_MOD_ADD_METHOD(Vertex3s); + PY_MOD_ADD_METHOD(Vertex3sv); + PY_MOD_ADD_METHOD(Vertex4d); + PY_MOD_ADD_METHOD(Vertex4dv); + PY_MOD_ADD_METHOD(Vertex4f); + PY_MOD_ADD_METHOD(Vertex4fv); + PY_MOD_ADD_METHOD(Vertex4i); + PY_MOD_ADD_METHOD(Vertex4iv); + PY_MOD_ADD_METHOD(Vertex4s); + PY_MOD_ADD_METHOD(Vertex4sv); + } + + + /* GL_VERSION_1_1 */ + { + PY_MOD_ADD_METHOD(BindTexture); + PY_MOD_ADD_METHOD(CopyTexImage1D); + PY_MOD_ADD_METHOD(CopyTexImage2D); + PY_MOD_ADD_METHOD(CopyTexSubImage1D); + PY_MOD_ADD_METHOD(CopyTexSubImage2D); + PY_MOD_ADD_METHOD(DeleteTextures); + PY_MOD_ADD_METHOD(DrawArrays); + PY_MOD_ADD_METHOD(DrawElements); + PY_MOD_ADD_METHOD(GenTextures); + PY_MOD_ADD_METHOD(IsTexture); + PY_MOD_ADD_METHOD(PolygonOffset); + PY_MOD_ADD_METHOD(TexSubImage1D); + PY_MOD_ADD_METHOD(TexSubImage2D); + } + /* adding in GL_VERSION_1_1 removed from core profile */ + if (use_deprecated == true) { + PY_MOD_ADD_METHOD(AreTexturesResident); + PY_MOD_ADD_METHOD(ArrayElement); + PY_MOD_ADD_METHOD(ColorPointer); + PY_MOD_ADD_METHOD(DisableClientState); + PY_MOD_ADD_METHOD(EdgeFlagPointer); + PY_MOD_ADD_METHOD(EnableClientState); + PY_MOD_ADD_METHOD(GetPointerv); + PY_MOD_ADD_METHOD(IndexPointer); + PY_MOD_ADD_METHOD(Indexub); + PY_MOD_ADD_METHOD(Indexubv); + PY_MOD_ADD_METHOD(InterleavedArrays); + PY_MOD_ADD_METHOD(NormalPointer); + PY_MOD_ADD_METHOD(PopClientAttrib); + PY_MOD_ADD_METHOD(PrioritizeTextures); + PY_MOD_ADD_METHOD(PushClientAttrib); + PY_MOD_ADD_METHOD(TexCoordPointer); + PY_MOD_ADD_METHOD(VertexPointer); + } + + + /* GL_VERSION_1_2 */ + { + PY_MOD_ADD_METHOD(CopyTexSubImage3D); + PY_MOD_ADD_METHOD(DrawRangeElements); + PY_MOD_ADD_METHOD(TexImage3D); + PY_MOD_ADD_METHOD(TexSubImage3D); + } + + + /* GL_VERSION_1_3 */ + { + PY_MOD_ADD_METHOD(ActiveTexture); + PY_MOD_ADD_METHOD(CompressedTexImage1D); + PY_MOD_ADD_METHOD(CompressedTexImage2D); + PY_MOD_ADD_METHOD(CompressedTexImage3D); + PY_MOD_ADD_METHOD(CompressedTexSubImage1D); + PY_MOD_ADD_METHOD(CompressedTexSubImage2D); + PY_MOD_ADD_METHOD(CompressedTexSubImage3D); + PY_MOD_ADD_METHOD(GetCompressedTexImage); + PY_MOD_ADD_METHOD(SampleCoverage); + } + /* adding in GL_VERSION_1_3 removed from core profile */ + if (use_deprecated == true) { + PY_MOD_ADD_METHOD(ClientActiveTexture); + PY_MOD_ADD_METHOD(LoadTransposeMatrixd); + PY_MOD_ADD_METHOD(LoadTransposeMatrixf); + PY_MOD_ADD_METHOD(MultTransposeMatrixd); + PY_MOD_ADD_METHOD(MultTransposeMatrixf); + PY_MOD_ADD_METHOD(MultiTexCoord1d); + PY_MOD_ADD_METHOD(MultiTexCoord1dv); + PY_MOD_ADD_METHOD(MultiTexCoord1f); + PY_MOD_ADD_METHOD(MultiTexCoord1fv); + PY_MOD_ADD_METHOD(MultiTexCoord1i); + PY_MOD_ADD_METHOD(MultiTexCoord1iv); + PY_MOD_ADD_METHOD(MultiTexCoord1s); + PY_MOD_ADD_METHOD(MultiTexCoord1sv); + PY_MOD_ADD_METHOD(MultiTexCoord2d); + PY_MOD_ADD_METHOD(MultiTexCoord2dv); + PY_MOD_ADD_METHOD(MultiTexCoord2f); + PY_MOD_ADD_METHOD(MultiTexCoord2fv); + PY_MOD_ADD_METHOD(MultiTexCoord2i); + PY_MOD_ADD_METHOD(MultiTexCoord2iv); + PY_MOD_ADD_METHOD(MultiTexCoord2s); + PY_MOD_ADD_METHOD(MultiTexCoord2sv); + PY_MOD_ADD_METHOD(MultiTexCoord3d); + PY_MOD_ADD_METHOD(MultiTexCoord3dv); + PY_MOD_ADD_METHOD(MultiTexCoord3f); + PY_MOD_ADD_METHOD(MultiTexCoord3fv); + PY_MOD_ADD_METHOD(MultiTexCoord3i); + PY_MOD_ADD_METHOD(MultiTexCoord3iv); + PY_MOD_ADD_METHOD(MultiTexCoord3s); + PY_MOD_ADD_METHOD(MultiTexCoord3sv); + PY_MOD_ADD_METHOD(MultiTexCoord4d); + PY_MOD_ADD_METHOD(MultiTexCoord4dv); + PY_MOD_ADD_METHOD(MultiTexCoord4f); + PY_MOD_ADD_METHOD(MultiTexCoord4fv); + PY_MOD_ADD_METHOD(MultiTexCoord4i); + PY_MOD_ADD_METHOD(MultiTexCoord4iv); + PY_MOD_ADD_METHOD(MultiTexCoord4s); + PY_MOD_ADD_METHOD(MultiTexCoord4sv); + } + + + /* GL_VERSION_1_4 */ + { + PY_MOD_ADD_METHOD(BlendColor); + PY_MOD_ADD_METHOD(BlendEquation); + } + + + /* GL_VERSION_1_5 */ + { + PY_MOD_ADD_METHOD(BeginQuery); + PY_MOD_ADD_METHOD(BindBuffer); + PY_MOD_ADD_METHOD(BufferData); + PY_MOD_ADD_METHOD(BufferSubData); + PY_MOD_ADD_METHOD(DeleteBuffers); + PY_MOD_ADD_METHOD(DeleteQueries); + PY_MOD_ADD_METHOD(EndQuery); + PY_MOD_ADD_METHOD(GenBuffers); + PY_MOD_ADD_METHOD(GenQueries); + PY_MOD_ADD_METHOD(GetBufferParameteriv); + PY_MOD_ADD_METHOD(GetBufferPointerv); + PY_MOD_ADD_METHOD(GetBufferSubData); + PY_MOD_ADD_METHOD(GetQueryObjectiv); + PY_MOD_ADD_METHOD(GetQueryObjectuiv); + PY_MOD_ADD_METHOD(GetQueryiv); + PY_MOD_ADD_METHOD(IsBuffer); + PY_MOD_ADD_METHOD(IsQuery); + PY_MOD_ADD_METHOD(MapBuffer); + PY_MOD_ADD_METHOD(UnmapBuffer); + } + + + /* GL_VERSION_2_0 */ + { + PY_MOD_ADD_METHOD(AttachShader); + PY_MOD_ADD_METHOD(BindAttribLocation); + PY_MOD_ADD_METHOD(BlendEquationSeparate); + PY_MOD_ADD_METHOD(CompileShader); + PY_MOD_ADD_METHOD(CreateProgram); + PY_MOD_ADD_METHOD(CreateShader); + PY_MOD_ADD_METHOD(DeleteProgram); + PY_MOD_ADD_METHOD(DeleteShader); + PY_MOD_ADD_METHOD(DetachShader); + PY_MOD_ADD_METHOD(DisableVertexAttribArray); + PY_MOD_ADD_METHOD(DrawBuffers); + PY_MOD_ADD_METHOD(EnableVertexAttribArray); + PY_MOD_ADD_METHOD(GetActiveAttrib); + PY_MOD_ADD_METHOD(GetActiveUniform); + PY_MOD_ADD_METHOD(GetAttachedShaders); + PY_MOD_ADD_METHOD(GetAttribLocation); + PY_MOD_ADD_METHOD(GetProgramInfoLog); + PY_MOD_ADD_METHOD(GetProgramiv); + PY_MOD_ADD_METHOD(GetShaderInfoLog); + PY_MOD_ADD_METHOD(GetShaderSource); + PY_MOD_ADD_METHOD(GetShaderiv); + PY_MOD_ADD_METHOD(GetUniformLocation); + PY_MOD_ADD_METHOD(GetUniformfv); + PY_MOD_ADD_METHOD(GetUniformiv); + PY_MOD_ADD_METHOD(GetVertexAttribPointerv); + PY_MOD_ADD_METHOD(GetVertexAttribdv); + PY_MOD_ADD_METHOD(GetVertexAttribfv); + PY_MOD_ADD_METHOD(GetVertexAttribiv); + PY_MOD_ADD_METHOD(IsProgram); + PY_MOD_ADD_METHOD(IsShader); + PY_MOD_ADD_METHOD(LinkProgram); + PY_MOD_ADD_METHOD(ShaderSource); + PY_MOD_ADD_METHOD(StencilFuncSeparate); + PY_MOD_ADD_METHOD(StencilMaskSeparate); + PY_MOD_ADD_METHOD(StencilOpSeparate); + PY_MOD_ADD_METHOD(Uniform1f); + PY_MOD_ADD_METHOD(Uniform1fv); + PY_MOD_ADD_METHOD(Uniform1i); + PY_MOD_ADD_METHOD(Uniform1iv); + PY_MOD_ADD_METHOD(Uniform2f); + PY_MOD_ADD_METHOD(Uniform2fv); + PY_MOD_ADD_METHOD(Uniform2i); + PY_MOD_ADD_METHOD(Uniform2iv); + PY_MOD_ADD_METHOD(Uniform3f); + PY_MOD_ADD_METHOD(Uniform3fv); + PY_MOD_ADD_METHOD(Uniform3i); + PY_MOD_ADD_METHOD(Uniform3iv); + PY_MOD_ADD_METHOD(Uniform4f); + PY_MOD_ADD_METHOD(Uniform4fv); + PY_MOD_ADD_METHOD(Uniform4i); + PY_MOD_ADD_METHOD(Uniform4iv); + PY_MOD_ADD_METHOD(UniformMatrix2fv); + PY_MOD_ADD_METHOD(UniformMatrix3fv); + PY_MOD_ADD_METHOD(UniformMatrix4fv); + PY_MOD_ADD_METHOD(UseProgram); + PY_MOD_ADD_METHOD(ValidateProgram); + PY_MOD_ADD_METHOD(VertexAttrib1d); + PY_MOD_ADD_METHOD(VertexAttrib1dv); + PY_MOD_ADD_METHOD(VertexAttrib1f); + PY_MOD_ADD_METHOD(VertexAttrib1fv); + PY_MOD_ADD_METHOD(VertexAttrib1s); + PY_MOD_ADD_METHOD(VertexAttrib1sv); + PY_MOD_ADD_METHOD(VertexAttrib2d); + PY_MOD_ADD_METHOD(VertexAttrib2dv); + PY_MOD_ADD_METHOD(VertexAttrib2f); + PY_MOD_ADD_METHOD(VertexAttrib2fv); + PY_MOD_ADD_METHOD(VertexAttrib2s); + PY_MOD_ADD_METHOD(VertexAttrib2sv); + PY_MOD_ADD_METHOD(VertexAttrib3d); + PY_MOD_ADD_METHOD(VertexAttrib3dv); + PY_MOD_ADD_METHOD(VertexAttrib3f); + PY_MOD_ADD_METHOD(VertexAttrib3fv); + PY_MOD_ADD_METHOD(VertexAttrib3s); + PY_MOD_ADD_METHOD(VertexAttrib3sv); + PY_MOD_ADD_METHOD(VertexAttrib4Nbv); + PY_MOD_ADD_METHOD(VertexAttrib4Niv); + PY_MOD_ADD_METHOD(VertexAttrib4Nsv); + PY_MOD_ADD_METHOD(VertexAttrib4Nub); + PY_MOD_ADD_METHOD(VertexAttrib4Nubv); + PY_MOD_ADD_METHOD(VertexAttrib4Nuiv); + PY_MOD_ADD_METHOD(VertexAttrib4Nusv); + PY_MOD_ADD_METHOD(VertexAttrib4bv); + PY_MOD_ADD_METHOD(VertexAttrib4d); + PY_MOD_ADD_METHOD(VertexAttrib4dv); + PY_MOD_ADD_METHOD(VertexAttrib4f); + PY_MOD_ADD_METHOD(VertexAttrib4fv); + PY_MOD_ADD_METHOD(VertexAttrib4iv); + PY_MOD_ADD_METHOD(VertexAttrib4s); + PY_MOD_ADD_METHOD(VertexAttrib4sv); + PY_MOD_ADD_METHOD(VertexAttrib4ubv); + PY_MOD_ADD_METHOD(VertexAttrib4uiv); + PY_MOD_ADD_METHOD(VertexAttrib4usv); + PY_MOD_ADD_METHOD(VertexAttribPointer); + } + + + /* GL_VERSION_2_1 */ + { + PY_MOD_ADD_METHOD(UniformMatrix2x3fv); + PY_MOD_ADD_METHOD(UniformMatrix2x4fv); + PY_MOD_ADD_METHOD(UniformMatrix3x2fv); + PY_MOD_ADD_METHOD(UniformMatrix3x4fv); + PY_MOD_ADD_METHOD(UniformMatrix4x2fv); + PY_MOD_ADD_METHOD(UniformMatrix4x3fv); + } + + + /* GL_VERSION_3_0 */ + { + PY_MOD_ADD_METHOD(BindVertexArray); + PY_MOD_ADD_METHOD(DeleteVertexArrays); + PY_MOD_ADD_METHOD(GenVertexArrays); + PY_MOD_ADD_METHOD(IsVertexArray); + } + + + /* GL_VERSION_3_1 */ + { + PY_MOD_ADD_METHOD(BindBufferBase); + PY_MOD_ADD_METHOD(BindBufferRange); + PY_MOD_ADD_METHOD(GetActiveUniformBlockName); + PY_MOD_ADD_METHOD(GetActiveUniformBlockiv); + PY_MOD_ADD_METHOD(GetActiveUniformName); + PY_MOD_ADD_METHOD(GetActiveUniformsiv); + PY_MOD_ADD_METHOD(GetIntegeri_v); + PY_MOD_ADD_METHOD(GetUniformBlockIndex); + PY_MOD_ADD_METHOD(GetUniformIndices); + PY_MOD_ADD_METHOD(UniformBlockBinding); + } + + + /* GL_VERSION_3_2 */ + { + PY_MOD_ADD_METHOD(FramebufferTexture); + PY_MOD_ADD_METHOD(GetBufferParameteri64v); + PY_MOD_ADD_METHOD(GetInteger64i_v); + PY_MOD_ADD_METHOD(GetMultisamplefv); + PY_MOD_ADD_METHOD(SampleMaski); + PY_MOD_ADD_METHOD(TexImage2DMultisample); + PY_MOD_ADD_METHOD(TexImage3DMultisample); + } + + + /* GL_VERSION_3_3 */ + { + PY_MOD_ADD_METHOD(ColorP3ui); + PY_MOD_ADD_METHOD(ColorP3uiv); + PY_MOD_ADD_METHOD(ColorP4ui); + PY_MOD_ADD_METHOD(ColorP4uiv); + PY_MOD_ADD_METHOD(MultiTexCoordP1ui); + PY_MOD_ADD_METHOD(MultiTexCoordP1uiv); + PY_MOD_ADD_METHOD(MultiTexCoordP2ui); + PY_MOD_ADD_METHOD(MultiTexCoordP2uiv); + PY_MOD_ADD_METHOD(MultiTexCoordP3ui); + PY_MOD_ADD_METHOD(MultiTexCoordP3uiv); + PY_MOD_ADD_METHOD(MultiTexCoordP4ui); + PY_MOD_ADD_METHOD(MultiTexCoordP4uiv); + PY_MOD_ADD_METHOD(NormalP3ui); + PY_MOD_ADD_METHOD(NormalP3uiv); + PY_MOD_ADD_METHOD(SecondaryColorP3ui); + PY_MOD_ADD_METHOD(SecondaryColorP3uiv); + PY_MOD_ADD_METHOD(TexCoordP1ui); + PY_MOD_ADD_METHOD(TexCoordP1uiv); + PY_MOD_ADD_METHOD(TexCoordP2ui); + PY_MOD_ADD_METHOD(TexCoordP2uiv); + PY_MOD_ADD_METHOD(TexCoordP3ui); + PY_MOD_ADD_METHOD(TexCoordP3uiv); + PY_MOD_ADD_METHOD(TexCoordP4ui); + PY_MOD_ADD_METHOD(TexCoordP4uiv); + PY_MOD_ADD_METHOD(VertexP2ui); + PY_MOD_ADD_METHOD(VertexP2uiv); + PY_MOD_ADD_METHOD(VertexP3ui); + PY_MOD_ADD_METHOD(VertexP3uiv); + PY_MOD_ADD_METHOD(VertexP4ui); + PY_MOD_ADD_METHOD(VertexP4uiv); + } + +#define PY_DICT_ADD_INT(x) py_module_dict_add_int(dict, #x, x) + + /* GL_VERSION_1_1 */ + { + PY_DICT_ADD_INT(GL_ALPHA); + PY_DICT_ADD_INT(GL_ALWAYS); + PY_DICT_ADD_INT(GL_AND); + PY_DICT_ADD_INT(GL_AND_INVERTED); + PY_DICT_ADD_INT(GL_AND_REVERSE); + PY_DICT_ADD_INT(GL_BACK); + PY_DICT_ADD_INT(GL_BACK_LEFT); + PY_DICT_ADD_INT(GL_BACK_RIGHT); + PY_DICT_ADD_INT(GL_BLEND); + PY_DICT_ADD_INT(GL_BLEND_DST); + PY_DICT_ADD_INT(GL_BLEND_SRC); + PY_DICT_ADD_INT(GL_BLUE); + PY_DICT_ADD_INT(GL_BYTE); + PY_DICT_ADD_INT(GL_CCW); + PY_DICT_ADD_INT(GL_CLEAR); + PY_DICT_ADD_INT(GL_COLOR); + PY_DICT_ADD_INT(GL_COLOR_BUFFER_BIT); + PY_DICT_ADD_INT(GL_COLOR_CLEAR_VALUE); + PY_DICT_ADD_INT(GL_COLOR_LOGIC_OP); + PY_DICT_ADD_INT(GL_COLOR_WRITEMASK); + PY_DICT_ADD_INT(GL_COPY); + PY_DICT_ADD_INT(GL_COPY_INVERTED); + PY_DICT_ADD_INT(GL_CULL_FACE); + PY_DICT_ADD_INT(GL_CULL_FACE_MODE); + PY_DICT_ADD_INT(GL_CW); + PY_DICT_ADD_INT(GL_DECR); + PY_DICT_ADD_INT(GL_DEPTH); + PY_DICT_ADD_INT(GL_DEPTH_BUFFER_BIT); + PY_DICT_ADD_INT(GL_DEPTH_CLEAR_VALUE); + PY_DICT_ADD_INT(GL_DEPTH_COMPONENT); + PY_DICT_ADD_INT(GL_DEPTH_FUNC); + PY_DICT_ADD_INT(GL_DEPTH_RANGE); + PY_DICT_ADD_INT(GL_DEPTH_TEST); + PY_DICT_ADD_INT(GL_DEPTH_WRITEMASK); + PY_DICT_ADD_INT(GL_DITHER); + PY_DICT_ADD_INT(GL_DONT_CARE); + PY_DICT_ADD_INT(GL_DOUBLE); + PY_DICT_ADD_INT(GL_DOUBLEBUFFER); + PY_DICT_ADD_INT(GL_DRAW_BUFFER); + PY_DICT_ADD_INT(GL_DST_ALPHA); + PY_DICT_ADD_INT(GL_DST_COLOR); + PY_DICT_ADD_INT(GL_EQUAL); + PY_DICT_ADD_INT(GL_EQUIV); + PY_DICT_ADD_INT(GL_EXTENSIONS); + PY_DICT_ADD_INT(GL_FALSE); + PY_DICT_ADD_INT(GL_FASTEST); + PY_DICT_ADD_INT(GL_FILL); + PY_DICT_ADD_INT(GL_FLOAT); + PY_DICT_ADD_INT(GL_FRONT); + PY_DICT_ADD_INT(GL_FRONT_AND_BACK); + PY_DICT_ADD_INT(GL_FRONT_FACE); + PY_DICT_ADD_INT(GL_FRONT_LEFT); + PY_DICT_ADD_INT(GL_FRONT_RIGHT); + PY_DICT_ADD_INT(GL_GEQUAL); + PY_DICT_ADD_INT(GL_GREATER); + PY_DICT_ADD_INT(GL_GREEN); + PY_DICT_ADD_INT(GL_INCR); + PY_DICT_ADD_INT(GL_INT); + PY_DICT_ADD_INT(GL_INVALID_ENUM); + PY_DICT_ADD_INT(GL_INVALID_OPERATION); + PY_DICT_ADD_INT(GL_INVALID_VALUE); + PY_DICT_ADD_INT(GL_INVERT); + PY_DICT_ADD_INT(GL_KEEP); + PY_DICT_ADD_INT(GL_LEFT); + PY_DICT_ADD_INT(GL_LEQUAL); + PY_DICT_ADD_INT(GL_LESS); + PY_DICT_ADD_INT(GL_LINE); + PY_DICT_ADD_INT(GL_LINEAR); + PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_LINEAR); + PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_NEAREST); + PY_DICT_ADD_INT(GL_LINES); + PY_DICT_ADD_INT(GL_LINE_LOOP); + PY_DICT_ADD_INT(GL_LINE_SMOOTH); + PY_DICT_ADD_INT(GL_LINE_SMOOTH_HINT); + PY_DICT_ADD_INT(GL_LINE_STRIP); + PY_DICT_ADD_INT(GL_LINE_WIDTH); + PY_DICT_ADD_INT(GL_LINE_WIDTH_GRANULARITY); + PY_DICT_ADD_INT(GL_LINE_WIDTH_RANGE); + PY_DICT_ADD_INT(GL_LOGIC_OP_MODE); + PY_DICT_ADD_INT(GL_MAX_TEXTURE_SIZE); + PY_DICT_ADD_INT(GL_MAX_VIEWPORT_DIMS); + PY_DICT_ADD_INT(GL_NAND); + PY_DICT_ADD_INT(GL_NEAREST); + PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_LINEAR); + PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_NEAREST); + PY_DICT_ADD_INT(GL_NEVER); + PY_DICT_ADD_INT(GL_NICEST); + PY_DICT_ADD_INT(GL_NONE); + PY_DICT_ADD_INT(GL_NOOP); + PY_DICT_ADD_INT(GL_NOR); + PY_DICT_ADD_INT(GL_NOTEQUAL); + PY_DICT_ADD_INT(GL_NO_ERROR); + PY_DICT_ADD_INT(GL_ONE); + PY_DICT_ADD_INT(GL_ONE_MINUS_DST_ALPHA); + PY_DICT_ADD_INT(GL_ONE_MINUS_DST_COLOR); + PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_ALPHA); + PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_COLOR); + PY_DICT_ADD_INT(GL_OR); + PY_DICT_ADD_INT(GL_OR_INVERTED); + PY_DICT_ADD_INT(GL_OR_REVERSE); + PY_DICT_ADD_INT(GL_OUT_OF_MEMORY); + PY_DICT_ADD_INT(GL_PACK_ALIGNMENT); + PY_DICT_ADD_INT(GL_PACK_LSB_FIRST); + PY_DICT_ADD_INT(GL_PACK_ROW_LENGTH); + PY_DICT_ADD_INT(GL_PACK_SKIP_PIXELS); + PY_DICT_ADD_INT(GL_PACK_SKIP_ROWS); + PY_DICT_ADD_INT(GL_PACK_SWAP_BYTES); + PY_DICT_ADD_INT(GL_POINT); + PY_DICT_ADD_INT(GL_POINTS); + PY_DICT_ADD_INT(GL_POINT_SIZE); + PY_DICT_ADD_INT(GL_POINT_SIZE_GRANULARITY); + PY_DICT_ADD_INT(GL_POINT_SIZE_RANGE); + PY_DICT_ADD_INT(GL_POLYGON_MODE); + PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FACTOR); + PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FILL); + PY_DICT_ADD_INT(GL_POLYGON_OFFSET_LINE); + PY_DICT_ADD_INT(GL_POLYGON_OFFSET_POINT); + PY_DICT_ADD_INT(GL_POLYGON_OFFSET_UNITS); + PY_DICT_ADD_INT(GL_POLYGON_SMOOTH); + PY_DICT_ADD_INT(GL_POLYGON_SMOOTH_HINT); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D); + PY_DICT_ADD_INT(GL_R3_G3_B2); + PY_DICT_ADD_INT(GL_READ_BUFFER); + PY_DICT_ADD_INT(GL_RED); + PY_DICT_ADD_INT(GL_RENDERER); + PY_DICT_ADD_INT(GL_REPEAT); + PY_DICT_ADD_INT(GL_REPLACE); + PY_DICT_ADD_INT(GL_RGB); + PY_DICT_ADD_INT(GL_RGB10); + PY_DICT_ADD_INT(GL_RGB10_A2); + PY_DICT_ADD_INT(GL_RGB12); + PY_DICT_ADD_INT(GL_RGB16); + PY_DICT_ADD_INT(GL_RGB4); + PY_DICT_ADD_INT(GL_RGB5); + PY_DICT_ADD_INT(GL_RGB5_A1); + PY_DICT_ADD_INT(GL_RGB8); + PY_DICT_ADD_INT(GL_RGBA); + PY_DICT_ADD_INT(GL_RGBA12); + PY_DICT_ADD_INT(GL_RGBA16); + PY_DICT_ADD_INT(GL_RGBA2); + PY_DICT_ADD_INT(GL_RGBA4); + PY_DICT_ADD_INT(GL_RGBA8); + PY_DICT_ADD_INT(GL_RIGHT); + PY_DICT_ADD_INT(GL_SCISSOR_BOX); + PY_DICT_ADD_INT(GL_SCISSOR_TEST); + PY_DICT_ADD_INT(GL_SET); + PY_DICT_ADD_INT(GL_SHORT); + PY_DICT_ADD_INT(GL_SRC_ALPHA); + PY_DICT_ADD_INT(GL_SRC_ALPHA_SATURATE); + PY_DICT_ADD_INT(GL_SRC_COLOR); + PY_DICT_ADD_INT(GL_STENCIL); + PY_DICT_ADD_INT(GL_STENCIL_BUFFER_BIT); + PY_DICT_ADD_INT(GL_STENCIL_CLEAR_VALUE); + PY_DICT_ADD_INT(GL_STENCIL_FAIL); + PY_DICT_ADD_INT(GL_STENCIL_FUNC); + PY_DICT_ADD_INT(GL_STENCIL_INDEX); + PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_FAIL); + PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_PASS); + PY_DICT_ADD_INT(GL_STENCIL_REF); + PY_DICT_ADD_INT(GL_STENCIL_TEST); + PY_DICT_ADD_INT(GL_STENCIL_VALUE_MASK); + PY_DICT_ADD_INT(GL_STENCIL_WRITEMASK); + PY_DICT_ADD_INT(GL_STEREO); + PY_DICT_ADD_INT(GL_SUBPIXEL_BITS); + PY_DICT_ADD_INT(GL_TEXTURE); + PY_DICT_ADD_INT(GL_TEXTURE_1D); + PY_DICT_ADD_INT(GL_TEXTURE_2D); + PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D); + PY_DICT_ADD_INT(GL_TEXTURE_BLUE_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_BORDER_COLOR); + PY_DICT_ADD_INT(GL_TEXTURE_GREEN_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_HEIGHT); + PY_DICT_ADD_INT(GL_TEXTURE_INTERNAL_FORMAT); + PY_DICT_ADD_INT(GL_TEXTURE_MAG_FILTER); + PY_DICT_ADD_INT(GL_TEXTURE_MIN_FILTER); + PY_DICT_ADD_INT(GL_TEXTURE_RED_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_WIDTH); + PY_DICT_ADD_INT(GL_TEXTURE_WRAP_S); + PY_DICT_ADD_INT(GL_TEXTURE_WRAP_T); + PY_DICT_ADD_INT(GL_TRIANGLES); + PY_DICT_ADD_INT(GL_TRIANGLE_FAN); + PY_DICT_ADD_INT(GL_TRIANGLE_STRIP); + PY_DICT_ADD_INT(GL_TRUE); + PY_DICT_ADD_INT(GL_UNPACK_ALIGNMENT); + PY_DICT_ADD_INT(GL_UNPACK_LSB_FIRST); + PY_DICT_ADD_INT(GL_UNPACK_ROW_LENGTH); + PY_DICT_ADD_INT(GL_UNPACK_SKIP_PIXELS); + PY_DICT_ADD_INT(GL_UNPACK_SKIP_ROWS); + PY_DICT_ADD_INT(GL_UNPACK_SWAP_BYTES); + PY_DICT_ADD_INT(GL_UNSIGNED_BYTE); + PY_DICT_ADD_INT(GL_UNSIGNED_INT); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT); + PY_DICT_ADD_INT(GL_VENDOR); + PY_DICT_ADD_INT(GL_VERSION); + PY_DICT_ADD_INT(GL_VIEWPORT); + PY_DICT_ADD_INT(GL_XOR); + PY_DICT_ADD_INT(GL_ZERO); + } + /* adding in GL_VERSION_1_1 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_2D); + PY_DICT_ADD_INT(GL_2_BYTES); + PY_DICT_ADD_INT(GL_3D); + PY_DICT_ADD_INT(GL_3D_COLOR); + PY_DICT_ADD_INT(GL_3D_COLOR_TEXTURE); + PY_DICT_ADD_INT(GL_3_BYTES); + PY_DICT_ADD_INT(GL_4D_COLOR_TEXTURE); + PY_DICT_ADD_INT(GL_4_BYTES); + PY_DICT_ADD_INT(GL_ACCUM); + PY_DICT_ADD_INT(GL_ACCUM_ALPHA_BITS); + PY_DICT_ADD_INT(GL_ACCUM_BLUE_BITS); + PY_DICT_ADD_INT(GL_ACCUM_BUFFER_BIT); + PY_DICT_ADD_INT(GL_ACCUM_CLEAR_VALUE); + PY_DICT_ADD_INT(GL_ACCUM_GREEN_BITS); + PY_DICT_ADD_INT(GL_ACCUM_RED_BITS); + PY_DICT_ADD_INT(GL_ADD); + PY_DICT_ADD_INT(GL_ALL_ATTRIB_BITS); + PY_DICT_ADD_INT(GL_ALPHA12); + PY_DICT_ADD_INT(GL_ALPHA16); + PY_DICT_ADD_INT(GL_ALPHA4); + PY_DICT_ADD_INT(GL_ALPHA8); + PY_DICT_ADD_INT(GL_ALPHA_BIAS); + PY_DICT_ADD_INT(GL_ALPHA_BITS); + PY_DICT_ADD_INT(GL_ALPHA_SCALE); + PY_DICT_ADD_INT(GL_ALPHA_TEST); + PY_DICT_ADD_INT(GL_ALPHA_TEST_FUNC); + PY_DICT_ADD_INT(GL_ALPHA_TEST_REF); + PY_DICT_ADD_INT(GL_AMBIENT); + PY_DICT_ADD_INT(GL_AMBIENT_AND_DIFFUSE); + PY_DICT_ADD_INT(GL_ATTRIB_STACK_DEPTH); + PY_DICT_ADD_INT(GL_AUTO_NORMAL); + PY_DICT_ADD_INT(GL_AUX0); + PY_DICT_ADD_INT(GL_AUX1); + PY_DICT_ADD_INT(GL_AUX2); + PY_DICT_ADD_INT(GL_AUX3); + PY_DICT_ADD_INT(GL_AUX_BUFFERS); + PY_DICT_ADD_INT(GL_BITMAP); + PY_DICT_ADD_INT(GL_BITMAP_TOKEN); + PY_DICT_ADD_INT(GL_BLUE_BIAS); + PY_DICT_ADD_INT(GL_BLUE_BITS); + PY_DICT_ADD_INT(GL_BLUE_SCALE); + PY_DICT_ADD_INT(GL_C3F_V3F); + PY_DICT_ADD_INT(GL_C4F_N3F_V3F); + PY_DICT_ADD_INT(GL_C4UB_V2F); + PY_DICT_ADD_INT(GL_C4UB_V3F); + PY_DICT_ADD_INT(GL_CLAMP); + PY_DICT_ADD_INT(GL_CLIENT_ALL_ATTRIB_BITS); + PY_DICT_ADD_INT(GL_CLIENT_ATTRIB_STACK_DEPTH); + PY_DICT_ADD_INT(GL_CLIENT_PIXEL_STORE_BIT); + PY_DICT_ADD_INT(GL_CLIENT_VERTEX_ARRAY_BIT); + PY_DICT_ADD_INT(GL_CLIP_PLANE0); + PY_DICT_ADD_INT(GL_CLIP_PLANE1); + PY_DICT_ADD_INT(GL_CLIP_PLANE2); + PY_DICT_ADD_INT(GL_CLIP_PLANE3); + PY_DICT_ADD_INT(GL_CLIP_PLANE4); + PY_DICT_ADD_INT(GL_CLIP_PLANE5); + PY_DICT_ADD_INT(GL_COEFF); + PY_DICT_ADD_INT(GL_COLOR_ARRAY); + PY_DICT_ADD_INT(GL_COLOR_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_COLOR_ARRAY_SIZE); + PY_DICT_ADD_INT(GL_COLOR_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_COLOR_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_COLOR_INDEX); + PY_DICT_ADD_INT(GL_COLOR_INDEXES); + PY_DICT_ADD_INT(GL_COLOR_MATERIAL); + PY_DICT_ADD_INT(GL_COLOR_MATERIAL_FACE); + PY_DICT_ADD_INT(GL_COLOR_MATERIAL_PARAMETER); + PY_DICT_ADD_INT(GL_COMPILE); + PY_DICT_ADD_INT(GL_COMPILE_AND_EXECUTE); + PY_DICT_ADD_INT(GL_CONSTANT_ATTENUATION); + PY_DICT_ADD_INT(GL_COPY_PIXEL_TOKEN); + PY_DICT_ADD_INT(GL_CURRENT_BIT); + PY_DICT_ADD_INT(GL_CURRENT_COLOR); + PY_DICT_ADD_INT(GL_CURRENT_INDEX); + PY_DICT_ADD_INT(GL_CURRENT_NORMAL); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_COLOR); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_DISTANCE); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_INDEX); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_POSITION); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_POSITION_VALID); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_TEXTURE_COORDS); + PY_DICT_ADD_INT(GL_CURRENT_TEXTURE_COORDS); + PY_DICT_ADD_INT(GL_DECAL); + PY_DICT_ADD_INT(GL_DEPTH_BIAS); + PY_DICT_ADD_INT(GL_DEPTH_BITS); + PY_DICT_ADD_INT(GL_DEPTH_SCALE); + PY_DICT_ADD_INT(GL_DIFFUSE); + PY_DICT_ADD_INT(GL_DOMAIN); + PY_DICT_ADD_INT(GL_DRAW_PIXEL_TOKEN); + PY_DICT_ADD_INT(GL_EDGE_FLAG); + PY_DICT_ADD_INT(GL_EDGE_FLAG_ARRAY); + PY_DICT_ADD_INT(GL_EDGE_FLAG_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_EDGE_FLAG_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_EMISSION); + PY_DICT_ADD_INT(GL_ENABLE_BIT); + PY_DICT_ADD_INT(GL_EVAL_BIT); + PY_DICT_ADD_INT(GL_EXP); + PY_DICT_ADD_INT(GL_EXP2); + PY_DICT_ADD_INT(GL_EYE_LINEAR); + PY_DICT_ADD_INT(GL_EYE_PLANE); + PY_DICT_ADD_INT(GL_FEEDBACK); + PY_DICT_ADD_INT(GL_FEEDBACK_BUFFER_POINTER); + PY_DICT_ADD_INT(GL_FEEDBACK_BUFFER_SIZE); + PY_DICT_ADD_INT(GL_FEEDBACK_BUFFER_TYPE); + PY_DICT_ADD_INT(GL_FLAT); + PY_DICT_ADD_INT(GL_FOG); + PY_DICT_ADD_INT(GL_FOG_BIT); + PY_DICT_ADD_INT(GL_FOG_COLOR); + PY_DICT_ADD_INT(GL_FOG_DENSITY); + PY_DICT_ADD_INT(GL_FOG_END); + PY_DICT_ADD_INT(GL_FOG_HINT); + PY_DICT_ADD_INT(GL_FOG_INDEX); + PY_DICT_ADD_INT(GL_FOG_MODE); + PY_DICT_ADD_INT(GL_FOG_START); + PY_DICT_ADD_INT(GL_GREEN_BIAS); + PY_DICT_ADD_INT(GL_GREEN_BITS); + PY_DICT_ADD_INT(GL_GREEN_SCALE); + PY_DICT_ADD_INT(GL_HINT_BIT); + PY_DICT_ADD_INT(GL_INDEX_ARRAY); + PY_DICT_ADD_INT(GL_INDEX_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_INDEX_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_INDEX_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_INDEX_BITS); + PY_DICT_ADD_INT(GL_INDEX_CLEAR_VALUE); + PY_DICT_ADD_INT(GL_INDEX_LOGIC_OP); + PY_DICT_ADD_INT(GL_INDEX_MODE); + PY_DICT_ADD_INT(GL_INDEX_OFFSET); + PY_DICT_ADD_INT(GL_INDEX_SHIFT); + PY_DICT_ADD_INT(GL_INDEX_WRITEMASK); + PY_DICT_ADD_INT(GL_INTENSITY); + PY_DICT_ADD_INT(GL_INTENSITY12); + PY_DICT_ADD_INT(GL_INTENSITY16); + PY_DICT_ADD_INT(GL_INTENSITY4); + PY_DICT_ADD_INT(GL_INTENSITY8); + PY_DICT_ADD_INT(GL_LIGHT0); + PY_DICT_ADD_INT(GL_LIGHT1); + PY_DICT_ADD_INT(GL_LIGHT2); + PY_DICT_ADD_INT(GL_LIGHT3); + PY_DICT_ADD_INT(GL_LIGHT4); + PY_DICT_ADD_INT(GL_LIGHT5); + PY_DICT_ADD_INT(GL_LIGHT6); + PY_DICT_ADD_INT(GL_LIGHT7); + PY_DICT_ADD_INT(GL_LIGHTING); + PY_DICT_ADD_INT(GL_LIGHTING_BIT); + PY_DICT_ADD_INT(GL_LIGHT_MODEL_AMBIENT); + PY_DICT_ADD_INT(GL_LIGHT_MODEL_LOCAL_VIEWER); + PY_DICT_ADD_INT(GL_LIGHT_MODEL_TWO_SIDE); + PY_DICT_ADD_INT(GL_LINEAR_ATTENUATION); + PY_DICT_ADD_INT(GL_LINE_BIT); + PY_DICT_ADD_INT(GL_LINE_RESET_TOKEN); + PY_DICT_ADD_INT(GL_LINE_STIPPLE); + PY_DICT_ADD_INT(GL_LINE_STIPPLE_PATTERN); + PY_DICT_ADD_INT(GL_LINE_STIPPLE_REPEAT); + PY_DICT_ADD_INT(GL_LINE_TOKEN); + PY_DICT_ADD_INT(GL_LIST_BASE); + PY_DICT_ADD_INT(GL_LIST_BIT); + PY_DICT_ADD_INT(GL_LIST_INDEX); + PY_DICT_ADD_INT(GL_LIST_MODE); + PY_DICT_ADD_INT(GL_LOAD); + PY_DICT_ADD_INT(GL_LOGIC_OP); + PY_DICT_ADD_INT(GL_LUMINANCE); + PY_DICT_ADD_INT(GL_LUMINANCE12); + PY_DICT_ADD_INT(GL_LUMINANCE12_ALPHA12); + PY_DICT_ADD_INT(GL_LUMINANCE12_ALPHA4); + PY_DICT_ADD_INT(GL_LUMINANCE16); + PY_DICT_ADD_INT(GL_LUMINANCE16_ALPHA16); + PY_DICT_ADD_INT(GL_LUMINANCE4); + PY_DICT_ADD_INT(GL_LUMINANCE4_ALPHA4); + PY_DICT_ADD_INT(GL_LUMINANCE6_ALPHA2); + PY_DICT_ADD_INT(GL_LUMINANCE8); + PY_DICT_ADD_INT(GL_LUMINANCE8_ALPHA8); + PY_DICT_ADD_INT(GL_LUMINANCE_ALPHA); + PY_DICT_ADD_INT(GL_MAP1_COLOR_4); + PY_DICT_ADD_INT(GL_MAP1_GRID_DOMAIN); + PY_DICT_ADD_INT(GL_MAP1_GRID_SEGMENTS); + PY_DICT_ADD_INT(GL_MAP1_INDEX); + PY_DICT_ADD_INT(GL_MAP1_NORMAL); + PY_DICT_ADD_INT(GL_MAP1_TEXTURE_COORD_1); + PY_DICT_ADD_INT(GL_MAP1_TEXTURE_COORD_2); + PY_DICT_ADD_INT(GL_MAP1_TEXTURE_COORD_3); + PY_DICT_ADD_INT(GL_MAP1_TEXTURE_COORD_4); + PY_DICT_ADD_INT(GL_MAP1_VERTEX_3); + PY_DICT_ADD_INT(GL_MAP1_VERTEX_4); + PY_DICT_ADD_INT(GL_MAP2_COLOR_4); + PY_DICT_ADD_INT(GL_MAP2_GRID_DOMAIN); + PY_DICT_ADD_INT(GL_MAP2_GRID_SEGMENTS); + PY_DICT_ADD_INT(GL_MAP2_INDEX); + PY_DICT_ADD_INT(GL_MAP2_NORMAL); + PY_DICT_ADD_INT(GL_MAP2_TEXTURE_COORD_1); + PY_DICT_ADD_INT(GL_MAP2_TEXTURE_COORD_2); + PY_DICT_ADD_INT(GL_MAP2_TEXTURE_COORD_3); + PY_DICT_ADD_INT(GL_MAP2_TEXTURE_COORD_4); + PY_DICT_ADD_INT(GL_MAP2_VERTEX_3); + PY_DICT_ADD_INT(GL_MAP2_VERTEX_4); + PY_DICT_ADD_INT(GL_MAP_COLOR); + PY_DICT_ADD_INT(GL_MAP_STENCIL); + PY_DICT_ADD_INT(GL_MATRIX_MODE); + PY_DICT_ADD_INT(GL_MAX_ATTRIB_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MAX_CLIP_PLANES); + PY_DICT_ADD_INT(GL_MAX_EVAL_ORDER); + PY_DICT_ADD_INT(GL_MAX_LIGHTS); + PY_DICT_ADD_INT(GL_MAX_LIST_NESTING); + PY_DICT_ADD_INT(GL_MAX_MODELVIEW_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MAX_NAME_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MAX_PIXEL_MAP_TABLE); + PY_DICT_ADD_INT(GL_MAX_PROJECTION_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MAX_TEXTURE_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MODELVIEW); + PY_DICT_ADD_INT(GL_MODELVIEW_MATRIX); + PY_DICT_ADD_INT(GL_MODELVIEW_STACK_DEPTH); + PY_DICT_ADD_INT(GL_MODULATE); + PY_DICT_ADD_INT(GL_MULT); + PY_DICT_ADD_INT(GL_N3F_V3F); + PY_DICT_ADD_INT(GL_NAME_STACK_DEPTH); + PY_DICT_ADD_INT(GL_NORMALIZE); + PY_DICT_ADD_INT(GL_NORMAL_ARRAY); + PY_DICT_ADD_INT(GL_NORMAL_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_NORMAL_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_NORMAL_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_OBJECT_LINEAR); + PY_DICT_ADD_INT(GL_OBJECT_PLANE); + PY_DICT_ADD_INT(GL_ORDER); + PY_DICT_ADD_INT(GL_PASS_THROUGH_TOKEN); + PY_DICT_ADD_INT(GL_PERSPECTIVE_CORRECTION_HINT); + PY_DICT_ADD_INT(GL_PIXEL_MAP_A_TO_A); + PY_DICT_ADD_INT(GL_PIXEL_MAP_A_TO_A_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_B_TO_B); + PY_DICT_ADD_INT(GL_PIXEL_MAP_B_TO_B_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_G_TO_G); + PY_DICT_ADD_INT(GL_PIXEL_MAP_G_TO_G_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_A); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_A_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_B); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_B_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_G); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_G_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_I); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_I_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_R); + PY_DICT_ADD_INT(GL_PIXEL_MAP_I_TO_R_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_R_TO_R); + PY_DICT_ADD_INT(GL_PIXEL_MAP_R_TO_R_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MAP_S_TO_S); + PY_DICT_ADD_INT(GL_PIXEL_MAP_S_TO_S_SIZE); + PY_DICT_ADD_INT(GL_PIXEL_MODE_BIT); + PY_DICT_ADD_INT(GL_POINT_BIT); + PY_DICT_ADD_INT(GL_POINT_SMOOTH); + PY_DICT_ADD_INT(GL_POINT_SMOOTH_HINT); + PY_DICT_ADD_INT(GL_POINT_TOKEN); + PY_DICT_ADD_INT(GL_POLYGON); + PY_DICT_ADD_INT(GL_POLYGON_BIT); + PY_DICT_ADD_INT(GL_POLYGON_STIPPLE); + PY_DICT_ADD_INT(GL_POLYGON_STIPPLE_BIT); + PY_DICT_ADD_INT(GL_POLYGON_TOKEN); + PY_DICT_ADD_INT(GL_POSITION); + PY_DICT_ADD_INT(GL_PROJECTION); + PY_DICT_ADD_INT(GL_PROJECTION_MATRIX); + PY_DICT_ADD_INT(GL_PROJECTION_STACK_DEPTH); + PY_DICT_ADD_INT(GL_Q); + PY_DICT_ADD_INT(GL_QUADRATIC_ATTENUATION); + PY_DICT_ADD_INT(GL_QUADS); + PY_DICT_ADD_INT(GL_QUAD_STRIP); + PY_DICT_ADD_INT(GL_R); + PY_DICT_ADD_INT(GL_RED_BIAS); + PY_DICT_ADD_INT(GL_RED_BITS); + PY_DICT_ADD_INT(GL_RED_SCALE); + PY_DICT_ADD_INT(GL_RENDER); + PY_DICT_ADD_INT(GL_RENDER_MODE); + PY_DICT_ADD_INT(GL_RETURN); + PY_DICT_ADD_INT(GL_RGBA_MODE); + PY_DICT_ADD_INT(GL_S); + PY_DICT_ADD_INT(GL_SCISSOR_BIT); + PY_DICT_ADD_INT(GL_SELECT); + PY_DICT_ADD_INT(GL_SELECTION_BUFFER_POINTER); + PY_DICT_ADD_INT(GL_SELECTION_BUFFER_SIZE); + PY_DICT_ADD_INT(GL_SHADE_MODEL); + PY_DICT_ADD_INT(GL_SHININESS); + PY_DICT_ADD_INT(GL_SMOOTH); + PY_DICT_ADD_INT(GL_SPECULAR); + PY_DICT_ADD_INT(GL_SPHERE_MAP); + PY_DICT_ADD_INT(GL_SPOT_CUTOFF); + PY_DICT_ADD_INT(GL_SPOT_DIRECTION); + PY_DICT_ADD_INT(GL_SPOT_EXPONENT); + PY_DICT_ADD_INT(GL_STACK_OVERFLOW); + PY_DICT_ADD_INT(GL_STACK_UNDERFLOW); + PY_DICT_ADD_INT(GL_STENCIL_BITS); + PY_DICT_ADD_INT(GL_T); + PY_DICT_ADD_INT(GL_T2F_C3F_V3F); + PY_DICT_ADD_INT(GL_T2F_C4F_N3F_V3F); + PY_DICT_ADD_INT(GL_T2F_C4UB_V3F); + PY_DICT_ADD_INT(GL_T2F_N3F_V3F); + PY_DICT_ADD_INT(GL_T2F_V3F); + PY_DICT_ADD_INT(GL_T4F_C4F_N3F_V4F); + PY_DICT_ADD_INT(GL_T4F_V4F); + PY_DICT_ADD_INT(GL_TEXTURE_BIT); + PY_DICT_ADD_INT(GL_TEXTURE_BORDER); + PY_DICT_ADD_INT(GL_TEXTURE_COMPONENTS); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_TEXTURE_ENV); + PY_DICT_ADD_INT(GL_TEXTURE_ENV_COLOR); + PY_DICT_ADD_INT(GL_TEXTURE_ENV_MODE); + PY_DICT_ADD_INT(GL_TEXTURE_GEN_MODE); + PY_DICT_ADD_INT(GL_TEXTURE_GEN_Q); + PY_DICT_ADD_INT(GL_TEXTURE_GEN_R); + PY_DICT_ADD_INT(GL_TEXTURE_GEN_S); + PY_DICT_ADD_INT(GL_TEXTURE_GEN_T); + PY_DICT_ADD_INT(GL_TEXTURE_INTENSITY_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_LUMINANCE_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_MATRIX); + PY_DICT_ADD_INT(GL_TEXTURE_PRIORITY); + PY_DICT_ADD_INT(GL_TEXTURE_RESIDENT); + PY_DICT_ADD_INT(GL_TEXTURE_STACK_DEPTH); + PY_DICT_ADD_INT(GL_TRANSFORM_BIT); + PY_DICT_ADD_INT(GL_V2F); + PY_DICT_ADD_INT(GL_V3F); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_SIZE); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_VIEWPORT_BIT); + PY_DICT_ADD_INT(GL_ZOOM_X); + PY_DICT_ADD_INT(GL_ZOOM_Y); + } + + + /* GL_VERSION_1_2 */ + { + PY_DICT_ADD_INT(GL_ALIASED_LINE_WIDTH_RANGE); + PY_DICT_ADD_INT(GL_BGR); + PY_DICT_ADD_INT(GL_BGRA); + PY_DICT_ADD_INT(GL_CLAMP_TO_EDGE); + PY_DICT_ADD_INT(GL_MAX_3D_TEXTURE_SIZE); + PY_DICT_ADD_INT(GL_MAX_ELEMENTS_INDICES); + PY_DICT_ADD_INT(GL_MAX_ELEMENTS_VERTICES); + PY_DICT_ADD_INT(GL_PACK_IMAGE_HEIGHT); + PY_DICT_ADD_INT(GL_PACK_SKIP_IMAGES); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_3D); + PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_GRANULARITY); + PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_RANGE); + PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_GRANULARITY); + PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_RANGE); + PY_DICT_ADD_INT(GL_TEXTURE_3D); + PY_DICT_ADD_INT(GL_TEXTURE_BASE_LEVEL); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_3D); + PY_DICT_ADD_INT(GL_TEXTURE_DEPTH); + PY_DICT_ADD_INT(GL_TEXTURE_MAX_LEVEL); + PY_DICT_ADD_INT(GL_TEXTURE_MAX_LOD); + PY_DICT_ADD_INT(GL_TEXTURE_MIN_LOD); + PY_DICT_ADD_INT(GL_TEXTURE_WRAP_R); + PY_DICT_ADD_INT(GL_UNPACK_IMAGE_HEIGHT); + PY_DICT_ADD_INT(GL_UNPACK_SKIP_IMAGES); + PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_2_3_3_REV); + PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_3_3_2); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_10_10_10_2); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_2_10_10_10_REV); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8_REV); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_1_5_5_5_REV); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4_REV); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_5_5_1); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5); + PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5_REV); + } + /* adding in GL_VERSION_1_2 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_ALIASED_POINT_SIZE_RANGE); + PY_DICT_ADD_INT(GL_LIGHT_MODEL_COLOR_CONTROL); + PY_DICT_ADD_INT(GL_RESCALE_NORMAL); + PY_DICT_ADD_INT(GL_SEPARATE_SPECULAR_COLOR); + PY_DICT_ADD_INT(GL_SINGLE_COLOR); + } + + + /* GL_VERSION_1_3 */ + { + PY_DICT_ADD_INT(GL_ACTIVE_TEXTURE); + PY_DICT_ADD_INT(GL_CLAMP_TO_BORDER); + PY_DICT_ADD_INT(GL_COMPRESSED_RGB); + PY_DICT_ADD_INT(GL_COMPRESSED_RGBA); + PY_DICT_ADD_INT(GL_COMPRESSED_TEXTURE_FORMATS); + PY_DICT_ADD_INT(GL_MAX_CUBE_MAP_TEXTURE_SIZE); + PY_DICT_ADD_INT(GL_MULTISAMPLE); + PY_DICT_ADD_INT(GL_NUM_COMPRESSED_TEXTURE_FORMATS); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_CUBE_MAP); + PY_DICT_ADD_INT(GL_SAMPLES); + PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_COVERAGE); + PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_ONE); + PY_DICT_ADD_INT(GL_SAMPLE_BUFFERS); + PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE); + PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_INVERT); + PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_VALUE); + PY_DICT_ADD_INT(GL_TEXTURE0); + PY_DICT_ADD_INT(GL_TEXTURE1); + PY_DICT_ADD_INT(GL_TEXTURE10); + PY_DICT_ADD_INT(GL_TEXTURE11); + PY_DICT_ADD_INT(GL_TEXTURE12); + PY_DICT_ADD_INT(GL_TEXTURE13); + PY_DICT_ADD_INT(GL_TEXTURE14); + PY_DICT_ADD_INT(GL_TEXTURE15); + PY_DICT_ADD_INT(GL_TEXTURE16); + PY_DICT_ADD_INT(GL_TEXTURE17); + PY_DICT_ADD_INT(GL_TEXTURE18); + PY_DICT_ADD_INT(GL_TEXTURE19); + PY_DICT_ADD_INT(GL_TEXTURE2); + PY_DICT_ADD_INT(GL_TEXTURE20); + PY_DICT_ADD_INT(GL_TEXTURE21); + PY_DICT_ADD_INT(GL_TEXTURE22); + PY_DICT_ADD_INT(GL_TEXTURE23); + PY_DICT_ADD_INT(GL_TEXTURE24); + PY_DICT_ADD_INT(GL_TEXTURE25); + PY_DICT_ADD_INT(GL_TEXTURE26); + PY_DICT_ADD_INT(GL_TEXTURE27); + PY_DICT_ADD_INT(GL_TEXTURE28); + PY_DICT_ADD_INT(GL_TEXTURE29); + PY_DICT_ADD_INT(GL_TEXTURE3); + PY_DICT_ADD_INT(GL_TEXTURE30); + PY_DICT_ADD_INT(GL_TEXTURE31); + PY_DICT_ADD_INT(GL_TEXTURE4); + PY_DICT_ADD_INT(GL_TEXTURE5); + PY_DICT_ADD_INT(GL_TEXTURE6); + PY_DICT_ADD_INT(GL_TEXTURE7); + PY_DICT_ADD_INT(GL_TEXTURE8); + PY_DICT_ADD_INT(GL_TEXTURE9); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_CUBE_MAP); + PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED); + PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED_IMAGE_SIZE); + PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSION_HINT); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_X); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y); + PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z); + } + /* adding in GL_VERSION_1_3 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_ADD_SIGNED); + PY_DICT_ADD_INT(GL_CLIENT_ACTIVE_TEXTURE); + PY_DICT_ADD_INT(GL_COMBINE); + PY_DICT_ADD_INT(GL_COMBINE_ALPHA); + PY_DICT_ADD_INT(GL_COMBINE_RGB); + PY_DICT_ADD_INT(GL_COMPRESSED_ALPHA); + PY_DICT_ADD_INT(GL_COMPRESSED_INTENSITY); + PY_DICT_ADD_INT(GL_COMPRESSED_LUMINANCE); + PY_DICT_ADD_INT(GL_COMPRESSED_LUMINANCE_ALPHA); + PY_DICT_ADD_INT(GL_CONSTANT); + PY_DICT_ADD_INT(GL_DOT3_RGB); + PY_DICT_ADD_INT(GL_DOT3_RGBA); + PY_DICT_ADD_INT(GL_INTERPOLATE); + PY_DICT_ADD_INT(GL_MAX_TEXTURE_UNITS); + PY_DICT_ADD_INT(GL_MULTISAMPLE_BIT); + PY_DICT_ADD_INT(GL_NORMAL_MAP); + PY_DICT_ADD_INT(GL_OPERAND0_ALPHA); + PY_DICT_ADD_INT(GL_OPERAND0_RGB); + PY_DICT_ADD_INT(GL_OPERAND1_ALPHA); + PY_DICT_ADD_INT(GL_OPERAND1_RGB); + PY_DICT_ADD_INT(GL_OPERAND2_ALPHA); + PY_DICT_ADD_INT(GL_OPERAND2_RGB); + PY_DICT_ADD_INT(GL_PREVIOUS); + PY_DICT_ADD_INT(GL_PRIMARY_COLOR); + PY_DICT_ADD_INT(GL_REFLECTION_MAP); + PY_DICT_ADD_INT(GL_RGB_SCALE); + PY_DICT_ADD_INT(GL_SOURCE0_ALPHA); + PY_DICT_ADD_INT(GL_SOURCE0_RGB); + PY_DICT_ADD_INT(GL_SOURCE1_ALPHA); + PY_DICT_ADD_INT(GL_SOURCE1_RGB); + PY_DICT_ADD_INT(GL_SOURCE2_ALPHA); + PY_DICT_ADD_INT(GL_SOURCE2_RGB); + PY_DICT_ADD_INT(GL_SUBTRACT); + PY_DICT_ADD_INT(GL_TRANSPOSE_COLOR_MATRIX); + PY_DICT_ADD_INT(GL_TRANSPOSE_MODELVIEW_MATRIX); + PY_DICT_ADD_INT(GL_TRANSPOSE_PROJECTION_MATRIX); + PY_DICT_ADD_INT(GL_TRANSPOSE_TEXTURE_MATRIX); + } + + + /* GL_VERSION_1_4 */ + { + PY_DICT_ADD_INT(GL_CONSTANT_ALPHA); + PY_DICT_ADD_INT(GL_CONSTANT_COLOR); + PY_DICT_ADD_INT(GL_FUNC_ADD); + PY_DICT_ADD_INT(GL_FUNC_REVERSE_SUBTRACT); + PY_DICT_ADD_INT(GL_FUNC_SUBTRACT); + PY_DICT_ADD_INT(GL_MAX); + PY_DICT_ADD_INT(GL_MIN); + PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_ALPHA); + PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_COLOR); + } + + + /* GL_VERSION_1_5 */ + { + PY_DICT_ADD_INT(GL_ARRAY_BUFFER); + PY_DICT_ADD_INT(GL_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_BUFFER_ACCESS); + PY_DICT_ADD_INT(GL_BUFFER_MAPPED); + PY_DICT_ADD_INT(GL_BUFFER_MAP_POINTER); + PY_DICT_ADD_INT(GL_BUFFER_SIZE); + PY_DICT_ADD_INT(GL_BUFFER_USAGE); + PY_DICT_ADD_INT(GL_CURRENT_QUERY); + PY_DICT_ADD_INT(GL_DYNAMIC_COPY); + PY_DICT_ADD_INT(GL_DYNAMIC_DRAW); + PY_DICT_ADD_INT(GL_DYNAMIC_READ); + PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER); + PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_QUERY_COUNTER_BITS); + PY_DICT_ADD_INT(GL_QUERY_RESULT); + PY_DICT_ADD_INT(GL_QUERY_RESULT_AVAILABLE); + PY_DICT_ADD_INT(GL_READ_ONLY); + PY_DICT_ADD_INT(GL_READ_WRITE); + PY_DICT_ADD_INT(GL_SAMPLES_PASSED); + PY_DICT_ADD_INT(GL_SRC1_ALPHA); + PY_DICT_ADD_INT(GL_STATIC_COPY); + PY_DICT_ADD_INT(GL_STATIC_DRAW); + PY_DICT_ADD_INT(GL_STATIC_READ); + PY_DICT_ADD_INT(GL_STREAM_COPY); + PY_DICT_ADD_INT(GL_STREAM_DRAW); + PY_DICT_ADD_INT(GL_STREAM_READ); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_WRITE_ONLY); + } + /* adding in GL_VERSION_1_5 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_COLOR_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_CURRENT_FOG_COORD); + PY_DICT_ADD_INT(GL_EDGE_FLAG_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_FOG_COORD); + PY_DICT_ADD_INT(GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_FOG_COORD_ARRAY); + PY_DICT_ADD_INT(GL_FOG_COORD_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_FOG_COORD_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_FOG_COORD_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_FOG_COORD_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_FOG_COORD_SRC); + PY_DICT_ADD_INT(GL_INDEX_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_NORMAL_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_SRC0_ALPHA); + PY_DICT_ADD_INT(GL_SRC0_RGB); + PY_DICT_ADD_INT(GL_SRC1_RGB); + PY_DICT_ADD_INT(GL_SRC2_ALPHA); + PY_DICT_ADD_INT(GL_SRC2_RGB); + PY_DICT_ADD_INT(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_WEIGHT_ARRAY_BUFFER_BINDING); + } + + + /* GL_VERSION_2_0 */ + { + PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTES); + PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH); + PY_DICT_ADD_INT(GL_ACTIVE_UNIFORMS); + PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_MAX_LENGTH); + PY_DICT_ADD_INT(GL_ATTACHED_SHADERS); + PY_DICT_ADD_INT(GL_BLEND_EQUATION_ALPHA); + PY_DICT_ADD_INT(GL_BLEND_EQUATION_RGB); + PY_DICT_ADD_INT(GL_BOOL); + PY_DICT_ADD_INT(GL_BOOL_VEC2); + PY_DICT_ADD_INT(GL_BOOL_VEC3); + PY_DICT_ADD_INT(GL_BOOL_VEC4); + PY_DICT_ADD_INT(GL_COMPILE_STATUS); + PY_DICT_ADD_INT(GL_CURRENT_PROGRAM); + PY_DICT_ADD_INT(GL_CURRENT_VERTEX_ATTRIB); + PY_DICT_ADD_INT(GL_DELETE_STATUS); + PY_DICT_ADD_INT(GL_DRAW_BUFFER0); + PY_DICT_ADD_INT(GL_DRAW_BUFFER1); + PY_DICT_ADD_INT(GL_DRAW_BUFFER10); + PY_DICT_ADD_INT(GL_DRAW_BUFFER11); + PY_DICT_ADD_INT(GL_DRAW_BUFFER12); + PY_DICT_ADD_INT(GL_DRAW_BUFFER13); + PY_DICT_ADD_INT(GL_DRAW_BUFFER14); + PY_DICT_ADD_INT(GL_DRAW_BUFFER15); + PY_DICT_ADD_INT(GL_DRAW_BUFFER2); + PY_DICT_ADD_INT(GL_DRAW_BUFFER3); + PY_DICT_ADD_INT(GL_DRAW_BUFFER4); + PY_DICT_ADD_INT(GL_DRAW_BUFFER5); + PY_DICT_ADD_INT(GL_DRAW_BUFFER6); + PY_DICT_ADD_INT(GL_DRAW_BUFFER7); + PY_DICT_ADD_INT(GL_DRAW_BUFFER8); + PY_DICT_ADD_INT(GL_DRAW_BUFFER9); + PY_DICT_ADD_INT(GL_FLOAT_MAT2); + PY_DICT_ADD_INT(GL_FLOAT_MAT3); + PY_DICT_ADD_INT(GL_FLOAT_MAT4); + PY_DICT_ADD_INT(GL_FLOAT_VEC2); + PY_DICT_ADD_INT(GL_FLOAT_VEC3); + PY_DICT_ADD_INT(GL_FLOAT_VEC4); + PY_DICT_ADD_INT(GL_FRAGMENT_SHADER); + PY_DICT_ADD_INT(GL_FRAGMENT_SHADER_DERIVATIVE_HINT); + PY_DICT_ADD_INT(GL_INFO_LOG_LENGTH); + PY_DICT_ADD_INT(GL_INT_VEC2); + PY_DICT_ADD_INT(GL_INT_VEC3); + PY_DICT_ADD_INT(GL_INT_VEC4); + PY_DICT_ADD_INT(GL_LINK_STATUS); + PY_DICT_ADD_INT(GL_LOWER_LEFT); + PY_DICT_ADD_INT(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); + PY_DICT_ADD_INT(GL_MAX_DRAW_BUFFERS); + PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS); + PY_DICT_ADD_INT(GL_MAX_TEXTURE_IMAGE_UNITS); + PY_DICT_ADD_INT(GL_MAX_VARYING_FLOATS); + PY_DICT_ADD_INT(GL_MAX_VERTEX_ATTRIBS); + PY_DICT_ADD_INT(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); + PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_COMPONENTS); + PY_DICT_ADD_INT(GL_POINT_SPRITE_COORD_ORIGIN); + PY_DICT_ADD_INT(GL_SAMPLER_1D); + PY_DICT_ADD_INT(GL_SAMPLER_1D_SHADOW); + PY_DICT_ADD_INT(GL_SAMPLER_2D); + PY_DICT_ADD_INT(GL_SAMPLER_2D_SHADOW); + PY_DICT_ADD_INT(GL_SAMPLER_3D); + PY_DICT_ADD_INT(GL_SAMPLER_CUBE); + PY_DICT_ADD_INT(GL_SHADER_SOURCE_LENGTH); + PY_DICT_ADD_INT(GL_SHADER_TYPE); + PY_DICT_ADD_INT(GL_SHADING_LANGUAGE_VERSION); + PY_DICT_ADD_INT(GL_STENCIL_BACK_FAIL); + PY_DICT_ADD_INT(GL_STENCIL_BACK_FUNC); + PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_FAIL); + PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_PASS); + PY_DICT_ADD_INT(GL_STENCIL_BACK_REF); + PY_DICT_ADD_INT(GL_STENCIL_BACK_VALUE_MASK); + PY_DICT_ADD_INT(GL_STENCIL_BACK_WRITEMASK); + PY_DICT_ADD_INT(GL_UPPER_LEFT); + PY_DICT_ADD_INT(GL_VALIDATE_STATUS); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_ENABLED); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_POINTER); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_SIZE); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_TYPE); + PY_DICT_ADD_INT(GL_VERTEX_PROGRAM_POINT_SIZE); + PY_DICT_ADD_INT(GL_VERTEX_SHADER); + } + /* adding in GL_VERSION_2_0 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_COORD_REPLACE); + PY_DICT_ADD_INT(GL_MAX_TEXTURE_COORDS); + PY_DICT_ADD_INT(GL_POINT_SPRITE); + PY_DICT_ADD_INT(GL_VERTEX_PROGRAM_TWO_SIDE); + } + + + /* GL_VERSION_2_1 */ + { + PY_DICT_ADD_INT(GL_COMPRESSED_SRGB); + PY_DICT_ADD_INT(GL_COMPRESSED_SRGB_ALPHA); + PY_DICT_ADD_INT(GL_FLOAT_MAT2x3); + PY_DICT_ADD_INT(GL_FLOAT_MAT2x4); + PY_DICT_ADD_INT(GL_FLOAT_MAT3x2); + PY_DICT_ADD_INT(GL_FLOAT_MAT3x4); + PY_DICT_ADD_INT(GL_FLOAT_MAT4x2); + PY_DICT_ADD_INT(GL_FLOAT_MAT4x3); + PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER); + PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER); + PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_SRGB); + PY_DICT_ADD_INT(GL_SRGB8); + PY_DICT_ADD_INT(GL_SRGB8_ALPHA8); + PY_DICT_ADD_INT(GL_SRGB_ALPHA); + } + /* adding in GL_VERSION_2_1 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_COMPRESSED_SLUMINANCE); + PY_DICT_ADD_INT(GL_COMPRESSED_SLUMINANCE_ALPHA); + PY_DICT_ADD_INT(GL_CURRENT_RASTER_SECONDARY_COLOR); + PY_DICT_ADD_INT(GL_SLUMINANCE); + PY_DICT_ADD_INT(GL_SLUMINANCE8); + PY_DICT_ADD_INT(GL_SLUMINANCE8_ALPHA8); + PY_DICT_ADD_INT(GL_SLUMINANCE_ALPHA); + } + + + /* GL_VERSION_3_0 */ + { + PY_DICT_ADD_INT(GL_VERTEX_ARRAY_BINDING); + } + /* adding in GL_VERSION_3_0 removed from core profile */ + if (use_deprecated == true) { + PY_DICT_ADD_INT(GL_ALPHA_INTEGER); + PY_DICT_ADD_INT(GL_CLAMP_FRAGMENT_COLOR); + PY_DICT_ADD_INT(GL_CLAMP_VERTEX_COLOR); + } + + + /* GL_VERSION_3_1 */ + { + PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCKS); + PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH); + PY_DICT_ADD_INT(GL_INVALID_INDEX); + PY_DICT_ADD_INT(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS); + PY_DICT_ADD_INT(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS); + PY_DICT_ADD_INT(GL_MAX_COMBINED_UNIFORM_BLOCKS); + PY_DICT_ADD_INT(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS); + PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_BLOCKS); + PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_BLOCKS); + PY_DICT_ADD_INT(GL_MAX_UNIFORM_BLOCK_SIZE); + PY_DICT_ADD_INT(GL_MAX_UNIFORM_BUFFER_BINDINGS); + PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_BLOCKS); + PY_DICT_ADD_INT(GL_UNIFORM_ARRAY_STRIDE); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_BINDING); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_DATA_SIZE); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_INDEX); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_NAME_LENGTH); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER); + PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER); + PY_DICT_ADD_INT(GL_UNIFORM_BUFFER); + PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_BINDING); + PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT); + PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_SIZE); + PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_START); + PY_DICT_ADD_INT(GL_UNIFORM_IS_ROW_MAJOR); + PY_DICT_ADD_INT(GL_UNIFORM_MATRIX_STRIDE); + PY_DICT_ADD_INT(GL_UNIFORM_NAME_LENGTH); + PY_DICT_ADD_INT(GL_UNIFORM_OFFSET); + PY_DICT_ADD_INT(GL_UNIFORM_SIZE); + PY_DICT_ADD_INT(GL_UNIFORM_TYPE); + } + + + /* GL_VERSION_3_2 */ + { + PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY); + PY_DICT_ADD_INT(GL_MAX_COLOR_TEXTURE_SAMPLES); + PY_DICT_ADD_INT(GL_MAX_DEPTH_TEXTURE_SAMPLES); + PY_DICT_ADD_INT(GL_MAX_INTEGER_SAMPLES); + PY_DICT_ADD_INT(GL_MAX_SAMPLE_MASK_WORDS); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY); + PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE_ARRAY); + PY_DICT_ADD_INT(GL_SAMPLE_MASK); + PY_DICT_ADD_INT(GL_SAMPLE_MASK_VALUE); + PY_DICT_ADD_INT(GL_SAMPLE_POSITION); + PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE_ARRAY); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY); + PY_DICT_ADD_INT(GL_TEXTURE_FIXED_SAMPLE_LOCATIONS); + PY_DICT_ADD_INT(GL_TEXTURE_SAMPLES); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE); + PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY); + } + return submodule; } @@ -1928,3 +3309,5 @@ static PyObject *Method_ShaderSource(PyObject *UNUSED(self), PyObject *args) return Py_INCREF(Py_None), Py_None; } + +/** \} */
\ No newline at end of file |