"

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 hasStereoExtension glOK'

       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 -

    for now, both will remain - finally they will be merged and duplicates removed ...

    (examples are makeobj and makeObject).

    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

    (actually, to not loose the VGL interface, another OpenGLWorkstation

     class should be written)

"

! !

!GLXWorkstation primitiveDefinitions!

%{

/*

 * 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

#include <stdio.h>

#ifdef GLX

# include <gl/glws.h>

# include <gl/sphere.h>

#else

# undef memset

# include <vogl.h>

# undef move

# include <X11/Xlib.h>

#endif

/*

 * XSGIStereo extension - if available

 */

#ifdef XSGIStereo

# include <X11/extensions/SGIStereo.h>

#endif

#ifndef NULL

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

#endif

typedef enum {

    GLXcolorIndexSingleBuffer,

    GLXcolorIndexDoubleBuffer,

    GLXrgbSingleBuffer,

    GLXrgbDoubleBuffer

} GLXWindowType;

/*

extern Window GLXCreateWindow();

*/

#ifdef THISCONTEXT_IN_REGISTER

  extern OBJ __thisContext__;

# define ENTERGLX       __thisContext__ = __thisContext

# define LEAVEGLX       __thisContext = __thisContext__; __thisContext__ = 0;

#else

# define ENTERGLX    /* nothing */

# define LEAVEGLX     /* nothing */

#endif

#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 myDpy           (Display *)(__MKCP(_INST(displayId)))

#define ISCONNECTED     (_INST(displayId) != nil)

#define _WindowVal(o)   (Window)(__MKCP(o))

/*

 * set the GLXWindow for followup drawing

 */

#define SETWIN(aGLXWindowId)                            \

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

	if (! ISCONNECTED ) {                           \

	    RETURN (false);                             \

	}                                               \

	if (! __isExternalAddress(aGLXWindowId)) {      \

	    RETURN (false);                             \

	}                                               \

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

	    RETURN (false);                             \

	}                                               \

	_INST(activeWindow) = aGLXWindowId;		\

	__STORE(self, aGLXWindowId);              	\

    } else {						\

	if (aGLXWindowId == nil) {			\

	    RETURN (false);				\

	}						\

    }

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

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

#define _coordVal(c)                             \

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

		    : (Coord)(__intVal(c)))

#define _icoordVal(c)      ((Icoord)(__intVal(c)))

#define _scoordVal(c)      ((Scoord)(__intVal(c)))

#define _screencoordVal(c) ((Screencoord)(__intVal(c)))

#define _colorindexVal(c)  ((Colorindex)(__intVal(c)))

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

/*

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

 * ST-object must be true or false. Return wth false if invalid.

 */

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

 * Return wth false if invalid.

 */

#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. Return wth false if invalid. 

 */

#define _ICOORD_(arg, dst)              \

    if (__isSmallInteger(arg))          \

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

    else { RETURN(false); }

/*

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

 * ST-object must be SmallInteger. Return wth false if invalid. 

 */

#define _SCOORD_(arg, dst)              \

    if (__isSmallInteger(arg))          \

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

    else { RETURN(false); }

#define _SCREENCOORD_(arg, dst)          \

    if (__isSmallInteger(arg))           \

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

    else { RETURN(false); }

#define _COLORINDEX_(arg, dst)           \

    if (__isSmallInteger(arg))           \

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

    else { RETURN(false); }

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

%}

! !

!GLXWorkstation primitiveVariables!

%{

/*

 * remembered info from private error handler

 */

static char lastErrorMsg[80] = "";

static unsigned lastRequestCode = 0;

static unsigned lastMinorCode = 0;

static unsigned lastResource = 0;

%}

! !

!GLXWorkstation primitiveFunctions!

%{

/*

 * catch X-errors and forward as errorInterrupt:#DisplayError,

 * (which itself invokes my handler and optionally raises an exceptionSignal)

 * the implementation below is somewhat wrong: it will

 * report all errors for Display, even though there could be

 * more than one display connection. (being fixed, new errorInterrupt mechanism

 * allows passing an additional argument, which is the displayID ...)

 *

 * this dublicates the functionality as found in XWorkstation;

 * the reason is to allow dynamic loading systems to load this module

 * before XWorkstation (which was not possible otherwise, due to unresolved

 * external references while loading this one)

 */

static

__XErrorHandler__(dpy, event)

    Display *dpy;

    XErrorEvent *event;

{

    XGetErrorText(dpy, event->error_code, lastErrorMsg, 80);

    if (lastErrorMsg[0] == '\0') {

	sprintf(lastErrorMsg, "code: %d", event->error_code);

    }

    lastRequestCode = event->request_code;

    lastMinorCode = event->minor_code;

    lastResource = event->resourceid;

    fprintf(stderr, "XWORKSTAT: x-error cought maj=%d (0x%x) min=%d (0x%x) resource=%x\n",

		    event->request_code, event->request_code,

		    event->minor_code, event->minor_code, event->resourceid);

    fprintf(stderr, "XWORKSTAT: x-error message is '%s'\n", lastErrorMsg);

    __errorInterruptWithIDAndParameter__(@symbol(DisplayError), __MKOBJ(dpy));

    return 0;

}

/* 

 * begin moved from GLXsupport.c

 */

/*

 * GLXsupport.c:

 *

 *   This file provides a helper function "GLXCreateWindow", which does

 * all the necessary magic to create an X window suitable for GL drawing 

 * to take place within.   see the definition of GLXCreateWindow for a 

 * description of how to call it.

 *

 * claus: I really had no time to look into all this,

 * this file has been just copied from a 4Dgifts demo ..

 * (will need more than a day to show more ...)

 */

#if defined(GLX) || defined(VGL)

#include        <X11/Xlib.h>

#include        <X11/Xutil.h>

#ifndef VGL

# include        <gl/glws.h>  

#endif

#include        <signal.h>

#include        <setjmp.h>

#include        "stcIntern.h"

/*

 * glxhelper.h:

 *

 *   List of drawing modes supported by GLXCreateWindow (in glxhelper.c).

 * More than this are possible with mixed model, but this is just an 

 * example.  You can either expand this list (and the corresponding code in 

 * GLXCreateWindow) or call the mixed model calls yourself, using 

 * GLXCreateWindow as an example.

 */

static char *typeToName[] = {

    "color index single buffer",

    "color index double buffer",

    "rgb single buffer",

    "rgb double buffer",

};

#ifndef VGL

/*

 * Dorky little helper function used to build up a GLXconfig array.

 */

static void set_entry (GLXconfig* ptr, int b, int m, int a)

{

    ptr->buffer = b;

    ptr->mode = m;

    ptr->arg = a;

}

#endif /* VGL */

static JMP_BUF errorReturn;

static void

glAbort() {

    longjmp(errorReturn, 1);

}

/*

 * GLXCreateWindow(dpy, parent, x, y, w, h, boderWidth, type)

 *

 * Return value is the X window id of the newly created window.

 *

 * Arguments are:

 *      dpy             The X "Display*" returned by XOpenDisplay

 *      parent          The parent of the newly created window,

 *                      a typical value for this is

 *                      RootWindow(dpy, DefaultScreen(dpy))

 *      x,y             The location of the window to be created,

 *                      y coordinate is measured from the top down.

 *      w,h             size of the new window

 *      borderWidth     the X border size for this window, should probably

 *                      be zero.

 *      type            the GLXWindowType (see glxhelper.h) desribing the

 *                      typer of GL drawing to be done in this window

 */

static Window 

GLXCreateWindow(dpy, parent, x, y, w, h, borderWidth, type)

    Display* dpy;

    Window parent;

    GLXWindowType type;

{

#ifdef VGL

    Visual visual;

#else

    GLXconfig params[50];

    GLXconfig* next;

    GLXconfig* retconfig;

    Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));

    XVisualInfo *vis;

#endif

    XVisualInfo template;

    XColor white;

    XSetWindowAttributes cwa;

    XWindowAttributes   pwa;

    int scr, i, nret;

    Window win;

#ifdef IRIX5

    SIG_PF oldSig;

#else

    void *oldSig;

#endif

    if (setjmp(errorReturn)) {

	printf("hard error in GL - return\n");

	signal(SIGSEGV, oldSig);

	return 0;

    }

    __CONT__

#ifdef VGL

    /*

     * I know what VGL supports; its somewhat unclean to hard code it here

     */

    switch (type) {

      case GLXcolorIndexSingleBuffer:

      case GLXcolorIndexDoubleBuffer:

	break;

      case GLXrgbSingleBuffer: