/* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 1.3.23 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make * changes to this file unless you know what you are doing--modify the SWIG * interface file instead. * ----------------------------------------------------------------------------- */ #define SWIGPYTHON #ifndef SWIG_TEMPLATE_DISAMBIGUATOR # if defined(__SUNPRO_CC) # define SWIG_TEMPLATE_DISAMBIGUATOR template # else # define SWIG_TEMPLATE_DISAMBIGUATOR # endif #endif #include /*********************************************************************** * common.swg * * This file contains generic SWIG runtime support for pointer * type checking as well as a few commonly used macros to control * external linkage. * * Author : David Beazley (beazley@cs.uchicago.edu) * * Copyright (c) 1999-2000, The University of Chicago * * This file may be freely redistributed without license or fee provided * this copyright message remains intact. ************************************************************************/ #include #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if !defined(STATIC_LINKED) # define SWIGEXPORT(a) __declspec(dllexport) a # else # define SWIGEXPORT(a) a # endif #else # define SWIGEXPORT(a) a #endif #define SWIGRUNTIME(x) static x #ifndef SWIGINLINE #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline #else # define SWIGINLINE #endif #endif /* This should only be incremented when either the layout of swig_type_info changes, or for whatever reason, the runtime changes incompatibly */ #define SWIG_RUNTIME_VERSION "1" /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE #define SWIG_QUOTE_STRING(x) #x #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) #else #define SWIG_TYPE_TABLE_NAME #endif #ifdef __cplusplus extern "C" { #endif typedef void *(*swig_converter_func)(void *); typedef struct swig_type_info *(*swig_dycast_func)(void **); typedef struct swig_type_info { const char *name; swig_converter_func converter; const char *str; void *clientdata; swig_dycast_func dcast; struct swig_type_info *next; struct swig_type_info *prev; } swig_type_info; static swig_type_info *swig_type_list = 0; static swig_type_info **swig_type_list_handle = &swig_type_list; /* Compare two type names skipping the space characters, therefore "char*" == "char *" and "Class" == "Class", etc. Return 0 when the two name types are equivalent, as in strncmp, but skipping ' '. */ static int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2) { for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { while ((*f1 == ' ') && (f1 != l1)) ++f1; while ((*f2 == ' ') && (f2 != l2)) ++f2; if (*f1 != *f2) return *f1 - *f2; } return (l1 - f1) - (l2 - f2); } /* Check type equivalence in a name list like ||... */ static int SWIG_TypeEquiv(const char *nb, const char *tb) { int equiv = 0; const char* te = tb + strlen(tb); const char* ne = nb; while (!equiv && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0; if (*ne) ++ne; } return equiv; } /* Register a type mapping with the type-checking */ static swig_type_info * SWIG_TypeRegister(swig_type_info *ti) { swig_type_info *tc, *head, *ret, *next; /* Check to see if this type has already been registered */ tc = *swig_type_list_handle; while (tc) { /* check simple type equivalence */ int typeequiv = (strcmp(tc->name, ti->name) == 0); /* check full type equivalence, resolving typedefs */ if (!typeequiv) { /* only if tc is not a typedef (no '|' on it) */ if (tc->str && ti->str && !strstr(tc->str,"|")) { typeequiv = SWIG_TypeEquiv(ti->str,tc->str); } } if (typeequiv) { /* Already exists in the table. Just add additional types to the list */ if (ti->clientdata) tc->clientdata = ti->clientdata; head = tc; next = tc->next; goto l1; } tc = tc->prev; } head = ti; next = 0; /* Place in list */ ti->prev = *swig_type_list_handle; *swig_type_list_handle = ti; /* Build linked lists */ l1: ret = head; tc = ti + 1; /* Patch up the rest of the links */ while (tc->name) { head->next = tc; tc->prev = head; head = tc; tc++; } if (next) next->prev = head; head->next = next; return ret; } /* Check the typename */ static swig_type_info * SWIG_TypeCheck(char *c, swig_type_info *ty) { swig_type_info *s; if (!ty) return 0; /* Void pointer */ s = ty->next; /* First element always just a name */ do { if (strcmp(s->name,c) == 0) { if (s == ty->next) return s; /* Move s to the top of the linked list */ s->prev->next = s->next; if (s->next) { s->next->prev = s->prev; } /* Insert s as second element in the list */ s->next = ty->next; if (ty->next) ty->next->prev = s; ty->next = s; s->prev = ty; return s; } s = s->next; } while (s && (s != ty->next)); return 0; } /* Cast a pointer up an inheritance hierarchy */ static SWIGINLINE void * SWIG_TypeCast(swig_type_info *ty, void *ptr) { if ((!ty) || (!ty->converter)) return ptr; return (*ty->converter)(ptr); } /* Dynamic pointer casting. Down an inheritance hierarchy */ static swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { swig_type_info *lastty = ty; if (!ty || !ty->dcast) return ty; while (ty && (ty->dcast)) { ty = (*ty->dcast)(ptr); if (ty) lastty = ty; } return lastty; } /* Return the name associated with this type */ static SWIGINLINE const char * SWIG_TypeName(const swig_type_info *ty) { return ty->name; } /* Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */ static const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the type, separated by vertical-bar characters. We choose to print the last name, as it is often (?) the most specific. */ if (type->str != NULL) { const char *last_name = type->str; const char *s; for (s = type->str; *s; s++) if (*s == '|') last_name = s+1; return last_name; } else return type->name; } /* Search for a swig_type_info structure */ static swig_type_info * SWIG_TypeQuery(const char *name) { swig_type_info *ty = *swig_type_list_handle; while (ty) { if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty; if (ty->name && (strcmp(name,ty->name) == 0)) return ty; ty = ty->prev; } return 0; } /* Set the clientdata field for a type */ static void SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { swig_type_info *tc, *equiv; if (ti->clientdata) return; /* if (ti->clientdata == clientdata) return; */ ti->clientdata = clientdata; equiv = ti->next; while (equiv) { if (!equiv->converter) { tc = *swig_type_list_handle; while (tc) { if ((strcmp(tc->name, equiv->name) == 0)) SWIG_TypeClientData(tc,clientdata); tc = tc->prev; } } equiv = equiv->next; } } /* Pack binary data into a string */ static char * SWIG_PackData(char *c, void *ptr, size_t sz) { static char hex[17] = "0123456789abcdef"; unsigned char *u = (unsigned char *) ptr; const unsigned char *eu = u + sz; register unsigned char uu; for (; u != eu; ++u) { uu = *u; *(c++) = hex[(uu & 0xf0) >> 4]; *(c++) = hex[uu & 0xf]; } return c; } /* Unpack binary data from a string */ static char * SWIG_UnpackData(char *c, void *ptr, size_t sz) { register unsigned char uu = 0; register int d; unsigned char *u = (unsigned char *) ptr; const unsigned char *eu = u + sz; for (; u != eu; ++u) { d = *(c++); if ((d >= '0') && (d <= '9')) uu = ((d - '0') << 4); else if ((d >= 'a') && (d <= 'f')) uu = ((d - ('a'-10)) << 4); d = *(c++); if ((d >= '0') && (d <= '9')) uu |= (d - '0'); else if ((d >= 'a') && (d <= 'f')) uu |= (d - ('a'-10)); *u = uu; } return c; } /* This function will propagate the clientdata field of type to * any new swig_type_info structures that have been added into the list * of equivalent types. It is like calling * SWIG_TypeClientData(type, clientdata) a second time. */ static void SWIG_PropagateClientData(swig_type_info *type) { swig_type_info *equiv = type->next; swig_type_info *tc; if (!type->clientdata) return; while (equiv) { if (!equiv->converter) { tc = *swig_type_list_handle; while (tc) { if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata) SWIG_TypeClientData(tc, type->clientdata); tc = tc->prev; } } equiv = equiv->next; } } #ifdef __cplusplus } #endif /* ----------------------------------------------------------------------------- * SWIG API. Portion that goes into the runtime * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #endif /* ----------------------------------------------------------------------------- * for internal method declarations * ----------------------------------------------------------------------------- */ #ifndef SWIGINTERN #define SWIGINTERN static #endif #ifndef SWIGINTERNSHORT #ifdef __cplusplus #define SWIGINTERNSHORT static inline #else /* C case */ #define SWIGINTERNSHORT static #endif /* __cplusplus */ #endif /* Common SWIG API */ #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags) #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags) #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) /* Python-specific SWIG API */ #define SWIG_newvarlink() SWIG_Python_newvarlink() #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags) #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) /* Exception handling in wrappers */ #define SWIG_fail goto fail #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0) #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1) #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj) #define SWIG_null_ref(type) SWIG_Python_NullRef(type) /* Contract support */ #define SWIG_contract_assert(expr, msg) \ if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else /* ----------------------------------------------------------------------------- * Constant declarations * ----------------------------------------------------------------------------- */ /* Constant Types */ #define SWIG_PY_INT 1 #define SWIG_PY_FLOAT 2 #define SWIG_PY_STRING 3 #define SWIG_PY_POINTER 4 #define SWIG_PY_BINARY 5 /* Constant information structure */ typedef struct swig_const_info { int type; char *name; long lvalue; double dvalue; void *pvalue; swig_type_info **ptype; } swig_const_info; /* ----------------------------------------------------------------------------- * Pointer declarations * ----------------------------------------------------------------------------- */ /* Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent C/C++ pointers in the python side. Very useful for debugging, but not always safe. */ #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES) # define SWIG_COBJECT_TYPES #endif /* Flags for pointer conversion */ #define SWIG_POINTER_EXCEPTION 0x1 #define SWIG_POINTER_DISOWN 0x2 /* ----------------------------------------------------------------------------- * Alloc. memory flags * ----------------------------------------------------------------------------- */ #define SWIG_OLDOBJ 1 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1 #define SWIG_PYSTR SWIG_NEWOBJ + 1 #ifdef __cplusplus } #endif /*********************************************************************** * pyrun.swg * * This file contains the runtime support for Python modules * and includes code for managing global variables and pointer * type checking. * * Author : David Beazley (beazley@cs.uchicago.edu) ************************************************************************/ #ifdef __cplusplus extern "C" { #endif /* ----------------------------------------------------------------------------- * global variable support code. * ----------------------------------------------------------------------------- */ typedef struct swig_globalvar { char *name; /* Name of global variable */ PyObject *(*get_attr)(); /* Return the current value */ int (*set_attr)(PyObject *); /* Set the value */ struct swig_globalvar *next; } swig_globalvar; typedef struct swig_varlinkobject { PyObject_HEAD swig_globalvar *vars; } swig_varlinkobject; static PyObject * swig_varlink_repr(swig_varlinkobject *v) { v = v; return PyString_FromString(""); } static int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) { swig_globalvar *var; flags = flags; fprintf(fp,"Global variables { "); for (var = v->vars; var; var=var->next) { fprintf(fp,"%s", var->name); if (var->next) fprintf(fp,", "); } fprintf(fp," }\n"); return 0; } static PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n) { swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { return (*var->get_attr)(); } var = var->next; } PyErr_SetString(PyExc_NameError,"Unknown C global variable"); return NULL; } static int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { return (*var->set_attr)(p); } var = var->next; } PyErr_SetString(PyExc_NameError,"Unknown C global variable"); return 1; } static PyTypeObject varlinktype = { PyObject_HEAD_INIT(0) 0, /* Number of items in variable part (ob_size) */ (char *)"swigvarlink", /* Type name (tp_name) */ sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ 0, /* Itemsize (tp_itemsize) */ 0, /* Deallocator (tp_dealloc) */ (printfunc) swig_varlink_print, /* Print (tp_print) */ (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ 0, /* tp_compare */ (reprfunc) swig_varlink_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ 0, /* tp_flags */ 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #ifdef COUNT_ALLOCS /* these must be last */ 0, /* tp_alloc */ 0, /* tp_free */ 0, /* tp_maxalloc */ 0, /* tp_next */ #endif }; /* Create a variable linking object for use later */ static PyObject * SWIG_Python_newvarlink(void) { swig_varlinkobject *result = 0; result = PyMem_NEW(swig_varlinkobject,1); varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ result->ob_type = &varlinktype; result->vars = 0; result->ob_refcnt = 0; Py_XINCREF((PyObject *) result); return ((PyObject*) result); } static void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { swig_varlinkobject *v; swig_globalvar *gv; v= (swig_varlinkobject *) p; gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); gv->name = (char *) malloc(strlen(name)+1); strcpy(gv->name,name); gv->get_attr = get_attr; gv->set_attr = set_attr; gv->next = v->vars; v->vars = gv; } /* ----------------------------------------------------------------------------- * errors manipulation * ----------------------------------------------------------------------------- */ static void SWIG_Python_TypeError(const char *type, PyObject *obj) { if (type) { if (!PyCObject_Check(obj)) { const char *otype = (obj ? obj->ob_type->tp_name : 0); if (otype) { PyObject *str = PyObject_Str(obj); const char *cstr = str ? PyString_AsString(str) : 0; if (cstr) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); } else { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); } Py_DECREF(str); return; } } else { const char *otype = (char *) PyCObject_GetDesc(obj); if (otype) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PyCObject(%s)' is received", type, otype); return; } } PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); } else { PyErr_Format(PyExc_TypeError, "unexpected type is received"); } } static SWIGINLINE void SWIG_Python_NullRef(const char *type) { if (type) { PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type); } else { PyErr_Format(PyExc_TypeError, "null reference was received"); } } static int SWIG_Python_AddErrMesg(const char* mesg, int infront) { if (PyErr_Occurred()) { PyObject *type = 0; PyObject *value = 0; PyObject *traceback = 0; PyErr_Fetch(&type, &value, &traceback); if (value) { PyObject *old_str = PyObject_Str(value); Py_XINCREF(type); PyErr_Clear(); if (infront) { PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); } else { PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); } Py_DECREF(old_str); } return 1; } else { return 0; } } static int SWIG_Python_ArgFail(int argnum) { if (PyErr_Occurred()) { /* add information about failing argument */ char mesg[256]; sprintf(mesg, "argument number %d:", argnum); return SWIG_Python_AddErrMesg(mesg, 1); } else { return 0; } } /* ----------------------------------------------------------------------------- * pointers/data manipulation * ----------------------------------------------------------------------------- */ /* Convert a pointer value */ static int SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) { swig_type_info *tc; char *c = 0; static PyObject *SWIG_this = 0; int newref = 0; PyObject *pyobj = 0; void *vptr; if (!obj) return 0; if (obj == Py_None) { *ptr = 0; return 0; } #ifdef SWIG_COBJECT_TYPES if (!(PyCObject_Check(obj))) { if (!SWIG_this) SWIG_this = PyString_FromString("this"); pyobj = obj; obj = PyObject_GetAttr(obj,SWIG_this); newref = 1; if (!obj) goto type_error; if (!PyCObject_Check(obj)) { Py_DECREF(obj); goto type_error; } } vptr = PyCObject_AsVoidPtr(obj); c = (char *) PyCObject_GetDesc(obj); if (newref) Py_DECREF(obj); goto type_check; #else if (!(PyString_Check(obj))) { if (!SWIG_this) SWIG_this = PyString_FromString("this"); pyobj = obj; obj = PyObject_GetAttr(obj,SWIG_this); newref = 1; if (!obj) goto type_error; if (!PyString_Check(obj)) { Py_DECREF(obj); goto type_error; } } c = PyString_AS_STRING(obj); /* Pointer values must start with leading underscore */ if (*c != '_') { if (strcmp(c,"NULL") == 0) { if (newref) { Py_DECREF(obj); } *ptr = (void *) 0; return 0; } else { if (newref) { Py_DECREF(obj); } goto type_error; } } c++; c = SWIG_UnpackData(c,&vptr,sizeof(void *)); if (newref) { Py_DECREF(obj); } #endif type_check: if (ty) { tc = SWIG_TypeCheck(c,ty); if (!tc) goto type_error; *ptr = SWIG_TypeCast(tc,vptr); } if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) { PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False); } return 0; type_error: PyErr_Clear(); if (pyobj && !obj) { obj = pyobj; if (PyCFunction_Check(obj)) { /* here we get the method pointer for callbacks */ char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); c = doc ? strstr(doc, "swig_ptr: ") : 0; if (c) { c += 10; if (*c == '_') { c++; c = SWIG_UnpackData(c,&vptr,sizeof(void *)); goto type_check; } } } } if (flags & SWIG_POINTER_EXCEPTION) { if (ty) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); } else { SWIG_Python_TypeError("C/C++ pointer", obj); } } return -1; } /* Convert a pointer value, signal an exception on a type mismatch */ static void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); if (flags & SWIG_POINTER_EXCEPTION) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); SWIG_Python_ArgFail(argnum); } } return result; } /* Convert a packed value value */ static int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) { swig_type_info *tc; char *c = 0; if ((!obj) || (!PyString_Check(obj))) goto type_error; c = PyString_AS_STRING(obj); /* Pointer values must start with leading underscore */ if (*c != '_') goto type_error; c++; c = SWIG_UnpackData(c,ptr,sz); if (ty) { tc = SWIG_TypeCheck(c,ty); if (!tc) goto type_error; } return 0; type_error: PyErr_Clear(); if (flags & SWIG_POINTER_EXCEPTION) { if (ty) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); } else { SWIG_Python_TypeError("C/C++ packed data", obj); } } return -1; } /* Create a new pointer string */ static char * SWIG_Python_PointerStr(char *buff, void *ptr, const char *name, size_t bsz) { char *r = buff; if ((2*sizeof(void *) + 2) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,&ptr,sizeof(void *)); if (strlen(name) + 1 > (bsz - (r - buff))) return 0; strcpy(r,name); return buff; } /* Create a new pointer object */ static PyObject * SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) { PyObject *robj; if (!ptr) { Py_INCREF(Py_None); return Py_None; } #ifdef SWIG_COBJECT_TYPES robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL); #else { char result[1024]; SWIG_Python_PointerStr(result, ptr, type->name, 1024); robj = PyString_FromString(result); } #endif if (!robj || (robj == Py_None)) return robj; if (type->clientdata) { PyObject *inst; PyObject *args = Py_BuildValue((char*)"(O)", robj); Py_DECREF(robj); inst = PyObject_CallObject((PyObject *) type->clientdata, args); Py_DECREF(args); if (inst) { if (own) { PyObject_SetAttrString(inst,(char*)"thisown",Py_True); } robj = inst; } } return robj; } static PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { char result[1024]; char *r = result; if ((2*sz + 2 + strlen(type->name)) > 1024) return 0; *(r++) = '_'; r = SWIG_PackData(r,ptr,sz); strcpy(r,type->name); return PyString_FromString(result); } /* ----------------------------------------------------------------------------- * constants/methods manipulation * ----------------------------------------------------------------------------- */ /* Install Constants */ static void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { int i; PyObject *obj; for (i = 0; constants[i].type; i++) { switch(constants[i].type) { case SWIG_PY_INT: obj = PyInt_FromLong(constants[i].lvalue); break; case SWIG_PY_FLOAT: obj = PyFloat_FromDouble(constants[i].dvalue); break; case SWIG_PY_STRING: if (constants[i].pvalue) { obj = PyString_FromString((char *) constants[i].pvalue); } else { Py_INCREF(Py_None); obj = Py_None; } break; case SWIG_PY_POINTER: obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); break; case SWIG_PY_BINARY: obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); break; default: obj = 0; break; } if (obj) { PyDict_SetItemString(d,constants[i].name,obj); Py_DECREF(obj); } } } /* Fix SwigMethods to carry the callback ptrs when needed */ static void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { int i; for (i = 0; methods[i].ml_name; ++i) { char *c = methods[i].ml_doc; if (c && (c = strstr(c, "swig_ptr: "))) { int j; swig_const_info *ci = 0; char *name = c + 10; for (j = 0; const_table[j].type; j++) { if (strncmp(const_table[j].name, name, strlen(const_table[j].name)) == 0) { ci = &(const_table[j]); break; } } if (ci) { size_t shift = (ci->ptype) - types; swig_type_info *ty = types_initial[shift]; size_t ldoc = (c - methods[i].ml_doc); size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; char *ndoc = (char*)malloc(ldoc + lptr + 10); char *buff = ndoc; void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue); strncpy(buff, methods[i].ml_doc, ldoc); buff += ldoc; strncpy(buff, "swig_ptr: ", 10); buff += 10; SWIG_Python_PointerStr(buff, ptr, ty->name, lptr); methods[i].ml_doc = ndoc; } } } } /* ----------------------------------------------------------------------------- * Lookup type pointer * ----------------------------------------------------------------------------- */ #if PY_MAJOR_VERSION < 2 /* PyModule_AddObject function was introduced in Python 2.0. The following function is copied out of Python/modsupport.c in python version 2.3.4 */ static int PyModule_AddObject(PyObject *m, char *name, PyObject *o) { PyObject *dict; if (!PyModule_Check(m)) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); return -1; } if (!o) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); return -1; } dict = PyModule_GetDict(m); if (dict == NULL) { /* Internal error -- modules must have a dict! */ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", PyModule_GetName(m)); return -1; } if (PyDict_SetItemString(dict, name, o)) return -1; Py_DECREF(o); return 0; } #endif static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} /* Sentinel */ }; static void SWIG_Python_LookupTypePointer(swig_type_info ***type_list_handle) { PyObject *module, *pointer; void *type_pointer; /* first check if module already created */ type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); if (type_pointer) { *type_list_handle = (swig_type_info **) type_pointer; } else { PyErr_Clear(); /* create a new module and variable */ module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); pointer = PyCObject_FromVoidPtr((void *) (*type_list_handle), NULL); if (pointer && module) { PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); } } } #ifdef __cplusplus } #endif /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_GLsizei swig_types[0] #define SWIGTYPE_p_GLshort swig_types[1] #define SWIGTYPE_p_GLboolean swig_types[2] #define SWIGTYPE_p_GLUquadric swig_types[3] #define SWIGTYPE_p_PyGLUquadric swig_types[4] #define SWIGTYPE_p_GLUnurbs swig_types[5] #define SWIGTYPE_p_PyGLUnurbs swig_types[6] #define SWIGTYPE_size_t swig_types[7] #define SWIGTYPE_p_GLushort swig_types[8] #define SWIGTYPE_p_GLenum swig_types[9] #define SWIGTYPE_p_GLvoid swig_types[10] #define SWIGTYPE_p_GLint swig_types[11] #define SWIGTYPE_p_char swig_types[12] #define SWIGTYPE_p_GLclampd swig_types[13] #define SWIGTYPE_p_PyGLUtesselator swig_types[14] #define SWIGTYPE_p_GLUtesselator swig_types[15] #define SWIGTYPE_p_GLclampf swig_types[16] #define SWIGTYPE_p_GLuint swig_types[17] #define SWIGTYPE_ptrdiff_t swig_types[18] #define SWIGTYPE_p_GLbyte swig_types[19] #define SWIGTYPE_p_GLbitfield swig_types[20] #define SWIGTYPE_p_GLfloat swig_types[21] #define SWIGTYPE_p_GLubyte swig_types[22] #define SWIGTYPE_p_GLdouble swig_types[23] static swig_type_info *swig_types[25]; /* -------- TYPES TABLE (END) -------- */ /*----------------------------------------------- @(target):= _GLU__init__.so ------------------------------------------------*/ #define SWIG_init init_GLU__init__ #define SWIG_name "_GLU__init__" SWIGINTERN PyObject * SWIG_FromCharPtr(const char* cptr) { if (cptr) { size_t size = strlen(cptr); if (size > INT_MAX) { return SWIG_NewPointerObj((char*)(cptr), SWIG_TypeQuery("char *"), 0); } else { if (size != 0) { return PyString_FromStringAndSize(cptr, size); } else { return PyString_FromString(cptr); } } } Py_INCREF(Py_None); return Py_None; } /*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/ #define SWIG_From_int PyInt_FromLong /*@@*/ /** * * GLU Module for PyOpenGL * * Date: May 2001 * * Authors: Tarn Weisner Burton * ***/ /* License from SGI's OpenGLŪ Sample Implementation */ /* # License Applicability. Except to the extent portions of this file are # made subject to an alternative license as permitted in the SGI Free # Software License B, Version 1.1 (the "License"), the contents of this # file are subject only to the provisions of the License. You may not use # this file except in compliance with the License. You may obtain a copy # of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 # Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: # # http://oss.sgi.com/projects/FreeB # # Note that, as provided in the License, the Software is distributed on an # "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS # DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND # CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A # PARTICULAR PURPOSE, AND NON-INFRINGEMENT. # # Original Code. The Original Code is: OpenGL Sample Implementation, # Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, # Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. # Copyright in any portions created by third parties is as indicated # elsewhere herein. All Rights Reserved. # # Additional Notice Provisions: The application programming interfaces # established by SGI in conjunction with the Original Code are The # OpenGL(R) Graphics System: A Specification (Version 1.2.1), released # April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version # 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X # Window System(R) (Version 1.3), released October 19, 1998. This software # was created using the OpenGL(R) version 1.2.1 Sample Implementation # published by SGI, but has not been independently verified as being # compliant with the OpenGL(R) version 1.2.1 Specification. */ GLint PyOpenGL_round(double x) { if (x >= 0) { return (GLint) (x+0.5); } else { return (GLint) (x-0.5); } } int __PyObject_AsArray_Size(PyObject* x); #ifdef NUMERIC #define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : ((PyArray_Check(x)) ? PyArray_Size(x) : __PyObject_AsArray_Size(x))) #else /* NUMERIC */ #define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : __PyObject_AsArray_Size(x)) #endif /* NUMERIC */ #define _PyObject_As(NAME, BASE) BASE* _PyObject_As##NAME(PyObject* source, PyObject** temp, int* len); #define _PyObject_AsArray_Cleanup(target, temp) if (temp) Py_XDECREF(temp); else PyMem_Del(target) _PyObject_As(FloatArray, float) _PyObject_As(DoubleArray, double) _PyObject_As(CharArray, signed char) _PyObject_As(UnsignedCharArray, unsigned char) _PyObject_As(ShortArray, short) _PyObject_As(UnsignedShortArray, unsigned short) _PyObject_As(IntArray, int) _PyObject_As(UnsignedIntArray, unsigned int) void* _PyObject_AsArray(GLenum type, PyObject* source, PyObject** temp, int* len); #define PyErr_XPrint() if (PyErr_Occurred()) PyErr_Print() #if HAS_DYNAMIC_EXT #define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\ RET PROC_NAME PROTO\ {\ typedef RET (APIENTRY *proc_##PROC_NAME) PROTO;\ proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\ if (proc) return proc CALL;\ PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\ return ERROR_RET;\ } #define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\ void PROC_NAME PROTO\ {\ typedef void (APIENTRY *proc_##PROC_NAME) PROTO;\ proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\ if (proc) proc CALL;\ else {\ PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\ }\ } #else #define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\ RET PROC_NAME PROTO\ {\ PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\ return ERROR_RET;\ } #define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\ void PROC_NAME PROTO\ {\ PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\ } #endif #define _PyTuple_From(NAME, BASE) PyObject* _PyTuple_From##NAME(int len, BASE* data); _PyTuple_From(UnsignedCharArray, unsigned char) _PyTuple_From(CharArray, signed char) _PyTuple_From(UnsignedShortArray, unsigned short) _PyTuple_From(ShortArray, short) _PyTuple_From(UnsignedIntArray, unsigned int) _PyTuple_From(IntArray, int) _PyTuple_From(FloatArray, float) _PyTuple_From(DoubleArray, double) #define _PyObject_From(NAME, BASE) PyObject* _PyObject_From##NAME(int nd, int* dims, BASE* data, int own); _PyObject_From(UnsignedCharArray, unsigned char) _PyObject_From(CharArray, signed char) _PyObject_From(UnsignedShortArray, unsigned short) _PyObject_From(ShortArray, short) _PyObject_From(UnsignedIntArray, unsigned int) _PyObject_From(IntArray, int) _PyObject_From(FloatArray, float) _PyObject_From(DoubleArray, double) PyObject* _PyObject_FromArray(GLenum type, int nd, int *dims, void* data, int own); void* SetupPixelRead(int rank, GLenum format, GLenum type, int *dims); void SetupPixelWrite(int rank); void* SetupRawPixelRead(GLenum format, GLenum type, int n, const int *dims, int* size); void* _PyObject_AsPointer(PyObject* x); /* The following line causes a warning on linux and cygwin The function is defined in interface_utils.c, which is linked to each extension module. For some reason, though, this declaration doesn't get recognised as a declaration prototype for that function. */ void init_util(); typedef void *PTR; typedef struct { void (*_decrement)(void* pointer); void (*_decrementPointer)(GLenum pname); int (*_incrementLock)(void *pointer); int (*_incrementPointerLock)(GLenum pname); void (*_acquire)(void* pointer); void (*_acquirePointer)(GLenum pname); #if HAS_DYNAMIC_EXT PTR (*GL_GetProcAddress)(const char* name); #endif int (*InitExtension)(const char *name, const char** procs); PyObject *_GLerror; PyObject *_GLUerror; } util_API; static util_API *_util_API = NULL; #define decrementLock(x) (*_util_API)._decrement(x) #define decrementPointerLock(x) (*_util_API)._decrementPointer(x) #define incrementLock(x) (*_util_API)._incrementLock(x) #define incrementPointerLock(x) (*_util_API)._incrementPointerLock(x) #define acquire(x) (*_util_API)._acquire(x) #define acquirePointer(x) (*_util_API)._acquirePointer(x) #define GLerror (*_util_API)._GLerror #define GLUerror (*_util_API)._GLUerror #if HAS_DYNAMIC_EXT #define GL_GetProcAddress(x) (*_util_API).GL_GetProcAddress(x) #endif #define InitExtension(x, y) (*_util_API).InitExtension(x, (const char**)y) #define PyErr_SetGLerror(code) PyErr_SetObject(GLerror, Py_BuildValue("is", code, gluErrorString(code))); #define PyErr_SetGLUerror(code) PyErr_SetObject(GLUerror, Py_BuildValue("is", code, gluErrorString(code))); int _PyObject_Dimension(PyObject* x, int rank); #define ERROR_MSG_SEP ", " #define ERROR_MSG_SEP_LEN 2 int GLErrOccurred() { if (PyErr_Occurred()) return 1; if (CurrentContextIsValid()) { GLenum error, *errors = NULL; char *msg = NULL; const char *this_msg; int count = 0; error = glGetError(); while (error != GL_NO_ERROR) { this_msg = gluErrorString(error); if (count) { msg = realloc(msg, (strlen(msg) + strlen(this_msg) + ERROR_MSG_SEP_LEN + 1)*sizeof(char)); strcat(msg, ERROR_MSG_SEP); strcat(msg, this_msg); errors = realloc(errors, (count + 1)*sizeof(GLenum)); } else { msg = malloc((strlen(this_msg) + 1)*sizeof(char)); strcpy(msg, this_msg); errors = malloc(sizeof(GLenum)); } errors[count++] = error; error = glGetError(); } if (count) { PyErr_SetObject(GLerror, Py_BuildValue("Os", _PyTuple_FromIntArray(count, (int*)errors), msg)); free(errors); free(msg); return 1; } } return 0; } void PyErr_SetGLErrorMessage( int id, char * message ) { /* set a GLerror with an ID and string message This tries pretty hard to look just like a regular error as produced by GLErrOccurred()'s formatter, save that there's only the single error being reported. Using id 0 is probably best for any future use where there isn't a good match for the exception description in the error-enumeration set. */ PyObject * args = NULL; args = Py_BuildValue( "(i)s", id, message ); if (args) { PyErr_SetObject( GLerror, args ); Py_XDECREF( args ); } else { PyErr_SetGLerror(id); } } void __ignoreDeletionCall(PyObject * tess ) { } typedef void (CALLBACK *callback)(); #include SWIGINTERNSHORT int SWIG_CheckUnsignedLongInRange(unsigned long value, unsigned long max_value, const char *errmsg) { if (value > max_value) { if (errmsg) { PyErr_Format(PyExc_OverflowError, "value %lu is greater than '%s' minimum %lu", value, errmsg, max_value); } return 0; } return 1; } SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) { if (PyInt_Check(obj)) { long v = PyInt_AS_LONG(obj); if (v >= 0) { if (val) *val = v; return 1; } } if (PyLong_Check(obj)) { unsigned long v = PyLong_AsUnsignedLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return 1; } else { if (!val) PyErr_Clear(); return 0; } } if (val) { SWIG_type_error("unsigned long", obj); } return 0; } #if UINT_MAX != ULONG_MAX SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val) { const char* errmsg = val ? "unsigned int" : (char*)0; unsigned long v; if (SWIG_AsVal_unsigned_SS_long(obj, &v)) { if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) { if (val) *val = (unsigned int)(v); return 1; } } else { PyErr_Clear(); } if (val) { SWIG_type_error(errmsg, obj); } return 0; } #else SWIGINTERNSHORT unsigned int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val) { return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val); } #endif SWIGINTERNSHORT unsigned int SWIG_As_unsigned_SS_int(PyObject* obj) { unsigned int v; if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) { /* this is needed to make valgrind/purify happier. */ memset((void*)&v, 0, sizeof(unsigned int)); } return v; } SWIGINTERNSHORT int SWIG_Check_unsigned_SS_int(PyObject* obj) { return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0); } static char _doc_gluErrorString[] = "gluErrorString(errCode) -> string"; static char _doc_gluGetString[] = "gluGetString(name) -> string"; SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val) { if (PyFloat_Check(obj)) { if (val) *val = PyFloat_AS_DOUBLE(obj); return 1; } if (PyInt_Check(obj)) { if (val) *val = PyInt_AS_LONG(obj); return 1; } if (PyLong_Check(obj)) { double v = PyLong_AsDouble(obj); if (!PyErr_Occurred()) { if (val) *val = v; return 1; } else { if (!val) PyErr_Clear(); return 0; } } if (val) { SWIG_type_error("double", obj); } return 0; } SWIGINTERNSHORT double SWIG_As_double(PyObject* obj) { double v; if (!SWIG_AsVal_double(obj, &v)) { /* this is needed to make valgrind/purify happier. */ memset((void*)&v, 0, sizeof(double)); } return v; } SWIGINTERNSHORT int SWIG_Check_double(PyObject* obj) { return SWIG_AsVal_double(obj, (double*)0); } static char _doc_gluOrtho2D[] = "gluOrtho2D(left, right, bottom, top) -> None"; static char _doc_gluPerspective[] = "gluPerspective(fovy, aspect, zNear, zFar) -> None"; void __gluPickMatrix(GLdouble x, GLdouble y, GLdouble width, GLdouble height, const GLint *viewport) { GLint _viewport[4]; if (!viewport) { glGetIntegerv(GL_VIEWPORT, _viewport); viewport = _viewport; } gluPickMatrix(x, y, width, height, (GLint*)viewport); } static char _doc_gluLookAt[] = "gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz) -> None"; PyObject* __gluProject(GLdouble objx, GLdouble objy, GLdouble objz, const GLdouble *modelMatrix, const GLdouble *projMatrix, const GLint *viewport) { GLdouble win[3], _modelMatrix[16], _projMatrix[16]; GLint _viewport[4]; if (!modelMatrix) { glGetDoublev(GL_MODELVIEW_MATRIX, _modelMatrix); modelMatrix = _modelMatrix; } if (!projMatrix) { glGetDoublev(GL_PROJECTION_MATRIX, _projMatrix); projMatrix = _projMatrix; } if (!viewport) { glGetIntegerv(GL_VIEWPORT, _viewport); viewport = _viewport; } if (gluProject(objx, objy, objz, modelMatrix, projMatrix, viewport, win, win + 1, win + 2)) { return _PyTuple_FromDoubleArray(3, win); } PyErr_SetGLUerror( GL_INVALID_VALUE ); return NULL; } PyObject* __gluUnProject(GLdouble winx, GLdouble winy, GLdouble winz, const GLdouble *modelMatrix, const GLdouble *projMatrix, const GLint *viewport) { GLdouble obj[3], _modelMatrix[16], _projMatrix[16]; GLint _viewport[4]; if (!modelMatrix) { glGetDoublev(GL_MODELVIEW_MATRIX, _modelMatrix); modelMatrix = _modelMatrix; } if (!projMatrix) { glGetDoublev(GL_PROJECTION_MATRIX, _projMatrix); projMatrix = _projMatrix; } if (!viewport) { glGetIntegerv(GL_VIEWPORT, _viewport); viewport = _viewport; } if (gluUnProject(winx, winy, winz, modelMatrix, projMatrix, viewport, obj, obj + 1, obj + 2)) { return _PyTuple_FromDoubleArray(3, obj); } Py_INCREF(Py_None); return Py_None; } PyObject* _gluScaleImage(GLenum format, GLint widthin, GLint heightin, GLenum typein, const void *datain, GLint widthout, GLint heightout, GLenum typeout) { PyObject* result; int code, dims[2]; int size; void* dataout; dims[0] = widthout; dims[1] = heightout; dataout = SetupRawPixelRead(format, typeout, 2, dims, &size); if (!dataout) return NULL; code = gluScaleImage(format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout); if (code) { PyMem_Del(dataout); PyErr_SetGLUerror(code); return NULL; } result = PyString_FromStringAndSize((const char*)dataout, size); PyMem_Del(dataout); return result; } PyObject* __gluScaleImage(GLenum format, GLint widthin, GLint heightin, GLenum type, const void *datain, GLint widthout, GLint heightout) { int dims[3], code; void *dataout; SetupPixelWrite(2); dims[0] = widthout; dims[1] = heightout; dataout = SetupPixelRead(2, format, type, dims); if (!dataout) return NULL; code = gluScaleImage(format, widthin, heightin, type, datain, widthout, heightout, type, dataout); if (code) { PyMem_Del(dataout); PyErr_SetGLUerror(code); return NULL; } return _PyObject_FromArray(type, (dims[2] == 1) ? 2 : 3, dims, dataout, 1); } SWIGINTERN int SWIG_CheckLongInRange(long value, long min_value, long max_value, const char *errmsg) { if (value < min_value) { if (errmsg) { PyErr_Format(PyExc_OverflowError, "value %ld is less than '%s' minimum %ld", value, errmsg, min_value); } return 0; } else if (value > max_value) { if (errmsg) { PyErr_Format(PyExc_OverflowError, "value %ld is greater than '%s' maximum %ld", value, errmsg, max_value); } return 0; } return 1; } SWIGINTERN int SWIG_AsVal_long(PyObject * obj, long* val) { if (PyInt_Check(obj)) { if (val) *val = PyInt_AS_LONG(obj); return 1; } if (PyLong_Check(obj)) { long v = PyLong_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return 1; } else { if (!val) PyErr_Clear(); return 0; } } if (val) { SWIG_type_error("long", obj); } return 0; } #if INT_MAX != LONG_MAX SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val) { const char* errmsg = val ? "int" : (char*)0; long v; if (SWIG_AsVal_long(obj, &v)) { if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) { if (val) *val = (int)(v); return 1; } else { return 0; } } else { PyErr_Clear(); } if (val) { SWIG_type_error(errmsg, obj); } return 0; } #else SWIGINTERNSHORT int SWIG_AsVal_int(PyObject *obj, int *val) { return SWIG_AsVal_long(obj,(long*)val); } #endif SWIGINTERNSHORT int SWIG_As_int(PyObject* obj) { int v; if (!SWIG_AsVal_int(obj, &v)) { /* this is needed to make valgrind/purify happier. */ memset((void*)&v, 0, sizeof(int)); } return v; } SWIGINTERNSHORT int SWIG_Check_int(PyObject* obj) { return SWIG_AsVal_int(obj, (int*)0); } static char _doc_gluScaleImage[] = "gluScaleImage(format, widthin, heightin, typein, datain, widthout, heightout, typeout) -> dataout"; static char _doc_gluScaleImageb[] = "gluScaleImageb(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImageub[] = "gluScaleImageub(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImages[] = "gluScaleImages(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImageus[] = "gluScaleImageus(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImagei[] = "gluScaleImagei(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImageui[] = "gluScaleImageui(format, datain, widthout, heightout) -> dataout"; static char _doc_gluScaleImagef[] = "gluScaleImagef(format, datain, widthout, heightout) -> dataout"; PyObject* _gluBuild1DMipmaps(GLenum target, GLint components, GLint width, GLenum format, GLenum type, const void *buffer) { int code; code = gluBuild1DMipmaps(target, components, width, format, type, buffer); if (code) { PyErr_SetGLUerror(code); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluBuild1DMipmaps[] = "gluBuild1DMipmaps(target, components, width, format, type, data) -> None"; PyObject *__gluBuild1DMipmaps(GLenum target, GLint components, GLint width, GLenum format, GLenum type, const void *buffer) { int code; SetupPixelWrite(1); code = gluBuild1DMipmaps(target, components, width, format, type, buffer); if (code) { PyErr_SetGLUerror(code); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluBuild1DMipmapsb[] = "gluBuild1DMipmapsb(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapsub[] = "gluBuild1DMipmapsub(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapss[] = "gluBuild1DMipmapss(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapsus[] = "gluBuild1DMipmapsus(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapsi[] = "gluBuild1DMipmapsi(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapsui[] = "gluBuild1DMipmapsui(target, components, format, pixels) -> None"; static char _doc_gluBuild1DMipmapsf[] = "gluBuild1DMipmapsf(target, components, format, pixels) -> None"; PyObject* _gluBuild2DMipmaps(GLenum target, GLint components, GLint width, GLint height, GLenum format, GLenum type, const void *buffer) { int code; code = gluBuild2DMipmaps(target, components, width, height, format, type, buffer); if (code) { PyErr_SetGLUerror(code); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluBuild2DMipmaps[] = "gluBuild2DMipmaps(target, components, width, height, format, type, data) -> None"; PyObject *__gluBuild2DMipmaps(GLenum target, GLint components, GLint width, GLint height, GLenum format, GLenum type, const void *buffer) { int code; SetupPixelWrite(2); code = gluBuild2DMipmaps(target, components, width, height, format, type, buffer); if (code) { PyErr_SetGLUerror(code); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluBuild2DMipmapsb[] = "gluBuild2DMipmapsb(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapsub[] = "gluBuild2DMipmapsub(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapss[] = "gluBuild2DMipmapss(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapsus[] = "gluBuild2DMipmapsus(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapsi[] = "gluBuild2DMipmapsi(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapsui[] = "gluBuild2DMipmapsui(target, components, format, pixels) -> None"; static char _doc_gluBuild2DMipmapsf[] = "gluBuild2DMipmapsf(target, components, format, pixels) -> None"; void CALLBACK throwGLUerror(GLenum code) { PyErr_SetGLUerror(code); } typedef struct { PyObject_HEAD GLUquadric *obj; PyObject *begin, *beginData, *edgeFlag, *edgeFlagData, *vertex, *vertexData; PyObject *end, *endData, *combine, *combineData; } PyGLUquadric; PyGLUquadric *currentQuadric = NULL; static void PyGLUquadric_Del(PyObject *self) { gluDeleteQuadric(((PyGLUquadric*)self)->obj); PyObject_Del(self); } PyTypeObject PyGLUquadric_Type = { PyObject_HEAD_INIT(0) 0, /* ob_size */ "GLUquadric", /* tp_name */ sizeof(PyGLUquadric), /* tp_basicsize */ 0, /* tp_itemsize */ PyGLUquadric_Del, /* tp_dealloc */ }; #define PYOBJ(x) ((x) ? (PyObject*)x : Py_None) PyGLUquadric* _gluNewQuadric() { PyGLUquadric *self = PyObject_NEW(PyGLUquadric, &PyGLUquadric_Type); if (!(self->obj = gluNewQuadric())) { PyErr_SetGLUerror(GLU_OUT_OF_MEMORY); return NULL; } gluQuadricCallback(self->obj, GLU_ERROR, throwGLUerror); return self; } PyObject* _gluQuadricCallback(PyGLUquadric* self, GLenum which, PyObject* pyfunc) { PyErr_SetString(PyExc_Exception, "Can't set that callback."); return NULL; } static char _doc_gluNewQuadric[] = "gluNewQuadric() -> GLUquadric"; static char _doc_gluDeleteQuadric[] = "gluDeleteQuadric(quadObject) -> (null function, use del nobj instead)"; static char _doc_gluQuadricNormals[] = "gluQuadricNormals(quadObject, normals) -> None"; SWIGINTERN int SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val) { const char* errmsg = val ? "unsigned char" : (char*)0; unsigned long v; if (SWIG_AsVal_unsigned_SS_long(obj, &v)) { if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) { if (val) *val = (unsigned char)(v); return 1; } else { return 0; } } else { PyErr_Clear(); } if (val) { SWIG_type_error(errmsg, obj); } return 0; } SWIGINTERNSHORT int SWIG_Check_unsigned_SS_char(PyObject* obj) { return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0); } static char _doc_gluQuadricTexture[] = "gluQuadricTexture(quadObject, textureCoords) -> None"; static char _doc_gluQuadricOrientation[] = "gluQuadricOrientation(quadObject, orientation) -> None"; static char _doc_gluQuadricDrawStyle[] = "gluQuadricDrawStyle(quadObject, drawStyle) -> None"; static char _doc_gluCylinder[] = "gluCylinder(qobj, baseRadius, topRadius, height, slices, stacks) -> None"; static char _doc_gluDisk[] = "gluDisk(qobj, innerRadius, outerRadius, slices, loops) -> None"; static char _doc_gluPartialDisk[] = "gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle) -> None"; static char _doc_gluSphere[] = "gluSphere(qobj, radius, slices, stacks) -> None"; static char _doc_gluQuadricCallback[] = "gluQuadricCallback(qobj, which, func)"; #ifndef GLU_VERSION_1_2 #define GLU_TESS_BEGIN 100100 #define GLU_TESS_VERTEX 100101 #define GLU_TESS_END 100102 #define GLU_TESS_ERROR 100103 #define GLU_TESS_EDGE_FLAG 100104 #define GLU_TESS_COMBINE 100105 #define GLU_TESS_BEGIN_DATA 100106 #define GLU_TESS_VERTEX_DATA 100107 #define GLU_TESS_END_DATA 100108 #define GLU_TESS_ERROR_DATA 100109 #define GLU_TESS_EDGE_FLAG_DATA 100110 #define GLU_TESS_COMBINE_DATA 100111 #endif typedef struct { PyObject_HEAD GLUtesselator *obj; PyObject *lockedObjects; PyObject *callbacks; PyObject *currentData; } PyGLUtesselator; static void PyGLUtesselator_Del(PyObject *self) { gluDeleteTess(((PyGLUtesselator*)self)->obj); Py_DECREF(((PyGLUtesselator*)self)->lockedObjects); Py_DECREF(((PyGLUtesselator*)self)->callbacks); if (((PyGLUtesselator*)self)->currentData) { Py_DECREF(((PyGLUtesselator*)self)->currentData); } PyObject_Del(self); } PyTypeObject PyGLUtesselator_Type = { PyObject_HEAD_INIT(0) 0, /* ob_size */ "GLUtesselator", /* tp_name */ sizeof(PyGLUtesselator), /* tp_basicsize */ 0, /* tp_itemsize */ PyGLUtesselator_Del, /* tp_dealloc */ }; #define PYOBJ(x) ((x) ? (PyObject*)x : Py_None) PyObject *GetTessCallback( void * currentTessellator, char *name) { if (currentTessellator) { PyGLUtesselator * tess = (PyGLUtesselator *) ((PyObject *) currentTessellator); { PyObject *this_callback = PyDict_GetItemString(tess->callbacks, name); if (this_callback != Py_None) return this_callback; } } return NULL; } PyObject *GetTessData( void * currentTessellator) { if (currentTessellator) { PyGLUtesselator * tess = (PyGLUtesselator *) ((PyObject *) currentTessellator); return tess->currentData; } return NULL; } void _PyPrint_ToStderr( char * message ) { /* message must be a null-terminated C-style string */ PyObject * sysModule; PyObject * sysModuleStdErr; PyObject * result; sysModule = NULL; sysModuleStdErr = NULL; sysModule = PyImport_ImportModule( "sys" ); if (sysModule) { sysModuleStdErr = PyObject_GetAttrString( sysModule, "stderr" ); if (sysModuleStdErr) { result = PyObject_CallMethod( sysModuleStdErr, "write", "s", message ); } } Py_XDECREF(sysModule); Py_XDECREF(sysModuleStdErr); Py_XDECREF(result); } void CALLBACK PyGLUtesselator_begin(GLenum type, void *polygon_data) { /* callback when Python code has only specified begin */ PyObject *this_callback = GetTessCallback( polygon_data, "begin"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "l", (long)type); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation begin callback\n" ); } } } void CALLBACK PyGLUtesselator_beginData(GLenum type, void *polygon_data) { /* callback when Python code has only specified begindata */ PyObject *this_callback = GetTessCallback( polygon_data, "beginData"); if (this_callback) { PyObject * data = GetTessData( polygon_data ); PyObject *result = PyObject_CallFunction(this_callback, "lO", (long)type, data); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation begin data callback\n" ); } } } void CALLBACK PyGLUtesselator_edgeFlag(GLboolean flag, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "edgeFlag"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "l", (long)flag); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation edge flag callback\n" ); } } } void CALLBACK PyGLUtesselator_edgeFlagData(GLboolean flag, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "edgeFlagData"); if (this_callback) { PyObject * data = GetTessData( polygon_data ); PyObject *result = PyObject_CallFunction(this_callback, "lO", (long)flag, data); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation edge flag data callback\n" ); } } } void CALLBACK PyGLUtesselator_vertex(void *vertex_data, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "vertex"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(O)", PYOBJ(vertex_data)); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr("Exception during GLU Tessellation vertex callback\n" ); } } } void CALLBACK PyGLUtesselator_vertexData(void *vertex_data, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "vertexData"); if (this_callback) { PyObject * data = GetTessData( polygon_data ); PyObject *result = PyObject_CallFunction(this_callback, "OO", PYOBJ(vertex_data), data); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation vertex data callback\n" ); } } } void CALLBACK PyGLUtesselator_end(void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "end"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, NULL); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation end callback\n" ); } } } void CALLBACK PyGLUtesselator_endData(void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "endData"); if (this_callback) { PyObject * data = GetTessData( polygon_data ); PyObject *result = PyObject_CallFunction(this_callback, "(O)", data); Py_XDECREF(result); if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation end data callback\n" ); } } } void CALLBACK PyGLUtesselator_combine(GLdouble coords[3], void *vertex_data[4], GLfloat weight[4], void **outData, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "combine"); if (this_callback) { PyObject *result = NULL; result = PyObject_CallFunction(this_callback, "(ddd)(OOOO)(ffff)", coords[0], coords[1], coords[2], PYOBJ(vertex_data[0]), PYOBJ(vertex_data[1]), PYOBJ(vertex_data[2]), PYOBJ(vertex_data[3]), weight[0], weight[1], weight[2], weight[3]); if (result) { PyList_Append( ((PyGLUtesselator *) ((PyObject *) polygon_data))->lockedObjects, result ); *outData = (void*)result; Py_DECREF(result); } if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation combine callback\n" ); } } } void CALLBACK PyGLUtesselator_combineData(GLdouble coords[3], void *vertex_data[4], GLfloat weight[4], void **outData, void *polygon_data) { PyObject *this_callback = GetTessCallback( polygon_data, "combineData"); if (this_callback) { PyObject * data = GetTessData( polygon_data ); PyObject *result = PyObject_CallFunction(this_callback, "(ddd)(OOOO)(ffff)O", coords[0], coords[1], coords[2], PYOBJ(vertex_data[0]), PYOBJ(vertex_data[1]), PYOBJ(vertex_data[2]), PYOBJ(vertex_data[3]), weight[0], weight[1], weight[2], weight[3], data); if (result) { PyList_Append( ((PyGLUtesselator *) ((PyObject *) polygon_data))->lockedObjects, result ); *outData = (void*)result; Py_DECREF(result); } if (PyErr_Occurred()){ PyErr_Print(); _PyPrint_ToStderr( "Exception during GLU Tessellation combine data callback\n" ); } } } void CALLBACK tess_throwGLUerror(GLenum code, void *polygon_data) { PyErr_SetObject(GLUerror, Py_BuildValue("isO", code, gluErrorString(code), PYOBJ(polygon_data))); } PyGLUtesselator* _gluNewTess() { PyGLUtesselator *self = PyObject_NEW(PyGLUtesselator, &PyGLUtesselator_Type); if (!(self->obj = gluNewTess())) { PyErr_SetGLUerror(GLU_OUT_OF_MEMORY); return NULL; } gluTessCallback(self->obj, GLU_TESS_ERROR_DATA, tess_throwGLUerror); self->lockedObjects = PyList_New(0); self->callbacks = PyDict_New(); self->currentData = Py_None; Py_INCREF( self->currentData ); return self; } #define SET_TESS_CALLBACK(NAME,TYPE)\ PyDict_SetItemString(self->callbacks, #NAME, pyfunc);\ gluTessCallback(self->obj, TYPE, (pyfunc == Py_None) ? NULL : (callback)PyGLUtesselator_##NAME); PyObject* _gluTessCallback(PyGLUtesselator* self, GLenum which, PyObject* pyfunc) { switch (which) { case GLU_TESS_BEGIN: SET_TESS_CALLBACK(begin,GLU_TESS_BEGIN_DATA) break; case GLU_TESS_BEGIN_DATA: SET_TESS_CALLBACK(beginData,GLU_TESS_BEGIN_DATA) break; case GLU_TESS_EDGE_FLAG: SET_TESS_CALLBACK(edgeFlag,GLU_TESS_EDGE_FLAG_DATA) break; case GLU_TESS_EDGE_FLAG_DATA: SET_TESS_CALLBACK(edgeFlagData,GLU_TESS_EDGE_FLAG_DATA) break; case GLU_TESS_VERTEX: SET_TESS_CALLBACK(vertex,GLU_TESS_VERTEX_DATA) break; case GLU_TESS_VERTEX_DATA: SET_TESS_CALLBACK(vertexData,GLU_TESS_VERTEX_DATA) break; case GLU_TESS_END: SET_TESS_CALLBACK(end,GLU_TESS_END_DATA) break; case GLU_TESS_END_DATA: SET_TESS_CALLBACK(endData,GLU_TESS_END_DATA) break; case GLU_TESS_COMBINE: SET_TESS_CALLBACK(combine,GLU_TESS_COMBINE_DATA) break; case GLU_TESS_COMBINE_DATA: SET_TESS_CALLBACK(combineData,GLU_TESS_COMBINE_DATA) break; case GLU_TESS_ERROR: case GLU_TESS_ERROR_DATA: PyErr_SetString(PyExc_Exception, "Can't set that callback."); return NULL; default: PyErr_SetString(PyExc_Exception, "Unknown callback code."); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluNewTess[] = "gluNewTess() -> GLUtesselator"; static char _doc_gluDeleteTess[] = "gluDeleteTess(tess) -> (null function, use del tess instead)"; void _gluTessBeginPolygon(PyGLUtesselator *self, PyObject *polygon_data) { PyList_Append(self->lockedObjects, polygon_data); if (self->currentData) { Py_DECREF( self->currentData); } self->currentData = polygon_data; Py_INCREF( polygon_data ); gluTessBeginPolygon(self->obj, (void*)self); } static char _doc_gluTessBeginPolygon[] = "gluTessBeginPolygon(tess, polygon_data) -> None"; static char _doc_gluBeginPolygon[] = "gluBeginPolygon(tess) -> None"; static char _doc_gluTessBeginContour[] = "gluTessBeginContour(tess) -> None"; void _gluTessVertex(PyGLUtesselator *self, const GLdouble *coords, PyObject *data) { PyList_Append(self->lockedObjects, data); gluTessVertex(self->obj, (GLdouble*)coords, (void*)data); } static char _doc_gluTessVertex[] = "gluTessVertex(tess, coords, data) -> None"; static char _doc_gluTessEndContour[] = "gluTessEndContour(tess) -> None"; static char _doc_gluNextContour[] = "gluNextContour(tess, type) -> None"; void _gluTessEndPolygon(PyGLUtesselator *self) { gluTessEndPolygon(self->obj); PySequence_DelSlice(self->lockedObjects, 0, -1); } static char _doc_gluTessEndPolygon[] = "gluTessEndPolygon(tess) -> None"; static char _doc_gluEndPolygon[] = "gluEndPolygon(tess) -> None"; static char _doc_gluTessProperty[] = "gluTessProperty(tess, which, value) -> None"; static char _doc_gluTessNormal[] = "gluTessNormal(tess, x, y, z) -> None"; static char _doc_gluTessCallback[] = "gluTessCallback(tess, which, pyfunc) -> None\n\ \n\ The error callbacks GLU_TESS_ERROR and GLU_TESS_ERROR_BEGIN cannot be set by\n\ gluTessCallback, instead an exception is thrown when an error occurs with the\n\ exception value set to a tuple (errno, polygon_data)"; static char _doc_gluGetTessProperty[] = "gluGetTessProperty(tess, which) -> value"; #ifndef GLU_VERSION_1_3 #define GLU_NURBS_MODE 100160 #define GLU_NURBS_TESSELLATOR 100161 #define GLU_NURBS_RENDERER 100162 #define GLU_NURBS_BEGIN 100164 #define GLU_NURBS_VERTEX 100165 #define GLU_NURBS_NORMAL 100166 #define GLU_NURBS_COLOR 100167 #define GLU_NURBS_TEXTURE_COORD 100168 #define GLU_NURBS_END 100169 #define GLU_NURBS_BEGIN_DATA 100170 #define GLU_NURBS_VERTEX_DATA 100171 #define GLU_NURBS_NORMAL_DATA 100172 #define GLU_NURBS_COLOR_DATA 100173 #define GLU_NURBS_TEXTURE_COORD_DATA 100174 #define GLU_NURBS_END_DATA 100175 #endif typedef struct { PyObject_HEAD GLUnurbs *obj; PyObject *data; PyObject *callbacks; } PyGLUnurbs; PyGLUnurbs *currentNurbs = NULL; static void PyGLUnurbs_Del(PyObject *self) { gluDeleteNurbsRenderer(((PyGLUnurbs*)self)->obj); Py_DECREF(((PyGLUnurbs*)self)->data); Py_DECREF(((PyGLUtesselator*)self)->callbacks); PyObject_Del(self); } PyTypeObject PyGLUnurbs_Type = { PyObject_HEAD_INIT(0) 0, /* ob_size */ "GLUnurbs", /* tp_name */ sizeof(PyGLUnurbs), /* tp_basicsize */ 0, /* tp_itemsize */ PyGLUnurbs_Del, /* tp_dealloc */ }; #define PYOBJ(x) ((x) ? (PyObject*)x : Py_None) PyObject *GetNurbsCallback(char *name) { if (currentNurbs) { PyObject *this_callback = PyDict_GetItemString(currentNurbs->callbacks, name); if (this_callback != Py_None) return this_callback; } return NULL; } PyGLUnurbs* _gluNewNurbsRenderer() { PyGLUnurbs *self = PyObject_NEW(PyGLUnurbs, &PyGLUnurbs_Type); if (!(self->obj = gluNewNurbsRenderer())) { PyErr_SetGLUerror(GLU_OUT_OF_MEMORY); return NULL; } gluNurbsCallback(self->obj, GLU_ERROR, throwGLUerror); Py_INCREF(self->data = Py_None); self->callbacks = PyDict_New(); return self; } void CALLBACK PyGLUnurbs_begin(GLenum type) { PyObject *this_callback = GetNurbsCallback("begin"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "l", (long)type); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_beginData(GLenum type, void *userData) { PyObject *this_callback = GetNurbsCallback("beginData"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "lO", (long)type, PYOBJ(userData)); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_vertex(GLfloat *vertex) { PyObject *this_callback = GetNurbsCallback("vertex"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(fff)", vertex[0], vertex[1], vertex[2]); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_vertexData(GLfloat *vertex, void *userData) { PyObject *this_callback = GetNurbsCallback("vertexData"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(fff)O", vertex[0], vertex[1], vertex[2], PYOBJ(userData)); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_normal(GLfloat *normal) { PyObject *this_callback = GetNurbsCallback("normal"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(fff)", normal[0], normal[1], normal[2]); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_normalData(GLfloat *normal, void *userData) { PyObject *this_callback = GetNurbsCallback("normalData"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(fff)O", normal[0], normal[1], normal[2], PYOBJ(userData)); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_color(GLfloat *color) { PyObject *this_callback = GetNurbsCallback("color"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(ffff)", color[0], color[1], color[2], color[3]); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_colorData(GLfloat *color, void *userData) { PyObject *this_callback = GetNurbsCallback("colorData"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "(ffff)O", color[0], color[1], color[2], color[3], PYOBJ(userData)); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_texCoord(GLfloat *texCoord) { PyObject *this_callback = GetNurbsCallback("texCoord"); if (this_callback) { PyObject *result = NULL; if (glIsEnabled(GL_MAP1_TEXTURE_COORD_1) || glIsEnabled(GL_MAP2_TEXTURE_COORD_1)) { result = PyObject_CallFunction(this_callback, "((f))", texCoord[0]); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_2) || glIsEnabled(GL_MAP2_TEXTURE_COORD_2)) { result = PyObject_CallFunction(this_callback, "(ff)", texCoord[0], texCoord[1]); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_3) || glIsEnabled(GL_MAP2_TEXTURE_COORD_3)) { result = PyObject_CallFunction(this_callback, "(fff)", texCoord[0], texCoord[1], texCoord[2]); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_4) || glIsEnabled(GL_MAP2_TEXTURE_COORD_4)) { result = PyObject_CallFunction(this_callback, "(ffff)", texCoord[0], texCoord[1], texCoord[2], texCoord[3]); } Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_texCoordData(GLfloat *texCoord, void *userData) { PyObject *this_callback = GetNurbsCallback("texCoordData"); if (this_callback) { PyObject *result = NULL; if (glIsEnabled(GL_MAP1_TEXTURE_COORD_1) || glIsEnabled(GL_MAP2_TEXTURE_COORD_1)) { result = PyObject_CallFunction(this_callback, "(f)O", texCoord[0], PYOBJ(userData)); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_2) || glIsEnabled(GL_MAP2_TEXTURE_COORD_2)) { result = PyObject_CallFunction(this_callback, "(ff)O", texCoord[0], texCoord[1], PYOBJ(userData)); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_3) || glIsEnabled(GL_MAP2_TEXTURE_COORD_3)) { result = PyObject_CallFunction(this_callback, "(fff)O", texCoord[0], texCoord[1], texCoord[2], PYOBJ(userData)); } else if (glIsEnabled(GL_MAP1_TEXTURE_COORD_4) || glIsEnabled(GL_MAP2_TEXTURE_COORD_4)) { result = PyObject_CallFunction(this_callback, "(ffff)O", texCoord[0], texCoord[1], texCoord[2], texCoord[3], PYOBJ(userData)); } Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_end() { PyObject *this_callback = GetNurbsCallback("end"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, NULL); Py_XDECREF(result); PyErr_XPrint(); } } void CALLBACK PyGLUnurbs_endData(void *userData) { PyObject *this_callback = GetNurbsCallback("endData"); if (this_callback) { PyObject *result = PyObject_CallFunction(this_callback, "O", PYOBJ(userData)); Py_XDECREF(result); PyErr_XPrint(); } } #define SET_NURBS_CALLBACK(NAME)\ PyDict_SetItemString(self->callbacks, #NAME, pyfunc);\ gluNurbsCallback(self->obj, which, (pyfunc == Py_None) ? NULL : (callback)PyGLUnurbs_##NAME); PyObject* _gluNurbsCallback(PyGLUnurbs* self, GLenum which, PyObject* pyfunc) { switch (which) { case GLU_NURBS_BEGIN: SET_NURBS_CALLBACK(begin) break; case GLU_NURBS_BEGIN_DATA: SET_NURBS_CALLBACK(beginData) break; case GLU_NURBS_VERTEX: SET_NURBS_CALLBACK(vertex) break; case GLU_NURBS_VERTEX_DATA: SET_NURBS_CALLBACK(vertexData) break; case GLU_NURBS_NORMAL: SET_NURBS_CALLBACK(normal) break; case GLU_NURBS_NORMAL_DATA: SET_NURBS_CALLBACK(normalData) break; case GLU_NURBS_COLOR: SET_NURBS_CALLBACK(color) break; case GLU_NURBS_COLOR_DATA: SET_NURBS_CALLBACK(colorData) break; case GLU_NURBS_TEXTURE_COORD: SET_NURBS_CALLBACK(texCoord) break; case GLU_NURBS_TEXTURE_COORD_DATA: SET_NURBS_CALLBACK(texCoordData) break; case GLU_NURBS_END: SET_NURBS_CALLBACK(end) break; case GLU_NURBS_END_DATA: SET_NURBS_CALLBACK(endData) break; case GLU_ERROR: PyErr_SetString(PyExc_Exception, "Can't set that callback."); return NULL; default: PyErr_SetString(PyExc_Exception, "Unknown callback code."); return NULL; } Py_INCREF(Py_None); return Py_None; } static char _doc_gluNewNurbsRenderer[] = "gluNewNurbsRenderer() -> GLUnurbs"; static char _doc_gluDeleteNurbsRenderer[] = "gluDeleteNurbsRenderer(nobj) -> None (null function, use del nobj instead)"; static char _doc_gluBeginSurface[] = "gluBeginSurface(nobj) -> None"; static char _doc_gluBeginCurve[] = "gluBeginCurve(nobj) -> None"; static char _doc_gluEndCurve[] = "gluEndCurve(nobj) -> None"; static char _doc_gluEndSurface[] = "gluEndSurface(nobj) -> None"; static char _doc_gluBeginTrim[] = "gluBeginTrim(nobj) -> None"; static char _doc_gluEndTrim[] = "gluEndTrim(nobj) -> None"; #define _gluPwlCurve(nobj, count, array, stride, type) \ gluPwlCurve(nobj, count, (GLfloat*)array, stride, type) static char _doc_gluPwlCurve[] = "gluPwlCurve(nobj, array, type) -> None"; #define _gluNurbsCurve(nobj, n_2, knot, d_5_0, d_5_1, ctlarray, type) \ gluNurbsCurve(nobj, n_2, (GLfloat*)knot, d_5_1, (GLfloat*)ctlarray, n_2 - d_5_0, type) static char _doc_gluNurbsCurve[] = "gluNurbsCurve(nobj, knot, ctlarray, type) -> None"; #define _gluNurbsSurface(nobj, sknot_len, sknot, tknot_len, tknot, d_0, d_1, d_2, ctlarray, type)\ gluNurbsSurface(\ nobj, sknot_len, (GLfloat*)sknot, tknot_len, (GLfloat*)tknot, \ d_1*d_2, d_2, (GLfloat*)ctlarray, sknot_len-d_0, tknot_len-d_1, type \ ) static char _doc_gluNurbsSurface[] = "gluNurbsSurface(nobj, sknot, tknot, ctlarray, type) -> None"; static char _doc_gluLoadSamplingMatrices[] = "gluLoadSamplingMatrices(nobj, modelMatrix, projMatrix, viewport) -> None"; #include SWIGINTERN int SWIG_CheckDoubleInRange(double value, double min_value, double max_value, const char* errmsg) { if (value < min_value) { if (errmsg) { PyErr_Format(PyExc_OverflowError, "value %g is less than %s minimum %g", value, errmsg, min_value); } return 0; } else if (value > max_value) { if (errmsg) { PyErr_Format(PyExc_OverflowError, "value %g is greater than %s maximum %g", value, errmsg, max_value); } return 0; } return 1; } SWIGINTERN int SWIG_AsVal_float(PyObject *obj, float *val) { const char* errmsg = val ? "float" : (char*)0; double v; if (SWIG_AsVal_double(obj, &v)) { if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) { if (val) *val = (float)(v); return 1; } else { return 0; } } else { PyErr_Clear(); } if (val) { SWIG_type_error(errmsg, obj); } return 0; } SWIGINTERNSHORT float SWIG_As_float(PyObject* obj) { float v; if (!SWIG_AsVal_float(obj, &v)) { /* this is needed to make valgrind/purify happier. */ memset((void*)&v, 0, sizeof(float)); } return v; } SWIGINTERNSHORT int SWIG_Check_float(PyObject* obj) { return SWIG_AsVal_float(obj, (float*)0); } static char _doc_gluNurbsProperty[] = "gluNurbsProperty(nobj, property, value) -> None"; static char _doc_gluGetNurbsProperty[] = "gluGetNurbsProperty(nobj, property) -> value"; static char _doc_gluNurbsCallback[] = "gluNurbsCallback(qobj, which, func)"; #if !EXT_DEFINES_PROTO || !defined(GLU_EXT_nurbs_tessellator) DECLARE_VOID_EXT(gluNurbsCallbackDataEXT, \ (GLUnurbs* theNurb, void* userData),\ (theNurb, userData)) #endif #define __gluNurbsCallbackDataEXT(nobj, data) gluNurbsCallbackDataEXT(nobj, (void*)data) static char _doc___gluNurbsCallbackDataEXT[] = "gluNurbsCallbackDataEXT(nobj, data) -> None"; static char *proc_names[] = { #if !EXT_DEFINES_PROTO || !defined(GLU_EXT_nurbs_tessellator) "gluNurbsCallbackDataEXT", #endif NULL }; #define __gluInitNurbsTessellatorEXT() InitExtension("GLU_EXT_nurbs_tessellator", proc_names) static char _doc___gluInitNurbsTessellatorEXT[] = "gluInitNurbsTessellatorEXT() -> bool"; /*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/ #define SWIG_From_double PyFloat_FromDouble /*@@*/ #ifdef __cplusplus extern "C" { #endif static PyObject *_wrap_gluErrorString(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLubyte *result; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluErrorString",&obj0)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { result = (GLubyte *)gluErrorString(arg1); if (GLErrOccurred()) { return NULL; } } { if (result) { resultobj= PyString_FromString(result); } else { Py_INCREF(resultobj = Py_None); } } return resultobj; fail: return NULL; } static PyObject *_wrap_gluGetString(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLubyte *result; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluGetString",&obj0)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { result = (GLubyte *)gluGetString(arg1); if (GLErrOccurred()) { return NULL; } } { if (result) { resultobj= PyString_FromString(result); } else { Py_INCREF(resultobj = Py_None); } } return resultobj; fail: return NULL; } static PyObject *_wrap_gluOrtho2D(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOO:gluOrtho2D",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { gluOrtho2D(arg1,arg2,arg3,arg4); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap_gluPerspective(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOO:gluPerspective",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { gluPerspective(arg1,arg2,arg3,arg4); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap___gluPickMatrix(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; GLint *arg5 = (GLint *) 0 ; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOO:__gluPickMatrix",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = _PyObject_AsIntArray(obj4, &temp_5, NULL); } { __gluPickMatrix(arg1,arg2,arg3,arg4,(GLint const *)arg5); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluLookAt(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; GLdouble arg5 ; GLdouble arg6 ; GLdouble arg7 ; GLdouble arg8 ; GLdouble arg9 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; PyObject * obj7 = 0 ; PyObject * obj8 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:gluLookAt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLdouble)(SWIG_As_double(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg6 = (GLdouble)(SWIG_As_double(obj5)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLdouble)(SWIG_As_double(obj6)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg8 = (GLdouble)(SWIG_As_double(obj7)); if (SWIG_arg_fail(8)) SWIG_fail; } { arg9 = (GLdouble)(SWIG_As_double(obj8)); if (SWIG_arg_fail(9)) SWIG_fail; } { gluLookAt(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap___gluProject(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble *arg4 = (GLdouble *) 0 ; GLdouble *arg5 = (GLdouble *) 0 ; GLint *arg6 = (GLint *) 0 ; PyObject *result; PyObject *temp_4 ; PyObject *temp_5 ; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOO:__gluProject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = _PyObject_AsDoubleArray(obj3, &temp_4, NULL); } { arg5 = _PyObject_AsDoubleArray(obj4, &temp_5, NULL); } { arg6 = _PyObject_AsIntArray(obj5, &temp_6, NULL); } { result = (PyObject *)__gluProject(arg1,arg2,arg3,(GLdouble const *)arg4,(GLdouble const *)arg5,(GLint const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg4, temp_4); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg4, temp_4); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap___gluUnProject(PyObject *self, PyObject *args) { PyObject *resultobj; GLdouble arg1 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble *arg4 = (GLdouble *) 0 ; GLdouble *arg5 = (GLdouble *) 0 ; GLint *arg6 = (GLint *) 0 ; PyObject *result; PyObject *temp_4 ; PyObject *temp_5 ; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOO:__gluUnProject",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail; { arg1 = (GLdouble)(SWIG_As_double(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = _PyObject_AsDoubleArray(obj3, &temp_4, NULL); } { arg5 = _PyObject_AsDoubleArray(obj4, &temp_5, NULL); } { arg6 = _PyObject_AsIntArray(obj5, &temp_6, NULL); } { result = (PyObject *)__gluUnProject(arg1,arg2,arg3,(GLdouble const *)arg4,(GLdouble const *)arg5,(GLint const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg4, temp_4); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg4, temp_4); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluScaleImage(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; PyObject *arg5 = (PyObject *) 0 ; GLint arg6 ; GLint arg7 ; GLenum arg8 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; PyObject * obj7 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOOOO:gluScaleImage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = obj4; } { arg6 = (GLint)(SWIG_As_int(obj5)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj6)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg8 = (GLenum)(SWIG_As_unsigned_SS_int(obj7)); if (SWIG_arg_fail(8)) SWIG_fail; } { result = (PyObject *)_gluScaleImage(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluScaleImageb(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLbyte *arg5 = (GLbyte *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImageb",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsCharArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLbyte const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImageub(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLubyte *arg5 = (GLubyte *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_UNSIGNED_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImageub",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsUnsignedCharArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLubyte const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImages(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLshort *arg5 = (GLshort *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImages",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsShortArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLshort const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImageus(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLushort *arg5 = (GLushort *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_UNSIGNED_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImageus",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsUnsignedShortArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLushort const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImagei(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLint *arg5 = (GLint *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImagei",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsIntArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLint const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImageui(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLuint *arg5 = (GLuint *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_UNSIGNED_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImageui",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsUnsignedIntArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLuint const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluScaleImagef(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLfloat *arg5 = (GLfloat *) 0 ; GLint arg6 ; GLint arg7 ; PyObject *result; PyObject *temp_5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg4 = GL_FLOAT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluScaleImagef",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg5 = _PyObject_AsFloatArray(obj1, &temp_5, NULL); } { arg6 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 1); } { arg3 = (GLint)_PyObject_Dimension(obj1, 0); } { result = (PyObject *)__gluScaleImage(arg1,arg2,arg3,arg4,(GLfloat const *)arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg5, temp_5); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg5, temp_5); } return NULL; } static PyObject *_wrap_gluBuild1DMipmaps(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; void *arg6 = (void *) 0 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOO:gluBuild1DMipmaps",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { int len; PyObject* str; if (obj5 == Py_None) { arg6= NULL; } else { str = PyObject_Str(obj5); PyString_AsStringAndSize(str, (char**)&arg6, &len); Py_DECREF(str); } } { result = (PyObject *)_gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(void const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluBuild1DMipmapsb(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLbyte *arg6 = (GLbyte *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsb",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsCharArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLbyte const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapsub(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLubyte *arg6 = (GLubyte *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_UNSIGNED_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsub",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsUnsignedCharArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLubyte const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapss(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLshort *arg6 = (GLshort *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapss",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsShortArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLshort const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapsus(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLushort *arg6 = (GLushort *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_UNSIGNED_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsus",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsUnsignedShortArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLushort const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapsi(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLint *arg6 = (GLint *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsi",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsIntArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLint const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapsui(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLuint *arg6 = (GLuint *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_UNSIGNED_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsui",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsUnsignedIntArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLuint const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild1DMipmapsf(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLshort *arg6 = (GLshort *) 0 ; PyObject *result; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { arg5 = GL_FLOAT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild1DMipmapsf",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg6 = _PyObject_AsShortArray(obj3, &temp_6, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj2, 0); } { result = (PyObject *)__gluBuild1DMipmaps(arg1,arg2,arg3,arg4,arg5,(GLshort const *)arg6); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluBuild2DMipmaps(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; void *arg7 = (void *) 0 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:gluBuild2DMipmaps",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj5)); if (SWIG_arg_fail(6)) SWIG_fail; } { int len; PyObject* str; if (obj6 == Py_None) { arg7= NULL; } else { str = PyObject_Str(obj6); PyString_AsStringAndSize(str, (char**)&arg7, &len); Py_DECREF(str); } } { result = (PyObject *)_gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(void const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluBuild2DMipmapsb(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLbyte *arg7 = (GLbyte *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsb",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsCharArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLbyte const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapsub(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLubyte *arg7 = (GLubyte *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_UNSIGNED_BYTE; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsub",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsUnsignedCharArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLubyte const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapss(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLshort *arg7 = (GLshort *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapss",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsShortArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLshort const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapsus(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLushort *arg7 = (GLushort *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_UNSIGNED_SHORT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsus",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsUnsignedShortArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLushort const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapsi(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLint *arg7 = (GLint *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsi",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsIntArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLint const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapsui(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLuint *arg7 = (GLuint *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_UNSIGNED_INT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsui",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsUnsignedIntArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLuint const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluBuild2DMipmapsf(PyObject *self, PyObject *args) { PyObject *resultobj; GLenum arg1 ; GLint arg2 ; GLint arg3 ; GLint arg4 ; GLenum arg5 ; GLenum arg6 ; GLshort *arg7 = (GLshort *) 0 ; PyObject *result; PyObject *temp_7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { arg6 = GL_FLOAT; } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluBuild2DMipmapsf",&obj0,&obj1,&obj2,&obj3)) goto fail; { arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); if (SWIG_arg_fail(1)) SWIG_fail; } { arg2 = (GLint)(SWIG_As_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg7 = _PyObject_AsShortArray(obj3, &temp_7, NULL); } { arg3 = (GLint)_PyObject_Dimension(obj3, 1); } { arg4 = (GLint)_PyObject_Dimension(obj3, 0); } { result = (PyObject *)__gluBuild2DMipmaps(arg1,arg2,arg3,arg4,arg5,arg6,(GLshort const *)arg7); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { _PyObject_AsArray_Cleanup(arg7, temp_7); } return resultobj; fail: { _PyObject_AsArray_Cleanup(arg7, temp_7); } return NULL; } static PyObject *_wrap_gluNewQuadric(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUquadric *result; if(!PyArg_ParseTuple(args,(char *)":gluNewQuadric")) goto fail; { result = (PyGLUquadric *)_gluNewQuadric(); if (GLErrOccurred()) { return NULL; } } { resultobj = (PyObject*)result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluDeleteQuadric(PyObject *self, PyObject *args) { PyObject *resultobj; PyObject *arg1 = (PyObject *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluDeleteQuadric",&obj0)) goto fail; { arg1 = obj0; } { __ignoreDeletionCall(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap_gluQuadricNormals(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLenum arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluQuadricNormals",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluQuadricNormals(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluQuadricTexture(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLboolean arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluQuadricTexture",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2= (PyObject_IsTrue(obj1)) ? GL_TRUE : GL_FALSE; } { gluQuadricTexture(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluQuadricOrientation(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLenum arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluQuadricOrientation",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluQuadricOrientation(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluQuadricDrawStyle(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLenum arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluQuadricDrawStyle",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluQuadricDrawStyle(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluCylinder(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; GLint arg5 ; GLint arg6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOO:gluCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLint)(SWIG_As_int(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg6 = (GLint)(SWIG_As_int(obj5)); if (SWIG_arg_fail(6)) SWIG_fail; } { gluCylinder(arg1,arg2,arg3,arg4,arg5,arg6); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluDisk(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLdouble arg2 ; GLdouble arg3 ; GLint arg4 ; GLint arg5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOO:gluDisk",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLint)(SWIG_As_int(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { gluDisk(arg1,arg2,arg3,arg4,arg5); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluPartialDisk(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLdouble arg2 ; GLdouble arg3 ; GLint arg4 ; GLint arg5 ; GLdouble arg6 ; GLdouble arg7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:gluPartialDisk",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { arg5 = (GLint)(SWIG_As_int(obj4)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg6 = (GLdouble)(SWIG_As_double(obj5)); if (SWIG_arg_fail(6)) SWIG_fail; } { arg7 = (GLdouble)(SWIG_As_double(obj6)); if (SWIG_arg_fail(7)) SWIG_fail; } { gluPartialDisk(arg1,arg2,arg3,arg4,arg5,arg6,arg7); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluSphere(PyObject *self, PyObject *args) { PyObject *resultobj; GLUquadric *arg1 = (GLUquadric *) 0 ; GLdouble arg2 ; GLint arg3 ; GLint arg4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOO:gluSphere",&obj0,&obj1,&obj2,&obj3)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } currentQuadric = (PyGLUquadric*)obj0; arg1 = currentQuadric->obj; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLint)(SWIG_As_int(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLint)(SWIG_As_int(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { gluSphere(arg1,arg2,arg3,arg4); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluQuadricCallback(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUquadric *arg1 = (PyGLUquadric *) 0 ; GLenum arg2 ; PyObject *arg3 = (PyObject *) 0 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluQuadricCallback",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUquadric_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUquadric object."); return NULL; } arg1 = currentQuadric = (PyGLUquadric*)obj0; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { if (obj2 != Py_None && !PyCallable_Check(obj2)) { PyErr_SetString(PyExc_Exception, "Not callable."); return NULL; } arg3 = obj2; } { result = (PyObject *)_gluQuadricCallback(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentQuadric = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluNewTess(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUtesselator *result; if(!PyArg_ParseTuple(args,(char *)":gluNewTess")) goto fail; { result = (PyGLUtesselator *)_gluNewTess(); if (GLErrOccurred()) { return NULL; } } { resultobj = (PyObject*)result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluDeleteTess(PyObject *self, PyObject *args) { PyObject *resultobj; PyObject *arg1 = (PyObject *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluDeleteTess",&obj0)) goto fail; { arg1 = obj0; } { __ignoreDeletionCall(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap_gluTessBeginPolygon(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUtesselator *arg1 = (PyGLUtesselator *) 0 ; PyObject *arg2 = (PyObject *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluTessBeginPolygon",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } arg1 = (PyGLUtesselator*)obj0; } { arg2 = obj1; } { _gluTessBeginPolygon(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluBeginPolygon(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluBeginPolygon",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { gluBeginPolygon(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessBeginContour(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluTessBeginContour",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { gluTessBeginContour(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessVertex(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUtesselator *arg1 = (PyGLUtesselator *) 0 ; GLdouble *arg2 = (GLdouble *) 0 ; PyObject *arg3 = (PyObject *) 0 ; PyObject *temp_2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluTessVertex",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } arg1 = (PyGLUtesselator*)obj0; } { arg2 = _PyObject_AsDoubleArray(obj1, &temp_2, NULL); } { arg3 = obj2; } { _gluTessVertex(arg1,(GLdouble const *)arg2,arg3); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg2, temp_2); } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg2, temp_2); } return NULL; } static PyObject *_wrap_gluTessEndContour(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluTessEndContour",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { gluTessEndContour(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluNextContour(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; GLenum arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:gluNextContour",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluNextContour(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessEndPolygon(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUtesselator *arg1 = (PyGLUtesselator *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluTessEndPolygon",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } arg1 = (PyGLUtesselator*)obj0; } { _gluTessEndPolygon(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluEndPolygon(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluEndPolygon",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { gluEndPolygon(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessProperty(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; GLenum arg2 ; GLdouble arg3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluTessProperty",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { gluTessProperty(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessNormal(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; GLdouble arg2 ; GLdouble arg3 ; GLdouble arg4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOO:gluTessNormal",&obj0,&obj1,&obj2,&obj3)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { arg2 = (GLdouble)(SWIG_As_double(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLdouble)(SWIG_As_double(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { arg4 = (GLdouble)(SWIG_As_double(obj3)); if (SWIG_arg_fail(4)) SWIG_fail; } { gluTessNormal(arg1,arg2,arg3,arg4); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluTessCallback(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUtesselator *arg1 = (PyGLUtesselator *) 0 ; GLenum arg2 ; PyObject *arg3 = (PyObject *) 0 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluTessCallback",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } arg1 = (PyGLUtesselator*)obj0; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { if (obj2 != Py_None && !PyCallable_Check(obj2)) { PyErr_SetString(PyExc_Exception, "Not callable."); return NULL; } arg3 = obj2; } { result = (PyObject *)_gluTessCallback(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluGetTessProperty(PyObject *self, PyObject *args) { PyObject *resultobj; GLUtesselator *arg1 = (GLUtesselator *) 0 ; GLenum arg2 ; GLdouble *arg3 ; double temp_3[1] ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; { int i; arg3 = temp_3; for (i = 0; i < 1; i++) arg3[i] = -DBL_MAX; } if(!PyArg_ParseTuple(args,(char *)"OO:gluGetTessProperty",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUtesselator_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUtesselator object."); return NULL; } /*currentTesselator = (PyGLUtesselator*)obj0;*/ arg1 = ((PyGLUtesselator*)obj0)->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluGetTessProperty(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { int n, dims[2]; Py_XDECREF(resultobj); for (n = 0; n < 1 && arg3[n] != -DBL_MAX; n++); switch (n) { case 0: Py_INCREF(Py_None); resultobj = Py_None; break; case 1: resultobj = PyFloat_FromDouble(arg3[0]); break; case 16: dims[0] = 4; dims[1] = 4; resultobj = _PyObject_FromDoubleArray(2, dims, arg3, 0); break; default: resultobj = _PyTuple_FromDoubleArray(n, arg3); } } { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return resultobj; fail: { /*currentTesselator = NULL;*/ if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluNewNurbsRenderer(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUnurbs *result; if(!PyArg_ParseTuple(args,(char *)":gluNewNurbsRenderer")) goto fail; { result = (PyGLUnurbs *)_gluNewNurbsRenderer(); if (GLErrOccurred()) { return NULL; } } { resultobj = (PyObject*)result; } return resultobj; fail: return NULL; } static PyObject *_wrap_gluDeleteNurbsRenderer(PyObject *self, PyObject *args) { PyObject *resultobj; PyObject *arg1 = (PyObject *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluDeleteNurbsRenderer",&obj0)) goto fail; { arg1 = obj0; } { __ignoreDeletionCall(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; return resultobj; fail: return NULL; } static PyObject *_wrap_gluBeginSurface(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluBeginSurface",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluBeginSurface(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluBeginCurve(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluBeginCurve",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluBeginCurve(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluEndCurve(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluEndCurve",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluEndCurve(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluEndSurface(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluEndSurface",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluEndSurface(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluBeginTrim(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluBeginTrim",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluBeginTrim(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluEndTrim(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject * obj0 = 0 ; if(!PyArg_ParseTuple(args,(char *)"O:gluEndTrim",&obj0)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { gluEndTrim(arg1); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluPwlCurve(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLint arg2 ; GLfloat *arg3 = (GLfloat *) 0 ; GLint arg4 ; GLenum arg5 ; PyObject *temp_3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; { } { } if(!PyArg_ParseTuple(args,(char *)"OOO:gluPwlCurve",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg3 = _PyObject_AsFloatArray(obj1, &temp_3, NULL); } { arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); if (SWIG_arg_fail(5)) SWIG_fail; } { arg2 = (GLint)_PyObject_Dimension(obj1, 0); } { arg4 = (GLint)_PyObject_Dimension(obj1, 1); } { _gluPwlCurve(arg1,arg2,(GLfloat const *)arg3,arg4,arg5); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } return NULL; } static PyObject *_wrap_gluNurbsCurve(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLint arg2 ; GLfloat *arg3 = (GLfloat *) 0 ; GLint arg4 ; GLint arg5 ; GLfloat *arg6 = (GLfloat *) 0 ; GLenum arg7 ; PyObject *temp_3 ; PyObject *temp_6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; { } { } { } if(!PyArg_ParseTuple(args,(char *)"OOOO:gluNurbsCurve",&obj0,&obj1,&obj2,&obj3)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg3 = _PyObject_AsFloatArray(obj1, &temp_3, NULL); } { arg6 = _PyObject_AsFloatArray(obj2, &temp_6, NULL); } { arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); if (SWIG_arg_fail(7)) SWIG_fail; } { arg2 = (GLint)_PyObject_AsArray_Size(obj1); } { arg4 = (GLint)_PyObject_Dimension(obj2, 0); } { arg5 = (GLint)_PyObject_Dimension(obj2, 1); } { _gluNurbsCurve(arg1,arg2,(GLfloat const *)arg3,arg4,arg5,(GLfloat const *)arg6,arg7); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg6, temp_6); } return NULL; } static PyObject *_wrap_gluNurbsSurface(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLint arg2 ; GLfloat *arg3 = (GLfloat *) 0 ; GLint arg4 ; GLfloat *arg5 = (GLfloat *) 0 ; GLint arg6 ; GLint arg7 ; GLint arg8 ; GLfloat *arg9 = (GLfloat *) 0 ; GLenum arg10 ; PyObject *temp_3 ; PyObject *temp_5 ; PyObject *temp_9 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; { } { } { } { } { } if(!PyArg_ParseTuple(args,(char *)"OOOOO:gluNurbsSurface",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg3 = _PyObject_AsFloatArray(obj1, &temp_3, NULL); } { arg5 = _PyObject_AsFloatArray(obj2, &temp_5, NULL); } { arg9 = _PyObject_AsFloatArray(obj3, &temp_9, NULL); } { arg10 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); if (SWIG_arg_fail(10)) SWIG_fail; } { arg2 = (GLint)_PyObject_AsArray_Size(obj1); } { arg4 = (GLint)_PyObject_AsArray_Size(obj2); } { arg6 = (GLint)_PyObject_Dimension(obj3, 0); } { arg7 = (GLint)_PyObject_Dimension(obj3, 1); } { arg8 = (GLint)_PyObject_Dimension(obj3, 2); } { _gluNurbsSurface(arg1,arg2,(GLfloat const *)arg3,arg4,(GLfloat const *)arg5,arg6,arg7,arg8,(GLfloat const *)arg9,arg10); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg9, temp_9); } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg5, temp_5); } { _PyObject_AsArray_Cleanup(arg9, temp_9); } return NULL; } static PyObject *_wrap_gluLoadSamplingMatrices(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLfloat *arg2 = (GLfloat *) 0 ; GLfloat *arg3 = (GLfloat *) 0 ; GLint *arg4 = (GLint *) 0 ; PyObject *temp_2 ; PyObject *temp_3 ; PyObject *temp_4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOOO:gluLoadSamplingMatrices",&obj0,&obj1,&obj2,&obj3)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg2 = _PyObject_AsFloatArray(obj1, &temp_2, NULL); } { arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); } { arg4 = _PyObject_AsIntArray(obj3, &temp_4, NULL); } { gluLoadSamplingMatrices(arg1,(GLfloat const *)arg2,(GLfloat const *)arg3,(GLint const *)arg4); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg2, temp_2); } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg4, temp_4); } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } { _PyObject_AsArray_Cleanup(arg2, temp_2); } { _PyObject_AsArray_Cleanup(arg3, temp_3); } { _PyObject_AsArray_Cleanup(arg4, temp_4); } return NULL; } static PyObject *_wrap_gluNurbsProperty(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLenum arg2 ; GLfloat arg3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluNurbsProperty",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { arg3 = (GLfloat)(SWIG_As_float(obj2)); if (SWIG_arg_fail(3)) SWIG_fail; } { gluNurbsProperty(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluGetNurbsProperty(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; GLenum arg2 ; GLfloat *arg3 ; float temp_3[1] ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; { int i; arg3 = temp_3; for (i = 0; i < 1; i++) arg3[i] = -FLT_MAX; } if(!PyArg_ParseTuple(args,(char *)"OO:gluGetNurbsProperty",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { gluGetNurbsProperty(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { int n, dims[2]; Py_XDECREF(resultobj); for (n = 0; n < 1 && arg3[n] != -FLT_MAX; n++); switch (n) { case 0: Py_INCREF(Py_None); resultobj = Py_None; break; case 1: resultobj = PyFloat_FromDouble(arg3[0]); break; case 16: dims[0] = 4; dims[1] = 4; resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); break; default: resultobj = _PyTuple_FromFloatArray(n, arg3); } } { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap_gluNurbsCallback(PyObject *self, PyObject *args) { PyObject *resultobj; PyGLUnurbs *arg1 = (PyGLUnurbs *) 0 ; GLenum arg2 ; PyObject *arg3 = (PyObject *) 0 ; PyObject *result; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OOO:gluNurbsCallback",&obj0,&obj1,&obj2)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } arg1 = currentNurbs = (PyGLUnurbs*)obj0; } { arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); if (SWIG_arg_fail(2)) SWIG_fail; } { if (obj2 != Py_None && !PyCallable_Check(obj2)) { PyErr_SetString(PyExc_Exception, "Not callable."); return NULL; } arg3 = obj2; } { result = (PyObject *)_gluNurbsCallback(arg1,arg2,arg3); if (GLErrOccurred()) { return NULL; } } { resultobj= result; } { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap___gluNurbsCallbackDataEXT(PyObject *self, PyObject *args) { PyObject *resultobj; GLUnurbs *arg1 = (GLUnurbs *) 0 ; PyObject *arg2 = (PyObject *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if(!PyArg_ParseTuple(args,(char *)"OO:__gluNurbsCallbackDataEXT",&obj0,&obj1)) goto fail; { if (obj0->ob_type != &PyGLUnurbs_Type) { PyErr_SetString(PyExc_Exception, "Not a GLUnurbs object."); return NULL; } currentNurbs = (PyGLUnurbs*)obj0; arg1 = currentNurbs->obj; } { arg2 = obj1; } { __gluNurbsCallbackDataEXT(arg1,arg2); if (GLErrOccurred()) { return NULL; } } Py_INCREF(Py_None); resultobj = Py_None; { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return resultobj; fail: { currentNurbs = NULL; if (PyErr_Occurred()) return NULL; } return NULL; } static PyObject *_wrap___gluInitNurbsTessellatorEXT(PyObject *self, PyObject *args) { PyObject *resultobj; int result; if(!PyArg_ParseTuple(args,(char *)":__gluInitNurbsTessellatorEXT")) goto fail; { result = (int)__gluInitNurbsTessellatorEXT(); if (GLErrOccurred()) { return NULL; } } { resultobj = SWIG_From_int((int)(result)); } return resultobj; fail: return NULL; } static PyMethodDef SwigMethods[] = { { (char *)"gluErrorString", _wrap_gluErrorString, METH_VARARGS, NULL}, { (char *)"gluGetString", _wrap_gluGetString, METH_VARARGS, NULL}, { (char *)"gluOrtho2D", _wrap_gluOrtho2D, METH_VARARGS, NULL}, { (char *)"gluPerspective", _wrap_gluPerspective, METH_VARARGS, NULL}, { (char *)"__gluPickMatrix", _wrap___gluPickMatrix, METH_VARARGS, NULL}, { (char *)"gluLookAt", _wrap_gluLookAt, METH_VARARGS, NULL}, { (char *)"__gluProject", _wrap___gluProject, METH_VARARGS, NULL}, { (char *)"__gluUnProject", _wrap___gluUnProject, METH_VARARGS, NULL}, { (char *)"gluScaleImage", _wrap_gluScaleImage, METH_VARARGS, NULL}, { (char *)"gluScaleImageb", _wrap_gluScaleImageb, METH_VARARGS, NULL}, { (char *)"gluScaleImageub", _wrap_gluScaleImageub, METH_VARARGS, NULL}, { (char *)"gluScaleImages", _wrap_gluScaleImages, METH_VARARGS, NULL}, { (char *)"gluScaleImageus", _wrap_gluScaleImageus, METH_VARARGS, NULL}, { (char *)"gluScaleImagei", _wrap_gluScaleImagei, METH_VARARGS, NULL}, { (char *)"gluScaleImageui", _wrap_gluScaleImageui, METH_VARARGS, NULL}, { (char *)"gluScaleImagef", _wrap_gluScaleImagef, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmaps", _wrap_gluBuild1DMipmaps, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsb", _wrap_gluBuild1DMipmapsb, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsub", _wrap_gluBuild1DMipmapsub, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapss", _wrap_gluBuild1DMipmapss, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsus", _wrap_gluBuild1DMipmapsus, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsi", _wrap_gluBuild1DMipmapsi, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsui", _wrap_gluBuild1DMipmapsui, METH_VARARGS, NULL}, { (char *)"gluBuild1DMipmapsf", _wrap_gluBuild1DMipmapsf, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmaps", _wrap_gluBuild2DMipmaps, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsb", _wrap_gluBuild2DMipmapsb, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsub", _wrap_gluBuild2DMipmapsub, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapss", _wrap_gluBuild2DMipmapss, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsus", _wrap_gluBuild2DMipmapsus, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsi", _wrap_gluBuild2DMipmapsi, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsui", _wrap_gluBuild2DMipmapsui, METH_VARARGS, NULL}, { (char *)"gluBuild2DMipmapsf", _wrap_gluBuild2DMipmapsf, METH_VARARGS, NULL}, { (char *)"gluNewQuadric", _wrap_gluNewQuadric, METH_VARARGS, NULL}, { (char *)"gluDeleteQuadric", _wrap_gluDeleteQuadric, METH_VARARGS, NULL}, { (char *)"gluQuadricNormals", _wrap_gluQuadricNormals, METH_VARARGS, NULL}, { (char *)"gluQuadricTexture", _wrap_gluQuadricTexture, METH_VARARGS, NULL}, { (char *)"gluQuadricOrientation", _wrap_gluQuadricOrientation, METH_VARARGS, NULL}, { (char *)"gluQuadricDrawStyle", _wrap_gluQuadricDrawStyle, METH_VARARGS, NULL}, { (char *)"gluCylinder", _wrap_gluCylinder, METH_VARARGS, NULL}, { (char *)"gluDisk", _wrap_gluDisk, METH_VARARGS, NULL}, { (char *)"gluPartialDisk", _wrap_gluPartialDisk, METH_VARARGS, NULL}, { (char *)"gluSphere", _wrap_gluSphere, METH_VARARGS, NULL}, { (char *)"gluQuadricCallback", _wrap_gluQuadricCallback, METH_VARARGS, NULL}, { (char *)"gluNewTess", _wrap_gluNewTess, METH_VARARGS, NULL}, { (char *)"gluDeleteTess", _wrap_gluDeleteTess, METH_VARARGS, NULL}, { (char *)"gluTessBeginPolygon", _wrap_gluTessBeginPolygon, METH_VARARGS, NULL}, { (char *)"gluBeginPolygon", _wrap_gluBeginPolygon, METH_VARARGS, NULL}, { (char *)"gluTessBeginContour", _wrap_gluTessBeginContour, METH_VARARGS, NULL}, { (char *)"gluTessVertex", _wrap_gluTessVertex, METH_VARARGS, NULL}, { (char *)"gluTessEndContour", _wrap_gluTessEndContour, METH_VARARGS, NULL}, { (char *)"gluNextContour", _wrap_gluNextContour, METH_VARARGS, NULL}, { (char *)"gluTessEndPolygon", _wrap_gluTessEndPolygon, METH_VARARGS, NULL}, { (char *)"gluEndPolygon", _wrap_gluEndPolygon, METH_VARARGS, NULL}, { (char *)"gluTessProperty", _wrap_gluTessProperty, METH_VARARGS, NULL}, { (char *)"gluTessNormal", _wrap_gluTessNormal, METH_VARARGS, NULL}, { (char *)"gluTessCallback", _wrap_gluTessCallback, METH_VARARGS, NULL}, { (char *)"gluGetTessProperty", _wrap_gluGetTessProperty, METH_VARARGS, NULL}, { (char *)"gluNewNurbsRenderer", _wrap_gluNewNurbsRenderer, METH_VARARGS, NULL}, { (char *)"gluDeleteNurbsRenderer", _wrap_gluDeleteNurbsRenderer, METH_VARARGS, NULL}, { (char *)"gluBeginSurface", _wrap_gluBeginSurface, METH_VARARGS, NULL}, { (char *)"gluBeginCurve", _wrap_gluBeginCurve, METH_VARARGS, NULL}, { (char *)"gluEndCurve", _wrap_gluEndCurve, METH_VARARGS, NULL}, { (char *)"gluEndSurface", _wrap_gluEndSurface, METH_VARARGS, NULL}, { (char *)"gluBeginTrim", _wrap_gluBeginTrim, METH_VARARGS, NULL}, { (char *)"gluEndTrim", _wrap_gluEndTrim, METH_VARARGS, NULL}, { (char *)"gluPwlCurve", _wrap_gluPwlCurve, METH_VARARGS, NULL}, { (char *)"gluNurbsCurve", _wrap_gluNurbsCurve, METH_VARARGS, NULL}, { (char *)"gluNurbsSurface", _wrap_gluNurbsSurface, METH_VARARGS, NULL}, { (char *)"gluLoadSamplingMatrices", _wrap_gluLoadSamplingMatrices, METH_VARARGS, NULL}, { (char *)"gluNurbsProperty", _wrap_gluNurbsProperty, METH_VARARGS, NULL}, { (char *)"gluGetNurbsProperty", _wrap_gluGetNurbsProperty, METH_VARARGS, NULL}, { (char *)"gluNurbsCallback", _wrap_gluNurbsCallback, METH_VARARGS, NULL}, { (char *)"__gluNurbsCallbackDataEXT", _wrap___gluNurbsCallbackDataEXT, METH_VARARGS, NULL}, { (char *)"__gluInitNurbsTessellatorEXT", _wrap___gluInitNurbsTessellatorEXT, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_GLsizei[] = {{"_p_GLsizei", 0, "int *|GLsizei *", 0, 0, 0, 0},{"_p_GLint", 0, 0, 0, 0, 0, 0},{"_p_GLsizei", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLshort[] = {{"_p_GLshort", 0, "short *|GLshort *", 0, 0, 0, 0},{"_p_GLshort", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLboolean[] = {{"_p_GLboolean", 0, "unsigned char *|GLboolean *", 0, 0, 0, 0},{"_p_GLboolean", 0, 0, 0, 0, 0, 0},{"_p_GLubyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLUquadric[] = {{"_p_GLUquadric", 0, "GLUquadric *", 0, 0, 0, 0},{"_p_GLUquadric", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_PyGLUquadric[] = {{"_p_PyGLUquadric", 0, "PyGLUquadric *", 0, 0, 0, 0},{"_p_PyGLUquadric", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLUnurbs[] = {{"_p_GLUnurbs", 0, "GLUnurbs *", 0, 0, 0, 0},{"_p_GLUnurbs", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_PyGLUnurbs[] = {{"_p_PyGLUnurbs", 0, "PyGLUnurbs *", 0, 0, 0, 0},{"_p_PyGLUnurbs", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLushort[] = {{"_p_GLushort", 0, "unsigned short *|GLushort *", 0, 0, 0, 0},{"_p_GLushort", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLenum[] = {{"_p_GLenum", 0, "unsigned int *|GLenum *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLvoid[] = {{"_p_GLvoid", 0, "void *|GLvoid *", 0, 0, 0, 0},{"_p_GLvoid", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLint[] = {{"_p_GLint", 0, "int *|GLint *", 0, 0, 0, 0},{"_p_GLint", 0, 0, 0, 0, 0, 0},{"_p_GLsizei", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLclampd[] = {{"_p_GLclampd", 0, "double *|GLclampd *", 0, 0, 0, 0},{"_p_GLclampd", 0, 0, 0, 0, 0, 0},{"_p_GLdouble", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_PyGLUtesselator[] = {{"_p_PyGLUtesselator", 0, "PyGLUtesselator *", 0, 0, 0, 0},{"_p_PyGLUtesselator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLUtesselator[] = {{"_p_GLUtesselator", 0, "GLUtesselator *", 0, 0, 0, 0},{"_p_GLUtesselator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLclampf[] = {{"_p_GLclampf", 0, "float *|GLclampf *", 0, 0, 0, 0},{"_p_GLfloat", 0, 0, 0, 0, 0, 0},{"_p_GLclampf", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLuint[] = {{"_p_GLuint", 0, "unsigned int *|GLuint *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLbyte[] = {{"_p_GLbyte", 0, "signed char *|GLbyte *", 0, 0, 0, 0},{"_p_GLbyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLbitfield[] = {{"_p_GLbitfield", 0, "unsigned int *|GLbitfield *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLfloat[] = {{"_p_GLfloat", 0, "float *|GLfloat *", 0, 0, 0, 0},{"_p_GLfloat", 0, 0, 0, 0, 0, 0},{"_p_GLclampf", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLubyte[] = {{"_p_GLubyte", 0, "unsigned char *|GLubyte *", 0, 0, 0, 0},{"_p_GLboolean", 0, 0, 0, 0, 0, 0},{"_p_GLubyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info _swigt__p_GLdouble[] = {{"_p_GLdouble", 0, "double *|GLdouble *", 0, 0, 0, 0},{"_p_GLclampd", 0, 0, 0, 0, 0, 0},{"_p_GLdouble", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; static swig_type_info *swig_types_initial[] = { _swigt__p_GLsizei, _swigt__p_GLshort, _swigt__p_GLboolean, _swigt__p_GLUquadric, _swigt__p_PyGLUquadric, _swigt__p_GLUnurbs, _swigt__p_PyGLUnurbs, _swigt__size_t, _swigt__p_GLushort, _swigt__p_GLenum, _swigt__p_GLvoid, _swigt__p_GLint, _swigt__p_char, _swigt__p_GLclampd, _swigt__p_PyGLUtesselator, _swigt__p_GLUtesselator, _swigt__p_GLclampf, _swigt__p_GLuint, _swigt__ptrdiff_t, _swigt__p_GLbyte, _swigt__p_GLbitfield, _swigt__p_GLfloat, _swigt__p_GLubyte, _swigt__p_GLdouble, 0 }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ static swig_const_info swig_const_table[] = { { SWIG_PY_POINTER, (char*)"__version__", 0, 0, (void *)"1.1.4.3", &SWIGTYPE_p_char}, { SWIG_PY_POINTER, (char*)"__date__", 0, 0, (void *)"2004/11/14 23:21:33", &SWIGTYPE_p_char}, { SWIG_PY_POINTER, (char*)"__author__", 0, 0, (void *)"Tarn Weisner Burton ", &SWIGTYPE_p_char}, { SWIG_PY_POINTER, (char*)"__doc__", 0, 0, (void *)"http://www.opengl.org/developers/documentation/glx.html", &SWIGTYPE_p_char}, {0, 0, 0, 0.0, 0, 0}}; #ifdef __cplusplus } #endif #ifdef SWIG_LINK_RUNTIME #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(_MSC_VER) || defined(__GNUC__) # define SWIGIMPORT(a) extern a # else # if defined(__BORLANDC__) # define SWIGIMPORT(a) a _export # else # define SWIGIMPORT(a) a # endif # endif #else # define SWIGIMPORT(a) a #endif #ifdef __cplusplus extern "C" #endif SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *); #endif #ifdef __cplusplus extern "C" #endif SWIGEXPORT(void) SWIG_init(void) { static PyObject *SWIG_globals = 0; static int typeinit = 0; PyObject *m, *d; int i; if (!SWIG_globals) SWIG_globals = SWIG_newvarlink(); /* Fix SwigMethods to carry the callback ptrs when needed */ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial); m = Py_InitModule((char *) SWIG_name, SwigMethods); d = PyModule_GetDict(m); if (!typeinit) { #ifdef SWIG_LINK_RUNTIME swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle); #else # ifndef SWIG_STATIC_RUNTIME SWIG_Python_LookupTypePointer(&swig_type_list_handle); # endif #endif for (i = 0; swig_types_initial[i]; i++) { swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]); } typeinit = 1; } SWIG_InstallConstants(d,swig_const_table); PyDict_SetItemString(d,"__version__", SWIG_FromCharPtr("1.1.4.3")); PyDict_SetItemString(d,"__date__", SWIG_FromCharPtr("2004/11/14 23:21:33")); { PyDict_SetItemString(d,"__api_version__", SWIG_From_int((int)(258))); } PyDict_SetItemString(d,"__author__", SWIG_FromCharPtr("Tarn Weisner Burton ")); PyDict_SetItemString(d,"__doc__", SWIG_FromCharPtr("http://www.opengl.org/developers/documentation/glx.html")); #ifdef NUMERIC PyArray_API = NULL; import_array(); init_util(); PyErr_Clear(); #endif { PyObject *util = PyImport_ImportModule("OpenGL.GL._GL__init__"); if (util) { PyObject *api_object = PyDict_GetItemString(PyModule_GetDict(util), "_util_API"); if (PyCObject_Check(api_object)) _util_API = (util_API*)PyCObject_AsVoidPtr(api_object); } } PyDict_SetItemString(d, "GLUerror", GLUerror); { PyDict_SetItemString(d,"GLU_VERSION_1_1", SWIG_From_int((int)(1))); } { PyDict_SetItemString(d,"GLU_VERSION_1_2", SWIG_From_int((int)(1))); } { PyDict_SetItemString(d,"GLU_INVALID_ENUM", SWIG_From_int((int)(100900))); } { PyDict_SetItemString(d,"GLU_INVALID_VALUE", SWIG_From_int((int)(100901))); } { PyDict_SetItemString(d,"GLU_OUT_OF_MEMORY", SWIG_From_int((int)(100902))); } { PyDict_SetItemString(d,"GLU_INCOMPATIBLE_GL_VERSION", SWIG_From_int((int)(100903))); } { PyDict_SetItemString(d,"GLU_VERSION", SWIG_From_int((int)(100800))); } { PyDict_SetItemString(d,"GLU_EXTENSIONS", SWIG_From_int((int)(100801))); } { PyDict_SetItemString(d,"GLU_SMOOTH", SWIG_From_int((int)(100000))); } { PyDict_SetItemString(d,"GLU_FLAT", SWIG_From_int((int)(100001))); } { PyDict_SetItemString(d,"GLU_NONE", SWIG_From_int((int)(100002))); } { PyDict_SetItemString(d,"GLU_POINT", SWIG_From_int((int)(100010))); } { PyDict_SetItemString(d,"GLU_LINE", SWIG_From_int((int)(100011))); } { PyDict_SetItemString(d,"GLU_FILL", SWIG_From_int((int)(100012))); } { PyDict_SetItemString(d,"GLU_SILHOUETTE", SWIG_From_int((int)(100013))); } { PyDict_SetItemString(d,"GLU_OUTSIDE", SWIG_From_int((int)(100020))); } { PyDict_SetItemString(d,"GLU_INSIDE", SWIG_From_int((int)(100021))); } { PyDict_SetItemString(d,"GLU_TESS_MAX_COORD", SWIG_From_double((double)(1.0e150))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_RULE", SWIG_From_int((int)(100140))); } { PyDict_SetItemString(d,"GLU_TESS_BOUNDARY_ONLY", SWIG_From_int((int)(100141))); } { PyDict_SetItemString(d,"GLU_TESS_TOLERANCE", SWIG_From_int((int)(100142))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_ODD", SWIG_From_int((int)(100130))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_NONZERO", SWIG_From_int((int)(100131))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_POSITIVE", SWIG_From_int((int)(100132))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_NEGATIVE", SWIG_From_int((int)(100133))); } { PyDict_SetItemString(d,"GLU_TESS_WINDING_ABS_GEQ_TWO", SWIG_From_int((int)(100134))); } { PyDict_SetItemString(d,"GLU_TESS_BEGIN", SWIG_From_int((int)(100100))); } { PyDict_SetItemString(d,"GLU_TESS_VERTEX", SWIG_From_int((int)(100101))); } { PyDict_SetItemString(d,"GLU_TESS_END", SWIG_From_int((int)(100102))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR", SWIG_From_int((int)(100103))); } { PyDict_SetItemString(d,"GLU_TESS_EDGE_FLAG", SWIG_From_int((int)(100104))); } { PyDict_SetItemString(d,"GLU_TESS_COMBINE", SWIG_From_int((int)(100105))); } { PyDict_SetItemString(d,"GLU_TESS_BEGIN_DATA", SWIG_From_int((int)(100106))); } { PyDict_SetItemString(d,"GLU_TESS_VERTEX_DATA", SWIG_From_int((int)(100107))); } { PyDict_SetItemString(d,"GLU_TESS_END_DATA", SWIG_From_int((int)(100108))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR_DATA", SWIG_From_int((int)(100109))); } { PyDict_SetItemString(d,"GLU_TESS_EDGE_FLAG_DATA", SWIG_From_int((int)(100110))); } { PyDict_SetItemString(d,"GLU_TESS_COMBINE_DATA", SWIG_From_int((int)(100111))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR1", SWIG_From_int((int)(100151))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR2", SWIG_From_int((int)(100152))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR3", SWIG_From_int((int)(100153))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR4", SWIG_From_int((int)(100154))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR5", SWIG_From_int((int)(100155))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR6", SWIG_From_int((int)(100156))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR7", SWIG_From_int((int)(100157))); } { PyDict_SetItemString(d,"GLU_TESS_ERROR8", SWIG_From_int((int)(100158))); } { PyDict_SetItemString(d,"GLU_TESS_MISSING_BEGIN_POLYGON", SWIG_From_int((int)(100151))); } { PyDict_SetItemString(d,"GLU_TESS_MISSING_BEGIN_CONTOUR", SWIG_From_int((int)(100152))); } { PyDict_SetItemString(d,"GLU_TESS_MISSING_END_POLYGON", SWIG_From_int((int)(100153))); } { PyDict_SetItemString(d,"GLU_TESS_MISSING_END_CONTOUR", SWIG_From_int((int)(100154))); } { PyDict_SetItemString(d,"GLU_TESS_COORD_TOO_LARGE", SWIG_From_int((int)(100155))); } { PyDict_SetItemString(d,"GLU_TESS_NEED_COMBINE_CALLBACK", SWIG_From_int((int)(100156))); } { PyDict_SetItemString(d,"GLU_AUTO_LOAD_MATRIX", SWIG_From_int((int)(100200))); } { PyDict_SetItemString(d,"GLU_CULLING", SWIG_From_int((int)(100201))); } { PyDict_SetItemString(d,"GLU_SAMPLING_TOLERANCE", SWIG_From_int((int)(100203))); } { PyDict_SetItemString(d,"GLU_DISPLAY_MODE", SWIG_From_int((int)(100204))); } { PyDict_SetItemString(d,"GLU_PARAMETRIC_TOLERANCE", SWIG_From_int((int)(100202))); } { PyDict_SetItemString(d,"GLU_SAMPLING_METHOD", SWIG_From_int((int)(100205))); } { PyDict_SetItemString(d,"GLU_U_STEP", SWIG_From_int((int)(100206))); } { PyDict_SetItemString(d,"GLU_V_STEP", SWIG_From_int((int)(100207))); } { PyDict_SetItemString(d,"GLU_PATH_LENGTH", SWIG_From_int((int)(100215))); } { PyDict_SetItemString(d,"GLU_PARAMETRIC_ERROR", SWIG_From_int((int)(100216))); } { PyDict_SetItemString(d,"GLU_DOMAIN_DISTANCE", SWIG_From_int((int)(100217))); } { PyDict_SetItemString(d,"GLU_MAP1_TRIM_2", SWIG_From_int((int)(100210))); } { PyDict_SetItemString(d,"GLU_MAP1_TRIM_3", SWIG_From_int((int)(100211))); } { PyDict_SetItemString(d,"GLU_OUTLINE_POLYGON", SWIG_From_int((int)(100240))); } { PyDict_SetItemString(d,"GLU_OUTLINE_PATCH", SWIG_From_int((int)(100241))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR1", SWIG_From_int((int)(100251))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR2", SWIG_From_int((int)(100252))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR3", SWIG_From_int((int)(100253))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR4", SWIG_From_int((int)(100254))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR5", SWIG_From_int((int)(100255))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR6", SWIG_From_int((int)(100256))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR7", SWIG_From_int((int)(100257))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR8", SWIG_From_int((int)(100258))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR9", SWIG_From_int((int)(100259))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR10", SWIG_From_int((int)(100260))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR11", SWIG_From_int((int)(100261))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR12", SWIG_From_int((int)(100262))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR13", SWIG_From_int((int)(100263))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR14", SWIG_From_int((int)(100264))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR15", SWIG_From_int((int)(100265))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR16", SWIG_From_int((int)(100266))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR17", SWIG_From_int((int)(100267))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR18", SWIG_From_int((int)(100268))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR19", SWIG_From_int((int)(100269))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR20", SWIG_From_int((int)(100270))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR21", SWIG_From_int((int)(100271))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR22", SWIG_From_int((int)(100272))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR23", SWIG_From_int((int)(100273))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR24", SWIG_From_int((int)(100274))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR25", SWIG_From_int((int)(100275))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR26", SWIG_From_int((int)(100276))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR27", SWIG_From_int((int)(100277))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR28", SWIG_From_int((int)(100278))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR29", SWIG_From_int((int)(100279))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR30", SWIG_From_int((int)(100280))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR31", SWIG_From_int((int)(100281))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR32", SWIG_From_int((int)(100282))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR33", SWIG_From_int((int)(100283))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR34", SWIG_From_int((int)(100284))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR35", SWIG_From_int((int)(100285))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR36", SWIG_From_int((int)(100286))); } { PyDict_SetItemString(d,"GLU_NURBS_ERROR37", SWIG_From_int((int)(100287))); } { PyDict_SetItemString(d,"GLU_CW", SWIG_From_int((int)(100120))); } { PyDict_SetItemString(d,"GLU_CCW", SWIG_From_int((int)(100121))); } { PyDict_SetItemString(d,"GLU_INTERIOR", SWIG_From_int((int)(100122))); } { PyDict_SetItemString(d,"GLU_EXTERIOR", SWIG_From_int((int)(100123))); } { PyDict_SetItemString(d,"GLU_UNKNOWN", SWIG_From_int((int)(100124))); } { PyDict_SetItemString(d,"GLU_BEGIN", SWIG_From_int((int)(100100))); } { PyDict_SetItemString(d,"GLU_VERTEX", SWIG_From_int((int)(100101))); } { PyDict_SetItemString(d,"GLU_END", SWIG_From_int((int)(100102))); } { PyDict_SetItemString(d,"GLU_ERROR", SWIG_From_int((int)(100103))); } { PyDict_SetItemString(d,"GLU_EDGE_FLAG", SWIG_From_int((int)(100104))); } }