mirror of https://github.com/python/cpython
1346 lines
31 KiB
Plaintext
1346 lines
31 KiB
Plaintext
/*
|
|
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>
|
|
|
|
#include "allobjects.h"
|
|
#include "import.h"
|
|
#include "modsupport.h"
|
|
#include "cgensupport.h"
|
|
#include "ceval.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.
|
|
*/
|
|
|
|
% qread
|
|
|
|
static object *
|
|
gl_qread(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
long retval;
|
|
short arg1 ;
|
|
BGN_SAVE
|
|
retval = qread( & arg1 );
|
|
END_SAVE
|
|
{ object *v = newtupleobject( 2 );
|
|
if (v == NULL) return NULL;
|
|
settupleitem(v, 0, mknewlongobject(retval));
|
|
settupleitem(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.
|
|
*/
|
|
|
|
% varray
|
|
|
|
static object *
|
|
gl_varray(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v, *w;
|
|
int i, n, width;
|
|
double vec[3];
|
|
object * (*getitem) FPROTO((object *, int));
|
|
|
|
if (!getiobjectarg(args, 1, 0, &v))
|
|
return NULL;
|
|
|
|
if (is_listobject(v)) {
|
|
n = getlistsize(v);
|
|
getitem = getlistitem;
|
|
}
|
|
else if (is_tupleobject(v)) {
|
|
n = gettuplesize(v);
|
|
getitem = gettupleitem;
|
|
}
|
|
else {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
|
|
if (n == 0) {
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
if (n > 0)
|
|
w = (*getitem)(v, 0);
|
|
|
|
width = 0;
|
|
if (w == NULL) {
|
|
}
|
|
else if (is_listobject(w)) {
|
|
width = getlistsize(w);
|
|
}
|
|
else if (is_tupleobject(w)) {
|
|
width = gettuplesize(w);
|
|
}
|
|
|
|
switch (width) {
|
|
case 2:
|
|
vec[2] = 0.0;
|
|
/* Fall through */
|
|
case 3:
|
|
break;
|
|
default:
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
w = (*getitem)(v, i);
|
|
if (!getidoublearray(w, 1, 0, width, vec))
|
|
return NULL;
|
|
v3d(vec);
|
|
}
|
|
|
|
INCREF(None);
|
|
return 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 object *gen_nvarray(); /* Forward */
|
|
|
|
% nvarray
|
|
|
|
static object *
|
|
gl_nvarray(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
return gen_nvarray(args, 0);
|
|
}
|
|
|
|
% vnarray
|
|
|
|
static object *
|
|
gl_vnarray(self, args)
|
|
object *self;
|
|
object *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 object *
|
|
gen_nvarray(args, inorm)
|
|
object *args;
|
|
int inorm;
|
|
{
|
|
object *v, *w, *wnorm, *wvec;
|
|
int i, n;
|
|
float norm[3], vec[3];
|
|
object * (*getitem) FPROTO((object *, int));
|
|
|
|
if (!getiobjectarg(args, 1, 0, &v))
|
|
return NULL;
|
|
|
|
if (is_listobject(v)) {
|
|
n = getlistsize(v);
|
|
getitem = getlistitem;
|
|
}
|
|
else if (is_tupleobject(v)) {
|
|
n = gettuplesize(v);
|
|
getitem = gettupleitem;
|
|
}
|
|
else {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
w = (*getitem)(v, i);
|
|
if (!is_tupleobject(w) || gettuplesize(w) != 2) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
wnorm = gettupleitem(w, inorm);
|
|
wvec = gettupleitem(w, 1 - inorm);
|
|
if (!getifloatarray(wnorm, 1, 0, 3, norm) ||
|
|
!getifloatarray(wvec, 1, 0, 3, vec))
|
|
return NULL;
|
|
n3f(norm);
|
|
v3f(vec);
|
|
}
|
|
|
|
INCREF(None);
|
|
return 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]
|
|
*/
|
|
|
|
% nurbssurface
|
|
|
|
static object *
|
|
gl_nurbssurface(self, args)
|
|
object *self;
|
|
object *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;
|
|
object *v, *w, *pt;
|
|
double *pnext;
|
|
if (!getilongarraysize(args, 6, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = NEW(double, arg1 )) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
if (!getidoublearray(args, 6, 0, arg1 , arg2))
|
|
return NULL;
|
|
if (!getilongarraysize(args, 6, 1, &arg3))
|
|
return NULL;
|
|
if ((arg4 = NEW(double, arg3 )) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
if (!getidoublearray(args, 6, 1, arg3 , arg4))
|
|
return NULL;
|
|
if (!getilongarg(args, 6, 3, &arg6))
|
|
return NULL;
|
|
if (!getilongarg(args, 6, 4, &arg7))
|
|
return NULL;
|
|
if (!getilongarg(args, 6, 5, &arg8))
|
|
return NULL;
|
|
if (arg8 == N_XYZ)
|
|
ncoords = 3;
|
|
else if (arg8 == N_XYZW)
|
|
ncoords = 4;
|
|
else {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
s_nctl = arg1 - arg6;
|
|
t_nctl = arg3 - arg7;
|
|
if (!getiobjectarg(args, 6, 2, &v))
|
|
return NULL;
|
|
if (!is_listobject(v) || getlistsize(v) != s_nctl) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
if ((arg5 = NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
pnext = arg5;
|
|
for (s = 0; s < s_nctl; s++) {
|
|
w = getlistitem(v, s);
|
|
if (w == NULL || !is_listobject(w) ||
|
|
getlistsize(w) != t_nctl) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
for (t = 0; t < t_nctl; t++) {
|
|
pt = getlistitem(w, t);
|
|
if (!getidoublearray(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 );
|
|
DEL(arg2);
|
|
DEL(arg4);
|
|
DEL(arg5);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
/* nurbscurve(knots, ctlpoints, order, type).
|
|
The length of ctlpoints is len(knots)-order. */
|
|
|
|
%nurbscurve
|
|
|
|
static object *
|
|
gl_nurbscurve(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
long arg1 ;
|
|
double * arg2 ;
|
|
long arg3 ;
|
|
double * arg4 ;
|
|
long arg5 ;
|
|
long arg6 ;
|
|
int ncoords, npoints;
|
|
int i;
|
|
object *v;
|
|
double *pnext;
|
|
if (!getilongarraysize(args, 4, 0, &arg1))
|
|
return NULL;
|
|
if ((arg2 = NEW(double, arg1 )) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
if (!getidoublearray(args, 4, 0, arg1 , arg2))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 2, &arg5))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 3, &arg6))
|
|
return NULL;
|
|
if (arg6 == N_ST)
|
|
ncoords = 2;
|
|
else if (arg6 == N_STW)
|
|
ncoords = 3;
|
|
else {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
npoints = arg1 - arg5;
|
|
if (!getiobjectarg(args, 4, 1, &v))
|
|
return NULL;
|
|
if (!is_listobject(v) || getlistsize(v) != npoints) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
if ((arg4 = NEW(double, npoints*ncoords )) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
pnext = arg4;
|
|
for (i = 0; i < npoints; i++) {
|
|
if (!getidoublearray(getlistitem(v, i), 1, 0, ncoords, pnext))
|
|
return NULL;
|
|
pnext += ncoords;
|
|
}
|
|
arg3 = (sizeof(double)) * ncoords;
|
|
nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
|
|
DEL(arg2);
|
|
DEL(arg4);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
/* pwlcurve(points, type).
|
|
Points is a list of points. Type must be N_ST. */
|
|
|
|
%pwlcurve
|
|
|
|
static object *
|
|
gl_pwlcurve(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
object *v;
|
|
long type;
|
|
double *data, *pnext;
|
|
long npoints, ncoords;
|
|
int i;
|
|
if (!getiobjectarg(args, 2, 0, &v))
|
|
return NULL;
|
|
if (!getilongarg(args, 2, 1, &type))
|
|
return NULL;
|
|
if (!is_listobject(v)) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
npoints = getlistsize(v);
|
|
if (type == N_ST)
|
|
ncoords = 2;
|
|
else {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
if ((data = NEW(double, npoints*ncoords)) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
pnext = data;
|
|
for (i = 0; i < npoints; i++) {
|
|
if (!getidoublearray(getlistitem(v, i), 1, 0, ncoords, pnext))
|
|
return NULL;
|
|
pnext += ncoords;
|
|
}
|
|
pwlcurve(npoints, data, sizeof(double)*ncoords, type);
|
|
DEL(data);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
|
|
/* Picking and Selecting */
|
|
|
|
static short *pickbuffer = NULL;
|
|
static long pickbuffersize;
|
|
|
|
static object *
|
|
pick_select(args, func)
|
|
object *args;
|
|
void (*func)();
|
|
{
|
|
if (!getilongarg(args, 1, 0, &pickbuffersize))
|
|
return NULL;
|
|
if (pickbuffer != NULL) {
|
|
err_setstr(RuntimeError,
|
|
"pick/gselect: already picking/selecting");
|
|
return NULL;
|
|
}
|
|
if ((pickbuffer = NEW(short, pickbuffersize)) == NULL) {
|
|
return err_nomem();
|
|
}
|
|
(*func)(pickbuffer, pickbuffersize);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
endpick_select(args, func)
|
|
object *args;
|
|
long (*func)();
|
|
{
|
|
object *v, *w;
|
|
int i, nhits, n;
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
if (pickbuffer == NULL) {
|
|
err_setstr(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 = newlistobject(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 = newintobject((long)pickbuffer[i]);
|
|
if (w == NULL) {
|
|
DECREF(v);
|
|
return NULL;
|
|
}
|
|
setlistitem(v, i, w);
|
|
}
|
|
DEL(pickbuffer);
|
|
pickbuffer = NULL;
|
|
return v;
|
|
}
|
|
|
|
extern void pick(), gselect();
|
|
extern long endpick(), endselect();
|
|
|
|
%pick
|
|
static object *gl_pick(self, args) object *self, *args; {
|
|
return pick_select(args, pick);
|
|
}
|
|
|
|
%endpick
|
|
static object *gl_endpick(self, args) object *self, *args; {
|
|
return endpick_select(args, endpick);
|
|
}
|
|
|
|
%gselect
|
|
static object *gl_gselect(self, args) object *self, *args; {
|
|
return pick_select(args, gselect);
|
|
}
|
|
|
|
%endselect
|
|
static object *gl_endselect(self, args) object *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. */
|
|
|
|
% getmatrix float r[16]
|
|
|
|
static object *
|
|
gl_getmatrix(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
Matrix arg1;
|
|
object *v, *w;
|
|
int i, j;
|
|
getmatrix( arg1 );
|
|
v = newlistobject(16);
|
|
if (v == NULL) {
|
|
return err_nomem();
|
|
}
|
|
for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
|
|
w = mknewfloatobject(arg1[i][j]);
|
|
if (w == NULL) {
|
|
DECREF(v);
|
|
return NULL;
|
|
}
|
|
setlistitem(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... */
|
|
|
|
% altgetmatrix float r[4][4]
|
|
|
|
static object *
|
|
gl_altgetmatrix(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
Matrix arg1;
|
|
object *v, *w;
|
|
int i, j;
|
|
getmatrix( arg1 );
|
|
v = newlistobject(4);
|
|
if (v == NULL) {
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
w = newlistobject(4);
|
|
if (w == NULL) {
|
|
DECREF(v);
|
|
return NULL;
|
|
}
|
|
setlistitem(v, i, w);
|
|
}
|
|
for (i = 0; i < 4; i++) {
|
|
for (j = 0; j < 4; j++) {
|
|
w = mknewfloatobject(arg1[i][j]);
|
|
if (w == NULL) {
|
|
DECREF(v);
|
|
return NULL;
|
|
}
|
|
setlistitem(getlistitem(v, i), j, w);
|
|
}
|
|
}
|
|
return v;
|
|
}
|
|
|
|
% lrectwrite
|
|
|
|
static object *
|
|
gl_lrectwrite(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
short x1 ;
|
|
short y1 ;
|
|
short x2 ;
|
|
short y2 ;
|
|
string parray ;
|
|
object *s;
|
|
int pixcount;
|
|
if (!getishortarg(args, 5, 0, &x1))
|
|
return NULL;
|
|
if (!getishortarg(args, 5, 1, &y1))
|
|
return NULL;
|
|
if (!getishortarg(args, 5, 2, &x2))
|
|
return NULL;
|
|
if (!getishortarg(args, 5, 3, &y2))
|
|
return NULL;
|
|
if (!getistringarg(args, 5, 4, &parray))
|
|
return NULL;
|
|
if (!getiobjectarg(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 (!is_stringobject(s) || getstringsize(s) != pixcount*sizeof(long)) {
|
|
err_setstr(RuntimeError,
|
|
"string arg to lrectwrite has wrong size");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
% lrectread
|
|
|
|
static object *
|
|
gl_lrectread(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
short x1 ;
|
|
short y1 ;
|
|
short x2 ;
|
|
short y2 ;
|
|
object *parray;
|
|
int pixcount;
|
|
if (!getishortarg(args, 4, 0, &x1))
|
|
return NULL;
|
|
if (!getishortarg(args, 4, 1, &y1))
|
|
return NULL;
|
|
if (!getishortarg(args, 4, 2, &x2))
|
|
return NULL;
|
|
if (!getishortarg(args, 4, 3, &y2))
|
|
return NULL;
|
|
pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
|
|
parray = newsizedstringobject((char *)NULL, pixcount*sizeof(long));
|
|
if (parray == NULL)
|
|
return NULL; /* No memory */
|
|
lrectread(x1, y1, x2, y2, (unsigned long *) getstringvalue(parray));
|
|
return parray;
|
|
}
|
|
|
|
% readdisplay
|
|
|
|
static object *
|
|
gl_readdisplay(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
short x1, y1, x2, y2;
|
|
unsigned long *parray, hints;
|
|
long size, size_ret;
|
|
object *rv;
|
|
|
|
if ( !getargs(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
|
|
return 0;
|
|
size = (long)(x2+1-x1) * (long)(y2+1-y1);
|
|
rv = newsizedstringobject((char *)NULL, size*sizeof(long));
|
|
if ( rv == NULL )
|
|
return NULL;
|
|
parray = (unsigned long *)getstringvalue(rv);
|
|
size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
|
|
if ( size_ret != size ) {
|
|
printf("gl_readdisplay: got %d pixels, expected %d\n",
|
|
size_ret, size);
|
|
err_setstr(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).
|
|
*/
|
|
|
|
% packrect
|
|
|
|
static object *
|
|
gl_packrect(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
long width, height, packfactor;
|
|
char *s;
|
|
object *unpacked, *packed;
|
|
int pixcount, packedcount, x, y, r, g, b;
|
|
unsigned long pixel;
|
|
unsigned char *p;
|
|
unsigned long *parray;
|
|
if (!getilongarg(args, 4, 0, &width))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 1, &height))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 2, &packfactor))
|
|
return NULL;
|
|
if (!getistringarg(args, 4, 3, &s)) /* For type checking only */
|
|
return NULL;
|
|
if (!getiobjectarg(args, 4, 3, &unpacked))
|
|
return NULL;
|
|
if (width <= 0 || height <= 0 || packfactor <= 0) {
|
|
err_setstr(RuntimeError, "packrect args must be > 0");
|
|
return NULL;
|
|
}
|
|
pixcount = width*height;
|
|
packedcount = ((width+packfactor-1)/packfactor) *
|
|
((height+packfactor-1)/packfactor);
|
|
if (getstringsize(unpacked) != pixcount*sizeof(long)) {
|
|
err_setstr(RuntimeError,
|
|
"string arg to packrect has wrong size");
|
|
return NULL;
|
|
}
|
|
packed = newsizedstringobject((char *)NULL, packedcount);
|
|
if (packed == NULL)
|
|
return NULL;
|
|
parray = (unsigned long *) getstringvalue(unpacked);
|
|
p = (unsigned char *) getstringvalue(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;
|
|
}
|
|
|
|
% unpackrect
|
|
|
|
static unsigned long unpacktab[256];
|
|
static int unpacktab_inited = 0;
|
|
|
|
static object *
|
|
gl_unpackrect(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
long width, height, packfactor;
|
|
char *s;
|
|
object *unpacked, *packed;
|
|
int pixcount, packedcount, y;
|
|
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 (!getilongarg(args, 4, 0, &width))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 1, &height))
|
|
return NULL;
|
|
if (!getilongarg(args, 4, 2, &packfactor))
|
|
return NULL;
|
|
if (!getistringarg(args, 4, 3, &s)) /* For type checking only */
|
|
return NULL;
|
|
if (!getiobjectarg(args, 4, 3, &packed))
|
|
return NULL;
|
|
if (width <= 0 || height <= 0 || packfactor <= 0) {
|
|
err_setstr(RuntimeError, "packrect args must be > 0");
|
|
return NULL;
|
|
}
|
|
pixcount = width*height;
|
|
packedcount = ((width+packfactor-1)/packfactor) *
|
|
((height+packfactor-1)/packfactor);
|
|
if (getstringsize(packed) != packedcount) {
|
|
err_setstr(RuntimeError,
|
|
"string arg to unpackrect has wrong size");
|
|
return NULL;
|
|
}
|
|
unpacked = newsizedstringobject((char *)NULL, pixcount*sizeof(long));
|
|
if (unpacked == NULL)
|
|
return NULL;
|
|
parray = (unsigned long *) getstringvalue(unpacked);
|
|
p = (unsigned char *) getstringvalue(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;
|
|
}
|
|
|
|
% gversion
|
|
static object *
|
|
gl_gversion(self, args)
|
|
object *self;
|
|
object *args;
|
|
{
|
|
char buf[20];
|
|
gversion(buf);
|
|
return newstringobject(buf);
|
|
}
|
|
|
|
|
|
/* End of manually written stubs */
|
|
|
|
%%
|
|
|
|
long getshade
|
|
if !solaris void devport short s long s
|
|
void rdr2i long s long s
|
|
void rectfs short s short s short s short s
|
|
void rects short s short s short s short s
|
|
void rmv2i long s long s
|
|
void noport
|
|
void popviewport
|
|
void clear
|
|
void clearhitcode
|
|
void closeobj
|
|
void cursoff
|
|
void curson
|
|
void doublebuffer
|
|
void finish
|
|
void gconfig
|
|
void ginit
|
|
void greset
|
|
void multimap
|
|
void onemap
|
|
void popattributes
|
|
void popmatrix
|
|
void pushattributes
|
|
void pushmatrix
|
|
void pushviewport
|
|
void qreset
|
|
void RGBmode
|
|
void singlebuffer
|
|
void swapbuffers
|
|
void gsync
|
|
void gflush
|
|
void tpon
|
|
void tpoff
|
|
void clkon
|
|
void clkoff
|
|
void ringbell
|
|
#void callfunc
|
|
void gbegin
|
|
void textinit
|
|
void initnames
|
|
void pclos
|
|
void popname
|
|
if !solaris void spclos
|
|
void zclear
|
|
void screenspace
|
|
void reshapeviewport
|
|
void winpush
|
|
void winpop
|
|
void foreground
|
|
void endfullscrn
|
|
if !solaris void endpupmode
|
|
void fullscrn
|
|
if !solaris void pupmode
|
|
void winconstraints
|
|
void pagecolor short s
|
|
void textcolor short s
|
|
void color short s
|
|
void curveit short s
|
|
void font short s
|
|
void linewidth short s
|
|
void setlinestyle short s
|
|
void setmap short s
|
|
void swapinterval short s
|
|
void writemask short s
|
|
if !solaris void textwritemask short s
|
|
void qdevice short s
|
|
void unqdevice short s
|
|
void curvebasis short s
|
|
void curveprecision short s
|
|
void loadname short s
|
|
void passthrough short s
|
|
void pushname short s
|
|
void setmonitor short s
|
|
if !solaris void setshade short s
|
|
void setpattern short s
|
|
if !solaris void pagewritemask short s
|
|
#
|
|
void callobj long s
|
|
void delobj long s
|
|
void editobj long s
|
|
void makeobj long s
|
|
void maketag long s
|
|
void chunksize long s
|
|
void compactify long s
|
|
void deltag long s
|
|
void lsrepeat long s
|
|
void objinsert long s
|
|
void objreplace long s
|
|
void winclose long s
|
|
void blanktime long s
|
|
void freepup long s
|
|
# This is not in the library!?
|
|
###void pupcolor long s
|
|
#
|
|
void backbuffer long s
|
|
void frontbuffer long s
|
|
if !solaris void lsbackup long s
|
|
void resetls long s
|
|
void lampon long s
|
|
void lampoff long s
|
|
void setbell long s
|
|
void blankscreen long s
|
|
void depthcue long s
|
|
void zbuffer long s
|
|
void backface long s
|
|
#
|
|
void cmov2i long s long s
|
|
void draw2i long s long s
|
|
void move2i long s long s
|
|
void pnt2i long s long s
|
|
void patchbasis long s long s
|
|
void patchprecision long s long s
|
|
void pdr2i long s long s
|
|
void pmv2i long s long s
|
|
void rpdr2i long s long s
|
|
void rpmv2i long s long s
|
|
void xfpt2i long s long s
|
|
void objdelete long s long s
|
|
void patchcurves long s long s
|
|
void minsize long s long s
|
|
void maxsize long s long s
|
|
void keepaspect long s long s
|
|
void prefsize long s long s
|
|
void stepunit long s long s
|
|
void fudge long s long s
|
|
void winmove long s long s
|
|
#
|
|
void attachcursor short s short s
|
|
void deflinestyle short s short s
|
|
void noise short s short s
|
|
void picksize short s short s
|
|
void qenter short s short s
|
|
void setdepth short s short s
|
|
void cmov2s short s short s
|
|
void draw2s short s short s
|
|
void move2s short s short s
|
|
void pdr2s short s short s
|
|
void pmv2s short s short s
|
|
void pnt2s short s short s
|
|
void rdr2s short s short s
|
|
void rmv2s short s short s
|
|
void rpdr2s short s short s
|
|
void rpmv2s short s short s
|
|
void xfpt2s short s short s
|
|
#
|
|
void cmov2 float s float s
|
|
void draw2 float s float s
|
|
void move2 float s float s
|
|
void pnt2 float s float s
|
|
void pdr2 float s float s
|
|
void pmv2 float s float s
|
|
void rdr2 float s float s
|
|
void rmv2 float s float s
|
|
void rpdr2 float s float s
|
|
void rpmv2 float s float s
|
|
void xfpt2 float s float s
|
|
#
|
|
void loadmatrix float s[4*4]
|
|
# Really [4][4]
|
|
void multmatrix float s[4*4]
|
|
# Really [4][4]
|
|
void crv float s[3*4]
|
|
# Really [4][3]
|
|
void rcrv float s[4*4]
|
|
# Really [4][4]
|
|
#
|
|
# Methods that have strings.
|
|
#
|
|
void addtopup long s char *s long s
|
|
void charstr char *s
|
|
void getport char *s
|
|
long strwidth char *s
|
|
long winopen char *s
|
|
void wintitle char *s
|
|
#
|
|
# Methods that have 1 long (# of elements) and an array
|
|
#
|
|
void polf long s float s[3*arg1]
|
|
void polf2 long s float s[2*arg1]
|
|
void poly long s float s[3*arg1]
|
|
void poly2 long s float s[2*arg1]
|
|
void crvn long s float s[3*arg1]
|
|
void rcrvn long s float s[4*arg1]
|
|
#
|
|
void polf2i long s long s[2*arg1]
|
|
void polfi long s long s[3*arg1]
|
|
void poly2i long s long s[2*arg1]
|
|
void polyi long s long s[3*arg1]
|
|
#
|
|
void polf2s long s short s[2*arg1]
|
|
void polfs long s short s[3*arg1]
|
|
void polys long s short s[3*arg1]
|
|
void poly2s long s short s[2*arg1]
|
|
#
|
|
void defcursor short s u_short s[128]
|
|
# Is this useful?
|
|
void writepixels short s u_short s[arg1]
|
|
# Should be unsigned short...
|
|
void defbasis long s float s[4*4]
|
|
if !solaris void gewrite short s short s[arg1]
|
|
#
|
|
void rotate short s char s
|
|
# This is not in the library!?
|
|
###void setbutton short s char s
|
|
void rot float s char s
|
|
#
|
|
void circfi long s long s long s
|
|
void circi long s long s long s
|
|
void cmovi long s long s long s
|
|
void drawi long s long s long s
|
|
void movei long s long s long s
|
|
void pnti long s long s long s
|
|
void newtag long s long s long s
|
|
void pdri long s long s long s
|
|
void pmvi long s long s long s
|
|
void rdri long s long s long s
|
|
void rmvi long s long s long s
|
|
void rpdri long s long s long s
|
|
void rpmvi long s long s long s
|
|
void xfpti long s long s long s
|
|
#
|
|
void circ float s float s float s
|
|
void circf float s float s float s
|
|
void cmov float s float s float s
|
|
void draw float s float s float s
|
|
void move float s float s float s
|
|
void pnt float s float s float s
|
|
void scale float s float s float s
|
|
void translate float s float s float s
|
|
void pdr float s float s float s
|
|
void pmv float s float s float s
|
|
void rdr float s float s float s
|
|
void rmv float s float s float s
|
|
void rpdr float s float s float s
|
|
void rpmv float s float s float s
|
|
void xfpt float s float s float s
|
|
#
|
|
void RGBcolor short s short s short s
|
|
void RGBwritemask short s short s short s
|
|
void setcursor short s short s short s
|
|
void tie short s short s short s
|
|
void circfs short s short s short s
|
|
void circs short s short s short s
|
|
void cmovs short s short s short s
|
|
void draws short s short s short s
|
|
void moves short s short s short s
|
|
void pdrs short s short s short s
|
|
void pmvs short s short s short s
|
|
void pnts short s short s short s
|
|
void rdrs short s short s short s
|
|
void rmvs short s short s short s
|
|
void rpdrs short s short s short s
|
|
void rpmvs short s short s short s
|
|
void xfpts short s short s short s
|
|
void curorigin short s short s short s
|
|
void cyclemap short s short s short s
|
|
#
|
|
void patch float s[4*4] float s[4*4] float s[4*4]
|
|
void splf long s float s[3*arg1] u_short s[arg1]
|
|
void splf2 long s float s[2*arg1] u_short s[arg1]
|
|
void splfi long s long s[3*arg1] u_short s[arg1]
|
|
void splf2i long s long s[2*arg1] u_short s[arg1]
|
|
void splfs long s short s[3*arg1] u_short s[arg1]
|
|
void splf2s long s short s[2*arg1] u_short s[arg1]
|
|
###void defpattern short s short s u_short s[arg2*arg2/16]
|
|
#
|
|
void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4]
|
|
#
|
|
# routines that send 4 floats
|
|
#
|
|
void ortho2 float s float s float s float s
|
|
void rect float s float s float s float s
|
|
void rectf float s float s float s float s
|
|
void xfpt4 float s float s float s float s
|
|
#
|
|
void textport short s short s short s short s
|
|
void mapcolor short s short s short s short s
|
|
void scrmask short s short s short s short s
|
|
void setvaluator short s short s short s short s
|
|
void viewport short s short s short s short s
|
|
void shaderange short s short s short s short s
|
|
void xfpt4s short s short s short s short s
|
|
void rectfi long s long s long s long s
|
|
void recti long s long s long s long s
|
|
void xfpt4i long s long s long s long s
|
|
void prefposition long s long s long s long s
|
|
#
|
|
void arc float s float s float s short s short s
|
|
void arcf float s float s float s short s short s
|
|
void arcfi long s long s long s short s short s
|
|
void arci long s long s long s short s short s
|
|
#
|
|
void bbox2 short s short s float s float s float s float s
|
|
void bbox2i short s short s long s long s long s long s
|
|
void bbox2s short s short s short s short s short s short s
|
|
void blink short s short s short s short s short s
|
|
void ortho float s float s float s float s float s float s
|
|
void window float s float s float s float s float s float s
|
|
void lookat float s float s float s float s float s float s short s
|
|
#
|
|
void perspective short s float s float s float s
|
|
void polarview float s short s short s short s
|
|
# XXX getichararray not supported
|
|
#void writeRGB short s char s[arg1] char s[arg1] char s[arg1]
|
|
#
|
|
void arcfs short s short s short s short s short s
|
|
void arcs short s short s short s short s short s
|
|
void rectcopy short s short s short s short s short s short s
|
|
if !solaris void RGBcursor short s short s short s short s short s short s short s
|
|
#
|
|
long getbutton short s
|
|
long getcmmode
|
|
long getlsbackup
|
|
long getresetls
|
|
long getdcm
|
|
long getzbuffer
|
|
long ismex
|
|
long isobj long s
|
|
long isqueued short s
|
|
long istag long s
|
|
#
|
|
long genobj
|
|
long gentag
|
|
long getbuffer
|
|
long getcolor
|
|
long getdisplaymode
|
|
long getfont
|
|
long getheight
|
|
long gethitcode
|
|
long getlstyle
|
|
long getlwidth
|
|
long getmap
|
|
long getplanes
|
|
long getwritemask
|
|
long qtest
|
|
long getlsrepeat
|
|
long getmonitor
|
|
long getopenobj
|
|
long getpattern
|
|
long winget
|
|
long winattach
|
|
long getothermonitor
|
|
long newpup
|
|
#
|
|
long getvaluator short s
|
|
void winset long s
|
|
long dopup long s
|
|
void getdepth short r short r
|
|
void getcpos short r short r
|
|
void getsize long r long r
|
|
void getorigin long r long r
|
|
void getviewport short r short r short r short r
|
|
if !solaris void gettp short r short r short r short r
|
|
void getgpos float r float r float r float r
|
|
void winposition long s long s long s long s
|
|
void gRGBcolor short r short r short r
|
|
void gRGBmask short r short r short r
|
|
void getscrmask short r short r short r short r
|
|
###void gRGBcursor short r short r short r short r short r short r short r short r
|
|
void getmcolor short s short r short r short r
|
|
void mapw long s short s short s float r float r float r float r float r float r
|
|
void mapw2 long s short s short s float r float r
|
|
###void defrasterfont short s short s short s Fontchar s[arg3] short s short s[4*arg5]
|
|
###long qread short r
|
|
void getcursor short r u_short r u_short r long r
|
|
#
|
|
# For these we receive arrays of stuff
|
|
#
|
|
###void getdev long s short s[arg1] short r[arg1]
|
|
#XXX not generated correctly yet
|
|
#void getmatrix float r[16]
|
|
###long readpixels short s short r[retval]
|
|
###long readRGB short s char r[retval] char r[retval] char r[retval]
|
|
###long blkqread short s short r[arg1]
|
|
#
|
|
# New 4D routines
|
|
#
|
|
void cmode
|
|
void concave long s
|
|
void curstype long s
|
|
void drawmode long s
|
|
void gammaramp short s[256] short s[256] short s[256]
|
|
long getbackface
|
|
long getdescender
|
|
long getdrawmode
|
|
long getmmode
|
|
long getsm
|
|
long getvideo long s
|
|
void imakebackground
|
|
void lmbind short s short s
|
|
void lmdef long s long s long s float s[arg3]
|
|
void mmode long s
|
|
void normal float s[3]
|
|
void overlay long s
|
|
void RGBrange short s short s short s short s short s short s short s short s
|
|
if !solaris void setvideo long s long s
|
|
void shademodel long s
|
|
void underlay long s
|
|
#
|
|
# New Personal Iris/GT Routines
|
|
#
|
|
void bgnclosedline
|
|
void bgnline
|
|
void bgnpoint
|
|
void bgnpolygon
|
|
void bgnsurface
|
|
void bgntmesh
|
|
void bgntrim
|
|
void endclosedline
|
|
void endline
|
|
void endpoint
|
|
void endpolygon
|
|
void endsurface
|
|
void endtmesh
|
|
void endtrim
|
|
void blendfunction long s long s
|
|
void c3f float s[3]
|
|
void c3i long s[3]
|
|
void c3s short s[3]
|
|
void c4f float s[4]
|
|
void c4i long s[4]
|
|
void c4s short s[4]
|
|
void colorf float s
|
|
void cpack long s
|
|
void czclear long s long s
|
|
void dglclose long s
|
|
long dglopen char *s long s
|
|
long getgdesc long s
|
|
void getnurbsproperty long s float r
|
|
void glcompat long s long s
|
|
void iconsize long s long s
|
|
void icontitle char *s
|
|
void lRGBrange short s short s short s short s short s short s long s long s
|
|
void linesmooth long s
|
|
void lmcolor long s
|
|
void logicop long s
|
|
###long lrectread short s short s short s short s long r[retval]
|
|
###void lrectwrite short s short s short s short s long s[(arg2-arg1+1)*(arg4-arg3+1)]
|
|
### Now manual, with string last arg
|
|
###long rectread short s short s short s short s short r[retval]
|
|
###void rectwrite short s short s short s short s short s[(arg2-arg1+1)*(arg4-arg3+1)]
|
|
void lsetdepth long s long s
|
|
void lshaderange short s short s long s long s
|
|
void n3f float s[3]
|
|
void noborder
|
|
void pntsmooth long s
|
|
void readsource long s
|
|
void rectzoom float s float s
|
|
void sbox float s float s float s float s
|
|
void sboxi long s long s long s long s
|
|
void sboxs short s short s short s short s
|
|
void sboxf float s float s float s float s
|
|
void sboxfi long s long s long s long s
|
|
void sboxfs short s short s short s short s
|
|
void setnurbsproperty long s float s
|
|
void setpup long s long s long s
|
|
void smoothline long s
|
|
void subpixel long s
|
|
void swaptmesh
|
|
long swinopen long s
|
|
void v2f float s[2]
|
|
void v2i long s[2]
|
|
void v2s short s[2]
|
|
void v3f float s[3]
|
|
void v3i long s[3]
|
|
void v3s short s[3]
|
|
void v4f float s[4]
|
|
void v4i long s[4]
|
|
void v4s short s[4]
|
|
void videocmd long s
|
|
long windepth long s
|
|
void wmpack long s
|
|
void zdraw long s
|
|
void zfunction long s
|
|
void zsource long s
|
|
void zwritemask long s
|
|
#
|
|
# uses doubles
|
|
#
|
|
void v2d double s[2]
|
|
void v3d double s[3]
|
|
void v4d double s[4]
|
|
#
|
|
# Why isn't this here?
|
|
#
|
|
void pixmode long s long s
|
|
#
|
|
# New in IRIX 4.0
|
|
#
|
|
long qgetfd
|
|
void dither long s
|