"

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

'!

!GLXWorkstation class methodsFor:'documentation'!

copyright

"

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.

"

!

version

"

"

!

documentation

"

    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 (i.e. GL-light; low nicotine).

    The GL simulation is derived from the PD vogl library, with slight

    modifictions to support multiple GL views.

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

    Some notes:

    I do not really 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 duplicated, Jeff and I developed those in parallel -

    Also, in a hurry to implement all those methods, many do no or only

    limited argument checking - make certain, that you pass the correct

    arguments.

    There might be some confusion in the v3[sifd] functions: basically they

    all do the same, and could be mapped onto one st-method (such as vertex3).

    However, the C-functions expect different argument types - I dont know if

    one or another of these functions suffers from any performance penalties.

    Therefore, I leave the direct 1-to-1 mapping; GL experts might know more

    about this (I use v3f in all of my code).

    written june 93 by claus

    VGL stuff dec 93

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

    Since this is a demo (consider it a free add-on goody) there is 

    *** NO WARRANTY ** for this.

    Notice: this should be rewritten to use the openGL library functions

"

! !

%{

/*

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

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

 */

/*

 * define this to enable:

 *    blendcolor getgconfig getmultisample leftbuffer rightbuffer monobuffer

 *    msalpha msmask mspattern mssize multisample stereobuffer

 *    t3s t3i t3f t3d t4s t4i t4f t4d tlutbind zbsize

 *

 * these are not available on all gl's

 */

/* #define FULL_GLX */

/*

 * 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

# undef memset

# include <vogl.h>

# include <X11/Xlib.h>

#endif

#ifndef NULL

# define NULL (char *)0         /* sigh */

#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.

 *

 */

#if defined(hpux) && defined(POSITIVE_ADDRESSES)

# define MKDPY(o)       (Display *)((int)(o) & ~TAG_INT)

#else

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

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

#endif

#define myDpy MKDPY(_INST(displayId))

#define SETWIN(aGLXWindowId)                             \

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

	if (! _isSmallInteger(aGLXWindowId)) {           \

	    RETURN (false);                              \

	}                                                \

	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)                            \

    ((__isFloat(c)) ? (Coord)(_floatVal(c))      \

		   : (Coord)(_intVal(c)))

#define _COORD_(arg, dst)               \

    if (__isFloat(arg))                  \

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

    else if (_isSmallInteger(arg))      \

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

    else if (__isFraction(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)               \

    if (__isFloat(arg))                  \

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

    else if (_isSmallInteger(arg))      \

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

    else if (__isFraction(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()

 */

static OBJ

doRotate(angle, axis)

    OBJ angle;

    char axis;

{

    Angle a_angle;

    float f_angle;

    if (__isFloat(angle)) {

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

	if (f_angle != 0.0)

	    rot(f_angle, axis);

	return (true);

    }

    if (__isFraction(angle)

     && _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;

	if (f_angle != 0.0)

	    rot(f_angle, axis);

	return (true);

    }

    if (_isSmallInteger(angle)) {

	f_angle = (float)(_intVal(angle));

	if (f_angle != 0.0)

	    rot(f_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;

	    if (__isFloat(o)) {

		vec[i] = _floatVal(o);

	    } else if (_isSmallInteger(o)) {

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

	    } else if (__isFraction(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;