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