mirror of
https://github.com/python/cpython.git
synced 2024-11-25 19:03:49 +08:00
fbd1d74286
However: "cgensupport.h" is still present... otherwise I get maaaany type errors... not sure if this needs more attention.
8531 lines
158 KiB
C
8531 lines
158 KiB
C
/***********************************************************
|
|
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
The Netherlands.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
|
Centrum or CWI or Corporation for National Research Initiatives or
|
|
CNRI not be used in advertising or publicity pertaining to
|
|
distribution of the software without specific, written prior
|
|
permission.
|
|
|
|
While CWI is the initial source for this software, a modified version
|
|
is made available by the Corporation for National Research Initiatives
|
|
(CNRI) at the Internet address ftp://ftp.python.org.
|
|
|
|
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
|
|
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
/*
|
|
Input used to generate the Python module "glmodule.c".
|
|
The stub generator is a Python script called "cgen.py".
|
|
|
|
Each definition must be contained on one line:
|
|
|
|
<returntype> <name> <type> <arg> <type> <arg>
|
|
|
|
<returntype> can be: void, short, long (XXX maybe others?)
|
|
|
|
<type> can be: char, string, short, float, long, or double
|
|
string indicates a null terminated string;
|
|
if <type> is char and <arg> begins with a *, the * is stripped
|
|
and <type> is changed into string
|
|
|
|
<arg> has the form <mode> or <mode>[<subscript>]
|
|
where <mode> can be
|
|
s: arg is sent
|
|
r: arg is received (arg is a pointer)
|
|
and <subscript> can be (N and I are numbers):
|
|
N
|
|
argI
|
|
retval
|
|
N*argI
|
|
N*I
|
|
N*retval
|
|
In the case where the subscript consists of two parts
|
|
separated by *, the first part is the width of the matrix, and
|
|
the second part is the length of the matrix. This order is
|
|
opposite from the order used in C to declare a two-dimensional
|
|
matrix.
|
|
*/
|
|
|
|
/*
|
|
* An attempt has been made to make this module switch threads on qread
|
|
* calls. It is far from safe, though.
|
|
*/
|
|
|
|
#include <gl.h>
|
|
#include <device.h>
|
|
|
|
#ifdef __sgi
|
|
extern int devport();
|
|
extern int textwritemask();
|
|
extern int pagewritemask();
|
|
extern int gewrite();
|
|
extern int gettp();
|
|
#endif
|
|
|
|
#include "Python.h"
|
|
#include "cgensupport.h"
|
|
|
|
|
|
/*
|
|
Some stubs are too complicated for the stub generator.
|
|
We can include manually written versions of them here.
|
|
A line starting with '%' gives the name of the function so the stub
|
|
generator can include it in the table of functions.
|
|
*/
|
|
|
|
|
|
static PyObject *
|
|
gl_qread(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
short arg1 ;
|
|
Py_BEGIN_ALLOW_THREADS
|
|
retval = qread( & arg1 );
|
|
Py_END_ALLOW_THREADS
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewlongobject(retval));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg1));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
varray -- an array of v.. calls.
|
|
The argument is an array (maybe list or tuple) of points.
|
|
Each point must be a tuple or list of coordinates (x, y, z).
|
|
The points may be 2- or 3-dimensional but must all have the
|
|
same dimension. Float and int values may be mixed however.
|
|
The points are always converted to 3D double precision points
|
|
by assuming z=0.0 if necessary (as indicated in the man page),
|
|
and for each point v3d() is called.
|
|
*/
|
|
|
|
|
|
static PyObject *
|
|
gl_varray(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
PyObject *v, *w=NULL;
|
|
int i, n, width;
|
|
double vec[3];
|
|
PyObject * (*getitem) Py_FPROTO((PyObject *, int));
|
|
|
|
if (!PyArg_GetObject(args, 1, 0, &v))
|
|
return NULL;
|
|
|
|
if (PyList_Check(v)) {
|
|
n = PyList_Size(v);
|
|
getitem = PyList_GetItem;
|
|
}
|
|
else if (PyTuple_Check(v)) {
|
|
n = PyTuple_Size(v);
|
|
getitem = PyTuple_GetItem;
|
|
}
|
|
else {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
|
|
if (n == 0) {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
if (n > 0)
|
|
w = (*getitem)(v, 0);
|
|
|
|
width = 0;
|
|
if (w == NULL) {
|
|
}
|
|
else if (PyList_Check(w)) {
|
|
width = PyList_Size(w);
|
|
}
|
|
else if (PyTuple_Check(w)) {
|
|
width = PyTuple_Size(w);
|
|
}
|
|
|
|
switch (width) {
|
|
case 2:
|
|
vec[2] = 0.0;
|
|
/* Fall through */
|
|
case 3:
|
|
break;
|
|
default:
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
w = (*getitem)(v, i);
|
|
if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
|
|
return NULL;
|
|
v3d(vec);
|
|
}
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
vnarray, nvarray -- an array of n3f and v3f calls.
|
|
The argument is an array (list or tuple) of pairs of points and normals.
|
|
Each pair is a tuple (NOT a list) of a point and a normal for that point.
|
|
Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
|
|
Three coordinates must be given. Float and int values may be mixed.
|
|
For each pair, n3f() is called for the normal, and then v3f() is called
|
|
for the vector.
|
|
|
|
vnarray and nvarray differ only in the order of the vector and normal in
|
|
the pair: vnarray expects (v, n) while nvarray expects (n, v).
|
|
*/
|
|
|
|
static PyObject *gen_nvarray(); /* Forward */
|
|
|
|
|
|
static PyObject *
|
|
gl_nvarray(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
return gen_nvarray(args, 0);
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
gl_vnarray(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
return gen_nvarray(args, 1);
|
|
}
|
|
|
|
/* Generic, internal version of {nv,nv}array: inorm indicates the
|
|
argument order, 0: normal first, 1: vector first. */
|
|
|
|
static PyObject *
|
|
gen_nvarray(args, inorm)
|
|
PyObject *args;
|
|
int inorm;
|
|
{
|
|
PyObject *v, *w, *wnorm, *wvec;
|
|
int i, n;
|
|
float norm[3], vec[3];
|
|
PyObject * (*getitem) Py_FPROTO((PyObject *, int));
|
|
|
|
if (!PyArg_GetObject(args, 1, 0, &v))
|
|
return NULL;
|
|
|
|
if (PyList_Check(v)) {
|
|
n = PyList_Size(v);
|
|
getitem = PyList_GetItem;
|
|
}
|
|
else if (PyTuple_Check(v)) {
|
|
n = PyTuple_Size(v);
|
|
getitem = PyTuple_GetItem;
|
|
}
|
|
else {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
w = (*getitem)(v, i);
|
|
if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
wnorm = PyTuple_GetItem(w, inorm);
|
|
wvec = PyTuple_GetItem(w, 1 - inorm);
|
|
if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
|
|
!PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
|
|
return NULL;
|
|
n3f(norm);
|
|
v3f(vec);
|
|
}
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
|
|
The dimensions of ctl[] are computed as follows:
|
|
[len(s_knots) - s_order], [len(t_knots) - t_order]
|
|
*/
|
|
|
|
|
|
static PyObject *
|
|
gl_nurbssurface(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
double * arg2 ;
|
|
long arg3 ;
|
|
double * arg4 ;
|
|
double *arg5 ;
|
|
long arg6 ;
|
|
long arg7 ;
|
|
long arg8 ;
|
|
long ncoords;
|
|
long s_byte_stride, t_byte_stride;
|
|
long s_nctl, t_nctl;
|
|
long s, t;
|
|
PyObject *v, *w, *pt;
|
|
double *pnext;
|
|
if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
|
|
return NULL;
|
|
if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 3, &arg6))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 4, &arg7))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 5, &arg8))
|
|
return NULL;
|
|
if (arg8 == N_XYZ)
|
|
ncoords = 3;
|
|
else if (arg8 == N_XYZW)
|
|
ncoords = 4;
|
|
else {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
s_nctl = arg1 - arg6;
|
|
t_nctl = arg3 - arg7;
|
|
if (!PyArg_GetObject(args, 6, 2, &v))
|
|
return NULL;
|
|
if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
pnext = arg5;
|
|
for (s = 0; s < s_nctl; s++) {
|
|
w = PyList_GetItem(v, s);
|
|
if (w == NULL || !PyList_Check(w) ||
|
|
PyList_Size(w) != t_nctl) {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
for (t = 0; t < t_nctl; t++) {
|
|
pt = PyList_GetItem(w, t);
|
|
if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
|
|
return NULL;
|
|
pnext += ncoords;
|
|
}
|
|
}
|
|
s_byte_stride = sizeof(double) * ncoords;
|
|
t_byte_stride = s_byte_stride * s_nctl;
|
|
nurbssurface( arg1 , arg2 , arg3 , arg4 ,
|
|
s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg4);
|
|
PyMem_DEL(arg5);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* nurbscurve(knots, ctlpoints, order, type).
|
|
The length of ctlpoints is len(knots)-order. */
|
|
|
|
|
|
static PyObject *
|
|
gl_nurbscurve(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
double * arg2 ;
|
|
long arg3 ;
|
|
double * arg4 ;
|
|
long arg5 ;
|
|
long arg6 ;
|
|
int ncoords, npoints;
|
|
int i;
|
|
PyObject *v;
|
|
double *pnext;
|
|
if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg6))
|
|
return NULL;
|
|
if (arg6 == N_ST)
|
|
ncoords = 2;
|
|
else if (arg6 == N_STW)
|
|
ncoords = 3;
|
|
else {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
npoints = arg1 - arg5;
|
|
if (!PyArg_GetObject(args, 4, 1, &v))
|
|
return NULL;
|
|
if (!PyList_Check(v) || PyList_Size(v) != npoints) {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
pnext = arg4;
|
|
for (i = 0; i < npoints; i++) {
|
|
if (!PyArg_GetDoubleArray(PyList_GetItem(v, i),
|
|
1, 0, ncoords, pnext))
|
|
return NULL;
|
|
pnext += ncoords;
|
|
}
|
|
arg3 = (sizeof(double)) * ncoords;
|
|
nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg4);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* pwlcurve(points, type).
|
|
Points is a list of points. Type must be N_ST. */
|
|
|
|
|
|
static PyObject *
|
|
gl_pwlcurve(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
PyObject *v;
|
|
long type;
|
|
double *data, *pnext;
|
|
long npoints, ncoords;
|
|
int i;
|
|
if (!PyArg_GetObject(args, 2, 0, &v))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &type))
|
|
return NULL;
|
|
if (!PyList_Check(v)) {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
npoints = PyList_Size(v);
|
|
if (type == N_ST)
|
|
ncoords = 2;
|
|
else {
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
pnext = data;
|
|
for (i = 0; i < npoints; i++) {
|
|
if (!PyArg_GetDoubleArray(PyList_GetItem(v, i),
|
|
1, 0, ncoords, pnext))
|
|
return NULL;
|
|
pnext += ncoords;
|
|
}
|
|
pwlcurve(npoints, data, sizeof(double)*ncoords, type);
|
|
PyMem_DEL(data);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
/* Picking and Selecting */
|
|
|
|
static short *pickbuffer = NULL;
|
|
static long pickbuffersize;
|
|
|
|
static PyObject *
|
|
pick_select(args, func)
|
|
PyObject *args;
|
|
void (*func)();
|
|
{
|
|
if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
|
|
return NULL;
|
|
if (pickbuffer != NULL) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"pick/gselect: already picking/selecting");
|
|
return NULL;
|
|
}
|
|
if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
(*func)(pickbuffer, pickbuffersize);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
endpick_select(args, func)
|
|
PyObject *args;
|
|
long (*func)();
|
|
{
|
|
PyObject *v, *w;
|
|
int i, nhits, n;
|
|
if (!PyArg_NoArgs(args))
|
|
return NULL;
|
|
if (pickbuffer == NULL) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"endpick/endselect: not in pick/select mode");
|
|
return NULL;
|
|
}
|
|
nhits = (*func)(pickbuffer);
|
|
if (nhits < 0) {
|
|
nhits = -nhits; /* How to report buffer overflow otherwise? */
|
|
}
|
|
/* Scan the buffer to see how many integers */
|
|
n = 0;
|
|
for (; nhits > 0; nhits--) {
|
|
n += 1 + pickbuffer[n];
|
|
}
|
|
v = PyList_New(n);
|
|
if (v == NULL)
|
|
return NULL;
|
|
/* XXX Could do it nicer and interpret the data structure here,
|
|
returning a list of lists. But this can be done in Python... */
|
|
for (i = 0; i < n; i++) {
|
|
w = PyInt_FromLong((long)pickbuffer[i]);
|
|
if (w == NULL) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
PyList_SetItem(v, i, w);
|
|
}
|
|
PyMem_DEL(pickbuffer);
|
|
pickbuffer = NULL;
|
|
return v;
|
|
}
|
|
|
|
extern void pick(), gselect();
|
|
extern long endpick(), endselect();
|
|
|
|
static PyObject *gl_pick(self, args) PyObject *self, *args; {
|
|
return pick_select(args, pick);
|
|
}
|
|
|
|
static PyObject *gl_endpick(self, args) PyObject *self, *args; {
|
|
return endpick_select(args, endpick);
|
|
}
|
|
|
|
static PyObject *gl_gselect(self, args) PyObject *self, *args; {
|
|
return pick_select(args, gselect);
|
|
}
|
|
|
|
static PyObject *gl_endselect(self, args) PyObject *self, *args; {
|
|
return endpick_select(args, endselect);
|
|
}
|
|
|
|
|
|
/* XXX The generator botches this one. Here's a quick hack to fix it. */
|
|
|
|
/* XXX The generator botches this one. Here's a quick hack to fix it. */
|
|
|
|
|
|
static PyObject *
|
|
gl_getmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
Matrix arg1;
|
|
PyObject *v, *w;
|
|
int i, j;
|
|
getmatrix( arg1 );
|
|
v = PyList_New(16);
|
|
if (v == NULL) {
|
|
return PyErr_NoMemory();
|
|
}
|
|
for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
|
|
w = mknewfloatobject(arg1[i][j]);
|
|
if (w == NULL) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
PyList_SetItem(v, i*4+j, w);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/* Here's an alternate version that returns a 4x4 matrix instead of
|
|
a vector. Unfortunately it is incompatible with loadmatrix and
|
|
multmatrix... */
|
|
|
|
|
|
static PyObject *
|
|
gl_altgetmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
Matrix arg1;
|
|
PyObject *v, *w;
|
|
int i, j;
|
|
getmatrix( arg1 );
|
|
v = PyList_New(4);
|
|
if (v == NULL) {
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
w = PyList_New(4);
|
|
if (w == NULL) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
PyList_SetItem(v, i, w);
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
for (j = 0; j < 4; j++) {
|
|
w = mknewfloatobject(arg1[i][j]);
|
|
if (w == NULL) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
PyList_SetItem(PyList_GetItem(v, i), j, w);
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
gl_lrectwrite(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short x1 ;
|
|
short y1 ;
|
|
short x2 ;
|
|
short y2 ;
|
|
string parray ;
|
|
PyObject *s;
|
|
#if 0
|
|
int pixcount;
|
|
#endif
|
|
if (!PyArg_GetShort(args, 5, 0, &x1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 1, &y1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 2, &x2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &y2))
|
|
return NULL;
|
|
if (!PyArg_GetString(args, 5, 4, &parray))
|
|
return NULL;
|
|
if (!PyArg_GetObject(args, 5, 4, &s))
|
|
return NULL;
|
|
#if 0
|
|
/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
|
|
pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
|
|
if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"string arg to lrectwrite has wrong size");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
gl_lrectread(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short x1 ;
|
|
short y1 ;
|
|
short x2 ;
|
|
short y2 ;
|
|
PyObject *parray;
|
|
int pixcount;
|
|
if (!PyArg_GetShort(args, 4, 0, &x1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &y1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &x2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &y2))
|
|
return NULL;
|
|
pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
|
|
parray = PyString_FromStringAndSize((char *)NULL,
|
|
pixcount*sizeof(long));
|
|
if (parray == NULL)
|
|
return NULL; /* No memory */
|
|
lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
|
|
return parray;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
gl_readdisplay(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short x1, y1, x2, y2;
|
|
unsigned long *parray, hints;
|
|
long size, size_ret;
|
|
PyObject *rv;
|
|
|
|
if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
|
|
return 0;
|
|
size = (long)(x2+1-x1) * (long)(y2+1-y1);
|
|
rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
|
|
if ( rv == NULL )
|
|
return NULL;
|
|
parray = (unsigned long *)PyString_AsString(rv);
|
|
size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
|
|
if ( size_ret != size ) {
|
|
printf("gl_readdisplay: got %ld pixels, expected %ld\n",
|
|
size_ret, size);
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"readdisplay returned unexpected length");
|
|
return NULL;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/* Desperately needed, here are tools to compress and decompress
|
|
the data manipulated by lrectread/lrectwrite.
|
|
|
|
gl.packrect(width, height, packfactor, bigdata) --> smalldata
|
|
makes 'bigdata' 4*(packfactor**2) times smaller by:
|
|
- turning it into B/W (a factor 4)
|
|
- replacing squares of size pacfactor by one
|
|
representative
|
|
|
|
gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
|
|
is the inverse; the numeric arguments must be *the same*.
|
|
|
|
Both work best if width and height are multiples of packfactor
|
|
(in fact unpackrect will leave garbage bytes).
|
|
*/
|
|
|
|
|
|
static PyObject *
|
|
gl_packrect(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long width, height, packfactor;
|
|
char *s;
|
|
PyObject *unpacked, *packed;
|
|
int pixcount, packedcount, x, y, r, g, b;
|
|
unsigned long pixel;
|
|
unsigned char *p;
|
|
unsigned long *parray;
|
|
if (!PyArg_GetLong(args, 4, 0, &width))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &height))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &packfactor))
|
|
return NULL;
|
|
if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
|
|
return NULL;
|
|
if (!PyArg_GetObject(args, 4, 3, &unpacked))
|
|
return NULL;
|
|
if (width <= 0 || height <= 0 || packfactor <= 0) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"packrect args must be > 0");
|
|
return NULL;
|
|
}
|
|
pixcount = width*height;
|
|
packedcount = ((width+packfactor-1)/packfactor) *
|
|
((height+packfactor-1)/packfactor);
|
|
if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"string arg to packrect has wrong size");
|
|
return NULL;
|
|
}
|
|
packed = PyString_FromStringAndSize((char *)NULL, packedcount);
|
|
if (packed == NULL)
|
|
return NULL;
|
|
parray = (unsigned long *) PyString_AsString(unpacked);
|
|
p = (unsigned char *) PyString_AsString(packed);
|
|
for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
|
|
for (x = 0; x < width; x += packfactor) {
|
|
pixel = parray[x];
|
|
r = pixel & 0xff;
|
|
g = (pixel >> 8) & 0xff;
|
|
b = (pixel >> 16) & 0xff;
|
|
*p++ = (30*r+59*g+11*b) / 100;
|
|
}
|
|
}
|
|
return packed;
|
|
}
|
|
|
|
|
|
static unsigned long unpacktab[256];
|
|
static int unpacktab_inited = 0;
|
|
|
|
static PyObject *
|
|
gl_unpackrect(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long width, height, packfactor;
|
|
char *s;
|
|
PyObject *unpacked, *packed;
|
|
int pixcount, packedcount;
|
|
register unsigned char *p;
|
|
register unsigned long *parray;
|
|
if (!unpacktab_inited) {
|
|
register int white;
|
|
for (white = 256; --white >= 0; )
|
|
unpacktab[white] = white * 0x010101L;
|
|
unpacktab_inited++;
|
|
}
|
|
if (!PyArg_GetLong(args, 4, 0, &width))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &height))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &packfactor))
|
|
return NULL;
|
|
if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
|
|
return NULL;
|
|
if (!PyArg_GetObject(args, 4, 3, &packed))
|
|
return NULL;
|
|
if (width <= 0 || height <= 0 || packfactor <= 0) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"packrect args must be > 0");
|
|
return NULL;
|
|
}
|
|
pixcount = width*height;
|
|
packedcount = ((width+packfactor-1)/packfactor) *
|
|
((height+packfactor-1)/packfactor);
|
|
if (PyString_Size(packed) != packedcount) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"string arg to unpackrect has wrong size");
|
|
return NULL;
|
|
}
|
|
unpacked = PyString_FromStringAndSize((char *)NULL,
|
|
pixcount*sizeof(long));
|
|
if (unpacked == NULL)
|
|
return NULL;
|
|
parray = (unsigned long *) PyString_AsString(unpacked);
|
|
p = (unsigned char *) PyString_AsString(packed);
|
|
if (packfactor == 1 && width*height > 0) {
|
|
/* Just expand bytes to longs */
|
|
register int x = width * height;
|
|
do {
|
|
*parray++ = unpacktab[*p++];
|
|
} while (--x >= 0);
|
|
}
|
|
else {
|
|
register int y;
|
|
for (y = 0; y < height-packfactor+1;
|
|
y += packfactor, parray += packfactor*width) {
|
|
register int x;
|
|
for (x = 0; x < width-packfactor+1; x += packfactor) {
|
|
register unsigned long pixel = unpacktab[*p++];
|
|
register int i;
|
|
for (i = packfactor*width; (i-=width) >= 0;) {
|
|
register int j;
|
|
for (j = packfactor; --j >= 0; )
|
|
parray[i+x+j] = pixel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return unpacked;
|
|
}
|
|
|
|
static PyObject *
|
|
gl_gversion(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
char buf[20];
|
|
gversion(buf);
|
|
return PyString_FromString(buf);
|
|
}
|
|
|
|
|
|
/* End of manually written stubs */
|
|
|
|
|
|
/* long getshade */
|
|
|
|
static PyObject *
|
|
gl_getshade(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getshade( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void devport short s long s */
|
|
|
|
static PyObject *
|
|
gl_devport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
devport( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdr2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_rdr2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rdr2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rectfs short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rectfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
rectfs( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rects short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rects(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
rects( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmv2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_rmv2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rmv2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void noport */
|
|
|
|
static PyObject *
|
|
gl_noport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
noport( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void popviewport */
|
|
|
|
static PyObject *
|
|
gl_popviewport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
popviewport( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void clear */
|
|
|
|
static PyObject *
|
|
gl_clear(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
clear( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void clearhitcode */
|
|
|
|
static PyObject *
|
|
gl_clearhitcode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
clearhitcode( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void closeobj */
|
|
|
|
static PyObject *
|
|
gl_closeobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
closeobj( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cursoff */
|
|
|
|
static PyObject *
|
|
gl_cursoff(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
cursoff( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curson */
|
|
|
|
static PyObject *
|
|
gl_curson(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
curson( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void doublebuffer */
|
|
|
|
static PyObject *
|
|
gl_doublebuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
doublebuffer( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void finish */
|
|
|
|
static PyObject *
|
|
gl_finish(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
finish( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gconfig */
|
|
|
|
static PyObject *
|
|
gl_gconfig(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
gconfig( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void ginit */
|
|
|
|
static PyObject *
|
|
gl_ginit(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
ginit( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void greset */
|
|
|
|
static PyObject *
|
|
gl_greset(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
greset( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void multimap */
|
|
|
|
static PyObject *
|
|
gl_multimap(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
multimap( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void onemap */
|
|
|
|
static PyObject *
|
|
gl_onemap(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
onemap( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void popattributes */
|
|
|
|
static PyObject *
|
|
gl_popattributes(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
popattributes( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void popmatrix */
|
|
|
|
static PyObject *
|
|
gl_popmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
popmatrix( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pushattributes */
|
|
|
|
static PyObject *
|
|
gl_pushattributes(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
pushattributes( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pushmatrix */
|
|
|
|
static PyObject *
|
|
gl_pushmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
pushmatrix( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pushviewport */
|
|
|
|
static PyObject *
|
|
gl_pushviewport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
pushviewport( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void qreset */
|
|
|
|
static PyObject *
|
|
gl_qreset(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
qreset( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void RGBmode */
|
|
|
|
static PyObject *
|
|
gl_RGBmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
RGBmode( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void singlebuffer */
|
|
|
|
static PyObject *
|
|
gl_singlebuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
singlebuffer( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void swapbuffers */
|
|
|
|
static PyObject *
|
|
gl_swapbuffers(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
swapbuffers( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gsync */
|
|
|
|
static PyObject *
|
|
gl_gsync(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
gsync( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gflush */
|
|
|
|
static PyObject *
|
|
gl_gflush(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
gflush( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void tpon */
|
|
|
|
static PyObject *
|
|
gl_tpon(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
tpon( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void tpoff */
|
|
|
|
static PyObject *
|
|
gl_tpoff(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
tpoff( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void clkon */
|
|
|
|
static PyObject *
|
|
gl_clkon(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
clkon( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void clkoff */
|
|
|
|
static PyObject *
|
|
gl_clkoff(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
clkoff( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void ringbell */
|
|
|
|
static PyObject *
|
|
gl_ringbell(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
ringbell( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gbegin */
|
|
|
|
static PyObject *
|
|
gl_gbegin(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
gbegin( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void textinit */
|
|
|
|
static PyObject *
|
|
gl_textinit(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
textinit( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void initnames */
|
|
|
|
static PyObject *
|
|
gl_initnames(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
initnames( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pclos */
|
|
|
|
static PyObject *
|
|
gl_pclos(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
pclos( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void popname */
|
|
|
|
static PyObject *
|
|
gl_popname(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
popname( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void spclos */
|
|
|
|
static PyObject *
|
|
gl_spclos(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
spclos( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zclear */
|
|
|
|
static PyObject *
|
|
gl_zclear(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
zclear( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void screenspace */
|
|
|
|
static PyObject *
|
|
gl_screenspace(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
screenspace( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void reshapeviewport */
|
|
|
|
static PyObject *
|
|
gl_reshapeviewport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
reshapeviewport( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void winpush */
|
|
|
|
static PyObject *
|
|
gl_winpush(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
winpush( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void winpop */
|
|
|
|
static PyObject *
|
|
gl_winpop(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
winpop( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void foreground */
|
|
|
|
static PyObject *
|
|
gl_foreground(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
foreground( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endfullscrn */
|
|
|
|
static PyObject *
|
|
gl_endfullscrn(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endfullscrn( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endpupmode */
|
|
|
|
static PyObject *
|
|
gl_endpupmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endpupmode( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void fullscrn */
|
|
|
|
static PyObject *
|
|
gl_fullscrn(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
fullscrn( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pupmode */
|
|
|
|
static PyObject *
|
|
gl_pupmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
pupmode( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void winconstraints */
|
|
|
|
static PyObject *
|
|
gl_winconstraints(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
winconstraints( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pagecolor short s */
|
|
|
|
static PyObject *
|
|
gl_pagecolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
pagecolor( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void textcolor short s */
|
|
|
|
static PyObject *
|
|
gl_textcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
textcolor( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void color short s */
|
|
|
|
static PyObject *
|
|
gl_color(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
color( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curveit short s */
|
|
|
|
static PyObject *
|
|
gl_curveit(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
curveit( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void font short s */
|
|
|
|
static PyObject *
|
|
gl_font(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
font( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void linewidth short s */
|
|
|
|
static PyObject *
|
|
gl_linewidth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
linewidth( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setlinestyle short s */
|
|
|
|
static PyObject *
|
|
gl_setlinestyle(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setlinestyle( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setmap short s */
|
|
|
|
static PyObject *
|
|
gl_setmap(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setmap( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void swapinterval short s */
|
|
|
|
static PyObject *
|
|
gl_swapinterval(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
swapinterval( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void writemask short s */
|
|
|
|
static PyObject *
|
|
gl_writemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
writemask( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void textwritemask short s */
|
|
|
|
static PyObject *
|
|
gl_textwritemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
textwritemask( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void qdevice short s */
|
|
|
|
static PyObject *
|
|
gl_qdevice(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
qdevice( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void unqdevice short s */
|
|
|
|
static PyObject *
|
|
gl_unqdevice(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
unqdevice( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curvebasis short s */
|
|
|
|
static PyObject *
|
|
gl_curvebasis(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
curvebasis( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curveprecision short s */
|
|
|
|
static PyObject *
|
|
gl_curveprecision(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
curveprecision( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void loadname short s */
|
|
|
|
static PyObject *
|
|
gl_loadname(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
loadname( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void passthrough short s */
|
|
|
|
static PyObject *
|
|
gl_passthrough(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
passthrough( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pushname short s */
|
|
|
|
static PyObject *
|
|
gl_pushname(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
pushname( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setmonitor short s */
|
|
|
|
static PyObject *
|
|
gl_setmonitor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setmonitor( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setshade short s */
|
|
|
|
static PyObject *
|
|
gl_setshade(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setshade( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setpattern short s */
|
|
|
|
static PyObject *
|
|
gl_setpattern(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setpattern( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pagewritemask short s */
|
|
|
|
static PyObject *
|
|
gl_pagewritemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
pagewritemask( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void callobj long s */
|
|
|
|
static PyObject *
|
|
gl_callobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
callobj( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void delobj long s */
|
|
|
|
static PyObject *
|
|
gl_delobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
delobj( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void editobj long s */
|
|
|
|
static PyObject *
|
|
gl_editobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
editobj( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void makeobj long s */
|
|
|
|
static PyObject *
|
|
gl_makeobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
makeobj( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void maketag long s */
|
|
|
|
static PyObject *
|
|
gl_maketag(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
maketag( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void chunksize long s */
|
|
|
|
static PyObject *
|
|
gl_chunksize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
chunksize( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void compactify long s */
|
|
|
|
static PyObject *
|
|
gl_compactify(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
compactify( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void deltag long s */
|
|
|
|
static PyObject *
|
|
gl_deltag(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
deltag( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lsrepeat long s */
|
|
|
|
static PyObject *
|
|
gl_lsrepeat(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
lsrepeat( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void objinsert long s */
|
|
|
|
static PyObject *
|
|
gl_objinsert(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
objinsert( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void objreplace long s */
|
|
|
|
static PyObject *
|
|
gl_objreplace(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
objreplace( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void winclose long s */
|
|
|
|
static PyObject *
|
|
gl_winclose(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
winclose( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void blanktime long s */
|
|
|
|
static PyObject *
|
|
gl_blanktime(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
blanktime( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void freepup long s */
|
|
|
|
static PyObject *
|
|
gl_freepup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
freepup( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void backbuffer long s */
|
|
|
|
static PyObject *
|
|
gl_backbuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
backbuffer( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void frontbuffer long s */
|
|
|
|
static PyObject *
|
|
gl_frontbuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
frontbuffer( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lsbackup long s */
|
|
|
|
static PyObject *
|
|
gl_lsbackup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
lsbackup( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void resetls long s */
|
|
|
|
static PyObject *
|
|
gl_resetls(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
resetls( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lampon long s */
|
|
|
|
static PyObject *
|
|
gl_lampon(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
lampon( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lampoff long s */
|
|
|
|
static PyObject *
|
|
gl_lampoff(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
lampoff( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setbell long s */
|
|
|
|
static PyObject *
|
|
gl_setbell(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
setbell( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void blankscreen long s */
|
|
|
|
static PyObject *
|
|
gl_blankscreen(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
blankscreen( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void depthcue long s */
|
|
|
|
static PyObject *
|
|
gl_depthcue(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
depthcue( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zbuffer long s */
|
|
|
|
static PyObject *
|
|
gl_zbuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
zbuffer( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void backface long s */
|
|
|
|
static PyObject *
|
|
gl_backface(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
backface( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmov2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_cmov2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
cmov2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void draw2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_draw2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
draw2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void move2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_move2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
move2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnt2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_pnt2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pnt2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void patchbasis long s long s */
|
|
|
|
static PyObject *
|
|
gl_patchbasis(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
patchbasis( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void patchprecision long s long s */
|
|
|
|
static PyObject *
|
|
gl_patchprecision(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
patchprecision( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdr2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_pdr2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pdr2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmv2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_pmv2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pmv2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdr2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_rpdr2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpdr2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmv2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_rpmv2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpmv2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt2i long s long s */
|
|
|
|
static PyObject *
|
|
gl_xfpt2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
xfpt2i( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void objdelete long s long s */
|
|
|
|
static PyObject *
|
|
gl_objdelete(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
objdelete( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void patchcurves long s long s */
|
|
|
|
static PyObject *
|
|
gl_patchcurves(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
patchcurves( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void minsize long s long s */
|
|
|
|
static PyObject *
|
|
gl_minsize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
minsize( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void maxsize long s long s */
|
|
|
|
static PyObject *
|
|
gl_maxsize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
maxsize( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void keepaspect long s long s */
|
|
|
|
static PyObject *
|
|
gl_keepaspect(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
keepaspect( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void prefsize long s long s */
|
|
|
|
static PyObject *
|
|
gl_prefsize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
prefsize( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void stepunit long s long s */
|
|
|
|
static PyObject *
|
|
gl_stepunit(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
stepunit( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void fudge long s long s */
|
|
|
|
static PyObject *
|
|
gl_fudge(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
fudge( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void winmove long s long s */
|
|
|
|
static PyObject *
|
|
gl_winmove(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
winmove( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void attachcursor short s short s */
|
|
|
|
static PyObject *
|
|
gl_attachcursor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
attachcursor( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void deflinestyle short s short s */
|
|
|
|
static PyObject *
|
|
gl_deflinestyle(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
deflinestyle( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void noise short s short s */
|
|
|
|
static PyObject *
|
|
gl_noise(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
noise( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void picksize short s short s */
|
|
|
|
static PyObject *
|
|
gl_picksize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
picksize( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void qenter short s short s */
|
|
|
|
static PyObject *
|
|
gl_qenter(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
qenter( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setdepth short s short s */
|
|
|
|
static PyObject *
|
|
gl_setdepth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
setdepth( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmov2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_cmov2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
cmov2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void draw2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_draw2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
draw2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void move2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_move2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
move2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdr2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pdr2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pdr2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmv2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pmv2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pmv2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnt2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pnt2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pnt2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdr2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rdr2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rdr2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmv2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rmv2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rmv2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdr2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rpdr2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpdr2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmv2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rpmv2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpmv2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt2s short s short s */
|
|
|
|
static PyObject *
|
|
gl_xfpt2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
xfpt2s( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmov2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_cmov2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
cmov2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void draw2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_draw2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
draw2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void move2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_move2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
move2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnt2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_pnt2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pnt2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdr2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_pdr2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pdr2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmv2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_pmv2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pmv2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdr2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_rdr2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rdr2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmv2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_rmv2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rmv2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdr2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_rpdr2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpdr2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmv2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_rpmv2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rpmv2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt2 float s float s */
|
|
|
|
static PyObject *
|
|
gl_xfpt2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
xfpt2( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void loadmatrix float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_loadmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 * 4 , (float *) arg1))
|
|
return NULL;
|
|
loadmatrix( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void multmatrix float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_multmatrix(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 * 4 , (float *) arg1))
|
|
return NULL;
|
|
multmatrix( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void crv float s[3*4] */
|
|
|
|
static PyObject *
|
|
gl_crv(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 3 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 * 4 , (float *) arg1))
|
|
return NULL;
|
|
crv( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rcrv float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_rcrv(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 * 4 , (float *) arg1))
|
|
return NULL;
|
|
rcrv( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void addtopup long s char *s long s */
|
|
|
|
static PyObject *
|
|
gl_addtopup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
string arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetString(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
addtopup( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void charstr char *s */
|
|
|
|
static PyObject *
|
|
gl_charstr(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
charstr( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void getport char *s */
|
|
|
|
static PyObject *
|
|
gl_getport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
getport( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long strwidth char *s */
|
|
|
|
static PyObject *
|
|
gl_strwidth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = strwidth( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long winopen char *s */
|
|
|
|
static PyObject *
|
|
gl_winopen(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = winopen( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void wintitle char *s */
|
|
|
|
static PyObject *
|
|
gl_wintitle(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
wintitle( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polf long s float s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
polf( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polf2 long s float s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polf2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 2 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
polf2( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void poly long s float s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_poly(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
poly( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void poly2 long s float s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_poly2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 2 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
poly2( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void crvn long s float s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_crvn(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
crvn( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rcrvn long s float s[4*arg1] */
|
|
|
|
static PyObject *
|
|
gl_rcrvn(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 4 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 4;
|
|
if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
rcrvn( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polf2i long s long s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polf2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 1, 0, 2 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
polf2i( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polfi long s long s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 1, 0, 3 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
polfi( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void poly2i long s long s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_poly2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 1, 0, 2 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
poly2i( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polyi long s long s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polyi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 1, 0, 3 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
polyi( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polf2s long s short s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polf2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, 2 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
polf2s( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polfs long s short s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, 3 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
polfs( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polys long s short s[3*arg1] */
|
|
|
|
static PyObject *
|
|
gl_polys(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 3 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, 3 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
polys( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void poly2s long s short s[2*arg1] */
|
|
|
|
static PyObject *
|
|
gl_poly2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 2 ] ;
|
|
if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, 2 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
poly2s( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void defcursor short s u_short s[128] */
|
|
|
|
static PyObject *
|
|
gl_defcursor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
unsigned short arg2 [ 128 ] ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShortArray(args, 2, 1, 128 , (short *) arg2))
|
|
return NULL;
|
|
defcursor( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void writepixels short s u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_writepixels(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
unsigned short * arg2 ;
|
|
if (!PyArg_GetShortArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, arg1 , (short *) arg2))
|
|
return NULL;
|
|
writepixels( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void defbasis long s float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_defbasis(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float arg2 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 2, 1, 4 * 4 , (float *) arg2))
|
|
return NULL;
|
|
defbasis( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gewrite short s short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_gewrite(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short * arg2 ;
|
|
if (!PyArg_GetShortArraySize(args, 1, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = PyMem_NEW(short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 1, 0, arg1 , arg2))
|
|
return NULL;
|
|
gewrite( arg1 , arg2 );
|
|
PyMem_DEL(arg2);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rotate short s char s */
|
|
|
|
static PyObject *
|
|
gl_rotate(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
char arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetChar(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rotate( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rot float s char s */
|
|
|
|
static PyObject *
|
|
gl_rot(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
char arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetChar(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rot( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circfi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_circfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circfi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_circi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmovi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_cmovi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
cmovi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void drawi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_drawi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
drawi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void movei long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_movei(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
movei( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnti long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_pnti(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pnti( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void newtag long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_newtag(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
newtag( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdri long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_pdri(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pdri( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmvi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_pmvi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pmvi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdri long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_rdri(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rdri( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmvi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_rmvi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rmvi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdri long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_rpdri(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpdri( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmvi long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_rpmvi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpmvi( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpti long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_xfpti(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
xfpti( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circ float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_circ(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circ( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circf float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_circf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circf( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmov float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_cmov(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
cmov( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void draw float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_draw(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
draw( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void move float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_move(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
move( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnt float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_pnt(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pnt( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void scale float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_scale(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
scale( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void translate float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_translate(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
translate( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdr float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_pdr(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pdr( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmv float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_pmv(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pmv( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdr float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rdr(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rdr( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmv float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rmv(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rmv( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdr float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rpdr(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpdr( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmv float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rpmv(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpmv( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_xfpt(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
if (!PyArg_GetFloat(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 3, 2, &arg3))
|
|
return NULL;
|
|
xfpt( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void RGBcolor short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_RGBcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
RGBcolor( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void RGBwritemask short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_RGBwritemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
RGBwritemask( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setcursor short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_setcursor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
setcursor( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void tie short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_tie(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
tie( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circfs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_circfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circfs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void circs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_circs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
circs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cmovs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_cmovs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
cmovs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void draws short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_draws(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
draws( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void moves short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_moves(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
moves( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pdrs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pdrs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pdrs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pmvs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pmvs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pmvs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pnts short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_pnts(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
pnts( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rdrs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rdrs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rdrs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rmvs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rmvs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rmvs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpdrs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rpdrs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpdrs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpmvs short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rpmvs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
rpmvs( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpts short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_xfpts(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
xfpts( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curorigin short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_curorigin(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
curorigin( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cyclemap short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_cyclemap(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
if (!PyArg_GetShort(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
cyclemap( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void patch float s[4*4] float s[4*4] float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_patch(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 4 ] ;
|
|
float arg2 [ 4 ] [ 4 ] ;
|
|
float arg3 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 3, 0, 4 * 4 , (float *) arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 3, 1, 4 * 4 , (float *) arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 3, 2, 4 * 4 , (float *) arg3))
|
|
return NULL;
|
|
patch( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splf long s float s[3*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 3 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 2, 0, 3 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splf( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splf2 long s float s[2*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splf2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float (* arg2) [ 2 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 2, 0, 2 * arg1 , (float *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splf2( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splfi long s long s[3*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 3 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 2, 0, 3 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splfi( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splf2i long s long s[2*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splf2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long (* arg2) [ 2 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetLongArray(args, 2, 0, 2 * arg1 , (long *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splf2i( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splfs long s short s[3*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 3 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 3;
|
|
if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 0, 3 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splfs( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void splf2s long s short s[2*arg1] u_short s[arg1] */
|
|
|
|
static PyObject *
|
|
gl_splf2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short (* arg2) [ 2 ] ;
|
|
unsigned short * arg3 ;
|
|
if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
|
|
return NULL;
|
|
arg1 = arg1 / 2;
|
|
if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 0, 2 * arg1 , (short *) arg2))
|
|
return NULL;
|
|
if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetShortArray(args, 2, 1, arg1 , (short *) arg3))
|
|
return NULL;
|
|
splf2s( arg1 , arg2 , arg3 );
|
|
PyMem_DEL(arg2);
|
|
PyMem_DEL(arg3);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */
|
|
|
|
static PyObject *
|
|
gl_rpatch(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] [ 4 ] ;
|
|
float arg2 [ 4 ] [ 4 ] ;
|
|
float arg3 [ 4 ] [ 4 ] ;
|
|
float arg4 [ 4 ] [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 4, 0, 4 * 4 , (float *) arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 4, 1, 4 * 4 , (float *) arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 4, 2, 4 * 4 , (float *) arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloatArray(args, 4, 3, 4 * 4 , (float *) arg4))
|
|
return NULL;
|
|
rpatch( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void ortho2 float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_ortho2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
ortho2( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rect float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rect(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
rect( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rectf float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_rectf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
rectf( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt4 float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_xfpt4(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
xfpt4( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void textport short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_textport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
textport( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void mapcolor short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_mapcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
mapcolor( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void scrmask short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_scrmask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
scrmask( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setvaluator short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_setvaluator(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
setvaluator( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void viewport short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_viewport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
viewport( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void shaderange short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_shaderange(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
shaderange( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt4s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_xfpt4s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
xfpt4s( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rectfi long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_rectfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
rectfi( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void recti long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_recti(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
recti( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void xfpt4i long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_xfpt4i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
xfpt4i( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void prefposition long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_prefposition(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
prefposition( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arc float s float s float s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arc(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetFloat(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arc( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arcf float s float s float s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arcf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetFloat(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arcf( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arcfi long s long s long s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arcfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetLong(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arcfi( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arci long s long s long s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arci(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetLong(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arci( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bbox2 short s short s float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_bbox2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
float arg6 ;
|
|
if (!PyArg_GetShort(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 5, &arg6))
|
|
return NULL;
|
|
bbox2( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bbox2i short s short s long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_bbox2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
long arg5 ;
|
|
long arg6 ;
|
|
if (!PyArg_GetShort(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 6, 5, &arg6))
|
|
return NULL;
|
|
bbox2i( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bbox2s short s short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_bbox2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
short arg6 ;
|
|
if (!PyArg_GetShort(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 5, &arg6))
|
|
return NULL;
|
|
bbox2s( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void blink short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_blink(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetShort(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
blink( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void ortho float s float s float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_ortho(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
float arg6 ;
|
|
if (!PyArg_GetFloat(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 5, &arg6))
|
|
return NULL;
|
|
ortho( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void window float s float s float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_window(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
float arg6 ;
|
|
if (!PyArg_GetFloat(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 6, 5, &arg6))
|
|
return NULL;
|
|
window( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lookat float s float s float s float s float s float s short s */
|
|
|
|
static PyObject *
|
|
gl_lookat(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
float arg6 ;
|
|
short arg7 ;
|
|
if (!PyArg_GetFloat(args, 7, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 7, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 7, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 7, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 7, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 7, 5, &arg6))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 6, &arg7))
|
|
return NULL;
|
|
lookat( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void perspective short s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_perspective(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
perspective( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void polarview float s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_polarview(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
polarview( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arcfs short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arcfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetShort(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arcfs( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void arcs short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_arcs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
if (!PyArg_GetShort(args, 5, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 5, 4, &arg5))
|
|
return NULL;
|
|
arcs( arg1 , arg2 , arg3 , arg4 , arg5 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rectcopy short s short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_rectcopy(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
short arg6 ;
|
|
if (!PyArg_GetShort(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 6, 5, &arg6))
|
|
return NULL;
|
|
rectcopy( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void RGBcursor short s short s short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_RGBcursor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
short arg6 ;
|
|
short arg7 ;
|
|
if (!PyArg_GetShort(args, 7, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 5, &arg6))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 7, 6, &arg7))
|
|
return NULL;
|
|
RGBcursor( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long getbutton short s */
|
|
|
|
static PyObject *
|
|
gl_getbutton(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = getbutton( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getcmmode */
|
|
|
|
static PyObject *
|
|
gl_getcmmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getcmmode( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getlsbackup */
|
|
|
|
static PyObject *
|
|
gl_getlsbackup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getlsbackup( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getresetls */
|
|
|
|
static PyObject *
|
|
gl_getresetls(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getresetls( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getdcm */
|
|
|
|
static PyObject *
|
|
gl_getdcm(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getdcm( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getzbuffer */
|
|
|
|
static PyObject *
|
|
gl_getzbuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getzbuffer( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long ismex */
|
|
|
|
static PyObject *
|
|
gl_ismex(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = ismex( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long isobj long s */
|
|
|
|
static PyObject *
|
|
gl_isobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = isobj( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long isqueued short s */
|
|
|
|
static PyObject *
|
|
gl_isqueued(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = isqueued( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long istag long s */
|
|
|
|
static PyObject *
|
|
gl_istag(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = istag( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long genobj */
|
|
|
|
static PyObject *
|
|
gl_genobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = genobj( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long gentag */
|
|
|
|
static PyObject *
|
|
gl_gentag(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = gentag( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getbuffer */
|
|
|
|
static PyObject *
|
|
gl_getbuffer(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getbuffer( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getcolor */
|
|
|
|
static PyObject *
|
|
gl_getcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getcolor( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getdisplaymode */
|
|
|
|
static PyObject *
|
|
gl_getdisplaymode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getdisplaymode( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getfont */
|
|
|
|
static PyObject *
|
|
gl_getfont(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getfont( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getheight */
|
|
|
|
static PyObject *
|
|
gl_getheight(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getheight( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long gethitcode */
|
|
|
|
static PyObject *
|
|
gl_gethitcode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = gethitcode( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getlstyle */
|
|
|
|
static PyObject *
|
|
gl_getlstyle(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getlstyle( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getlwidth */
|
|
|
|
static PyObject *
|
|
gl_getlwidth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getlwidth( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getmap */
|
|
|
|
static PyObject *
|
|
gl_getmap(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getmap( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getplanes */
|
|
|
|
static PyObject *
|
|
gl_getplanes(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getplanes( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getwritemask */
|
|
|
|
static PyObject *
|
|
gl_getwritemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getwritemask( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long qtest */
|
|
|
|
static PyObject *
|
|
gl_qtest(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = qtest( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getlsrepeat */
|
|
|
|
static PyObject *
|
|
gl_getlsrepeat(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getlsrepeat( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getmonitor */
|
|
|
|
static PyObject *
|
|
gl_getmonitor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getmonitor( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getopenobj */
|
|
|
|
static PyObject *
|
|
gl_getopenobj(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getopenobj( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getpattern */
|
|
|
|
static PyObject *
|
|
gl_getpattern(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getpattern( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long winget */
|
|
|
|
static PyObject *
|
|
gl_winget(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = winget( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long winattach */
|
|
|
|
static PyObject *
|
|
gl_winattach(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = winattach( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getothermonitor */
|
|
|
|
static PyObject *
|
|
gl_getothermonitor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getothermonitor( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long newpup */
|
|
|
|
static PyObject *
|
|
gl_newpup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = newpup( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getvaluator short s */
|
|
|
|
static PyObject *
|
|
gl_getvaluator(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
short arg1 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = getvaluator( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void winset long s */
|
|
|
|
static PyObject *
|
|
gl_winset(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
winset( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long dopup long s */
|
|
|
|
static PyObject *
|
|
gl_dopup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = dopup( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void getdepth short r short r */
|
|
|
|
static PyObject *
|
|
gl_getdepth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
getdepth( & arg1 , & arg2 );
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getcpos short r short r */
|
|
|
|
static PyObject *
|
|
gl_getcpos(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
getcpos( & arg1 , & arg2 );
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getsize long r long r */
|
|
|
|
static PyObject *
|
|
gl_getsize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
getsize( & arg1 , & arg2 );
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewlongobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewlongobject(arg2));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getorigin long r long r */
|
|
|
|
static PyObject *
|
|
gl_getorigin(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
getorigin( & arg1 , & arg2 );
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewlongobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewlongobject(arg2));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getviewport short r short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_getviewport(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
getviewport( & arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 4 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg3));
|
|
PyTuple_SetItem(v, 3, mknewshortobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void gettp short r short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_gettp(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
gettp( & arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 4 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg3));
|
|
PyTuple_SetItem(v, 3, mknewshortobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getgpos float r float r float r float r */
|
|
|
|
static PyObject *
|
|
gl_getgpos(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
getgpos( & arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 4 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewfloatobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewfloatobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewfloatobject(arg3));
|
|
PyTuple_SetItem(v, 3, mknewfloatobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void winposition long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_winposition(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
winposition( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gRGBcolor short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_gRGBcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
gRGBcolor( & arg1 , & arg2 , & arg3 );
|
|
{ PyObject *v = PyTuple_New( 3 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg3));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void gRGBmask short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_gRGBmask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
gRGBmask( & arg1 , & arg2 , & arg3 );
|
|
{ PyObject *v = PyTuple_New( 3 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg3));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getscrmask short r short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_getscrmask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
getscrmask( & arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 4 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg3));
|
|
PyTuple_SetItem(v, 3, mknewshortobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getmcolor short s short r short r short r */
|
|
|
|
static PyObject *
|
|
gl_getmcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 1, 0, &arg1))
|
|
return NULL;
|
|
getmcolor( arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 3 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg2));
|
|
PyTuple_SetItem(v, 1, mknewshortobject(arg3));
|
|
PyTuple_SetItem(v, 2, mknewshortobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void mapw long s short s short s float r float r float r
|
|
float r float r float r */
|
|
|
|
static PyObject *
|
|
gl_mapw(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
float arg6 ;
|
|
float arg7 ;
|
|
float arg8 ;
|
|
float arg9 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
mapw( arg1, arg2, arg3, &arg4, &arg5, &arg6, &arg7, &arg8, &arg9 );
|
|
{ PyObject *v = PyTuple_New( 6 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
|
|
PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
|
|
PyTuple_SetItem(v, 2, mknewfloatobject(arg6));
|
|
PyTuple_SetItem(v, 3, mknewfloatobject(arg7));
|
|
PyTuple_SetItem(v, 4, mknewfloatobject(arg8));
|
|
PyTuple_SetItem(v, 5, mknewfloatobject(arg9));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void mapw2 long s short s short s float r float r */
|
|
|
|
static PyObject *
|
|
gl_mapw2(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
float arg4 ;
|
|
float arg5 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 3, 2, &arg3))
|
|
return NULL;
|
|
mapw2( arg1 , arg2 , arg3 , & arg4 , & arg5 );
|
|
{ PyObject *v = PyTuple_New( 2 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
|
|
PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void getcursor short r u_short r u_short r long r */
|
|
|
|
static PyObject *
|
|
gl_getcursor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
unsigned short arg2 ;
|
|
unsigned short arg3 ;
|
|
long arg4 ;
|
|
getcursor( & arg1 , & arg2 , & arg3 , & arg4 );
|
|
{ PyObject *v = PyTuple_New( 4 );
|
|
if (v == NULL) return NULL;
|
|
PyTuple_SetItem(v, 0, mknewshortobject(arg1));
|
|
PyTuple_SetItem(v, 1, mknewshortobject((short) arg2));
|
|
PyTuple_SetItem(v, 2, mknewshortobject((short) arg3));
|
|
PyTuple_SetItem(v, 3, mknewlongobject(arg4));
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/* void cmode */
|
|
|
|
static PyObject *
|
|
gl_cmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
cmode( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void concave long s */
|
|
|
|
static PyObject *
|
|
gl_concave(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
concave( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void curstype long s */
|
|
|
|
static PyObject *
|
|
gl_curstype(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
curstype( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void drawmode long s */
|
|
|
|
static PyObject *
|
|
gl_drawmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
drawmode( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void gammaramp short s[256] short s[256] short s[256] */
|
|
|
|
static PyObject *
|
|
gl_gammaramp(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 256 ] ;
|
|
short arg2 [ 256 ] ;
|
|
short arg3 [ 256 ] ;
|
|
if (!PyArg_GetShortArray(args, 3, 0, 256 , arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShortArray(args, 3, 1, 256 , arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShortArray(args, 3, 2, 256 , arg3))
|
|
return NULL;
|
|
gammaramp( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long getbackface */
|
|
|
|
static PyObject *
|
|
gl_getbackface(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getbackface( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getdescender */
|
|
|
|
static PyObject *
|
|
gl_getdescender(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getdescender( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getdrawmode */
|
|
|
|
static PyObject *
|
|
gl_getdrawmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getdrawmode( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getmmode */
|
|
|
|
static PyObject *
|
|
gl_getmmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getmmode( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getsm */
|
|
|
|
static PyObject *
|
|
gl_getsm(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = getsm( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getvideo long s */
|
|
|
|
static PyObject *
|
|
gl_getvideo(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = getvideo( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void imakebackground */
|
|
|
|
static PyObject *
|
|
gl_imakebackground(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
imakebackground( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lmbind short s short s */
|
|
|
|
static PyObject *
|
|
gl_lmbind(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
if (!PyArg_GetShort(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 2, 1, &arg2))
|
|
return NULL;
|
|
lmbind( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lmdef long s long s long s float s[arg3] */
|
|
|
|
static PyObject *
|
|
gl_lmdef(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
float * arg4 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLongArraySize(args, 3, 2, &arg3))
|
|
return NULL;
|
|
if ((arg4 = PyMem_NEW(float , arg3 )) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (!PyArg_GetFloatArray(args, 3, 2, arg3 , arg4))
|
|
return NULL;
|
|
lmdef( arg1 , arg2 , arg3 , arg4 );
|
|
PyMem_DEL(arg4);
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void mmode long s */
|
|
|
|
static PyObject *
|
|
gl_mmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
mmode( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void normal float s[3] */
|
|
|
|
static PyObject *
|
|
gl_normal(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 3 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
normal( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void overlay long s */
|
|
|
|
static PyObject *
|
|
gl_overlay(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
overlay( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void RGBrange short s short s short s
|
|
short s short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_RGBrange(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
short arg6 ;
|
|
short arg7 ;
|
|
short arg8 ;
|
|
if (!PyArg_GetShort(args, 8, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 5, &arg6))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 6, &arg7))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 7, &arg8))
|
|
return NULL;
|
|
RGBrange( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setvideo long s long s */
|
|
|
|
static PyObject *
|
|
gl_setvideo(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
setvideo( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void shademodel long s */
|
|
|
|
static PyObject *
|
|
gl_shademodel(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
shademodel( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void underlay long s */
|
|
|
|
static PyObject *
|
|
gl_underlay(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
underlay( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgnclosedline */
|
|
|
|
static PyObject *
|
|
gl_bgnclosedline(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgnclosedline( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgnline */
|
|
|
|
static PyObject *
|
|
gl_bgnline(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgnline( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgnpoint */
|
|
|
|
static PyObject *
|
|
gl_bgnpoint(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgnpoint( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgnpolygon */
|
|
|
|
static PyObject *
|
|
gl_bgnpolygon(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgnpolygon( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgnsurface */
|
|
|
|
static PyObject *
|
|
gl_bgnsurface(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgnsurface( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgntmesh */
|
|
|
|
static PyObject *
|
|
gl_bgntmesh(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgntmesh( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void bgntrim */
|
|
|
|
static PyObject *
|
|
gl_bgntrim(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
bgntrim( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endclosedline */
|
|
|
|
static PyObject *
|
|
gl_endclosedline(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endclosedline( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endline */
|
|
|
|
static PyObject *
|
|
gl_endline(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endline( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endpoint */
|
|
|
|
static PyObject *
|
|
gl_endpoint(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endpoint( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endpolygon */
|
|
|
|
static PyObject *
|
|
gl_endpolygon(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endpolygon( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endsurface */
|
|
|
|
static PyObject *
|
|
gl_endsurface(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endsurface( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endtmesh */
|
|
|
|
static PyObject *
|
|
gl_endtmesh(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endtmesh( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void endtrim */
|
|
|
|
static PyObject *
|
|
gl_endtrim(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
endtrim( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void blendfunction long s long s */
|
|
|
|
static PyObject *
|
|
gl_blendfunction(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
blendfunction( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c3f float s[3] */
|
|
|
|
static PyObject *
|
|
gl_c3f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 3 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
c3f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c3i long s[3] */
|
|
|
|
static PyObject *
|
|
gl_c3i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 [ 3 ] ;
|
|
if (!PyArg_GetLongArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
c3i( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c3s short s[3] */
|
|
|
|
static PyObject *
|
|
gl_c3s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 3 ] ;
|
|
if (!PyArg_GetShortArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
c3s( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c4f float s[4] */
|
|
|
|
static PyObject *
|
|
gl_c4f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
c4f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c4i long s[4] */
|
|
|
|
static PyObject *
|
|
gl_c4i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 [ 4 ] ;
|
|
if (!PyArg_GetLongArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
c4i( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void c4s short s[4] */
|
|
|
|
static PyObject *
|
|
gl_c4s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 4 ] ;
|
|
if (!PyArg_GetShortArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
c4s( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void colorf float s */
|
|
|
|
static PyObject *
|
|
gl_colorf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
if (!PyArg_GetFloat(args, 1, 0, &arg1))
|
|
return NULL;
|
|
colorf( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void cpack long s */
|
|
|
|
static PyObject *
|
|
gl_cpack(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
cpack( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void czclear long s long s */
|
|
|
|
static PyObject *
|
|
gl_czclear(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
czclear( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void dglclose long s */
|
|
|
|
static PyObject *
|
|
gl_dglclose(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
dglclose( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long dglopen char *s long s */
|
|
|
|
static PyObject *
|
|
gl_dglopen(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
string arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetString(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
retval = dglopen( arg1 , arg2 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* long getgdesc long s */
|
|
|
|
static PyObject *
|
|
gl_getgdesc(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = getgdesc( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void getnurbsproperty long s float r */
|
|
|
|
static PyObject *
|
|
gl_getnurbsproperty(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
getnurbsproperty( arg1 , & arg2 );
|
|
return mknewfloatobject(arg2);
|
|
}
|
|
|
|
/* void glcompat long s long s */
|
|
|
|
static PyObject *
|
|
gl_glcompat(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
glcompat( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void iconsize long s long s */
|
|
|
|
static PyObject *
|
|
gl_iconsize(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
iconsize( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void icontitle char *s */
|
|
|
|
static PyObject *
|
|
gl_icontitle(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
string arg1 ;
|
|
if (!PyArg_GetString(args, 1, 0, &arg1))
|
|
return NULL;
|
|
icontitle( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lRGBrange short s short s short s short s
|
|
short s short s long s long s */
|
|
|
|
static PyObject *
|
|
gl_lRGBrange(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
short arg5 ;
|
|
short arg6 ;
|
|
long arg7 ;
|
|
long arg8 ;
|
|
if (!PyArg_GetShort(args, 8, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 3, &arg4))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 4, &arg5))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 8, 5, &arg6))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 8, 6, &arg7))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 8, 7, &arg8))
|
|
return NULL;
|
|
lRGBrange( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void linesmooth long s */
|
|
|
|
static PyObject *
|
|
gl_linesmooth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
linesmooth( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lmcolor long s */
|
|
|
|
static PyObject *
|
|
gl_lmcolor(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
lmcolor( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void logicop long s */
|
|
|
|
static PyObject *
|
|
gl_logicop(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
logicop( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lsetdepth long s long s */
|
|
|
|
static PyObject *
|
|
gl_lsetdepth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
lsetdepth( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void lshaderange short s short s long s long s */
|
|
|
|
static PyObject *
|
|
gl_lshaderange(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
lshaderange( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void n3f float s[3] */
|
|
|
|
static PyObject *
|
|
gl_n3f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 3 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
n3f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void noborder */
|
|
|
|
static PyObject *
|
|
gl_noborder(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
noborder( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pntsmooth long s */
|
|
|
|
static PyObject *
|
|
gl_pntsmooth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
pntsmooth( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void readsource long s */
|
|
|
|
static PyObject *
|
|
gl_readsource(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
readsource( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void rectzoom float s float s */
|
|
|
|
static PyObject *
|
|
gl_rectzoom(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetFloat(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
rectzoom( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sbox float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_sbox(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sbox( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sboxi long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_sboxi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sboxi( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sboxs short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_sboxs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sboxs( arg1, arg2, arg3, arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sboxf float s float s float s float s */
|
|
|
|
static PyObject *
|
|
gl_sboxf(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 ;
|
|
float arg2 ;
|
|
float arg3 ;
|
|
float arg4 ;
|
|
if (!PyArg_GetFloat(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sboxf( arg1, arg2, arg3, arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sboxfi long s long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_sboxfi(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
long arg4 ;
|
|
if (!PyArg_GetLong(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sboxfi( arg1, arg2, arg3, arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void sboxfs short s short s short s short s */
|
|
|
|
static PyObject *
|
|
gl_sboxfs(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 ;
|
|
short arg2 ;
|
|
short arg3 ;
|
|
short arg4 ;
|
|
if (!PyArg_GetShort(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 2, &arg3))
|
|
return NULL;
|
|
if (!PyArg_GetShort(args, 4, 3, &arg4))
|
|
return NULL;
|
|
sboxfs( arg1 , arg2 , arg3 , arg4 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setnurbsproperty long s float s */
|
|
|
|
static PyObject *
|
|
gl_setnurbsproperty(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
float arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetFloat(args, 2, 1, &arg2))
|
|
return NULL;
|
|
setnurbsproperty( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void setpup long s long s long s */
|
|
|
|
static PyObject *
|
|
gl_setpup(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
long arg3 ;
|
|
if (!PyArg_GetLong(args, 3, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 1, &arg2))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 3, 2, &arg3))
|
|
return NULL;
|
|
setpup( arg1 , arg2 , arg3 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void smoothline long s */
|
|
|
|
static PyObject *
|
|
gl_smoothline(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
smoothline( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void subpixel long s */
|
|
|
|
static PyObject *
|
|
gl_subpixel(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
subpixel( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void swaptmesh */
|
|
|
|
static PyObject *
|
|
gl_swaptmesh(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
swaptmesh( );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long swinopen long s */
|
|
|
|
static PyObject *
|
|
gl_swinopen(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = swinopen( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void v2f float s[2] */
|
|
|
|
static PyObject *
|
|
gl_v2f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 2 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 2 , arg1))
|
|
return NULL;
|
|
v2f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v2i long s[2] */
|
|
|
|
static PyObject *
|
|
gl_v2i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 [ 2 ] ;
|
|
if (!PyArg_GetLongArray(args, 1, 0, 2 , arg1))
|
|
return NULL;
|
|
v2i( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v2s short s[2] */
|
|
|
|
static PyObject *
|
|
gl_v2s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 2 ] ;
|
|
if (!PyArg_GetShortArray(args, 1, 0, 2 , arg1))
|
|
return NULL;
|
|
v2s( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v3f float s[3] */
|
|
|
|
static PyObject *
|
|
gl_v3f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 3 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
v3f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v3i long s[3] */
|
|
|
|
static PyObject *
|
|
gl_v3i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 [ 3 ] ;
|
|
if (!PyArg_GetLongArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
v3i( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v3s short s[3] */
|
|
|
|
static PyObject *
|
|
gl_v3s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 3 ] ;
|
|
if (!PyArg_GetShortArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
v3s( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v4f float s[4] */
|
|
|
|
static PyObject *
|
|
gl_v4f(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
float arg1 [ 4 ] ;
|
|
if (!PyArg_GetFloatArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
v4f( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v4i long s[4] */
|
|
|
|
static PyObject *
|
|
gl_v4i(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 [ 4 ] ;
|
|
if (!PyArg_GetLongArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
v4i( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v4s short s[4] */
|
|
|
|
static PyObject *
|
|
gl_v4s(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
short arg1 [ 4 ] ;
|
|
if (!PyArg_GetShortArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
v4s( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void videocmd long s */
|
|
|
|
static PyObject *
|
|
gl_videocmd(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
videocmd( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long windepth long s */
|
|
|
|
static PyObject *
|
|
gl_windepth(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
retval = windepth( arg1 );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void wmpack long s */
|
|
|
|
static PyObject *
|
|
gl_wmpack(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
wmpack( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zdraw long s */
|
|
|
|
static PyObject *
|
|
gl_zdraw(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
zdraw( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zfunction long s */
|
|
|
|
static PyObject *
|
|
gl_zfunction(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
zfunction( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zsource long s */
|
|
|
|
static PyObject *
|
|
gl_zsource(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
zsource( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void zwritemask long s */
|
|
|
|
static PyObject *
|
|
gl_zwritemask(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
zwritemask( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v2d double s[2] */
|
|
|
|
static PyObject *
|
|
gl_v2d(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
double arg1 [ 2 ] ;
|
|
if (!PyArg_GetDoubleArray(args, 1, 0, 2 , arg1))
|
|
return NULL;
|
|
v2d( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v3d double s[3] */
|
|
|
|
static PyObject *
|
|
gl_v3d(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
double arg1 [ 3 ] ;
|
|
if (!PyArg_GetDoubleArray(args, 1, 0, 3 , arg1))
|
|
return NULL;
|
|
v3d( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void v4d double s[4] */
|
|
|
|
static PyObject *
|
|
gl_v4d(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
double arg1 [ 4 ] ;
|
|
if (!PyArg_GetDoubleArray(args, 1, 0, 4 , arg1))
|
|
return NULL;
|
|
v4d( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* void pixmode long s long s */
|
|
|
|
static PyObject *
|
|
gl_pixmode(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
long arg2 ;
|
|
if (!PyArg_GetLong(args, 2, 0, &arg1))
|
|
return NULL;
|
|
if (!PyArg_GetLong(args, 2, 1, &arg2))
|
|
return NULL;
|
|
pixmode( arg1 , arg2 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
/* long qgetfd */
|
|
|
|
static PyObject *
|
|
gl_qgetfd(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long retval;
|
|
retval = qgetfd( );
|
|
return mknewlongobject(retval);
|
|
}
|
|
|
|
/* void dither long s */
|
|
|
|
static PyObject *
|
|
gl_dither(self, args)
|
|
PyObject *self;
|
|
PyObject *args;
|
|
{
|
|
long arg1 ;
|
|
if (!PyArg_GetLong(args, 1, 0, &arg1))
|
|
return NULL;
|
|
dither( arg1 );
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyMethodDef gl_methods[] = {
|
|
{"qread", gl_qread},
|
|
{"varray", gl_varray},
|
|
{"nvarray", gl_nvarray},
|
|
{"vnarray", gl_vnarray},
|
|
{"nurbssurface", gl_nurbssurface},
|
|
{"nurbscurve", gl_nurbscurve},
|
|
{"pwlcurve", gl_pwlcurve},
|
|
{"pick", gl_pick},
|
|
{"endpick", gl_endpick},
|
|
{"gselect", gl_gselect},
|
|
{"endselect", gl_endselect},
|
|
{"getmatrix", gl_getmatrix},
|
|
{"altgetmatrix", gl_altgetmatrix},
|
|
{"lrectwrite", gl_lrectwrite},
|
|
{"lrectread", gl_lrectread},
|
|
{"readdisplay", gl_readdisplay},
|
|
{"packrect", gl_packrect},
|
|
{"unpackrect", gl_unpackrect},
|
|
{"gversion", gl_gversion},
|
|
{"getshade", gl_getshade},
|
|
{"devport", gl_devport},
|
|
{"rdr2i", gl_rdr2i},
|
|
{"rectfs", gl_rectfs},
|
|
{"rects", gl_rects},
|
|
{"rmv2i", gl_rmv2i},
|
|
{"noport", gl_noport},
|
|
{"popviewport", gl_popviewport},
|
|
{"clear", gl_clear},
|
|
{"clearhitcode", gl_clearhitcode},
|
|
{"closeobj", gl_closeobj},
|
|
{"cursoff", gl_cursoff},
|
|
{"curson", gl_curson},
|
|
{"doublebuffer", gl_doublebuffer},
|
|
{"finish", gl_finish},
|
|
{"gconfig", gl_gconfig},
|
|
{"ginit", gl_ginit},
|
|
{"greset", gl_greset},
|
|
{"multimap", gl_multimap},
|
|
{"onemap", gl_onemap},
|
|
{"popattributes", gl_popattributes},
|
|
{"popmatrix", gl_popmatrix},
|
|
{"pushattributes", gl_pushattributes},
|
|
{"pushmatrix", gl_pushmatrix},
|
|
{"pushviewport", gl_pushviewport},
|
|
{"qreset", gl_qreset},
|
|
{"RGBmode", gl_RGBmode},
|
|
{"singlebuffer", gl_singlebuffer},
|
|
{"swapbuffers", gl_swapbuffers},
|
|
{"gsync", gl_gsync},
|
|
{"gflush", gl_gflush},
|
|
{"tpon", gl_tpon},
|
|
{"tpoff", gl_tpoff},
|
|
{"clkon", gl_clkon},
|
|
{"clkoff", gl_clkoff},
|
|
{"ringbell", gl_ringbell},
|
|
{"gbegin", gl_gbegin},
|
|
{"textinit", gl_textinit},
|
|
{"initnames", gl_initnames},
|
|
{"pclos", gl_pclos},
|
|
{"popname", gl_popname},
|
|
{"spclos", gl_spclos},
|
|
{"zclear", gl_zclear},
|
|
{"screenspace", gl_screenspace},
|
|
{"reshapeviewport", gl_reshapeviewport},
|
|
{"winpush", gl_winpush},
|
|
{"winpop", gl_winpop},
|
|
{"foreground", gl_foreground},
|
|
{"endfullscrn", gl_endfullscrn},
|
|
{"endpupmode", gl_endpupmode},
|
|
{"fullscrn", gl_fullscrn},
|
|
{"pupmode", gl_pupmode},
|
|
{"winconstraints", gl_winconstraints},
|
|
{"pagecolor", gl_pagecolor},
|
|
{"textcolor", gl_textcolor},
|
|
{"color", gl_color},
|
|
{"curveit", gl_curveit},
|
|
{"font", gl_font},
|
|
{"linewidth", gl_linewidth},
|
|
{"setlinestyle", gl_setlinestyle},
|
|
{"setmap", gl_setmap},
|
|
{"swapinterval", gl_swapinterval},
|
|
{"writemask", gl_writemask},
|
|
{"textwritemask", gl_textwritemask},
|
|
{"qdevice", gl_qdevice},
|
|
{"unqdevice", gl_unqdevice},
|
|
{"curvebasis", gl_curvebasis},
|
|
{"curveprecision", gl_curveprecision},
|
|
{"loadname", gl_loadname},
|
|
{"passthrough", gl_passthrough},
|
|
{"pushname", gl_pushname},
|
|
{"setmonitor", gl_setmonitor},
|
|
{"setshade", gl_setshade},
|
|
{"setpattern", gl_setpattern},
|
|
{"pagewritemask", gl_pagewritemask},
|
|
{"callobj", gl_callobj},
|
|
{"delobj", gl_delobj},
|
|
{"editobj", gl_editobj},
|
|
{"makeobj", gl_makeobj},
|
|
{"maketag", gl_maketag},
|
|
{"chunksize", gl_chunksize},
|
|
{"compactify", gl_compactify},
|
|
{"deltag", gl_deltag},
|
|
{"lsrepeat", gl_lsrepeat},
|
|
{"objinsert", gl_objinsert},
|
|
{"objreplace", gl_objreplace},
|
|
{"winclose", gl_winclose},
|
|
{"blanktime", gl_blanktime},
|
|
{"freepup", gl_freepup},
|
|
{"backbuffer", gl_backbuffer},
|
|
{"frontbuffer", gl_frontbuffer},
|
|
{"lsbackup", gl_lsbackup},
|
|
{"resetls", gl_resetls},
|
|
{"lampon", gl_lampon},
|
|
{"lampoff", gl_lampoff},
|
|
{"setbell", gl_setbell},
|
|
{"blankscreen", gl_blankscreen},
|
|
{"depthcue", gl_depthcue},
|
|
{"zbuffer", gl_zbuffer},
|
|
{"backface", gl_backface},
|
|
{"cmov2i", gl_cmov2i},
|
|
{"draw2i", gl_draw2i},
|
|
{"move2i", gl_move2i},
|
|
{"pnt2i", gl_pnt2i},
|
|
{"patchbasis", gl_patchbasis},
|
|
{"patchprecision", gl_patchprecision},
|
|
{"pdr2i", gl_pdr2i},
|
|
{"pmv2i", gl_pmv2i},
|
|
{"rpdr2i", gl_rpdr2i},
|
|
{"rpmv2i", gl_rpmv2i},
|
|
{"xfpt2i", gl_xfpt2i},
|
|
{"objdelete", gl_objdelete},
|
|
{"patchcurves", gl_patchcurves},
|
|
{"minsize", gl_minsize},
|
|
{"maxsize", gl_maxsize},
|
|
{"keepaspect", gl_keepaspect},
|
|
{"prefsize", gl_prefsize},
|
|
{"stepunit", gl_stepunit},
|
|
{"fudge", gl_fudge},
|
|
{"winmove", gl_winmove},
|
|
{"attachcursor", gl_attachcursor},
|
|
{"deflinestyle", gl_deflinestyle},
|
|
{"noise", gl_noise},
|
|
{"picksize", gl_picksize},
|
|
{"qenter", gl_qenter},
|
|
{"setdepth", gl_setdepth},
|
|
{"cmov2s", gl_cmov2s},
|
|
{"draw2s", gl_draw2s},
|
|
{"move2s", gl_move2s},
|
|
{"pdr2s", gl_pdr2s},
|
|
{"pmv2s", gl_pmv2s},
|
|
{"pnt2s", gl_pnt2s},
|
|
{"rdr2s", gl_rdr2s},
|
|
{"rmv2s", gl_rmv2s},
|
|
{"rpdr2s", gl_rpdr2s},
|
|
{"rpmv2s", gl_rpmv2s},
|
|
{"xfpt2s", gl_xfpt2s},
|
|
{"cmov2", gl_cmov2},
|
|
{"draw2", gl_draw2},
|
|
{"move2", gl_move2},
|
|
{"pnt2", gl_pnt2},
|
|
{"pdr2", gl_pdr2},
|
|
{"pmv2", gl_pmv2},
|
|
{"rdr2", gl_rdr2},
|
|
{"rmv2", gl_rmv2},
|
|
{"rpdr2", gl_rpdr2},
|
|
{"rpmv2", gl_rpmv2},
|
|
{"xfpt2", gl_xfpt2},
|
|
{"loadmatrix", gl_loadmatrix},
|
|
{"multmatrix", gl_multmatrix},
|
|
{"crv", gl_crv},
|
|
{"rcrv", gl_rcrv},
|
|
{"addtopup", gl_addtopup},
|
|
{"charstr", gl_charstr},
|
|
{"getport", gl_getport},
|
|
{"strwidth", gl_strwidth},
|
|
{"winopen", gl_winopen},
|
|
{"wintitle", gl_wintitle},
|
|
{"polf", gl_polf},
|
|
{"polf2", gl_polf2},
|
|
{"poly", gl_poly},
|
|
{"poly2", gl_poly2},
|
|
{"crvn", gl_crvn},
|
|
{"rcrvn", gl_rcrvn},
|
|
{"polf2i", gl_polf2i},
|
|
{"polfi", gl_polfi},
|
|
{"poly2i", gl_poly2i},
|
|
{"polyi", gl_polyi},
|
|
{"polf2s", gl_polf2s},
|
|
{"polfs", gl_polfs},
|
|
{"polys", gl_polys},
|
|
{"poly2s", gl_poly2s},
|
|
{"defcursor", gl_defcursor},
|
|
{"writepixels", gl_writepixels},
|
|
{"defbasis", gl_defbasis},
|
|
{"gewrite", gl_gewrite},
|
|
{"rotate", gl_rotate},
|
|
{"rot", gl_rot},
|
|
{"circfi", gl_circfi},
|
|
{"circi", gl_circi},
|
|
{"cmovi", gl_cmovi},
|
|
{"drawi", gl_drawi},
|
|
{"movei", gl_movei},
|
|
{"pnti", gl_pnti},
|
|
{"newtag", gl_newtag},
|
|
{"pdri", gl_pdri},
|
|
{"pmvi", gl_pmvi},
|
|
{"rdri", gl_rdri},
|
|
{"rmvi", gl_rmvi},
|
|
{"rpdri", gl_rpdri},
|
|
{"rpmvi", gl_rpmvi},
|
|
{"xfpti", gl_xfpti},
|
|
{"circ", gl_circ},
|
|
{"circf", gl_circf},
|
|
{"cmov", gl_cmov},
|
|
{"draw", gl_draw},
|
|
{"move", gl_move},
|
|
{"pnt", gl_pnt},
|
|
{"scale", gl_scale},
|
|
{"translate", gl_translate},
|
|
{"pdr", gl_pdr},
|
|
{"pmv", gl_pmv},
|
|
{"rdr", gl_rdr},
|
|
{"rmv", gl_rmv},
|
|
{"rpdr", gl_rpdr},
|
|
{"rpmv", gl_rpmv},
|
|
{"xfpt", gl_xfpt},
|
|
{"RGBcolor", gl_RGBcolor},
|
|
{"RGBwritemask", gl_RGBwritemask},
|
|
{"setcursor", gl_setcursor},
|
|
{"tie", gl_tie},
|
|
{"circfs", gl_circfs},
|
|
{"circs", gl_circs},
|
|
{"cmovs", gl_cmovs},
|
|
{"draws", gl_draws},
|
|
{"moves", gl_moves},
|
|
{"pdrs", gl_pdrs},
|
|
{"pmvs", gl_pmvs},
|
|
{"pnts", gl_pnts},
|
|
{"rdrs", gl_rdrs},
|
|
{"rmvs", gl_rmvs},
|
|
{"rpdrs", gl_rpdrs},
|
|
{"rpmvs", gl_rpmvs},
|
|
{"xfpts", gl_xfpts},
|
|
{"curorigin", gl_curorigin},
|
|
{"cyclemap", gl_cyclemap},
|
|
{"patch", gl_patch},
|
|
{"splf", gl_splf},
|
|
{"splf2", gl_splf2},
|
|
{"splfi", gl_splfi},
|
|
{"splf2i", gl_splf2i},
|
|
{"splfs", gl_splfs},
|
|
{"splf2s", gl_splf2s},
|
|
{"rpatch", gl_rpatch},
|
|
{"ortho2", gl_ortho2},
|
|
{"rect", gl_rect},
|
|
{"rectf", gl_rectf},
|
|
{"xfpt4", gl_xfpt4},
|
|
{"textport", gl_textport},
|
|
{"mapcolor", gl_mapcolor},
|
|
{"scrmask", gl_scrmask},
|
|
{"setvaluator", gl_setvaluator},
|
|
{"viewport", gl_viewport},
|
|
{"shaderange", gl_shaderange},
|
|
{"xfpt4s", gl_xfpt4s},
|
|
{"rectfi", gl_rectfi},
|
|
{"recti", gl_recti},
|
|
{"xfpt4i", gl_xfpt4i},
|
|
{"prefposition", gl_prefposition},
|
|
{"arc", gl_arc},
|
|
{"arcf", gl_arcf},
|
|
{"arcfi", gl_arcfi},
|
|
{"arci", gl_arci},
|
|
{"bbox2", gl_bbox2},
|
|
{"bbox2i", gl_bbox2i},
|
|
{"bbox2s", gl_bbox2s},
|
|
{"blink", gl_blink},
|
|
{"ortho", gl_ortho},
|
|
{"window", gl_window},
|
|
{"lookat", gl_lookat},
|
|
{"perspective", gl_perspective},
|
|
{"polarview", gl_polarview},
|
|
{"arcfs", gl_arcfs},
|
|
{"arcs", gl_arcs},
|
|
{"rectcopy", gl_rectcopy},
|
|
{"RGBcursor", gl_RGBcursor},
|
|
{"getbutton", gl_getbutton},
|
|
{"getcmmode", gl_getcmmode},
|
|
{"getlsbackup", gl_getlsbackup},
|
|
{"getresetls", gl_getresetls},
|
|
{"getdcm", gl_getdcm},
|
|
{"getzbuffer", gl_getzbuffer},
|
|
{"ismex", gl_ismex},
|
|
{"isobj", gl_isobj},
|
|
{"isqueued", gl_isqueued},
|
|
{"istag", gl_istag},
|
|
{"genobj", gl_genobj},
|
|
{"gentag", gl_gentag},
|
|
{"getbuffer", gl_getbuffer},
|
|
{"getcolor", gl_getcolor},
|
|
{"getdisplaymode", gl_getdisplaymode},
|
|
{"getfont", gl_getfont},
|
|
{"getheight", gl_getheight},
|
|
{"gethitcode", gl_gethitcode},
|
|
{"getlstyle", gl_getlstyle},
|
|
{"getlwidth", gl_getlwidth},
|
|
{"getmap", gl_getmap},
|
|
{"getplanes", gl_getplanes},
|
|
{"getwritemask", gl_getwritemask},
|
|
{"qtest", gl_qtest},
|
|
{"getlsrepeat", gl_getlsrepeat},
|
|
{"getmonitor", gl_getmonitor},
|
|
{"getopenobj", gl_getopenobj},
|
|
{"getpattern", gl_getpattern},
|
|
{"winget", gl_winget},
|
|
{"winattach", gl_winattach},
|
|
{"getothermonitor", gl_getothermonitor},
|
|
{"newpup", gl_newpup},
|
|
{"getvaluator", gl_getvaluator},
|
|
{"winset", gl_winset},
|
|
{"dopup", gl_dopup},
|
|
{"getdepth", gl_getdepth},
|
|
{"getcpos", gl_getcpos},
|
|
{"getsize", gl_getsize},
|
|
{"getorigin", gl_getorigin},
|
|
{"getviewport", gl_getviewport},
|
|
{"gettp", gl_gettp},
|
|
{"getgpos", gl_getgpos},
|
|
{"winposition", gl_winposition},
|
|
{"gRGBcolor", gl_gRGBcolor},
|
|
{"gRGBmask", gl_gRGBmask},
|
|
{"getscrmask", gl_getscrmask},
|
|
{"getmcolor", gl_getmcolor},
|
|
{"mapw", gl_mapw},
|
|
{"mapw2", gl_mapw2},
|
|
{"getcursor", gl_getcursor},
|
|
{"cmode", gl_cmode},
|
|
{"concave", gl_concave},
|
|
{"curstype", gl_curstype},
|
|
{"drawmode", gl_drawmode},
|
|
{"gammaramp", gl_gammaramp},
|
|
{"getbackface", gl_getbackface},
|
|
{"getdescender", gl_getdescender},
|
|
{"getdrawmode", gl_getdrawmode},
|
|
{"getmmode", gl_getmmode},
|
|
{"getsm", gl_getsm},
|
|
{"getvideo", gl_getvideo},
|
|
{"imakebackground", gl_imakebackground},
|
|
{"lmbind", gl_lmbind},
|
|
{"lmdef", gl_lmdef},
|
|
{"mmode", gl_mmode},
|
|
{"normal", gl_normal},
|
|
{"overlay", gl_overlay},
|
|
{"RGBrange", gl_RGBrange},
|
|
{"setvideo", gl_setvideo},
|
|
{"shademodel", gl_shademodel},
|
|
{"underlay", gl_underlay},
|
|
{"bgnclosedline", gl_bgnclosedline},
|
|
{"bgnline", gl_bgnline},
|
|
{"bgnpoint", gl_bgnpoint},
|
|
{"bgnpolygon", gl_bgnpolygon},
|
|
{"bgnsurface", gl_bgnsurface},
|
|
{"bgntmesh", gl_bgntmesh},
|
|
{"bgntrim", gl_bgntrim},
|
|
{"endclosedline", gl_endclosedline},
|
|
{"endline", gl_endline},
|
|
{"endpoint", gl_endpoint},
|
|
{"endpolygon", gl_endpolygon},
|
|
{"endsurface", gl_endsurface},
|
|
{"endtmesh", gl_endtmesh},
|
|
{"endtrim", gl_endtrim},
|
|
{"blendfunction", gl_blendfunction},
|
|
{"c3f", gl_c3f},
|
|
{"c3i", gl_c3i},
|
|
{"c3s", gl_c3s},
|
|
{"c4f", gl_c4f},
|
|
{"c4i", gl_c4i},
|
|
{"c4s", gl_c4s},
|
|
{"colorf", gl_colorf},
|
|
{"cpack", gl_cpack},
|
|
{"czclear", gl_czclear},
|
|
{"dglclose", gl_dglclose},
|
|
{"dglopen", gl_dglopen},
|
|
{"getgdesc", gl_getgdesc},
|
|
{"getnurbsproperty", gl_getnurbsproperty},
|
|
{"glcompat", gl_glcompat},
|
|
{"iconsize", gl_iconsize},
|
|
{"icontitle", gl_icontitle},
|
|
{"lRGBrange", gl_lRGBrange},
|
|
{"linesmooth", gl_linesmooth},
|
|
{"lmcolor", gl_lmcolor},
|
|
{"logicop", gl_logicop},
|
|
{"lsetdepth", gl_lsetdepth},
|
|
{"lshaderange", gl_lshaderange},
|
|
{"n3f", gl_n3f},
|
|
{"noborder", gl_noborder},
|
|
{"pntsmooth", gl_pntsmooth},
|
|
{"readsource", gl_readsource},
|
|
{"rectzoom", gl_rectzoom},
|
|
{"sbox", gl_sbox},
|
|
{"sboxi", gl_sboxi},
|
|
{"sboxs", gl_sboxs},
|
|
{"sboxf", gl_sboxf},
|
|
{"sboxfi", gl_sboxfi},
|
|
{"sboxfs", gl_sboxfs},
|
|
{"setnurbsproperty", gl_setnurbsproperty},
|
|
{"setpup", gl_setpup},
|
|
{"smoothline", gl_smoothline},
|
|
{"subpixel", gl_subpixel},
|
|
{"swaptmesh", gl_swaptmesh},
|
|
{"swinopen", gl_swinopen},
|
|
{"v2f", gl_v2f},
|
|
{"v2i", gl_v2i},
|
|
{"v2s", gl_v2s},
|
|
{"v3f", gl_v3f},
|
|
{"v3i", gl_v3i},
|
|
{"v3s", gl_v3s},
|
|
{"v4f", gl_v4f},
|
|
{"v4i", gl_v4i},
|
|
{"v4s", gl_v4s},
|
|
{"videocmd", gl_videocmd},
|
|
{"windepth", gl_windepth},
|
|
{"wmpack", gl_wmpack},
|
|
{"zdraw", gl_zdraw},
|
|
{"zfunction", gl_zfunction},
|
|
{"zsource", gl_zsource},
|
|
{"zwritemask", gl_zwritemask},
|
|
{"v2d", gl_v2d},
|
|
{"v3d", gl_v3d},
|
|
{"v4d", gl_v4d},
|
|
{"pixmode", gl_pixmode},
|
|
{"qgetfd", gl_qgetfd},
|
|
{"dither", gl_dither},
|
|
{NULL, NULL} /* Sentinel */
|
|
};
|
|
|
|
void
|
|
initgl()
|
|
{
|
|
Py_InitModule("gl", gl_methods);
|
|
}
|