1 2 /* 3 Input used to generate the Python module "glmodule.c". 4 The stub generator is a Python script called "cgen.py". 5 6 Each definition must be contained on one line: 7 8 <returntype> <name> <type> <arg> <type> <arg> 9 10 <returntype> can be: void, short, long (XXX maybe others?) 11 12 <type> can be: char, string, short, float, long, or double 13 string indicates a null terminated string; 14 if <type> is char and <arg> begins with a *, the * is stripped 15 and <type> is changed into string 16 17 <arg> has the form <mode> or <mode>[<subscript>] 18 where <mode> can be 19 s: arg is sent 20 r: arg is received (arg is a pointer) 21 and <subscript> can be (N and I are numbers): 22 N 23 argI 24 retval 25 N*argI 26 N*I 27 N*retval 28 In the case where the subscript consists of two parts 29 separated by *, the first part is the width of the matrix, and 30 the second part is the length of the matrix. This order is 31 opposite from the order used in C to declare a two-dimensional 32 matrix. 33 */ 34 35 /* 36 * An attempt has been made to make this module switch threads on qread 37 * calls. It is far from safe, though. 38 */ 39 40 #include <gl.h> 41 #include <device.h> 42 43 #ifdef __sgi 44 extern int devport(); 45 extern int textwritemask(); 46 extern int pagewritemask(); 47 extern int gewrite(); 48 extern int gettp(); 49 #endif 50 51 #include "Python.h" 52 #include "cgensupport.h" 53 54 /* 55 Some stubs are too complicated for the stub generator. 56 We can include manually written versions of them here. 57 A line starting with '%' gives the name of the function so the stub 58 generator can include it in the table of functions. 59 */ 60 61 62 static PyObject * 63 gl_qread(PyObject *self, PyObject *args) 64 { 65 long retval; 66 short arg1 ; 67 Py_BEGIN_ALLOW_THREADS 68 retval = qread( & arg1 ); 69 Py_END_ALLOW_THREADS 70 { PyObject *v = PyTuple_New( 2 ); 71 if (v == NULL) return NULL; 72 PyTuple_SetItem(v, 0, mknewlongobject(retval)); 73 PyTuple_SetItem(v, 1, mknewshortobject(arg1)); 74 return v; 75 } 76 } 77 78 79 /* 80 varray -- an array of v.. calls. 81 The argument is an array (maybe list or tuple) of points. 82 Each point must be a tuple or list of coordinates (x, y, z). 83 The points may be 2- or 3-dimensional but must all have the 84 same dimension. Float and int values may be mixed however. 85 The points are always converted to 3D double precision points 86 by assuming z=0.0 if necessary (as indicated in the man page), 87 and for each point v3d() is called. 88 */ 89 90 91 static PyObject * 92 gl_varray(PyObject *self, PyObject *args) 93 { 94 PyObject *v, *w=NULL; 95 int i, n, width; 96 double vec[3]; 97 PyObject * (*getitem)(PyObject *, int); 98 99 if (!PyArg_GetObject(args, 1, 0, &v)) 100 return NULL; 101 102 if (PyList_Check(v)) { 103 n = PyList_Size(v); 104 getitem = PyList_GetItem; 105 } 106 else if (PyTuple_Check(v)) { 107 n = PyTuple_Size(v); 108 getitem = PyTuple_GetItem; 109 } 110 else { 111 PyErr_BadArgument(); 112 return NULL; 113 } 114 115 if (n == 0) { 116 Py_INCREF(Py_None); 117 return Py_None; 118 } 119 if (n > 0) 120 w = (*getitem)(v, 0); 121 122 width = 0; 123 if (w == NULL) { 124 } 125 else if (PyList_Check(w)) { 126 width = PyList_Size(w); 127 } 128 else if (PyTuple_Check(w)) { 129 width = PyTuple_Size(w); 130 } 131 132 switch (width) { 133 case 2: 134 vec[2] = 0.0; 135 /* Fall through */ 136 case 3: 137 break; 138 default: 139 PyErr_BadArgument(); 140 return NULL; 141 } 142 143 for (i = 0; i < n; i++) { 144 w = (*getitem)(v, i); 145 if (!PyArg_GetDoubleArray(w, 1, 0, width, vec)) 146 return NULL; 147 v3d(vec); 148 } 149 150 Py_INCREF(Py_None); 151 return Py_None; 152 } 153 154 /* 155 vnarray, nvarray -- an array of n3f and v3f calls. 156 The argument is an array (list or tuple) of pairs of points and normals. 157 Each pair is a tuple (NOT a list) of a point and a normal for that point. 158 Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z). 159 Three coordinates must be given. Float and int values may be mixed. 160 For each pair, n3f() is called for the normal, and then v3f() is called 161 for the vector. 162 163 vnarray and nvarray differ only in the order of the vector and normal in 164 the pair: vnarray expects (v, n) while nvarray expects (n, v). 165 */ 166 167 static PyObject *gen_nvarray(); /* Forward */ 168 169 170 static PyObject * 171 gl_nvarray(PyObject *self, PyObject *args) 172 { 173 return gen_nvarray(args, 0); 174 } 175 176 177 static PyObject * 178 gl_vnarray(PyObject *self, PyObject *args) 179 { 180 return gen_nvarray(args, 1); 181 } 182 183 /* Generic, internal version of {nv,nv}array: inorm indicates the 184 argument order, 0: normal first, 1: vector first. */ 185 186 static PyObject * 187 gen_nvarray(PyObject *args, int inorm) 188 { 189 PyObject *v, *w, *wnorm, *wvec; 190 int i, n; 191 float norm[3], vec[3]; 192 PyObject * (*getitem)(PyObject *, int); 193 194 if (!PyArg_GetObject(args, 1, 0, &v)) 195 return NULL; 196 197 if (PyList_Check(v)) { 198 n = PyList_Size(v); 199 getitem = PyList_GetItem; 200 } 201 else if (PyTuple_Check(v)) { 202 n = PyTuple_Size(v); 203 getitem = PyTuple_GetItem; 204 } 205 else { 206 PyErr_BadArgument(); 207 return NULL; 208 } 209 210 for (i = 0; i < n; i++) { 211 w = (*getitem)(v, i); 212 if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) { 213 PyErr_BadArgument(); 214 return NULL; 215 } 216 wnorm = PyTuple_GetItem(w, inorm); 217 wvec = PyTuple_GetItem(w, 1 - inorm); 218 if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) || 219 !PyArg_GetFloatArray(wvec, 1, 0, 3, vec)) 220 return NULL; 221 n3f(norm); 222 v3f(vec); 223 } 224 225 Py_INCREF(Py_None); 226 return Py_None; 227 } 228 229 /* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type). 230 The dimensions of ctl[] are computed as follows: 231 [len(s_knots) - s_order], [len(t_knots) - t_order] 232 */ 233 234 235 static PyObject * 236 gl_nurbssurface(PyObject *self, PyObject *args) 237 { 238 long arg1 ; 239 double * arg2 ; 240 long arg3 ; 241 double * arg4 ; 242 double *arg5 ; 243 long arg6 ; 244 long arg7 ; 245 long arg8 ; 246 long ncoords; 247 long s_byte_stride, t_byte_stride; 248 long s_nctl, t_nctl; 249 long s, t; 250 PyObject *v, *w, *pt; 251 double *pnext; 252 if (!PyArg_GetLongArraySize(args, 6, 0, &arg1)) 253 return NULL; 254 if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) { 255 return PyErr_NoMemory(); 256 } 257 if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2)) 258 return NULL; 259 if (!PyArg_GetLongArraySize(args, 6, 1, &arg3)) 260 return NULL; 261 if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) { 262 return PyErr_NoMemory(); 263 } 264 if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4)) 265 return NULL; 266 if (!PyArg_GetLong(args, 6, 3, &arg6)) 267 return NULL; 268 if (!PyArg_GetLong(args, 6, 4, &arg7)) 269 return NULL; 270 if (!PyArg_GetLong(args, 6, 5, &arg8)) 271 return NULL; 272 if (arg8 == N_XYZ) 273 ncoords = 3; 274 else if (arg8 == N_XYZW) 275 ncoords = 4; 276 else { 277 PyErr_BadArgument(); 278 return NULL; 279 } 280 s_nctl = arg1 - arg6; 281 t_nctl = arg3 - arg7; 282 if (!PyArg_GetObject(args, 6, 2, &v)) 283 return NULL; 284 if (!PyList_Check(v) || PyList_Size(v) != s_nctl) { 285 PyErr_BadArgument(); 286 return NULL; 287 } 288 if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) { 289 return PyErr_NoMemory(); 290 } 291 pnext = arg5; 292 for (s = 0; s < s_nctl; s++) { 293 w = PyList_GetItem(v, s); 294 if (w == NULL || !PyList_Check(w) || 295 PyList_Size(w) != t_nctl) { 296 PyErr_BadArgument(); 297 return NULL; 298 } 299 for (t = 0; t < t_nctl; t++) { 300 pt = PyList_GetItem(w, t); 301 if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext)) 302 return NULL; 303 pnext += ncoords; 304 } 305 } 306 s_byte_stride = sizeof(double) * ncoords; 307 t_byte_stride = s_byte_stride * s_nctl; 308 nurbssurface( arg1 , arg2 , arg3 , arg4 , 309 s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 ); 310 PyMem_DEL(arg2); 311 PyMem_DEL(arg4); 312 PyMem_DEL(arg5); 313 Py_INCREF(Py_None); 314 return Py_None; 315 } 316 317 /* nurbscurve(knots, ctlpoints, order, type). 318 The length of ctlpoints is len(knots)-order. */ 319 320 321 static PyObject * 322 gl_nurbscurve(PyObject *self, PyObject *args) 323 { 324 long arg1 ; 325 double * arg2 ; 326 long arg3 ; 327 double * arg4 ; 328 long arg5 ; 329 long arg6 ; 330 int ncoords, npoints; 331 int i; 332 PyObject *v; 333 double *pnext; 334 if (!PyArg_GetLongArraySize(args, 4, 0, &arg1)) 335 return NULL; 336 if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) { 337 return PyErr_NoMemory(); 338 } 339 if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2)) 340 return NULL; 341 if (!PyArg_GetLong(args, 4, 2, &arg5)) 342 return NULL; 343 if (!PyArg_GetLong(args, 4, 3, &arg6)) 344 return NULL; 345 if (arg6 == N_ST) 346 ncoords = 2; 347 else if (arg6 == N_STW) 348 ncoords = 3; 349 else { 350 PyErr_BadArgument(); 351 return NULL; 352 } 353 npoints = arg1 - arg5; 354 if (!PyArg_GetObject(args, 4, 1, &v)) 355 return NULL; 356 if (!PyList_Check(v) || PyList_Size(v) != npoints) { 357 PyErr_BadArgument(); 358 return NULL; 359 } 360 if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) { 361 return PyErr_NoMemory(); 362 } 363 pnext = arg4; 364 for (i = 0; i < npoints; i++) { 365 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext)) 366 return NULL; 367 pnext += ncoords; 368 } 369 arg3 = (sizeof(double)) * ncoords; 370 nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 371 PyMem_DEL(arg2); 372 PyMem_DEL(arg4); 373 Py_INCREF(Py_None); 374 return Py_None; 375 } 376 377 /* pwlcurve(points, type). 378 Points is a list of points. Type must be N_ST. */ 379 380 381 static PyObject * 382 gl_pwlcurve(PyObject *self, PyObject *args) 383 { 384 PyObject *v; 385 long type; 386 double *data, *pnext; 387 long npoints, ncoords; 388 int i; 389 if (!PyArg_GetObject(args, 2, 0, &v)) 390 return NULL; 391 if (!PyArg_GetLong(args, 2, 1, &type)) 392 return NULL; 393 if (!PyList_Check(v)) { 394 PyErr_BadArgument(); 395 return NULL; 396 } 397 npoints = PyList_Size(v); 398 if (type == N_ST) 399 ncoords = 2; 400 else { 401 PyErr_BadArgument(); 402 return NULL; 403 } 404 if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) { 405 return PyErr_NoMemory(); 406 } 407 pnext = data; 408 for (i = 0; i < npoints; i++) { 409 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext)) 410 return NULL; 411 pnext += ncoords; 412 } 413 pwlcurve(npoints, data, sizeof(double)*ncoords, type); 414 PyMem_DEL(data); 415 Py_INCREF(Py_None); 416 return Py_None; 417 } 418 419 420 /* Picking and Selecting */ 421 422 static short *pickbuffer = NULL; 423 static long pickbuffersize; 424 425 static PyObject * 426 pick_select(PyObject *args, void (*func)()) 427 { 428 if (!PyArg_GetLong(args, 1, 0, &pickbuffersize)) 429 return NULL; 430 if (pickbuffer != NULL) { 431 PyErr_SetString(PyExc_RuntimeError, 432 "pick/gselect: already picking/selecting"); 433 return NULL; 434 } 435 if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) { 436 return PyErr_NoMemory(); 437 } 438 (*func)(pickbuffer, pickbuffersize); 439 Py_INCREF(Py_None); 440 return Py_None; 441 } 442 443 static PyObject * 444 endpick_select(long (*func)()) 445 { 446 PyObject *v, *w; 447 int i, nhits, n; 448 if (pickbuffer == NULL) { 449 PyErr_SetString(PyExc_RuntimeError, 450 "endpick/endselect: not in pick/select mode"); 451 return NULL; 452 } 453 nhits = (*func)(pickbuffer); 454 if (nhits < 0) { 455 nhits = -nhits; /* How to report buffer overflow otherwise? */ 456 } 457 /* Scan the buffer to see how many integers */ 458 n = 0; 459 for (; nhits > 0; nhits--) { 460 n += 1 + pickbuffer[n]; 461 } 462 v = PyList_New(n); 463 if (v == NULL) 464 return NULL; 465 /* XXX Could do it nicer and interpret the data structure here, 466 returning a list of lists. But this can be done in Python... */ 467 for (i = 0; i < n; i++) { 468 w = PyInt_FromLong((long)pickbuffer[i]); 469 if (w == NULL) { 470 Py_DECREF(v); 471 return NULL; 472 } 473 PyList_SetItem(v, i, w); 474 } 475 PyMem_DEL(pickbuffer); 476 pickbuffer = NULL; 477 return v; 478 } 479 480 extern void pick(), gselect(); 481 extern long endpick(), endselect(); 482 483 static PyObject *gl_pick(PyObject *self, PyObject *args) 484 { 485 return pick_select(args, pick); 486 } 487 488 static PyObject *gl_endpick(PyObject *self) 489 { 490 return endpick_select(endpick); 491 } 492 493 static PyObject *gl_gselect(PyObject *self, PyObject *args) 494 { 495 return pick_select(args, gselect); 496 } 497 498 static PyObject *gl_endselect(PyObject *self) 499 { 500 return endpick_select(endselect); 501 } 502 503 504 /* XXX The generator botches this one. Here's a quick hack to fix it. */ 505 506 /* XXX The generator botches this one. Here's a quick hack to fix it. */ 507 508 509 static PyObject * 510 gl_getmatrix(PyObject *self, PyObject *args) 511 { 512 Matrix arg1; 513 PyObject *v, *w; 514 int i, j; 515 getmatrix( arg1 ); 516 v = PyList_New(16); 517 if (v == NULL) { 518 return PyErr_NoMemory(); 519 } 520 for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) { 521 w = mknewfloatobject(arg1[i][j]); 522 if (w == NULL) { 523 Py_DECREF(v); 524 return NULL; 525 } 526 PyList_SetItem(v, i*4+j, w); 527 } 528 return v; 529 } 530 531 /* Here's an alternate version that returns a 4x4 matrix instead of 532 a vector. Unfortunately it is incompatible with loadmatrix and 533 multmatrix... */ 534 535 536 static PyObject * 537 gl_altgetmatrix(PyObject *self, PyObject *args) 538 { 539 Matrix arg1; 540 PyObject *v, *w; 541 int i, j; 542 getmatrix( arg1 ); 543 v = PyList_New(4); 544 if (v == NULL) { 545 return NULL; 546 } 547 for (i = 0; i < 4; i++) { 548 w = PyList_New(4); 549 if (w == NULL) { 550 Py_DECREF(v); 551 return NULL; 552 } 553 PyList_SetItem(v, i, w); 554 } 555 for (i = 0; i < 4; i++) { 556 for (j = 0; j < 4; j++) { 557 w = mknewfloatobject(arg1[i][j]); 558 if (w == NULL) { 559 Py_DECREF(v); 560 return NULL; 561 } 562 PyList_SetItem(PyList_GetItem(v, i), j, w); 563 } 564 } 565 return v; 566 } 567 568 569 static PyObject * 570 gl_lrectwrite(PyObject *self, PyObject *args) 571 { 572 short x1 ; 573 short y1 ; 574 short x2 ; 575 short y2 ; 576 string parray ; 577 PyObject *s; 578 #if 0 579 int pixcount; 580 #endif 581 if (!PyArg_GetShort(args, 5, 0, &x1)) 582 return NULL; 583 if (!PyArg_GetShort(args, 5, 1, &y1)) 584 return NULL; 585 if (!PyArg_GetShort(args, 5, 2, &x2)) 586 return NULL; 587 if (!PyArg_GetShort(args, 5, 3, &y2)) 588 return NULL; 589 if (!PyArg_GetString(args, 5, 4, &parray)) 590 return NULL; 591 if (!PyArg_GetObject(args, 5, 4, &s)) 592 return NULL; 593 #if 0 594 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */ 595 pixcount = (long)(x2+1-x1) * (long)(y2+1-y1); 596 if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) { 597 PyErr_SetString(PyExc_RuntimeError, 598 "string arg to lrectwrite has wrong size"); 599 return NULL; 600 } 601 #endif 602 lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray ); 603 Py_INCREF(Py_None); 604 return Py_None; 605 } 606 607 608 static PyObject * 609 gl_lrectread(PyObject *self, PyObject *args) 610 { 611 short x1 ; 612 short y1 ; 613 short x2 ; 614 short y2 ; 615 PyObject *parray; 616 int pixcount; 617 if (!PyArg_GetShort(args, 4, 0, &x1)) 618 return NULL; 619 if (!PyArg_GetShort(args, 4, 1, &y1)) 620 return NULL; 621 if (!PyArg_GetShort(args, 4, 2, &x2)) 622 return NULL; 623 if (!PyArg_GetShort(args, 4, 3, &y2)) 624 return NULL; 625 pixcount = (long)(x2+1-x1) * (long)(y2+1-y1); 626 parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long)); 627 if (parray == NULL) 628 return NULL; /* No memory */ 629 lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray)); 630 return parray; 631 } 632 633 634 static PyObject * 635 gl_readdisplay(PyObject *self, PyObject *args) 636 { 637 short x1, y1, x2, y2; 638 unsigned long *parray, hints; 639 long size, size_ret; 640 PyObject *rv; 641 642 if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) ) 643 return 0; 644 size = (long)(x2+1-x1) * (long)(y2+1-y1); 645 rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long)); 646 if ( rv == NULL ) 647 return NULL; 648 parray = (unsigned long *)PyString_AsString(rv); 649 size_ret = readdisplay(x1, y1, x2, y2, parray, hints); 650 if ( size_ret != size ) { 651 printf("gl_readdisplay: got %ld pixels, expected %ld\n", 652 size_ret, size); 653 PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length"); 654 return NULL; 655 } 656 return rv; 657 } 658 659 /* Desperately needed, here are tools to compress and decompress 660 the data manipulated by lrectread/lrectwrite. 661 662 gl.packrect(width, height, packfactor, bigdata) --> smalldata 663 makes 'bigdata' 4*(packfactor**2) times smaller by: 664 - turning it into B/W (a factor 4) 665 - replacing squares of size pacfactor by one 666 representative 667 668 gl.unpackrect(width, height, packfactor, smalldata) --> bigdata 669 is the inverse; the numeric arguments must be *the same*. 670 671 Both work best if width and height are multiples of packfactor 672 (in fact unpackrect will leave garbage bytes). 673 */ 674 675 676 static PyObject * 677 gl_packrect(PyObject *self, PyObject *args) 678 { 679 long width, height, packfactor; 680 char *s; 681 PyObject *unpacked, *packed; 682 int pixcount, packedcount, x, y, r, g, b; 683 unsigned long pixel; 684 unsigned char *p; 685 unsigned long *parray; 686 if (!PyArg_GetLong(args, 4, 0, &width)) 687 return NULL; 688 if (!PyArg_GetLong(args, 4, 1, &height)) 689 return NULL; 690 if (!PyArg_GetLong(args, 4, 2, &packfactor)) 691 return NULL; 692 if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */ 693 return NULL; 694 if (!PyArg_GetObject(args, 4, 3, &unpacked)) 695 return NULL; 696 if (width <= 0 || height <= 0 || packfactor <= 0) { 697 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0"); 698 return NULL; 699 } 700 pixcount = width*height; 701 packedcount = ((width+packfactor-1)/packfactor) * 702 ((height+packfactor-1)/packfactor); 703 if (PyString_Size(unpacked) != pixcount*sizeof(long)) { 704 PyErr_SetString(PyExc_RuntimeError, 705 "string arg to packrect has wrong size"); 706 return NULL; 707 } 708 packed = PyString_FromStringAndSize((char *)NULL, packedcount); 709 if (packed == NULL) 710 return NULL; 711 parray = (unsigned long *) PyString_AsString(unpacked); 712 p = (unsigned char *) PyString_AsString(packed); 713 for (y = 0; y < height; y += packfactor, parray += packfactor*width) { 714 for (x = 0; x < width; x += packfactor) { 715 pixel = parray[x]; 716 r = pixel & 0xff; 717 g = (pixel >> 8) & 0xff; 718 b = (pixel >> 16) & 0xff; 719 *p++ = (30*r+59*g+11*b) / 100; 720 } 721 } 722 return packed; 723 } 724 725 726 static unsigned long unpacktab[256]; 727 static int unpacktab_inited = 0; 728 729 static PyObject * 730 gl_unpackrect(PyObject *self, PyObject *args) 731 { 732 long width, height, packfactor; 733 char *s; 734 PyObject *unpacked, *packed; 735 int pixcount, packedcount; 736 register unsigned char *p; 737 register unsigned long *parray; 738 if (!unpacktab_inited) { 739 register int white; 740 for (white = 256; --white >= 0; ) 741 unpacktab[white] = white * 0x010101L; 742 unpacktab_inited++; 743 } 744 if (!PyArg_GetLong(args, 4, 0, &width)) 745 return NULL; 746 if (!PyArg_GetLong(args, 4, 1, &height)) 747 return NULL; 748 if (!PyArg_GetLong(args, 4, 2, &packfactor)) 749 return NULL; 750 if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */ 751 return NULL; 752 if (!PyArg_GetObject(args, 4, 3, &packed)) 753 return NULL; 754 if (width <= 0 || height <= 0 || packfactor <= 0) { 755 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0"); 756 return NULL; 757 } 758 pixcount = width*height; 759 packedcount = ((width+packfactor-1)/packfactor) * 760 ((height+packfactor-1)/packfactor); 761 if (PyString_Size(packed) != packedcount) { 762 PyErr_SetString(PyExc_RuntimeError, 763 "string arg to unpackrect has wrong size"); 764 return NULL; 765 } 766 unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long)); 767 if (unpacked == NULL) 768 return NULL; 769 parray = (unsigned long *) PyString_AsString(unpacked); 770 p = (unsigned char *) PyString_AsString(packed); 771 if (packfactor == 1 && width*height > 0) { 772 /* Just expand bytes to longs */ 773 register int x = width * height; 774 do { 775 *parray++ = unpacktab[*p++]; 776 } while (--x >= 0); 777 } 778 else { 779 register int y; 780 for (y = 0; y < height-packfactor+1; 781 y += packfactor, parray += packfactor*width) { 782 register int x; 783 for (x = 0; x < width-packfactor+1; x += packfactor) { 784 register unsigned long pixel = unpacktab[*p++]; 785 register int i; 786 for (i = packfactor*width; (i-=width) >= 0;) { 787 register int j; 788 for (j = packfactor; --j >= 0; ) 789 parray[i+x+j] = pixel; 790 } 791 } 792 } 793 } 794 return unpacked; 795 } 796 797 static PyObject * 798 gl_gversion(PyObject *self, PyObject *args) 799 { 800 char buf[20]; 801 gversion(buf); 802 return PyString_FromString(buf); 803 } 804 805 806 /* void clear - Manual because of clash with termcap */ 807 static PyObject * 808 gl_clear(PyObject *self, PyObject *args) 809 { 810 __GLclear( ); 811 Py_INCREF(Py_None); 812 return Py_None; 813 } 814 815 /* End of manually written stubs */ 816 817 818 /* long getshade */ 819 820 static PyObject * 821 gl_getshade(PyObject *self, PyObject *args) 822 { 823 long retval; 824 retval = getshade( ); 825 return mknewlongobject(retval); 826 } 827 828 /* void devport short s long s */ 829 830 static PyObject * 831 gl_devport(PyObject *self, PyObject *args) 832 { 833 short arg1 ; 834 long arg2 ; 835 if (!getishortarg(args, 2, 0, &arg1)) 836 return NULL; 837 if (!getilongarg(args, 2, 1, &arg2)) 838 return NULL; 839 devport( arg1 , arg2 ); 840 Py_INCREF(Py_None); 841 return Py_None; 842 } 843 844 /* void rdr2i long s long s */ 845 846 static PyObject * 847 gl_rdr2i(PyObject *self, PyObject *args) 848 { 849 long arg1 ; 850 long arg2 ; 851 if (!getilongarg(args, 2, 0, &arg1)) 852 return NULL; 853 if (!getilongarg(args, 2, 1, &arg2)) 854 return NULL; 855 rdr2i( arg1 , arg2 ); 856 Py_INCREF(Py_None); 857 return Py_None; 858 } 859 860 /* void rectfs short s short s short s short s */ 861 862 static PyObject * 863 gl_rectfs(PyObject *self, PyObject *args) 864 { 865 short arg1 ; 866 short arg2 ; 867 short arg3 ; 868 short arg4 ; 869 if (!getishortarg(args, 4, 0, &arg1)) 870 return NULL; 871 if (!getishortarg(args, 4, 1, &arg2)) 872 return NULL; 873 if (!getishortarg(args, 4, 2, &arg3)) 874 return NULL; 875 if (!getishortarg(args, 4, 3, &arg4)) 876 return NULL; 877 rectfs( arg1 , arg2 , arg3 , arg4 ); 878 Py_INCREF(Py_None); 879 return Py_None; 880 } 881 882 /* void rects short s short s short s short s */ 883 884 static PyObject * 885 gl_rects(PyObject *self, PyObject *args) 886 { 887 short arg1 ; 888 short arg2 ; 889 short arg3 ; 890 short arg4 ; 891 if (!getishortarg(args, 4, 0, &arg1)) 892 return NULL; 893 if (!getishortarg(args, 4, 1, &arg2)) 894 return NULL; 895 if (!getishortarg(args, 4, 2, &arg3)) 896 return NULL; 897 if (!getishortarg(args, 4, 3, &arg4)) 898 return NULL; 899 rects( arg1 , arg2 , arg3 , arg4 ); 900 Py_INCREF(Py_None); 901 return Py_None; 902 } 903 904 /* void rmv2i long s long s */ 905 906 static PyObject * 907 gl_rmv2i(PyObject *self, PyObject *args) 908 { 909 long arg1 ; 910 long arg2 ; 911 if (!getilongarg(args, 2, 0, &arg1)) 912 return NULL; 913 if (!getilongarg(args, 2, 1, &arg2)) 914 return NULL; 915 rmv2i( arg1 , arg2 ); 916 Py_INCREF(Py_None); 917 return Py_None; 918 } 919 920 /* void noport */ 921 922 static PyObject * 923 gl_noport(PyObject *self, PyObject *args) 924 { 925 noport( ); 926 Py_INCREF(Py_None); 927 return Py_None; 928 } 929 930 /* void popviewport */ 931 932 static PyObject * 933 gl_popviewport(PyObject *self, PyObject *args) 934 { 935 popviewport( ); 936 Py_INCREF(Py_None); 937 return Py_None; 938 } 939 940 /* void clearhitcode */ 941 942 static PyObject * 943 gl_clearhitcode(PyObject *self, PyObject *args) 944 { 945 clearhitcode( ); 946 Py_INCREF(Py_None); 947 return Py_None; 948 } 949 950 /* void closeobj */ 951 952 static PyObject * 953 gl_closeobj(PyObject *self, PyObject *args) 954 { 955 closeobj( ); 956 Py_INCREF(Py_None); 957 return Py_None; 958 } 959 960 /* void cursoff */ 961 962 static PyObject * 963 gl_cursoff(PyObject *self, PyObject *args) 964 { 965 cursoff( ); 966 Py_INCREF(Py_None); 967 return Py_None; 968 } 969 970 /* void curson */ 971 972 static PyObject * 973 gl_curson(PyObject *self, PyObject *args) 974 { 975 curson( ); 976 Py_INCREF(Py_None); 977 return Py_None; 978 } 979 980 /* void doublebuffer */ 981 982 static PyObject * 983 gl_doublebuffer(PyObject *self, PyObject *args) 984 { 985 doublebuffer( ); 986 Py_INCREF(Py_None); 987 return Py_None; 988 } 989 990 /* void finish */ 991 992 static PyObject * 993 gl_finish(PyObject *self, PyObject *args) 994 { 995 finish( ); 996 Py_INCREF(Py_None); 997 return Py_None; 998 } 999 1000 /* void gconfig */ 1001 1002 static PyObject * 1003 gl_gconfig(PyObject *self, PyObject *args) 1004 { 1005 gconfig( ); 1006 Py_INCREF(Py_None); 1007 return Py_None; 1008 } 1009 1010 /* void ginit */ 1011 1012 static PyObject * 1013 gl_ginit(PyObject *self, PyObject *args) 1014 { 1015 ginit( ); 1016 Py_INCREF(Py_None); 1017 return Py_None; 1018 } 1019 1020 /* void greset */ 1021 1022 static PyObject * 1023 gl_greset(PyObject *self, PyObject *args) 1024 { 1025 greset( ); 1026 Py_INCREF(Py_None); 1027 return Py_None; 1028 } 1029 1030 /* void multimap */ 1031 1032 static PyObject * 1033 gl_multimap(PyObject *self, PyObject *args) 1034 { 1035 multimap( ); 1036 Py_INCREF(Py_None); 1037 return Py_None; 1038 } 1039 1040 /* void onemap */ 1041 1042 static PyObject * 1043 gl_onemap(PyObject *self, PyObject *args) 1044 { 1045 onemap( ); 1046 Py_INCREF(Py_None); 1047 return Py_None; 1048 } 1049 1050 /* void popattributes */ 1051 1052 static PyObject * 1053 gl_popattributes(PyObject *self, PyObject *args) 1054 { 1055 popattributes( ); 1056 Py_INCREF(Py_None); 1057 return Py_None; 1058 } 1059 1060 /* void popmatrix */ 1061 1062 static PyObject * 1063 gl_popmatrix(PyObject *self, PyObject *args) 1064 { 1065 popmatrix( ); 1066 Py_INCREF(Py_None); 1067 return Py_None; 1068 } 1069 1070 /* void pushattributes */ 1071 1072 static PyObject * 1073 gl_pushattributes(PyObject *self, PyObject *args) 1074 { 1075 pushattributes( ); 1076 Py_INCREF(Py_None); 1077 return Py_None; 1078 } 1079 1080 /* void pushmatrix */ 1081 1082 static PyObject * 1083 gl_pushmatrix(PyObject *self, PyObject *args) 1084 { 1085 pushmatrix( ); 1086 Py_INCREF(Py_None); 1087 return Py_None; 1088 } 1089 1090 /* void pushviewport */ 1091 1092 static PyObject * 1093 gl_pushviewport(PyObject *self, PyObject *args) 1094 { 1095 pushviewport( ); 1096 Py_INCREF(Py_None); 1097 return Py_None; 1098 } 1099 1100 /* void qreset */ 1101 1102 static PyObject * 1103 gl_qreset(PyObject *self, PyObject *args) 1104 { 1105 qreset( ); 1106 Py_INCREF(Py_None); 1107 return Py_None; 1108 } 1109 1110 /* void RGBmode */ 1111 1112 static PyObject * 1113 gl_RGBmode(PyObject *self, PyObject *args) 1114 { 1115 RGBmode( ); 1116 Py_INCREF(Py_None); 1117 return Py_None; 1118 } 1119 1120 /* void singlebuffer */ 1121 1122 static PyObject * 1123 gl_singlebuffer(PyObject *self, PyObject *args) 1124 { 1125 singlebuffer( ); 1126 Py_INCREF(Py_None); 1127 return Py_None; 1128 } 1129 1130 /* void swapbuffers */ 1131 1132 static PyObject * 1133 gl_swapbuffers(PyObject *self, PyObject *args) 1134 { 1135 swapbuffers( ); 1136 Py_INCREF(Py_None); 1137 return Py_None; 1138 } 1139 1140 /* void gsync */ 1141 1142 static PyObject * 1143 gl_gsync(PyObject *self, PyObject *args) 1144 { 1145 gsync( ); 1146 Py_INCREF(Py_None); 1147 return Py_None; 1148 } 1149 1150 /* void gflush */ 1151 1152 static PyObject * 1153 gl_gflush(PyObject *self, PyObject *args) 1154 { 1155 gflush( ); 1156 Py_INCREF(Py_None); 1157 return Py_None; 1158 } 1159 1160 /* void tpon */ 1161 1162 static PyObject * 1163 gl_tpon(PyObject *self, PyObject *args) 1164 { 1165 tpon( ); 1166 Py_INCREF(Py_None); 1167 return Py_None; 1168 } 1169 1170 /* void tpoff */ 1171 1172 static PyObject * 1173 gl_tpoff(PyObject *self, PyObject *args) 1174 { 1175 tpoff( ); 1176 Py_INCREF(Py_None); 1177 return Py_None; 1178 } 1179 1180 /* void clkon */ 1181 1182 static PyObject * 1183 gl_clkon(PyObject *self, PyObject *args) 1184 { 1185 clkon( ); 1186 Py_INCREF(Py_None); 1187 return Py_None; 1188 } 1189 1190 /* void clkoff */ 1191 1192 static PyObject * 1193 gl_clkoff(PyObject *self, PyObject *args) 1194 { 1195 clkoff( ); 1196 Py_INCREF(Py_None); 1197 return Py_None; 1198 } 1199 1200 /* void ringbell */ 1201 1202 static PyObject * 1203 gl_ringbell(PyObject *self, PyObject *args) 1204 { 1205 ringbell( ); 1206 Py_INCREF(Py_None); 1207 return Py_None; 1208 } 1209 1210 /* void gbegin */ 1211 1212 static PyObject * 1213 gl_gbegin(PyObject *self, PyObject *args) 1214 { 1215 gbegin( ); 1216 Py_INCREF(Py_None); 1217 return Py_None; 1218 } 1219 1220 /* void textinit */ 1221 1222 static PyObject * 1223 gl_textinit(PyObject *self, PyObject *args) 1224 { 1225 textinit( ); 1226 Py_INCREF(Py_None); 1227 return Py_None; 1228 } 1229 1230 /* void initnames */ 1231 1232 static PyObject * 1233 gl_initnames(PyObject *self, PyObject *args) 1234 { 1235 initnames( ); 1236 Py_INCREF(Py_None); 1237 return Py_None; 1238 } 1239 1240 /* void pclos */ 1241 1242 static PyObject * 1243 gl_pclos(PyObject *self, PyObject *args) 1244 { 1245 pclos( ); 1246 Py_INCREF(Py_None); 1247 return Py_None; 1248 } 1249 1250 /* void popname */ 1251 1252 static PyObject * 1253 gl_popname(PyObject *self, PyObject *args) 1254 { 1255 popname( ); 1256 Py_INCREF(Py_None); 1257 return Py_None; 1258 } 1259 1260 /* void spclos */ 1261 1262 static PyObject * 1263 gl_spclos(PyObject *self, PyObject *args) 1264 { 1265 spclos( ); 1266 Py_INCREF(Py_None); 1267 return Py_None; 1268 } 1269 1270 /* void zclear */ 1271 1272 static PyObject * 1273 gl_zclear(PyObject *self, PyObject *args) 1274 { 1275 zclear( ); 1276 Py_INCREF(Py_None); 1277 return Py_None; 1278 } 1279 1280 /* void screenspace */ 1281 1282 static PyObject * 1283 gl_screenspace(PyObject *self, PyObject *args) 1284 { 1285 screenspace( ); 1286 Py_INCREF(Py_None); 1287 return Py_None; 1288 } 1289 1290 /* void reshapeviewport */ 1291 1292 static PyObject * 1293 gl_reshapeviewport(PyObject *self, PyObject *args) 1294 { 1295 reshapeviewport( ); 1296 Py_INCREF(Py_None); 1297 return Py_None; 1298 } 1299 1300 /* void winpush */ 1301 1302 static PyObject * 1303 gl_winpush(PyObject *self, PyObject *args) 1304 { 1305 winpush( ); 1306 Py_INCREF(Py_None); 1307 return Py_None; 1308 } 1309 1310 /* void winpop */ 1311 1312 static PyObject * 1313 gl_winpop(PyObject *self, PyObject *args) 1314 { 1315 winpop( ); 1316 Py_INCREF(Py_None); 1317 return Py_None; 1318 } 1319 1320 /* void foreground */ 1321 1322 static PyObject * 1323 gl_foreground(PyObject *self, PyObject *args) 1324 { 1325 foreground( ); 1326 Py_INCREF(Py_None); 1327 return Py_None; 1328 } 1329 1330 /* void endfullscrn */ 1331 1332 static PyObject * 1333 gl_endfullscrn(PyObject *self, PyObject *args) 1334 { 1335 endfullscrn( ); 1336 Py_INCREF(Py_None); 1337 return Py_None; 1338 } 1339 1340 /* void endpupmode */ 1341 1342 static PyObject * 1343 gl_endpupmode(PyObject *self, PyObject *args) 1344 { 1345 endpupmode( ); 1346 Py_INCREF(Py_None); 1347 return Py_None; 1348 } 1349 1350 /* void fullscrn */ 1351 1352 static PyObject * 1353 gl_fullscrn(PyObject *self, PyObject *args) 1354 { 1355 fullscrn( ); 1356 Py_INCREF(Py_None); 1357 return Py_None; 1358 } 1359 1360 /* void pupmode */ 1361 1362 static PyObject * 1363 gl_pupmode(PyObject *self, PyObject *args) 1364 { 1365 pupmode( ); 1366 Py_INCREF(Py_None); 1367 return Py_None; 1368 } 1369 1370 /* void winconstraints */ 1371 1372 static PyObject * 1373 gl_winconstraints(PyObject *self, PyObject *args) 1374 { 1375 winconstraints( ); 1376 Py_INCREF(Py_None); 1377 return Py_None; 1378 } 1379 1380 /* void pagecolor short s */ 1381 1382 static PyObject * 1383 gl_pagecolor(PyObject *self, PyObject *args) 1384 { 1385 short arg1 ; 1386 if (!getishortarg(args, 1, 0, &arg1)) 1387 return NULL; 1388 pagecolor( arg1 ); 1389 Py_INCREF(Py_None); 1390 return Py_None; 1391 } 1392 1393 /* void textcolor short s */ 1394 1395 static PyObject * 1396 gl_textcolor(PyObject *self, PyObject *args) 1397 { 1398 short arg1 ; 1399 if (!getishortarg(args, 1, 0, &arg1)) 1400 return NULL; 1401 textcolor( arg1 ); 1402 Py_INCREF(Py_None); 1403 return Py_None; 1404 } 1405 1406 /* void color short s */ 1407 1408 static PyObject * 1409 gl_color(PyObject *self, PyObject *args) 1410 { 1411 short arg1 ; 1412 if (!getishortarg(args, 1, 0, &arg1)) 1413 return NULL; 1414 color( arg1 ); 1415 Py_INCREF(Py_None); 1416 return Py_None; 1417 } 1418 1419 /* void curveit short s */ 1420 1421 static PyObject * 1422 gl_curveit(PyObject *self, PyObject *args) 1423 { 1424 short arg1 ; 1425 if (!getishortarg(args, 1, 0, &arg1)) 1426 return NULL; 1427 curveit( arg1 ); 1428 Py_INCREF(Py_None); 1429 return Py_None; 1430 } 1431 1432 /* void font short s */ 1433 1434 static PyObject * 1435 gl_font(PyObject *self, PyObject *args) 1436 { 1437 short arg1 ; 1438 if (!getishortarg(args, 1, 0, &arg1)) 1439 return NULL; 1440 font( arg1 ); 1441 Py_INCREF(Py_None); 1442 return Py_None; 1443 } 1444 1445 /* void linewidth short s */ 1446 1447 static PyObject * 1448 gl_linewidth(PyObject *self, PyObject *args) 1449 { 1450 short arg1 ; 1451 if (!getishortarg(args, 1, 0, &arg1)) 1452 return NULL; 1453 linewidth( arg1 ); 1454 Py_INCREF(Py_None); 1455 return Py_None; 1456 } 1457 1458 /* void setlinestyle short s */ 1459 1460 static PyObject * 1461 gl_setlinestyle(PyObject *self, PyObject *args) 1462 { 1463 short arg1 ; 1464 if (!getishortarg(args, 1, 0, &arg1)) 1465 return NULL; 1466 setlinestyle( arg1 ); 1467 Py_INCREF(Py_None); 1468 return Py_None; 1469 } 1470 1471 /* void setmap short s */ 1472 1473 static PyObject * 1474 gl_setmap(PyObject *self, PyObject *args) 1475 { 1476 short arg1 ; 1477 if (!getishortarg(args, 1, 0, &arg1)) 1478 return NULL; 1479 setmap( arg1 ); 1480 Py_INCREF(Py_None); 1481 return Py_None; 1482 } 1483 1484 /* void swapinterval short s */ 1485 1486 static PyObject * 1487 gl_swapinterval(PyObject *self, PyObject *args) 1488 { 1489 short arg1 ; 1490 if (!getishortarg(args, 1, 0, &arg1)) 1491 return NULL; 1492 swapinterval( arg1 ); 1493 Py_INCREF(Py_None); 1494 return Py_None; 1495 } 1496 1497 /* void writemask short s */ 1498 1499 static PyObject * 1500 gl_writemask(PyObject *self, PyObject *args) 1501 { 1502 short arg1 ; 1503 if (!getishortarg(args, 1, 0, &arg1)) 1504 return NULL; 1505 writemask( arg1 ); 1506 Py_INCREF(Py_None); 1507 return Py_None; 1508 } 1509 1510 /* void textwritemask short s */ 1511 1512 static PyObject * 1513 gl_textwritemask(PyObject *self, PyObject *args) 1514 { 1515 short arg1 ; 1516 if (!getishortarg(args, 1, 0, &arg1)) 1517 return NULL; 1518 textwritemask( arg1 ); 1519 Py_INCREF(Py_None); 1520 return Py_None; 1521 } 1522 1523 /* void qdevice short s */ 1524 1525 static PyObject * 1526 gl_qdevice(PyObject *self, PyObject *args) 1527 { 1528 short arg1 ; 1529 if (!getishortarg(args, 1, 0, &arg1)) 1530 return NULL; 1531 qdevice( arg1 ); 1532 Py_INCREF(Py_None); 1533 return Py_None; 1534 } 1535 1536 /* void unqdevice short s */ 1537 1538 static PyObject * 1539 gl_unqdevice(PyObject *self, PyObject *args) 1540 { 1541 short arg1 ; 1542 if (!getishortarg(args, 1, 0, &arg1)) 1543 return NULL; 1544 unqdevice( arg1 ); 1545 Py_INCREF(Py_None); 1546 return Py_None; 1547 } 1548 1549 /* void curvebasis short s */ 1550 1551 static PyObject * 1552 gl_curvebasis(PyObject *self, PyObject *args) 1553 { 1554 short arg1 ; 1555 if (!getishortarg(args, 1, 0, &arg1)) 1556 return NULL; 1557 curvebasis( arg1 ); 1558 Py_INCREF(Py_None); 1559 return Py_None; 1560 } 1561 1562 /* void curveprecision short s */ 1563 1564 static PyObject * 1565 gl_curveprecision(PyObject *self, PyObject *args) 1566 { 1567 short arg1 ; 1568 if (!getishortarg(args, 1, 0, &arg1)) 1569 return NULL; 1570 curveprecision( arg1 ); 1571 Py_INCREF(Py_None); 1572 return Py_None; 1573 } 1574 1575 /* void loadname short s */ 1576 1577 static PyObject * 1578 gl_loadname(PyObject *self, PyObject *args) 1579 { 1580 short arg1 ; 1581 if (!getishortarg(args, 1, 0, &arg1)) 1582 return NULL; 1583 loadname( arg1 ); 1584 Py_INCREF(Py_None); 1585 return Py_None; 1586 } 1587 1588 /* void passthrough short s */ 1589 1590 static PyObject * 1591 gl_passthrough(PyObject *self, PyObject *args) 1592 { 1593 short arg1 ; 1594 if (!getishortarg(args, 1, 0, &arg1)) 1595 return NULL; 1596 passthrough( arg1 ); 1597 Py_INCREF(Py_None); 1598 return Py_None; 1599 } 1600 1601 /* void pushname short s */ 1602 1603 static PyObject * 1604 gl_pushname(PyObject *self, PyObject *args) 1605 { 1606 short arg1 ; 1607 if (!getishortarg(args, 1, 0, &arg1)) 1608 return NULL; 1609 pushname( arg1 ); 1610 Py_INCREF(Py_None); 1611 return Py_None; 1612 } 1613 1614 /* void setmonitor short s */ 1615 1616 static PyObject * 1617 gl_setmonitor(PyObject *self, PyObject *args) 1618 { 1619 short arg1 ; 1620 if (!getishortarg(args, 1, 0, &arg1)) 1621 return NULL; 1622 setmonitor( arg1 ); 1623 Py_INCREF(Py_None); 1624 return Py_None; 1625 } 1626 1627 /* void setshade short s */ 1628 1629 static PyObject * 1630 gl_setshade(PyObject *self, PyObject *args) 1631 { 1632 short arg1 ; 1633 if (!getishortarg(args, 1, 0, &arg1)) 1634 return NULL; 1635 setshade( arg1 ); 1636 Py_INCREF(Py_None); 1637 return Py_None; 1638 } 1639 1640 /* void setpattern short s */ 1641 1642 static PyObject * 1643 gl_setpattern(PyObject *self, PyObject *args) 1644 { 1645 short arg1 ; 1646 if (!getishortarg(args, 1, 0, &arg1)) 1647 return NULL; 1648 setpattern( arg1 ); 1649 Py_INCREF(Py_None); 1650 return Py_None; 1651 } 1652 1653 /* void pagewritemask short s */ 1654 1655 static PyObject * 1656 gl_pagewritemask(PyObject *self, PyObject *args) 1657 { 1658 short arg1 ; 1659 if (!getishortarg(args, 1, 0, &arg1)) 1660 return NULL; 1661 pagewritemask( arg1 ); 1662 Py_INCREF(Py_None); 1663 return Py_None; 1664 } 1665 1666 /* void callobj long s */ 1667 1668 static PyObject * 1669 gl_callobj(PyObject *self, PyObject *args) 1670 { 1671 long arg1 ; 1672 if (!getilongarg(args, 1, 0, &arg1)) 1673 return NULL; 1674 callobj( arg1 ); 1675 Py_INCREF(Py_None); 1676 return Py_None; 1677 } 1678 1679 /* void delobj long s */ 1680 1681 static PyObject * 1682 gl_delobj(PyObject *self, PyObject *args) 1683 { 1684 long arg1 ; 1685 if (!getilongarg(args, 1, 0, &arg1)) 1686 return NULL; 1687 delobj( arg1 ); 1688 Py_INCREF(Py_None); 1689 return Py_None; 1690 } 1691 1692 /* void editobj long s */ 1693 1694 static PyObject * 1695 gl_editobj(PyObject *self, PyObject *args) 1696 { 1697 long arg1 ; 1698 if (!getilongarg(args, 1, 0, &arg1)) 1699 return NULL; 1700 editobj( arg1 ); 1701 Py_INCREF(Py_None); 1702 return Py_None; 1703 } 1704 1705 /* void makeobj long s */ 1706 1707 static PyObject * 1708 gl_makeobj(PyObject *self, PyObject *args) 1709 { 1710 long arg1 ; 1711 if (!getilongarg(args, 1, 0, &arg1)) 1712 return NULL; 1713 makeobj( arg1 ); 1714 Py_INCREF(Py_None); 1715 return Py_None; 1716 } 1717 1718 /* void maketag long s */ 1719 1720 static PyObject * 1721 gl_maketag(PyObject *self, PyObject *args) 1722 { 1723 long arg1 ; 1724 if (!getilongarg(args, 1, 0, &arg1)) 1725 return NULL; 1726 maketag( arg1 ); 1727 Py_INCREF(Py_None); 1728 return Py_None; 1729 } 1730 1731 /* void chunksize long s */ 1732 1733 static PyObject * 1734 gl_chunksize(PyObject *self, PyObject *args) 1735 { 1736 long arg1 ; 1737 if (!getilongarg(args, 1, 0, &arg1)) 1738 return NULL; 1739 chunksize( arg1 ); 1740 Py_INCREF(Py_None); 1741 return Py_None; 1742 } 1743 1744 /* void compactify long s */ 1745 1746 static PyObject * 1747 gl_compactify(PyObject *self, PyObject *args) 1748 { 1749 long arg1 ; 1750 if (!getilongarg(args, 1, 0, &arg1)) 1751 return NULL; 1752 compactify( arg1 ); 1753 Py_INCREF(Py_None); 1754 return Py_None; 1755 } 1756 1757 /* void deltag long s */ 1758 1759 static PyObject * 1760 gl_deltag(PyObject *self, PyObject *args) 1761 { 1762 long arg1 ; 1763 if (!getilongarg(args, 1, 0, &arg1)) 1764 return NULL; 1765 deltag( arg1 ); 1766 Py_INCREF(Py_None); 1767 return Py_None; 1768 } 1769 1770 /* void lsrepeat long s */ 1771 1772 static PyObject * 1773 gl_lsrepeat(PyObject *self, PyObject *args) 1774 { 1775 long arg1 ; 1776 if (!getilongarg(args, 1, 0, &arg1)) 1777 return NULL; 1778 lsrepeat( arg1 ); 1779 Py_INCREF(Py_None); 1780 return Py_None; 1781 } 1782 1783 /* void objinsert long s */ 1784 1785 static PyObject * 1786 gl_objinsert(PyObject *self, PyObject *args) 1787 { 1788 long arg1 ; 1789 if (!getilongarg(args, 1, 0, &arg1)) 1790 return NULL; 1791 objinsert( arg1 ); 1792 Py_INCREF(Py_None); 1793 return Py_None; 1794 } 1795 1796 /* void objreplace long s */ 1797 1798 static PyObject * 1799 gl_objreplace(PyObject *self, PyObject *args) 1800 { 1801 long arg1 ; 1802 if (!getilongarg(args, 1, 0, &arg1)) 1803 return NULL; 1804 objreplace( arg1 ); 1805 Py_INCREF(Py_None); 1806 return Py_None; 1807 } 1808 1809 /* void winclose long s */ 1810 1811 static PyObject * 1812 gl_winclose(PyObject *self, PyObject *args) 1813 { 1814 long arg1 ; 1815 if (!getilongarg(args, 1, 0, &arg1)) 1816 return NULL; 1817 winclose( arg1 ); 1818 Py_INCREF(Py_None); 1819 return Py_None; 1820 } 1821 1822 /* void blanktime long s */ 1823 1824 static PyObject * 1825 gl_blanktime(PyObject *self, PyObject *args) 1826 { 1827 long arg1 ; 1828 if (!getilongarg(args, 1, 0, &arg1)) 1829 return NULL; 1830 blanktime( arg1 ); 1831 Py_INCREF(Py_None); 1832 return Py_None; 1833 } 1834 1835 /* void freepup long s */ 1836 1837 static PyObject * 1838 gl_freepup(PyObject *self, PyObject *args) 1839 { 1840 long arg1 ; 1841 if (!getilongarg(args, 1, 0, &arg1)) 1842 return NULL; 1843 freepup( arg1 ); 1844 Py_INCREF(Py_None); 1845 return Py_None; 1846 } 1847 1848 /* void backbuffer long s */ 1849 1850 static PyObject * 1851 gl_backbuffer(PyObject *self, PyObject *args) 1852 { 1853 long arg1 ; 1854 if (!getilongarg(args, 1, 0, &arg1)) 1855 return NULL; 1856 backbuffer( arg1 ); 1857 Py_INCREF(Py_None); 1858 return Py_None; 1859 } 1860 1861 /* void frontbuffer long s */ 1862 1863 static PyObject * 1864 gl_frontbuffer(PyObject *self, PyObject *args) 1865 { 1866 long arg1 ; 1867 if (!getilongarg(args, 1, 0, &arg1)) 1868 return NULL; 1869 frontbuffer( arg1 ); 1870 Py_INCREF(Py_None); 1871 return Py_None; 1872 } 1873 1874 /* void lsbackup long s */ 1875 1876 static PyObject * 1877 gl_lsbackup(PyObject *self, PyObject *args) 1878 { 1879 long arg1 ; 1880 if (!getilongarg(args, 1, 0, &arg1)) 1881 return NULL; 1882 lsbackup( arg1 ); 1883 Py_INCREF(Py_None); 1884 return Py_None; 1885 } 1886 1887 /* void resetls long s */ 1888 1889 static PyObject * 1890 gl_resetls(PyObject *self, PyObject *args) 1891 { 1892 long arg1 ; 1893 if (!getilongarg(args, 1, 0, &arg1)) 1894 return NULL; 1895 resetls( arg1 ); 1896 Py_INCREF(Py_None); 1897 return Py_None; 1898 } 1899 1900 /* void lampon long s */ 1901 1902 static PyObject * 1903 gl_lampon(PyObject *self, PyObject *args) 1904 { 1905 long arg1 ; 1906 if (!getilongarg(args, 1, 0, &arg1)) 1907 return NULL; 1908 lampon( arg1 ); 1909 Py_INCREF(Py_None); 1910 return Py_None; 1911 } 1912 1913 /* void lampoff long s */ 1914 1915 static PyObject * 1916 gl_lampoff(PyObject *self, PyObject *args) 1917 { 1918 long arg1 ; 1919 if (!getilongarg(args, 1, 0, &arg1)) 1920 return NULL; 1921 lampoff( arg1 ); 1922 Py_INCREF(Py_None); 1923 return Py_None; 1924 } 1925 1926 /* void setbell long s */ 1927 1928 static PyObject * 1929 gl_setbell(PyObject *self, PyObject *args) 1930 { 1931 long arg1 ; 1932 if (!getilongarg(args, 1, 0, &arg1)) 1933 return NULL; 1934 setbell( arg1 ); 1935 Py_INCREF(Py_None); 1936 return Py_None; 1937 } 1938 1939 /* void blankscreen long s */ 1940 1941 static PyObject * 1942 gl_blankscreen(PyObject *self, PyObject *args) 1943 { 1944 long arg1 ; 1945 if (!getilongarg(args, 1, 0, &arg1)) 1946 return NULL; 1947 blankscreen( arg1 ); 1948 Py_INCREF(Py_None); 1949 return Py_None; 1950 } 1951 1952 /* void depthcue long s */ 1953 1954 static PyObject * 1955 gl_depthcue(PyObject *self, PyObject *args) 1956 { 1957 long arg1 ; 1958 if (!getilongarg(args, 1, 0, &arg1)) 1959 return NULL; 1960 depthcue( arg1 ); 1961 Py_INCREF(Py_None); 1962 return Py_None; 1963 } 1964 1965 /* void zbuffer long s */ 1966 1967 static PyObject * 1968 gl_zbuffer(PyObject *self, PyObject *args) 1969 { 1970 long arg1 ; 1971 if (!getilongarg(args, 1, 0, &arg1)) 1972 return NULL; 1973 zbuffer( arg1 ); 1974 Py_INCREF(Py_None); 1975 return Py_None; 1976 } 1977 1978 /* void backface long s */ 1979 1980 static PyObject * 1981 gl_backface(PyObject *self, PyObject *args) 1982 { 1983 long arg1 ; 1984 if (!getilongarg(args, 1, 0, &arg1)) 1985 return NULL; 1986 backface( arg1 ); 1987 Py_INCREF(Py_None); 1988 return Py_None; 1989 } 1990 1991 /* void cmov2i long s long s */ 1992 1993 static PyObject * 1994 gl_cmov2i(PyObject *self, PyObject *args) 1995 { 1996 long arg1 ; 1997 long arg2 ; 1998 if (!getilongarg(args, 2, 0, &arg1)) 1999 return NULL; 2000 if (!getilongarg(args, 2, 1, &arg2)) 2001 return NULL; 2002 cmov2i( arg1 , arg2 ); 2003 Py_INCREF(Py_None); 2004 return Py_None; 2005 } 2006 2007 /* void draw2i long s long s */ 2008 2009 static PyObject * 2010 gl_draw2i(PyObject *self, PyObject *args) 2011 { 2012 long arg1 ; 2013 long arg2 ; 2014 if (!getilongarg(args, 2, 0, &arg1)) 2015 return NULL; 2016 if (!getilongarg(args, 2, 1, &arg2)) 2017 return NULL; 2018 draw2i( arg1 , arg2 ); 2019 Py_INCREF(Py_None); 2020 return Py_None; 2021 } 2022 2023 /* void move2i long s long s */ 2024 2025 static PyObject * 2026 gl_move2i(PyObject *self, PyObject *args) 2027 { 2028 long arg1 ; 2029 long arg2 ; 2030 if (!getilongarg(args, 2, 0, &arg1)) 2031 return NULL; 2032 if (!getilongarg(args, 2, 1, &arg2)) 2033 return NULL; 2034 move2i( arg1 , arg2 ); 2035 Py_INCREF(Py_None); 2036 return Py_None; 2037 } 2038 2039 /* void pnt2i long s long s */ 2040 2041 static PyObject * 2042 gl_pnt2i(PyObject *self, PyObject *args) 2043 { 2044 long arg1 ; 2045 long arg2 ; 2046 if (!getilongarg(args, 2, 0, &arg1)) 2047 return NULL; 2048 if (!getilongarg(args, 2, 1, &arg2)) 2049 return NULL; 2050 pnt2i( arg1 , arg2 ); 2051 Py_INCREF(Py_None); 2052 return Py_None; 2053 } 2054 2055 /* void patchbasis long s long s */ 2056 2057 static PyObject * 2058 gl_patchbasis(PyObject *self, PyObject *args) 2059 { 2060 long arg1 ; 2061 long arg2 ; 2062 if (!getilongarg(args, 2, 0, &arg1)) 2063 return NULL; 2064 if (!getilongarg(args, 2, 1, &arg2)) 2065 return NULL; 2066 patchbasis( arg1 , arg2 ); 2067 Py_INCREF(Py_None); 2068 return Py_None; 2069 } 2070 2071 /* void patchprecision long s long s */ 2072 2073 static PyObject * 2074 gl_patchprecision(PyObject *self, PyObject *args) 2075 { 2076 long arg1 ; 2077 long arg2 ; 2078 if (!getilongarg(args, 2, 0, &arg1)) 2079 return NULL; 2080 if (!getilongarg(args, 2, 1, &arg2)) 2081 return NULL; 2082 patchprecision( arg1 , arg2 ); 2083 Py_INCREF(Py_None); 2084 return Py_None; 2085 } 2086 2087 /* void pdr2i long s long s */ 2088 2089 static PyObject * 2090 gl_pdr2i(PyObject *self, PyObject *args) 2091 { 2092 long arg1 ; 2093 long arg2 ; 2094 if (!getilongarg(args, 2, 0, &arg1)) 2095 return NULL; 2096 if (!getilongarg(args, 2, 1, &arg2)) 2097 return NULL; 2098 pdr2i( arg1 , arg2 ); 2099 Py_INCREF(Py_None); 2100 return Py_None; 2101 } 2102 2103 /* void pmv2i long s long s */ 2104 2105 static PyObject * 2106 gl_pmv2i(PyObject *self, PyObject *args) 2107 { 2108 long arg1 ; 2109 long arg2 ; 2110 if (!getilongarg(args, 2, 0, &arg1)) 2111 return NULL; 2112 if (!getilongarg(args, 2, 1, &arg2)) 2113 return NULL; 2114 pmv2i( arg1 , arg2 ); 2115 Py_INCREF(Py_None); 2116 return Py_None; 2117 } 2118 2119 /* void rpdr2i long s long s */ 2120 2121 static PyObject * 2122 gl_rpdr2i(PyObject *self, PyObject *args) 2123 { 2124 long arg1 ; 2125 long arg2 ; 2126 if (!getilongarg(args, 2, 0, &arg1)) 2127 return NULL; 2128 if (!getilongarg(args, 2, 1, &arg2)) 2129 return NULL; 2130 rpdr2i( arg1 , arg2 ); 2131 Py_INCREF(Py_None); 2132 return Py_None; 2133 } 2134 2135 /* void rpmv2i long s long s */ 2136 2137 static PyObject * 2138 gl_rpmv2i(PyObject *self, PyObject *args) 2139 { 2140 long arg1 ; 2141 long arg2 ; 2142 if (!getilongarg(args, 2, 0, &arg1)) 2143 return NULL; 2144 if (!getilongarg(args, 2, 1, &arg2)) 2145 return NULL; 2146 rpmv2i( arg1 , arg2 ); 2147 Py_INCREF(Py_None); 2148 return Py_None; 2149 } 2150 2151 /* void xfpt2i long s long s */ 2152 2153 static PyObject * 2154 gl_xfpt2i(PyObject *self, PyObject *args) 2155 { 2156 long arg1 ; 2157 long arg2 ; 2158 if (!getilongarg(args, 2, 0, &arg1)) 2159 return NULL; 2160 if (!getilongarg(args, 2, 1, &arg2)) 2161 return NULL; 2162 xfpt2i( arg1 , arg2 ); 2163 Py_INCREF(Py_None); 2164 return Py_None; 2165 } 2166 2167 /* void objdelete long s long s */ 2168 2169 static PyObject * 2170 gl_objdelete(PyObject *self, PyObject *args) 2171 { 2172 long arg1 ; 2173 long arg2 ; 2174 if (!getilongarg(args, 2, 0, &arg1)) 2175 return NULL; 2176 if (!getilongarg(args, 2, 1, &arg2)) 2177 return NULL; 2178 objdelete( arg1 , arg2 ); 2179 Py_INCREF(Py_None); 2180 return Py_None; 2181 } 2182 2183 /* void patchcurves long s long s */ 2184 2185 static PyObject * 2186 gl_patchcurves(PyObject *self, PyObject *args) 2187 { 2188 long arg1 ; 2189 long arg2 ; 2190 if (!getilongarg(args, 2, 0, &arg1)) 2191 return NULL; 2192 if (!getilongarg(args, 2, 1, &arg2)) 2193 return NULL; 2194 patchcurves( arg1 , arg2 ); 2195 Py_INCREF(Py_None); 2196 return Py_None; 2197 } 2198 2199 /* void minsize long s long s */ 2200 2201 static PyObject * 2202 gl_minsize(PyObject *self, PyObject *args) 2203 { 2204 long arg1 ; 2205 long arg2 ; 2206 if (!getilongarg(args, 2, 0, &arg1)) 2207 return NULL; 2208 if (!getilongarg(args, 2, 1, &arg2)) 2209 return NULL; 2210 minsize( arg1 , arg2 ); 2211 Py_INCREF(Py_None); 2212 return Py_None; 2213 } 2214 2215 /* void maxsize long s long s */ 2216 2217 static PyObject * 2218 gl_maxsize(PyObject *self, PyObject *args) 2219 { 2220 long arg1 ; 2221 long arg2 ; 2222 if (!getilongarg(args, 2, 0, &arg1)) 2223 return NULL; 2224 if (!getilongarg(args, 2, 1, &arg2)) 2225 return NULL; 2226 maxsize( arg1 , arg2 ); 2227 Py_INCREF(Py_None); 2228 return Py_None; 2229 } 2230 2231 /* void keepaspect long s long s */ 2232 2233 static PyObject * 2234 gl_keepaspect(PyObject *self, PyObject *args) 2235 { 2236 long arg1 ; 2237 long arg2 ; 2238 if (!getilongarg(args, 2, 0, &arg1)) 2239 return NULL; 2240 if (!getilongarg(args, 2, 1, &arg2)) 2241 return NULL; 2242 keepaspect( arg1 , arg2 ); 2243 Py_INCREF(Py_None); 2244 return Py_None; 2245 } 2246 2247 /* void prefsize long s long s */ 2248 2249 static PyObject * 2250 gl_prefsize(PyObject *self, PyObject *args) 2251 { 2252 long arg1 ; 2253 long arg2 ; 2254 if (!getilongarg(args, 2, 0, &arg1)) 2255 return NULL; 2256 if (!getilongarg(args, 2, 1, &arg2)) 2257 return NULL; 2258 prefsize( arg1 , arg2 ); 2259 Py_INCREF(Py_None); 2260 return Py_None; 2261 } 2262 2263 /* void stepunit long s long s */ 2264 2265 static PyObject * 2266 gl_stepunit(PyObject *self, PyObject *args) 2267 { 2268 long arg1 ; 2269 long arg2 ; 2270 if (!getilongarg(args, 2, 0, &arg1)) 2271 return NULL; 2272 if (!getilongarg(args, 2, 1, &arg2)) 2273 return NULL; 2274 stepunit( arg1 , arg2 ); 2275 Py_INCREF(Py_None); 2276 return Py_None; 2277 } 2278 2279 /* void fudge long s long s */ 2280 2281 static PyObject * 2282 gl_fudge(PyObject *self, PyObject *args) 2283 { 2284 long arg1 ; 2285 long arg2 ; 2286 if (!getilongarg(args, 2, 0, &arg1)) 2287 return NULL; 2288 if (!getilongarg(args, 2, 1, &arg2)) 2289 return NULL; 2290 fudge( arg1 , arg2 ); 2291 Py_INCREF(Py_None); 2292 return Py_None; 2293 } 2294 2295 /* void winmove long s long s */ 2296 2297 static PyObject * 2298 gl_winmove(PyObject *self, PyObject *args) 2299 { 2300 long arg1 ; 2301 long arg2 ; 2302 if (!getilongarg(args, 2, 0, &arg1)) 2303 return NULL; 2304 if (!getilongarg(args, 2, 1, &arg2)) 2305 return NULL; 2306 winmove( arg1 , arg2 ); 2307 Py_INCREF(Py_None); 2308 return Py_None; 2309 } 2310 2311 /* void attachcursor short s short s */ 2312 2313 static PyObject * 2314 gl_attachcursor(PyObject *self, PyObject *args) 2315 { 2316 short arg1 ; 2317 short arg2 ; 2318 if (!getishortarg(args, 2, 0, &arg1)) 2319 return NULL; 2320 if (!getishortarg(args, 2, 1, &arg2)) 2321 return NULL; 2322 attachcursor( arg1 , arg2 ); 2323 Py_INCREF(Py_None); 2324 return Py_None; 2325 } 2326 2327 /* void deflinestyle short s short s */ 2328 2329 static PyObject * 2330 gl_deflinestyle(PyObject *self, PyObject *args) 2331 { 2332 short arg1 ; 2333 short arg2 ; 2334 if (!getishortarg(args, 2, 0, &arg1)) 2335 return NULL; 2336 if (!getishortarg(args, 2, 1, &arg2)) 2337 return NULL; 2338 deflinestyle( arg1 , arg2 ); 2339 Py_INCREF(Py_None); 2340 return Py_None; 2341 } 2342 2343 /* void noise short s short s */ 2344 2345 static PyObject * 2346 gl_noise(PyObject *self, PyObject *args) 2347 { 2348 short arg1 ; 2349 short arg2 ; 2350 if (!getishortarg(args, 2, 0, &arg1)) 2351 return NULL; 2352 if (!getishortarg(args, 2, 1, &arg2)) 2353 return NULL; 2354 noise( arg1 , arg2 ); 2355 Py_INCREF(Py_None); 2356 return Py_None; 2357 } 2358 2359 /* void picksize short s short s */ 2360 2361 static PyObject * 2362 gl_picksize(PyObject *self, PyObject *args) 2363 { 2364 short arg1 ; 2365 short arg2 ; 2366 if (!getishortarg(args, 2, 0, &arg1)) 2367 return NULL; 2368 if (!getishortarg(args, 2, 1, &arg2)) 2369 return NULL; 2370 picksize( arg1 , arg2 ); 2371 Py_INCREF(Py_None); 2372 return Py_None; 2373 } 2374 2375 /* void qenter short s short s */ 2376 2377 static PyObject * 2378 gl_qenter(PyObject *self, PyObject *args) 2379 { 2380 short arg1 ; 2381 short arg2 ; 2382 if (!getishortarg(args, 2, 0, &arg1)) 2383 return NULL; 2384 if (!getishortarg(args, 2, 1, &arg2)) 2385 return NULL; 2386 qenter( arg1 , arg2 ); 2387 Py_INCREF(Py_None); 2388 return Py_None; 2389 } 2390 2391 /* void setdepth short s short s */ 2392 2393 static PyObject * 2394 gl_setdepth(PyObject *self, PyObject *args) 2395 { 2396 short arg1 ; 2397 short arg2 ; 2398 if (!getishortarg(args, 2, 0, &arg1)) 2399 return NULL; 2400 if (!getishortarg(args, 2, 1, &arg2)) 2401 return NULL; 2402 setdepth( arg1 , arg2 ); 2403 Py_INCREF(Py_None); 2404 return Py_None; 2405 } 2406 2407 /* void cmov2s short s short s */ 2408 2409 static PyObject * 2410 gl_cmov2s(PyObject *self, PyObject *args) 2411 { 2412 short arg1 ; 2413 short arg2 ; 2414 if (!getishortarg(args, 2, 0, &arg1)) 2415 return NULL; 2416 if (!getishortarg(args, 2, 1, &arg2)) 2417 return NULL; 2418 cmov2s( arg1 , arg2 ); 2419 Py_INCREF(Py_None); 2420 return Py_None; 2421 } 2422 2423 /* void draw2s short s short s */ 2424 2425 static PyObject * 2426 gl_draw2s(PyObject *self, PyObject *args) 2427 { 2428 short arg1 ; 2429 short arg2 ; 2430 if (!getishortarg(args, 2, 0, &arg1)) 2431 return NULL; 2432 if (!getishortarg(args, 2, 1, &arg2)) 2433 return NULL; 2434 draw2s( arg1 , arg2 ); 2435 Py_INCREF(Py_None); 2436 return Py_None; 2437 } 2438 2439 /* void move2s short s short s */ 2440 2441 static PyObject * 2442 gl_move2s(PyObject *self, PyObject *args) 2443 { 2444 short arg1 ; 2445 short arg2 ; 2446 if (!getishortarg(args, 2, 0, &arg1)) 2447 return NULL; 2448 if (!getishortarg(args, 2, 1, &arg2)) 2449 return NULL; 2450 move2s( arg1 , arg2 ); 2451 Py_INCREF(Py_None); 2452 return Py_None; 2453 } 2454 2455 /* void pdr2s short s short s */ 2456 2457 static PyObject * 2458 gl_pdr2s(PyObject *self, PyObject *args) 2459 { 2460 short arg1 ; 2461 short arg2 ; 2462 if (!getishortarg(args, 2, 0, &arg1)) 2463 return NULL; 2464 if (!getishortarg(args, 2, 1, &arg2)) 2465 return NULL; 2466 pdr2s( arg1 , arg2 ); 2467 Py_INCREF(Py_None); 2468 return Py_None; 2469 } 2470 2471 /* void pmv2s short s short s */ 2472 2473 static PyObject * 2474 gl_pmv2s(PyObject *self, PyObject *args) 2475 { 2476 short arg1 ; 2477 short arg2 ; 2478 if (!getishortarg(args, 2, 0, &arg1)) 2479 return NULL; 2480 if (!getishortarg(args, 2, 1, &arg2)) 2481 return NULL; 2482 pmv2s( arg1 , arg2 ); 2483 Py_INCREF(Py_None); 2484 return Py_None; 2485 } 2486 2487 /* void pnt2s short s short s */ 2488 2489 static PyObject * 2490 gl_pnt2s(PyObject *self, PyObject *args) 2491 { 2492 short arg1 ; 2493 short arg2 ; 2494 if (!getishortarg(args, 2, 0, &arg1)) 2495 return NULL; 2496 if (!getishortarg(args, 2, 1, &arg2)) 2497 return NULL; 2498 pnt2s( arg1 , arg2 ); 2499 Py_INCREF(Py_None); 2500 return Py_None; 2501 } 2502 2503 /* void rdr2s short s short s */ 2504 2505 static PyObject * 2506 gl_rdr2s(PyObject *self, PyObject *args) 2507 { 2508 short arg1 ; 2509 short arg2 ; 2510 if (!getishortarg(args, 2, 0, &arg1)) 2511 return NULL; 2512 if (!getishortarg(args, 2, 1, &arg2)) 2513 return NULL; 2514 rdr2s( arg1 , arg2 ); 2515 Py_INCREF(Py_None); 2516 return Py_None; 2517 } 2518 2519 /* void rmv2s short s short s */ 2520 2521 static PyObject * 2522 gl_rmv2s(PyObject *self, PyObject *args) 2523 { 2524 short arg1 ; 2525 short arg2 ; 2526 if (!getishortarg(args, 2, 0, &arg1)) 2527 return NULL; 2528 if (!getishortarg(args, 2, 1, &arg2)) 2529 return NULL; 2530 rmv2s( arg1 , arg2 ); 2531 Py_INCREF(Py_None); 2532 return Py_None; 2533 } 2534 2535 /* void rpdr2s short s short s */ 2536 2537 static PyObject * 2538 gl_rpdr2s(PyObject *self, PyObject *args) 2539 { 2540 short arg1 ; 2541 short arg2 ; 2542 if (!getishortarg(args, 2, 0, &arg1)) 2543 return NULL; 2544 if (!getishortarg(args, 2, 1, &arg2)) 2545 return NULL; 2546 rpdr2s( arg1 , arg2 ); 2547 Py_INCREF(Py_None); 2548 return Py_None; 2549 } 2550 2551 /* void rpmv2s short s short s */ 2552 2553 static PyObject * 2554 gl_rpmv2s(PyObject *self, PyObject *args) 2555 { 2556 short arg1 ; 2557 short arg2 ; 2558 if (!getishortarg(args, 2, 0, &arg1)) 2559 return NULL; 2560 if (!getishortarg(args, 2, 1, &arg2)) 2561 return NULL; 2562 rpmv2s( arg1 , arg2 ); 2563 Py_INCREF(Py_None); 2564 return Py_None; 2565 } 2566 2567 /* void xfpt2s short s short s */ 2568 2569 static PyObject * 2570 gl_xfpt2s(PyObject *self, PyObject *args) 2571 { 2572 short arg1 ; 2573 short arg2 ; 2574 if (!getishortarg(args, 2, 0, &arg1)) 2575 return NULL; 2576 if (!getishortarg(args, 2, 1, &arg2)) 2577 return NULL; 2578 xfpt2s( arg1 , arg2 ); 2579 Py_INCREF(Py_None); 2580 return Py_None; 2581 } 2582 2583 /* void cmov2 float s float s */ 2584 2585 static PyObject * 2586 gl_cmov2(PyObject *self, PyObject *args) 2587 { 2588 float arg1 ; 2589 float arg2 ; 2590 if (!getifloatarg(args, 2, 0, &arg1)) 2591 return NULL; 2592 if (!getifloatarg(args, 2, 1, &arg2)) 2593 return NULL; 2594 cmov2( arg1 , arg2 ); 2595 Py_INCREF(Py_None); 2596 return Py_None; 2597 } 2598 2599 /* void draw2 float s float s */ 2600 2601 static PyObject * 2602 gl_draw2(PyObject *self, PyObject *args) 2603 { 2604 float arg1 ; 2605 float arg2 ; 2606 if (!getifloatarg(args, 2, 0, &arg1)) 2607 return NULL; 2608 if (!getifloatarg(args, 2, 1, &arg2)) 2609 return NULL; 2610 draw2( arg1 , arg2 ); 2611 Py_INCREF(Py_None); 2612 return Py_None; 2613 } 2614 2615 /* void move2 float s float s */ 2616 2617 static PyObject * 2618 gl_move2(PyObject *self, PyObject *args) 2619 { 2620 float arg1 ; 2621 float arg2 ; 2622 if (!getifloatarg(args, 2, 0, &arg1)) 2623 return NULL; 2624 if (!getifloatarg(args, 2, 1, &arg2)) 2625 return NULL; 2626 move2( arg1 , arg2 ); 2627 Py_INCREF(Py_None); 2628 return Py_None; 2629 } 2630 2631 /* void pnt2 float s float s */ 2632 2633 static PyObject * 2634 gl_pnt2(PyObject *self, PyObject *args) 2635 { 2636 float arg1 ; 2637 float arg2 ; 2638 if (!getifloatarg(args, 2, 0, &arg1)) 2639 return NULL; 2640 if (!getifloatarg(args, 2, 1, &arg2)) 2641 return NULL; 2642 pnt2( arg1 , arg2 ); 2643 Py_INCREF(Py_None); 2644 return Py_None; 2645 } 2646 2647 /* void pdr2 float s float s */ 2648 2649 static PyObject * 2650 gl_pdr2(PyObject *self, PyObject *args) 2651 { 2652 float arg1 ; 2653 float arg2 ; 2654 if (!getifloatarg(args, 2, 0, &arg1)) 2655 return NULL; 2656 if (!getifloatarg(args, 2, 1, &arg2)) 2657 return NULL; 2658 pdr2( arg1 , arg2 ); 2659 Py_INCREF(Py_None); 2660 return Py_None; 2661 } 2662 2663 /* void pmv2 float s float s */ 2664 2665 static PyObject * 2666 gl_pmv2(PyObject *self, PyObject *args) 2667 { 2668 float arg1 ; 2669 float arg2 ; 2670 if (!getifloatarg(args, 2, 0, &arg1)) 2671 return NULL; 2672 if (!getifloatarg(args, 2, 1, &arg2)) 2673 return NULL; 2674 pmv2( arg1 , arg2 ); 2675 Py_INCREF(Py_None); 2676 return Py_None; 2677 } 2678 2679 /* void rdr2 float s float s */ 2680 2681 static PyObject * 2682 gl_rdr2(PyObject *self, PyObject *args) 2683 { 2684 float arg1 ; 2685 float arg2 ; 2686 if (!getifloatarg(args, 2, 0, &arg1)) 2687 return NULL; 2688 if (!getifloatarg(args, 2, 1, &arg2)) 2689 return NULL; 2690 rdr2( arg1 , arg2 ); 2691 Py_INCREF(Py_None); 2692 return Py_None; 2693 } 2694 2695 /* void rmv2 float s float s */ 2696 2697 static PyObject * 2698 gl_rmv2(PyObject *self, PyObject *args) 2699 { 2700 float arg1 ; 2701 float arg2 ; 2702 if (!getifloatarg(args, 2, 0, &arg1)) 2703 return NULL; 2704 if (!getifloatarg(args, 2, 1, &arg2)) 2705 return NULL; 2706 rmv2( arg1 , arg2 ); 2707 Py_INCREF(Py_None); 2708 return Py_None; 2709 } 2710 2711 /* void rpdr2 float s float s */ 2712 2713 static PyObject * 2714 gl_rpdr2(PyObject *self, PyObject *args) 2715 { 2716 float arg1 ; 2717 float arg2 ; 2718 if (!getifloatarg(args, 2, 0, &arg1)) 2719 return NULL; 2720 if (!getifloatarg(args, 2, 1, &arg2)) 2721 return NULL; 2722 rpdr2( arg1 , arg2 ); 2723 Py_INCREF(Py_None); 2724 return Py_None; 2725 } 2726 2727 /* void rpmv2 float s float s */ 2728 2729 static PyObject * 2730 gl_rpmv2(PyObject *self, PyObject *args) 2731 { 2732 float arg1 ; 2733 float arg2 ; 2734 if (!getifloatarg(args, 2, 0, &arg1)) 2735 return NULL; 2736 if (!getifloatarg(args, 2, 1, &arg2)) 2737 return NULL; 2738 rpmv2( arg1 , arg2 ); 2739 Py_INCREF(Py_None); 2740 return Py_None; 2741 } 2742 2743 /* void xfpt2 float s float s */ 2744 2745 static PyObject * 2746 gl_xfpt2(PyObject *self, PyObject *args) 2747 { 2748 float arg1 ; 2749 float arg2 ; 2750 if (!getifloatarg(args, 2, 0, &arg1)) 2751 return NULL; 2752 if (!getifloatarg(args, 2, 1, &arg2)) 2753 return NULL; 2754 xfpt2( arg1 , arg2 ); 2755 Py_INCREF(Py_None); 2756 return Py_None; 2757 } 2758 2759 /* void loadmatrix float s[4*4] */ 2760 2761 static PyObject * 2762 gl_loadmatrix(PyObject *self, PyObject *args) 2763 { 2764 float arg1 [ 4 ] [ 4 ] ; 2765 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) 2766 return NULL; 2767 loadmatrix( arg1 ); 2768 Py_INCREF(Py_None); 2769 return Py_None; 2770 } 2771 2772 /* void multmatrix float s[4*4] */ 2773 2774 static PyObject * 2775 gl_multmatrix(PyObject *self, PyObject *args) 2776 { 2777 float arg1 [ 4 ] [ 4 ] ; 2778 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) 2779 return NULL; 2780 multmatrix( arg1 ); 2781 Py_INCREF(Py_None); 2782 return Py_None; 2783 } 2784 2785 /* void crv float s[3*4] */ 2786 2787 static PyObject * 2788 gl_crv(PyObject *self, PyObject *args) 2789 { 2790 float arg1 [ 4 ] [ 3 ] ; 2791 if (!getifloatarray(args, 1, 0, 3 * 4 , (float *) arg1)) 2792 return NULL; 2793 crv( arg1 ); 2794 Py_INCREF(Py_None); 2795 return Py_None; 2796 } 2797 2798 /* void rcrv float s[4*4] */ 2799 2800 static PyObject * 2801 gl_rcrv(PyObject *self, PyObject *args) 2802 { 2803 float arg1 [ 4 ] [ 4 ] ; 2804 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) 2805 return NULL; 2806 rcrv( arg1 ); 2807 Py_INCREF(Py_None); 2808 return Py_None; 2809 } 2810 2811 /* void addtopup long s char *s long s */ 2812 2813 static PyObject * 2814 gl_addtopup(PyObject *self, PyObject *args) 2815 { 2816 long arg1 ; 2817 string arg2 ; 2818 long arg3 ; 2819 if (!getilongarg(args, 3, 0, &arg1)) 2820 return NULL; 2821 if (!getistringarg(args, 3, 1, &arg2)) 2822 return NULL; 2823 if (!getilongarg(args, 3, 2, &arg3)) 2824 return NULL; 2825 addtopup( arg1 , arg2 , arg3 ); 2826 Py_INCREF(Py_None); 2827 return Py_None; 2828 } 2829 2830 /* void charstr char *s */ 2831 2832 static PyObject * 2833 gl_charstr(PyObject *self, PyObject *args) 2834 { 2835 string arg1 ; 2836 if (!getistringarg(args, 1, 0, &arg1)) 2837 return NULL; 2838 charstr( arg1 ); 2839 Py_INCREF(Py_None); 2840 return Py_None; 2841 } 2842 2843 /* void getport char *s */ 2844 2845 static PyObject * 2846 gl_getport(PyObject *self, PyObject *args) 2847 { 2848 string arg1 ; 2849 if (!getistringarg(args, 1, 0, &arg1)) 2850 return NULL; 2851 getport( arg1 ); 2852 Py_INCREF(Py_None); 2853 return Py_None; 2854 } 2855 2856 /* long strwidth char *s */ 2857 2858 static PyObject * 2859 gl_strwidth(PyObject *self, PyObject *args) 2860 { 2861 long retval; 2862 string arg1 ; 2863 if (!getistringarg(args, 1, 0, &arg1)) 2864 return NULL; 2865 retval = strwidth( arg1 ); 2866 return mknewlongobject(retval); 2867 } 2868 2869 /* long winopen char *s */ 2870 2871 static PyObject * 2872 gl_winopen(PyObject *self, PyObject *args) 2873 { 2874 long retval; 2875 string arg1 ; 2876 if (!getistringarg(args, 1, 0, &arg1)) 2877 return NULL; 2878 retval = winopen( arg1 ); 2879 return mknewlongobject(retval); 2880 } 2881 2882 /* void wintitle char *s */ 2883 2884 static PyObject * 2885 gl_wintitle(PyObject *self, PyObject *args) 2886 { 2887 string arg1 ; 2888 if (!getistringarg(args, 1, 0, &arg1)) 2889 return NULL; 2890 wintitle( arg1 ); 2891 Py_INCREF(Py_None); 2892 return Py_None; 2893 } 2894 2895 /* void polf long s float s[3*arg1] */ 2896 2897 static PyObject * 2898 gl_polf(PyObject *self, PyObject *args) 2899 { 2900 long arg1 ; 2901 float (* arg2) [ 3 ] ; 2902 if (!getilongarraysize(args, 1, 0, &arg1)) 2903 return NULL; 2904 arg1 = arg1 / 3; 2905 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) 2906 return PyErr_NoMemory(); 2907 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) 2908 return NULL; 2909 polf( arg1 , arg2 ); 2910 PyMem_DEL(arg2); 2911 Py_INCREF(Py_None); 2912 return Py_None; 2913 } 2914 2915 /* void polf2 long s float s[2*arg1] */ 2916 2917 static PyObject * 2918 gl_polf2(PyObject *self, PyObject *args) 2919 { 2920 long arg1 ; 2921 float (* arg2) [ 2 ] ; 2922 if (!getilongarraysize(args, 1, 0, &arg1)) 2923 return NULL; 2924 arg1 = arg1 / 2; 2925 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) 2926 return PyErr_NoMemory(); 2927 if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2)) 2928 return NULL; 2929 polf2( arg1 , arg2 ); 2930 PyMem_DEL(arg2); 2931 Py_INCREF(Py_None); 2932 return Py_None; 2933 } 2934 2935 /* void poly long s float s[3*arg1] */ 2936 2937 static PyObject * 2938 gl_poly(PyObject *self, PyObject *args) 2939 { 2940 long arg1 ; 2941 float (* arg2) [ 3 ] ; 2942 if (!getilongarraysize(args, 1, 0, &arg1)) 2943 return NULL; 2944 arg1 = arg1 / 3; 2945 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) 2946 return PyErr_NoMemory(); 2947 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) 2948 return NULL; 2949 poly( arg1 , arg2 ); 2950 PyMem_DEL(arg2); 2951 Py_INCREF(Py_None); 2952 return Py_None; 2953 } 2954 2955 /* void poly2 long s float s[2*arg1] */ 2956 2957 static PyObject * 2958 gl_poly2(PyObject *self, PyObject *args) 2959 { 2960 long arg1 ; 2961 float (* arg2) [ 2 ] ; 2962 if (!getilongarraysize(args, 1, 0, &arg1)) 2963 return NULL; 2964 arg1 = arg1 / 2; 2965 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) 2966 return PyErr_NoMemory(); 2967 if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2)) 2968 return NULL; 2969 poly2( arg1 , arg2 ); 2970 PyMem_DEL(arg2); 2971 Py_INCREF(Py_None); 2972 return Py_None; 2973 } 2974 2975 /* void crvn long s float s[3*arg1] */ 2976 2977 static PyObject * 2978 gl_crvn(PyObject *self, PyObject *args) 2979 { 2980 long arg1 ; 2981 float (* arg2) [ 3 ] ; 2982 if (!getilongarraysize(args, 1, 0, &arg1)) 2983 return NULL; 2984 arg1 = arg1 / 3; 2985 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) 2986 return PyErr_NoMemory(); 2987 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) 2988 return NULL; 2989 crvn( arg1 , arg2 ); 2990 PyMem_DEL(arg2); 2991 Py_INCREF(Py_None); 2992 return Py_None; 2993 } 2994 2995 /* void rcrvn long s float s[4*arg1] */ 2996 2997 static PyObject * 2998 gl_rcrvn(PyObject *self, PyObject *args) 2999 { 3000 long arg1 ; 3001 float (* arg2) [ 4 ] ; 3002 if (!getilongarraysize(args, 1, 0, &arg1)) 3003 return NULL; 3004 arg1 = arg1 / 4; 3005 if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL) 3006 return PyErr_NoMemory(); 3007 if (!getifloatarray(args, 1, 0, 4 * arg1 , (float *) arg2)) 3008 return NULL; 3009 rcrvn( arg1 , arg2 ); 3010 PyMem_DEL(arg2); 3011 Py_INCREF(Py_None); 3012 return Py_None; 3013 } 3014 3015 /* void polf2i long s long s[2*arg1] */ 3016 3017 static PyObject * 3018 gl_polf2i(PyObject *self, PyObject *args) 3019 { 3020 long arg1 ; 3021 long (* arg2) [ 2 ] ; 3022 if (!getilongarraysize(args, 1, 0, &arg1)) 3023 return NULL; 3024 arg1 = arg1 / 2; 3025 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) 3026 return PyErr_NoMemory(); 3027 if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2)) 3028 return NULL; 3029 polf2i( arg1 , arg2 ); 3030 PyMem_DEL(arg2); 3031 Py_INCREF(Py_None); 3032 return Py_None; 3033 } 3034 3035 /* void polfi long s long s[3*arg1] */ 3036 3037 static PyObject * 3038 gl_polfi(PyObject *self, PyObject *args) 3039 { 3040 long arg1 ; 3041 long (* arg2) [ 3 ] ; 3042 if (!getilongarraysize(args, 1, 0, &arg1)) 3043 return NULL; 3044 arg1 = arg1 / 3; 3045 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) 3046 return PyErr_NoMemory(); 3047 if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2)) 3048 return NULL; 3049 polfi( arg1 , arg2 ); 3050 PyMem_DEL(arg2); 3051 Py_INCREF(Py_None); 3052 return Py_None; 3053 } 3054 3055 /* void poly2i long s long s[2*arg1] */ 3056 3057 static PyObject * 3058 gl_poly2i(PyObject *self, PyObject *args) 3059 { 3060 long arg1 ; 3061 long (* arg2) [ 2 ] ; 3062 if (!getilongarraysize(args, 1, 0, &arg1)) 3063 return NULL; 3064 arg1 = arg1 / 2; 3065 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) 3066 return PyErr_NoMemory(); 3067 if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2)) 3068 return NULL; 3069 poly2i( arg1 , arg2 ); 3070 PyMem_DEL(arg2); 3071 Py_INCREF(Py_None); 3072 return Py_None; 3073 } 3074 3075 /* void polyi long s long s[3*arg1] */ 3076 3077 static PyObject * 3078 gl_polyi(PyObject *self, PyObject *args) 3079 { 3080 long arg1 ; 3081 long (* arg2) [ 3 ] ; 3082 if (!getilongarraysize(args, 1, 0, &arg1)) 3083 return NULL; 3084 arg1 = arg1 / 3; 3085 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) 3086 return PyErr_NoMemory(); 3087 if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2)) 3088 return NULL; 3089 polyi( arg1 , arg2 ); 3090 PyMem_DEL(arg2); 3091 Py_INCREF(Py_None); 3092 return Py_None; 3093 } 3094 3095 /* void polf2s long s short s[2*arg1] */ 3096 3097 static PyObject * 3098 gl_polf2s(PyObject *self, PyObject *args) 3099 { 3100 long arg1 ; 3101 short (* arg2) [ 2 ] ; 3102 if (!getilongarraysize(args, 1, 0, &arg1)) 3103 return NULL; 3104 arg1 = arg1 / 2; 3105 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) 3106 return PyErr_NoMemory(); 3107 if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2)) 3108 return NULL; 3109 polf2s( arg1 , arg2 ); 3110 PyMem_DEL(arg2); 3111 Py_INCREF(Py_None); 3112 return Py_None; 3113 } 3114 3115 /* void polfs long s short s[3*arg1] */ 3116 3117 static PyObject * 3118 gl_polfs(PyObject *self, PyObject *args) 3119 { 3120 long arg1 ; 3121 short (* arg2) [ 3 ] ; 3122 if (!getilongarraysize(args, 1, 0, &arg1)) 3123 return NULL; 3124 arg1 = arg1 / 3; 3125 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) 3126 return PyErr_NoMemory(); 3127 if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2)) 3128 return NULL; 3129 polfs( arg1 , arg2 ); 3130 PyMem_DEL(arg2); 3131 Py_INCREF(Py_None); 3132 return Py_None; 3133 } 3134 3135 /* void polys long s short s[3*arg1] */ 3136 3137 static PyObject * 3138 gl_polys(PyObject *self, PyObject *args) 3139 { 3140 long arg1 ; 3141 short (* arg2) [ 3 ] ; 3142 if (!getilongarraysize(args, 1, 0, &arg1)) 3143 return NULL; 3144 arg1 = arg1 / 3; 3145 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) 3146 return PyErr_NoMemory(); 3147 if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2)) 3148 return NULL; 3149 polys( arg1 , arg2 ); 3150 PyMem_DEL(arg2); 3151 Py_INCREF(Py_None); 3152 return Py_None; 3153 } 3154 3155 /* void poly2s long s short s[2*arg1] */ 3156 3157 static PyObject * 3158 gl_poly2s(PyObject *self, PyObject *args) 3159 { 3160 long arg1 ; 3161 short (* arg2) [ 2 ] ; 3162 if (!getilongarraysize(args, 1, 0, &arg1)) 3163 return NULL; 3164 arg1 = arg1 / 2; 3165 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) 3166 return PyErr_NoMemory(); 3167 if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2)) 3168 return NULL; 3169 poly2s( arg1 , arg2 ); 3170 PyMem_DEL(arg2); 3171 Py_INCREF(Py_None); 3172 return Py_None; 3173 } 3174 3175 /* void defcursor short s u_short s[128] */ 3176 3177 static PyObject * 3178 gl_defcursor(PyObject *self, PyObject *args) 3179 { 3180 short arg1 ; 3181 unsigned short arg2 [ 128 ] ; 3182 if (!getishortarg(args, 2, 0, &arg1)) 3183 return NULL; 3184 if (!getishortarray(args, 2, 1, 128 , (short *) arg2)) 3185 return NULL; 3186 defcursor( arg1 , arg2 ); 3187 Py_INCREF(Py_None); 3188 return Py_None; 3189 } 3190 3191 /* void writepixels short s u_short s[arg1] */ 3192 3193 static PyObject * 3194 gl_writepixels(PyObject *self, PyObject *args) 3195 { 3196 short arg1 ; 3197 unsigned short * arg2 ; 3198 if (!getishortarraysize(args, 1, 0, &arg1)) 3199 return NULL; 3200 if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL) 3201 return PyErr_NoMemory(); 3202 if (!getishortarray(args, 1, 0, arg1 , (short *) arg2)) 3203 return NULL; 3204 writepixels( arg1 , arg2 ); 3205 PyMem_DEL(arg2); 3206 Py_INCREF(Py_None); 3207 return Py_None; 3208 } 3209 3210 /* void defbasis long s float s[4*4] */ 3211 3212 static PyObject * 3213 gl_defbasis(PyObject *self, PyObject *args) 3214 { 3215 long arg1 ; 3216 float arg2 [ 4 ] [ 4 ] ; 3217 if (!getilongarg(args, 2, 0, &arg1)) 3218 return NULL; 3219 if (!getifloatarray(args, 2, 1, 4 * 4 , (float *) arg2)) 3220 return NULL; 3221 defbasis( arg1 , arg2 ); 3222 Py_INCREF(Py_None); 3223 return Py_None; 3224 } 3225 3226 /* void gewrite short s short s[arg1] */ 3227 3228 static PyObject * 3229 gl_gewrite(PyObject *self, PyObject *args) 3230 { 3231 short arg1 ; 3232 short * arg2 ; 3233 if (!getishortarraysize(args, 1, 0, &arg1)) 3234 return NULL; 3235 if ((arg2 = PyMem_NEW(short , arg1 )) == NULL) 3236 return PyErr_NoMemory(); 3237 if (!getishortarray(args, 1, 0, arg1 , arg2)) 3238 return NULL; 3239 gewrite( arg1 , arg2 ); 3240 PyMem_DEL(arg2); 3241 Py_INCREF(Py_None); 3242 return Py_None; 3243 } 3244 3245 /* void rotate short s char s */ 3246 3247 static PyObject * 3248 gl_rotate(PyObject *self, PyObject *args) 3249 { 3250 short arg1 ; 3251 char arg2 ; 3252 if (!getishortarg(args, 2, 0, &arg1)) 3253 return NULL; 3254 if (!getichararg(args, 2, 1, &arg2)) 3255 return NULL; 3256 rotate( arg1 , arg2 ); 3257 Py_INCREF(Py_None); 3258 return Py_None; 3259 } 3260 3261 /* void rot float s char s */ 3262 3263 static PyObject * 3264 gl_rot(PyObject *self, PyObject *args) 3265 { 3266 float arg1 ; 3267 char arg2 ; 3268 if (!getifloatarg(args, 2, 0, &arg1)) 3269 return NULL; 3270 if (!getichararg(args, 2, 1, &arg2)) 3271 return NULL; 3272 rot( arg1 , arg2 ); 3273 Py_INCREF(Py_None); 3274 return Py_None; 3275 } 3276 3277 /* void circfi long s long s long s */ 3278 3279 static PyObject * 3280 gl_circfi(PyObject *self, PyObject *args) 3281 { 3282 long arg1 ; 3283 long arg2 ; 3284 long arg3 ; 3285 if (!getilongarg(args, 3, 0, &arg1)) 3286 return NULL; 3287 if (!getilongarg(args, 3, 1, &arg2)) 3288 return NULL; 3289 if (!getilongarg(args, 3, 2, &arg3)) 3290 return NULL; 3291 circfi( arg1 , arg2 , arg3 ); 3292 Py_INCREF(Py_None); 3293 return Py_None; 3294 } 3295 3296 /* void circi long s long s long s */ 3297 3298 static PyObject * 3299 gl_circi(PyObject *self, PyObject *args) 3300 { 3301 long arg1 ; 3302 long arg2 ; 3303 long arg3 ; 3304 if (!getilongarg(args, 3, 0, &arg1)) 3305 return NULL; 3306 if (!getilongarg(args, 3, 1, &arg2)) 3307 return NULL; 3308 if (!getilongarg(args, 3, 2, &arg3)) 3309 return NULL; 3310 circi( arg1 , arg2 , arg3 ); 3311 Py_INCREF(Py_None); 3312 return Py_None; 3313 } 3314 3315 /* void cmovi long s long s long s */ 3316 3317 static PyObject * 3318 gl_cmovi(PyObject *self, PyObject *args) 3319 { 3320 long arg1 ; 3321 long arg2 ; 3322 long arg3 ; 3323 if (!getilongarg(args, 3, 0, &arg1)) 3324 return NULL; 3325 if (!getilongarg(args, 3, 1, &arg2)) 3326 return NULL; 3327 if (!getilongarg(args, 3, 2, &arg3)) 3328 return NULL; 3329 cmovi( arg1 , arg2 , arg3 ); 3330 Py_INCREF(Py_None); 3331 return Py_None; 3332 } 3333 3334 /* void drawi long s long s long s */ 3335 3336 static PyObject * 3337 gl_drawi(PyObject *self, PyObject *args) 3338 { 3339 long arg1 ; 3340 long arg2 ; 3341 long arg3 ; 3342 if (!getilongarg(args, 3, 0, &arg1)) 3343 return NULL; 3344 if (!getilongarg(args, 3, 1, &arg2)) 3345 return NULL; 3346 if (!getilongarg(args, 3, 2, &arg3)) 3347 return NULL; 3348 drawi( arg1 , arg2 , arg3 ); 3349 Py_INCREF(Py_None); 3350 return Py_None; 3351 } 3352 3353 /* void movei long s long s long s */ 3354 3355 static PyObject * 3356 gl_movei(PyObject *self, PyObject *args) 3357 { 3358 long arg1 ; 3359 long arg2 ; 3360 long arg3 ; 3361 if (!getilongarg(args, 3, 0, &arg1)) 3362 return NULL; 3363 if (!getilongarg(args, 3, 1, &arg2)) 3364 return NULL; 3365 if (!getilongarg(args, 3, 2, &arg3)) 3366 return NULL; 3367 movei( arg1 , arg2 , arg3 ); 3368 Py_INCREF(Py_None); 3369 return Py_None; 3370 } 3371 3372 /* void pnti long s long s long s */ 3373 3374 static PyObject * 3375 gl_pnti(PyObject *self, PyObject *args) 3376 { 3377 long arg1 ; 3378 long arg2 ; 3379 long arg3 ; 3380 if (!getilongarg(args, 3, 0, &arg1)) 3381 return NULL; 3382 if (!getilongarg(args, 3, 1, &arg2)) 3383 return NULL; 3384 if (!getilongarg(args, 3, 2, &arg3)) 3385 return NULL; 3386 pnti( arg1 , arg2 , arg3 ); 3387 Py_INCREF(Py_None); 3388 return Py_None; 3389 } 3390 3391 /* void newtag long s long s long s */ 3392 3393 static PyObject * 3394 gl_newtag(PyObject *self, PyObject *args) 3395 { 3396 long arg1 ; 3397 long arg2 ; 3398 long arg3 ; 3399 if (!getilongarg(args, 3, 0, &arg1)) 3400 return NULL; 3401 if (!getilongarg(args, 3, 1, &arg2)) 3402 return NULL; 3403 if (!getilongarg(args, 3, 2, &arg3)) 3404 return NULL; 3405 newtag( arg1 , arg2 , arg3 ); 3406 Py_INCREF(Py_None); 3407 return Py_None; 3408 } 3409 3410 /* void pdri long s long s long s */ 3411 3412 static PyObject * 3413 gl_pdri(PyObject *self, PyObject *args) 3414 { 3415 long arg1 ; 3416 long arg2 ; 3417 long arg3 ; 3418 if (!getilongarg(args, 3, 0, &arg1)) 3419 return NULL; 3420 if (!getilongarg(args, 3, 1, &arg2)) 3421 return NULL; 3422 if (!getilongarg(args, 3, 2, &arg3)) 3423 return NULL; 3424 pdri( arg1 , arg2 , arg3 ); 3425 Py_INCREF(Py_None); 3426 return Py_None; 3427 } 3428 3429 /* void pmvi long s long s long s */ 3430 3431 static PyObject * 3432 gl_pmvi(PyObject *self, PyObject *args) 3433 { 3434 long arg1 ; 3435 long arg2 ; 3436 long arg3 ; 3437 if (!getilongarg(args, 3, 0, &arg1)) 3438 return NULL; 3439 if (!getilongarg(args, 3, 1, &arg2)) 3440 return NULL; 3441 if (!getilongarg(args, 3, 2, &arg3)) 3442 return NULL; 3443 pmvi( arg1 , arg2 , arg3 ); 3444 Py_INCREF(Py_None); 3445 return Py_None; 3446 } 3447 3448 /* void rdri long s long s long s */ 3449 3450 static PyObject * 3451 gl_rdri(PyObject *self, PyObject *args) 3452 { 3453 long arg1 ; 3454 long arg2 ; 3455 long arg3 ; 3456 if (!getilongarg(args, 3, 0, &arg1)) 3457 return NULL; 3458 if (!getilongarg(args, 3, 1, &arg2)) 3459 return NULL; 3460 if (!getilongarg(args, 3, 2, &arg3)) 3461 return NULL; 3462 rdri( arg1 , arg2 , arg3 ); 3463 Py_INCREF(Py_None); 3464 return Py_None; 3465 } 3466 3467 /* void rmvi long s long s long s */ 3468 3469 static PyObject * 3470 gl_rmvi(PyObject *self, PyObject *args) 3471 { 3472 long arg1 ; 3473 long arg2 ; 3474 long arg3 ; 3475 if (!getilongarg(args, 3, 0, &arg1)) 3476 return NULL; 3477 if (!getilongarg(args, 3, 1, &arg2)) 3478 return NULL; 3479 if (!getilongarg(args, 3, 2, &arg3)) 3480 return NULL; 3481 rmvi( arg1 , arg2 , arg3 ); 3482 Py_INCREF(Py_None); 3483 return Py_None; 3484 } 3485 3486 /* void rpdri long s long s long s */ 3487 3488 static PyObject * 3489 gl_rpdri(PyObject *self, PyObject *args) 3490 { 3491 long arg1 ; 3492 long arg2 ; 3493 long arg3 ; 3494 if (!getilongarg(args, 3, 0, &arg1)) 3495 return NULL; 3496 if (!getilongarg(args, 3, 1, &arg2)) 3497 return NULL; 3498 if (!getilongarg(args, 3, 2, &arg3)) 3499 return NULL; 3500 rpdri( arg1 , arg2 , arg3 ); 3501 Py_INCREF(Py_None); 3502 return Py_None; 3503 } 3504 3505 /* void rpmvi long s long s long s */ 3506 3507 static PyObject * 3508 gl_rpmvi(PyObject *self, PyObject *args) 3509 { 3510 long arg1 ; 3511 long arg2 ; 3512 long arg3 ; 3513 if (!getilongarg(args, 3, 0, &arg1)) 3514 return NULL; 3515 if (!getilongarg(args, 3, 1, &arg2)) 3516 return NULL; 3517 if (!getilongarg(args, 3, 2, &arg3)) 3518 return NULL; 3519 rpmvi( arg1 , arg2 , arg3 ); 3520 Py_INCREF(Py_None); 3521 return Py_None; 3522 } 3523 3524 /* void xfpti long s long s long s */ 3525 3526 static PyObject * 3527 gl_xfpti(PyObject *self, PyObject *args) 3528 { 3529 long arg1 ; 3530 long arg2 ; 3531 long arg3 ; 3532 if (!getilongarg(args, 3, 0, &arg1)) 3533 return NULL; 3534 if (!getilongarg(args, 3, 1, &arg2)) 3535 return NULL; 3536 if (!getilongarg(args, 3, 2, &arg3)) 3537 return NULL; 3538 xfpti( arg1 , arg2 , arg3 ); 3539 Py_INCREF(Py_None); 3540 return Py_None; 3541 } 3542 3543 /* void circ float s float s float s */ 3544 3545 static PyObject * 3546 gl_circ(PyObject *self, PyObject *args) 3547 { 3548 float arg1 ; 3549 float arg2 ; 3550 float arg3 ; 3551 if (!getifloatarg(args, 3, 0, &arg1)) 3552 return NULL; 3553 if (!getifloatarg(args, 3, 1, &arg2)) 3554 return NULL; 3555 if (!getifloatarg(args, 3, 2, &arg3)) 3556 return NULL; 3557 circ( arg1 , arg2 , arg3 ); 3558 Py_INCREF(Py_None); 3559 return Py_None; 3560 } 3561 3562 /* void circf float s float s float s */ 3563 3564 static PyObject * 3565 gl_circf(PyObject *self, PyObject *args) 3566 { 3567 float arg1 ; 3568 float arg2 ; 3569 float arg3 ; 3570 if (!getifloatarg(args, 3, 0, &arg1)) 3571 return NULL; 3572 if (!getifloatarg(args, 3, 1, &arg2)) 3573 return NULL; 3574 if (!getifloatarg(args, 3, 2, &arg3)) 3575 return NULL; 3576 circf( arg1 , arg2 , arg3 ); 3577 Py_INCREF(Py_None); 3578 return Py_None; 3579 } 3580 3581 /* void cmov float s float s float s */ 3582 3583 static PyObject * 3584 gl_cmov(PyObject *self, PyObject *args) 3585 { 3586 float arg1 ; 3587 float arg2 ; 3588 float arg3 ; 3589 if (!getifloatarg(args, 3, 0, &arg1)) 3590 return NULL; 3591 if (!getifloatarg(args, 3, 1, &arg2)) 3592 return NULL; 3593 if (!getifloatarg(args, 3, 2, &arg3)) 3594 return NULL; 3595 cmov( arg1 , arg2 , arg3 ); 3596 Py_INCREF(Py_None); 3597 return Py_None; 3598 } 3599 3600 /* void draw float s float s float s */ 3601 3602 static PyObject * 3603 gl_draw(PyObject *self, PyObject *args) 3604 { 3605 float arg1 ; 3606 float arg2 ; 3607 float arg3 ; 3608 if (!getifloatarg(args, 3, 0, &arg1)) 3609 return NULL; 3610 if (!getifloatarg(args, 3, 1, &arg2)) 3611 return NULL; 3612 if (!getifloatarg(args, 3, 2, &arg3)) 3613 return NULL; 3614 draw( arg1 , arg2 , arg3 ); 3615 Py_INCREF(Py_None); 3616 return Py_None; 3617 } 3618 3619 /* void move float s float s float s */ 3620 3621 static PyObject * 3622 gl_move(PyObject *self, PyObject *args) 3623 { 3624 float arg1 ; 3625 float arg2 ; 3626 float arg3 ; 3627 if (!getifloatarg(args, 3, 0, &arg1)) 3628 return NULL; 3629 if (!getifloatarg(args, 3, 1, &arg2)) 3630 return NULL; 3631 if (!getifloatarg(args, 3, 2, &arg3)) 3632 return NULL; 3633 move( arg1 , arg2 , arg3 ); 3634 Py_INCREF(Py_None); 3635 return Py_None; 3636 } 3637 3638 /* void pnt float s float s float s */ 3639 3640 static PyObject * 3641 gl_pnt(PyObject *self, PyObject *args) 3642 { 3643 float arg1 ; 3644 float arg2 ; 3645 float arg3 ; 3646 if (!getifloatarg(args, 3, 0, &arg1)) 3647 return NULL; 3648 if (!getifloatarg(args, 3, 1, &arg2)) 3649 return NULL; 3650 if (!getifloatarg(args, 3, 2, &arg3)) 3651 return NULL; 3652 pnt( arg1 , arg2 , arg3 ); 3653 Py_INCREF(Py_None); 3654 return Py_None; 3655 } 3656 3657 /* void scale float s float s float s */ 3658 3659 static PyObject * 3660 gl_scale(PyObject *self, PyObject *args) 3661 { 3662 float arg1 ; 3663 float arg2 ; 3664 float arg3 ; 3665 if (!getifloatarg(args, 3, 0, &arg1)) 3666 return NULL; 3667 if (!getifloatarg(args, 3, 1, &arg2)) 3668 return NULL; 3669 if (!getifloatarg(args, 3, 2, &arg3)) 3670 return NULL; 3671 scale( arg1 , arg2 , arg3 ); 3672 Py_INCREF(Py_None); 3673 return Py_None; 3674 } 3675 3676 /* void translate float s float s float s */ 3677 3678 static PyObject * 3679 gl_translate(PyObject *self, PyObject *args) 3680 { 3681 float arg1 ; 3682 float arg2 ; 3683 float arg3 ; 3684 if (!getifloatarg(args, 3, 0, &arg1)) 3685 return NULL; 3686 if (!getifloatarg(args, 3, 1, &arg2)) 3687 return NULL; 3688 if (!getifloatarg(args, 3, 2, &arg3)) 3689 return NULL; 3690 translate( arg1 , arg2 , arg3 ); 3691 Py_INCREF(Py_None); 3692 return Py_None; 3693 } 3694 3695 /* void pdr float s float s float s */ 3696 3697 static PyObject * 3698 gl_pdr(PyObject *self, PyObject *args) 3699 { 3700 float arg1 ; 3701 float arg2 ; 3702 float arg3 ; 3703 if (!getifloatarg(args, 3, 0, &arg1)) 3704 return NULL; 3705 if (!getifloatarg(args, 3, 1, &arg2)) 3706 return NULL; 3707 if (!getifloatarg(args, 3, 2, &arg3)) 3708 return NULL; 3709 pdr( arg1 , arg2 , arg3 ); 3710 Py_INCREF(Py_None); 3711 return Py_None; 3712 } 3713 3714 /* void pmv float s float s float s */ 3715 3716 static PyObject * 3717 gl_pmv(PyObject *self, PyObject *args) 3718 { 3719 float arg1 ; 3720 float arg2 ; 3721 float arg3 ; 3722 if (!getifloatarg(args, 3, 0, &arg1)) 3723 return NULL; 3724 if (!getifloatarg(args, 3, 1, &arg2)) 3725 return NULL; 3726 if (!getifloatarg(args, 3, 2, &arg3)) 3727 return NULL; 3728 pmv( arg1 , arg2 , arg3 ); 3729 Py_INCREF(Py_None); 3730 return Py_None; 3731 } 3732 3733 /* void rdr float s float s float s */ 3734 3735 static PyObject * 3736 gl_rdr(PyObject *self, PyObject *args) 3737 { 3738 float arg1 ; 3739 float arg2 ; 3740 float arg3 ; 3741 if (!getifloatarg(args, 3, 0, &arg1)) 3742 return NULL; 3743 if (!getifloatarg(args, 3, 1, &arg2)) 3744 return NULL; 3745 if (!getifloatarg(args, 3, 2, &arg3)) 3746 return NULL; 3747 rdr( arg1 , arg2 , arg3 ); 3748 Py_INCREF(Py_None); 3749 return Py_None; 3750 } 3751 3752 /* void rmv float s float s float s */ 3753 3754 static PyObject * 3755 gl_rmv(PyObject *self, PyObject *args) 3756 { 3757 float arg1 ; 3758 float arg2 ; 3759 float arg3 ; 3760 if (!getifloatarg(args, 3, 0, &arg1)) 3761 return NULL; 3762 if (!getifloatarg(args, 3, 1, &arg2)) 3763 return NULL; 3764 if (!getifloatarg(args, 3, 2, &arg3)) 3765 return NULL; 3766 rmv( arg1 , arg2 , arg3 ); 3767 Py_INCREF(Py_None); 3768 return Py_None; 3769 } 3770 3771 /* void rpdr float s float s float s */ 3772 3773 static PyObject * 3774 gl_rpdr(PyObject *self, PyObject *args) 3775 { 3776 float arg1 ; 3777 float arg2 ; 3778 float arg3 ; 3779 if (!getifloatarg(args, 3, 0, &arg1)) 3780 return NULL; 3781 if (!getifloatarg(args, 3, 1, &arg2)) 3782 return NULL; 3783 if (!getifloatarg(args, 3, 2, &arg3)) 3784 return NULL; 3785 rpdr( arg1 , arg2 , arg3 ); 3786 Py_INCREF(Py_None); 3787 return Py_None; 3788 } 3789 3790 /* void rpmv float s float s float s */ 3791 3792 static PyObject * 3793 gl_rpmv(PyObject *self, PyObject *args) 3794 { 3795 float arg1 ; 3796 float arg2 ; 3797 float arg3 ; 3798 if (!getifloatarg(args, 3, 0, &arg1)) 3799 return NULL; 3800 if (!getifloatarg(args, 3, 1, &arg2)) 3801 return NULL; 3802 if (!getifloatarg(args, 3, 2, &arg3)) 3803 return NULL; 3804 rpmv( arg1 , arg2 , arg3 ); 3805 Py_INCREF(Py_None); 3806 return Py_None; 3807 } 3808 3809 /* void xfpt float s float s float s */ 3810 3811 static PyObject * 3812 gl_xfpt(PyObject *self, PyObject *args) 3813 { 3814 float arg1 ; 3815 float arg2 ; 3816 float arg3 ; 3817 if (!getifloatarg(args, 3, 0, &arg1)) 3818 return NULL; 3819 if (!getifloatarg(args, 3, 1, &arg2)) 3820 return NULL; 3821 if (!getifloatarg(args, 3, 2, &arg3)) 3822 return NULL; 3823 xfpt( arg1 , arg2 , arg3 ); 3824 Py_INCREF(Py_None); 3825 return Py_None; 3826 } 3827 3828 /* void RGBcolor short s short s short s */ 3829 3830 static PyObject * 3831 gl_RGBcolor(PyObject *self, PyObject *args) 3832 { 3833 short arg1 ; 3834 short arg2 ; 3835 short arg3 ; 3836 if (!getishortarg(args, 3, 0, &arg1)) 3837 return NULL; 3838 if (!getishortarg(args, 3, 1, &arg2)) 3839 return NULL; 3840 if (!getishortarg(args, 3, 2, &arg3)) 3841 return NULL; 3842 RGBcolor( arg1 , arg2 , arg3 ); 3843 Py_INCREF(Py_None); 3844 return Py_None; 3845 } 3846 3847 /* void RGBwritemask short s short s short s */ 3848 3849 static PyObject * 3850 gl_RGBwritemask(PyObject *self, PyObject *args) 3851 { 3852 short arg1 ; 3853 short arg2 ; 3854 short arg3 ; 3855 if (!getishortarg(args, 3, 0, &arg1)) 3856 return NULL; 3857 if (!getishortarg(args, 3, 1, &arg2)) 3858 return NULL; 3859 if (!getishortarg(args, 3, 2, &arg3)) 3860 return NULL; 3861 RGBwritemask( arg1 , arg2 , arg3 ); 3862 Py_INCREF(Py_None); 3863 return Py_None; 3864 } 3865 3866 /* void setcursor short s short s short s */ 3867 3868 static PyObject * 3869 gl_setcursor(PyObject *self, PyObject *args) 3870 { 3871 short arg1 ; 3872 short arg2 ; 3873 short arg3 ; 3874 if (!getishortarg(args, 3, 0, &arg1)) 3875 return NULL; 3876 if (!getishortarg(args, 3, 1, &arg2)) 3877 return NULL; 3878 if (!getishortarg(args, 3, 2, &arg3)) 3879 return NULL; 3880 setcursor( arg1 , arg2 , arg3 ); 3881 Py_INCREF(Py_None); 3882 return Py_None; 3883 } 3884 3885 /* void tie short s short s short s */ 3886 3887 static PyObject * 3888 gl_tie(PyObject *self, PyObject *args) 3889 { 3890 short arg1 ; 3891 short arg2 ; 3892 short arg3 ; 3893 if (!getishortarg(args, 3, 0, &arg1)) 3894 return NULL; 3895 if (!getishortarg(args, 3, 1, &arg2)) 3896 return NULL; 3897 if (!getishortarg(args, 3, 2, &arg3)) 3898 return NULL; 3899 tie( arg1 , arg2 , arg3 ); 3900 Py_INCREF(Py_None); 3901 return Py_None; 3902 } 3903 3904 /* void circfs short s short s short s */ 3905 3906 static PyObject * 3907 gl_circfs(PyObject *self, PyObject *args) 3908 { 3909 short arg1 ; 3910 short arg2 ; 3911 short arg3 ; 3912 if (!getishortarg(args, 3, 0, &arg1)) 3913 return NULL; 3914 if (!getishortarg(args, 3, 1, &arg2)) 3915 return NULL; 3916 if (!getishortarg(args, 3, 2, &arg3)) 3917 return NULL; 3918 circfs( arg1 , arg2 , arg3 ); 3919 Py_INCREF(Py_None); 3920 return Py_None; 3921 } 3922 3923 /* void circs short s short s short s */ 3924 3925 static PyObject * 3926 gl_circs(PyObject *self, PyObject *args) 3927 { 3928 short arg1 ; 3929 short arg2 ; 3930 short arg3 ; 3931 if (!getishortarg(args, 3, 0, &arg1)) 3932 return NULL; 3933 if (!getishortarg(args, 3, 1, &arg2)) 3934 return NULL; 3935 if (!getishortarg(args, 3, 2, &arg3)) 3936 return NULL; 3937 circs( arg1 , arg2 , arg3 ); 3938 Py_INCREF(Py_None); 3939 return Py_None; 3940 } 3941 3942 /* void cmovs short s short s short s */ 3943 3944 static PyObject * 3945 gl_cmovs(PyObject *self, PyObject *args) 3946 { 3947 short arg1 ; 3948 short arg2 ; 3949 short arg3 ; 3950 if (!getishortarg(args, 3, 0, &arg1)) 3951 return NULL; 3952 if (!getishortarg(args, 3, 1, &arg2)) 3953 return NULL; 3954 if (!getishortarg(args, 3, 2, &arg3)) 3955 return NULL; 3956 cmovs( arg1 , arg2 , arg3 ); 3957 Py_INCREF(Py_None); 3958 return Py_None; 3959 } 3960 3961 /* void draws short s short s short s */ 3962 3963 static PyObject * 3964 gl_draws(PyObject *self, PyObject *args) 3965 { 3966 short arg1 ; 3967 short arg2 ; 3968 short arg3 ; 3969 if (!getishortarg(args, 3, 0, &arg1)) 3970 return NULL; 3971 if (!getishortarg(args, 3, 1, &arg2)) 3972 return NULL; 3973 if (!getishortarg(args, 3, 2, &arg3)) 3974 return NULL; 3975 draws( arg1 , arg2 , arg3 ); 3976 Py_INCREF(Py_None); 3977 return Py_None; 3978 } 3979 3980 /* void moves short s short s short s */ 3981 3982 static PyObject * 3983 gl_moves(PyObject *self, PyObject *args) 3984 { 3985 short arg1 ; 3986 short arg2 ; 3987 short arg3 ; 3988 if (!getishortarg(args, 3, 0, &arg1)) 3989 return NULL; 3990 if (!getishortarg(args, 3, 1, &arg2)) 3991 return NULL; 3992 if (!getishortarg(args, 3, 2, &arg3)) 3993 return NULL; 3994 moves( arg1 , arg2 , arg3 ); 3995 Py_INCREF(Py_None); 3996 return Py_None; 3997 } 3998 3999 /* void pdrs short s short s short s */ 4000 4001 static PyObject * 4002 gl_pdrs(PyObject *self, PyObject *args) 4003 { 4004 short arg1 ; 4005 short arg2 ; 4006 short arg3 ; 4007 if (!getishortarg(args, 3, 0, &arg1)) 4008 return NULL; 4009 if (!getishortarg(args, 3, 1, &arg2)) 4010 return NULL; 4011 if (!getishortarg(args, 3, 2, &arg3)) 4012 return NULL; 4013 pdrs( arg1 , arg2 , arg3 ); 4014 Py_INCREF(Py_None); 4015 return Py_None; 4016 } 4017 4018 /* void pmvs short s short s short s */ 4019 4020 static PyObject * 4021 gl_pmvs(PyObject *self, PyObject *args) 4022 { 4023 short arg1 ; 4024 short arg2 ; 4025 short arg3 ; 4026 if (!getishortarg(args, 3, 0, &arg1)) 4027 return NULL; 4028 if (!getishortarg(args, 3, 1, &arg2)) 4029 return NULL; 4030 if (!getishortarg(args, 3, 2, &arg3)) 4031 return NULL; 4032 pmvs( arg1 , arg2 , arg3 ); 4033 Py_INCREF(Py_None); 4034 return Py_None; 4035 } 4036 4037 /* void pnts short s short s short s */ 4038 4039 static PyObject * 4040 gl_pnts(PyObject *self, PyObject *args) 4041 { 4042 short arg1 ; 4043 short arg2 ; 4044 short arg3 ; 4045 if (!getishortarg(args, 3, 0, &arg1)) 4046 return NULL; 4047 if (!getishortarg(args, 3, 1, &arg2)) 4048 return NULL; 4049 if (!getishortarg(args, 3, 2, &arg3)) 4050 return NULL; 4051 pnts( arg1 , arg2 , arg3 ); 4052 Py_INCREF(Py_None); 4053 return Py_None; 4054 } 4055 4056 /* void rdrs short s short s short s */ 4057 4058 static PyObject * 4059 gl_rdrs(PyObject *self, PyObject *args) 4060 { 4061 short arg1 ; 4062 short arg2 ; 4063 short arg3 ; 4064 if (!getishortarg(args, 3, 0, &arg1)) 4065 return NULL; 4066 if (!getishortarg(args, 3, 1, &arg2)) 4067 return NULL; 4068 if (!getishortarg(args, 3, 2, &arg3)) 4069 return NULL; 4070 rdrs( arg1 , arg2 , arg3 ); 4071 Py_INCREF(Py_None); 4072 return Py_None; 4073 } 4074 4075 /* void rmvs short s short s short s */ 4076 4077 static PyObject * 4078 gl_rmvs(PyObject *self, PyObject *args) 4079 { 4080 short arg1 ; 4081 short arg2 ; 4082 short arg3 ; 4083 if (!getishortarg(args, 3, 0, &arg1)) 4084 return NULL; 4085 if (!getishortarg(args, 3, 1, &arg2)) 4086 return NULL; 4087 if (!getishortarg(args, 3, 2, &arg3)) 4088 return NULL; 4089 rmvs( arg1 , arg2 , arg3 ); 4090 Py_INCREF(Py_None); 4091 return Py_None; 4092 } 4093 4094 /* void rpdrs short s short s short s */ 4095 4096 static PyObject * 4097 gl_rpdrs(PyObject *self, PyObject *args) 4098 { 4099 short arg1 ; 4100 short arg2 ; 4101 short arg3 ; 4102 if (!getishortarg(args, 3, 0, &arg1)) 4103 return NULL; 4104 if (!getishortarg(args, 3, 1, &arg2)) 4105 return NULL; 4106 if (!getishortarg(args, 3, 2, &arg3)) 4107 return NULL; 4108 rpdrs( arg1 , arg2 , arg3 ); 4109 Py_INCREF(Py_None); 4110 return Py_None; 4111 } 4112 4113 /* void rpmvs short s short s short s */ 4114 4115 static PyObject * 4116 gl_rpmvs(PyObject *self, PyObject *args) 4117 { 4118 short arg1 ; 4119 short arg2 ; 4120 short arg3 ; 4121 if (!getishortarg(args, 3, 0, &arg1)) 4122 return NULL; 4123 if (!getishortarg(args, 3, 1, &arg2)) 4124 return NULL; 4125 if (!getishortarg(args, 3, 2, &arg3)) 4126 return NULL; 4127 rpmvs( arg1 , arg2 , arg3 ); 4128 Py_INCREF(Py_None); 4129 return Py_None; 4130 } 4131 4132 /* void xfpts short s short s short s */ 4133 4134 static PyObject * 4135 gl_xfpts(PyObject *self, PyObject *args) 4136 { 4137 short arg1 ; 4138 short arg2 ; 4139 short arg3 ; 4140 if (!getishortarg(args, 3, 0, &arg1)) 4141 return NULL; 4142 if (!getishortarg(args, 3, 1, &arg2)) 4143 return NULL; 4144 if (!getishortarg(args, 3, 2, &arg3)) 4145 return NULL; 4146 xfpts( arg1 , arg2 , arg3 ); 4147 Py_INCREF(Py_None); 4148 return Py_None; 4149 } 4150 4151 /* void curorigin short s short s short s */ 4152 4153 static PyObject * 4154 gl_curorigin(PyObject *self, PyObject *args) 4155 { 4156 short arg1 ; 4157 short arg2 ; 4158 short arg3 ; 4159 if (!getishortarg(args, 3, 0, &arg1)) 4160 return NULL; 4161 if (!getishortarg(args, 3, 1, &arg2)) 4162 return NULL; 4163 if (!getishortarg(args, 3, 2, &arg3)) 4164 return NULL; 4165 curorigin( arg1 , arg2 , arg3 ); 4166 Py_INCREF(Py_None); 4167 return Py_None; 4168 } 4169 4170 /* void cyclemap short s short s short s */ 4171 4172 static PyObject * 4173 gl_cyclemap(PyObject *self, PyObject *args) 4174 { 4175 short arg1 ; 4176 short arg2 ; 4177 short arg3 ; 4178 if (!getishortarg(args, 3, 0, &arg1)) 4179 return NULL; 4180 if (!getishortarg(args, 3, 1, &arg2)) 4181 return NULL; 4182 if (!getishortarg(args, 3, 2, &arg3)) 4183 return NULL; 4184 cyclemap( arg1 , arg2 , arg3 ); 4185 Py_INCREF(Py_None); 4186 return Py_None; 4187 } 4188 4189 /* void patch float s[4*4] float s[4*4] float s[4*4] */ 4190 4191 static PyObject * 4192 gl_patch(PyObject *self, PyObject *args) 4193 { 4194 float arg1 [ 4 ] [ 4 ] ; 4195 float arg2 [ 4 ] [ 4 ] ; 4196 float arg3 [ 4 ] [ 4 ] ; 4197 if (!getifloatarray(args, 3, 0, 4 * 4 , (float *) arg1)) 4198 return NULL; 4199 if (!getifloatarray(args, 3, 1, 4 * 4 , (float *) arg2)) 4200 return NULL; 4201 if (!getifloatarray(args, 3, 2, 4 * 4 , (float *) arg3)) 4202 return NULL; 4203 patch( arg1 , arg2 , arg3 ); 4204 Py_INCREF(Py_None); 4205 return Py_None; 4206 } 4207 4208 /* void splf long s float s[3*arg1] u_short s[arg1] */ 4209 4210 static PyObject * 4211 gl_splf(PyObject *self, PyObject *args) 4212 { 4213 long arg1 ; 4214 float (* arg2) [ 3 ] ; 4215 unsigned short * arg3 ; 4216 if (!getilongarraysize(args, 2, 0, &arg1)) 4217 return NULL; 4218 arg1 = arg1 / 3; 4219 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) 4220 return PyErr_NoMemory(); 4221 if (!getifloatarray(args, 2, 0, 3 * arg1 , (float *) arg2)) 4222 return NULL; 4223 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4224 return PyErr_NoMemory(); 4225 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4226 return NULL; 4227 splf( arg1 , arg2 , arg3 ); 4228 PyMem_DEL(arg2); 4229 PyMem_DEL(arg3); 4230 Py_INCREF(Py_None); 4231 return Py_None; 4232 } 4233 4234 /* void splf2 long s float s[2*arg1] u_short s[arg1] */ 4235 4236 static PyObject * 4237 gl_splf2(PyObject *self, PyObject *args) 4238 { 4239 long arg1 ; 4240 float (* arg2) [ 2 ] ; 4241 unsigned short * arg3 ; 4242 if (!getilongarraysize(args, 2, 0, &arg1)) 4243 return NULL; 4244 arg1 = arg1 / 2; 4245 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) 4246 return PyErr_NoMemory(); 4247 if (!getifloatarray(args, 2, 0, 2 * arg1 , (float *) arg2)) 4248 return NULL; 4249 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4250 return PyErr_NoMemory(); 4251 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4252 return NULL; 4253 splf2( arg1 , arg2 , arg3 ); 4254 PyMem_DEL(arg2); 4255 PyMem_DEL(arg3); 4256 Py_INCREF(Py_None); 4257 return Py_None; 4258 } 4259 4260 /* void splfi long s long s[3*arg1] u_short s[arg1] */ 4261 4262 static PyObject * 4263 gl_splfi(PyObject *self, PyObject *args) 4264 { 4265 long arg1 ; 4266 long (* arg2) [ 3 ] ; 4267 unsigned short * arg3 ; 4268 if (!getilongarraysize(args, 2, 0, &arg1)) 4269 return NULL; 4270 arg1 = arg1 / 3; 4271 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) 4272 return PyErr_NoMemory(); 4273 if (!getilongarray(args, 2, 0, 3 * arg1 , (long *) arg2)) 4274 return NULL; 4275 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4276 return PyErr_NoMemory(); 4277 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4278 return NULL; 4279 splfi( arg1 , arg2 , arg3 ); 4280 PyMem_DEL(arg2); 4281 PyMem_DEL(arg3); 4282 Py_INCREF(Py_None); 4283 return Py_None; 4284 } 4285 4286 /* void splf2i long s long s[2*arg1] u_short s[arg1] */ 4287 4288 static PyObject * 4289 gl_splf2i(PyObject *self, PyObject *args) 4290 { 4291 long arg1 ; 4292 long (* arg2) [ 2 ] ; 4293 unsigned short * arg3 ; 4294 if (!getilongarraysize(args, 2, 0, &arg1)) 4295 return NULL; 4296 arg1 = arg1 / 2; 4297 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) 4298 return PyErr_NoMemory(); 4299 if (!getilongarray(args, 2, 0, 2 * arg1 , (long *) arg2)) 4300 return NULL; 4301 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4302 return PyErr_NoMemory(); 4303 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4304 return NULL; 4305 splf2i( arg1 , arg2 , arg3 ); 4306 PyMem_DEL(arg2); 4307 PyMem_DEL(arg3); 4308 Py_INCREF(Py_None); 4309 return Py_None; 4310 } 4311 4312 /* void splfs long s short s[3*arg1] u_short s[arg1] */ 4313 4314 static PyObject * 4315 gl_splfs(PyObject *self, PyObject *args) 4316 { 4317 long arg1 ; 4318 short (* arg2) [ 3 ] ; 4319 unsigned short * arg3 ; 4320 if (!getilongarraysize(args, 2, 0, &arg1)) 4321 return NULL; 4322 arg1 = arg1 / 3; 4323 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) 4324 return PyErr_NoMemory(); 4325 if (!getishortarray(args, 2, 0, 3 * arg1 , (short *) arg2)) 4326 return NULL; 4327 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4328 return PyErr_NoMemory(); 4329 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4330 return NULL; 4331 splfs( arg1 , arg2 , arg3 ); 4332 PyMem_DEL(arg2); 4333 PyMem_DEL(arg3); 4334 Py_INCREF(Py_None); 4335 return Py_None; 4336 } 4337 4338 /* void splf2s long s short s[2*arg1] u_short s[arg1] */ 4339 4340 static PyObject * 4341 gl_splf2s(PyObject *self, PyObject *args) 4342 { 4343 long arg1 ; 4344 short (* arg2) [ 2 ] ; 4345 unsigned short * arg3 ; 4346 if (!getilongarraysize(args, 2, 0, &arg1)) 4347 return NULL; 4348 arg1 = arg1 / 2; 4349 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) 4350 return PyErr_NoMemory(); 4351 if (!getishortarray(args, 2, 0, 2 * arg1 , (short *) arg2)) 4352 return NULL; 4353 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) 4354 return PyErr_NoMemory(); 4355 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) 4356 return NULL; 4357 splf2s( arg1 , arg2 , arg3 ); 4358 PyMem_DEL(arg2); 4359 PyMem_DEL(arg3); 4360 Py_INCREF(Py_None); 4361 return Py_None; 4362 } 4363 4364 /* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */ 4365 4366 static PyObject * 4367 gl_rpatch(PyObject *self, PyObject *args) 4368 { 4369 float arg1 [ 4 ] [ 4 ] ; 4370 float arg2 [ 4 ] [ 4 ] ; 4371 float arg3 [ 4 ] [ 4 ] ; 4372 float arg4 [ 4 ] [ 4 ] ; 4373 if (!getifloatarray(args, 4, 0, 4 * 4 , (float *) arg1)) 4374 return NULL; 4375 if (!getifloatarray(args, 4, 1, 4 * 4 , (float *) arg2)) 4376 return NULL; 4377 if (!getifloatarray(args, 4, 2, 4 * 4 , (float *) arg3)) 4378 return NULL; 4379 if (!getifloatarray(args, 4, 3, 4 * 4 , (float *) arg4)) 4380 return NULL; 4381 rpatch( arg1 , arg2 , arg3 , arg4 ); 4382 Py_INCREF(Py_None); 4383 return Py_None; 4384 } 4385 4386 /* void ortho2 float s float s float s float s */ 4387 4388 static PyObject * 4389 gl_ortho2(PyObject *self, PyObject *args) 4390 { 4391 float arg1 ; 4392 float arg2 ; 4393 float arg3 ; 4394 float arg4 ; 4395 if (!getifloatarg(args, 4, 0, &arg1)) 4396 return NULL; 4397 if (!getifloatarg(args, 4, 1, &arg2)) 4398 return NULL; 4399 if (!getifloatarg(args, 4, 2, &arg3)) 4400 return NULL; 4401 if (!getifloatarg(args, 4, 3, &arg4)) 4402 return NULL; 4403 ortho2( arg1 , arg2 , arg3 , arg4 ); 4404 Py_INCREF(Py_None); 4405 return Py_None; 4406 } 4407 4408 /* void rect float s float s float s float s */ 4409 4410 static PyObject * 4411 gl_rect(PyObject *self, PyObject *args) 4412 { 4413 float arg1 ; 4414 float arg2 ; 4415 float arg3 ; 4416 float arg4 ; 4417 if (!getifloatarg(args, 4, 0, &arg1)) 4418 return NULL; 4419 if (!getifloatarg(args, 4, 1, &arg2)) 4420 return NULL; 4421 if (!getifloatarg(args, 4, 2, &arg3)) 4422 return NULL; 4423 if (!getifloatarg(args, 4, 3, &arg4)) 4424 return NULL; 4425 rect( arg1 , arg2 , arg3 , arg4 ); 4426 Py_INCREF(Py_None); 4427 return Py_None; 4428 } 4429 4430 /* void rectf float s float s float s float s */ 4431 4432 static PyObject * 4433 gl_rectf(PyObject *self, PyObject *args) 4434 { 4435 float arg1 ; 4436 float arg2 ; 4437 float arg3 ; 4438 float arg4 ; 4439 if (!getifloatarg(args, 4, 0, &arg1)) 4440 return NULL; 4441 if (!getifloatarg(args, 4, 1, &arg2)) 4442 return NULL; 4443 if (!getifloatarg(args, 4, 2, &arg3)) 4444 return NULL; 4445 if (!getifloatarg(args, 4, 3, &arg4)) 4446 return NULL; 4447 rectf( arg1 , arg2 , arg3 , arg4 ); 4448 Py_INCREF(Py_None); 4449 return Py_None; 4450 } 4451 4452 /* void xfpt4 float s float s float s float s */ 4453 4454 static PyObject * 4455 gl_xfpt4(PyObject *self, PyObject *args) 4456 { 4457 float arg1 ; 4458 float arg2 ; 4459 float arg3 ; 4460 float arg4 ; 4461 if (!getifloatarg(args, 4, 0, &arg1)) 4462 return NULL; 4463 if (!getifloatarg(args, 4, 1, &arg2)) 4464 return NULL; 4465 if (!getifloatarg(args, 4, 2, &arg3)) 4466 return NULL; 4467 if (!getifloatarg(args, 4, 3, &arg4)) 4468 return NULL; 4469 xfpt4( arg1 , arg2 , arg3 , arg4 ); 4470 Py_INCREF(Py_None); 4471 return Py_None; 4472 } 4473 4474 /* void textport short s short s short s short s */ 4475 4476 static PyObject * 4477 gl_textport(PyObject *self, PyObject *args) 4478 { 4479 short arg1 ; 4480 short arg2 ; 4481 short arg3 ; 4482 short arg4 ; 4483 if (!getishortarg(args, 4, 0, &arg1)) 4484 return NULL; 4485 if (!getishortarg(args, 4, 1, &arg2)) 4486 return NULL; 4487 if (!getishortarg(args, 4, 2, &arg3)) 4488 return NULL; 4489 if (!getishortarg(args, 4, 3, &arg4)) 4490 return NULL; 4491 textport( arg1 , arg2 , arg3 , arg4 ); 4492 Py_INCREF(Py_None); 4493 return Py_None; 4494 } 4495 4496 /* void mapcolor short s short s short s short s */ 4497 4498 static PyObject * 4499 gl_mapcolor(PyObject *self, PyObject *args) 4500 { 4501 short arg1 ; 4502 short arg2 ; 4503 short arg3 ; 4504 short arg4 ; 4505 if (!getishortarg(args, 4, 0, &arg1)) 4506 return NULL; 4507 if (!getishortarg(args, 4, 1, &arg2)) 4508 return NULL; 4509 if (!getishortarg(args, 4, 2, &arg3)) 4510 return NULL; 4511 if (!getishortarg(args, 4, 3, &arg4)) 4512 return NULL; 4513 mapcolor( arg1 , arg2 , arg3 , arg4 ); 4514 Py_INCREF(Py_None); 4515 return Py_None; 4516 } 4517 4518 /* void scrmask short s short s short s short s */ 4519 4520 static PyObject * 4521 gl_scrmask(PyObject *self, PyObject *args) 4522 { 4523 short arg1 ; 4524 short arg2 ; 4525 short arg3 ; 4526 short arg4 ; 4527 if (!getishortarg(args, 4, 0, &arg1)) 4528 return NULL; 4529 if (!getishortarg(args, 4, 1, &arg2)) 4530 return NULL; 4531 if (!getishortarg(args, 4, 2, &arg3)) 4532 return NULL; 4533 if (!getishortarg(args, 4, 3, &arg4)) 4534 return NULL; 4535 scrmask( arg1 , arg2 , arg3 , arg4 ); 4536 Py_INCREF(Py_None); 4537 return Py_None; 4538 } 4539 4540 /* void setvaluator short s short s short s short s */ 4541 4542 static PyObject * 4543 gl_setvaluator(PyObject *self, PyObject *args) 4544 { 4545 short arg1 ; 4546 short arg2 ; 4547 short arg3 ; 4548 short arg4 ; 4549 if (!getishortarg(args, 4, 0, &arg1)) 4550 return NULL; 4551 if (!getishortarg(args, 4, 1, &arg2)) 4552 return NULL; 4553 if (!getishortarg(args, 4, 2, &arg3)) 4554 return NULL; 4555 if (!getishortarg(args, 4, 3, &arg4)) 4556 return NULL; 4557 setvaluator( arg1 , arg2 , arg3 , arg4 ); 4558 Py_INCREF(Py_None); 4559 return Py_None; 4560 } 4561 4562 /* void viewport short s short s short s short s */ 4563 4564 static PyObject * 4565 gl_viewport(PyObject *self, PyObject *args) 4566 { 4567 short arg1 ; 4568 short arg2 ; 4569 short arg3 ; 4570 short arg4 ; 4571 if (!getishortarg(args, 4, 0, &arg1)) 4572 return NULL; 4573 if (!getishortarg(args, 4, 1, &arg2)) 4574 return NULL; 4575 if (!getishortarg(args, 4, 2, &arg3)) 4576 return NULL; 4577 if (!getishortarg(args, 4, 3, &arg4)) 4578 return NULL; 4579 viewport( arg1 , arg2 , arg3 , arg4 ); 4580 Py_INCREF(Py_None); 4581 return Py_None; 4582 } 4583 4584 /* void shaderange short s short s short s short s */ 4585 4586 static PyObject * 4587 gl_shaderange(PyObject *self, PyObject *args) 4588 { 4589 short arg1 ; 4590 short arg2 ; 4591 short arg3 ; 4592 short arg4 ; 4593 if (!getishortarg(args, 4, 0, &arg1)) 4594 return NULL; 4595 if (!getishortarg(args, 4, 1, &arg2)) 4596 return NULL; 4597 if (!getishortarg(args, 4, 2, &arg3)) 4598 return NULL; 4599 if (!getishortarg(args, 4, 3, &arg4)) 4600 return NULL; 4601 shaderange( arg1 , arg2 , arg3 , arg4 ); 4602 Py_INCREF(Py_None); 4603 return Py_None; 4604 } 4605 4606 /* void xfpt4s short s short s short s short s */ 4607 4608 static PyObject * 4609 gl_xfpt4s(PyObject *self, PyObject *args) 4610 { 4611 short arg1 ; 4612 short arg2 ; 4613 short arg3 ; 4614 short arg4 ; 4615 if (!getishortarg(args, 4, 0, &arg1)) 4616 return NULL; 4617 if (!getishortarg(args, 4, 1, &arg2)) 4618 return NULL; 4619 if (!getishortarg(args, 4, 2, &arg3)) 4620 return NULL; 4621 if (!getishortarg(args, 4, 3, &arg4)) 4622 return NULL; 4623 xfpt4s( arg1 , arg2 , arg3 , arg4 ); 4624 Py_INCREF(Py_None); 4625 return Py_None; 4626 } 4627 4628 /* void rectfi long s long s long s long s */ 4629 4630 static PyObject * 4631 gl_rectfi(PyObject *self, PyObject *args) 4632 { 4633 long arg1 ; 4634 long arg2 ; 4635 long arg3 ; 4636 long arg4 ; 4637 if (!getilongarg(args, 4, 0, &arg1)) 4638 return NULL; 4639 if (!getilongarg(args, 4, 1, &arg2)) 4640 return NULL; 4641 if (!getilongarg(args, 4, 2, &arg3)) 4642 return NULL; 4643 if (!getilongarg(args, 4, 3, &arg4)) 4644 return NULL; 4645 rectfi( arg1 , arg2 , arg3 , arg4 ); 4646 Py_INCREF(Py_None); 4647 return Py_None; 4648 } 4649 4650 /* void recti long s long s long s long s */ 4651 4652 static PyObject * 4653 gl_recti(PyObject *self, PyObject *args) 4654 { 4655 long arg1 ; 4656 long arg2 ; 4657 long arg3 ; 4658 long arg4 ; 4659 if (!getilongarg(args, 4, 0, &arg1)) 4660 return NULL; 4661 if (!getilongarg(args, 4, 1, &arg2)) 4662 return NULL; 4663 if (!getilongarg(args, 4, 2, &arg3)) 4664 return NULL; 4665 if (!getilongarg(args, 4, 3, &arg4)) 4666 return NULL; 4667 recti( arg1 , arg2 , arg3 , arg4 ); 4668 Py_INCREF(Py_None); 4669 return Py_None; 4670 } 4671 4672 /* void xfpt4i long s long s long s long s */ 4673 4674 static PyObject * 4675 gl_xfpt4i(PyObject *self, PyObject *args) 4676 { 4677 long arg1 ; 4678 long arg2 ; 4679 long arg3 ; 4680 long arg4 ; 4681 if (!getilongarg(args, 4, 0, &arg1)) 4682 return NULL; 4683 if (!getilongarg(args, 4, 1, &arg2)) 4684 return NULL; 4685 if (!getilongarg(args, 4, 2, &arg3)) 4686 return NULL; 4687 if (!getilongarg(args, 4, 3, &arg4)) 4688 return NULL; 4689 xfpt4i( arg1 , arg2 , arg3 , arg4 ); 4690 Py_INCREF(Py_None); 4691 return Py_None; 4692 } 4693 4694 /* void prefposition long s long s long s long s */ 4695 4696 static PyObject * 4697 gl_prefposition(PyObject *self, PyObject *args) 4698 { 4699 long arg1 ; 4700 long arg2 ; 4701 long arg3 ; 4702 long arg4 ; 4703 if (!getilongarg(args, 4, 0, &arg1)) 4704 return NULL; 4705 if (!getilongarg(args, 4, 1, &arg2)) 4706 return NULL; 4707 if (!getilongarg(args, 4, 2, &arg3)) 4708 return NULL; 4709 if (!getilongarg(args, 4, 3, &arg4)) 4710 return NULL; 4711 prefposition( arg1 , arg2 , arg3 , arg4 ); 4712 Py_INCREF(Py_None); 4713 return Py_None; 4714 } 4715 4716 /* void arc float s float s float s short s short s */ 4717 4718 static PyObject * 4719 gl_arc(PyObject *self, PyObject *args) 4720 { 4721 float arg1 ; 4722 float arg2 ; 4723 float arg3 ; 4724 short arg4 ; 4725 short arg5 ; 4726 if (!getifloatarg(args, 5, 0, &arg1)) 4727 return NULL; 4728 if (!getifloatarg(args, 5, 1, &arg2)) 4729 return NULL; 4730 if (!getifloatarg(args, 5, 2, &arg3)) 4731 return NULL; 4732 if (!getishortarg(args, 5, 3, &arg4)) 4733 return NULL; 4734 if (!getishortarg(args, 5, 4, &arg5)) 4735 return NULL; 4736 arc( arg1 , arg2 , arg3 , arg4 , arg5 ); 4737 Py_INCREF(Py_None); 4738 return Py_None; 4739 } 4740 4741 /* void arcf float s float s float s short s short s */ 4742 4743 static PyObject * 4744 gl_arcf(PyObject *self, PyObject *args) 4745 { 4746 float arg1 ; 4747 float arg2 ; 4748 float arg3 ; 4749 short arg4 ; 4750 short arg5 ; 4751 if (!getifloatarg(args, 5, 0, &arg1)) 4752 return NULL; 4753 if (!getifloatarg(args, 5, 1, &arg2)) 4754 return NULL; 4755 if (!getifloatarg(args, 5, 2, &arg3)) 4756 return NULL; 4757 if (!getishortarg(args, 5, 3, &arg4)) 4758 return NULL; 4759 if (!getishortarg(args, 5, 4, &arg5)) 4760 return NULL; 4761 arcf( arg1 , arg2 , arg3 , arg4 , arg5 ); 4762 Py_INCREF(Py_None); 4763 return Py_None; 4764 } 4765 4766 /* void arcfi long s long s long s short s short s */ 4767 4768 static PyObject * 4769 gl_arcfi(PyObject *self, PyObject *args) 4770 { 4771 long arg1 ; 4772 long arg2 ; 4773 long arg3 ; 4774 short arg4 ; 4775 short arg5 ; 4776 if (!getilongarg(args, 5, 0, &arg1)) 4777 return NULL; 4778 if (!getilongarg(args, 5, 1, &arg2)) 4779 return NULL; 4780 if (!getilongarg(args, 5, 2, &arg3)) 4781 return NULL; 4782 if (!getishortarg(args, 5, 3, &arg4)) 4783 return NULL; 4784 if (!getishortarg(args, 5, 4, &arg5)) 4785 return NULL; 4786 arcfi( arg1 , arg2 , arg3 , arg4 , arg5 ); 4787 Py_INCREF(Py_None); 4788 return Py_None; 4789 } 4790 4791 /* void arci long s long s long s short s short s */ 4792 4793 static PyObject * 4794 gl_arci(PyObject *self, PyObject *args) 4795 { 4796 long arg1 ; 4797 long arg2 ; 4798 long arg3 ; 4799 short arg4 ; 4800 short arg5 ; 4801 if (!getilongarg(args, 5, 0, &arg1)) 4802 return NULL; 4803 if (!getilongarg(args, 5, 1, &arg2)) 4804 return NULL; 4805 if (!getilongarg(args, 5, 2, &arg3)) 4806 return NULL; 4807 if (!getishortarg(args, 5, 3, &arg4)) 4808 return NULL; 4809 if (!getishortarg(args, 5, 4, &arg5)) 4810 return NULL; 4811 arci( arg1 , arg2 , arg3 , arg4 , arg5 ); 4812 Py_INCREF(Py_None); 4813 return Py_None; 4814 } 4815 4816 /* void bbox2 short s short s float s float s float s float s */ 4817 4818 static PyObject * 4819 gl_bbox2(PyObject *self, PyObject *args) 4820 { 4821 short arg1 ; 4822 short arg2 ; 4823 float arg3 ; 4824 float arg4 ; 4825 float arg5 ; 4826 float arg6 ; 4827 if (!getishortarg(args, 6, 0, &arg1)) 4828 return NULL; 4829 if (!getishortarg(args, 6, 1, &arg2)) 4830 return NULL; 4831 if (!getifloatarg(args, 6, 2, &arg3)) 4832 return NULL; 4833 if (!getifloatarg(args, 6, 3, &arg4)) 4834 return NULL; 4835 if (!getifloatarg(args, 6, 4, &arg5)) 4836 return NULL; 4837 if (!getifloatarg(args, 6, 5, &arg6)) 4838 return NULL; 4839 bbox2( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 4840 Py_INCREF(Py_None); 4841 return Py_None; 4842 } 4843 4844 /* void bbox2i short s short s long s long s long s long s */ 4845 4846 static PyObject * 4847 gl_bbox2i(PyObject *self, PyObject *args) 4848 { 4849 short arg1 ; 4850 short arg2 ; 4851 long arg3 ; 4852 long arg4 ; 4853 long arg5 ; 4854 long arg6 ; 4855 if (!getishortarg(args, 6, 0, &arg1)) 4856 return NULL; 4857 if (!getishortarg(args, 6, 1, &arg2)) 4858 return NULL; 4859 if (!getilongarg(args, 6, 2, &arg3)) 4860 return NULL; 4861 if (!getilongarg(args, 6, 3, &arg4)) 4862 return NULL; 4863 if (!getilongarg(args, 6, 4, &arg5)) 4864 return NULL; 4865 if (!getilongarg(args, 6, 5, &arg6)) 4866 return NULL; 4867 bbox2i( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 4868 Py_INCREF(Py_None); 4869 return Py_None; 4870 } 4871 4872 /* void bbox2s short s short s short s short s short s short s */ 4873 4874 static PyObject * 4875 gl_bbox2s(PyObject *self, PyObject *args) 4876 { 4877 short arg1 ; 4878 short arg2 ; 4879 short arg3 ; 4880 short arg4 ; 4881 short arg5 ; 4882 short arg6 ; 4883 if (!getishortarg(args, 6, 0, &arg1)) 4884 return NULL; 4885 if (!getishortarg(args, 6, 1, &arg2)) 4886 return NULL; 4887 if (!getishortarg(args, 6, 2, &arg3)) 4888 return NULL; 4889 if (!getishortarg(args, 6, 3, &arg4)) 4890 return NULL; 4891 if (!getishortarg(args, 6, 4, &arg5)) 4892 return NULL; 4893 if (!getishortarg(args, 6, 5, &arg6)) 4894 return NULL; 4895 bbox2s( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 4896 Py_INCREF(Py_None); 4897 return Py_None; 4898 } 4899 4900 /* void blink short s short s short s short s short s */ 4901 4902 static PyObject * 4903 gl_blink(PyObject *self, PyObject *args) 4904 { 4905 short arg1 ; 4906 short arg2 ; 4907 short arg3 ; 4908 short arg4 ; 4909 short arg5 ; 4910 if (!getishortarg(args, 5, 0, &arg1)) 4911 return NULL; 4912 if (!getishortarg(args, 5, 1, &arg2)) 4913 return NULL; 4914 if (!getishortarg(args, 5, 2, &arg3)) 4915 return NULL; 4916 if (!getishortarg(args, 5, 3, &arg4)) 4917 return NULL; 4918 if (!getishortarg(args, 5, 4, &arg5)) 4919 return NULL; 4920 blink( arg1 , arg2 , arg3 , arg4 , arg5 ); 4921 Py_INCREF(Py_None); 4922 return Py_None; 4923 } 4924 4925 /* void ortho float s float s float s float s float s float s */ 4926 4927 static PyObject * 4928 gl_ortho(PyObject *self, PyObject *args) 4929 { 4930 float arg1 ; 4931 float arg2 ; 4932 float arg3 ; 4933 float arg4 ; 4934 float arg5 ; 4935 float arg6 ; 4936 if (!getifloatarg(args, 6, 0, &arg1)) 4937 return NULL; 4938 if (!getifloatarg(args, 6, 1, &arg2)) 4939 return NULL; 4940 if (!getifloatarg(args, 6, 2, &arg3)) 4941 return NULL; 4942 if (!getifloatarg(args, 6, 3, &arg4)) 4943 return NULL; 4944 if (!getifloatarg(args, 6, 4, &arg5)) 4945 return NULL; 4946 if (!getifloatarg(args, 6, 5, &arg6)) 4947 return NULL; 4948 ortho( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 4949 Py_INCREF(Py_None); 4950 return Py_None; 4951 } 4952 4953 /* void window float s float s float s float s float s float s */ 4954 4955 static PyObject * 4956 gl_window(PyObject *self, PyObject *args) 4957 { 4958 float arg1 ; 4959 float arg2 ; 4960 float arg3 ; 4961 float arg4 ; 4962 float arg5 ; 4963 float arg6 ; 4964 if (!getifloatarg(args, 6, 0, &arg1)) 4965 return NULL; 4966 if (!getifloatarg(args, 6, 1, &arg2)) 4967 return NULL; 4968 if (!getifloatarg(args, 6, 2, &arg3)) 4969 return NULL; 4970 if (!getifloatarg(args, 6, 3, &arg4)) 4971 return NULL; 4972 if (!getifloatarg(args, 6, 4, &arg5)) 4973 return NULL; 4974 if (!getifloatarg(args, 6, 5, &arg6)) 4975 return NULL; 4976 window( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 4977 Py_INCREF(Py_None); 4978 return Py_None; 4979 } 4980 4981 /* void lookat float s float s float s float s float s float s short s */ 4982 4983 static PyObject * 4984 gl_lookat(PyObject *self, PyObject *args) 4985 { 4986 float arg1 ; 4987 float arg2 ; 4988 float arg3 ; 4989 float arg4 ; 4990 float arg5 ; 4991 float arg6 ; 4992 short arg7 ; 4993 if (!getifloatarg(args, 7, 0, &arg1)) 4994 return NULL; 4995 if (!getifloatarg(args, 7, 1, &arg2)) 4996 return NULL; 4997 if (!getifloatarg(args, 7, 2, &arg3)) 4998 return NULL; 4999 if (!getifloatarg(args, 7, 3, &arg4)) 5000 return NULL; 5001 if (!getifloatarg(args, 7, 4, &arg5)) 5002 return NULL; 5003 if (!getifloatarg(args, 7, 5, &arg6)) 5004 return NULL; 5005 if (!getishortarg(args, 7, 6, &arg7)) 5006 return NULL; 5007 lookat( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 ); 5008 Py_INCREF(Py_None); 5009 return Py_None; 5010 } 5011 5012 /* void perspective short s float s float s float s */ 5013 5014 static PyObject * 5015 gl_perspective(PyObject *self, PyObject *args) 5016 { 5017 short arg1 ; 5018 float arg2 ; 5019 float arg3 ; 5020 float arg4 ; 5021 if (!getishortarg(args, 4, 0, &arg1)) 5022 return NULL; 5023 if (!getifloatarg(args, 4, 1, &arg2)) 5024 return NULL; 5025 if (!getifloatarg(args, 4, 2, &arg3)) 5026 return NULL; 5027 if (!getifloatarg(args, 4, 3, &arg4)) 5028 return NULL; 5029 perspective( arg1 , arg2 , arg3 , arg4 ); 5030 Py_INCREF(Py_None); 5031 return Py_None; 5032 } 5033 5034 /* void polarview float s short s short s short s */ 5035 5036 static PyObject * 5037 gl_polarview(PyObject *self, PyObject *args) 5038 { 5039 float arg1 ; 5040 short arg2 ; 5041 short arg3 ; 5042 short arg4 ; 5043 if (!getifloatarg(args, 4, 0, &arg1)) 5044 return NULL; 5045 if (!getishortarg(args, 4, 1, &arg2)) 5046 return NULL; 5047 if (!getishortarg(args, 4, 2, &arg3)) 5048 return NULL; 5049 if (!getishortarg(args, 4, 3, &arg4)) 5050 return NULL; 5051 polarview( arg1 , arg2 , arg3 , arg4 ); 5052 Py_INCREF(Py_None); 5053 return Py_None; 5054 } 5055 5056 /* void arcfs short s short s short s short s short s */ 5057 5058 static PyObject * 5059 gl_arcfs(PyObject *self, PyObject *args) 5060 { 5061 short arg1 ; 5062 short arg2 ; 5063 short arg3 ; 5064 short arg4 ; 5065 short arg5 ; 5066 if (!getishortarg(args, 5, 0, &arg1)) 5067 return NULL; 5068 if (!getishortarg(args, 5, 1, &arg2)) 5069 return NULL; 5070 if (!getishortarg(args, 5, 2, &arg3)) 5071 return NULL; 5072 if (!getishortarg(args, 5, 3, &arg4)) 5073 return NULL; 5074 if (!getishortarg(args, 5, 4, &arg5)) 5075 return NULL; 5076 arcfs( arg1 , arg2 , arg3 , arg4 , arg5 ); 5077 Py_INCREF(Py_None); 5078 return Py_None; 5079 } 5080 5081 /* void arcs short s short s short s short s short s */ 5082 5083 static PyObject * 5084 gl_arcs(PyObject *self, PyObject *args) 5085 { 5086 short arg1 ; 5087 short arg2 ; 5088 short arg3 ; 5089 short arg4 ; 5090 short arg5 ; 5091 if (!getishortarg(args, 5, 0, &arg1)) 5092 return NULL; 5093 if (!getishortarg(args, 5, 1, &arg2)) 5094 return NULL; 5095 if (!getishortarg(args, 5, 2, &arg3)) 5096 return NULL; 5097 if (!getishortarg(args, 5, 3, &arg4)) 5098 return NULL; 5099 if (!getishortarg(args, 5, 4, &arg5)) 5100 return NULL; 5101 arcs( arg1 , arg2 , arg3 , arg4 , arg5 ); 5102 Py_INCREF(Py_None); 5103 return Py_None; 5104 } 5105 5106 /* void rectcopy short s short s short s short s short s short s */ 5107 5108 static PyObject * 5109 gl_rectcopy(PyObject *self, PyObject *args) 5110 { 5111 short arg1 ; 5112 short arg2 ; 5113 short arg3 ; 5114 short arg4 ; 5115 short arg5 ; 5116 short arg6 ; 5117 if (!getishortarg(args, 6, 0, &arg1)) 5118 return NULL; 5119 if (!getishortarg(args, 6, 1, &arg2)) 5120 return NULL; 5121 if (!getishortarg(args, 6, 2, &arg3)) 5122 return NULL; 5123 if (!getishortarg(args, 6, 3, &arg4)) 5124 return NULL; 5125 if (!getishortarg(args, 6, 4, &arg5)) 5126 return NULL; 5127 if (!getishortarg(args, 6, 5, &arg6)) 5128 return NULL; 5129 rectcopy( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); 5130 Py_INCREF(Py_None); 5131 return Py_None; 5132 } 5133 5134 /* void RGBcursor short s short s short s short s short s short s short s */ 5135 5136 static PyObject * 5137 gl_RGBcursor(PyObject *self, PyObject *args) 5138 { 5139 short arg1 ; 5140 short arg2 ; 5141 short arg3 ; 5142 short arg4 ; 5143 short arg5 ; 5144 short arg6 ; 5145 short arg7 ; 5146 if (!getishortarg(args, 7, 0, &arg1)) 5147 return NULL; 5148 if (!getishortarg(args, 7, 1, &arg2)) 5149 return NULL; 5150 if (!getishortarg(args, 7, 2, &arg3)) 5151 return NULL; 5152 if (!getishortarg(args, 7, 3, &arg4)) 5153 return NULL; 5154 if (!getishortarg(args, 7, 4, &arg5)) 5155 return NULL; 5156 if (!getishortarg(args, 7, 5, &arg6)) 5157 return NULL; 5158 if (!getishortarg(args, 7, 6, &arg7)) 5159 return NULL; 5160 RGBcursor( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 ); 5161 Py_INCREF(Py_None); 5162 return Py_None; 5163 } 5164 5165 /* long getbutton short s */ 5166 5167 static PyObject * 5168 gl_getbutton(PyObject *self, PyObject *args) 5169 { 5170 long retval; 5171 short arg1 ; 5172 if (!getishortarg(args, 1, 0, &arg1)) 5173 return NULL; 5174 retval = getbutton( arg1 ); 5175 return mknewlongobject(retval); 5176 } 5177 5178 /* long getcmmode */ 5179 5180 static PyObject * 5181 gl_getcmmode(PyObject *self, PyObject *args) 5182 { 5183 long retval; 5184 retval = getcmmode( ); 5185 return mknewlongobject(retval); 5186 } 5187 5188 /* long getlsbackup */ 5189 5190 static PyObject * 5191 gl_getlsbackup(PyObject *self, PyObject *args) 5192 { 5193 long retval; 5194 retval = getlsbackup( ); 5195 return mknewlongobject(retval); 5196 } 5197 5198 /* long getresetls */ 5199 5200 static PyObject * 5201 gl_getresetls(PyObject *self, PyObject *args) 5202 { 5203 long retval; 5204 retval = getresetls( ); 5205 return mknewlongobject(retval); 5206 } 5207 5208 /* long getdcm */ 5209 5210 static PyObject * 5211 gl_getdcm(PyObject *self, PyObject *args) 5212 { 5213 long retval; 5214 retval = getdcm( ); 5215 return mknewlongobject(retval); 5216 } 5217 5218 /* long getzbuffer */ 5219 5220 static PyObject * 5221 gl_getzbuffer(PyObject *self, PyObject *args) 5222 { 5223 long retval; 5224 retval = getzbuffer( ); 5225 return mknewlongobject(retval); 5226 } 5227 5228 /* long ismex */ 5229 5230 static PyObject * 5231 gl_ismex(PyObject *self, PyObject *args) 5232 { 5233 long retval; 5234 retval = ismex( ); 5235 return mknewlongobject(retval); 5236 } 5237 5238 /* long isobj long s */ 5239 5240 static PyObject * 5241 gl_isobj(PyObject *self, PyObject *args) 5242 { 5243 long retval; 5244 long arg1 ; 5245 if (!getilongarg(args, 1, 0, &arg1)) 5246 return NULL; 5247 retval = isobj( arg1 ); 5248 return mknewlongobject(retval); 5249 } 5250 5251 /* long isqueued short s */ 5252 5253 static PyObject * 5254 gl_isqueued(PyObject *self, PyObject *args) 5255 { 5256 long retval; 5257 short arg1 ; 5258 if (!getishortarg(args, 1, 0, &arg1)) 5259 return NULL; 5260 retval = isqueued( arg1 ); 5261 return mknewlongobject(retval); 5262 } 5263 5264 /* long istag long s */ 5265 5266 static PyObject * 5267 gl_istag(PyObject *self, PyObject *args) 5268 { 5269 long retval; 5270 long arg1 ; 5271 if (!getilongarg(args, 1, 0, &arg1)) 5272 return NULL; 5273 retval = istag( arg1 ); 5274 return mknewlongobject(retval); 5275 } 5276 5277 /* long genobj */ 5278 5279 static PyObject * 5280 gl_genobj(PyObject *self, PyObject *args) 5281 { 5282 long retval; 5283 retval = genobj( ); 5284 return mknewlongobject(retval); 5285 } 5286 5287 /* long gentag */ 5288 5289 static PyObject * 5290 gl_gentag(PyObject *self, PyObject *args) 5291 { 5292 long retval; 5293 retval = gentag( ); 5294 return mknewlongobject(retval); 5295 } 5296 5297 /* long getbuffer */ 5298 5299 static PyObject * 5300 gl_getbuffer(PyObject *self, PyObject *args) 5301 { 5302 long retval; 5303 retval = getbuffer( ); 5304 return mknewlongobject(retval); 5305 } 5306 5307 /* long getcolor */ 5308 5309 static PyObject * 5310 gl_getcolor(PyObject *self, PyObject *args) 5311 { 5312 long retval; 5313 retval = getcolor( ); 5314 return mknewlongobject(retval); 5315 } 5316 5317 /* long getdisplaymode */ 5318 5319 static PyObject * 5320 gl_getdisplaymode(PyObject *self, PyObject *args) 5321 { 5322 long retval; 5323 retval = getdisplaymode( ); 5324 return mknewlongobject(retval); 5325 } 5326 5327 /* long getfont */ 5328 5329 static PyObject * 5330 gl_getfont(PyObject *self, PyObject *args) 5331 { 5332 long retval; 5333 retval = getfont( ); 5334 return mknewlongobject(retval); 5335 } 5336 5337 /* long getheight */ 5338 5339 static PyObject * 5340 gl_getheight(PyObject *self, PyObject *args) 5341 { 5342 long retval; 5343 retval = getheight( ); 5344 return mknewlongobject(retval); 5345 } 5346 5347 /* long gethitcode */ 5348 5349 static PyObject * 5350 gl_gethitcode(PyObject *self, PyObject *args) 5351 { 5352 long retval; 5353 retval = gethitcode( ); 5354 return mknewlongobject(retval); 5355 } 5356 5357 /* long getlstyle */ 5358 5359 static PyObject * 5360 gl_getlstyle(PyObject *self, PyObject *args) 5361 { 5362 long retval; 5363 retval = getlstyle( ); 5364 return mknewlongobject(retval); 5365 } 5366 5367 /* long getlwidth */ 5368 5369 static PyObject * 5370 gl_getlwidth(PyObject *self, PyObject *args) 5371 { 5372 long retval; 5373 retval = getlwidth( ); 5374 return mknewlongobject(retval); 5375 } 5376 5377 /* long getmap */ 5378 5379 static PyObject * 5380 gl_getmap(PyObject *self, PyObject *args) 5381 { 5382 long retval; 5383 retval = getmap( ); 5384 return mknewlongobject(retval); 5385 } 5386 5387 /* long getplanes */ 5388 5389 static PyObject * 5390 gl_getplanes(PyObject *self, PyObject *args) 5391 { 5392 long retval; 5393 retval = getplanes( ); 5394 return mknewlongobject(retval); 5395 } 5396 5397 /* long getwritemask */ 5398 5399 static PyObject * 5400 gl_getwritemask(PyObject *self, PyObject *args) 5401 { 5402 long retval; 5403 retval = getwritemask( ); 5404 return mknewlongobject(retval); 5405 } 5406 5407 /* long qtest */ 5408 5409 static PyObject * 5410 gl_qtest(PyObject *self, PyObject *args) 5411 { 5412 long retval; 5413 retval = qtest( ); 5414 return mknewlongobject(retval); 5415 } 5416 5417 /* long getlsrepeat */ 5418 5419 static PyObject * 5420 gl_getlsrepeat(PyObject *self, PyObject *args) 5421 { 5422 long retval; 5423 retval = getlsrepeat( ); 5424 return mknewlongobject(retval); 5425 } 5426 5427 /* long getmonitor */ 5428 5429 static PyObject * 5430 gl_getmonitor(PyObject *self, PyObject *args) 5431 { 5432 long retval; 5433 retval = getmonitor( ); 5434 return mknewlongobject(retval); 5435 } 5436 5437 /* long getopenobj */ 5438 5439 static PyObject * 5440 gl_getopenobj(PyObject *self, PyObject *args) 5441 { 5442 long retval; 5443 retval = getopenobj( ); 5444 return mknewlongobject(retval); 5445 } 5446 5447 /* long getpattern */ 5448 5449 static PyObject * 5450 gl_getpattern(PyObject *self, PyObject *args) 5451 { 5452 long retval; 5453 retval = getpattern( ); 5454 return mknewlongobject(retval); 5455 } 5456 5457 /* long winget */ 5458 5459 static PyObject * 5460 gl_winget(PyObject *self, PyObject *args) 5461 { 5462 long retval; 5463 retval = winget( ); 5464 return mknewlongobject(retval); 5465 } 5466 5467 /* long winattach */ 5468 5469 static PyObject * 5470 gl_winattach(PyObject *self, PyObject *args) 5471 { 5472 long retval; 5473 retval = winattach( ); 5474 return mknewlongobject(retval); 5475 } 5476 5477 /* long getothermonitor */ 5478 5479 static PyObject * 5480 gl_getothermonitor(PyObject *self, PyObject *args) 5481 { 5482 long retval; 5483 retval = getothermonitor( ); 5484 return mknewlongobject(retval); 5485 } 5486 5487 /* long newpup */ 5488 5489 static PyObject * 5490 gl_newpup(PyObject *self, PyObject *args) 5491 { 5492 long retval; 5493 retval = newpup( ); 5494 return mknewlongobject(retval); 5495 } 5496 5497 /* long getvaluator short s */ 5498 5499 static PyObject * 5500 gl_getvaluator(PyObject *self, PyObject *args) 5501 { 5502 long retval; 5503 short arg1 ; 5504 if (!getishortarg(args, 1, 0, &arg1)) 5505 return NULL; 5506 retval = getvaluator( arg1 ); 5507 return mknewlongobject(retval); 5508 } 5509 5510 /* void winset long s */ 5511 5512 static PyObject * 5513 gl_winset(PyObject *self, PyObject *args) 5514 { 5515 long arg1 ; 5516 if (!getilongarg(args, 1, 0, &arg1)) 5517 return NULL; 5518 winset( arg1 ); 5519 Py_INCREF(Py_None); 5520 return Py_None; 5521 } 5522 5523 /* long dopup long s */ 5524 5525 static PyObject * 5526 gl_dopup(PyObject *self, PyObject *args) 5527 { 5528 long retval; 5529 long arg1 ; 5530 if (!getilongarg(args, 1, 0, &arg1)) 5531 return NULL; 5532 retval = dopup( arg1 ); 5533 return mknewlongobject(retval); 5534 } 5535 5536 /* void getdepth short r short r */ 5537 5538 static PyObject * 5539 gl_getdepth(PyObject *self, PyObject *args) 5540 { 5541 short arg1 ; 5542 short arg2 ; 5543 getdepth( & arg1 , & arg2 ); 5544 { PyObject *v = PyTuple_New( 2 ); 5545 if (v == NULL) return NULL; 5546 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5547 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5548 return v; 5549 } 5550 } 5551 5552 /* void getcpos short r short r */ 5553 5554 static PyObject * 5555 gl_getcpos(PyObject *self, PyObject *args) 5556 { 5557 short arg1 ; 5558 short arg2 ; 5559 getcpos( & arg1 , & arg2 ); 5560 { PyObject *v = PyTuple_New( 2 ); 5561 if (v == NULL) return NULL; 5562 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5563 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5564 return v; 5565 } 5566 } 5567 5568 /* void getsize long r long r */ 5569 5570 static PyObject * 5571 gl_getsize(PyObject *self, PyObject *args) 5572 { 5573 long arg1 ; 5574 long arg2 ; 5575 getsize( & arg1 , & arg2 ); 5576 { PyObject *v = PyTuple_New( 2 ); 5577 if (v == NULL) return NULL; 5578 PyTuple_SetItem(v, 0, mknewlongobject(arg1)); 5579 PyTuple_SetItem(v, 1, mknewlongobject(arg2)); 5580 return v; 5581 } 5582 } 5583 5584 /* void getorigin long r long r */ 5585 5586 static PyObject * 5587 gl_getorigin(PyObject *self, PyObject *args) 5588 { 5589 long arg1 ; 5590 long arg2 ; 5591 getorigin( & arg1 , & arg2 ); 5592 { PyObject *v = PyTuple_New( 2 ); 5593 if (v == NULL) return NULL; 5594 PyTuple_SetItem(v, 0, mknewlongobject(arg1)); 5595 PyTuple_SetItem(v, 1, mknewlongobject(arg2)); 5596 return v; 5597 } 5598 } 5599 5600 /* void getviewport short r short r short r short r */ 5601 5602 static PyObject * 5603 gl_getviewport(PyObject *self, PyObject *args) 5604 { 5605 short arg1 ; 5606 short arg2 ; 5607 short arg3 ; 5608 short arg4 ; 5609 getviewport( & arg1 , & arg2 , & arg3 , & arg4 ); 5610 { PyObject *v = PyTuple_New( 4 ); 5611 if (v == NULL) return NULL; 5612 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5613 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5614 PyTuple_SetItem(v, 2, mknewshortobject(arg3)); 5615 PyTuple_SetItem(v, 3, mknewshortobject(arg4)); 5616 return v; 5617 } 5618 } 5619 5620 /* void gettp short r short r short r short r */ 5621 5622 static PyObject * 5623 gl_gettp(PyObject *self, PyObject *args) 5624 { 5625 short arg1 ; 5626 short arg2 ; 5627 short arg3 ; 5628 short arg4 ; 5629 gettp( & arg1 , & arg2 , & arg3 , & arg4 ); 5630 { PyObject *v = PyTuple_New( 4 ); 5631 if (v == NULL) return NULL; 5632 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5633 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5634 PyTuple_SetItem(v, 2, mknewshortobject(arg3)); 5635 PyTuple_SetItem(v, 3, mknewshortobject(arg4)); 5636 return v; 5637 } 5638 } 5639 5640 /* void getgpos float r float r float r float r */ 5641 5642 static PyObject * 5643 gl_getgpos(PyObject *self, PyObject *args) 5644 { 5645 float arg1 ; 5646 float arg2 ; 5647 float arg3 ; 5648 float arg4 ; 5649 getgpos( & arg1 , & arg2 , & arg3 , & arg4 ); 5650 { PyObject *v = PyTuple_New( 4 ); 5651 if (v == NULL) return NULL; 5652 PyTuple_SetItem(v, 0, mknewfloatobject(arg1)); 5653 PyTuple_SetItem(v, 1, mknewfloatobject(arg2)); 5654 PyTuple_SetItem(v, 2, mknewfloatobject(arg3)); 5655 PyTuple_SetItem(v, 3, mknewfloatobject(arg4)); 5656 return v; 5657 } 5658 } 5659 5660 /* void winposition long s long s long s long s */ 5661 5662 static PyObject * 5663 gl_winposition(PyObject *self, PyObject *args) 5664 { 5665 long arg1 ; 5666 long arg2 ; 5667 long arg3 ; 5668 long arg4 ; 5669 if (!getilongarg(args, 4, 0, &arg1)) 5670 return NULL; 5671 if (!getilongarg(args, 4, 1, &arg2)) 5672 return NULL; 5673 if (!getilongarg(args, 4, 2, &arg3)) 5674 return NULL; 5675 if (!getilongarg(args, 4, 3, &arg4)) 5676 return NULL; 5677 winposition( arg1 , arg2 , arg3 , arg4 ); 5678 Py_INCREF(Py_None); 5679 return Py_None; 5680 } 5681 5682 /* void gRGBcolor short r short r short r */ 5683 5684 static PyObject * 5685 gl_gRGBcolor(PyObject *self, PyObject *args) 5686 { 5687 short arg1 ; 5688 short arg2 ; 5689 short arg3 ; 5690 gRGBcolor( & arg1 , & arg2 , & arg3 ); 5691 { PyObject *v = PyTuple_New( 3 ); 5692 if (v == NULL) return NULL; 5693 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5694 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5695 PyTuple_SetItem(v, 2, mknewshortobject(arg3)); 5696 return v; 5697 } 5698 } 5699 5700 /* void gRGBmask short r short r short r */ 5701 5702 static PyObject * 5703 gl_gRGBmask(PyObject *self, PyObject *args) 5704 { 5705 short arg1 ; 5706 short arg2 ; 5707 short arg3 ; 5708 gRGBmask( & arg1 , & arg2 , & arg3 ); 5709 { PyObject *v = PyTuple_New( 3 ); 5710 if (v == NULL) return NULL; 5711 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5712 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5713 PyTuple_SetItem(v, 2, mknewshortobject(arg3)); 5714 return v; 5715 } 5716 } 5717 5718 /* void getscrmask short r short r short r short r */ 5719 5720 static PyObject * 5721 gl_getscrmask(PyObject *self, PyObject *args) 5722 { 5723 short arg1 ; 5724 short arg2 ; 5725 short arg3 ; 5726 short arg4 ; 5727 getscrmask( & arg1 , & arg2 , & arg3 , & arg4 ); 5728 { PyObject *v = PyTuple_New( 4 ); 5729 if (v == NULL) return NULL; 5730 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5731 PyTuple_SetItem(v, 1, mknewshortobject(arg2)); 5732 PyTuple_SetItem(v, 2, mknewshortobject(arg3)); 5733 PyTuple_SetItem(v, 3, mknewshortobject(arg4)); 5734 return v; 5735 } 5736 } 5737 5738 /* void getmcolor short s short r short r short r */ 5739 5740 static PyObject * 5741 gl_getmcolor(PyObject *self, PyObject *args) 5742 { 5743 short arg1 ; 5744 short arg2 ; 5745 short arg3 ; 5746 short arg4 ; 5747 if (!getishortarg(args, 1, 0, &arg1)) 5748 return NULL; 5749 getmcolor( arg1 , & arg2 , & arg3 , & arg4 ); 5750 { PyObject *v = PyTuple_New( 3 ); 5751 if (v == NULL) return NULL; 5752 PyTuple_SetItem(v, 0, mknewshortobject(arg2)); 5753 PyTuple_SetItem(v, 1, mknewshortobject(arg3)); 5754 PyTuple_SetItem(v, 2, mknewshortobject(arg4)); 5755 return v; 5756 } 5757 } 5758 5759 /* void mapw long s short s short s float r float r float r float r float r float r */ 5760 5761 static PyObject * 5762 gl_mapw(PyObject *self, PyObject *args) 5763 { 5764 long arg1 ; 5765 short arg2 ; 5766 short arg3 ; 5767 float arg4 ; 5768 float arg5 ; 5769 float arg6 ; 5770 float arg7 ; 5771 float arg8 ; 5772 float arg9 ; 5773 if (!getilongarg(args, 3, 0, &arg1)) 5774 return NULL; 5775 if (!getishortarg(args, 3, 1, &arg2)) 5776 return NULL; 5777 if (!getishortarg(args, 3, 2, &arg3)) 5778 return NULL; 5779 mapw( arg1 , arg2 , arg3 , & arg4 , & arg5 , & arg6 , & arg7 , & arg8 , & arg9 ); 5780 { PyObject *v = PyTuple_New( 6 ); 5781 if (v == NULL) return NULL; 5782 PyTuple_SetItem(v, 0, mknewfloatobject(arg4)); 5783 PyTuple_SetItem(v, 1, mknewfloatobject(arg5)); 5784 PyTuple_SetItem(v, 2, mknewfloatobject(arg6)); 5785 PyTuple_SetItem(v, 3, mknewfloatobject(arg7)); 5786 PyTuple_SetItem(v, 4, mknewfloatobject(arg8)); 5787 PyTuple_SetItem(v, 5, mknewfloatobject(arg9)); 5788 return v; 5789 } 5790 } 5791 5792 /* void mapw2 long s short s short s float r float r */ 5793 5794 static PyObject * 5795 gl_mapw2(PyObject *self, PyObject *args) 5796 { 5797 long arg1 ; 5798 short arg2 ; 5799 short arg3 ; 5800 float arg4 ; 5801 float arg5 ; 5802 if (!getilongarg(args, 3, 0, &arg1)) 5803 return NULL; 5804 if (!getishortarg(args, 3, 1, &arg2)) 5805 return NULL; 5806 if (!getishortarg(args, 3, 2, &arg3)) 5807 return NULL; 5808 mapw2( arg1 , arg2 , arg3 , & arg4 , & arg5 ); 5809 { PyObject *v = PyTuple_New( 2 ); 5810 if (v == NULL) return NULL; 5811 PyTuple_SetItem(v, 0, mknewfloatobject(arg4)); 5812 PyTuple_SetItem(v, 1, mknewfloatobject(arg5)); 5813 return v; 5814 } 5815 } 5816 5817 /* void getcursor short r u_short r u_short r long r */ 5818 5819 static PyObject * 5820 gl_getcursor(PyObject *self, PyObject *args) 5821 { 5822 short arg1 ; 5823 unsigned short arg2 ; 5824 unsigned short arg3 ; 5825 long arg4 ; 5826 getcursor( & arg1 , & arg2 , & arg3 , & arg4 ); 5827 { PyObject *v = PyTuple_New( 4 ); 5828 if (v == NULL) return NULL; 5829 PyTuple_SetItem(v, 0, mknewshortobject(arg1)); 5830 PyTuple_SetItem(v, 1, mknewshortobject((short) arg2)); 5831 PyTuple_SetItem(v, 2, mknewshortobject((short) arg3)); 5832 PyTuple_SetItem(v, 3, mknewlongobject(arg4)); 5833 return v; 5834 } 5835 } 5836 5837 /* void cmode */ 5838 5839 static PyObject * 5840 gl_cmode(PyObject *self, PyObject *args) 5841 { 5842 cmode( ); 5843 Py_INCREF(Py_None); 5844 return Py_None; 5845 } 5846 5847 /* void concave long s */ 5848 5849 static PyObject * 5850 gl_concave(PyObject *self, PyObject *args) 5851 { 5852 long arg1 ; 5853 if (!getilongarg(args, 1, 0, &arg1)) 5854 return NULL; 5855 concave( arg1 ); 5856 Py_INCREF(Py_None); 5857 return Py_None; 5858 } 5859 5860 /* void curstype long s */ 5861 5862 static PyObject * 5863 gl_curstype(PyObject *self, PyObject *args) 5864 { 5865 long arg1 ; 5866 if (!getilongarg(args, 1, 0, &arg1)) 5867 return NULL; 5868 curstype( arg1 ); 5869 Py_INCREF(Py_None); 5870 return Py_None; 5871 } 5872 5873 /* void drawmode long s */ 5874 5875 static PyObject * 5876 gl_drawmode(PyObject *self, PyObject *args) 5877 { 5878 long arg1 ; 5879 if (!getilongarg(args, 1, 0, &arg1)) 5880 return NULL; 5881 drawmode( arg1 ); 5882 Py_INCREF(Py_None); 5883 return Py_None; 5884 } 5885 5886 /* void gammaramp short s[256] short s[256] short s[256] */ 5887 5888 static PyObject * 5889 gl_gammaramp(PyObject *self, PyObject *args) 5890 { 5891 short arg1 [ 256 ] ; 5892 short arg2 [ 256 ] ; 5893 short arg3 [ 256 ] ; 5894 if (!getishortarray(args, 3, 0, 256 , arg1)) 5895 return NULL; 5896 if (!getishortarray(args, 3, 1, 256 , arg2)) 5897 return NULL; 5898 if (!getishortarray(args, 3, 2, 256 , arg3)) 5899 return NULL; 5900 gammaramp( arg1 , arg2 , arg3 ); 5901 Py_INCREF(Py_None); 5902 return Py_None; 5903 } 5904 5905 /* long getbackface */ 5906 5907 static PyObject * 5908 gl_getbackface(PyObject *self, PyObject *args) 5909 { 5910 long retval; 5911 retval = getbackface( ); 5912 return mknewlongobject(retval); 5913 } 5914 5915 /* long getdescender */ 5916 5917 static PyObject * 5918 gl_getdescender(PyObject *self, PyObject *args) 5919 { 5920 long retval; 5921 retval = getdescender( ); 5922 return mknewlongobject(retval); 5923 } 5924 5925 /* long getdrawmode */ 5926 5927 static PyObject * 5928 gl_getdrawmode(PyObject *self, PyObject *args) 5929 { 5930 long retval; 5931 retval = getdrawmode( ); 5932 return mknewlongobject(retval); 5933 } 5934 5935 /* long getmmode */ 5936 5937 static PyObject * 5938 gl_getmmode(PyObject *self, PyObject *args) 5939 { 5940 long retval; 5941 retval = getmmode( ); 5942 return mknewlongobject(retval); 5943 } 5944 5945 /* long getsm */ 5946 5947 static PyObject * 5948 gl_getsm(PyObject *self, PyObject *args) 5949 { 5950 long retval; 5951 retval = getsm( ); 5952 return mknewlongobject(retval); 5953 } 5954 5955 /* long getvideo long s */ 5956 5957 static PyObject * 5958 gl_getvideo(PyObject *self, PyObject *args) 5959 { 5960 long retval; 5961 long arg1 ; 5962 if (!getilongarg(args, 1, 0, &arg1)) 5963 return NULL; 5964 retval = getvideo( arg1 ); 5965 return mknewlongobject(retval); 5966 } 5967 5968 /* void imakebackground */ 5969 5970 static PyObject * 5971 gl_imakebackground(PyObject *self, PyObject *args) 5972 { 5973 imakebackground( ); 5974 Py_INCREF(Py_None); 5975 return Py_None; 5976 } 5977 5978 /* void lmbind short s short s */ 5979 5980 static PyObject * 5981 gl_lmbind(PyObject *self, PyObject *args) 5982 { 5983 short arg1 ; 5984 short arg2 ; 5985 if (!getishortarg(args, 2, 0, &arg1)) 5986 return NULL; 5987 if (!getishortarg(args, 2, 1, &arg2)) 5988 return NULL; 5989 lmbind( arg1 , arg2 ); 5990 Py_INCREF(Py_None); 5991 return Py_None; 5992 } 5993 5994 /* void lmdef long s long s long s float s[arg3] */ 5995 5996 static PyObject * 5997 gl_lmdef(PyObject *self, PyObject *args) 5998 { 5999 long arg1 ; 6000 long arg2 ; 6001 long arg3 ; 6002 float * arg4 ; 6003 if (!getilongarg(args, 3, 0, &arg1)) 6004 return NULL; 6005 if (!getilongarg(args, 3, 1, &arg2)) 6006 return NULL; 6007 if (!getilongarraysize(args, 3, 2, &arg3)) 6008 return NULL; 6009 if ((arg4 = PyMem_NEW(float , arg3 )) == NULL) 6010 return PyErr_NoMemory(); 6011 if (!getifloatarray(args, 3, 2, arg3 , arg4)) 6012 return NULL; 6013 lmdef( arg1 , arg2 , arg3 , arg4 ); 6014 PyMem_DEL(arg4); 6015 Py_INCREF(Py_None); 6016 return Py_None; 6017 } 6018 6019 /* void mmode long s */ 6020 6021 static PyObject * 6022 gl_mmode(PyObject *self, PyObject *args) 6023 { 6024 long arg1 ; 6025 if (!getilongarg(args, 1, 0, &arg1)) 6026 return NULL; 6027 mmode( arg1 ); 6028 Py_INCREF(Py_None); 6029 return Py_None; 6030 } 6031 6032 /* void normal float s[3] */ 6033 6034 static PyObject * 6035 gl_normal(PyObject *self, PyObject *args) 6036 { 6037 float arg1 [ 3 ] ; 6038 if (!getifloatarray(args, 1, 0, 3 , arg1)) 6039 return NULL; 6040 normal( arg1 ); 6041 Py_INCREF(Py_None); 6042 return Py_None; 6043 } 6044 6045 /* void overlay long s */ 6046 6047 static PyObject * 6048 gl_overlay(PyObject *self, PyObject *args) 6049 { 6050 long arg1 ; 6051 if (!getilongarg(args, 1, 0, &arg1)) 6052 return NULL; 6053 overlay( arg1 ); 6054 Py_INCREF(Py_None); 6055 return Py_None; 6056 } 6057 6058 /* void RGBrange short s short s short s short s short s short s short s short s */ 6059 6060 static PyObject * 6061 gl_RGBrange(PyObject *self, PyObject *args) 6062 { 6063 short arg1 ; 6064 short arg2 ; 6065 short arg3 ; 6066 short arg4 ; 6067 short arg5 ; 6068 short arg6 ; 6069 short arg7 ; 6070 short arg8 ; 6071 if (!getishortarg(args, 8, 0, &arg1)) 6072 return NULL; 6073 if (!getishortarg(args, 8, 1, &arg2)) 6074 return NULL; 6075 if (!getishortarg(args, 8, 2, &arg3)) 6076 return NULL; 6077 if (!getishortarg(args, 8, 3, &arg4)) 6078 return NULL; 6079 if (!getishortarg(args, 8, 4, &arg5)) 6080 return NULL; 6081 if (!getishortarg(args, 8, 5, &arg6)) 6082 return NULL; 6083 if (!getishortarg(args, 8, 6, &arg7)) 6084 return NULL; 6085 if (!getishortarg(args, 8, 7, &arg8)) 6086 return NULL; 6087 RGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 ); 6088 Py_INCREF(Py_None); 6089 return Py_None; 6090 } 6091 6092 /* void setvideo long s long s */ 6093 6094 static PyObject * 6095 gl_setvideo(PyObject *self, PyObject *args) 6096 { 6097 long arg1 ; 6098 long arg2 ; 6099 if (!getilongarg(args, 2, 0, &arg1)) 6100 return NULL; 6101 if (!getilongarg(args, 2, 1, &arg2)) 6102 return NULL; 6103 setvideo( arg1 , arg2 ); 6104 Py_INCREF(Py_None); 6105 return Py_None; 6106 } 6107 6108 /* void shademodel long s */ 6109 6110 static PyObject * 6111 gl_shademodel(PyObject *self, PyObject *args) 6112 { 6113 long arg1 ; 6114 if (!getilongarg(args, 1, 0, &arg1)) 6115 return NULL; 6116 shademodel( arg1 ); 6117 Py_INCREF(Py_None); 6118 return Py_None; 6119 } 6120 6121 /* void underlay long s */ 6122 6123 static PyObject * 6124 gl_underlay(PyObject *self, PyObject *args) 6125 { 6126 long arg1 ; 6127 if (!getilongarg(args, 1, 0, &arg1)) 6128 return NULL; 6129 underlay( arg1 ); 6130 Py_INCREF(Py_None); 6131 return Py_None; 6132 } 6133 6134 /* void bgnclosedline */ 6135 6136 static PyObject * 6137 gl_bgnclosedline(PyObject *self, PyObject *args) 6138 { 6139 bgnclosedline( ); 6140 Py_INCREF(Py_None); 6141 return Py_None; 6142 } 6143 6144 /* void bgnline */ 6145 6146 static PyObject * 6147 gl_bgnline(PyObject *self, PyObject *args) 6148 { 6149 bgnline( ); 6150 Py_INCREF(Py_None); 6151 return Py_None; 6152 } 6153 6154 /* void bgnpoint */ 6155 6156 static PyObject * 6157 gl_bgnpoint(PyObject *self, PyObject *args) 6158 { 6159 bgnpoint( ); 6160 Py_INCREF(Py_None); 6161 return Py_None; 6162 } 6163 6164 /* void bgnpolygon */ 6165 6166 static PyObject * 6167 gl_bgnpolygon(PyObject *self, PyObject *args) 6168 { 6169 bgnpolygon( ); 6170 Py_INCREF(Py_None); 6171 return Py_None; 6172 } 6173 6174 /* void bgnsurface */ 6175 6176 static PyObject * 6177 gl_bgnsurface(PyObject *self, PyObject *args) 6178 { 6179 bgnsurface( ); 6180 Py_INCREF(Py_None); 6181 return Py_None; 6182 } 6183 6184 /* void bgntmesh */ 6185 6186 static PyObject * 6187 gl_bgntmesh(PyObject *self, PyObject *args) 6188 { 6189 bgntmesh( ); 6190 Py_INCREF(Py_None); 6191 return Py_None; 6192 } 6193 6194 /* void bgntrim */ 6195 6196 static PyObject * 6197 gl_bgntrim(PyObject *self, PyObject *args) 6198 { 6199 bgntrim( ); 6200 Py_INCREF(Py_None); 6201 return Py_None; 6202 } 6203 6204 /* void endclosedline */ 6205 6206 static PyObject * 6207 gl_endclosedline(PyObject *self, PyObject *args) 6208 { 6209 endclosedline( ); 6210 Py_INCREF(Py_None); 6211 return Py_None; 6212 } 6213 6214 /* void endline */ 6215 6216 static PyObject * 6217 gl_endline(PyObject *self, PyObject *args) 6218 { 6219 endline( ); 6220 Py_INCREF(Py_None); 6221 return Py_None; 6222 } 6223 6224 /* void endpoint */ 6225 6226 static PyObject * 6227 gl_endpoint(PyObject *self, PyObject *args) 6228 { 6229 endpoint( ); 6230 Py_INCREF(Py_None); 6231 return Py_None; 6232 } 6233 6234 /* void endpolygon */ 6235 6236 static PyObject * 6237 gl_endpolygon(PyObject *self, PyObject *args) 6238 { 6239 endpolygon( ); 6240 Py_INCREF(Py_None); 6241 return Py_None; 6242 } 6243 6244 /* void endsurface */ 6245 6246 static PyObject * 6247 gl_endsurface(PyObject *self, PyObject *args) 6248 { 6249 endsurface( ); 6250 Py_INCREF(Py_None); 6251 return Py_None; 6252 } 6253 6254 /* void endtmesh */ 6255 6256 static PyObject * 6257 gl_endtmesh(PyObject *self, PyObject *args) 6258 { 6259 endtmesh( ); 6260 Py_INCREF(Py_None); 6261 return Py_None; 6262 } 6263 6264 /* void endtrim */ 6265 6266 static PyObject * 6267 gl_endtrim(PyObject *self, PyObject *args) 6268 { 6269 endtrim( ); 6270 Py_INCREF(Py_None); 6271 return Py_None; 6272 } 6273 6274 /* void blendfunction long s long s */ 6275 6276 static PyObject * 6277 gl_blendfunction(PyObject *self, PyObject *args) 6278 { 6279 long arg1 ; 6280 long arg2 ; 6281 if (!getilongarg(args, 2, 0, &arg1)) 6282 return NULL; 6283 if (!getilongarg(args, 2, 1, &arg2)) 6284 return NULL; 6285 blendfunction( arg1 , arg2 ); 6286 Py_INCREF(Py_None); 6287 return Py_None; 6288 } 6289 6290 /* void c3f float s[3] */ 6291 6292 static PyObject * 6293 gl_c3f(PyObject *self, PyObject *args) 6294 { 6295 float arg1 [ 3 ] ; 6296 if (!getifloatarray(args, 1, 0, 3 , arg1)) 6297 return NULL; 6298 c3f( arg1 ); 6299 Py_INCREF(Py_None); 6300 return Py_None; 6301 } 6302 6303 /* void c3i long s[3] */ 6304 6305 static PyObject * 6306 gl_c3i(PyObject *self, PyObject *args) 6307 { 6308 long arg1 [ 3 ] ; 6309 if (!getilongarray(args, 1, 0, 3 , arg1)) 6310 return NULL; 6311 c3i( arg1 ); 6312 Py_INCREF(Py_None); 6313 return Py_None; 6314 } 6315 6316 /* void c3s short s[3] */ 6317 6318 static PyObject * 6319 gl_c3s(PyObject *self, PyObject *args) 6320 { 6321 short arg1 [ 3 ] ; 6322 if (!getishortarray(args, 1, 0, 3 , arg1)) 6323 return NULL; 6324 c3s( arg1 ); 6325 Py_INCREF(Py_None); 6326 return Py_None; 6327 } 6328 6329 /* void c4f float s[4] */ 6330 6331 static PyObject * 6332 gl_c4f(PyObject *self, PyObject *args) 6333 { 6334 float arg1 [ 4 ] ; 6335 if (!getifloatarray(args, 1, 0, 4 , arg1)) 6336 return NULL; 6337 c4f( arg1 ); 6338 Py_INCREF(Py_None); 6339 return Py_None; 6340 } 6341 6342 /* void c4i long s[4] */ 6343 6344 static PyObject * 6345 gl_c4i(PyObject *self, PyObject *args) 6346 { 6347 long arg1 [ 4 ] ; 6348 if (!getilongarray(args, 1, 0, 4 , arg1)) 6349 return NULL; 6350 c4i( arg1 ); 6351 Py_INCREF(Py_None); 6352 return Py_None; 6353 } 6354 6355 /* void c4s short s[4] */ 6356 6357 static PyObject * 6358 gl_c4s(PyObject *self, PyObject *args) 6359 { 6360 short arg1 [ 4 ] ; 6361 if (!getishortarray(args, 1, 0, 4 , arg1)) 6362 return NULL; 6363 c4s( arg1 ); 6364 Py_INCREF(Py_None); 6365 return Py_None; 6366 } 6367 6368 /* void colorf float s */ 6369 6370 static PyObject * 6371 gl_colorf(PyObject *self, PyObject *args) 6372 { 6373 float arg1 ; 6374 if (!getifloatarg(args, 1, 0, &arg1)) 6375 return NULL; 6376 colorf( arg1 ); 6377 Py_INCREF(Py_None); 6378 return Py_None; 6379 } 6380 6381 /* void cpack long s */ 6382 6383 static PyObject * 6384 gl_cpack(PyObject *self, PyObject *args) 6385 { 6386 long arg1 ; 6387 if (!getilongarg(args, 1, 0, &arg1)) 6388 return NULL; 6389 cpack( arg1 ); 6390 Py_INCREF(Py_None); 6391 return Py_None; 6392 } 6393 6394 /* void czclear long s long s */ 6395 6396 static PyObject * 6397 gl_czclear(PyObject *self, PyObject *args) 6398 { 6399 long arg1 ; 6400 long arg2 ; 6401 if (!getilongarg(args, 2, 0, &arg1)) 6402 return NULL; 6403 if (!getilongarg(args, 2, 1, &arg2)) 6404 return NULL; 6405 czclear( arg1 , arg2 ); 6406 Py_INCREF(Py_None); 6407 return Py_None; 6408 } 6409 6410 /* void dglclose long s */ 6411 6412 static PyObject * 6413 gl_dglclose(PyObject *self, PyObject *args) 6414 { 6415 long arg1 ; 6416 if (!getilongarg(args, 1, 0, &arg1)) 6417 return NULL; 6418 dglclose( arg1 ); 6419 Py_INCREF(Py_None); 6420 return Py_None; 6421 } 6422 6423 /* long dglopen char *s long s */ 6424 6425 static PyObject * 6426 gl_dglopen(PyObject *self, PyObject *args) 6427 { 6428 long retval; 6429 string arg1 ; 6430 long arg2 ; 6431 if (!getistringarg(args, 2, 0, &arg1)) 6432 return NULL; 6433 if (!getilongarg(args, 2, 1, &arg2)) 6434 return NULL; 6435 retval = dglopen( arg1 , arg2 ); 6436 return mknewlongobject(retval); 6437 } 6438 6439 /* long getgdesc long s */ 6440 6441 static PyObject * 6442 gl_getgdesc(PyObject *self, PyObject *args) 6443 { 6444 long retval; 6445 long arg1 ; 6446 if (!getilongarg(args, 1, 0, &arg1)) 6447 return NULL; 6448 retval = getgdesc( arg1 ); 6449 return mknewlongobject(retval); 6450 } 6451 6452 /* void getnurbsproperty long s float r */ 6453 6454 static PyObject * 6455 gl_getnurbsproperty(PyObject *self, PyObject *args) 6456 { 6457 long arg1 ; 6458 float arg2 ; 6459 if (!getilongarg(args, 1, 0, &arg1)) 6460 return NULL; 6461 getnurbsproperty( arg1 , & arg2 ); 6462 return mknewfloatobject(arg2); 6463 } 6464 6465 /* void glcompat long s long s */ 6466 6467 static PyObject * 6468 gl_glcompat(PyObject *self, PyObject *args) 6469 { 6470 long arg1 ; 6471 long arg2 ; 6472 if (!getilongarg(args, 2, 0, &arg1)) 6473 return NULL; 6474 if (!getilongarg(args, 2, 1, &arg2)) 6475 return NULL; 6476 glcompat( arg1 , arg2 ); 6477 Py_INCREF(Py_None); 6478 return Py_None; 6479 } 6480 6481 /* void iconsize long s long s */ 6482 6483 static PyObject * 6484 gl_iconsize(PyObject *self, PyObject *args) 6485 { 6486 long arg1 ; 6487 long arg2 ; 6488 if (!getilongarg(args, 2, 0, &arg1)) 6489 return NULL; 6490 if (!getilongarg(args, 2, 1, &arg2)) 6491 return NULL; 6492 iconsize( arg1 , arg2 ); 6493 Py_INCREF(Py_None); 6494 return Py_None; 6495 } 6496 6497 /* void icontitle char *s */ 6498 6499 static PyObject * 6500 gl_icontitle(PyObject *self, PyObject *args) 6501 { 6502 string arg1 ; 6503 if (!getistringarg(args, 1, 0, &arg1)) 6504 return NULL; 6505 icontitle( arg1 ); 6506 Py_INCREF(Py_None); 6507 return Py_None; 6508 } 6509 6510 /* void lRGBrange short s short s short s short s short s short s long s long s */ 6511 6512 static PyObject * 6513 gl_lRGBrange(PyObject *self, PyObject *args) 6514 { 6515 short arg1 ; 6516 short arg2 ; 6517 short arg3 ; 6518 short arg4 ; 6519 short arg5 ; 6520 short arg6 ; 6521 long arg7 ; 6522 long arg8 ; 6523 if (!getishortarg(args, 8, 0, &arg1)) 6524 return NULL; 6525 if (!getishortarg(args, 8, 1, &arg2)) 6526 return NULL; 6527 if (!getishortarg(args, 8, 2, &arg3)) 6528 return NULL; 6529 if (!getishortarg(args, 8, 3, &arg4)) 6530 return NULL; 6531 if (!getishortarg(args, 8, 4, &arg5)) 6532 return NULL; 6533 if (!getishortarg(args, 8, 5, &arg6)) 6534 return NULL; 6535 if (!getilongarg(args, 8, 6, &arg7)) 6536 return NULL; 6537 if (!getilongarg(args, 8, 7, &arg8)) 6538 return NULL; 6539 lRGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 ); 6540 Py_INCREF(Py_None); 6541 return Py_None; 6542 } 6543 6544 /* void linesmooth long s */ 6545 6546 static PyObject * 6547 gl_linesmooth(PyObject *self, PyObject *args) 6548 { 6549 long arg1 ; 6550 if (!getilongarg(args, 1, 0, &arg1)) 6551 return NULL; 6552 linesmooth( arg1 ); 6553 Py_INCREF(Py_None); 6554 return Py_None; 6555 } 6556 6557 /* void lmcolor long s */ 6558 6559 static PyObject * 6560 gl_lmcolor(PyObject *self, PyObject *args) 6561 { 6562 long arg1 ; 6563 if (!getilongarg(args, 1, 0, &arg1)) 6564 return NULL; 6565 lmcolor( arg1 ); 6566 Py_INCREF(Py_None); 6567 return Py_None; 6568 } 6569 6570 /* void logicop long s */ 6571 6572 static PyObject * 6573 gl_logicop(PyObject *self, PyObject *args) 6574 { 6575 long arg1 ; 6576 if (!getilongarg(args, 1, 0, &arg1)) 6577 return NULL; 6578 logicop( arg1 ); 6579 Py_INCREF(Py_None); 6580 return Py_None; 6581 } 6582 6583 /* void lsetdepth long s long s */ 6584 6585 static PyObject * 6586 gl_lsetdepth(PyObject *self, PyObject *args) 6587 { 6588 long arg1 ; 6589 long arg2 ; 6590 if (!getilongarg(args, 2, 0, &arg1)) 6591 return NULL; 6592 if (!getilongarg(args, 2, 1, &arg2)) 6593 return NULL; 6594 lsetdepth( arg1 , arg2 ); 6595 Py_INCREF(Py_None); 6596 return Py_None; 6597 } 6598 6599 /* void lshaderange short s short s long s long s */ 6600 6601 static PyObject * 6602 gl_lshaderange(PyObject *self, PyObject *args) 6603 { 6604 short arg1 ; 6605 short arg2 ; 6606 long arg3 ; 6607 long arg4 ; 6608 if (!getishortarg(args, 4, 0, &arg1)) 6609 return NULL; 6610 if (!getishortarg(args, 4, 1, &arg2)) 6611 return NULL; 6612 if (!getilongarg(args, 4, 2, &arg3)) 6613 return NULL; 6614 if (!getilongarg(args, 4, 3, &arg4)) 6615 return NULL; 6616 lshaderange( arg1 , arg2 , arg3 , arg4 ); 6617 Py_INCREF(Py_None); 6618 return Py_None; 6619 } 6620 6621 /* void n3f float s[3] */ 6622 6623 static PyObject * 6624 gl_n3f(PyObject *self, PyObject *args) 6625 { 6626 float arg1 [ 3 ] ; 6627 if (!getifloatarray(args, 1, 0, 3 , arg1)) 6628 return NULL; 6629 n3f( arg1 ); 6630 Py_INCREF(Py_None); 6631 return Py_None; 6632 } 6633 6634 /* void noborder */ 6635 6636 static PyObject * 6637 gl_noborder(PyObject *self, PyObject *args) 6638 { 6639 noborder( ); 6640 Py_INCREF(Py_None); 6641 return Py_None; 6642 } 6643 6644 /* void pntsmooth long s */ 6645 6646 static PyObject * 6647 gl_pntsmooth(PyObject *self, PyObject *args) 6648 { 6649 long arg1 ; 6650 if (!getilongarg(args, 1, 0, &arg1)) 6651 return NULL; 6652 pntsmooth( arg1 ); 6653 Py_INCREF(Py_None); 6654 return Py_None; 6655 } 6656 6657 /* void readsource long s */ 6658 6659 static PyObject * 6660 gl_readsource(PyObject *self, PyObject *args) 6661 { 6662 long arg1 ; 6663 if (!getilongarg(args, 1, 0, &arg1)) 6664 return NULL; 6665 readsource( arg1 ); 6666 Py_INCREF(Py_None); 6667 return Py_None; 6668 } 6669 6670 /* void rectzoom float s float s */ 6671 6672 static PyObject * 6673 gl_rectzoom(PyObject *self, PyObject *args) 6674 { 6675 float arg1 ; 6676 float arg2 ; 6677 if (!getifloatarg(args, 2, 0, &arg1)) 6678 return NULL; 6679 if (!getifloatarg(args, 2, 1, &arg2)) 6680 return NULL; 6681 rectzoom( arg1 , arg2 ); 6682 Py_INCREF(Py_None); 6683 return Py_None; 6684 } 6685 6686 /* void sbox float s float s float s float s */ 6687 6688 static PyObject * 6689 gl_sbox(PyObject *self, PyObject *args) 6690 { 6691 float arg1 ; 6692 float arg2 ; 6693 float arg3 ; 6694 float arg4 ; 6695 if (!getifloatarg(args, 4, 0, &arg1)) 6696 return NULL; 6697 if (!getifloatarg(args, 4, 1, &arg2)) 6698 return NULL; 6699 if (!getifloatarg(args, 4, 2, &arg3)) 6700 return NULL; 6701 if (!getifloatarg(args, 4, 3, &arg4)) 6702 return NULL; 6703 sbox( arg1 , arg2 , arg3 , arg4 ); 6704 Py_INCREF(Py_None); 6705 return Py_None; 6706 } 6707 6708 /* void sboxi long s long s long s long s */ 6709 6710 static PyObject * 6711 gl_sboxi(PyObject *self, PyObject *args) 6712 { 6713 long arg1 ; 6714 long arg2 ; 6715 long arg3 ; 6716 long arg4 ; 6717 if (!getilongarg(args, 4, 0, &arg1)) 6718 return NULL; 6719 if (!getilongarg(args, 4, 1, &arg2)) 6720 return NULL; 6721 if (!getilongarg(args, 4, 2, &arg3)) 6722 return NULL; 6723 if (!getilongarg(args, 4, 3, &arg4)) 6724 return NULL; 6725 sboxi( arg1 , arg2 , arg3 , arg4 ); 6726 Py_INCREF(Py_None); 6727 return Py_None; 6728 } 6729 6730 /* void sboxs short s short s short s short s */ 6731 6732 static PyObject * 6733 gl_sboxs(PyObject *self, PyObject *args) 6734 { 6735 short arg1 ; 6736 short arg2 ; 6737 short arg3 ; 6738 short arg4 ; 6739 if (!getishortarg(args, 4, 0, &arg1)) 6740 return NULL; 6741 if (!getishortarg(args, 4, 1, &arg2)) 6742 return NULL; 6743 if (!getishortarg(args, 4, 2, &arg3)) 6744 return NULL; 6745 if (!getishortarg(args, 4, 3, &arg4)) 6746 return NULL; 6747 sboxs( arg1 , arg2 , arg3 , arg4 ); 6748 Py_INCREF(Py_None); 6749 return Py_None; 6750 } 6751 6752 /* void sboxf float s float s float s float s */ 6753 6754 static PyObject * 6755 gl_sboxf(PyObject *self, PyObject *args) 6756 { 6757 float arg1 ; 6758 float arg2 ; 6759 float arg3 ; 6760 float arg4 ; 6761 if (!getifloatarg(args, 4, 0, &arg1)) 6762 return NULL; 6763 if (!getifloatarg(args, 4, 1, &arg2)) 6764 return NULL; 6765 if (!getifloatarg(args, 4, 2, &arg3)) 6766 return NULL; 6767 if (!getifloatarg(args, 4, 3, &arg4)) 6768 return NULL; 6769 sboxf( arg1 , arg2 , arg3 , arg4 ); 6770 Py_INCREF(Py_None); 6771 return Py_None; 6772 } 6773 6774 /* void sboxfi long s long s long s long s */ 6775 6776 static PyObject * 6777 gl_sboxfi(PyObject *self, PyObject *args) 6778 { 6779 long arg1 ; 6780 long arg2 ; 6781 long arg3 ; 6782 long arg4 ; 6783 if (!getilongarg(args, 4, 0, &arg1)) 6784 return NULL; 6785 if (!getilongarg(args, 4, 1, &arg2)) 6786 return NULL; 6787 if (!getilongarg(args, 4, 2, &arg3)) 6788 return NULL; 6789 if (!getilongarg(args, 4, 3, &arg4)) 6790 return NULL; 6791 sboxfi( arg1 , arg2 , arg3 , arg4 ); 6792 Py_INCREF(Py_None); 6793 return Py_None; 6794 } 6795 6796 /* void sboxfs short s short s short s short s */ 6797 6798 static PyObject * 6799 gl_sboxfs(PyObject *self, PyObject *args) 6800 { 6801 short arg1 ; 6802 short arg2 ; 6803 short arg3 ; 6804 short arg4 ; 6805 if (!getishortarg(args, 4, 0, &arg1)) 6806 return NULL; 6807 if (!getishortarg(args, 4, 1, &arg2)) 6808 return NULL; 6809 if (!getishortarg(args, 4, 2, &arg3)) 6810 return NULL; 6811 if (!getishortarg(args, 4, 3, &arg4)) 6812 return NULL; 6813 sboxfs( arg1 , arg2 , arg3 , arg4 ); 6814 Py_INCREF(Py_None); 6815 return Py_None; 6816 } 6817 6818 /* void setnurbsproperty long s float s */ 6819 6820 static PyObject * 6821 gl_setnurbsproperty(PyObject *self, PyObject *args) 6822 { 6823 long arg1 ; 6824 float arg2 ; 6825 if (!getilongarg(args, 2, 0, &arg1)) 6826 return NULL; 6827 if (!getifloatarg(args, 2, 1, &arg2)) 6828 return NULL; 6829 setnurbsproperty( arg1 , arg2 ); 6830 Py_INCREF(Py_None); 6831 return Py_None; 6832 } 6833 6834 /* void setpup long s long s long s */ 6835 6836 static PyObject * 6837 gl_setpup(PyObject *self, PyObject *args) 6838 { 6839 long arg1 ; 6840 long arg2 ; 6841 long arg3 ; 6842 if (!getilongarg(args, 3, 0, &arg1)) 6843 return NULL; 6844 if (!getilongarg(args, 3, 1, &arg2)) 6845 return NULL; 6846 if (!getilongarg(args, 3, 2, &arg3)) 6847 return NULL; 6848 setpup( arg1 , arg2 , arg3 ); 6849 Py_INCREF(Py_None); 6850 return Py_None; 6851 } 6852 6853 /* void smoothline long s */ 6854 6855 static PyObject * 6856 gl_smoothline(PyObject *self, PyObject *args) 6857 { 6858 long arg1 ; 6859 if (!getilongarg(args, 1, 0, &arg1)) 6860 return NULL; 6861 smoothline( arg1 ); 6862 Py_INCREF(Py_None); 6863 return Py_None; 6864 } 6865 6866 /* void subpixel long s */ 6867 6868 static PyObject * 6869 gl_subpixel(PyObject *self, PyObject *args) 6870 { 6871 long arg1 ; 6872 if (!getilongarg(args, 1, 0, &arg1)) 6873 return NULL; 6874 subpixel( arg1 ); 6875 Py_INCREF(Py_None); 6876 return Py_None; 6877 } 6878 6879 /* void swaptmesh */ 6880 6881 static PyObject * 6882 gl_swaptmesh(PyObject *self, PyObject *args) 6883 { 6884 swaptmesh( ); 6885 Py_INCREF(Py_None); 6886 return Py_None; 6887 } 6888 6889 /* long swinopen long s */ 6890 6891 static PyObject * 6892 gl_swinopen(PyObject *self, PyObject *args) 6893 { 6894 long retval; 6895 long arg1 ; 6896 if (!getilongarg(args, 1, 0, &arg1)) 6897 return NULL; 6898 retval = swinopen( arg1 ); 6899 return mknewlongobject(retval); 6900 } 6901 6902 /* void v2f float s[2] */ 6903 6904 static PyObject * 6905 gl_v2f(PyObject *self, PyObject *args) 6906 { 6907 float arg1 [ 2 ] ; 6908 if (!getifloatarray(args, 1, 0, 2 , arg1)) 6909 return NULL; 6910 v2f( arg1 ); 6911 Py_INCREF(Py_None); 6912 return Py_None; 6913 } 6914 6915 /* void v2i long s[2] */ 6916 6917 static PyObject * 6918 gl_v2i(PyObject *self, PyObject *args) 6919 { 6920 long arg1 [ 2 ] ; 6921 if (!getilongarray(args, 1, 0, 2 , arg1)) 6922 return NULL; 6923 v2i( arg1 ); 6924 Py_INCREF(Py_None); 6925 return Py_None; 6926 } 6927 6928 /* void v2s short s[2] */ 6929 6930 static PyObject * 6931 gl_v2s(PyObject *self, PyObject *args) 6932 { 6933 short arg1 [ 2 ] ; 6934 if (!getishortarray(args, 1, 0, 2 , arg1)) 6935 return NULL; 6936 v2s( arg1 ); 6937 Py_INCREF(Py_None); 6938 return Py_None; 6939 } 6940 6941 /* void v3f float s[3] */ 6942 6943 static PyObject * 6944 gl_v3f(PyObject *self, PyObject *args) 6945 { 6946 float arg1 [ 3 ] ; 6947 if (!getifloatarray(args, 1, 0, 3 , arg1)) 6948 return NULL; 6949 v3f( arg1 ); 6950 Py_INCREF(Py_None); 6951 return Py_None; 6952 } 6953 6954 /* void v3i long s[3] */ 6955 6956 static PyObject * 6957 gl_v3i(PyObject *self, PyObject *args) 6958 { 6959 long arg1 [ 3 ] ; 6960 if (!getilongarray(args, 1, 0, 3 , arg1)) 6961 return NULL; 6962 v3i( arg1 ); 6963 Py_INCREF(Py_None); 6964 return Py_None; 6965 } 6966 6967 /* void v3s short s[3] */ 6968 6969 static PyObject * 6970 gl_v3s(PyObject *self, PyObject *args) 6971 { 6972 short arg1 [ 3 ] ; 6973 if (!getishortarray(args, 1, 0, 3 , arg1)) 6974 return NULL; 6975 v3s( arg1 ); 6976 Py_INCREF(Py_None); 6977 return Py_None; 6978 } 6979 6980 /* void v4f float s[4] */ 6981 6982 static PyObject * 6983 gl_v4f(PyObject *self, PyObject *args) 6984 { 6985 float arg1 [ 4 ] ; 6986 if (!getifloatarray(args, 1, 0, 4 , arg1)) 6987 return NULL; 6988 v4f( arg1 ); 6989 Py_INCREF(Py_None); 6990 return Py_None; 6991 } 6992 6993 /* void v4i long s[4] */ 6994 6995 static PyObject * 6996 gl_v4i(PyObject *self, PyObject *args) 6997 { 6998 long arg1 [ 4 ] ; 6999 if (!getilongarray(args, 1, 0, 4 , arg1)) 7000 return NULL; 7001 v4i( arg1 ); 7002 Py_INCREF(Py_None); 7003 return Py_None; 7004 } 7005 7006 /* void v4s short s[4] */ 7007 7008 static PyObject * 7009 gl_v4s(PyObject *self, PyObject *args) 7010 { 7011 short arg1 [ 4 ] ; 7012 if (!getishortarray(args, 1, 0, 4 , arg1)) 7013 return NULL; 7014 v4s( arg1 ); 7015 Py_INCREF(Py_None); 7016 return Py_None; 7017 } 7018 7019 /* void videocmd long s */ 7020 7021 static PyObject * 7022 gl_videocmd(PyObject *self, PyObject *args) 7023 { 7024 long arg1 ; 7025 if (!getilongarg(args, 1, 0, &arg1)) 7026 return NULL; 7027 videocmd( arg1 ); 7028 Py_INCREF(Py_None); 7029 return Py_None; 7030 } 7031 7032 /* long windepth long s */ 7033 7034 static PyObject * 7035 gl_windepth(PyObject *self, PyObject *args) 7036 { 7037 long retval; 7038 long arg1 ; 7039 if (!getilongarg(args, 1, 0, &arg1)) 7040 return NULL; 7041 retval = windepth( arg1 ); 7042 return mknewlongobject(retval); 7043 } 7044 7045 /* void wmpack long s */ 7046 7047 static PyObject * 7048 gl_wmpack(PyObject *self, PyObject *args) 7049 { 7050 long arg1 ; 7051 if (!getilongarg(args, 1, 0, &arg1)) 7052 return NULL; 7053 wmpack( arg1 ); 7054 Py_INCREF(Py_None); 7055 return Py_None; 7056 } 7057 7058 /* void zdraw long s */ 7059 7060 static PyObject * 7061 gl_zdraw(PyObject *self, PyObject *args) 7062 { 7063 long arg1 ; 7064 if (!getilongarg(args, 1, 0, &arg1)) 7065 return NULL; 7066 zdraw( arg1 ); 7067 Py_INCREF(Py_None); 7068 return Py_None; 7069 } 7070 7071 /* void zfunction long s */ 7072 7073 static PyObject * 7074 gl_zfunction(PyObject *self, PyObject *args) 7075 { 7076 long arg1 ; 7077 if (!getilongarg(args, 1, 0, &arg1)) 7078 return NULL; 7079 zfunction( arg1 ); 7080 Py_INCREF(Py_None); 7081 return Py_None; 7082 } 7083 7084 /* void zsource long s */ 7085 7086 static PyObject * 7087 gl_zsource(PyObject *self, PyObject *args) 7088 { 7089 long arg1 ; 7090 if (!getilongarg(args, 1, 0, &arg1)) 7091 return NULL; 7092 zsource( arg1 ); 7093 Py_INCREF(Py_None); 7094 return Py_None; 7095 } 7096 7097 /* void zwritemask long s */ 7098 7099 static PyObject * 7100 gl_zwritemask(PyObject *self, PyObject *args) 7101 { 7102 long arg1 ; 7103 if (!getilongarg(args, 1, 0, &arg1)) 7104 return NULL; 7105 zwritemask( arg1 ); 7106 Py_INCREF(Py_None); 7107 return Py_None; 7108 } 7109 7110 /* void v2d double s[2] */ 7111 7112 static PyObject * 7113 gl_v2d(PyObject *self, PyObject *args) 7114 { 7115 double arg1 [ 2 ] ; 7116 if (!getidoublearray(args, 1, 0, 2 , arg1)) 7117 return NULL; 7118 v2d( arg1 ); 7119 Py_INCREF(Py_None); 7120 return Py_None; 7121 } 7122 7123 /* void v3d double s[3] */ 7124 7125 static PyObject * 7126 gl_v3d(PyObject *self, PyObject *args) 7127 { 7128 double arg1 [ 3 ] ; 7129 if (!getidoublearray(args, 1, 0, 3 , arg1)) 7130 return NULL; 7131 v3d( arg1 ); 7132 Py_INCREF(Py_None); 7133 return Py_None; 7134 } 7135 7136 /* void v4d double s[4] */ 7137 7138 static PyObject * 7139 gl_v4d(PyObject *self, PyObject *args) 7140 { 7141 double arg1 [ 4 ] ; 7142 if (!getidoublearray(args, 1, 0, 4 , arg1)) 7143 return NULL; 7144 v4d( arg1 ); 7145 Py_INCREF(Py_None); 7146 return Py_None; 7147 } 7148 7149 /* void pixmode long s long s */ 7150 7151 static PyObject * 7152 gl_pixmode(PyObject *self, PyObject *args) 7153 { 7154 long arg1 ; 7155 long arg2 ; 7156 if (!getilongarg(args, 2, 0, &arg1)) 7157 return NULL; 7158 if (!getilongarg(args, 2, 1, &arg2)) 7159 return NULL; 7160 pixmode( arg1 , arg2 ); 7161 Py_INCREF(Py_None); 7162 return Py_None; 7163 } 7164 7165 /* long qgetfd */ 7166 7167 static PyObject * 7168 gl_qgetfd(PyObject *self, PyObject *args) 7169 { 7170 long retval; 7171 retval = qgetfd( ); 7172 return mknewlongobject(retval); 7173 } 7174 7175 /* void dither long s */ 7176 7177 static PyObject * 7178 gl_dither(PyObject *self, PyObject *args) 7179 { 7180 long arg1 ; 7181 if (!getilongarg(args, 1, 0, &arg1)) 7182 return NULL; 7183 dither( arg1 ); 7184 Py_INCREF(Py_None); 7185 return Py_None; 7186 } 7187 7188 static struct PyMethodDef gl_methods[] = { 7189 {"qread", gl_qread, METH_OLDARGS}, 7190 {"varray", gl_varray, METH_OLDARGS}, 7191 {"nvarray", gl_nvarray, METH_OLDARGS}, 7192 {"vnarray", gl_vnarray, METH_OLDARGS}, 7193 {"nurbssurface", gl_nurbssurface, METH_OLDARGS}, 7194 {"nurbscurve", gl_nurbscurve, METH_OLDARGS}, 7195 {"pwlcurve", gl_pwlcurve, METH_OLDARGS}, 7196 {"pick", gl_pick, METH_OLDARGS}, 7197 {"endpick", gl_endpick, METH_NOARGS}, 7198 {"gselect", gl_gselect, METH_OLDARGS}, 7199 {"endselect", gl_endselect, METH_NOARGS}, 7200 {"getmatrix", gl_getmatrix, METH_OLDARGS}, 7201 {"altgetmatrix", gl_altgetmatrix, METH_OLDARGS}, 7202 {"lrectwrite", gl_lrectwrite, METH_OLDARGS}, 7203 {"lrectread", gl_lrectread, METH_OLDARGS}, 7204 {"readdisplay", gl_readdisplay, METH_OLDARGS}, 7205 {"packrect", gl_packrect, METH_OLDARGS}, 7206 {"unpackrect", gl_unpackrect, METH_OLDARGS}, 7207 {"gversion", gl_gversion, METH_OLDARGS}, 7208 {"clear", gl_clear, METH_OLDARGS}, 7209 {"getshade", gl_getshade, METH_OLDARGS}, 7210 {"devport", gl_devport, METH_OLDARGS}, 7211 {"rdr2i", gl_rdr2i, METH_OLDARGS}, 7212 {"rectfs", gl_rectfs, METH_OLDARGS}, 7213 {"rects", gl_rects, METH_OLDARGS}, 7214 {"rmv2i", gl_rmv2i, METH_OLDARGS}, 7215 {"noport", gl_noport, METH_OLDARGS}, 7216 {"popviewport", gl_popviewport, METH_OLDARGS}, 7217 {"clearhitcode", gl_clearhitcode, METH_OLDARGS}, 7218 {"closeobj", gl_closeobj, METH_OLDARGS}, 7219 {"cursoff", gl_cursoff, METH_OLDARGS}, 7220 {"curson", gl_curson, METH_OLDARGS}, 7221 {"doublebuffer", gl_doublebuffer, METH_OLDARGS}, 7222 {"finish", gl_finish, METH_OLDARGS}, 7223 {"gconfig", gl_gconfig, METH_OLDARGS}, 7224 {"ginit", gl_ginit, METH_OLDARGS}, 7225 {"greset", gl_greset, METH_OLDARGS}, 7226 {"multimap", gl_multimap, METH_OLDARGS}, 7227 {"onemap", gl_onemap, METH_OLDARGS}, 7228 {"popattributes", gl_popattributes, METH_OLDARGS}, 7229 {"popmatrix", gl_popmatrix, METH_OLDARGS}, 7230 {"pushattributes", gl_pushattributes,METH_OLDARGS}, 7231 {"pushmatrix", gl_pushmatrix, METH_OLDARGS}, 7232 {"pushviewport", gl_pushviewport, METH_OLDARGS}, 7233 {"qreset", gl_qreset, METH_OLDARGS}, 7234 {"RGBmode", gl_RGBmode, METH_OLDARGS}, 7235 {"singlebuffer", gl_singlebuffer, METH_OLDARGS}, 7236 {"swapbuffers", gl_swapbuffers, METH_OLDARGS}, 7237 {"gsync", gl_gsync, METH_OLDARGS}, 7238 {"gflush", gl_gflush, METH_OLDARGS}, 7239 {"tpon", gl_tpon, METH_OLDARGS}, 7240 {"tpoff", gl_tpoff, METH_OLDARGS}, 7241 {"clkon", gl_clkon, METH_OLDARGS}, 7242 {"clkoff", gl_clkoff, METH_OLDARGS}, 7243 {"ringbell", gl_ringbell, METH_OLDARGS}, 7244 {"gbegin", gl_gbegin, METH_OLDARGS}, 7245 {"textinit", gl_textinit, METH_OLDARGS}, 7246 {"initnames", gl_initnames, METH_OLDARGS}, 7247 {"pclos", gl_pclos, METH_OLDARGS}, 7248 {"popname", gl_popname, METH_OLDARGS}, 7249 {"spclos", gl_spclos, METH_OLDARGS}, 7250 {"zclear", gl_zclear, METH_OLDARGS}, 7251 {"screenspace", gl_screenspace, METH_OLDARGS}, 7252 {"reshapeviewport", gl_reshapeviewport, METH_OLDARGS}, 7253 {"winpush", gl_winpush, METH_OLDARGS}, 7254 {"winpop", gl_winpop, METH_OLDARGS}, 7255 {"foreground", gl_foreground, METH_OLDARGS}, 7256 {"endfullscrn", gl_endfullscrn, METH_OLDARGS}, 7257 {"endpupmode", gl_endpupmode, METH_OLDARGS}, 7258 {"fullscrn", gl_fullscrn, METH_OLDARGS}, 7259 {"pupmode", gl_pupmode, METH_OLDARGS}, 7260 {"winconstraints", gl_winconstraints, METH_OLDARGS}, 7261 {"pagecolor", gl_pagecolor, METH_OLDARGS}, 7262 {"textcolor", gl_textcolor, METH_OLDARGS}, 7263 {"color", gl_color, METH_OLDARGS}, 7264 {"curveit", gl_curveit, METH_OLDARGS}, 7265 {"font", gl_font, METH_OLDARGS}, 7266 {"linewidth", gl_linewidth, METH_OLDARGS}, 7267 {"setlinestyle", gl_setlinestyle, METH_OLDARGS}, 7268 {"setmap", gl_setmap, METH_OLDARGS}, 7269 {"swapinterval", gl_swapinterval, METH_OLDARGS}, 7270 {"writemask", gl_writemask, METH_OLDARGS}, 7271 {"textwritemask", gl_textwritemask, METH_OLDARGS}, 7272 {"qdevice", gl_qdevice, METH_OLDARGS}, 7273 {"unqdevice", gl_unqdevice, METH_OLDARGS}, 7274 {"curvebasis", gl_curvebasis, METH_OLDARGS}, 7275 {"curveprecision", gl_curveprecision,METH_OLDARGS}, 7276 {"loadname", gl_loadname, METH_OLDARGS}, 7277 {"passthrough", gl_passthrough, METH_OLDARGS}, 7278 {"pushname", gl_pushname, METH_OLDARGS}, 7279 {"setmonitor", gl_setmonitor, METH_OLDARGS}, 7280 {"setshade", gl_setshade, METH_OLDARGS}, 7281 {"setpattern", gl_setpattern, METH_OLDARGS}, 7282 {"pagewritemask", gl_pagewritemask, METH_OLDARGS}, 7283 {"callobj", gl_callobj, METH_OLDARGS}, 7284 {"delobj", gl_delobj, METH_OLDARGS}, 7285 {"editobj", gl_editobj, METH_OLDARGS}, 7286 {"makeobj", gl_makeobj, METH_OLDARGS}, 7287 {"maketag", gl_maketag, METH_OLDARGS}, 7288 {"chunksize", gl_chunksize, METH_OLDARGS}, 7289 {"compactify", gl_compactify, METH_OLDARGS}, 7290 {"deltag", gl_deltag, METH_OLDARGS}, 7291 {"lsrepeat", gl_lsrepeat, METH_OLDARGS}, 7292 {"objinsert", gl_objinsert, METH_OLDARGS}, 7293 {"objreplace", gl_objreplace, METH_OLDARGS}, 7294 {"winclose", gl_winclose, METH_OLDARGS}, 7295 {"blanktime", gl_blanktime, METH_OLDARGS}, 7296 {"freepup", gl_freepup, METH_OLDARGS}, 7297 {"backbuffer", gl_backbuffer, METH_OLDARGS}, 7298 {"frontbuffer", gl_frontbuffer, METH_OLDARGS}, 7299 {"lsbackup", gl_lsbackup, METH_OLDARGS}, 7300 {"resetls", gl_resetls, METH_OLDARGS}, 7301 {"lampon", gl_lampon, METH_OLDARGS}, 7302 {"lampoff", gl_lampoff, METH_OLDARGS}, 7303 {"setbell", gl_setbell, METH_OLDARGS}, 7304 {"blankscreen", gl_blankscreen, METH_OLDARGS}, 7305 {"depthcue", gl_depthcue, METH_OLDARGS}, 7306 {"zbuffer", gl_zbuffer, METH_OLDARGS}, 7307 {"backface", gl_backface, METH_OLDARGS}, 7308 {"cmov2i", gl_cmov2i, METH_OLDARGS}, 7309 {"draw2i", gl_draw2i, METH_OLDARGS}, 7310 {"move2i", gl_move2i, METH_OLDARGS}, 7311 {"pnt2i", gl_pnt2i, METH_OLDARGS}, 7312 {"patchbasis", gl_patchbasis, METH_OLDARGS}, 7313 {"patchprecision", gl_patchprecision, METH_OLDARGS}, 7314 {"pdr2i", gl_pdr2i, METH_OLDARGS}, 7315 {"pmv2i", gl_pmv2i, METH_OLDARGS}, 7316 {"rpdr2i", gl_rpdr2i, METH_OLDARGS}, 7317 {"rpmv2i", gl_rpmv2i, METH_OLDARGS}, 7318 {"xfpt2i", gl_xfpt2i, METH_OLDARGS}, 7319 {"objdelete", gl_objdelete, METH_OLDARGS}, 7320 {"patchcurves", gl_patchcurves, METH_OLDARGS}, 7321 {"minsize", gl_minsize, METH_OLDARGS}, 7322 {"maxsize", gl_maxsize, METH_OLDARGS}, 7323 {"keepaspect", gl_keepaspect, METH_OLDARGS}, 7324 {"prefsize", gl_prefsize, METH_OLDARGS}, 7325 {"stepunit", gl_stepunit, METH_OLDARGS}, 7326 {"fudge", gl_fudge, METH_OLDARGS}, 7327 {"winmove", gl_winmove, METH_OLDARGS}, 7328 {"attachcursor", gl_attachcursor, METH_OLDARGS}, 7329 {"deflinestyle", gl_deflinestyle, METH_OLDARGS}, 7330 {"noise", gl_noise, METH_OLDARGS}, 7331 {"picksize", gl_picksize, METH_OLDARGS}, 7332 {"qenter", gl_qenter, METH_OLDARGS}, 7333 {"setdepth", gl_setdepth, METH_OLDARGS}, 7334 {"cmov2s", gl_cmov2s, METH_OLDARGS}, 7335 {"draw2s", gl_draw2s, METH_OLDARGS}, 7336 {"move2s", gl_move2s, METH_OLDARGS}, 7337 {"pdr2s", gl_pdr2s, METH_OLDARGS}, 7338 {"pmv2s", gl_pmv2s, METH_OLDARGS}, 7339 {"pnt2s", gl_pnt2s, METH_OLDARGS}, 7340 {"rdr2s", gl_rdr2s, METH_OLDARGS}, 7341 {"rmv2s", gl_rmv2s, METH_OLDARGS}, 7342 {"rpdr2s", gl_rpdr2s, METH_OLDARGS}, 7343 {"rpmv2s", gl_rpmv2s, METH_OLDARGS}, 7344 {"xfpt2s", gl_xfpt2s, METH_OLDARGS}, 7345 {"cmov2", gl_cmov2, METH_OLDARGS}, 7346 {"draw2", gl_draw2, METH_OLDARGS}, 7347 {"move2", gl_move2, METH_OLDARGS}, 7348 {"pnt2", gl_pnt2, METH_OLDARGS}, 7349 {"pdr2", gl_pdr2, METH_OLDARGS}, 7350 {"pmv2", gl_pmv2, METH_OLDARGS}, 7351 {"rdr2", gl_rdr2, METH_OLDARGS}, 7352 {"rmv2", gl_rmv2, METH_OLDARGS}, 7353 {"rpdr2", gl_rpdr2, METH_OLDARGS}, 7354 {"rpmv2", gl_rpmv2, METH_OLDARGS}, 7355 {"xfpt2", gl_xfpt2, METH_OLDARGS}, 7356 {"loadmatrix", gl_loadmatrix, METH_OLDARGS}, 7357 {"multmatrix", gl_multmatrix, METH_OLDARGS}, 7358 {"crv", gl_crv, METH_OLDARGS}, 7359 {"rcrv", gl_rcrv, METH_OLDARGS}, 7360 {"addtopup", gl_addtopup, METH_OLDARGS}, 7361 {"charstr", gl_charstr, METH_OLDARGS}, 7362 {"getport", gl_getport, METH_OLDARGS}, 7363 {"strwidth", gl_strwidth, METH_OLDARGS}, 7364 {"winopen", gl_winopen, METH_OLDARGS}, 7365 {"wintitle", gl_wintitle, METH_OLDARGS}, 7366 {"polf", gl_polf, METH_OLDARGS}, 7367 {"polf2", gl_polf2, METH_OLDARGS}, 7368 {"poly", gl_poly, METH_OLDARGS}, 7369 {"poly2", gl_poly2, METH_OLDARGS}, 7370 {"crvn", gl_crvn, METH_OLDARGS}, 7371 {"rcrvn", gl_rcrvn, METH_OLDARGS}, 7372 {"polf2i", gl_polf2i, METH_OLDARGS}, 7373 {"polfi", gl_polfi, METH_OLDARGS}, 7374 {"poly2i", gl_poly2i, METH_OLDARGS}, 7375 {"polyi", gl_polyi, METH_OLDARGS}, 7376 {"polf2s", gl_polf2s, METH_OLDARGS}, 7377 {"polfs", gl_polfs, METH_OLDARGS}, 7378 {"polys", gl_polys, METH_OLDARGS}, 7379 {"poly2s", gl_poly2s, METH_OLDARGS}, 7380 {"defcursor", gl_defcursor, METH_OLDARGS}, 7381 {"writepixels", gl_writepixels, METH_OLDARGS}, 7382 {"defbasis", gl_defbasis, METH_OLDARGS}, 7383 {"gewrite", gl_gewrite, METH_OLDARGS}, 7384 {"rotate", gl_rotate, METH_OLDARGS}, 7385 {"rot", gl_rot, METH_OLDARGS}, 7386 {"circfi", gl_circfi, METH_OLDARGS}, 7387 {"circi", gl_circi, METH_OLDARGS}, 7388 {"cmovi", gl_cmovi, METH_OLDARGS}, 7389 {"drawi", gl_drawi, METH_OLDARGS}, 7390 {"movei", gl_movei, METH_OLDARGS}, 7391 {"pnti", gl_pnti, METH_OLDARGS}, 7392 {"newtag", gl_newtag, METH_OLDARGS}, 7393 {"pdri", gl_pdri, METH_OLDARGS}, 7394 {"pmvi", gl_pmvi, METH_OLDARGS}, 7395 {"rdri", gl_rdri, METH_OLDARGS}, 7396 {"rmvi", gl_rmvi, METH_OLDARGS}, 7397 {"rpdri", gl_rpdri, METH_OLDARGS}, 7398 {"rpmvi", gl_rpmvi, METH_OLDARGS}, 7399 {"xfpti", gl_xfpti, METH_OLDARGS}, 7400 {"circ", gl_circ, METH_OLDARGS}, 7401 {"circf", gl_circf, METH_OLDARGS}, 7402 {"cmov", gl_cmov, METH_OLDARGS}, 7403 {"draw", gl_draw, METH_OLDARGS}, 7404 {"move", gl_move, METH_OLDARGS}, 7405 {"pnt", gl_pnt, METH_OLDARGS}, 7406 {"scale", gl_scale, METH_OLDARGS}, 7407 {"translate", gl_translate, METH_OLDARGS}, 7408 {"pdr", gl_pdr, METH_OLDARGS}, 7409 {"pmv", gl_pmv, METH_OLDARGS}, 7410 {"rdr", gl_rdr, METH_OLDARGS}, 7411 {"rmv", gl_rmv, METH_OLDARGS}, 7412 {"rpdr", gl_rpdr, METH_OLDARGS}, 7413 {"rpmv", gl_rpmv, METH_OLDARGS}, 7414 {"xfpt", gl_xfpt, METH_OLDARGS}, 7415 {"RGBcolor", gl_RGBcolor, METH_OLDARGS}, 7416 {"RGBwritemask", gl_RGBwritemask, METH_OLDARGS}, 7417 {"setcursor", gl_setcursor, METH_OLDARGS}, 7418 {"tie", gl_tie, METH_OLDARGS}, 7419 {"circfs", gl_circfs, METH_OLDARGS}, 7420 {"circs", gl_circs, METH_OLDARGS}, 7421 {"cmovs", gl_cmovs, METH_OLDARGS}, 7422 {"draws", gl_draws, METH_OLDARGS}, 7423 {"moves", gl_moves, METH_OLDARGS}, 7424 {"pdrs", gl_pdrs, METH_OLDARGS}, 7425 {"pmvs", gl_pmvs, METH_OLDARGS}, 7426 {"pnts", gl_pnts, METH_OLDARGS}, 7427 {"rdrs", gl_rdrs, METH_OLDARGS}, 7428 {"rmvs", gl_rmvs, METH_OLDARGS}, 7429 {"rpdrs", gl_rpdrs, METH_OLDARGS}, 7430 {"rpmvs", gl_rpmvs, METH_OLDARGS}, 7431 {"xfpts", gl_xfpts, METH_OLDARGS}, 7432 {"curorigin", gl_curorigin, METH_OLDARGS}, 7433 {"cyclemap", gl_cyclemap, METH_OLDARGS}, 7434 {"patch", gl_patch, METH_OLDARGS}, 7435 {"splf", gl_splf, METH_OLDARGS}, 7436 {"splf2", gl_splf2, METH_OLDARGS}, 7437 {"splfi", gl_splfi, METH_OLDARGS}, 7438 {"splf2i", gl_splf2i, METH_OLDARGS}, 7439 {"splfs", gl_splfs, METH_OLDARGS}, 7440 {"splf2s", gl_splf2s, METH_OLDARGS}, 7441 {"rpatch", gl_rpatch, METH_OLDARGS}, 7442 {"ortho2", gl_ortho2, METH_OLDARGS}, 7443 {"rect", gl_rect, METH_OLDARGS}, 7444 {"rectf", gl_rectf, METH_OLDARGS}, 7445 {"xfpt4", gl_xfpt4, METH_OLDARGS}, 7446 {"textport", gl_textport, METH_OLDARGS}, 7447 {"mapcolor", gl_mapcolor, METH_OLDARGS}, 7448 {"scrmask", gl_scrmask, METH_OLDARGS}, 7449 {"setvaluator", gl_setvaluator, METH_OLDARGS}, 7450 {"viewport", gl_viewport, METH_OLDARGS}, 7451 {"shaderange", gl_shaderange, METH_OLDARGS}, 7452 {"xfpt4s", gl_xfpt4s, METH_OLDARGS}, 7453 {"rectfi", gl_rectfi, METH_OLDARGS}, 7454 {"recti", gl_recti, METH_OLDARGS}, 7455 {"xfpt4i", gl_xfpt4i, METH_OLDARGS}, 7456 {"prefposition", gl_prefposition, METH_OLDARGS}, 7457 {"arc", gl_arc, METH_OLDARGS}, 7458 {"arcf", gl_arcf, METH_OLDARGS}, 7459 {"arcfi", gl_arcfi, METH_OLDARGS}, 7460 {"arci", gl_arci, METH_OLDARGS}, 7461 {"bbox2", gl_bbox2, METH_OLDARGS}, 7462 {"bbox2i", gl_bbox2i, METH_OLDARGS}, 7463 {"bbox2s", gl_bbox2s, METH_OLDARGS}, 7464 {"blink", gl_blink, METH_OLDARGS}, 7465 {"ortho", gl_ortho, METH_OLDARGS}, 7466 {"window", gl_window, METH_OLDARGS}, 7467 {"lookat", gl_lookat, METH_OLDARGS}, 7468 {"perspective", gl_perspective, METH_OLDARGS}, 7469 {"polarview", gl_polarview, METH_OLDARGS}, 7470 {"arcfs", gl_arcfs, METH_OLDARGS}, 7471 {"arcs", gl_arcs, METH_OLDARGS}, 7472 {"rectcopy", gl_rectcopy, METH_OLDARGS}, 7473 {"RGBcursor", gl_RGBcursor, METH_OLDARGS}, 7474 {"getbutton", gl_getbutton, METH_OLDARGS}, 7475 {"getcmmode", gl_getcmmode, METH_OLDARGS}, 7476 {"getlsbackup", gl_getlsbackup, METH_OLDARGS}, 7477 {"getresetls", gl_getresetls, METH_OLDARGS}, 7478 {"getdcm", gl_getdcm, METH_OLDARGS}, 7479 {"getzbuffer", gl_getzbuffer, METH_OLDARGS}, 7480 {"ismex", gl_ismex, METH_OLDARGS}, 7481 {"isobj", gl_isobj, METH_OLDARGS}, 7482 {"isqueued", gl_isqueued, METH_OLDARGS}, 7483 {"istag", gl_istag, METH_OLDARGS}, 7484 {"genobj", gl_genobj, METH_OLDARGS}, 7485 {"gentag", gl_gentag, METH_OLDARGS}, 7486 {"getbuffer", gl_getbuffer, METH_OLDARGS}, 7487 {"getcolor", gl_getcolor, METH_OLDARGS}, 7488 {"getdisplaymode", gl_getdisplaymode, METH_OLDARGS}, 7489 {"getfont", gl_getfont, METH_OLDARGS}, 7490 {"getheight", gl_getheight, METH_OLDARGS}, 7491 {"gethitcode", gl_gethitcode, METH_OLDARGS}, 7492 {"getlstyle", gl_getlstyle, METH_OLDARGS}, 7493 {"getlwidth", gl_getlwidth, METH_OLDARGS}, 7494 {"getmap", gl_getmap, METH_OLDARGS}, 7495 {"getplanes", gl_getplanes, METH_OLDARGS}, 7496 {"getwritemask", gl_getwritemask, METH_OLDARGS}, 7497 {"qtest", gl_qtest, METH_OLDARGS}, 7498 {"getlsrepeat", gl_getlsrepeat, METH_OLDARGS}, 7499 {"getmonitor", gl_getmonitor, METH_OLDARGS}, 7500 {"getopenobj", gl_getopenobj, METH_OLDARGS}, 7501 {"getpattern", gl_getpattern, METH_OLDARGS}, 7502 {"winget", gl_winget, METH_OLDARGS}, 7503 {"winattach", gl_winattach, METH_OLDARGS}, 7504 {"getothermonitor", gl_getothermonitor, METH_OLDARGS}, 7505 {"newpup", gl_newpup, METH_OLDARGS}, 7506 {"getvaluator", gl_getvaluator, METH_OLDARGS}, 7507 {"winset", gl_winset, METH_OLDARGS}, 7508 {"dopup", gl_dopup, METH_OLDARGS}, 7509 {"getdepth", gl_getdepth, METH_OLDARGS}, 7510 {"getcpos", gl_getcpos, METH_OLDARGS}, 7511 {"getsize", gl_getsize, METH_OLDARGS}, 7512 {"getorigin", gl_getorigin, METH_OLDARGS}, 7513 {"getviewport", gl_getviewport, METH_OLDARGS}, 7514 {"gettp", gl_gettp, METH_OLDARGS}, 7515 {"getgpos", gl_getgpos, METH_OLDARGS}, 7516 {"winposition", gl_winposition, METH_OLDARGS}, 7517 {"gRGBcolor", gl_gRGBcolor, METH_OLDARGS}, 7518 {"gRGBmask", gl_gRGBmask, METH_OLDARGS}, 7519 {"getscrmask", gl_getscrmask, METH_OLDARGS}, 7520 {"getmcolor", gl_getmcolor, METH_OLDARGS}, 7521 {"mapw", gl_mapw, METH_OLDARGS}, 7522 {"mapw2", gl_mapw2, METH_OLDARGS}, 7523 {"getcursor", gl_getcursor, METH_OLDARGS}, 7524 {"cmode", gl_cmode, METH_OLDARGS}, 7525 {"concave", gl_concave, METH_OLDARGS}, 7526 {"curstype", gl_curstype, METH_OLDARGS}, 7527 {"drawmode", gl_drawmode, METH_OLDARGS}, 7528 {"gammaramp", gl_gammaramp, METH_OLDARGS}, 7529 {"getbackface", gl_getbackface, METH_OLDARGS}, 7530 {"getdescender", gl_getdescender, METH_OLDARGS}, 7531 {"getdrawmode", gl_getdrawmode, METH_OLDARGS}, 7532 {"getmmode", gl_getmmode, METH_OLDARGS}, 7533 {"getsm", gl_getsm, METH_OLDARGS}, 7534 {"getvideo", gl_getvideo, METH_OLDARGS}, 7535 {"imakebackground", gl_imakebackground, METH_OLDARGS}, 7536 {"lmbind", gl_lmbind, METH_OLDARGS}, 7537 {"lmdef", gl_lmdef, METH_OLDARGS}, 7538 {"mmode", gl_mmode, METH_OLDARGS}, 7539 {"normal", gl_normal, METH_OLDARGS}, 7540 {"overlay", gl_overlay, METH_OLDARGS}, 7541 {"RGBrange", gl_RGBrange, METH_OLDARGS}, 7542 {"setvideo", gl_setvideo, METH_OLDARGS}, 7543 {"shademodel", gl_shademodel, METH_OLDARGS}, 7544 {"underlay", gl_underlay, METH_OLDARGS}, 7545 {"bgnclosedline", gl_bgnclosedline, METH_OLDARGS}, 7546 {"bgnline", gl_bgnline, METH_OLDARGS}, 7547 {"bgnpoint", gl_bgnpoint, METH_OLDARGS}, 7548 {"bgnpolygon", gl_bgnpolygon, METH_OLDARGS}, 7549 {"bgnsurface", gl_bgnsurface, METH_OLDARGS}, 7550 {"bgntmesh", gl_bgntmesh, METH_OLDARGS}, 7551 {"bgntrim", gl_bgntrim, METH_OLDARGS}, 7552 {"endclosedline", gl_endclosedline, METH_OLDARGS}, 7553 {"endline", gl_endline, METH_OLDARGS}, 7554 {"endpoint", gl_endpoint, METH_OLDARGS}, 7555 {"endpolygon", gl_endpolygon, METH_OLDARGS}, 7556 {"endsurface", gl_endsurface, METH_OLDARGS}, 7557 {"endtmesh", gl_endtmesh, METH_OLDARGS}, 7558 {"endtrim", gl_endtrim, METH_OLDARGS}, 7559 {"blendfunction", gl_blendfunction, METH_OLDARGS}, 7560 {"c3f", gl_c3f, METH_OLDARGS}, 7561 {"c3i", gl_c3i, METH_OLDARGS}, 7562 {"c3s", gl_c3s, METH_OLDARGS}, 7563 {"c4f", gl_c4f, METH_OLDARGS}, 7564 {"c4i", gl_c4i, METH_OLDARGS}, 7565 {"c4s", gl_c4s, METH_OLDARGS}, 7566 {"colorf", gl_colorf, METH_OLDARGS}, 7567 {"cpack", gl_cpack, METH_OLDARGS}, 7568 {"czclear", gl_czclear, METH_OLDARGS}, 7569 {"dglclose", gl_dglclose, METH_OLDARGS}, 7570 {"dglopen", gl_dglopen, METH_OLDARGS}, 7571 {"getgdesc", gl_getgdesc, METH_OLDARGS}, 7572 {"getnurbsproperty", gl_getnurbsproperty, METH_OLDARGS}, 7573 {"glcompat", gl_glcompat, METH_OLDARGS}, 7574 {"iconsize", gl_iconsize, METH_OLDARGS}, 7575 {"icontitle", gl_icontitle, METH_OLDARGS}, 7576 {"lRGBrange", gl_lRGBrange, METH_OLDARGS}, 7577 {"linesmooth", gl_linesmooth, METH_OLDARGS}, 7578 {"lmcolor", gl_lmcolor, METH_OLDARGS}, 7579 {"logicop", gl_logicop, METH_OLDARGS}, 7580 {"lsetdepth", gl_lsetdepth, METH_OLDARGS}, 7581 {"lshaderange", gl_lshaderange, METH_OLDARGS}, 7582 {"n3f", gl_n3f, METH_OLDARGS}, 7583 {"noborder", gl_noborder, METH_OLDARGS}, 7584 {"pntsmooth", gl_pntsmooth, METH_OLDARGS}, 7585 {"readsource", gl_readsource, METH_OLDARGS}, 7586 {"rectzoom", gl_rectzoom, METH_OLDARGS}, 7587 {"sbox", gl_sbox, METH_OLDARGS}, 7588 {"sboxi", gl_sboxi, METH_OLDARGS}, 7589 {"sboxs", gl_sboxs, METH_OLDARGS}, 7590 {"sboxf", gl_sboxf, METH_OLDARGS}, 7591 {"sboxfi", gl_sboxfi, METH_OLDARGS}, 7592 {"sboxfs", gl_sboxfs, METH_OLDARGS}, 7593 {"setnurbsproperty", gl_setnurbsproperty, METH_OLDARGS}, 7594 {"setpup", gl_setpup, METH_OLDARGS}, 7595 {"smoothline", gl_smoothline, METH_OLDARGS}, 7596 {"subpixel", gl_subpixel, METH_OLDARGS}, 7597 {"swaptmesh", gl_swaptmesh, METH_OLDARGS}, 7598 {"swinopen", gl_swinopen, METH_OLDARGS}, 7599 {"v2f", gl_v2f, METH_OLDARGS}, 7600 {"v2i", gl_v2i, METH_OLDARGS}, 7601 {"v2s", gl_v2s, METH_OLDARGS}, 7602 {"v3f", gl_v3f, METH_OLDARGS}, 7603 {"v3i", gl_v3i, METH_OLDARGS}, 7604 {"v3s", gl_v3s, METH_OLDARGS}, 7605 {"v4f", gl_v4f, METH_OLDARGS}, 7606 {"v4i", gl_v4i, METH_OLDARGS}, 7607 {"v4s", gl_v4s, METH_OLDARGS}, 7608 {"videocmd", gl_videocmd, METH_OLDARGS}, 7609 {"windepth", gl_windepth, METH_OLDARGS}, 7610 {"wmpack", gl_wmpack, METH_OLDARGS}, 7611 {"zdraw", gl_zdraw, METH_OLDARGS}, 7612 {"zfunction", gl_zfunction, METH_OLDARGS}, 7613 {"zsource", gl_zsource, METH_OLDARGS}, 7614 {"zwritemask", gl_zwritemask, METH_OLDARGS}, 7615 {"v2d", gl_v2d, METH_OLDARGS}, 7616 {"v3d", gl_v3d, METH_OLDARGS}, 7617 {"v4d", gl_v4d, METH_OLDARGS}, 7618 {"pixmode", gl_pixmode, METH_OLDARGS}, 7619 {"qgetfd", gl_qgetfd, METH_OLDARGS}, 7620 {"dither", gl_dither, METH_OLDARGS}, 7621 {NULL, NULL} /* Sentinel */ 7622 }; 7623 7624 void 7625 initgl(void) 7626 { 7627 if (PyErr_WarnPy3k("the gl module has been removed in " 7628 "Python 3.0", 2) < 0) 7629 return; 7630 7631 (void) Py_InitModule("gl", gl_methods); 7632 } 7633
