3747 lines
145 KiB
C
3747 lines
145 KiB
C
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* Contributor(s): Willian P. Germano, Campbell Barton
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/** \file blender/python/generic/bgl.c
|
|
* \ingroup pygen
|
|
*
|
|
* This file is the 'bgl' module which wraps OpenGL functions and constants,
|
|
* allowing script writers to make OpenGL calls in their Python scripts.
|
|
*
|
|
* \note
|
|
* This module is very similar to 'PyOpenGL' which could replace 'bgl' one day.
|
|
*/
|
|
|
|
#include <Python.h>
|
|
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "GPU_glew.h"
|
|
#include "MEM_guardedalloc.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; */
|
|
#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)
|
|
|
|
/* 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);
|
|
|
|
/* Buffer sequence methods */
|
|
|
|
static int Buffer_len(Buffer *self);
|
|
static PyObject *Buffer_item(Buffer *self, int i);
|
|
static PyObject *Buffer_slice(Buffer *self, int begin, int end);
|
|
static int Buffer_ass_item(Buffer *self, int i, PyObject *v);
|
|
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;
|
|
}
|
|
|
|
static int gl_buffer_type_from_py_buffer(Py_buffer *pybuffer)
|
|
{
|
|
char *typestr = pybuffer->format;
|
|
Py_ssize_t itemsize = pybuffer->itemsize;
|
|
|
|
if (ELEM(typestr[0], '<', '>', '|')) {
|
|
typestr += 1;
|
|
}
|
|
|
|
switch (typestr[0]) {
|
|
case 't':
|
|
case 'b':
|
|
case 'h':
|
|
case 'i':
|
|
case 'l':
|
|
if (itemsize == 1) return GL_BYTE;
|
|
if (itemsize == 2) return GL_SHORT;
|
|
if (itemsize == 4) return GL_INT;
|
|
break;
|
|
case 'f':
|
|
case 'd':
|
|
if (itemsize == 4) return GL_FLOAT;
|
|
if (itemsize == 8) return GL_DOUBLE;
|
|
break;
|
|
}
|
|
return -1; /* UNKNOWN */
|
|
}
|
|
|
|
static bool compare_dimensions(int ndim, int *dim1, Py_ssize_t *dim2)
|
|
{
|
|
for (int i = 0; i < ndim; i++) {
|
|
if (dim1[i] != dim2[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** \} */
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \name Buffer API
|
|
* \{ */
|
|
|
|
static PySequenceMethods Buffer_SeqMethods = {
|
|
(lenfunc) Buffer_len, /*sq_length */
|
|
(binaryfunc) NULL, /*sq_concat */
|
|
(ssizeargfunc) NULL, /*sq_repeat */
|
|
(ssizeargfunc) Buffer_item, /*sq_item */
|
|
(ssizessizeargfunc) NULL, /*sq_slice, deprecated, handled in Buffer_item */
|
|
(ssizeobjargproc) Buffer_ass_item, /*sq_ass_item */
|
|
(ssizessizeobjargproc) NULL, /*sq_ass_slice, deprecated handled in Buffer_ass_item */
|
|
(objobjproc) NULL, /* sq_contains */
|
|
(binaryfunc) NULL, /* sq_inplace_concat */
|
|
(ssizeargfunc) NULL, /* sq_inplace_repeat */
|
|
};
|
|
|
|
|
|
static PyMappingMethods Buffer_AsMapping = {
|
|
(lenfunc)Buffer_len,
|
|
(binaryfunc)Buffer_subscript,
|
|
(objobjargproc)Buffer_ass_subscript
|
|
};
|
|
|
|
static void Buffer_dealloc(Buffer *self);
|
|
static PyObject *Buffer_repr(Buffer *self);
|
|
|
|
static PyObject *Buffer_to_list(Buffer *self)
|
|
{
|
|
int i, len = self->dimensions[0];
|
|
PyObject *list = PyList_New(len);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
PyList_SET_ITEM(list, i, Buffer_item(self, i));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static PyObject *Buffer_to_list_recursive(Buffer *self)
|
|
{
|
|
PyObject *list;
|
|
|
|
if (self->ndimensions > 1) {
|
|
int i, len = self->dimensions[0];
|
|
list = PyList_New(len);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
Buffer *sub = (Buffer *)Buffer_item(self, i);
|
|
PyList_SET_ITEM(list, i, Buffer_to_list_recursive(sub));
|
|
Py_DECREF(sub);
|
|
}
|
|
}
|
|
else {
|
|
list = Buffer_to_list(self);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static PyObject *Buffer_dimensions(Buffer *self, void *UNUSED(arg))
|
|
{
|
|
PyObject *list = PyList_New(self->ndimensions);
|
|
int i;
|
|
|
|
for (i = 0; i < self->ndimensions; i++) {
|
|
PyList_SET_ITEM(list, i, PyLong_FromLong(self->dimensions[i]));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static PyMethodDef Buffer_methods[] = {
|
|
{"to_list", (PyCFunction)Buffer_to_list_recursive, METH_NOARGS,
|
|
"return the buffer as a list"},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
static PyGetSetDef Buffer_getseters[] = {
|
|
{(char *)"dimensions", (getter)Buffer_dimensions, NULL, NULL, NULL},
|
|
{NULL, NULL, NULL, NULL, NULL}
|
|
};
|
|
|
|
|
|
PyTypeObject BGL_bufferType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"bgl.Buffer", /*tp_name */
|
|
sizeof(Buffer), /*tp_basicsize */
|
|
0, /*tp_itemsize */
|
|
(destructor)Buffer_dealloc, /*tp_dealloc */
|
|
(printfunc)NULL, /*tp_print */
|
|
NULL, /*tp_getattr */
|
|
NULL, /*tp_setattr */
|
|
NULL, /*tp_compare */
|
|
(reprfunc) Buffer_repr, /*tp_repr */
|
|
NULL, /*tp_as_number */
|
|
&Buffer_SeqMethods, /*tp_as_sequence */
|
|
&Buffer_AsMapping, /* PyMappingMethods *tp_as_mapping; */
|
|
|
|
/* More standard operations (here for binary compatibility) */
|
|
|
|
NULL, /* hashfunc tp_hash; */
|
|
NULL, /* ternaryfunc tp_call; */
|
|
NULL, /* reprfunc tp_str; */
|
|
NULL, /* getattrofunc tp_getattro; */
|
|
NULL, /* setattrofunc tp_setattro; */
|
|
|
|
/* Functions to access object as input/output buffer */
|
|
NULL, /* PyBufferProcs *tp_as_buffer; */
|
|
|
|
/*** Flags to define presence of optional/expanded features ***/
|
|
Py_TPFLAGS_DEFAULT, /* long tp_flags; */
|
|
|
|
NULL, /* char *tp_doc; Documentation string */
|
|
/*** Assigned meaning in release 2.0 ***/
|
|
/* call function for all accessible objects */
|
|
NULL, /* traverseproc tp_traverse; */
|
|
|
|
/* delete references to contained objects */
|
|
NULL, /* inquiry tp_clear; */
|
|
|
|
/*** Assigned meaning in release 2.1 ***/
|
|
/*** rich comparisons ***/
|
|
NULL, /* richcmpfunc tp_richcompare; */
|
|
|
|
/*** weak reference enabler ***/
|
|
0, /* long tp_weaklistoffset; */
|
|
|
|
/*** Added in release 2.2 ***/
|
|
/* Iterators */
|
|
NULL, /* getiterfunc tp_iter; */
|
|
NULL, /* iternextfunc tp_iternext; */
|
|
/*** Attribute descriptor and subclassing stuff ***/
|
|
Buffer_methods, /* struct PyMethodDef *tp_methods; */
|
|
NULL, /* struct PyMemberDef *tp_members; */
|
|
Buffer_getseters, /* struct PyGetSetDef *tp_getset; */
|
|
NULL, /*tp_base*/
|
|
NULL, /*tp_dict*/
|
|
NULL, /*tp_descr_get*/
|
|
NULL, /*tp_descr_set*/
|
|
0, /*tp_dictoffset*/
|
|
NULL, /*tp_init*/
|
|
NULL, /*tp_alloc*/
|
|
Buffer_new, /*tp_new*/
|
|
NULL, /*tp_free*/
|
|
NULL, /*tp_is_gc*/
|
|
NULL, /*tp_bases*/
|
|
NULL, /*tp_mro*/
|
|
NULL, /*tp_cache*/
|
|
NULL, /*tp_subclasses*/
|
|
NULL, /*tp_weaklist*/
|
|
NULL /*tp_del*/
|
|
};
|
|
|
|
|
|
static Buffer *BGL_MakeBuffer_FromData(PyObject *parent, int type, int ndimensions, int *dimensions, void *buf)
|
|
{
|
|
Buffer *buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType);
|
|
|
|
Py_XINCREF(parent);
|
|
buffer->parent = parent;
|
|
buffer->ndimensions = ndimensions;
|
|
buffer->dimensions = MEM_mallocN(ndimensions * sizeof(int), "Buffer dimensions");
|
|
memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int));
|
|
buffer->type = type;
|
|
buffer->buf.asvoid = buf;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
void *buf = NULL;
|
|
int i, size = BGL_typeSize(type);
|
|
|
|
for (i = 0; i < ndimensions; i++) {
|
|
size *= dimensions[i];
|
|
}
|
|
|
|
buf = MEM_mallocN(size, "Buffer buffer");
|
|
|
|
buffer = BGL_MakeBuffer_FromData(NULL, type, ndimensions, dimensions, buf);
|
|
|
|
if (initbuffer) {
|
|
memcpy(buffer->buf.asvoid, initbuffer, size);
|
|
}
|
|
else {
|
|
memset(buffer->buf.asvoid, 0, size);
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
|
|
#define MAX_DIMENSIONS 256
|
|
static PyObject *Buffer_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
|
|
{
|
|
PyObject *length_ob = NULL, *init = NULL;
|
|
Buffer *buffer = NULL;
|
|
int dimensions[MAX_DIMENSIONS];
|
|
|
|
int type;
|
|
Py_ssize_t i, ndimensions = 0;
|
|
|
|
if (kwds && PyDict_Size(kwds)) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"bgl.Buffer(): takes no keyword args");
|
|
return NULL;
|
|
}
|
|
|
|
if (!PyArg_ParseTuple(args, "iO|O: bgl.Buffer", &type, &length_ob, &init)) {
|
|
return NULL;
|
|
}
|
|
if (!ELEM(type, GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE)) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"invalid first argument type, should be one of "
|
|
"GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE");
|
|
return NULL;
|
|
}
|
|
|
|
if (PyLong_Check(length_ob)) {
|
|
ndimensions = 1;
|
|
if (((dimensions[0] = PyLong_AsLong(length_ob)) < 1)) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
|
|
return NULL;
|
|
}
|
|
}
|
|
else if (PySequence_Check(length_ob)) {
|
|
ndimensions = PySequence_Size(length_ob);
|
|
if (ndimensions > MAX_DIMENSIONS) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"too many dimensions, max is "STRINGIFY(MAX_DIMENSIONS));
|
|
return NULL;
|
|
}
|
|
else if (ndimensions < 1) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"sequence must have at least one dimension");
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < ndimensions; i++) {
|
|
PyObject *ob = PySequence_GetItem(length_ob, i);
|
|
|
|
if (!PyLong_Check(ob))
|
|
dimensions[i] = 1;
|
|
else
|
|
dimensions[i] = PyLong_AsLong(ob);
|
|
Py_DECREF(ob);
|
|
|
|
if (dimensions[i] < 1) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"dimensions must be between 1 and "STRINGIFY(MAX_DIMENSIONS));
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"invalid second argument argument expected a sequence "
|
|
"or an int, not a %.200s", Py_TYPE(length_ob)->tp_name);
|
|
return NULL;
|
|
}
|
|
|
|
if (init && PyObject_CheckBuffer(init)) {
|
|
Py_buffer pybuffer;
|
|
|
|
if (PyObject_GetBuffer(init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) {
|
|
/* PyObject_GetBuffer raise a PyExc_BufferError */
|
|
return NULL;
|
|
}
|
|
|
|
if (type != gl_buffer_type_from_py_buffer(&pybuffer)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"`GL_TYPE` and `typestr` of object with buffer interface do not match. '%s'", pybuffer.format);
|
|
}
|
|
else if (ndimensions != pybuffer.ndim ||
|
|
!compare_dimensions(ndimensions, dimensions, pybuffer.shape))
|
|
{
|
|
PyErr_Format(PyExc_TypeError, "array size does not match");
|
|
}
|
|
else {
|
|
buffer = BGL_MakeBuffer_FromData(init, type, pybuffer.ndim, dimensions, pybuffer.buf);
|
|
}
|
|
|
|
PyBuffer_Release(&pybuffer);
|
|
}
|
|
else {
|
|
buffer = BGL_MakeBuffer(type, ndimensions, dimensions, NULL);
|
|
if (init && Buffer_ass_slice(buffer, 0, dimensions[0], init)) {
|
|
Py_DECREF(buffer);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return (PyObject *)buffer;
|
|
}
|
|
|
|
/* Buffer sequence methods */
|
|
|
|
static int Buffer_len(Buffer *self)
|
|
{
|
|
return self->dimensions[0];
|
|
}
|
|
|
|
static PyObject *Buffer_item(Buffer *self, int i)
|
|
{
|
|
if (i >= self->dimensions[0] || i < 0) {
|
|
PyErr_SetString(PyExc_IndexError, "array index out of range");
|
|
return NULL;
|
|
}
|
|
|
|
if (self->ndimensions == 1) {
|
|
switch (self->type) {
|
|
case GL_BYTE: return Py_BuildValue("b", self->buf.asbyte[i]);
|
|
case GL_SHORT: return Py_BuildValue("h", self->buf.asshort[i]);
|
|
case GL_INT: return Py_BuildValue("i", self->buf.asint[i]);
|
|
case GL_FLOAT: return PyFloat_FromDouble(self->buf.asfloat[i]);
|
|
case GL_DOUBLE: return Py_BuildValue("d", self->buf.asdouble[i]);
|
|
}
|
|
}
|
|
else {
|
|
int j, offset = i * BGL_typeSize(self->type);
|
|
|
|
for (j = 1; j < self->ndimensions; j++) {
|
|
offset *= self->dimensions[j];
|
|
}
|
|
|
|
return (PyObject *)BGL_MakeBuffer_FromData(
|
|
(PyObject *)self, self->type,
|
|
self->ndimensions - 1,
|
|
self->dimensions + 1,
|
|
self->buf.asbyte + offset);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *Buffer_slice(Buffer *self, int begin, int end)
|
|
{
|
|
PyObject *list;
|
|
int count;
|
|
|
|
if (begin < 0) begin = 0;
|
|
if (end > self->dimensions[0]) end = self->dimensions[0];
|
|
if (begin > end) begin = end;
|
|
|
|
list = PyList_New(end - begin);
|
|
|
|
for (count = begin; count < end; count++) {
|
|
PyList_SET_ITEM(list, count - begin, Buffer_item(self, count));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
static int Buffer_ass_item(Buffer *self, int i, PyObject *v)
|
|
{
|
|
if (i >= self->dimensions[0] || i < 0) {
|
|
PyErr_SetString(PyExc_IndexError,
|
|
"array assignment index out of range");
|
|
return -1;
|
|
}
|
|
|
|
if (self->ndimensions != 1) {
|
|
Buffer *row = (Buffer *)Buffer_item(self, i);
|
|
|
|
if (row) {
|
|
int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v);
|
|
Py_DECREF(row);
|
|
return ret;
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
switch (self->type) {
|
|
case GL_BYTE: return PyArg_Parse(v, "b:Expected ints", &self->buf.asbyte[i]) ? 0 : -1;
|
|
case GL_SHORT: return PyArg_Parse(v, "h:Expected ints", &self->buf.asshort[i]) ? 0 : -1;
|
|
case GL_INT: return PyArg_Parse(v, "i:Expected ints", &self->buf.asint[i]) ? 0 : -1;
|
|
case GL_FLOAT: return PyArg_Parse(v, "f:Expected floats", &self->buf.asfloat[i]) ? 0 : -1;
|
|
case GL_DOUBLE: return PyArg_Parse(v, "d:Expected floats", &self->buf.asdouble[i]) ? 0 : -1;
|
|
default: return 0; /* should never happen */
|
|
}
|
|
}
|
|
|
|
static int Buffer_ass_slice(Buffer *self, int begin, int end, PyObject *seq)
|
|
{
|
|
PyObject *item;
|
|
int count, err = 0;
|
|
|
|
if (begin < 0) begin = 0;
|
|
if (end > self->dimensions[0]) end = self->dimensions[0];
|
|
if (begin > end) begin = end;
|
|
|
|
if (!PySequence_Check(seq)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"buffer[:] = value, invalid assignment. "
|
|
"Expected a sequence, not an %.200s type",
|
|
Py_TYPE(seq)->tp_name);
|
|
return -1;
|
|
}
|
|
|
|
/* re-use count var */
|
|
if ((count = PySequence_Size(seq)) != (end - begin)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"buffer[:] = value, size mismatch in assignment. "
|
|
"Expected: %d (given: %d)", count, end - begin);
|
|
return -1;
|
|
}
|
|
|
|
for (count = begin; count < end; count++) {
|
|
item = PySequence_GetItem(seq, count - begin);
|
|
if (item) {
|
|
err = Buffer_ass_item(self, count, item);
|
|
Py_DECREF(item);
|
|
}
|
|
else {
|
|
err = -1;
|
|
}
|
|
if (err) {
|
|
break;
|
|
}
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static PyObject *Buffer_subscript(Buffer *self, PyObject *item)
|
|
{
|
|
if (PyIndex_Check(item)) {
|
|
Py_ssize_t i;
|
|
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
|
if (i == -1 && PyErr_Occurred())
|
|
return NULL;
|
|
if (i < 0)
|
|
i += self->dimensions[0];
|
|
return Buffer_item(self, i);
|
|
}
|
|
else if (PySlice_Check(item)) {
|
|
Py_ssize_t start, stop, step, slicelength;
|
|
|
|
if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
|
|
return NULL;
|
|
|
|
if (slicelength <= 0) {
|
|
return PyTuple_New(0);
|
|
}
|
|
else if (step == 1) {
|
|
return Buffer_slice(self, start, stop);
|
|
}
|
|
else {
|
|
PyErr_SetString(PyExc_IndexError,
|
|
"slice steps not supported with vectors");
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"buffer indices must be integers, not %.200s",
|
|
Py_TYPE(item)->tp_name);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value)
|
|
{
|
|
if (PyIndex_Check(item)) {
|
|
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
|
if (i == -1 && PyErr_Occurred())
|
|
return -1;
|
|
if (i < 0)
|
|
i += self->dimensions[0];
|
|
return Buffer_ass_item(self, i, value);
|
|
}
|
|
else if (PySlice_Check(item)) {
|
|
Py_ssize_t start, stop, step, slicelength;
|
|
|
|
if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0)
|
|
return -1;
|
|
|
|
if (step == 1)
|
|
return Buffer_ass_slice(self, start, stop, value);
|
|
else {
|
|
PyErr_SetString(PyExc_IndexError,
|
|
"slice steps not supported with vectors");
|
|
return -1;
|
|
}
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"buffer indices must be integers, not %.200s",
|
|
Py_TYPE(item)->tp_name);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
static void Buffer_dealloc(Buffer *self)
|
|
{
|
|
if (self->parent) {
|
|
Py_DECREF(self->parent);
|
|
}
|
|
else {
|
|
MEM_freeN(self->buf.asvoid);
|
|
}
|
|
|
|
MEM_freeN(self->dimensions);
|
|
|
|
PyObject_DEL(self);
|
|
}
|
|
|
|
|
|
static PyObject *Buffer_repr(Buffer *self)
|
|
{
|
|
PyObject *list = Buffer_to_list_recursive(self);
|
|
PyObject *repr;
|
|
const char *typestr;
|
|
|
|
switch (self->type) {
|
|
case GL_BYTE: typestr = "GL_BYTE"; break;
|
|
case GL_SHORT: typestr = "GL_SHORT"; break;
|
|
case GL_INT: typestr = "GL_INT"; break;
|
|
case GL_FLOAT: typestr = "GL_FLOAT"; break;
|
|
case GL_DOUBLE: typestr = "GL_DOUBLE"; break;
|
|
default: typestr = "UNKNOWN"; break;
|
|
}
|
|
|
|
repr = PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list);
|
|
Py_DECREF(list);
|
|
|
|
return repr;
|
|
}
|
|
|
|
/** \} */
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \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, GLstring))
|
|
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, GLstring))
|
|
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, GLstring))
|
|
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, GLstring))
|
|
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}
|
|
|
|
static struct PyMethodDef BGL_methods[] = {
|
|
MethodDefu(Perspective),
|
|
MethodDefu(LookAt),
|
|
MethodDefu(Ortho2D),
|
|
MethodDefu(PickMatrix),
|
|
MethodDefu(Project),
|
|
MethodDefu(UnProject),
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
#undef MethodDefu
|
|
|
|
static struct PyModuleDef BGL_module_def = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"bgl", /* m_name */
|
|
NULL, /* m_doc */
|
|
0, /* m_size */
|
|
BGL_methods, /* m_methods */
|
|
NULL, /* m_reload */
|
|
NULL, /* m_traverse */
|
|
NULL, /* m_clear */
|
|
NULL, /* m_free */
|
|
};
|
|
|
|
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_int64(PyObject *dict, const char *name, int64_t value)
|
|
{
|
|
PyObject *item;
|
|
PyDict_SetItemString(dict, name, item = PyLong_FromLongLong(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;
|
|
submodule = PyModule_Create(&BGL_module_def);
|
|
dict = PyModule_GetDict(submodule);
|
|
|
|
if (PyType_Ready(&BGL_bufferType) < 0)
|
|
return NULL; /* should never happen */
|
|
|
|
PyModule_AddObject(submodule, "Buffer", (PyObject *)&BGL_bufferType);
|
|
Py_INCREF((PyObject *)&BGL_bufferType);
|
|
|
|
/* needed since some function pointers won't be NULL */
|
|
#ifdef __GNUC__
|
|
# pragma GCC diagnostic ignored "-Waddress"
|
|
#endif
|
|
|
|
#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)
|
|
#define PY_DICT_ADD_INT64(x) py_module_dict_add_int64(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_BLEND_DST_ALPHA);
|
|
PY_DICT_ADD_INT(GL_BLEND_DST_RGB);
|
|
PY_DICT_ADD_INT(GL_BLEND_SRC_ALPHA);
|
|
PY_DICT_ADD_INT(GL_BLEND_SRC_RGB);
|
|
PY_DICT_ADD_INT(GL_CONSTANT_ALPHA);
|
|
PY_DICT_ADD_INT(GL_CONSTANT_COLOR);
|
|
PY_DICT_ADD_INT(GL_DECR_WRAP);
|
|
PY_DICT_ADD_INT(GL_DEPTH_COMPONENT16);
|
|
PY_DICT_ADD_INT(GL_DEPTH_COMPONENT24);
|
|
PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32);
|
|
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_INCR_WRAP);
|
|
PY_DICT_ADD_INT(GL_MAX);
|
|
PY_DICT_ADD_INT(GL_MAX_TEXTURE_LOD_BIAS);
|
|
PY_DICT_ADD_INT(GL_MIN);
|
|
PY_DICT_ADD_INT(GL_MIRRORED_REPEAT);
|
|
PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_ALPHA);
|
|
PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_COLOR);
|
|
PY_DICT_ADD_INT(GL_POINT_FADE_THRESHOLD_SIZE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_FUNC);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_MODE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_SIZE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_LOD_BIAS);
|
|
}
|
|
/* adding in GL_VERSION_1_4 removed from core profile */
|
|
if (use_deprecated == true) {
|
|
PY_DICT_ADD_INT(GL_COLOR_SUM);
|
|
PY_DICT_ADD_INT(GL_COMPARE_R_TO_TEXTURE);
|
|
PY_DICT_ADD_INT(GL_CURRENT_FOG_COORDINATE);
|
|
PY_DICT_ADD_INT(GL_CURRENT_SECONDARY_COLOR);
|
|
PY_DICT_ADD_INT(GL_DEPTH_TEXTURE_MODE);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE_ARRAY);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE_ARRAY_POINTER);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE_ARRAY_STRIDE);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE_ARRAY_TYPE);
|
|
PY_DICT_ADD_INT(GL_FOG_COORDINATE_SOURCE);
|
|
PY_DICT_ADD_INT(GL_FRAGMENT_DEPTH);
|
|
PY_DICT_ADD_INT(GL_GENERATE_MIPMAP);
|
|
PY_DICT_ADD_INT(GL_GENERATE_MIPMAP_HINT);
|
|
PY_DICT_ADD_INT(GL_POINT_DISTANCE_ATTENUATION);
|
|
PY_DICT_ADD_INT(GL_POINT_SIZE_MAX);
|
|
PY_DICT_ADD_INT(GL_POINT_SIZE_MIN);
|
|
PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY);
|
|
PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY_POINTER);
|
|
PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY_SIZE);
|
|
PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY_STRIDE);
|
|
PY_DICT_ADD_INT(GL_SECONDARY_COLOR_ARRAY_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_FILTER_CONTROL);
|
|
}
|
|
|
|
|
|
/* 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_BGRA_INTEGER);
|
|
PY_DICT_ADD_INT(GL_BGR_INTEGER);
|
|
PY_DICT_ADD_INT(GL_BLUE_INTEGER);
|
|
PY_DICT_ADD_INT(GL_BUFFER_ACCESS_FLAGS);
|
|
PY_DICT_ADD_INT(GL_BUFFER_MAP_LENGTH);
|
|
PY_DICT_ADD_INT(GL_BUFFER_MAP_OFFSET);
|
|
PY_DICT_ADD_INT(GL_CLAMP_READ_COLOR);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE0);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE1);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE2);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE3);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE4);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE5);
|
|
#if 0
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE6);
|
|
PY_DICT_ADD_INT(GL_CLIP_DISTANCE7);
|
|
#endif
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT0);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT1);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT2);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT3);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT4);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT5);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT6);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT7);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT8);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT9);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT10);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT11);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT12);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT13);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT14);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT15);
|
|
#if 0
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT16);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT17);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT18);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT19);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT20);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT21);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT22);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT23);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT24);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT25);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT26);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT27);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT28);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT29);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT30);
|
|
PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT31);
|
|
#endif
|
|
PY_DICT_ADD_INT(GL_COMPARE_REF_TO_TEXTURE);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_RED);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_RED_RGTC1);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_RG);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_RG_RGTC2);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RED_RGTC1);
|
|
PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RG_RGTC2);
|
|
PY_DICT_ADD_INT(GL_CONTEXT_FLAGS);
|
|
PY_DICT_ADD_INT(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT);
|
|
PY_DICT_ADD_INT(GL_DEPTH24_STENCIL8);
|
|
PY_DICT_ADD_INT(GL_DEPTH32F_STENCIL8);
|
|
PY_DICT_ADD_INT(GL_DEPTH_ATTACHMENT);
|
|
PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32F);
|
|
PY_DICT_ADD_INT(GL_DEPTH_STENCIL);
|
|
PY_DICT_ADD_INT(GL_DEPTH_STENCIL_ATTACHMENT);
|
|
PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER);
|
|
PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER_BINDING);
|
|
PY_DICT_ADD_INT(GL_FIXED_ONLY);
|
|
PY_DICT_ADD_INT(GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_BINDING);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_COMPLETE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_DEFAULT);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_SRGB);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNDEFINED);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNSUPPORTED);
|
|
PY_DICT_ADD_INT(GL_GREEN_INTEGER);
|
|
PY_DICT_ADD_INT(GL_HALF_FLOAT);
|
|
PY_DICT_ADD_INT(GL_INDEX);
|
|
PY_DICT_ADD_INT(GL_INTERLEAVED_ATTRIBS);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_1D);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_2D);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_3D);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_CUBE);
|
|
PY_DICT_ADD_INT(GL_INVALID_FRAMEBUFFER_OPERATION);
|
|
PY_DICT_ADD_INT(GL_MAJOR_VERSION);
|
|
PY_DICT_ADD_INT(GL_MAP_FLUSH_EXPLICIT_BIT);
|
|
PY_DICT_ADD_INT(GL_MAP_INVALIDATE_BUFFER_BIT);
|
|
PY_DICT_ADD_INT(GL_MAP_INVALIDATE_RANGE_BIT);
|
|
PY_DICT_ADD_INT(GL_MAP_READ_BIT);
|
|
PY_DICT_ADD_INT(GL_MAP_UNSYNCHRONIZED_BIT);
|
|
PY_DICT_ADD_INT(GL_MAP_WRITE_BIT);
|
|
PY_DICT_ADD_INT(GL_MAX_ARRAY_TEXTURE_LAYERS);
|
|
PY_DICT_ADD_INT(GL_MAX_CLIP_DISTANCES);
|
|
PY_DICT_ADD_INT(GL_MAX_COLOR_ATTACHMENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_PROGRAM_TEXEL_OFFSET);
|
|
PY_DICT_ADD_INT(GL_MAX_RENDERBUFFER_SIZE);
|
|
PY_DICT_ADD_INT(GL_MAX_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
|
|
PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_VARYING_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MINOR_VERSION);
|
|
PY_DICT_ADD_INT(GL_MIN_PROGRAM_TEXEL_OFFSET);
|
|
PY_DICT_ADD_INT(GL_NUM_EXTENSIONS);
|
|
PY_DICT_ADD_INT(GL_PRIMITIVES_GENERATED);
|
|
PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_QUERY_BY_REGION_NO_WAIT);
|
|
PY_DICT_ADD_INT(GL_QUERY_BY_REGION_WAIT);
|
|
PY_DICT_ADD_INT(GL_QUERY_NO_WAIT);
|
|
PY_DICT_ADD_INT(GL_QUERY_WAIT);
|
|
PY_DICT_ADD_INT(GL_R11F_G11F_B10F);
|
|
PY_DICT_ADD_INT(GL_R16);
|
|
PY_DICT_ADD_INT(GL_R16F);
|
|
PY_DICT_ADD_INT(GL_R16I);
|
|
PY_DICT_ADD_INT(GL_R16UI);
|
|
PY_DICT_ADD_INT(GL_R32F);
|
|
PY_DICT_ADD_INT(GL_R32I);
|
|
PY_DICT_ADD_INT(GL_R32UI);
|
|
PY_DICT_ADD_INT(GL_R8);
|
|
PY_DICT_ADD_INT(GL_R8I);
|
|
PY_DICT_ADD_INT(GL_R8UI);
|
|
PY_DICT_ADD_INT(GL_RASTERIZER_DISCARD);
|
|
PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER);
|
|
PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER_BINDING);
|
|
PY_DICT_ADD_INT(GL_RED_INTEGER);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_ALPHA_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_BINDING);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_BLUE_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_DEPTH_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_GREEN_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_HEIGHT);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_INTERNAL_FORMAT);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_RED_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_STENCIL_SIZE);
|
|
PY_DICT_ADD_INT(GL_RENDERBUFFER_WIDTH);
|
|
PY_DICT_ADD_INT(GL_RG);
|
|
PY_DICT_ADD_INT(GL_RG16);
|
|
PY_DICT_ADD_INT(GL_RG16F);
|
|
PY_DICT_ADD_INT(GL_RG16I);
|
|
PY_DICT_ADD_INT(GL_RG16UI);
|
|
PY_DICT_ADD_INT(GL_RG32F);
|
|
PY_DICT_ADD_INT(GL_RG32I);
|
|
PY_DICT_ADD_INT(GL_RG32UI);
|
|
PY_DICT_ADD_INT(GL_RG8);
|
|
PY_DICT_ADD_INT(GL_RG8I);
|
|
PY_DICT_ADD_INT(GL_RG8UI);
|
|
PY_DICT_ADD_INT(GL_RGB16F);
|
|
PY_DICT_ADD_INT(GL_RGB16I);
|
|
PY_DICT_ADD_INT(GL_RGB16UI);
|
|
PY_DICT_ADD_INT(GL_RGB32F);
|
|
PY_DICT_ADD_INT(GL_RGB32I);
|
|
PY_DICT_ADD_INT(GL_RGB32UI);
|
|
PY_DICT_ADD_INT(GL_RGB8I);
|
|
PY_DICT_ADD_INT(GL_RGB8UI);
|
|
PY_DICT_ADD_INT(GL_RGB9_E5);
|
|
PY_DICT_ADD_INT(GL_RGBA16F);
|
|
PY_DICT_ADD_INT(GL_RGBA16I);
|
|
PY_DICT_ADD_INT(GL_RGBA16UI);
|
|
PY_DICT_ADD_INT(GL_RGBA32F);
|
|
PY_DICT_ADD_INT(GL_RGBA32I);
|
|
PY_DICT_ADD_INT(GL_RGBA32UI);
|
|
PY_DICT_ADD_INT(GL_RGBA8I);
|
|
PY_DICT_ADD_INT(GL_RGBA8UI);
|
|
PY_DICT_ADD_INT(GL_RGBA_INTEGER);
|
|
PY_DICT_ADD_INT(GL_RGB_INTEGER);
|
|
PY_DICT_ADD_INT(GL_RG_INTEGER);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY_SHADOW);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY_SHADOW);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_CUBE_SHADOW);
|
|
PY_DICT_ADD_INT(GL_SEPARATE_ATTRIBS);
|
|
PY_DICT_ADD_INT(GL_STENCIL_ATTACHMENT);
|
|
PY_DICT_ADD_INT(GL_STENCIL_INDEX1);
|
|
PY_DICT_ADD_INT(GL_STENCIL_INDEX16);
|
|
PY_DICT_ADD_INT(GL_STENCIL_INDEX4);
|
|
PY_DICT_ADD_INT(GL_STENCIL_INDEX8);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BLUE_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_GREEN_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_RED_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SHARED_SIZE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_STENCIL_SIZE);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_MODE);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_START);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYINGS);
|
|
PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_10F_11F_11F_REV);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_24_8);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_5_9_9_9_REV);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_ARRAY);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_3D);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_CUBE);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC2);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC3);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC4);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_NORMALIZED);
|
|
PY_DICT_ADD_INT(GL_VERTEX_ARRAY_BINDING);
|
|
PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_INTEGER);
|
|
}
|
|
/* 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);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_INTENSITY_TYPE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_LUMINANCE_TYPE);
|
|
}
|
|
|
|
/* 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_COPY_READ_BUFFER);
|
|
PY_DICT_ADD_INT(GL_COPY_WRITE_BUFFER);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_RECT);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_BUFFER);
|
|
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_RECTANGLE_TEXTURE_SIZE);
|
|
PY_DICT_ADD_INT(GL_MAX_TEXTURE_BUFFER_SIZE);
|
|
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_PRIMITIVE_RESTART);
|
|
PY_DICT_ADD_INT(GL_PRIMITIVE_RESTART_INDEX);
|
|
PY_DICT_ADD_INT(GL_PROXY_TEXTURE_RECTANGLE);
|
|
PY_DICT_ADD_INT(GL_R16_SNORM);
|
|
PY_DICT_ADD_INT(GL_R8_SNORM);
|
|
PY_DICT_ADD_INT(GL_RG16_SNORM);
|
|
PY_DICT_ADD_INT(GL_RG8_SNORM);
|
|
PY_DICT_ADD_INT(GL_RGB16_SNORM);
|
|
PY_DICT_ADD_INT(GL_RGB8_SNORM);
|
|
PY_DICT_ADD_INT(GL_RGBA16_SNORM);
|
|
PY_DICT_ADD_INT(GL_RGBA8_SNORM);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT_SHADOW);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_BUFFER);
|
|
PY_DICT_ADD_INT(GL_SIGNED_NORMALIZED);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BINDING_BUFFER);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BINDING_RECTANGLE);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BUFFER);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_BUFFER_DATA_STORE_BINDING);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_RECTANGLE);
|
|
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);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_RECT);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_BUFFER);
|
|
}
|
|
|
|
|
|
/* GL_VERSION_3_2 */
|
|
{
|
|
PY_DICT_ADD_INT(GL_ALREADY_SIGNALED);
|
|
PY_DICT_ADD_INT(GL_CONDITION_SATISFIED);
|
|
PY_DICT_ADD_INT(GL_CONTEXT_COMPATIBILITY_PROFILE_BIT);
|
|
PY_DICT_ADD_INT(GL_CONTEXT_CORE_PROFILE_BIT);
|
|
PY_DICT_ADD_INT(GL_CONTEXT_PROFILE_MASK);
|
|
PY_DICT_ADD_INT(GL_DEPTH_CLAMP);
|
|
PY_DICT_ADD_INT(GL_FIRST_VERTEX_CONVENTION);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_LAYERED);
|
|
PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS);
|
|
PY_DICT_ADD_INT(GL_GEOMETRY_INPUT_TYPE);
|
|
PY_DICT_ADD_INT(GL_GEOMETRY_OUTPUT_TYPE);
|
|
PY_DICT_ADD_INT(GL_GEOMETRY_SHADER);
|
|
PY_DICT_ADD_INT(GL_GEOMETRY_VERTICES_OUT);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE);
|
|
PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY);
|
|
PY_DICT_ADD_INT(GL_LAST_VERTEX_CONVENTION);
|
|
PY_DICT_ADD_INT(GL_LINES_ADJACENCY);
|
|
PY_DICT_ADD_INT(GL_LINE_STRIP_ADJACENCY);
|
|
PY_DICT_ADD_INT(GL_MAX_COLOR_TEXTURE_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_MAX_DEPTH_TEXTURE_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_MAX_FRAGMENT_INPUT_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_INPUT_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_VERTICES);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_MAX_INTEGER_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_MAX_SAMPLE_MASK_WORDS);
|
|
PY_DICT_ADD_INT(GL_MAX_SERVER_WAIT_TIMEOUT);
|
|
PY_DICT_ADD_INT(GL_MAX_VERTEX_OUTPUT_COMPONENTS);
|
|
PY_DICT_ADD_INT(GL_OBJECT_TYPE);
|
|
PY_DICT_ADD_INT(GL_PROGRAM_POINT_SIZE);
|
|
PY_DICT_ADD_INT(GL_PROVOKING_VERTEX);
|
|
PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE);
|
|
PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY);
|
|
PY_DICT_ADD_INT(GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION);
|
|
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_SIGNALED);
|
|
PY_DICT_ADD_INT(GL_SYNC_CONDITION);
|
|
PY_DICT_ADD_INT(GL_SYNC_FENCE);
|
|
PY_DICT_ADD_INT(GL_SYNC_FLAGS);
|
|
PY_DICT_ADD_INT(GL_SYNC_FLUSH_COMMANDS_BIT);
|
|
PY_DICT_ADD_INT(GL_SYNC_GPU_COMMANDS_COMPLETE);
|
|
PY_DICT_ADD_INT(GL_SYNC_STATUS);
|
|
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_CUBE_MAP_SEAMLESS);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_FIXED_SAMPLE_LOCATIONS);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SAMPLES);
|
|
PY_DICT_ADD_INT(GL_TIMEOUT_EXPIRED);
|
|
PY_DICT_ADD_INT64(GL_TIMEOUT_IGNORED);
|
|
PY_DICT_ADD_INT(GL_TRIANGLES_ADJACENCY);
|
|
PY_DICT_ADD_INT(GL_TRIANGLE_STRIP_ADJACENCY);
|
|
PY_DICT_ADD_INT(GL_UNSIGNALED);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE);
|
|
PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY);
|
|
PY_DICT_ADD_INT(GL_WAIT_FAILED);
|
|
}
|
|
|
|
/* GL_VERSION_3_3 */
|
|
{
|
|
PY_DICT_ADD_INT(GL_ANY_SAMPLES_PASSED);
|
|
PY_DICT_ADD_INT(GL_INT_2_10_10_10_REV);
|
|
PY_DICT_ADD_INT(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS);
|
|
PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_ALPHA);
|
|
PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_COLOR);
|
|
PY_DICT_ADD_INT(GL_RGB10_A2UI);
|
|
PY_DICT_ADD_INT(GL_SAMPLER_BINDING);
|
|
PY_DICT_ADD_INT(GL_SRC1_COLOR);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_A);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_B);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_G);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_R);
|
|
PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_RGBA);
|
|
PY_DICT_ADD_INT(GL_TIMESTAMP);
|
|
PY_DICT_ADD_INT(GL_TIME_ELAPSED);
|
|
PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR);
|
|
}
|
|
|
|
return submodule;
|
|
}
|
|
|
|
static PyObject *Method_ShaderSource(PyObject *UNUSED(self), PyObject *args)
|
|
{
|
|
unsigned int shader;
|
|
const char *source;
|
|
|
|
if (!PyArg_ParseTuple(args, "Is", &shader, &source))
|
|
return NULL;
|
|
|
|
glShaderSource(shader, 1, (const char **)&source, NULL);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/** \} */
|