home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / demos / OpenGL / space / events.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-11  |  22.6 KB  |  840 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. #include "space.h"
  18.  
  19. static uint16 cursor[16] = {
  20.           0x0100, 0x0100, 0x0100, 0x0100,
  21.           0x0100, 0x0100, 0x0100, 0xFFFE,
  22.           0x0100, 0x0100, 0x0100, 0x0100,
  23.           0x0100, 0x0100, 0x0100, 0x0000
  24. } ;
  25.  
  26. #ifdef SP_OPEN_GL
  27. static Bool WaitForNotify(Display *d, XEvent *e, char *arg)
  28.    { return (e->type == MapNotify) && (e->xmap.window == (Window)arg); }
  29. #endif
  30.  
  31. extern t_stopwatch Counter ;
  32.  
  33. /**********************************************************************
  34. *  spOpenWindow()                                                
  35. **********************************************************************/
  36. uint32 spOpenWindow(void)
  37.  
  38. {
  39. #ifdef SP_IRIS_GL
  40.    if (getgdesc(GD_BITS_NORM_DBL_RED) <= 0)  {
  41.      fprintf(stderr,"Need doublebuffer RGB mode for this demo!\n") ;
  42.      exit(0) ;
  43.      }
  44.  
  45.    if (Counter.flags & FLSCR_FLAG)
  46.      prefposition(0,getgdesc(GD_XPMAX)-1,0,getgdesc(GD_YPMAX)-1) ;
  47.  
  48.    noborder() ;
  49.    foreground() ;
  50.    Counter.winst.wid = winopen("Space");
  51.  
  52.    Counter.rotsizex = getgdesc(GD_XPMAX); 
  53.    Counter.rotsizey = getgdesc(GD_YPMAX);
  54.  
  55.    RGBmode() ;
  56.    doublebuffer() ;
  57.    if (getgdesc(GD_MULTISAMPLE))  {
  58.      mssize(8,32,0);
  59.      zbsize(0);
  60.      gconfig() ;
  61.  
  62.      if (getgconfig(GC_BITS_MS_ZBUFFER) == 0 || getgconfig(GC_MS_SAMPLES) < 4) {
  63.        mssize(0,0,0);
  64.        zbsize(32);
  65.        gconfig() ;
  66.        }
  67.      }
  68.    else gconfig() ;
  69.  
  70.    return(1);
  71. #endif
  72.  
  73. #ifdef SP_OPEN_GL
  74.    Colormap cmap;
  75.    XSetWindowAttributes swa;
  76.    XEvent event;
  77.    uint32 x1,y1,x2,y2;
  78.    int arr[8];
  79.  
  80.    /* get display */
  81.    if (!(Counter.winst.dpy = XOpenDisplay(0))) {
  82.      fprintf(stderr,"ERROR: XOpenDisplay() failed.\n");
  83.      return(0);
  84.      }
  85.  
  86.    /* get screen number */
  87.    Counter.winst.snu = DefaultScreen(Counter.winst.dpy);
  88.  
  89.    /* screen size */
  90.    Counter.rotsizex = DisplayWidth(Counter.winst.dpy,Counter.winst.snu);
  91.    Counter.rotsizey = DisplayHeight(Counter.winst.dpy,Counter.winst.snu);
  92.  
  93.    /* get visual */
  94.    arr[0] = GLX_RGBA;
  95.    arr[1] = GLX_DEPTH_SIZE;
  96.    arr[2] = 24;
  97.    arr[3] = GLX_DOUBLEBUFFER;
  98.    arr[4] = None;
  99.    if (!(Counter.winst.vis = glXChooseVisual(Counter.winst.dpy,Counter.winst.snu,arr)))  {
  100.      fprintf(stderr,"ERROR: glXChooseVisual() failed.\n");
  101.      return(0);
  102.      }
  103.  
  104.    /* get context */
  105.    if (!(Counter.winst.ctx = glXCreateContext(Counter.winst.dpy,Counter.winst.vis,0,GL_TRUE))) {
  106.      fprintf(stderr,"ERROR: glXCreateContext() failed.\n");
  107.      return(0);
  108.      }
  109.  
  110.    /* root window */
  111.    Counter.winst.rwi = RootWindow(Counter.winst.dpy,Counter.winst.vis->screen);
  112.  
  113.    /* get RGBA colormap */
  114.    if (!(cmap = XCreateColormap(Counter.winst.dpy,Counter.winst.rwi,Counter.winst.vis->visual,AllocNone))) {
  115.      fprintf(stderr,"ERROR: glXCreateColorMap() failed.\n");
  116.      return(0);
  117.      }
  118.  
  119.    if (Counter.flags & FLSCR_FLAG) {
  120.      x1 = 0;
  121.      y1 = 0;
  122.      x2 = Counter.rotsizex;
  123.      y2 = Counter.rotsizey;
  124.      }
  125.    else {
  126.      x1 = 100;
  127.      y1 = 100;
  128.      x2 = 512;
  129.      y2 = 512;
  130.      }
  131.  
  132.    /* get window */
  133.    swa.colormap = cmap;
  134.    swa.border_pixel = 0;
  135.    swa.event_mask = StructureNotifyMask;
  136.    if (!(Counter.winst.win = XCreateWindow(Counter.winst.dpy,Counter.winst.rwi,x1,y1,x2,y2,0,Counter.winst.vis->depth,
  137.            InputOutput,Counter.winst.vis->visual,CWBorderPixel|CWColormap|CWEventMask,&swa))) {
  138.      fprintf(stderr,"ERROR: XCreateWindow() failed.\n");
  139.      return(0);
  140.      }
  141.  
  142.    if (Counter.flags & FLSCR_FLAG) {
  143.      XSizeHints sh;
  144.  
  145.      sh.flags = USPosition;
  146.      sh.x = x1;
  147.      sh.y = y1;
  148.      XSetStandardProperties(Counter.winst.dpy,Counter.winst.win,"", "", None, 0, 0, &sh);
  149.      }
  150.  
  151.    {  /* noborder */
  152.       struct { long flags,functions,decorations,input_mode; } hints;
  153.       int     fmt;
  154.       uint32  nitems,byaf;
  155.       Atom    type,mwmhints = XInternAtom(Counter.winst.dpy,"_MOTIF_WM_HINTS",False);
  156.    
  157.       XGetWindowProperty(Counter.winst.dpy,Counter.winst.win,mwmhints,0,4,False,
  158.                                 mwmhints,&type,&fmt,&nitems,&byaf,(char**)&hints);
  159.    
  160.       hints.decorations = 0;
  161.       hints.flags |= 2;
  162.    
  163.       XChangeProperty(Counter.winst.dpy,Counter.winst.win,mwmhints,mwmhints,32,PropModeReplace,(uchar8 *)&hints,4);
  164.       XFlush(Counter.winst.dpy);
  165.    }
  166.  
  167.    XStoreName(Counter.winst.dpy,Counter.winst.win, "space");
  168.    XMapWindow(Counter.winst.dpy,Counter.winst.win);
  169.    XFlush(Counter.winst.dpy);
  170.  
  171.    XIfEvent(Counter.winst.dpy,&event,WaitForNotify,(char*)Counter.winst.win);
  172.  
  173.    glXMakeCurrent(Counter.winst.dpy,Counter.winst.win,Counter.winst.ctx);
  174.    return(1);
  175. #endif
  176. }
  177.  
  178. /**********************************************************************
  179. *  spGetWindowGeometry()                                                
  180. **********************************************************************/
  181. void spGetWindowGeometry(void)
  182.  
  183. {
  184. #ifdef SP_IRIS_GL
  185.    getsize(&Counter.winsizex,&Counter.winsizey);
  186.    getorigin(&Counter.winorigx,&Counter.winorigy);
  187. #endif
  188.  
  189. #ifdef SP_OPEN_GL
  190.    XWindowAttributes wa;
  191.  
  192.    XGetWindowAttributes(Counter.winst.dpy,Counter.winst.win,&wa);
  193.    Counter.winorigx = wa.x;
  194.    Counter.winorigy = wa.y;
  195.    Counter.winsizex = wa.width;
  196.    Counter.winsizey = wa.height;
  197. #endif
  198. }
  199.  
  200. /**********************************************************************
  201. *  spInitFont()                                                
  202. **********************************************************************/
  203. uint32 spInitFont(char *fn)
  204.  
  205. {
  206. #ifdef SP_IRIS_GL
  207.    return(1);
  208. #endif
  209.  
  210. #ifdef SP_OPEN_GL
  211.    XFontStruct *fontInfo;
  212.    uint32 firt, last;
  213.  
  214.    /* Lookup font */
  215.    if (!(fontInfo = XLoadQueryFont(Counter.winst.dpy,fn)))  {
  216.      fprintf(stderr,"ERROR: XLoadQueryFont() failed.\n");
  217.      return(0);
  218.      }
  219.  
  220.    firt = fontInfo->min_char_or_byte2;
  221.    last = fontInfo->max_char_or_byte2;
  222.  
  223.    if (!(Counter.fontbase = glGenLists(last+1))) {
  224.      fprintf(stderr,"ERROR: glGenLists() failed.\n");
  225.      return(0);
  226.      }
  227.  
  228.    glXUseXFont(fontInfo->fid, firt, last-firt+1, Counter.fontbase+firt);
  229.    return(1);
  230. #endif
  231. }
  232.  
  233. /**********************************************************************
  234. *  spDrawString()                                                
  235. **********************************************************************/
  236. void spDrawString(float x,float y,float z,char *ch)
  237.  
  238. {
  239. #ifdef SP_IRIS_GL
  240.    cmov(x,y,z);
  241.    charstr(ch);
  242. #endif
  243.  
  244. #ifdef SP_OPEN_GL
  245.     glRasterPos3f(x,y,z);
  246.     glListBase(Counter.fontbase);
  247.     glCallLists(strlen(ch),GL_UNSIGNED_BYTE,ch);
  248. #endif
  249. }
  250.  
  251. /**********************************************************************
  252. *  spInitCursor()                                                
  253. **********************************************************************/
  254. void spInitCursor(void)
  255.  
  256. {
  257.    Counter.mouse_x = 0;
  258.    Counter.mouse_y = 0;
  259.    Counter.mouse_b = 0;
  260.    Counter.mouse_n = 0;
  261.  
  262. #ifdef SP_IRIS_GL
  263.    curstype(C16X1) ;
  264.    defcursor(1,cursor) ;
  265.    curorigin(1,7,7) ;
  266.    setcursor(1,0,0) ;
  267.  
  268.    setvaluator(MOUSEX,Counter.winorigx+Counter.winsizex/2,0,getgdesc(GD_XPMAX)-1) ;
  269.    setvaluator(MOUSEY,Counter.winorigy+Counter.winsizey/2,0,getgdesc(GD_YPMAX)-1) ;
  270. #endif
  271.  
  272. #ifdef SP_OPEN_GL
  273.    XWarpPointer(Counter.winst.dpy,None,Counter.winst.win,0,0,0,0,
  274.          Counter.winorigx+(Counter.winsizex>>1),Counter.winorigy+(Counter.winsizey>>1));
  275. #endif
  276. }
  277.  
  278. /**********************************************************************
  279. *  spInitKeyboard()                                                
  280. **********************************************************************/
  281. void spInitKeyboard(void)
  282.  
  283. {
  284. #ifdef SP_IRIS_GL
  285.    qdevice(ESCKEY); /* exit */
  286.    qdevice(BUT10);  /* a: autopilot */
  287.    qdevice(BUT11);  /* s: stats */
  288.    qdevice(BUT20);  /* x: text toggle */
  289.    qdevice(BUT26);  /* h: help */
  290.    qdevice(BUT41);  /* l: shade every frame */
  291.    qdevice(BUT28);  /* v: reverse velocity */
  292.    qdevice(BUT23);  /* r: time slow */
  293.    qdevice(BUT24);  /* t: time fast */
  294.    qdevice(BUT31);  /* y: time reset */
  295.    qdevice(BUT17);  /* d: debug flag */
  296.    qdevice(BUT36);  /* n: star name flag */
  297.    qdevice(BUT19);  /* z: zodiac flag */
  298.    qdevice(BUT39);  /* i: moon orbit flag */
  299.    qdevice(BUT40);  /* o: planet orbit flag */
  300.    qdevice(BUT9 );  /* q: control panel */
  301.    qdevice(BUT35);  /* b: single buffer mode */
  302.    qdevice(BUT32);  /* u: user entry mode */
  303.  
  304.    qdevice(BUT157); /* printscreen: image dump flag */
  305.    qdevice(BUT46);  /* -: time direction */
  306.    qdevice(BUT73);  /* down arrow: decrease tesselation level */
  307.    qdevice(BUT80);  /* up   arrow: increase tesselation level */
  308.    qdevice(BUT50);  /* return */
  309.    qdevice(BUT145); /* f1: sound */
  310.    qdevice(BUT51);  /* .: for reading floats */
  311.    qdevice(BUT44);  /* ,: for star naming */
  312.    qdevice(BUT4);   /* right shift */
  313.    qdevice(BUT5);   /* left  shift */
  314.    qdevice(BUT2);   /* left  ctrl */
  315.    qdevice(BUT144); /* right ctrl */
  316.  
  317.    qdevice(BUT45);  /* 0 */
  318.    qdevice(BUT7);   /* 1 */
  319.    qdevice(BUT13);  /* 2 */
  320.    qdevice(BUT14);  /* 3 */
  321.    qdevice(BUT21);  /* 4 */
  322.    qdevice(BUT22);  /* 5 */
  323.    qdevice(BUT29);  /* 6 */
  324.    qdevice(BUT30);  /* 7 */
  325.    qdevice(BUT37);  /* 8 */
  326.    qdevice(BUT38);  /* 9 */
  327.  
  328.    qdevice(WINFREEZE) ;
  329.    qdevice(WINTHAW) ;
  330. #endif
  331.  
  332. #ifdef SP_OPEN_GL
  333.    long mask;
  334.  
  335.    mask = FocusChangeMask | ExposureMask | ResizeRedirectMask | PointerMotionMask |
  336.             KeyPressMask | KeyReleaseMask| ButtonPressMask | ButtonReleaseMask ;
  337.    XSelectInput(Counter.winst.dpy,Counter.winst.win,mask);
  338.    XFlush(Counter.winst.dpy);
  339. #endif
  340. }
  341.  
  342. /**********************************************************************
  343. *  spReadEvents()                                                
  344. **********************************************************************/
  345. void spReadEvents(t_boss *flaggs)
  346.  
  347. {
  348. #ifdef SP_IRIS_GL
  349.    sint16   val ;
  350.    sint32   v;
  351.  
  352.    while (qtest())  {
  353.      v = qread(&val) ;
  354.  
  355.      if (v == WINFREEZE)  {
  356.        while (qread(&val) != WINTHAW) ;
  357.  
  358.        if (Counter.flags & PANEL_FLAG)
  359.          draw_menu() ;
  360.  
  361.        qreset() ;
  362.        return ;
  363.        }
  364.  
  365.      if (v == SP_IO_lsh || v == SP_IO_rsh)
  366.        if (val)
  367.          Counter.flags |= SHIFT_FLAG ;
  368.        else Counter.flags &= ~SHIFT_FLAG ;
  369.  
  370.      if (v == SP_IO_lct || v == SP_IO_rct)
  371.        if (val)
  372.          Counter.flags |= CNTRL_FLAG ;
  373.        else Counter.flags &= ~CNTRL_FLAG ;
  374.  
  375.      if (!val)
  376.        key_press(flaggs,v);
  377.      }
  378.  
  379.    Counter.mouse_x = getvaluator(MOUSEX) ;
  380.    Counter.mouse_y = getvaluator(MOUSEY) ;
  381.  
  382.    Counter.mouse_b = 0;
  383.    if (getbutton(LEFTMOUSE))
  384.      Counter.mouse_b |= SP_LMOUSE;
  385.    if (getbutton(MIDDLEMOUSE))
  386.      Counter.mouse_b |= SP_MMOUSE;
  387.    if (getbutton(RIGHTMOUSE))
  388.      Counter.mouse_b |= SP_RMOUSE;
  389. #endif
  390.  
  391. #ifdef SP_OPEN_GL
  392.    int flag;
  393.    XEvent event;
  394.    KeySym keysym;
  395.    char   buf[16];
  396.  
  397.    Counter.mouse_b = 0;
  398.  
  399.    while (XEventsQueued(Counter.winst.dpy,QueuedAfterReading)) {
  400.      XNextEvent(Counter.winst.dpy, &event);
  401.  
  402.      switch (event.type) {
  403.        case MotionNotify:
  404.          Counter.mouse_x = Counter.winorigx + event.xbutton.x;
  405.          Counter.mouse_y = Counter.winorigy + Counter.rotsizey - event.xbutton.y - 1;
  406.          break;
  407.  
  408.        case ButtonPress:
  409.          if (event.xbutton.button == Button1) {
  410.            Counter.mouse_n |= (SP_LMOUSE<<4);
  411.            Counter.mouse_b |= SP_LMOUSE;
  412.            }
  413.          if (event.xbutton.button == Button2) {
  414.            Counter.mouse_n |= (SP_MMOUSE<<4);
  415.            Counter.mouse_b |= SP_MMOUSE;
  416.            }
  417.          if (event.xbutton.button == Button3) {
  418.            Counter.mouse_n |= (SP_RMOUSE<<4);
  419.            Counter.mouse_b |= SP_RMOUSE;
  420.            }
  421.          break;
  422.  
  423.        case ButtonRelease:
  424.          if (event.xbutton.button == Button1)
  425.            Counter.mouse_n &= ~(SP_LMOUSE<<4);
  426.          if (event.xbutton.button == Button2)
  427.            Counter.mouse_n &= ~(SP_MMOUSE<<4);
  428.          if (event.xbutton.button == Button3)
  429.            Counter.mouse_n &= ~(SP_RMOUSE<<4);
  430.          break;
  431.  
  432.        case KeyPress:
  433.          flag = XLookupString((XKeyEvent *)&event, buf, 16, &keysym, 0);
  434.  
  435.          if (keysym == 65505 || keysym == 65506) {
  436.            if (Counter.flags & SHIFT_FLAG)
  437.              Counter.flags &= ~SHIFT_FLAG ;
  438.            else Counter.flags |= SHIFT_FLAG ;
  439.            }
  440.          else if (keysym == 65507 || keysym == 65508) {
  441.            if (Counter.flags & CNTRL_FLAG)
  442.              Counter.flags &= ~CNTRL_FLAG ;
  443.            else Counter.flags |= CNTRL_FLAG ;
  444.            }
  445.          else if (keysym == 65362)
  446.            key_press(flaggs,SP_IO_up);
  447.          else if (keysym == 65364) 
  448.            key_press(flaggs,SP_IO_dwn);
  449.          else if (keysym == 65377)
  450.            key_press(flaggs,SP_IO_pri);
  451.  
  452.          if (flag)
  453.            key_press(flaggs,buf[0]);
  454.          break;
  455.  
  456.        case DestroyNotify:
  457.          exit(1);
  458.          break;
  459.  
  460.        case Expose:
  461.        case ConfigureNotify:
  462.        case KeyRelease:
  463.        default:
  464.          break;
  465.        }
  466.      }
  467.  
  468.    if (Counter.mouse_n & (SP_LMOUSE<<4))
  469.      Counter.mouse_b |= SP_LMOUSE;
  470.    if (Counter.mouse_n & (SP_MMOUSE<<4))
  471.      Counter.mouse_b |= SP_MMOUSE;
  472.    if (Counter.mouse_n & (SP_RMOUSE<<4))
  473.      Counter.mouse_b |= SP_RMOUSE;
  474. #endif
  475. }
  476.  
  477. /**********************************************************************
  478. *  spInitSpaceball()                                                
  479. **********************************************************************/
  480. void spInitSpaceball(void)
  481.  
  482. {
  483. #ifdef SP_IRIS_GL
  484.    qdevice(SBPICK) ;
  485.    qdevice(SBBUT1) ;
  486.    qdevice(SBBUT2) ;
  487.    qdevice(SBBUT3) ;
  488.    qdevice(SBBUT4) ;
  489.    qdevice(SBBUT5) ;
  490.    qdevice(SBBUT6) ;
  491.    qdevice(SBBUT7) ;
  492.    qdevice(SBBUT8) ;
  493.  
  494.    qdevice(SBTX) ;
  495.    qdevice(SBTY) ;
  496.    qdevice(SBTZ) ;
  497.    qdevice(SBRX) ;
  498.    qdevice(SBRY) ;
  499.    qdevice(SBRZ) ;
  500.    qdevice(SBPERIOD) ;
  501. #endif
  502.  
  503. #ifdef SP_OPEN_GL
  504.  
  505. #endif
  506. }
  507.  
  508. /**********************************************************************
  509. *  spReadSpaceball()                                                
  510. **********************************************************************/
  511. void spReadSpaceball(t_boss *flaggs)
  512.  
  513. {
  514.  
  515. }
  516.  
  517. /**********************************************************************
  518. *  spInitBell()                                                
  519. **********************************************************************/
  520. void spInitBell(void)
  521.  
  522. {
  523. #ifdef SP_IRIS_GL
  524.    setbell(1);
  525. #endif
  526.  
  527. #ifdef SP_OPEN_GL
  528.    XKeyboardControl kbc;
  529.  
  530.    kbc.bell_percent  = 100;
  531.    kbc.bell_pitch    =  -1;
  532.    kbc.bell_duration =  -1;
  533.    XChangeKeyboardControl(Counter.winst.dpy,KBBellPercent|KBBellPitch|KBBellDuration,&kbc);
  534. #endif
  535. }
  536.  
  537. /**********************************************************************
  538. *  spRingBell()                                                
  539. **********************************************************************/
  540. void spRingBell(void)
  541.  
  542. {
  543. #ifdef SP_IRIS_GL
  544.    ringbell();
  545. #endif
  546.  
  547. #ifdef SP_OPEN_GL
  548.    XBell(Counter.winst.dpy,100);
  549. #endif
  550. }
  551.  
  552. /**********************************************************************
  553. *  spWaitForLeftButton()                                                
  554. **********************************************************************/
  555. void spWaitForLeftButton(void)
  556.  
  557. {
  558. #ifdef SP_IRIS_GL
  559.    while (1)
  560.      if (getbutton(LEFTMOUSE))  {
  561.        Counter.mouse_x = getvaluator(MOUSEX);
  562.        Counter.mouse_y = getvaluator(MOUSEY);
  563.        return;
  564.        }
  565. #endif
  566.  
  567. #ifdef SP_OPEN_GL
  568.    XEvent event;
  569.    uint32 flag = 0;
  570.  
  571.    while (1)
  572.      if (XEventsQueued(Counter.winst.dpy,QueuedAfterReading)) {
  573.        XNextEvent(Counter.winst.dpy, &event);
  574.  
  575.        switch (event.type) {
  576.          case MotionNotify:
  577.            Counter.mouse_x = Counter.winorigx + event.xbutton.x;
  578.            Counter.mouse_y = Counter.winorigy + Counter.rotsizey - event.xbutton.y - 1;
  579.            flag |= 2;
  580.            break;
  581.  
  582.          case ButtonPress:
  583.            if (event.xbutton.button == Button1)
  584.              flag |= 1;
  585.            break;
  586.   
  587.          default:
  588.            break;
  589.          }
  590.   
  591.        if (flag == 3)
  592.          return;
  593.        }
  594. #endif
  595. }
  596.  
  597. /**********************************************************************
  598. *  spSwapBuffers()                                                
  599. **********************************************************************/
  600. void spSwapBuffers(void)
  601.  
  602. {
  603. #ifdef SP_IRIS_GL
  604.    swapbuffers() ;
  605. #endif
  606.  
  607. #ifdef SP_OPEN_GL
  608.    glXSwapBuffers(Counter.winst.dpy, Counter.winst.win);
  609. #endif
  610. }
  611.  
  612. /********************************************************************** 
  613. *  spIdentifyMachine()  -  
  614. **********************************************************************/
  615. void spIdentifyMachine(void)
  616.  
  617. {
  618. #ifdef SP_IRIS_GL
  619.    char ghw[64];
  620.  
  621.    gversion(ghw);
  622.  
  623.    if (strncmp("GL4DRE",ghw,6) == 0)
  624.      Counter.winst.hwid = SP_HW_RE;
  625.    else if (strncmp("GL4DVGX",ghw,7) == 0)
  626.      Counter.winst.hwid = SP_HW_VGX;
  627.    else if (strncmp("GL4DGT", ghw,6) == 0)
  628.      Counter.winst.hwid = SP_HW_GT;
  629.    else if (strncmp("GL4DLG", ghw,6) == 0)
  630.      Counter.winst.hwid = SP_HW_LG;
  631.    else if (strncmp("GL4DXG", ghw,6) == 0)
  632.      Counter.winst.hwid = SP_HW_XG;
  633.    else if (strncmp("GL4DPI", ghw,6) == 0)
  634.      Counter.winst.hwid = SP_HW_PI;
  635.    else if (strncmp("GL4DG", ghw,5) == 0)
  636.      Counter.winst.hwid = SP_HW_G;
  637.    else
  638.      Counter.winst.hwid = SP_HW_UNKNOWN;
  639. #endif
  640.  
  641. #ifdef SP_OPEN_GL
  642.    Counter.winst.hwid = SP_HW_RE;
  643. #endif
  644. }
  645.  
  646. /********************************************************************** 
  647. *  spReadFloat()  -  
  648. **********************************************************************/
  649. flot32 spReadFloat(void)
  650.  
  651. {
  652. #ifdef SP_IRIS_GL
  653.    sint32 v,i=0,flag=0;
  654.    flot32 r,f=1.0,num;
  655.    sint16 val;
  656.  
  657.    qreset() ;
  658.    num = 0.0;
  659.  
  660.    while (1)  {
  661.      v = qread(&val) ;
  662.  
  663.      if (!val)  {
  664.        r = -1 ;
  665.  
  666.        switch(v)  {
  667.          case SP_IO_0  : r = 0 ; break ;
  668.          case SP_IO_1  : r = 1 ; break ;
  669.          case SP_IO_2  : r = 2 ; break ;
  670.          case SP_IO_3  : r = 3 ; break ;
  671.          case SP_IO_4  : r = 4 ; break ;
  672.          case SP_IO_5  : r = 5 ; break ;
  673.          case SP_IO_6  : r = 6 ; break ;
  674.          case SP_IO_7  : r = 7 ; break ;
  675.          case SP_IO_8  : r = 8 ; break ;
  676.          case SP_IO_9  : r = 9 ; break ;
  677.          case SP_IO_pnt: flag = 1; break ;
  678.          case SP_IO_ret: return(num*f); break;
  679.          default       : break ;
  680.          }
  681.  
  682.        if (r >= 0)  {
  683.          if (flag)
  684.            f *= 0.1;
  685.          num = 10*num + r ;
  686.          }
  687.        }
  688.      }
  689. #endif
  690.  
  691. #ifdef SP_OPEN_GL
  692.    XEvent event;
  693.    KeySym keysym;
  694.    char   buf[16];
  695.    sint32 v,i=0,flag=0;
  696.    flot32 r,f=1.0,num=0.0;
  697.  
  698.    while (1) {
  699.      XEventsQueued(Counter.winst.dpy,QueuedAfterReading);
  700.      XNextEvent(Counter.winst.dpy, &event);
  701.  
  702.      if (event.type == KeyPress) {
  703.        if (XLookupString((XKeyEvent *)&event, buf, 16, &keysym, 0))  {
  704.          r = -1 ;
  705.          switch(buf[0])  {
  706.            case SP_IO_0  : r = 0 ; break ;
  707.            case SP_IO_1  : r = 1 ; break ;
  708.            case SP_IO_2  : r = 2 ; break ;
  709.            case SP_IO_3  : r = 3 ; break ;
  710.            case SP_IO_4  : r = 4 ; break ;
  711.            case SP_IO_5  : r = 5 ; break ;
  712.            case SP_IO_6  : r = 6 ; break ;
  713.            case SP_IO_7  : r = 7 ; break ;
  714.            case SP_IO_8  : r = 8 ; break ;
  715.            case SP_IO_9  : r = 9 ; break ;
  716.            case SP_IO_pnt: flag = 1; break ;
  717.            case SP_IO_ret: return(num*f); break;
  718.            default       : break ;
  719.            }
  720.  
  721.          if (r >= 0)  {
  722.            if (flag)
  723.              f *= 0.1;
  724.            num = 10*num + r ;
  725.            }
  726.          }
  727.        }
  728.      }
  729. #endif
  730. }
  731.  
  732. /********************************************************************** 
  733. *  spReadStar()  -  
  734. **********************************************************************/
  735. sint32 spReadStar(sint32 n[3])
  736.  
  737. {
  738. #ifdef SP_IRIS_GL
  739.    register sint32 v,i=0,r ;
  740.    sint16 val ;
  741.  
  742.    qreset() ;
  743.    n[0] = n[1] = n[2] = 0 ;
  744.  
  745.    while (1)  {
  746.      v = qread(&val) ;
  747.  
  748.      if (!val)  {
  749.        r = -1 ;
  750.  
  751.        switch(v)  {
  752.          case SP_IO_0  : r = 0 ; break ;
  753.          case SP_IO_1  : r = 1 ; break ;
  754.          case SP_IO_2  : r = 2 ; break ;
  755.          case SP_IO_3  : r = 3 ; break ;
  756.          case SP_IO_4  : r = 4 ; break ;
  757.          case SP_IO_5  : r = 5 ; break ;
  758.          case SP_IO_6  : r = 6 ; break ;
  759.          case SP_IO_7  : r = 7 ; break ;
  760.          case SP_IO_8  : r = 8 ; break ;
  761.          case SP_IO_9  : r = 9 ; break ;
  762.          case SP_IO_com: i++   ; break ;
  763.          case SP_IO_tid: i++   ; break ;
  764.  
  765.          case SP_IO_ret: if (i < 2)  {
  766.                            n[1] = SOL_X_GRID ; 
  767.                            n[2] = SOL_Z_GRID ;
  768.                            }
  769.                          else if (i > 2)
  770.                            n[0] = n[1] = n[2] = -1 ;
  771.                    
  772.                          if (n[0] < 0 || n[1] < 0 || n[1] >= STARSQ || n[2] < 0 || n[2] >= STARSQ)
  773.                            return(0) ;
  774.  
  775.                          return(1) ;
  776.                          break ;
  777.  
  778.          default       : break ;
  779.          }
  780.  
  781.        if (r >= 0)
  782.          n[i] = 10*n[i] + r ;
  783.        }
  784.      }
  785. #endif
  786.  
  787. #ifdef SP_OPEN_GL
  788.    XEvent event;
  789.    KeySym keysym;
  790.    char   buf[16];
  791.    sint32 i=0,r;
  792.  
  793.    n[0] = n[1] = n[2] = 0 ;
  794.  
  795.    while (1) {
  796.      XEventsQueued(Counter.winst.dpy,QueuedAfterReading);
  797.      XNextEvent(Counter.winst.dpy, &event);
  798.  
  799.      if (event.type == KeyPress) {
  800.        if (XLookupString((XKeyEvent *)&event, buf, 16, &keysym, 0))  {
  801.          r = -1 ;
  802.          switch(buf[0])  {
  803.            case SP_IO_0  : r = 0 ; break ;
  804.            case SP_IO_1  : r = 1 ; break ;
  805.            case SP_IO_2  : r = 2 ; break ;
  806.            case SP_IO_3  : r = 3 ; break ;
  807.            case SP_IO_4  : r = 4 ; break ;
  808.            case SP_IO_5  : r = 5 ; break ;
  809.            case SP_IO_6  : r = 6 ; break ;
  810.            case SP_IO_7  : r = 7 ; break ;
  811.            case SP_IO_8  : r = 8 ; break ;
  812.            case SP_IO_9  : r = 9 ; break ;
  813.            case SP_IO_com: i++   ; break ;
  814.            case SP_IO_tid: i++   ; break ;
  815.     
  816.            case SP_IO_ret: if (i < 2)  {
  817.                              n[1] = SOL_X_GRID ;
  818.                              n[2] = SOL_Z_GRID ;
  819.                              }
  820.                            else if (i > 2)
  821.                              n[0] = n[1] = n[2] = -1 ;
  822.  
  823.                            if (n[0] < 0 || n[1] < 0 || n[1] >= STARSQ || n[2] < 0 || n[2] >= STARSQ)
  824.                              return(0) ;
  825.  
  826.                            return(1) ;
  827.                            break ;
  828.  
  829.            default       : break ;
  830.            }
  831.  
  832.          if (r >= 0)
  833.            n[i] = 10*n[i] + r ;
  834.          }
  835.        }
  836.      }
  837. #endif
  838. }
  839.  
  840.