"

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 is stupid, GLX defines String, which is also defined here ...

 */

# include <gl/glws.h>

# include <gl/sphere.h>

typedef enum {

    GLXcolorIndexSingleBuffer,

    GLXcolorIndexDoubleBuffer,

    GLXrgbSingleBuffer,

    GLXrgbDoubleBuffer

} GLXWindowType;

extern Window GLXCreateWindow(Display*,Window,int,int,int,int,int,GLXWindowType);

#undef String

/*

 * some defines - tired of typing ...

 */

#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;              \

    }

#define _COORD_(arg, dst)               \

    if (_isFloat(arg))                  \

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

    else if (_isSmallInteger(arg))      \

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

    else break;

#define _FLOAT_(arg, dst)               \

    if (_isFloat(arg))                  \

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

    else if (_isSmallInteger(arg))      \

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

#define _ANGLE_(arg, dst)               \

    if (_isSmallInteger(arg))           \

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

    else break;

#define _INT_(arg, dst)                 \

    if (_isSmallInteger(arg))           \

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

    else break;

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:

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

        return (float *)pElem;

      case DOUBLEARRAY:

        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:

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

        /* get elements one-by-one */

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

            o = *(OBJ *)pElem;

            pElem += sizeof(OBJ);

        }

        return vec;

    }

    return (float *)0;

}

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;

    OBJ o;

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

    cls = _qClass(obj);

    nByte = _qSize(obj) - OHDR_SIZE;

    if (cls == FloatArray) {

        int x = 0;

        int i,j;

        if (nByte < (16 * sizeof(float))) return (Matrix *)0;

        return (Matrix *) _FloatArrayInstPtr(obj)->f_element;

    }

    if (cls == DoubleArray) {

        int x = 0;

        int i,j;

        if (nByte < (16 * sizeof(double))) return (Matrix *)0;

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

            for (j=0; j<4; j++) {

                (*mp)[i][j] = _DoubleArrayInstPtr(obj)->d_element[x];

                x++;

            }

        }

        return mp;

    }

    if (cls == Array) {

        int x = 0;

        int i,j;

        if (nByte < (16 * sizeof(OBJ))) return (Matrix *)0;

        /* get elements one-by-one */

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

            for (j=0; j<4; j++) {

                o = _ArrayInstPtr(obj)->a_element[x];

                x++;

            }

        }

        return mp;

    }

    return (Matrix *)0;

}

%}

!GLXWorkstation methodsFor:'window creation'!

createGLXWindowFor:aView left:xpos top:ypos width:wwidth height:wheight type:glxType

    |ext minWidth minHeight maxWidth maxHeight 

     bWidth bColor viewBg viewBgId wsuperView wsuperViewId wcreateOnTop 

     winputOnly wlabel wcursor wcursorId wicon wiconId windowId

     weventMask wiconView wiconViewId bitGravity viewGravity vBgColor

     vBgForm deepForm|

    "{ Symbol: colorIndexSingleBuffer }"

    "{ Symbol: colorIndexDoubleBuffer }"

    "{ Symbol: rgbSingleBuffer }"

    "{ Symbol: rgbDoubleBuffer }"

    wsuperView := aView superView.

    wsuperView notNil ifTrue:[

        wsuperViewId := wsuperView id

    ].

%{

    Display *dpy = myDpy;

    int screen = _intVal(_INST(screen));

    Window newWindow, parentWindow;

    extern Window GLXCreateWindow();

    int t;

    if (_isSmallInteger(xpos) && _isSmallInteger(ypos)

     && _isSmallInteger(wwidth) && _isSmallInteger(wheight)) {

        if (_isSmallInteger(wsuperViewId)) {

            parentWindow = MKWIN(wsuperViewId);

        } else {

            parentWindow = RootWindow(dpy, screen);

        }

        if (glxType == _colorIndexSingleBuffer)

            t = GLXcolorIndexSingleBuffer;

        else if (glxType == _colorIndexDoubleBuffer)

            t = GLXcolorIndexDoubleBuffer;

        else if (glxType == _rgbSingleBuffer)

            t = GLXrgbSingleBuffer;

        else if (glxType == _rgbDoubleBuffer)

            t = GLXrgbDoubleBuffer;

        else {

            RETURN ( nil );

        }

        newWindow = GLXCreateWindow(dpy, parentWindow,

                                    _intVal(xpos), _intVal(ypos),

                                    _intVal(wwidth), _intVal(wheight),

                                    0, t);

        if (! newWindow) {

            RETURN ( nil );

        }

        windowId = MKOBJ(newWindow);

    }

%}

.

    windowId notNil ifTrue:[

        self addKnownView:aView withId:windowId.

    ].

    ^ windowId

!

unlinkGLXView:aGLXWindowId

    "remove X/GLX link"

%{

    if (_isSmallInteger(aGLXWindowId))

        GLXUnlinkWindow(myDpy, MKWIN(aGLXWindowId));

%}

! !

!GLXWorkstation methodsFor:'glx access'!

    "define perspective projection"

%{  /* NOCONTEXT */

    Angle a_fovy;

    Coord c_near, c_far;

    float f_aspect;

    do {

        _ANGLE_ (fovy, a_fovy);

        _FLOAT_ (aspect, f_aspect);

        _COORD_ (near, c_near);

        _COORD_ (far, c_far);

        SETWIN(aGLXWindowId)

        perspective(a_fovy, f_aspect, c_near, c_far);

        RETURN (true);

    } while(0);

%}

.

    ^ false

!

glxTranslateX:x y:y z:z in:aGLXWindowId

    "translate current matrix"

%{  /* NOCONTEXT */

    Coord c_x, c_y, c_z;

    do {

        _COORD_ (x, c_x);

        _COORD_ (y, c_y);

        _COORD_ (z, c_z);

        SETWIN(aGLXWindowId)

        translate(c_x, c_y, c_z);

        RETURN (true);

    } while(0);

%}

.

    ^ false

!

glxScaleX:x y:y z:z in:aGLXWindowId

    "scale & mirror current matrix"

%{  /* NOCONTEXT */

    float f_x, f_y, f_z;

    do {

        _FLOAT_ (x, f_x);