"

COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

XWorkstation subclass:#GLXWorkstation

       instanceVariableNames:'activeWindow'

       classVariableNames:   ''

       poolDictionaries:''

       category:'Interface-Graphics'

!

GLXWorkstation comment:'

COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

this class was originally written as a demo on how an interface to 

a c graphics library could be implemented. In the mean time, it has become

quite complete ...

It provides an interface to either a real GL (on SGI workstations)

or a simulated VGL (GL-light; low nicotine).

Most of the hard work was done by Jeff (thanks indeed) ...

I do really not know what most of these functions do - for more

detail, see the GL man pages (on SGI) or the doc provided with VGL.

The interface offered here provides a very very low level (i.e one-to-one)

interface to GL functions. More high-level stuff is required, to make

3D drawing be more object-oriented. (see a bit of this in clients/IRIS-specials)

Some functions are dublicated, Jeff and I developed those in parallel - 

one of them will vanish - that is certain ...

written june 93 by claus

VGL stuff dec 93

many many additions jan 94 by Jeff McAffer <jeff@is.s.u-tokyo.ac.jp>

'!

%{

/*

 * on SGI, this class is compiled with -DGLX, while

 * for simulation (using vogl), this is compiled with -DVGL

 */

/*

 * this is stupid, GLX defines String, which is also defined here ...

 */

# define String GLX_String

#ifdef GLX

# include <gl/glws.h>

# include <gl/sphere.h>

#else

# include <vogl.h>

# include <X11/Xlib.h>

#endif

typedef enum {

    GLXcolorIndexSingleBuffer,

    GLXcolorIndexDoubleBuffer,

    GLXrgbSingleBuffer,

    GLXrgbDoubleBuffer

} GLXWindowType;

extern Window GLXCreateWindow();

#undef String

/*

 * some defines - tired of typing ...

 * most of these macros/functions extract values from smalltalk objects and

 * put/pack them into corresponding c variables.

 *

 */

#define MKDPY(o)       (Display *)(_intVal(o))

#define MKWIN(o)       (Window)(_intVal(o))

#define MKGC(o)        (GC)(_intVal(o))

#define MKCURS(o)      (Cursor)(_intVal(o))

#define MKFONT(o)      (XFontStruct *)(_intVal(o))

#define MKDPSContext(o)      (DPSContext)(_intVal(o))

#define myDpy MKDPY(_INST(displayId))

#define SETWIN(aGLXWindowId)                             \

    if (_INST(activeWindow) != aGLXWindowId) {           \

        if (GLXwinset(myDpy, MKWIN(aGLXWindowId)) < 0) { \

            RETURN (false);                              \

        }                                                \

        _INST(activeWindow) = aGLXWindowId;              \

    }

/*

 * check for and fetch a boolean from ST-arg into C-dst

 * ST-object must be true or false

 */

#define _MKBOOLEAN(b)   ((b==FALSE) ? false : true)

#define _booleanVal(b)  ((b==false) ? (Boolean)FALSE : (Boolean)TRUE)

#define _BOOLEAN_(arg, dst)             \

    if (arg==true)                      \

        dst = (Boolean)TRUE;            \

    else if (arg==false)                \

        dst = (Boolean)FALSE;           \

    else { RETURN(false); }

/*

 * check for and fetch a coord from ST-arg into C-dst

 * ST-object must be Float, SmallInteger or Fraction

 */

#define _coordVal(c)                            \

                   : (Coord)(_intVal(c)))

#define _COORD_(arg, dst)               \

        dst = (Coord)(_floatVal(arg));  \

    else if (_isSmallInteger(arg))      \

        dst = (Coord)(_intVal(arg));    \

          && _isSmallInteger(_FractionInstPtr(arg)->f_numerator)        \

          && _isSmallInteger(_FractionInstPtr(arg)->f_denominator)) {   \

        float n, d;                                                     \

                                                                        \

        n = (float)(_intVal(_FractionInstPtr(arg)->f_numerator));       \

        d = (float)(_intVal(_FractionInstPtr(arg)->f_denominator));     \

        dst = (Coord)(n / d);                                           \

    } else { RETURN(false); }

/*

 * check for and fetch an icoord from ST-arg into C-dst

 * ST-object must be SmallInteger 

 */

#define _icoordVal(c) ((Icoord)(_intVal(c)))

#define _ICOORD_(arg, dst)              \

    if (_isSmallInteger(arg))           \

      dst = (Icoord)(_intVal(arg));     \

    else { RETURN(false); }

/*

 * check for and fetch an icoord from ST-arg into C-dst

 * ST-object must be SmallInteger 

 */

#define _scoordVal(c) ((Scoord)(_intVal(c)))

#define _SCOORD_(arg, dst)              \

    if (_isSmallInteger(arg))           \

      dst = (Scoord)(_intVal(arg));     \

    else { RETURN(false); }

#define _screencoordVal(c) ((Screencoord)(_intVal(c)))

#define _SCREENCOORD_(arg, dst)          \

    if (_isSmallInteger(arg))            \

      dst = (Screencoord)(_intVal(arg)); \

    else { RETURN(false); }

#define _colorindexVal(c) ((Colorindex)(_intVal(c)))

#define _COLORINDEX_(arg, dst)           \

    if (_isSmallInteger(arg))            \

      dst = (Colorindex)(_intVal(arg));  \

    else { RETURN(false); }

#define _linestyleVal(l) ((Linestyle)(_intVal(l)))

#define _shortVal(l) ((short)(_intVal(l)))

#define _longVal(l) ((long)(_intVal(l)))

#define _deviceVal(l) ((Device)(_intVal(l)))

#define _tagVal(l) ((Tag)(_intVal(l)))

#define _objectVal(l) ((Object)(_intVal(l)))

#define _offsetVal(l) ((Offset)(_intVal(l)))

#define _rgbVal(l) ((RGBvalue)(_intVal(l)))

#define _angleVal(c) ((Angle)(_intVal(c)))

#define _ANGLE_(arg, dst)               \

    if (_isSmallInteger(arg))           \

        dst = (Angle)(_intVal(arg));    \

    else { RETURN(false); }

#define _FLOAT_(arg, dst)               \

        dst = (float)(_floatVal(arg));  \

    else if (_isSmallInteger(arg))      \

        dst = (float)(_intVal(arg));    \

          && _isSmallInteger(_FractionInstPtr(arg)->f_numerator)        \

          && _isSmallInteger(_FractionInstPtr(arg)->f_denominator)) {   \

        float n, d;                                                     \

                                                                        \

        n = (float)(_intVal(_FractionInstPtr(arg)->f_numerator));       \

        d = (float)(_intVal(_FractionInstPtr(arg)->f_denominator));     \

        dst = (float)(n / d);                                           \

    } else { RETURN(false); }

#define _INT_(arg, dst)                 \

    if (_isSmallInteger(arg))           \

        dst = (int)(_intVal(arg));      \

    else { RETURN(false); }

#define _indexedArea(object)            \

    (((char *) (_InstPtr(object)))      \

        + OHDR_SIZE                     \

        + (_intVal(_ClassInstPtr(_qClass(object))->c_ninstvars)) * sizeof(OBJ))

/*

 * helper for rotation - call rot() for floats or fractions; rotate for integers

 */

static OBJ

doRotate(angle, axis)

    OBJ angle;

    char axis;

{

    Angle a_angle;

    float f_angle;

        f_angle = (float)(_floatVal(angle));

        rot(f_angle, axis);

        return (true);

    }

     && _isSmallInteger(_FractionInstPtr(angle)->f_numerator)

     && _isSmallInteger(_FractionInstPtr(angle)->f_denominator)) {

        float n, d;

        n = (float)(_intVal(_FractionInstPtr(angle)->f_numerator));

        d = (float)(_intVal(_FractionInstPtr(angle)->f_denominator));

        f_angle = n / d;

        rot(f_angle, axis);

        return (true);

    }

    if (_isSmallInteger(angle)) {

        a_angle = (Angle)(_intVal(angle));

        rotate(a_angle, axis);

        return (true);

    }

    return false;

}

/*

 * fetch integers from an st-array (elements must be smallIntegers)

 */

static long *

getLongsFromInto(obj, vec, count)

   OBJ obj;

   long *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (long *)NULL;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    if (nByte < (count * sizeof(OBJ))) return (long *)NULL;

    for (i=0; i<count; i++) {

        o = *(OBJ *)pElem;

        if (! _isSmallInteger(o)) return (long *)NULL;

        vec[i] = (long)_intVal(o);

        pElem += sizeof(OBJ);

    }

    return vec;

}

/*

 * fetch shorts from an st-array (elements must be smallIntegers)

 */

static short *

getShortsFromInto(obj, vec, count)

   OBJ obj;

   short *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (short *)NULL;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    if (nByte < (count * sizeof(OBJ))) return (short *)NULL;

    for (i=0; i<count; i++) {

        o = *(OBJ *)pElem;

        if (! _isSmallInteger(o)) return (short *)NULL;

        vec[i] = (short)_intVal(o);

        pElem += sizeof(OBJ);

    }

    return vec;

}

/*

 * fetch floats from an st-object into a c-float array 

 * which may be a floatArray, doubleArray or array-of-something,

 * where something may be a float, fraction or smallInteger,

 */

static float *

getFloatsFromInto(obj, vec, count)

   OBJ obj;

   float *vec;

{

    OBJ cls;

    int nByte;

    OBJ o;

    int i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (float *)0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case FLOATARRAY:

        /*

         * best speed for float array

         * - the data is already as we want it

         */

        if (nByte < (count * sizeof(float))) return (float *)0;

        return (float *)pElem;

      case DOUBLEARRAY:

        /*

         * for double array, have to copy-and-cast

         */

        if (nByte < (count * sizeof(double))) return (float *)0;

        for (i=0; i<count; i++) {

            vec[i] = *((double *)pElem);

            pElem += sizeof(double);

        }

        return vec;

      case POINTERARRAY:

        /*

         * for other array, have to fetch, check and store

         * the elements can be floats, smallintegers or fractions

         */

        if (nByte < (count * sizeof(OBJ))) return (float *)0;

        /* get elements one-by-one */

        for (i=0; i<count; i++) {

            o = *(OBJ *)pElem;

                vec[i] = _floatVal(o);

            } else if (_isSmallInteger(o)) {

                vec[i] = (float)(_intVal(o));

                    && _isSmallInteger(_FractionInstPtr(o)->f_numerator)

                    && _isSmallInteger(_FractionInstPtr(o)->f_denominator)) {

                float n, d;

                n = (float)(_intVal(_FractionInstPtr(o)->f_numerator));

                d = (float)(_intVal(_FractionInstPtr(o)->f_denominator));

                vec[i] = n / d;

            } else

                return 0;

            pElem += sizeof(OBJ);

        }

        return vec;

    }

    return (float *)0;

}

/*

 * fetch doubles from an st-object into a c-double array 

 * which may be a floatArray, doubleArray or array-of-something,

 * where something may be a float, fraction or smallInteger,

 */

static double *

getDoublesFromInto(obj, vec, count)

   OBJ obj;

   double *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (double *)0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case DOUBLEARRAY:

        /* best speed for double array - the data is already as we want it */

        if (nByte < (count * sizeof(double))) return (double *)0;

        return (double *)pElem;

      case FLOATARRAY:

        if (nByte < (count * sizeof(float))) return (double *)0;

        for (i=0; i<count; i++) {

            vec[i] = *((float *)pElem);

            pElem += sizeof(float);

        }

        return vec;

      case POINTERARRAY:

        if (nByte < (count * sizeof(OBJ))) return (double *)0;

        /* get elements one-by-one */

        for (i=0; i<count; i++) {

            o = *(OBJ *)pElem;

                vec[i] = _floatVal(o);

            else if (_isSmallInteger(o)) 

                vec[i] = (double)(_intVal(o));

                     && _isSmallInteger(_FractionInstPtr(o)->f_numerator)

                     && _isSmallInteger(_FractionInstPtr(o)->f_denominator)) {

                double n, d;

                n = (double)(_intVal(_FractionInstPtr(o)->f_numerator));

                d = (double)(_intVal(_FractionInstPtr(o)->f_denominator));

                vec[i] = n / d;

            } else 

                return 0;

            pElem += sizeof(OBJ);

        }

        return vec;

    }

    return (double *)0;

}

/*

 * move from a c-float array into an st-object,

 * the st-object MUST be either a float- or double array

 */

static

putFloatsFromInto(vec, obj, count)

   OBJ obj;

   float *vec;

{

    OBJ cls;

    int nByte;

    OBJ o;

    int i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return 0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case FLOATARRAY:

        if (nByte < (count * sizeof(float))) return 0;

        for (i=0; i<count; i++) {

            *(float *)pElem = vec[i];

            pElem += sizeof(float);

        }

        return 1;

      case DOUBLEARRAY:

        if (nByte < (count * sizeof(float))) return 0;

        for (i=0; i<count; i++) {

            *(double *)pElem = vec[i];

            pElem += sizeof(double);

        }

        return 1;

    }

    /* not implemented for others */

    return 0;

}

static Matrix*

getFloatsFromMatrixInto(obj, mp)

    OBJ obj;

    Matrix *mp;

{

    OBJ cls;

    extern OBJ FloatArray, DoubleArray, Array;

    int nByte;