diff options
Diffstat (limited to 'source/blender/bpython/intern/opy_draw.c')
| -rw-r--r-- | source/blender/bpython/intern/opy_draw.c | 2683 |
1 files changed, 0 insertions, 2683 deletions
diff --git a/source/blender/bpython/intern/opy_draw.c b/source/blender/bpython/intern/opy_draw.c deleted file mode 100644 index d9653409724..00000000000 --- a/source/blender/bpython/intern/opy_draw.c +++ /dev/null @@ -1,2683 +0,0 @@ -/* python.c MIXED MODEL - * - * june 99 - * $Id$ - * - * ***** BEGIN GPL/BL DUAL 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. The Blender - * Foundation also sells licenses for use in proprietary software under - * the Blender License. See http://www.blender.org/BL/ for information - * about this. - * - * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL/BL DUAL LICENSE BLOCK ***** - */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - -#ifdef WIN32 -#include "BLI_winstuff.h" -#endif - -#include "MEM_guardedalloc.h" - -#include "BMF_Api.h" - -#include "DNA_screen_types.h" -#include "DNA_space_types.h" -#include "DNA_text_types.h" - -#include "BKE_global.h" - -#include "BIF_gl.h" -#include "BIF_screen.h" -#include "BIF_space.h" -#include "BIF_interface.h" -#include "BIF_mywindow.h" - -#include "interface.h" -#include "mydevice.h" /* for all the event constants */ - -#include "Python.h" -#include "BPY_macros.h" -#include "BPY_main.h" -#include "BPY_tools.h" - -int disable_force_draw= 0; - -/* hack to flag that window redraw has happened inside slider callback: */ - -static void exit_pydraw (SpaceText *st); -static uiBlock *Get_uiBlock (void); -void initDraw (void); - -/* Button Object */ - -typedef struct _Button { - PyObject_VAR_HEAD - - int type; /* 1 == int, 2 == float, 3 == string */ - int slen; /* length of string (if type == 3) */ - union { - int asint; - float asfloat; - char *asstr; - } val; -} Button; - - -static void Button_dealloc(PyObject *self) { - Button *but= (Button*) self; - - if(but->type==3) MEM_freeN(but->val.asstr); - - PyMem_DEL(self); -} - -static PyObject *Button_getattr(PyObject *self, char *name) { - Button *but= (Button*) self; - - if(STREQ(name, "val")) { - if (but->type==1) - return Py_BuildValue("i", but->val.asint); - else if (but->type==2) - return Py_BuildValue("f", but->val.asfloat); - else if (but->type==3) - return Py_BuildValue("s", but->val.asstr); - } - PyErr_SetString(PyExc_AttributeError, name); - return NULL; -} - -static int Button_setattr(PyObject *self, char *name, PyObject *v) { - Button *but= (Button*) self; - - if(STREQ(name, "val")) { - if (but->type==1) - PyArg_Parse(v, "i", &but->val.asint); - else if (but->type==2) - PyArg_Parse(v, "f", &but->val.asfloat); - else if (but->type==3) { - char *newstr; - - PyArg_Parse(v, "s", &newstr); - strncpy(but->val.asstr, newstr, but->slen); - } - } else { - PyErr_SetString(PyExc_AttributeError, name); - return -1; - } - - return 0; -} - -static PyObject *Button_repr(PyObject *self) { - return PyObject_Repr(Button_getattr(self, "val")); -} - -PyTypeObject Button_Type = { - PyObject_HEAD_INIT(NULL) - 0, /*ob_size*/ - "Button", /*tp_name*/ - sizeof(Button), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor) Button_dealloc, /*tp_dealloc*/ - (printfunc) 0, /*tp_print*/ - (getattrfunc) Button_getattr, /*tp_getattr*/ - (setattrfunc) Button_setattr, /*tp_setattr*/ - (cmpfunc) 0, /*tp_cmp*/ - (reprfunc) Button_repr, /*tp_repr*/ -}; - - -static Button *newbutton (void) { - Button *but= (Button *) PyObject_NEW(Button, &Button_Type); - - return but; -} - - -/* GUI interface routines */ - -static void exit_pydraw(SpaceText *st) -{ - scrarea_queue_redraw(st->area); - - if (st) { - Py_XDECREF((PyObject *) st->py_draw); - Py_XDECREF((PyObject *) st->py_event); - Py_XDECREF((PyObject *) st->py_button); - - st->py_draw= st->py_event= st->py_button= NULL; - } -} - -static void exec_callback(SpaceText *st, PyObject *callback, PyObject *args) -{ - PyObject *result= PyEval_CallObject(callback, args); - - if (result==NULL) { - st->text->compiled= NULL; - PyErr_Print(); - exit_pydraw(st); - } - Py_XDECREF(result); - Py_DECREF(args); -} - -/* the handler for drawing routines (see Register method) */ - -void BPY_spacetext_do_pywin_draw(SpaceText *st) -{ - uiBlock *block; - char butblock[20]; - - sprintf(butblock, "win %d", curarea->win); - block= uiNewBlock(&curarea->uiblocks, butblock, UI_EMBOSSX, UI_HELV, curarea->win); - - if (st->py_draw) { - glPushAttrib(GL_ALL_ATTRIB_BITS); - exec_callback(st, st->py_draw, Py_BuildValue("()")); - glPopAttrib(); - } else { - glClearColor(0.4375, 0.4375, 0.4375, 0.0); - glClear(GL_COLOR_BUFFER_BIT); - } - - uiDrawBlock(block); - - curarea->win_swap= WIN_BACK_OK; -} - -/* the handler for button event routines (see Register method) */ - -static void spacetext_do_pywin_buttons(SpaceText *st, unsigned short event) { - if (st->py_button) { - exec_callback(st, st->py_button, Py_BuildValue("(i)", event)); - } -} - -/* calls the generic event handling methods registered with Register */ - -void BPY_spacetext_do_pywin_event(SpaceText *st, unsigned short event, short val) { - if (event==QKEY && G.qual & (LR_ALTKEY|LR_CTRLKEY|LR_SHIFTKEY)) { - exit_pydraw(st); - return; - } - - if (val) { - if (uiDoBlocks(&curarea->uiblocks, event)!=UI_NOTHING ) event= 0; - - if (event==UI_BUT_EVENT) { - spacetext_do_pywin_buttons(st, val); - } - } - - if (st->py_event) { - exec_callback(st, st->py_event, Py_BuildValue("(ii)", event, val)); - } -} - -int BPY_spacetext_is_pywin(SpaceText *st) { - return (st->py_draw || st->py_event || st->py_button); -} - -static char Method_Exit_doc[]= -"() - Exit the windowing interface"; -static PyObject *Method_Exit (PyObject *self, PyObject *args) -{ - SpaceText *st= curarea->spacedata.first; -#ifdef CLEAR_NAMESPACE - PyObject *d; -#endif - BPY_TRY(PyArg_ParseTuple(args, "")); - - exit_pydraw(st); -#ifdef CLEAR_NAMESPACE - d = st->py_globaldict; // The current window's global namespace dictionary - if (d) { - PyDict_Clear(d); - Py_DECREF(d); // release dictionary - } -#endif - - return BPY_incr_ret(Py_None); -} - -static char Method_Register_doc[]= -"(draw, event, button) - Register callbacks for windowing\n\ -\n\ -(draw) A function to draw the screen, taking no arguments\n\ -(event) A function to handle events, taking 2 arguments (evt, val)\n\ - (evt) The event number\n\ - (val) The value modifier (for key and mouse press/release)\n\ -(button) A function to handle button events, taking 1 argument (evt)\n\ - (evt) The button number\n\ -\n\ -A None object can be passed if a callback is unused."; - -static PyObject *Method_Register (PyObject *self, PyObject *args) -{ - PyObject *newdrawc= NULL, *neweventc= NULL, *newbuttonc= NULL; - SpaceText *st= curarea->spacedata.first; - - BPY_TRY(PyArg_ParseTuple(args, "O|OO", &newdrawc, &neweventc, &newbuttonc)); - - /* This is a hack again: - * Every python script should actually do a global variable cleanup at - * the end of execution. - * For scripts registering GUI callbacks, this does not work, because - * the global namespace of the interpreter still needs to be accessed - * from the callback. - * Workaround: a text object has a flag which allows the global name - * space to be cleared at the end of the script. This flag should be - * normally set when executed with Alt-P. For a script registering with - * the GUI though, clear the flag and set it when the GUI mode is left - * (Method_Exit). - */ - - BPY_debug(("--- disable clear namespace")); - - st->flags &= ~ST_CLEAR_NAMESPACE; - - - if (!PyCallable_Check(newdrawc)) newdrawc= NULL; - if (!PyCallable_Check(neweventc)) neweventc= NULL; - if (!PyCallable_Check(newbuttonc)) newbuttonc= NULL; - - if (!(newdrawc || neweventc || newbuttonc)) - return BPY_incr_ret(Py_None); - - exit_pydraw(st); - - Py_XINCREF(newdrawc); - Py_XINCREF(neweventc); - Py_XINCREF(newbuttonc); - - st->py_draw= newdrawc; - st->py_event= neweventc; - st->py_button= newbuttonc; - - scrarea_queue_redraw(st->area); - - return BPY_incr_ret(Py_None); -} - - -static char Method_Redraw_doc[]= -"([after]) - Queue a redraw event\n\ -\n\ -[after=0] Determines whether the redraw is processed before or after other input events.\n\ -\n\ -Redraw events are buffered so that regardless of how many events are queued\n\ -the window only receives one redraw event."; - -static PyObject *Method_Redraw (PyObject *self, PyObject *args) -{ - int after= 0; - - BPY_TRY(PyArg_ParseTuple(args, "|i", &after)); - - if (after) addafterqueue(curarea->win, REDRAW, 1); - else scrarea_queue_winredraw(curarea); - - return BPY_incr_ret(Py_None); -} - - -static char Method_Draw_doc[]= -"() - Force an immediate redraw\n\ -\n\ -Forced redraws are not buffered, in other words the window is redrawn\n\ -exactly once for everytime this function is called."; -static PyObject *Method_Draw (PyObject *self, PyObject *args) -{ - /* If forced drawing is disable queue a redraw event instead */ - if (disable_force_draw) { - scrarea_queue_winredraw(curarea); - return BPY_incr_ret(Py_None); - } - - BPY_TRY(PyArg_ParseTuple(args, "")); - - scrarea_do_windraw(curarea); - - screen_swapbuffers(); - - return BPY_incr_ret(Py_None); -} - - - -static char Method_Create_doc[]= -"(value) - Create a default Button object\n\ -\n\ -(value) - The value to store in the button\n\ -\n\ -Valid values are ints, floats, and strings"; - -static PyObject *Method_Create (PyObject *self, PyObject *args) -{ - Button *but; - PyObject *in; - - BPY_TRY(PyArg_ParseTuple(args, "O", &in)); - - but= newbutton(); - if(PyFloat_Check(in)) { - but->type= 2; - but->val.asfloat= PyFloat_AsDouble(in); - } else if (PyInt_Check(in)) { - but->type= 1; - but->val.asint= PyInt_AsLong(in); - } else if (PyString_Check(in)) { - char *newstr= PyString_AsString(in); - - but->type= 3; - but->slen= strlen(newstr); - but->val.asstr= MEM_mallocN(but->slen+1, "button string"); - - strcpy(but->val.asstr, newstr); - } - - return (PyObject *) but; -} - -static uiBlock *Get_uiBlock(void) -{ - char butblock[32]; - - sprintf(butblock, "win %d", curarea->win); - - return uiGetBlock(butblock, curarea); -} - -static char Method_Button_doc[]= -"(name, event, x, y, width, height, [tooltip]) - Create a new Button (push) button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_Button (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL; - int event; - int x, y, w, h; - - BPY_TRY(PyArg_ParseTuple(args, "siiiii|s", &name, &event, &x, &y, &w, &h, &tip)); - - block= Get_uiBlock(); - - if(block) uiDefBut(block, BUT, event, name, x, y, w, h, 0, 0, 0, 0, 0, tip); - - return BPY_incr_ret(Py_None); -} - -static char Method_Menu_doc[]= -"(name, event, x, y, width, height, default, [tooltip]) - Create a new Menu button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(default) The number of the option to be selected by default\n\ -[tooltip=""] The button's tooltip\n\ -\n\ -The menu options are specified through the name of the\n\ -button. Options are followed by a format code and seperated\n\ -by the '|' (pipe) character.\n\ -Valid format codes are\n\ - %t - The option should be used as the title\n\ - %xN - The option should set the integer N in the button value."; - -static PyObject *Method_Menu (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL; - int event, def; - int x, y, w, h; - Button *but; - - BPY_TRY(PyArg_ParseTuple(args, "siiiiii|s", &name, &event, &x, &y, &w, &h, &def, &tip)); - - but= newbutton(); - but->type= 1; - but->val.asint= def; - - block= Get_uiBlock(); - if(block) uiDefButI(block, MENU, event, name, x, y, w, h, &but->val.asint, 0, 0, 0, 0, tip); - - return (PyObject *) but; -} - -static char Method_Toggle_doc[]= -"(name, event, x, y, width, height, default, [tooltip]) - Create a new Toggle button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(default) An integer (0 or 1) specifying the default state\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_Toggle (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL; - int event; - int x, y, w, h, def; - Button *but; - - BPY_TRY(PyArg_ParseTuple(args, "siiiiii|s", &name, &event, &x, &y, &w, &h, &def, &tip)); - - but= newbutton(); - but->type= 1; - but->val.asint= def; - - block= Get_uiBlock(); - if(block) uiDefButI(block, TOG, event, name, x, y, w, h, &but->val.asint, 0, 0, 0, 0, tip); - - return (PyObject *) but; -} - - -/* DO NOT TOUCH THIS FUNCTION ! - Redrawing a slider inside its own callback routine is actually forbidden - with the current toolkit architecture (button routines are not reentrant). - But it works anyway. - XXX This is condemned to be dinosource in future - it's a hack. - */ - -static void py_slider_update(void *butv, void *data2_unused) -{ - uiBut *but= butv; - - disable_force_draw= 1; - /* - Disable forced drawing, otherwise the button object which - is still being used might be deleted - */ - -// UIfrontbuf = 0; -// spacetext_do_pywin_buttons(curarea->spacedata.first, but->retval); - - g_window_redrawn = 0; - curarea->win_swap= WIN_BACK_OK; - //UIfrontbuf = 1; - spacetext_do_pywin_buttons(curarea->spacedata.first, uiButGetRetVal(but)); - //UIfrontbuf = 0; - - if (!g_window_redrawn) /* if Redraw already called */ - Windowmodule_Redraw(0, Py_BuildValue("(i)", SPACE_VIEW3D)); - - disable_force_draw= 0; -} - -static char Method_Slider_doc[]= -"(name, event, x, y, width, height, initial, min, max, [update, tooltip]) - Create a new Slider button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(initial, min, max) Three values (int or float) specifying the initial and limit values.\n\ -[update=1] A value controlling whether the slider will emit events as it is edited.\n\ - A non-zero value (default) enables the events. A zero value supresses them.\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_Slider (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL; - int event; - int x, y, w, h, realtime=1; - Button *but; - PyObject *mino, *maxo, *inio; - - BPY_TRY(PyArg_ParseTuple(args, "siiiiiOOO|is", &name, &event, &x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip)); - - - but= newbutton(); - if (PyFloat_Check(inio)) { - float ini, min, max; - - ini= PyFloat_AsDouble(inio); - min= PyFloat_AsDouble(mino); - max= PyFloat_AsDouble(maxo); - - but->type= 2; - but->val.asfloat= ini; - - block= Get_uiBlock(); - if(block) { - uiBut *ubut; - ubut= uiDefButF(block, NUMSLI, event, name, x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip); - if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL); - } - } - else { - int ini, min, max; - - ini= PyInt_AsLong(inio); - min= PyInt_AsLong(mino); - max= PyInt_AsLong(maxo); - - but->type= 1; - but->val.asint= ini; - - block= Get_uiBlock(); - if(block) { - uiBut *ubut; - ubut= uiDefButI(block, NUMSLI, event, name, x, y, w, h, &but->val.asint, min, max, 0, 0, tip); - if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL); - } - } - return (PyObject *) but; -} - -static char Method_Scrollbar_doc[]= -"(event, x, y, width, height, initial, min, max, [update, tooltip]) - Create a new Scrollbar\n\ -\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(initial, min, max) Three values (int or float) specifying the initial and limit values.\n\ -[update=1] A value controlling whether the slider will emit events as it is edited.\n\ - A non-zero value (default) enables the events. A zero value supresses them.\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_Scrollbar (PyObject *self, PyObject *args) -{ - char *tip= NULL; - uiBlock *block; - int event; - int x, y, w, h, realtime=1; - Button *but; - PyObject *mino, *maxo, *inio; - float ini, min, max; - - BPY_TRY(PyArg_ParseTuple(args, "iiiiiOOO|is", &event, &x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip)); - - if (!PyNumber_Check(inio) || !PyNumber_Check(inio) || !PyNumber_Check(inio)) - return BPY_err_ret_ob(PyExc_AttributeError, "expected numbers for initial, min, and max"); - - but= newbutton(); - - if (PyFloat_Check(inio)) but->type= 2; - else but->type= 1; - - ini= PyFloat_AsDouble(inio); - min= PyFloat_AsDouble(mino); - max= PyFloat_AsDouble(maxo); - - if (but->type==2) { - but->val.asfloat= ini; - block= Get_uiBlock(); - if(block) { - uiBut *ubut; - ubut= uiDefButF(block, SCROLL, event, "", x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip); - if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL); - } - } else { - but->val.asint= ini; - block= Get_uiBlock(); - if(block) { - uiBut *ubut; - ubut= uiDefButI(block, SCROLL, event, "", x, y, w, h, &but->val.asint, min, max, 0, 0, tip); - if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL); - } - } - - return (PyObject *) but; -} - -static char Method_Number_doc[]= -"(name, event, x, y, width, height, initial, min, max, [tooltip]) - Create a new Number button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(initial, min, max) Three values (int or float) specifying the initial and limit values.\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_Number (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL; - int event; - int x, y, w, h; - Button *but; - PyObject *mino, *maxo, *inio; - - BPY_TRY(PyArg_ParseTuple(args, "siiiiiOOO|s", &name, &event, &x, &y, &w, &h, &inio, &mino, &maxo, &tip)); - - but= newbutton(); - - if (PyFloat_Check(inio)) { - float ini, min, max; - - ini= PyFloat_AsDouble(inio); - min= PyFloat_AsDouble(mino); - max= PyFloat_AsDouble(maxo); - - but->type= 2; - but->val.asfloat= ini; - - block= Get_uiBlock(); - if(block) uiDefButF(block, NUM, event, name, x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip); - } else { - int ini, min, max; - - ini= PyInt_AsLong(inio); - min= PyInt_AsLong(mino); - max= PyInt_AsLong(maxo); - - but->type= 1; - but->val.asint= ini; - - block= Get_uiBlock(); - if(block) uiDefButI(block, NUM, event, name, x, y, w, h, &but->val.asint, min, max, 0, 0, tip); - } - - return (PyObject *) but; -} - -static char Method_String_doc[]= -"(name, event, x, y, width, height, initial, length, [tooltip]) - Create a new String button\n\ -\n\ -(name) A string to display on the button\n\ -(event) The event number to pass to the button event function when activated\n\ -(x, y) The lower left coordinate of the button\n\ -(width, height) The button width and height\n\ -(initial) The string to display initially\n\ -(length) The maximum input length\n\ -[tooltip=""] The button's tooltip"; - -static PyObject *Method_String (PyObject *self, PyObject *args) -{ - uiBlock *block; - char *name, *tip= NULL, *newstr; - int event; - int x, y, w, h, len; - Button *but; - - BPY_TRY(PyArg_ParseTuple(args, "siiiiisi|s", &name, &event, &x, &y, &w, &h, &newstr, &len, &tip)); - - but= newbutton(); - but->type= 3; - but->slen= len; - but->val.asstr= MEM_mallocN(len+1, "button string"); - - strncpy(but->val.asstr, newstr, len); - but->val.asstr[len]= 0; - - block= Get_uiBlock(); - if(block) uiDefBut(block, TEX, event, name, x, y, w, h, but->val.asstr, 0, len, 0, 0, tip); - - return (PyObject *) but; -} - -static char Method_Text_doc[]= -"(text) - Draw text onscreen\n\ -\n\ -(text) The text to draw\n"; -static PyObject *Method_Text (PyObject *self, PyObject *args) -{ - char *text; - - BPY_TRY(PyArg_ParseTuple(args, "s", &text)); - - BMF_DrawString(G.font, text); - - return BPY_incr_ret(Py_None); -} - -#undef MethodDef -#define MethodDef(func) _MethodDef(func, Method) - -static struct PyMethodDef Draw_methods[] = { - MethodDef(Create), - MethodDef(Button), - MethodDef(Toggle), - MethodDef(Menu), - MethodDef(Slider), - MethodDef(Scrollbar), - MethodDef(Number), - MethodDef(String), - - MethodDef(Text), - - MethodDef(Exit), - MethodDef(Redraw), - MethodDef(Draw), - MethodDef(Register), - - {NULL, NULL} -}; - -PyObject *init_py_draw(void) -{ - PyObject *mod= Py_InitModule(SUBMODULE(Draw), Draw_methods); - PyObject *dict= PyModule_GetDict(mod); - - Button_Type.ob_type= &PyType_Type; - - BPY_ADDCONST(dict, LEFTMOUSE); - BPY_ADDCONST(dict, MIDDLEMOUSE); - BPY_ADDCONST(dict, RIGHTMOUSE); - BPY_ADDCONST(dict, MOUSEX); - BPY_ADDCONST(dict, MOUSEY); - BPY_ADDCONST(dict, TIMER0); - BPY_ADDCONST(dict, TIMER1); - BPY_ADDCONST(dict, TIMER2); - BPY_ADDCONST(dict, TIMER3); - BPY_ADDCONST(dict, KEYBD); - BPY_ADDCONST(dict, RAWKEYBD); - BPY_ADDCONST(dict, REDRAW); - BPY_ADDCONST(dict, INPUTCHANGE); - BPY_ADDCONST(dict, QFULL); - BPY_ADDCONST(dict, WINFREEZE); - BPY_ADDCONST(dict, WINTHAW); - BPY_ADDCONST(dict, WINCLOSE); - BPY_ADDCONST(dict, WINQUIT); -#ifndef IRISGL - BPY_ADDCONST(dict, Q_FIRSTTIME); -#endif - BPY_ADDCONST(dict, AKEY); - BPY_ADDCONST(dict, BKEY); - BPY_ADDCONST(dict, CKEY); - BPY_ADDCONST(dict, DKEY); - BPY_ADDCONST(dict, EKEY); - BPY_ADDCONST(dict, FKEY); - BPY_ADDCONST(dict, GKEY); - BPY_ADDCONST(dict, HKEY); - BPY_ADDCONST(dict, IKEY); - BPY_ADDCONST(dict, JKEY); - BPY_ADDCONST(dict, KKEY); - BPY_ADDCONST(dict, LKEY); - BPY_ADDCONST(dict, MKEY); - BPY_ADDCONST(dict, NKEY); - BPY_ADDCONST(dict, OKEY); - BPY_ADDCONST(dict, PKEY); - BPY_ADDCONST(dict, QKEY); - BPY_ADDCONST(dict, RKEY); - BPY_ADDCONST(dict, SKEY); - BPY_ADDCONST(dict, TKEY); - BPY_ADDCONST(dict, UKEY); - BPY_ADDCONST(dict, VKEY); - BPY_ADDCONST(dict, WKEY); - BPY_ADDCONST(dict, XKEY); - BPY_ADDCONST(dict, YKEY); - BPY_ADDCONST(dict, ZKEY); - BPY_ADDCONST(dict, ZEROKEY); - BPY_ADDCONST(dict, ONEKEY); - BPY_ADDCONST(dict, TWOKEY); - BPY_ADDCONST(dict, THREEKEY); - BPY_ADDCONST(dict, FOURKEY); - BPY_ADDCONST(dict, FIVEKEY); - BPY_ADDCONST(dict, SIXKEY); - BPY_ADDCONST(dict, SEVENKEY); - BPY_ADDCONST(dict, EIGHTKEY); - BPY_ADDCONST(dict, NINEKEY); - BPY_ADDCONST(dict, CAPSLOCKKEY); - BPY_ADDCONST(dict, LEFTCTRLKEY); - BPY_ADDCONST(dict, LEFTALTKEY); - BPY_ADDCONST(dict, RIGHTALTKEY); - BPY_ADDCONST(dict, RIGHTCTRLKEY); - BPY_ADDCONST(dict, RIGHTSHIFTKEY); - BPY_ADDCONST(dict, LEFTSHIFTKEY); - BPY_ADDCONST(dict, ESCKEY); - BPY_ADDCONST(dict, TABKEY); - BPY_ADDCONST(dict, RETKEY); - BPY_ADDCONST(dict, SPACEKEY); - BPY_ADDCONST(dict, LINEFEEDKEY); - BPY_ADDCONST(dict, BACKSPACEKEY); - BPY_ADDCONST(dict, DELKEY); - BPY_ADDCONST(dict, SEMICOLONKEY); - BPY_ADDCONST(dict, PERIODKEY); - BPY_ADDCONST(dict, COMMAKEY); - BPY_ADDCONST(dict, QUOTEKEY); - BPY_ADDCONST(dict, ACCENTGRAVEKEY); - BPY_ADDCONST(dict, MINUSKEY); - BPY_ADDCONST(dict, SLASHKEY); - BPY_ADDCONST(dict, BACKSLASHKEY); - BPY_ADDCONST(dict, EQUALKEY); - BPY_ADDCONST(dict, LEFTBRACKETKEY); - BPY_ADDCONST(dict, RIGHTBRACKETKEY); - BPY_ADDCONST(dict, LEFTARROWKEY); - BPY_ADDCONST(dict, DOWNARROWKEY); - BPY_ADDCONST(dict, RIGHTARROWKEY); - BPY_ADDCONST(dict, UPARROWKEY); - BPY_ADDCONST(dict, PAD2); - BPY_ADDCONST(dict, PAD4); - BPY_ADDCONST(dict, PAD6); - BPY_ADDCONST(dict, PAD8); - BPY_ADDCONST(dict, PAD1); - BPY_ADDCONST(dict, PAD3); - BPY_ADDCONST(dict, PAD5); - BPY_ADDCONST(dict, PAD7); - BPY_ADDCONST(dict, PAD9); - BPY_ADDCONST(dict, PADPERIOD); - BPY_ADDCONST(dict, PADSLASHKEY); - BPY_ADDCONST(dict, PADASTERKEY); - BPY_ADDCONST(dict, PAD0); - BPY_ADDCONST(dict, PADMINUS); - BPY_ADDCONST(dict, PADENTER); - BPY_ADDCONST(dict, PADPLUSKEY); - BPY_ADDCONST(dict, F1KEY); - BPY_ADDCONST(dict, F2KEY); - BPY_ADDCONST(dict, F3KEY); - BPY_ADDCONST(dict, F4KEY); - BPY_ADDCONST(dict, F5KEY); - BPY_ADDCONST(dict, F6KEY); - BPY_ADDCONST(dict, F7KEY); - BPY_ADDCONST(dict, F8KEY); - BPY_ADDCONST(dict, F9KEY); - BPY_ADDCONST(dict, F10KEY); - BPY_ADDCONST(dict, F11KEY); - BPY_ADDCONST(dict, F12KEY); - BPY_ADDCONST(dict, PAUSEKEY); - BPY_ADDCONST(dict, INSERTKEY); - BPY_ADDCONST(dict, HOMEKEY); - BPY_ADDCONST(dict, PAGEUPKEY); - BPY_ADDCONST(dict, PAGEDOWNKEY); - BPY_ADDCONST(dict, ENDKEY); - - return mod; -} - - -/* Buffer Object */ - -/* For Python access to OpenGL functions requiring - * a pointer. - */ - -PyTypeObject Buffer_Type; - -typedef struct _Buffer { - PyObject_VAR_HEAD - - PyObject *parent; - - int type; /* GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT */ - int ndimensions; - int *dimensions; - - union { - char *asbyte; - short *asshort; - int *asint; - float *asfloat; - - void *asvoid; - } buf; -} Buffer; - -static int type_size(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); - } - return -1; -} - -static Buffer *make_buffer(int type, int ndimensions, int *dimensions) { - Buffer *buffer; - void *buf= NULL; - int i, size, length; - - length= 1; - for (i=0; i<ndimensions; i++) length*= dimensions[i]; - - size= type_size(type); - - buf= MEM_mallocN(length*size, "Buffer buffer"); - - buffer= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type); - buffer->parent= NULL; - buffer->ndimensions= ndimensions; - buffer->dimensions= dimensions; - buffer->type= type; - buffer->buf.asvoid= buf; - - for (i= 0; i<length; i++) { - if (type==GL_BYTE) - buffer->buf.asbyte[i]= 0; - - else if (type==GL_SHORT) - buffer->buf.asshort[i]= 0; - - else if (type==GL_INT) - buffer->buf.asint[i]= 0; - - else if (type==GL_FLOAT) - buffer->buf.asfloat[i]= 0.0; - } - - return buffer; -} - -static int Buffer_ass_slice(PyObject *self, int begin, int end, PyObject *seq); - -static char Method_Buffer_doc[]= -"(type, dimensions, [template]) - Create a new Buffer object\n\ -\n\ -(type) - The format to store data in\n\ -(dimensions) - An int or sequence specifying the dimensions of the buffer\n\ -[template] - A sequence of matching dimensions to the buffer to be created\n\ - which will be used to initialize the Buffer.\n\ -\n\ -If a template is not passed in all fields will be initialized to 0.\n\ -\n\ -The type should be one of GL_BYTE, GL_SHORT, GL_INT, or GL_FLOAT.\n\ -If the dimensions are specified as an int a linear buffer will be\n\ -created. If a sequence is passed for the dimensions the buffer\n\ -will have len(sequence) dimensions, where the size for each dimension\n\ -is determined by the value in the sequence at that index.\n\ -\n\ -For example, passing [100, 100] will create a 2 dimensional\n\ -square buffer. Passing [16, 16, 32] will create a 3 dimensional\n\ -buffer which is twice as deep as it is wide or high."; - -static PyObject *Method_Buffer (PyObject *self, PyObject *args) -{ - PyObject *length_ob= NULL, *template= NULL; - Buffer *buffer; - - int i, type; - int *dimensions = 0, ndimensions = 0; - - BPY_TRY(PyArg_ParseTuple(args, "iO|O", &type, &length_ob, &template)); - - if (type!=GL_BYTE && type!=GL_SHORT && type!=GL_INT && type!=GL_FLOAT) { - PyErr_SetString(PyExc_AttributeError, "type"); - return NULL; - } - - if (PyNumber_Check(length_ob)) { - ndimensions= 1; - dimensions= MEM_mallocN(ndimensions*sizeof(int), "Buffer dimensions"); - dimensions[0]= PyInt_AsLong(length_ob); - - } else if (PySequence_Check(length_ob)) { - ndimensions= PySequence_Length(length_ob); - dimensions= MEM_mallocN(ndimensions*sizeof(int), "Buffer dimensions"); - - for (i=0; i<ndimensions; i++) { - PyObject *ob= PySequence_GetItem(length_ob, i); - - if (!PyNumber_Check(ob)) dimensions[i]= 1; - else dimensions[i]= PyInt_AsLong(ob); - - Py_DECREF(ob); - } - } - - buffer= make_buffer(type, ndimensions, dimensions); - if (template && ndimensions) { - if (Buffer_ass_slice((PyObject *) buffer, 0, dimensions[0], template)) { - Py_DECREF(buffer); - return NULL; - } - } - - return (PyObject *) buffer; -} - -/**********/ - - -/* Buffer sequence methods */ - -static int Buffer_len(PyObject *self) { - Buffer *buf= (Buffer *) self; - - return buf->dimensions[0]; -} - -static PyObject *Buffer_item(PyObject *self, int i) { - Buffer *buf= (Buffer *) self; - - if (i >= buf->dimensions[0]) { - PyErr_SetString(PyExc_IndexError, "array index out of range"); - return NULL; - } - - if (buf->ndimensions==1) { - switch (buf->type) { - case GL_BYTE: return Py_BuildValue("b", buf->buf.asbyte[i]); - case GL_SHORT: return Py_BuildValue("h", buf->buf.asshort[i]); - case GL_INT: return Py_BuildValue("i", buf->buf.asint[i]); - case GL_FLOAT: return Py_BuildValue("f", buf->buf.asfloat[i]); - } - } else { - Buffer *newbuf; - int j, length, size; - - length= 1; - for (j=1; j<buf->ndimensions; j++) { - length*= buf->dimensions[j]; - } - size= type_size(buf->type); - - newbuf= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type); - - Py_INCREF(self); - newbuf->parent= self; - - newbuf->ndimensions= buf->ndimensions-1; - newbuf->type= buf->type; - newbuf->buf.asvoid= buf->buf.asbyte + i*length*size; - - newbuf->dimensions= MEM_mallocN(newbuf->ndimensions*sizeof(int), "Buffer dimensions"); - memcpy(newbuf->dimensions, buf->dimensions+1, newbuf->ndimensions*sizeof(int)); - - return (PyObject *) newbuf; - } - - return NULL; -} - -static PyObject *Buffer_slice(PyObject *self, int begin, int end) -{ - Buffer *buf= (Buffer *) self; - PyObject *list; - int count; - - if (begin<0) begin= 0; - if (end>buf->dimensions[0]) end= buf->dimensions[0]; - if (begin>end) begin= end; - - list= PyList_New(end-begin); - - for (count= begin; count<end; count++) - PyList_SetItem(list, count-begin, Buffer_item(self, count)); - - return list; -} - -static int Buffer_ass_item(PyObject *self, int i, PyObject *v) { - Buffer *buf= (Buffer *) self; - - if (i >= buf->dimensions[0]) { - PyErr_SetString(PyExc_IndexError, "array assignment index out of range"); - return -1; - } - - if (buf->ndimensions!=1) { - PyObject *row= Buffer_item(self, i); - int ret; - - if (!row) return -1; - - ret= Buffer_ass_slice(row, 0, buf->dimensions[1], v); - Py_DECREF(row); - - return ret; - } - - if (buf->type==GL_BYTE) { - if (!PyArg_Parse(v, "b;Coordinates must be ints", &buf->buf.asbyte[i])) - return -1; - - } else if (buf->type==GL_SHORT) { - if (!PyArg_Parse(v, "h;Coordinates must be ints", &buf->buf.asshort[i])) - return -1; - - } else if (buf->type==GL_INT) { - if (!PyArg_Parse(v, "i;Coordinates must be ints", &buf->buf.asint[i])) - return -1; - - } else if (buf->type==GL_FLOAT) { - if (!PyArg_Parse(v, "f;Coordinates must be floats", &buf->buf.asfloat[i])) - return -1; - } - - return 0; -} - -static int Buffer_ass_slice(PyObject *self, int begin, int end, PyObject *seq) -{ - Buffer *buf= (Buffer *) self; - PyObject *item; - int count, err=0; - - if (begin<0) begin= 0; - if (end>buf->dimensions[0]) end= buf->dimensions[0]; - if (begin>end) begin= end; - - if (!PySequence_Check(seq)) { - PyErr_SetString(PyExc_TypeError, "illegal argument type for built-in operation"); - return -1; - } - - if (PySequence_Length(seq)!=(end-begin)) { - PyErr_SetString(PyExc_TypeError, "size mismatch in assignment"); - return -1; - } - - for (count= begin; count<end; count++) { - item= PySequence_GetItem(seq, count-begin); - err= Buffer_ass_item(self, count, item); - Py_DECREF(item); - - if (err) break; - } - - return err; -} -static PySequenceMethods Buffer_SeqMethods = { - (inquiry) Buffer_len, /*sq_length*/ - (binaryfunc) 0, /*sq_concat*/ - (intargfunc) 0, /*sq_repeat*/ - (intargfunc) Buffer_item, /*sq_item*/ - (intintargfunc) Buffer_slice, /*sq_slice*/ - (intobjargproc) Buffer_ass_item, /*sq_ass_item*/ - (intintobjargproc) Buffer_ass_slice, /*sq_ass_slice*/ -}; - - - -/**********/ - -static void Buffer_dealloc(PyObject *self) { - Buffer *buf= (Buffer *) self; - - if (buf->parent) Py_DECREF(buf->parent); - else MEM_freeN(buf->buf.asvoid); - - MEM_freeN(buf->dimensions); - - PyMem_DEL(self); -} - -static PyObject *Buffer_tolist(PyObject *self) { - int i, len= ((Buffer *)self)->dimensions[0]; - PyObject *list= PyList_New(len); - - for (i=0; i<len; i++) { - PyList_SetItem(list, i, Buffer_item(self, i)); - } - - return list; -} - -static PyObject *Buffer_dimensions(PyObject *self) { - Buffer *buffer= (Buffer *) self; - PyObject *list= PyList_New(buffer->ndimensions); - int i; - - for (i= 0; i<buffer->ndimensions; i++) { - PyList_SetItem(list, i, PyInt_FromLong(buffer->dimensions[i])); - } - - return list; -} - -static PyObject *Buffer_getattr(PyObject *self, char *name) { - if (strcmp(name, "list")==0) return Buffer_tolist(self); - else if (strcmp(name, "dimensions")==0) return Buffer_dimensions(self); - - PyErr_SetString(PyExc_AttributeError, name); - return NULL; -} - -static PyObject *Buffer_repr(PyObject *self) { - PyObject *list= Buffer_tolist(self); - PyObject *repr= PyObject_Repr(list); - Py_DECREF(list); - - return repr; -} - -PyTypeObject Buffer_Type = { - PyObject_HEAD_INIT(NULL) - 0, /*ob_size*/ - "Buffer", /*tp_name*/ - sizeof(Buffer), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - (destructor) Buffer_dealloc, /*tp_dealloc*/ - (printfunc) 0, /*tp_print*/ - (getattrfunc) Buffer_getattr, /*tp_getattr*/ - (setattrfunc) 0, /*tp_setattr*/ - (cmpfunc) 0, /*tp_compare*/ - (reprfunc) Buffer_repr, /*tp_repr*/ - 0, /*tp_as_number*/ - &Buffer_SeqMethods, /*tp_as_sequence*/ -}; - -#ifndef __APPLE__ -/* By golly George! It looks like fancy pants macro time!!! */ - -/* -#define int_str "i" -#define int_var(number) bgl_int##number -#define int_ref(number) &bgl_int##number -#define int_def(number) int int_var(number) - -#define float_str "f" -#define float_var(number) bgl_float##number -#define float_ref(number) &bgl_float##number -#define float_def(number) float float_var(number) -*/ - -/* 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 - -#define buffer_str "O!" -#define buffer_var(number) (bgl_buffer##number)->buf.asvoid -#define buffer_ref(number) &Buffer_Type, &bgl_buffer##number -#define buffer_def(number) Buffer *bgl_buffer##number - -/* GL Pointer fields, handled by buffer type */ -/* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP */ - -#define GLbooleanP_str "O!" -#define GLbooleanP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLbooleanP_ref(number) &Buffer_Type, &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) &Buffer_Type, &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) &Buffer_Type, &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) &Buffer_Type, &bgl_buffer##number -#define GLintP_def(number) Buffer *bgl_buffer##number - -#define GLuintP_str "O!" -#define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLuintP_ref(number) &Buffer_Type, &bgl_buffer##number -#define GLuintP_def(number) Buffer *bgl_buffer##number - -#define GLshortP_str "O!" -#define GLshortP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLshortP_ref(number) &Buffer_Type, &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) &Buffer_Type, &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) &Buffer_Type, &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) &Buffer_Type, &bgl_buffer##number -#define GLdoubleP_def(number) Buffer *bgl_buffer##number - -#define GLclampfP_str "O!" -#define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLclampfP_ref(number) &Buffer_Type, &bgl_buffer##number -#define GLclampfP_def(number) Buffer *bgl_buffer##number - -#define GLvoidP_str "O!" -#define GLvoidP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLvoidP_ref(number) &Buffer_Type, &bgl_buffer##number -#define GLvoidP_def(number) Buffer *bgl_buffer##number - -#define buffer_str "O!" -#define buffer_var(number) (bgl_buffer##number)->buf.asvoid -#define buffer_ref(number) &Buffer_Type, &bgl_buffer##number -#define buffer_def(number) Buffer *bgl_buffer##number - -/* 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 "i" -#define GLsizei_var(num) bgl_var##num -#define GLsizei_ref(num) &bgl_var##num -#define GLsizei_def(num) int GLsizei_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 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 float GLclampf; */ -#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) - -/* 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; */ -#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) - -/* typedef void GLvoid; */ -/* #define GLvoid_str "" */ -/* #define GLvoid_var(num) bgl_var##num */ -/* #define GLvoid_ref(num) &bgl_var##num */ -/* #define GLvoid_def(num) char bgl_var##num */ - -#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_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_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_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 ret_def_void -#define ret_set_void -#define ret_ret_void return BPY_incr_ret(Py_None) - -#define ret_def_GLint int ret_int -#define ret_set_GLint ret_int= -#define ret_ret_GLint return PyInt_FromLong(ret_int); - -#define ret_def_GLuint unsigned int ret_uint -#define ret_set_GLuint ret_uint= -#define ret_ret_GLuint return PyInt_FromLong((long) ret_uint); - -#define ret_def_GLenum unsigned int ret_uint -#define ret_set_GLenum ret_uint= -#define ret_ret_GLenum return PyInt_FromLong((long) ret_uint); - -#define ret_def_GLboolean unsigned char ret_bool -#define ret_set_GLboolean ret_bool= -#define ret_ret_GLboolean return PyInt_FromLong((long) ret_bool); - -#define ret_def_GLstring const unsigned char *ret_str; -#define ret_set_GLstring ret_str= -#define ret_ret_GLstring return PyString_FromString(ret_str); - -#define BGL_Wrap(nargs, funcname, ret, arg_list) \ -static PyObject *Method_##funcname (PyObject *self, PyObject *args) {\ - arg_def##nargs arg_list; \ - ret_def_##ret; \ - if(!PyArg_ParseTuple(args, arg_str##nargs arg_list, arg_ref##nargs arg_list)) return NULL;\ - ret_set_##ret gl##funcname (arg_var##nargs arg_list);\ - ret_ret_##ret; \ -} - -BGL_Wrap(2, Accum, void, (GLenum, GLfloat)) -BGL_Wrap(2, AlphaFunc, void, (GLenum, GLclampf)) -BGL_Wrap(3, AreTexturesResident, GLboolean, (GLsizei, GLuintP, GLbooleanP)) -BGL_Wrap(1, Begin, void, (GLenum)) -BGL_Wrap(2, BindTexture, void, (GLenum, GLuint)) -BGL_Wrap(7, Bitmap, void, (GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, GLubyteP)) -BGL_Wrap(2, BlendFunc, void, (GLenum, GLenum)) -BGL_Wrap(1, CallList, void, (GLuint)) -BGL_Wrap(3, CallLists, void, (GLsizei, GLenum, GLvoidP)) -BGL_Wrap(1, Clear, void, (GLbitfield)) -BGL_Wrap(4, ClearAccum, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(4, ClearColor, void, (GLclampf, GLclampf, GLclampf, GLclampf)) -BGL_Wrap(1, ClearDepth, void, (GLclampd)) -BGL_Wrap(1, ClearIndex, void, (GLfloat)) -BGL_Wrap(1, ClearStencil, void, (GLint)) -BGL_Wrap(2, ClipPlane, void, (GLenum, GLdoubleP)) -BGL_Wrap(3, Color3b, void, (GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Color3bv, void, (GLbyteP)) -BGL_Wrap(3, Color3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Color3dv, void, (GLdoubleP)) -BGL_Wrap(3, Color3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Color3fv, void, (GLfloatP)) -BGL_Wrap(3, Color3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Color3iv, void, (GLintP)) -BGL_Wrap(3, Color3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Color3sv, void, (GLshortP)) -BGL_Wrap(3, Color3ub, void, (GLubyte, GLubyte, GLubyte)) -BGL_Wrap(1, Color3ubv, void, (GLubyteP)) -BGL_Wrap(3, Color3ui, void, (GLuint, GLuint, GLuint)) -BGL_Wrap(1, Color3uiv, void, (GLuintP)) -BGL_Wrap(3, Color3us, void, (GLushort, GLushort, GLushort)) -BGL_Wrap(1, Color3usv, void, (GLushortP)) -BGL_Wrap(4, Color4b, void, (GLbyte, GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Color4bv, void, (GLbyteP)) -BGL_Wrap(4, Color4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Color4dv, void, (GLdoubleP)) -BGL_Wrap(4, Color4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Color4fv, void, (GLfloatP)) -BGL_Wrap(4, Color4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, Color4iv, void, (GLintP)) -BGL_Wrap(4, Color4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, Color4sv, void, (GLshortP)) -BGL_Wrap(4, Color4ub, void, (GLubyte, GLubyte, GLubyte, GLubyte)) -BGL_Wrap(1, Color4ubv, void, (GLubyteP)) -BGL_Wrap(4, Color4ui, void, (GLuint, GLuint, GLuint, GLuint)) -BGL_Wrap(1, Color4uiv, void, (GLuintP)) -BGL_Wrap(4, Color4us, void, (GLushort, GLushort, GLushort, GLushort)) -BGL_Wrap(1, Color4usv, void, (GLushortP)) -BGL_Wrap(4, ColorMask, void, (GLboolean, GLboolean, GLboolean, GLboolean)) -BGL_Wrap(2, ColorMaterial, void, (GLenum, GLenum)) -BGL_Wrap(5, CopyPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum)) -BGL_Wrap(1, CullFace, void, (GLenum)) -BGL_Wrap(2, DeleteLists, void, (GLuint, GLsizei)) -BGL_Wrap(2, DeleteTextures, void, (GLsizei, GLuintP)) -BGL_Wrap(1, DepthFunc, void, (GLenum)) -BGL_Wrap(1, DepthMask, void, (GLboolean)) -BGL_Wrap(2, DepthRange, void, (GLclampd, GLclampd)) -BGL_Wrap(1, Disable, void, (GLenum)) -BGL_Wrap(1, DrawBuffer, void, (GLenum)) -BGL_Wrap(5, DrawPixels, void, (GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) -BGL_Wrap(1, EdgeFlag, void, (GLboolean)) -BGL_Wrap(1, EdgeFlagv, void, (GLbooleanP)) -BGL_Wrap(1, Enable, void, (GLenum)) -BGL_Wrap(1, End, void, (void)) -BGL_Wrap(1, EndList, void, (void)) -BGL_Wrap(1, EvalCoord1d, void, (GLdouble)) -BGL_Wrap(1, EvalCoord1dv, void, (GLdoubleP)) -BGL_Wrap(1, EvalCoord1f, void, (GLfloat)) -BGL_Wrap(1, EvalCoord1fv, void, (GLfloatP)) -BGL_Wrap(2, EvalCoord2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, EvalCoord2dv, void, (GLdoubleP)) -BGL_Wrap(2, EvalCoord2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, EvalCoord2fv, void, (GLfloatP)) -BGL_Wrap(3, EvalMesh1, void, (GLenum, GLint, GLint)) -BGL_Wrap(5, EvalMesh2, void, (GLenum, GLint, GLint, GLint, GLint)) -BGL_Wrap(1, EvalPoint1, void, (GLint)) -BGL_Wrap(2, EvalPoint2, void, (GLint, GLint)) -BGL_Wrap(3, FeedbackBuffer, void, (GLsizei, GLenum, GLfloatP)) -BGL_Wrap(1, Finish, void, (void)) -BGL_Wrap(1, Flush, void, (void)) -BGL_Wrap(2, Fogf, void, (GLenum, GLfloat)) -BGL_Wrap(2, Fogfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, Fogi, void, (GLenum, GLint)) -BGL_Wrap(2, Fogiv, void, (GLenum, GLintP)) -BGL_Wrap(1, FrontFace, void, (GLenum)) -BGL_Wrap(6, Frustum, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, GenLists, GLuint, (GLsizei)) -BGL_Wrap(2, GenTextures, void, (GLsizei, GLuintP)) -BGL_Wrap(2, GetBooleanv, void, (GLenum, GLbooleanP)) -BGL_Wrap(2, GetClipPlane, void, (GLenum, GLdoubleP)) -BGL_Wrap(2, GetDoublev, void, (GLenum, GLdoubleP)) -BGL_Wrap(1, GetError, GLenum, (void)) -BGL_Wrap(2, GetFloatv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, GetIntegerv, void, (GLenum, GLintP)) -BGL_Wrap(3, GetLightfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetLightiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetMapdv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, GetMapfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetMapiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetMaterialfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetMaterialiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, GetPixelMapfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, GetPixelMapuiv, void, (GLenum, GLuintP)) -BGL_Wrap(2, GetPixelMapusv, void, (GLenum, GLushortP)) -BGL_Wrap(1, GetPolygonStipple, void, (GLubyteP)) -BGL_Wrap(1, GetString, GLstring, (GLenum)) -BGL_Wrap(3, GetTexEnvfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexEnviv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, GetTexGendv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, GetTexGenfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexGeniv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(5, GetTexImage, void, (GLenum, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(4, GetTexLevelParameterfv, void, (GLenum, GLint, GLenum, GLfloatP)) -BGL_Wrap(4, GetTexLevelParameteriv, void, (GLenum, GLint, GLenum, GLintP)) -BGL_Wrap(3, GetTexParameterfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, GetTexParameteriv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, Hint, void, (GLenum, GLenum)) -BGL_Wrap(1, IndexMask, void, (GLuint)) -BGL_Wrap(1, Indexd, void, (GLdouble)) -BGL_Wrap(1, Indexdv, void, (GLdoubleP)) -BGL_Wrap(1, Indexf, void, (GLfloat)) -BGL_Wrap(1, Indexfv, void, (GLfloatP)) -BGL_Wrap(1, Indexi, void, (GLint)) -BGL_Wrap(1, Indexiv, void, (GLintP)) -BGL_Wrap(1, Indexs, void, (GLshort)) -BGL_Wrap(1, Indexsv, void, (GLshortP)) -BGL_Wrap(1, InitNames, void, (void)) -BGL_Wrap(1, IsEnabled, GLboolean, (GLenum)) -BGL_Wrap(1, IsList, GLboolean, (GLuint)) -BGL_Wrap(1, IsTexture, GLboolean, (GLuint)) -BGL_Wrap(2, LightModelf, void, (GLenum, GLfloat)) -BGL_Wrap(2, LightModelfv, void, (GLenum, GLfloatP)) -BGL_Wrap(2, LightModeli, void, (GLenum, GLint)) -BGL_Wrap(2, LightModeliv, void, (GLenum, GLintP)) -BGL_Wrap(3, Lightf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, Lightfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, Lighti, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, Lightiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(2, LineStipple, void, (GLint, GLushort)) -BGL_Wrap(1, LineWidth, void, (GLfloat)) -BGL_Wrap(1, ListBase, void, (GLuint)) -BGL_Wrap(1, LoadIdentity, void, (void)) -BGL_Wrap(1, LoadMatrixd, void, (GLdoubleP)) -BGL_Wrap(1, LoadMatrixf, void, (GLfloatP)) -BGL_Wrap(1, LoadName, void, (GLuint)) -BGL_Wrap(1, LogicOp, void, (GLenum)) -BGL_Wrap(6, Map1d, void, (GLenum, GLdouble, GLdouble, GLint, GLint, GLdoubleP)) -BGL_Wrap(6, Map1f, void, (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloatP)) -BGL_Wrap(10, Map2d, void, (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdoubleP)) -BGL_Wrap(10, Map2f, void, (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloatP)) -BGL_Wrap(3, MapGrid1d, void, (GLint, GLdouble, GLdouble)) -BGL_Wrap(3, MapGrid1f, void, (GLint, GLfloat, GLfloat)) -BGL_Wrap(6, MapGrid2d, void, (GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble)) -BGL_Wrap(6, MapGrid2f, void, (GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat)) -BGL_Wrap(3, Materialf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, Materialfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, Materiali, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, Materialiv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(1, MatrixMode, void, (GLenum)) -BGL_Wrap(1, MultMatrixd, void, (GLdoubleP)) -BGL_Wrap(1, MultMatrixf, void, (GLfloatP)) -BGL_Wrap(2, NewList, void, (GLuint, GLenum)) -BGL_Wrap(3, Normal3b, void, (GLbyte, GLbyte, GLbyte)) -BGL_Wrap(1, Normal3bv, void, (GLbyteP)) -BGL_Wrap(3, Normal3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Normal3dv, void, (GLdoubleP)) -BGL_Wrap(3, Normal3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Normal3fv, void, (GLfloatP)) -BGL_Wrap(3, Normal3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Normal3iv, void, (GLintP)) -BGL_Wrap(3, Normal3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Normal3sv, void, (GLshortP)) -BGL_Wrap(6, Ortho, void, (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, PassThrough, void, (GLfloat)) -BGL_Wrap(3, PixelMapfv, void, (GLenum, GLint, GLfloatP)) -BGL_Wrap(3, PixelMapuiv, void, (GLenum, GLint, GLuintP)) -BGL_Wrap(3, PixelMapusv, void, (GLenum, GLint, GLushortP)) -BGL_Wrap(2, PixelStoref, void, (GLenum, GLfloat)) -BGL_Wrap(2, PixelStorei, void, (GLenum, GLint)) -BGL_Wrap(2, PixelTransferf, void, (GLenum, GLfloat)) -BGL_Wrap(2, PixelTransferi, void, (GLenum, GLint)) -BGL_Wrap(2, PixelZoom, void, (GLfloat, GLfloat)) -BGL_Wrap(1, PointSize, void, (GLfloat)) -BGL_Wrap(2, PolygonMode, void, (GLenum, GLenum)) -BGL_Wrap(2, PolygonOffset, void, (GLfloat, GLfloat)) -BGL_Wrap(1, PolygonStipple, void, (GLubyteP)) -BGL_Wrap(1, PopAttrib, void, (void)) -BGL_Wrap(1, PopMatrix, void, (void)) -BGL_Wrap(1, PopName, void, (void)) -BGL_Wrap(3, PrioritizeTextures, void, (GLsizei, GLuintP, GLclampfP)) -BGL_Wrap(1, PushAttrib, void, (GLbitfield)) -BGL_Wrap(1, PushMatrix, void, (void)) -BGL_Wrap(1, PushName, void, (GLuint)) -BGL_Wrap(2, RasterPos2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos2dv, void, (GLdoubleP)) -BGL_Wrap(2, RasterPos2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos2fv, void, (GLfloatP)) -BGL_Wrap(2, RasterPos2i, void, (GLint, GLint)) -BGL_Wrap(1, RasterPos2iv, void, (GLintP)) -BGL_Wrap(2, RasterPos2s, void, (GLshort, GLshort)) -BGL_Wrap(1, RasterPos2sv, void, (GLshortP)) -BGL_Wrap(3, RasterPos3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos3dv, void, (GLdoubleP)) -BGL_Wrap(3, RasterPos3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos3fv, void, (GLfloatP)) -BGL_Wrap(3, RasterPos3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, RasterPos3iv, void, (GLintP)) -BGL_Wrap(3, RasterPos3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, RasterPos3sv, void, (GLshortP)) -BGL_Wrap(4, RasterPos4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, RasterPos4dv, void, (GLdoubleP)) -BGL_Wrap(4, RasterPos4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, RasterPos4fv, void, (GLfloatP)) -BGL_Wrap(4, RasterPos4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, RasterPos4iv, void, (GLintP)) -BGL_Wrap(4, RasterPos4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, RasterPos4sv, void, (GLshortP)) -BGL_Wrap(1, ReadBuffer, void, (GLenum)) -BGL_Wrap(7, ReadPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)) -BGL_Wrap(4, Rectd, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(2, Rectdv, void, (GLdoubleP, GLdoubleP)) -BGL_Wrap(4, Rectf, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(2, Rectfv, void, (GLfloatP, GLfloatP)) -BGL_Wrap(4, Recti, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(2, Rectiv, void, (GLintP, GLintP)) -BGL_Wrap(4, Rects, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(2, Rectsv, void, (GLshortP, GLshortP)) -BGL_Wrap(1, RenderMode, GLint, (GLenum)) -BGL_Wrap(4, Rotated, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(4, Rotatef, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(3, Scaled, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(3, Scalef, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(4, Scissor, void, (GLint, GLint, GLsizei, GLsizei)) -BGL_Wrap(2, SelectBuffer, void, (GLsizei, GLuintP)) -BGL_Wrap(1, ShadeModel, void, (GLenum)) -BGL_Wrap(3, StencilFunc, void, (GLenum, GLint, GLuint)) -BGL_Wrap(1, StencilMask, void, (GLuint)) -BGL_Wrap(3, StencilOp, void, (GLenum, GLenum, GLenum)) -BGL_Wrap(1, TexCoord1d, void, (GLdouble)) -BGL_Wrap(1, TexCoord1dv, void, (GLdoubleP)) -BGL_Wrap(1, TexCoord1f, void, (GLfloat)) -BGL_Wrap(1, TexCoord1fv, void, (GLfloatP)) -BGL_Wrap(1, TexCoord1i, void, (GLint)) -BGL_Wrap(1, TexCoord1iv, void, (GLintP)) -BGL_Wrap(1, TexCoord1s, void, (GLshort)) -BGL_Wrap(1, TexCoord1sv, void, (GLshortP)) -BGL_Wrap(2, TexCoord2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord2dv, void, (GLdoubleP)) -BGL_Wrap(2, TexCoord2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord2fv, void, (GLfloatP)) -BGL_Wrap(2, TexCoord2i, void, (GLint, GLint)) -BGL_Wrap(1, TexCoord2iv, void, (GLintP)) -BGL_Wrap(2, TexCoord2s, void, (GLshort, GLshort)) -BGL_Wrap(1, TexCoord2sv, void, (GLshortP)) -BGL_Wrap(3, TexCoord3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord3dv, void, (GLdoubleP)) -BGL_Wrap(3, TexCoord3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord3fv, void, (GLfloatP)) -BGL_Wrap(3, TexCoord3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, TexCoord3iv, void, (GLintP)) -BGL_Wrap(3, TexCoord3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, TexCoord3sv, void, (GLshortP)) -BGL_Wrap(4, TexCoord4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, TexCoord4dv, void, (GLdoubleP)) -BGL_Wrap(4, TexCoord4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, TexCoord4fv, void, (GLfloatP)) -BGL_Wrap(4, TexCoord4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, TexCoord4iv, void, (GLintP)) -BGL_Wrap(4, TexCoord4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, TexCoord4sv, void, (GLshortP)) -BGL_Wrap(3, TexEnvf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexEnvfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexEnvi, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexEnviv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, TexGend, void, (GLenum, GLenum, GLdouble)) -BGL_Wrap(3, TexGendv, void, (GLenum, GLenum, GLdoubleP)) -BGL_Wrap(3, TexGenf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexGenfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexGeni, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexGeniv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(8, TexImage1D, void, (GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(9, TexImage2D, void, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)) -BGL_Wrap(3, TexParameterf, void, (GLenum, GLenum, GLfloat)) -BGL_Wrap(3, TexParameterfv, void, (GLenum, GLenum, GLfloatP)) -BGL_Wrap(3, TexParameteri, void, (GLenum, GLenum, GLint)) -BGL_Wrap(3, TexParameteriv, void, (GLenum, GLenum, GLintP)) -BGL_Wrap(3, Translated, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(3, Translatef, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(2, Vertex2d, void, (GLdouble, GLdouble)) -BGL_Wrap(1, Vertex2dv, void, (GLdoubleP)) -BGL_Wrap(2, Vertex2f, void, (GLfloat, GLfloat)) -BGL_Wrap(1, Vertex2fv, void, (GLfloatP)) -BGL_Wrap(2, Vertex2i, void, (GLint, GLint)) -BGL_Wrap(1, Vertex2iv, void, (GLintP)) -BGL_Wrap(2, Vertex2s, void, (GLshort, GLshort)) -BGL_Wrap(1, Vertex2sv, void, (GLshortP)) -BGL_Wrap(3, Vertex3d, void, (GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Vertex3dv, void, (GLdoubleP)) -BGL_Wrap(3, Vertex3f, void, (GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Vertex3fv, void, (GLfloatP)) -BGL_Wrap(3, Vertex3i, void, (GLint, GLint, GLint)) -BGL_Wrap(1, Vertex3iv, void, (GLintP)) -BGL_Wrap(3, Vertex3s, void, (GLshort, GLshort, GLshort)) -BGL_Wrap(1, Vertex3sv, void, (GLshortP)) -BGL_Wrap(4, Vertex4d, void, (GLdouble, GLdouble, GLdouble, GLdouble)) -BGL_Wrap(1, Vertex4dv, void, (GLdoubleP)) -BGL_Wrap(4, Vertex4f, void, (GLfloat, GLfloat, GLfloat, GLfloat)) -BGL_Wrap(1, Vertex4fv, void, (GLfloatP)) -BGL_Wrap(4, Vertex4i, void, (GLint, GLint, GLint, GLint)) -BGL_Wrap(1, Vertex4iv, void, (GLintP)) -BGL_Wrap(4, Vertex4s, void, (GLshort, GLshort, GLshort, GLshort)) -BGL_Wrap(1, Vertex4sv, void, (GLshortP)) -BGL_Wrap(4, Viewport, void, (GLint, GLint, GLsizei, GLsizei)) -#endif - -/* XXX */ -#undef MethodDef -#define MethodDef(func) {"gl"#func, Method_##func, METH_VARARGS} - -static struct PyMethodDef BGL_methods[] = { - {"Buffer", Method_Buffer, METH_VARARGS, Method_Buffer_doc}, -#ifndef __APPLE__ - MethodDef( Accum), - MethodDef( AlphaFunc), - MethodDef( AreTexturesResident), - MethodDef( Begin), - MethodDef( BindTexture), - MethodDef( Bitmap), - MethodDef( BlendFunc), - MethodDef( CallList), - MethodDef( CallLists), - MethodDef( Clear), - MethodDef( ClearAccum), - MethodDef( ClearColor), - MethodDef( ClearDepth), - MethodDef( ClearIndex), - MethodDef( ClearStencil), - MethodDef( ClipPlane), - MethodDef( Color3b), - MethodDef( Color3bv), - MethodDef( Color3d), - MethodDef( Color3dv), - MethodDef( Color3f), - MethodDef( Color3fv), - MethodDef( Color3i), - MethodDef( Color3iv), - MethodDef( Color3s), - MethodDef( Color3sv), - MethodDef( Color3ub), - MethodDef( Color3ubv), - MethodDef( Color3ui), - MethodDef( Color3uiv), - MethodDef( Color3us), - MethodDef( Color3usv), - MethodDef( Color4b), - MethodDef( Color4bv), - MethodDef( Color4d), - MethodDef( Color4dv), - MethodDef( Color4f), - MethodDef( Color4fv), - MethodDef( Color4i), - MethodDef( Color4iv), - MethodDef( Color4s), - MethodDef( Color4sv), - MethodDef( Color4ub), - MethodDef( Color4ubv), - MethodDef( Color4ui), - MethodDef( Color4uiv), - MethodDef( Color4us), - MethodDef( Color4usv), - MethodDef( ColorMask), - MethodDef( ColorMaterial), - MethodDef( CopyPixels), - MethodDef( CullFace), - MethodDef( DeleteLists), - MethodDef( DeleteTextures), - MethodDef( DepthFunc), - MethodDef( DepthMask), - MethodDef( DepthRange), - MethodDef( Disable), - MethodDef( DrawBuffer), - MethodDef( DrawPixels), - MethodDef( EdgeFlag), - MethodDef( EdgeFlagv), - MethodDef( Enable), - MethodDef( End), - MethodDef( EndList), - MethodDef( EvalCoord1d), - MethodDef( EvalCoord1dv), - MethodDef( EvalCoord1f), - MethodDef( EvalCoord1fv), - MethodDef( EvalCoord2d), - MethodDef( EvalCoord2dv), - MethodDef( EvalCoord2f), - MethodDef( EvalCoord2fv), - MethodDef( EvalMesh1), - MethodDef( EvalMesh2), - MethodDef( EvalPoint1), - MethodDef( EvalPoint2), - MethodDef( FeedbackBuffer), - MethodDef( Finish), - MethodDef( Flush), - MethodDef( Fogf), - MethodDef( Fogfv), - MethodDef( Fogi), - MethodDef( Fogiv), - MethodDef( FrontFace), - MethodDef( Frustum), - MethodDef( GenLists), - MethodDef( GenTextures), - MethodDef( GetBooleanv), - MethodDef( GetClipPlane), - MethodDef( GetDoublev), - MethodDef( GetError), - MethodDef( GetFloatv), - MethodDef( GetIntegerv), - MethodDef( GetLightfv), - MethodDef( GetLightiv), - MethodDef( GetMapdv), - MethodDef( GetMapfv), - MethodDef( GetMapiv), - MethodDef( GetMaterialfv), - MethodDef( GetMaterialiv), - MethodDef( GetPixelMapfv), - MethodDef( GetPixelMapuiv), - MethodDef( GetPixelMapusv), - MethodDef( GetPolygonStipple), - MethodDef( GetString), - MethodDef( GetTexEnvfv), - MethodDef( GetTexEnviv), - MethodDef( GetTexGendv), - MethodDef( GetTexGenfv), - MethodDef( GetTexGeniv), - MethodDef( GetTexImage), - MethodDef( GetTexLevelParameterfv), - MethodDef( GetTexLevelParameteriv), - MethodDef( GetTexParameterfv), - MethodDef( GetTexParameteriv), - MethodDef( Hint), - MethodDef( IndexMask), - MethodDef( Indexd), - MethodDef( Indexdv), - MethodDef( Indexf), - MethodDef( Indexfv), - MethodDef( Indexi), - MethodDef( Indexiv), - MethodDef( Indexs), - MethodDef( Indexsv), - MethodDef( InitNames), - MethodDef( IsEnabled), - MethodDef( IsList), - MethodDef( IsTexture), - MethodDef( LightModelf), - MethodDef( LightModelfv), - MethodDef( LightModeli), - MethodDef( LightModeliv), - MethodDef( Lightf), - MethodDef( Lightfv), - MethodDef( Lighti), - MethodDef( Lightiv), - MethodDef( LineStipple), - MethodDef( LineWidth), - MethodDef( ListBase), - MethodDef( LoadIdentity), - MethodDef( LoadMatrixd), - MethodDef( LoadMatrixf), - MethodDef( LoadName), - MethodDef( LogicOp), - MethodDef( Map1d), - MethodDef( Map1f), - MethodDef( Map2d), - MethodDef( Map2f), - MethodDef( MapGrid1d), - MethodDef( MapGrid1f), - MethodDef( MapGrid2d), - MethodDef( MapGrid2f), - MethodDef( Materialf), - MethodDef( Materialfv), - MethodDef( Materiali), - MethodDef( Materialiv), - MethodDef( MatrixMode), - MethodDef( MultMatrixd), - MethodDef( MultMatrixf), - MethodDef( NewList), - MethodDef( Normal3b), - MethodDef( Normal3bv), - MethodDef( Normal3d), - MethodDef( Normal3dv), - MethodDef( Normal3f), - MethodDef( Normal3fv), - MethodDef( Normal3i), - MethodDef( Normal3iv), - MethodDef( Normal3s), - MethodDef( Normal3sv), - MethodDef( Ortho), - MethodDef( PassThrough), - MethodDef( PixelMapfv), - MethodDef( PixelMapuiv), - MethodDef( PixelMapusv), - MethodDef( PixelStoref), - MethodDef( PixelStorei), - MethodDef( PixelTransferf), - MethodDef( PixelTransferi), - MethodDef( PixelZoom), - MethodDef( PointSize), - MethodDef( PolygonMode), - MethodDef( PolygonOffset), - MethodDef( PolygonStipple), - MethodDef( PopAttrib), - MethodDef( PopMatrix), - MethodDef( PopName), - MethodDef( PrioritizeTextures), - MethodDef( PushAttrib), - MethodDef( PushMatrix), - MethodDef( PushName), - MethodDef( RasterPos2d), - MethodDef( RasterPos2dv), - MethodDef( RasterPos2f), - MethodDef( RasterPos2fv), - MethodDef( RasterPos2i), - MethodDef( RasterPos2iv), - MethodDef( RasterPos2s), - MethodDef( RasterPos2sv), - MethodDef( RasterPos3d), - MethodDef( RasterPos3dv), - MethodDef( RasterPos3f), - MethodDef( RasterPos3fv), - MethodDef( RasterPos3i), - MethodDef( RasterPos3iv), - MethodDef( RasterPos3s), - MethodDef( RasterPos3sv), - MethodDef( RasterPos4d), - MethodDef( RasterPos4dv), - MethodDef( RasterPos4f), - MethodDef( RasterPos4fv), - MethodDef( RasterPos4i), - MethodDef( RasterPos4iv), - MethodDef( RasterPos4s), - MethodDef( RasterPos4sv), - MethodDef( ReadBuffer), - MethodDef( ReadPixels), - MethodDef( Rectd), - MethodDef( Rectdv), - MethodDef( Rectf), - MethodDef( Rectfv), - MethodDef( Recti), - MethodDef( Rectiv), - MethodDef( Rects), - MethodDef( Rectsv), - MethodDef( RenderMode), - MethodDef( Rotated), - MethodDef( Rotatef), - MethodDef( Scaled), - MethodDef( Scalef), - MethodDef( Scissor), - MethodDef( SelectBuffer), - MethodDef( ShadeModel), - MethodDef( StencilFunc), - MethodDef( StencilMask), - MethodDef( StencilOp), - MethodDef( TexCoord1d), - MethodDef( TexCoord1dv), - MethodDef( TexCoord1f), - MethodDef( TexCoord1fv), - MethodDef( TexCoord1i), - MethodDef( TexCoord1iv), - MethodDef( TexCoord1s), - MethodDef( TexCoord1sv), - MethodDef( TexCoord2d), - MethodDef( TexCoord2dv), - MethodDef( TexCoord2f), - MethodDef( TexCoord2fv), - MethodDef( TexCoord2i), - MethodDef( TexCoord2iv), - MethodDef( TexCoord2s), - MethodDef( TexCoord2sv), - MethodDef( TexCoord3d), - MethodDef( TexCoord3dv), - MethodDef( TexCoord3f), - MethodDef( TexCoord3fv), - MethodDef( TexCoord3i), - MethodDef( TexCoord3iv), - MethodDef( TexCoord3s), - MethodDef( TexCoord3sv), - MethodDef( TexCoord4d), - MethodDef( TexCoord4dv), - MethodDef( TexCoord4f), - MethodDef( TexCoord4fv), - MethodDef( TexCoord4i), - MethodDef( TexCoord4iv), - MethodDef( TexCoord4s), - MethodDef( TexCoord4sv), - MethodDef( TexEnvf), - MethodDef( TexEnvfv), - MethodDef( TexEnvi), - MethodDef( TexEnviv), - MethodDef( TexGend), - MethodDef( TexGendv), - MethodDef( TexGenf), - MethodDef( TexGenfv), - MethodDef( TexGeni), - MethodDef( TexGeniv), - MethodDef( TexImage1D), - MethodDef( TexImage2D), - MethodDef( TexParameterf), - MethodDef( TexParameterfv), - MethodDef( TexParameteri), - MethodDef( TexParameteriv), - MethodDef( Translated), - MethodDef( Translatef), - MethodDef( Vertex2d), - MethodDef( Vertex2dv), - MethodDef( Vertex2f), - MethodDef( Vertex2fv), - MethodDef( Vertex2i), - MethodDef( Vertex2iv), - MethodDef( Vertex2s), - MethodDef( Vertex2sv), - MethodDef( Vertex3d), - MethodDef( Vertex3dv), - MethodDef( Vertex3f), - MethodDef( Vertex3fv), - MethodDef( Vertex3i), - MethodDef( Vertex3iv), - MethodDef( Vertex3s), - MethodDef( Vertex3sv), - MethodDef( Vertex4d), - MethodDef( Vertex4dv), - MethodDef( Vertex4f), - MethodDef( Vertex4fv), - MethodDef( Vertex4i), - MethodDef( Vertex4iv), - MethodDef( Vertex4s), - MethodDef( Vertex4sv), - MethodDef( Viewport), -#endif - - {NULL, NULL} -}; - -PyObject *init_py_bgl(void) -{ - PyObject *mod= Py_InitModule(SUBMODULE(BGL), BGL_methods); - PyObject *dict= PyModule_GetDict(mod); - - Buffer_Type.ob_type= &PyType_Type; - - BPY_ADDCONST(dict, GL_CURRENT_BIT); - BPY_ADDCONST(dict, GL_POINT_BIT); - BPY_ADDCONST(dict, GL_LINE_BIT); - BPY_ADDCONST(dict, GL_POLYGON_BIT); - BPY_ADDCONST(dict, GL_POLYGON_STIPPLE_BIT); - BPY_ADDCONST(dict, GL_PIXEL_MODE_BIT); - BPY_ADDCONST(dict, GL_LIGHTING_BIT); - BPY_ADDCONST(dict, GL_FOG_BIT); - BPY_ADDCONST(dict, GL_DEPTH_BUFFER_BIT); - BPY_ADDCONST(dict, GL_ACCUM_BUFFER_BIT); - BPY_ADDCONST(dict, GL_STENCIL_BUFFER_BIT); - BPY_ADDCONST(dict, GL_VIEWPORT_BIT); - BPY_ADDCONST(dict, GL_TRANSFORM_BIT); - BPY_ADDCONST(dict, GL_ENABLE_BIT); - BPY_ADDCONST(dict, GL_COLOR_BUFFER_BIT); - BPY_ADDCONST(dict, GL_HINT_BIT); - BPY_ADDCONST(dict, GL_EVAL_BIT); - BPY_ADDCONST(dict, GL_LIST_BIT); - BPY_ADDCONST(dict, GL_TEXTURE_BIT); - BPY_ADDCONST(dict, GL_SCISSOR_BIT); - BPY_ADDCONST(dict, GL_ALL_ATTRIB_BITS); - - BPY_ADDCONST(dict, GL_FALSE); - BPY_ADDCONST(dict, GL_TRUE); - - BPY_ADDCONST(dict, GL_POINTS); - BPY_ADDCONST(dict, GL_LINES); - BPY_ADDCONST(dict, GL_LINE_LOOP); - BPY_ADDCONST(dict, GL_LINE_STRIP); - BPY_ADDCONST(dict, GL_TRIANGLES); - BPY_ADDCONST(dict, GL_TRIANGLE_STRIP); - BPY_ADDCONST(dict, GL_TRIANGLE_FAN); - BPY_ADDCONST(dict, GL_QUADS); - BPY_ADDCONST(dict, GL_QUAD_STRIP); - BPY_ADDCONST(dict, GL_POLYGON); - - BPY_ADDCONST(dict, GL_ACCUM); - BPY_ADDCONST(dict, GL_LOAD); - BPY_ADDCONST(dict, GL_RETURN); - BPY_ADDCONST(dict, GL_MULT); - BPY_ADDCONST(dict, GL_ADD); - - BPY_ADDCONST(dict, GL_NEVER); - BPY_ADDCONST(dict, GL_LESS); - BPY_ADDCONST(dict, GL_EQUAL); - BPY_ADDCONST(dict, GL_LEQUAL); - BPY_ADDCONST(dict, GL_GREATER); - BPY_ADDCONST(dict, GL_NOTEQUAL); - BPY_ADDCONST(dict, GL_GEQUAL); - BPY_ADDCONST(dict, GL_ALWAYS); - - BPY_ADDCONST(dict, GL_ZERO); - BPY_ADDCONST(dict, GL_ONE); - BPY_ADDCONST(dict, GL_SRC_COLOR); - BPY_ADDCONST(dict, GL_ONE_MINUS_SRC_COLOR); - BPY_ADDCONST(dict, GL_SRC_ALPHA); - BPY_ADDCONST(dict, GL_ONE_MINUS_SRC_ALPHA); - BPY_ADDCONST(dict, GL_DST_ALPHA); - BPY_ADDCONST(dict, GL_ONE_MINUS_DST_ALPHA); - - BPY_ADDCONST(dict, GL_DST_COLOR); - BPY_ADDCONST(dict, GL_ONE_MINUS_DST_COLOR); - BPY_ADDCONST(dict, GL_SRC_ALPHA_SATURATE); - - BPY_ADDCONST(dict, GL_NONE); - BPY_ADDCONST(dict, GL_FRONT_LEFT); - BPY_ADDCONST(dict, GL_FRONT_RIGHT); - BPY_ADDCONST(dict, GL_BACK_LEFT); - BPY_ADDCONST(dict, GL_BACK_RIGHT); - BPY_ADDCONST(dict, GL_FRONT); - BPY_ADDCONST(dict, GL_BACK); - BPY_ADDCONST(dict, GL_LEFT); - BPY_ADDCONST(dict, GL_RIGHT); - BPY_ADDCONST(dict, GL_FRONT_AND_BACK); - BPY_ADDCONST(dict, GL_AUX0); - BPY_ADDCONST(dict, GL_AUX1); - BPY_ADDCONST(dict, GL_AUX2); - BPY_ADDCONST(dict, GL_AUX3); - - BPY_ADDCONST(dict, GL_NO_ERROR); - BPY_ADDCONST(dict, GL_INVALID_ENUM); - BPY_ADDCONST(dict, GL_INVALID_VALUE); - BPY_ADDCONST(dict, GL_INVALID_OPERATION); - BPY_ADDCONST(dict, GL_STACK_OVERFLOW); - BPY_ADDCONST(dict, GL_STACK_UNDERFLOW); - BPY_ADDCONST(dict, GL_OUT_OF_MEMORY); - - BPY_ADDCONST(dict, GL_2D); - BPY_ADDCONST(dict, GL_3D); - BPY_ADDCONST(dict, GL_3D_COLOR); - BPY_ADDCONST(dict, GL_3D_COLOR_TEXTURE); - BPY_ADDCONST(dict, GL_4D_COLOR_TEXTURE); - - BPY_ADDCONST(dict, GL_PASS_THROUGH_TOKEN); - BPY_ADDCONST(dict, GL_POINT_TOKEN); - BPY_ADDCONST(dict, GL_LINE_TOKEN); - BPY_ADDCONST(dict, GL_POLYGON_TOKEN); - BPY_ADDCONST(dict, GL_BITMAP_TOKEN); - BPY_ADDCONST(dict, GL_DRAW_PIXEL_TOKEN); - BPY_ADDCONST(dict, GL_COPY_PIXEL_TOKEN); - BPY_ADDCONST(dict, GL_LINE_RESET_TOKEN); - - BPY_ADDCONST(dict, GL_EXP); - BPY_ADDCONST(dict, GL_EXP2); - - BPY_ADDCONST(dict, GL_CW); - BPY_ADDCONST(dict, GL_CCW); - - BPY_ADDCONST(dict, GL_COEFF); - BPY_ADDCONST(dict, GL_ORDER); - BPY_ADDCONST(dict, GL_DOMAIN); - - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_I); - BPY_ADDCONST(dict, GL_PIXEL_MAP_S_TO_S); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_R); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_G); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_B); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_A); - BPY_ADDCONST(dict, GL_PIXEL_MAP_R_TO_R); - BPY_ADDCONST(dict, GL_PIXEL_MAP_G_TO_G); - BPY_ADDCONST(dict, GL_PIXEL_MAP_B_TO_B); - BPY_ADDCONST(dict, GL_PIXEL_MAP_A_TO_A); - - BPY_ADDCONST(dict, GL_CURRENT_COLOR); - BPY_ADDCONST(dict, GL_CURRENT_INDEX); - BPY_ADDCONST(dict, GL_CURRENT_NORMAL); - BPY_ADDCONST(dict, GL_CURRENT_TEXTURE_COORDS); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_COLOR); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_INDEX); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_TEXTURE_COORDS); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_POSITION); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_POSITION_VALID); - BPY_ADDCONST(dict, GL_CURRENT_RASTER_DISTANCE); - BPY_ADDCONST(dict, GL_POINT_SMOOTH); - BPY_ADDCONST(dict, GL_POINT_SIZE); - BPY_ADDCONST(dict, GL_POINT_SIZE_RANGE); - BPY_ADDCONST(dict, GL_POINT_SIZE_GRANULARITY); - BPY_ADDCONST(dict, GL_LINE_SMOOTH); - BPY_ADDCONST(dict, GL_LINE_WIDTH); - BPY_ADDCONST(dict, GL_LINE_WIDTH_RANGE); - BPY_ADDCONST(dict, GL_LINE_WIDTH_GRANULARITY); - BPY_ADDCONST(dict, GL_LINE_STIPPLE); - BPY_ADDCONST(dict, GL_LINE_STIPPLE_PATTERN); - BPY_ADDCONST(dict, GL_LINE_STIPPLE_REPEAT); - BPY_ADDCONST(dict, GL_LIST_MODE); - BPY_ADDCONST(dict, GL_MAX_LIST_NESTING); - BPY_ADDCONST(dict, GL_LIST_BASE); - BPY_ADDCONST(dict, GL_LIST_INDEX); - BPY_ADDCONST(dict, GL_POLYGON_MODE); - BPY_ADDCONST(dict, GL_POLYGON_SMOOTH); - BPY_ADDCONST(dict, GL_POLYGON_STIPPLE); - BPY_ADDCONST(dict, GL_EDGE_FLAG); - BPY_ADDCONST(dict, GL_CULL_FACE); - BPY_ADDCONST(dict, GL_CULL_FACE_MODE); - BPY_ADDCONST(dict, GL_FRONT_FACE); - BPY_ADDCONST(dict, GL_LIGHTING); - BPY_ADDCONST(dict, GL_LIGHT_MODEL_LOCAL_VIEWER); - BPY_ADDCONST(dict, GL_LIGHT_MODEL_TWO_SIDE); - BPY_ADDCONST(dict, GL_LIGHT_MODEL_AMBIENT); - BPY_ADDCONST(dict, GL_SHADE_MODEL); - BPY_ADDCONST(dict, GL_COLOR_MATERIAL_FACE); - BPY_ADDCONST(dict, GL_COLOR_MATERIAL_PARAMETER); - BPY_ADDCONST(dict, GL_COLOR_MATERIAL); - BPY_ADDCONST(dict, GL_FOG); - BPY_ADDCONST(dict, GL_FOG_INDEX); - BPY_ADDCONST(dict, GL_FOG_DENSITY); - BPY_ADDCONST(dict, GL_FOG_START); - BPY_ADDCONST(dict, GL_FOG_END); - BPY_ADDCONST(dict, GL_FOG_MODE); - BPY_ADDCONST(dict, GL_FOG_COLOR); - BPY_ADDCONST(dict, GL_DEPTH_RANGE); - BPY_ADDCONST(dict, GL_DEPTH_TEST); - BPY_ADDCONST(dict, GL_DEPTH_WRITEMASK); - BPY_ADDCONST(dict, GL_DEPTH_CLEAR_VALUE); - BPY_ADDCONST(dict, GL_DEPTH_FUNC); - BPY_ADDCONST(dict, GL_ACCUM_CLEAR_VALUE); - BPY_ADDCONST(dict, GL_STENCIL_TEST); - BPY_ADDCONST(dict, GL_STENCIL_CLEAR_VALUE); - BPY_ADDCONST(dict, GL_STENCIL_FUNC); - BPY_ADDCONST(dict, GL_STENCIL_VALUE_MASK); - BPY_ADDCONST(dict, GL_STENCIL_FAIL); - BPY_ADDCONST(dict, GL_STENCIL_PASS_DEPTH_FAIL); - BPY_ADDCONST(dict, GL_STENCIL_PASS_DEPTH_PASS); - BPY_ADDCONST(dict, GL_STENCIL_REF); - BPY_ADDCONST(dict, GL_STENCIL_WRITEMASK); - BPY_ADDCONST(dict, GL_MATRIX_MODE); - BPY_ADDCONST(dict, GL_NORMALIZE); - BPY_ADDCONST(dict, GL_VIEWPORT); - BPY_ADDCONST(dict, GL_MODELVIEW_STACK_DEPTH); - BPY_ADDCONST(dict, GL_PROJECTION_STACK_DEPTH); - BPY_ADDCONST(dict, GL_TEXTURE_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MODELVIEW_MATRIX); - BPY_ADDCONST(dict, GL_PROJECTION_MATRIX); - BPY_ADDCONST(dict, GL_TEXTURE_MATRIX); - BPY_ADDCONST(dict, GL_ATTRIB_STACK_DEPTH); - BPY_ADDCONST(dict, GL_ALPHA_TEST); - BPY_ADDCONST(dict, GL_ALPHA_TEST_FUNC); - BPY_ADDCONST(dict, GL_ALPHA_TEST_REF); - BPY_ADDCONST(dict, GL_DITHER); - BPY_ADDCONST(dict, GL_BLEND_DST); - BPY_ADDCONST(dict, GL_BLEND_SRC); - BPY_ADDCONST(dict, GL_BLEND); - BPY_ADDCONST(dict, GL_LOGIC_OP_MODE); - BPY_ADDCONST(dict, GL_LOGIC_OP); - BPY_ADDCONST(dict, GL_AUX_BUFFERS); - BPY_ADDCONST(dict, GL_DRAW_BUFFER); - BPY_ADDCONST(dict, GL_READ_BUFFER); - BPY_ADDCONST(dict, GL_SCISSOR_BOX); - BPY_ADDCONST(dict, GL_SCISSOR_TEST); - BPY_ADDCONST(dict, GL_INDEX_CLEAR_VALUE); - BPY_ADDCONST(dict, GL_INDEX_WRITEMASK); - BPY_ADDCONST(dict, GL_COLOR_CLEAR_VALUE); - BPY_ADDCONST(dict, GL_COLOR_WRITEMASK); - BPY_ADDCONST(dict, GL_INDEX_MODE); - BPY_ADDCONST(dict, GL_RGBA_MODE); - BPY_ADDCONST(dict, GL_DOUBLEBUFFER); - BPY_ADDCONST(dict, GL_STEREO); - BPY_ADDCONST(dict, GL_RENDER_MODE); - BPY_ADDCONST(dict, GL_PERSPECTIVE_CORRECTION_HINT); - BPY_ADDCONST(dict, GL_POINT_SMOOTH_HINT); - BPY_ADDCONST(dict, GL_LINE_SMOOTH_HINT); - BPY_ADDCONST(dict, GL_POLYGON_SMOOTH_HINT); - BPY_ADDCONST(dict, GL_FOG_HINT); - BPY_ADDCONST(dict, GL_TEXTURE_GEN_S); - BPY_ADDCONST(dict, GL_TEXTURE_GEN_T); - BPY_ADDCONST(dict, GL_TEXTURE_GEN_R); - BPY_ADDCONST(dict, GL_TEXTURE_GEN_Q); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_I_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_S_TO_S_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_R_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_G_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_B_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_A_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_R_TO_R_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_G_TO_G_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_B_TO_B_SIZE); - BPY_ADDCONST(dict, GL_PIXEL_MAP_A_TO_A_SIZE); - BPY_ADDCONST(dict, GL_UNPACK_SWAP_BYTES); - BPY_ADDCONST(dict, GL_UNPACK_LSB_FIRST); - BPY_ADDCONST(dict, GL_UNPACK_ROW_LENGTH); - BPY_ADDCONST(dict, GL_UNPACK_SKIP_ROWS); - BPY_ADDCONST(dict, GL_UNPACK_SKIP_PIXELS); - BPY_ADDCONST(dict, GL_UNPACK_ALIGNMENT); - BPY_ADDCONST(dict, GL_PACK_SWAP_BYTES); - BPY_ADDCONST(dict, GL_PACK_LSB_FIRST); - BPY_ADDCONST(dict, GL_PACK_ROW_LENGTH); - BPY_ADDCONST(dict, GL_PACK_SKIP_ROWS); - BPY_ADDCONST(dict, GL_PACK_SKIP_PIXELS); - BPY_ADDCONST(dict, GL_PACK_ALIGNMENT); - BPY_ADDCONST(dict, GL_MAP_COLOR); - BPY_ADDCONST(dict, GL_MAP_STENCIL); - BPY_ADDCONST(dict, GL_INDEX_SHIFT); - BPY_ADDCONST(dict, GL_INDEX_OFFSET); - BPY_ADDCONST(dict, GL_RED_SCALE); - BPY_ADDCONST(dict, GL_RED_BIAS); - BPY_ADDCONST(dict, GL_ZOOM_X); - BPY_ADDCONST(dict, GL_ZOOM_Y); - BPY_ADDCONST(dict, GL_GREEN_SCALE); - BPY_ADDCONST(dict, GL_GREEN_BIAS); - BPY_ADDCONST(dict, GL_BLUE_SCALE); - BPY_ADDCONST(dict, GL_BLUE_BIAS); - BPY_ADDCONST(dict, GL_ALPHA_SCALE); - BPY_ADDCONST(dict, GL_ALPHA_BIAS); - BPY_ADDCONST(dict, GL_DEPTH_SCALE); - BPY_ADDCONST(dict, GL_DEPTH_BIAS); - BPY_ADDCONST(dict, GL_MAX_EVAL_ORDER); - BPY_ADDCONST(dict, GL_MAX_LIGHTS); - BPY_ADDCONST(dict, GL_MAX_CLIP_PLANES); - BPY_ADDCONST(dict, GL_MAX_TEXTURE_SIZE); - BPY_ADDCONST(dict, GL_MAX_PIXEL_MAP_TABLE); - BPY_ADDCONST(dict, GL_MAX_ATTRIB_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MAX_MODELVIEW_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MAX_NAME_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MAX_PROJECTION_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MAX_TEXTURE_STACK_DEPTH); - BPY_ADDCONST(dict, GL_MAX_VIEWPORT_DIMS); - BPY_ADDCONST(dict, GL_SUBPIXEL_BITS); - BPY_ADDCONST(dict, GL_INDEX_BITS); - BPY_ADDCONST(dict, GL_RED_BITS); - BPY_ADDCONST(dict, GL_GREEN_BITS); - BPY_ADDCONST(dict, GL_BLUE_BITS); - BPY_ADDCONST(dict, GL_ALPHA_BITS); - BPY_ADDCONST(dict, GL_DEPTH_BITS); - BPY_ADDCONST(dict, GL_STENCIL_BITS); - BPY_ADDCONST(dict, GL_ACCUM_RED_BITS); - BPY_ADDCONST(dict, GL_ACCUM_GREEN_BITS); - BPY_ADDCONST(dict, GL_ACCUM_BLUE_BITS); - BPY_ADDCONST(dict, GL_ACCUM_ALPHA_BITS); - BPY_ADDCONST(dict, GL_NAME_STACK_DEPTH); - BPY_ADDCONST(dict, GL_AUTO_NORMAL); - BPY_ADDCONST(dict, GL_MAP1_COLOR_4); - BPY_ADDCONST(dict, GL_MAP1_INDEX); - BPY_ADDCONST(dict, GL_MAP1_NORMAL); - BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_1); - BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_2); - BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_3); - BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_4); - BPY_ADDCONST(dict, GL_MAP1_VERTEX_3); - BPY_ADDCONST(dict, GL_MAP1_VERTEX_4); - BPY_ADDCONST(dict, GL_MAP2_COLOR_4); - BPY_ADDCONST(dict, GL_MAP2_INDEX); - BPY_ADDCONST(dict, GL_MAP2_NORMAL); - BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_1); - BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_2); - BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_3); - BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_4); - BPY_ADDCONST(dict, GL_MAP2_VERTEX_3); - BPY_ADDCONST(dict, GL_MAP2_VERTEX_4); - BPY_ADDCONST(dict, GL_MAP1_GRID_DOMAIN); - BPY_ADDCONST(dict, GL_MAP1_GRID_SEGMENTS); - BPY_ADDCONST(dict, GL_MAP2_GRID_DOMAIN); - BPY_ADDCONST(dict, GL_MAP2_GRID_SEGMENTS); - BPY_ADDCONST(dict, GL_TEXTURE_1D); - BPY_ADDCONST(dict, GL_TEXTURE_2D); - - BPY_ADDCONST(dict, GL_TEXTURE_WIDTH); - BPY_ADDCONST(dict, GL_TEXTURE_HEIGHT); - BPY_ADDCONST(dict, GL_TEXTURE_COMPONENTS); - BPY_ADDCONST(dict, GL_TEXTURE_BORDER_COLOR); - BPY_ADDCONST(dict, GL_TEXTURE_BORDER); - - BPY_ADDCONST(dict, GL_DONT_CARE); - BPY_ADDCONST(dict, GL_FASTEST); - BPY_ADDCONST(dict, GL_NICEST); - - BPY_ADDCONST(dict, GL_AMBIENT); - BPY_ADDCONST(dict, GL_DIFFUSE); - BPY_ADDCONST(dict, GL_SPECULAR); - BPY_ADDCONST(dict, GL_POSITION); - BPY_ADDCONST(dict, GL_SPOT_DIRECTION); - BPY_ADDCONST(dict, GL_SPOT_EXPONENT); - BPY_ADDCONST(dict, GL_SPOT_CUTOFF); - BPY_ADDCONST(dict, GL_CONSTANT_ATTENUATION); - BPY_ADDCONST(dict, GL_LINEAR_ATTENUATION); - BPY_ADDCONST(dict, GL_QUADRATIC_ATTENUATION); - - BPY_ADDCONST(dict, GL_COMPILE); - BPY_ADDCONST(dict, GL_COMPILE_AND_EXECUTE); - - BPY_ADDCONST(dict, GL_BYTE); - BPY_ADDCONST(dict, GL_UNSIGNED_BYTE); - BPY_ADDCONST(dict, GL_SHORT); - BPY_ADDCONST(dict, GL_UNSIGNED_SHORT); - BPY_ADDCONST(dict, GL_INT); - BPY_ADDCONST(dict, GL_UNSIGNED_INT); - BPY_ADDCONST(dict, GL_FLOAT); - BPY_ADDCONST(dict, GL_2_BYTES); - BPY_ADDCONST(dict, GL_3_BYTES); - BPY_ADDCONST(dict, GL_4_BYTES); - - BPY_ADDCONST(dict, GL_CLEAR); - BPY_ADDCONST(dict, GL_AND); - BPY_ADDCONST(dict, GL_AND_REVERSE); - BPY_ADDCONST(dict, GL_COPY); - BPY_ADDCONST(dict, GL_AND_INVERTED); - BPY_ADDCONST(dict, GL_NOOP); - BPY_ADDCONST(dict, GL_XOR); - BPY_ADDCONST(dict, GL_OR); - BPY_ADDCONST(dict, GL_NOR); - BPY_ADDCONST(dict, GL_EQUIV); - BPY_ADDCONST(dict, GL_INVERT); - BPY_ADDCONST(dict, GL_OR_REVERSE); - BPY_ADDCONST(dict, GL_COPY_INVERTED); - BPY_ADDCONST(dict, GL_OR_INVERTED); - BPY_ADDCONST(dict, GL_NAND); - BPY_ADDCONST(dict, GL_SET); - - BPY_ADDCONST(dict, GL_EMISSION); - BPY_ADDCONST(dict, GL_SHININESS); - BPY_ADDCONST(dict, GL_AMBIENT_AND_DIFFUSE); - BPY_ADDCONST(dict, GL_COLOR_INDEXES); - - BPY_ADDCONST(dict, GL_MODELVIEW); - BPY_ADDCONST(dict, GL_PROJECTION); - BPY_ADDCONST(dict, GL_TEXTURE); - - BPY_ADDCONST(dict, GL_COLOR); - BPY_ADDCONST(dict, GL_DEPTH); - BPY_ADDCONST(dict, GL_STENCIL); - - BPY_ADDCONST(dict, GL_COLOR_INDEX); - BPY_ADDCONST(dict, GL_STENCIL_INDEX); - BPY_ADDCONST(dict, GL_DEPTH_COMPONENT); - BPY_ADDCONST(dict, GL_RED); - BPY_ADDCONST(dict, GL_GREEN); - BPY_ADDCONST(dict, GL_BLUE); - BPY_ADDCONST(dict, GL_ALPHA); - BPY_ADDCONST(dict, GL_RGB); - BPY_ADDCONST(dict, GL_RGBA); - BPY_ADDCONST(dict, GL_LUMINANCE); - BPY_ADDCONST(dict, GL_LUMINANCE_ALPHA); - - BPY_ADDCONST(dict, GL_BITMAP); - - BPY_ADDCONST(dict, GL_POINT); - BPY_ADDCONST(dict, GL_LINE); - BPY_ADDCONST(dict, GL_FILL); - - BPY_ADDCONST(dict, GL_RENDER); - BPY_ADDCONST(dict, GL_FEEDBACK); - BPY_ADDCONST(dict, GL_SELECT); - - BPY_ADDCONST(dict, GL_FLAT); - BPY_ADDCONST(dict, GL_SMOOTH); - - BPY_ADDCONST(dict, GL_KEEP); - BPY_ADDCONST(dict, GL_REPLACE); - BPY_ADDCONST(dict, GL_INCR); - BPY_ADDCONST(dict, GL_DECR); - - BPY_ADDCONST(dict, GL_VENDOR); - BPY_ADDCONST(dict, GL_RENDERER); - BPY_ADDCONST(dict, GL_VERSION); - BPY_ADDCONST(dict, GL_EXTENSIONS); - - BPY_ADDCONST(dict, GL_S); - BPY_ADDCONST(dict, GL_T); - BPY_ADDCONST(dict, GL_R); - BPY_ADDCONST(dict, GL_Q); - - BPY_ADDCONST(dict, GL_MODULATE); - BPY_ADDCONST(dict, GL_DECAL); - - BPY_ADDCONST(dict, GL_TEXTURE_ENV_MODE); - BPY_ADDCONST(dict, GL_TEXTURE_ENV_COLOR); - - BPY_ADDCONST(dict, GL_TEXTURE_ENV); - - BPY_ADDCONST(dict, GL_EYE_LINEAR); - BPY_ADDCONST(dict, GL_OBJECT_LINEAR); - BPY_ADDCONST(dict, GL_SPHERE_MAP); - - BPY_ADDCONST(dict, GL_TEXTURE_GEN_MODE); - BPY_ADDCONST(dict, GL_OBJECT_PLANE); - BPY_ADDCONST(dict, GL_EYE_PLANE); - - BPY_ADDCONST(dict, GL_NEAREST); - BPY_ADDCONST(dict, GL_LINEAR); - - BPY_ADDCONST(dict, GL_NEAREST_MIPMAP_NEAREST); - BPY_ADDCONST(dict, GL_LINEAR_MIPMAP_NEAREST); - BPY_ADDCONST(dict, GL_NEAREST_MIPMAP_LINEAR); - BPY_ADDCONST(dict, GL_LINEAR_MIPMAP_LINEAR); - - BPY_ADDCONST(dict, GL_TEXTURE_MAG_FILTER); - BPY_ADDCONST(dict, GL_TEXTURE_MIN_FILTER); - BPY_ADDCONST(dict, GL_TEXTURE_WRAP_S); - BPY_ADDCONST(dict, GL_TEXTURE_WRAP_T); - - BPY_ADDCONST(dict, GL_CLAMP); - BPY_ADDCONST(dict, GL_REPEAT); - - BPY_ADDCONST(dict, GL_CLIP_PLANE0); - BPY_ADDCONST(dict, GL_CLIP_PLANE1); - BPY_ADDCONST(dict, GL_CLIP_PLANE2); - BPY_ADDCONST(dict, GL_CLIP_PLANE3); - BPY_ADDCONST(dict, GL_CLIP_PLANE4); - BPY_ADDCONST(dict, GL_CLIP_PLANE5); - - BPY_ADDCONST(dict, GL_LIGHT0); - BPY_ADDCONST(dict, GL_LIGHT1); - BPY_ADDCONST(dict, GL_LIGHT2); - BPY_ADDCONST(dict, GL_LIGHT3); - BPY_ADDCONST(dict, GL_LIGHT4); - BPY_ADDCONST(dict, GL_LIGHT5); - BPY_ADDCONST(dict, GL_LIGHT6); - BPY_ADDCONST(dict, GL_LIGHT7); - - BPY_ADDCONST(dict, GL_POLYGON_OFFSET_UNITS); - BPY_ADDCONST(dict, GL_POLYGON_OFFSET_POINT); - BPY_ADDCONST(dict, GL_POLYGON_OFFSET_LINE); - BPY_ADDCONST(dict, GL_POLYGON_OFFSET_FILL); - BPY_ADDCONST(dict, GL_POLYGON_OFFSET_FACTOR); - - BPY_ADDCONST(dict, GL_TEXTURE_PRIORITY); - BPY_ADDCONST(dict, GL_TEXTURE_RESIDENT); - BPY_ADDCONST(dict, GL_TEXTURE_BINDING_1D); - BPY_ADDCONST(dict, GL_TEXTURE_BINDING_2D); - - return mod; -} - -void initDraw(void) -{ - init_py_draw(); - init_py_bgl(); -} |