ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rhd_glx1.c
Revision: 3.2
Committed: Mon Jul 21 22:30:18 2003 UTC (20 years, 8 months ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 3.1: +4 -4 lines
Log Message:
Eliminated copystruct() macro, which is unnecessary in ANSI.
Reduced ambiguity warnings for nested if/if/else clauses.

File Contents

# User Rev Content
1 greg 3.1 #ifndef lint
2 schorsch 3.2 static const char RCSid[] = "$Id: rhd_glx1.c,v 3.1 2003/02/22 02:07:24 greg Exp $";
3 greg 3.1 #endif
4     /*
5     * OpenGL GLX driver for holodeck display.
6     * Based on x11 driver.
7     */
8    
9     #include "standard.h"
10    
11     #include <GL/glx.h>
12    
13     #include "rhd_qtree.h"
14    
15     #include "x11icon.h"
16    
17     #ifndef RAYQLEN
18     #define RAYQLEN 50000 /* max. rays to queue before flush */
19     #endif
20    
21     #ifndef FEQ
22     #define FEQ(a,b) ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
23     #endif
24    
25     #ifndef MAXCONE
26     #define MAXCONE 16 /* number of different cone sizes */
27     #endif
28     #ifndef MAXVERT
29     #define MAXVERT 64 /* maximum number of cone vertices */
30     #endif
31     #ifndef MINVERT
32     #define MINVERT 4 /* minimum number of cone vertices */
33     #endif
34     #ifndef DEPTHFACT
35     #define DEPTHFACT 16. /* multiplier for depth tests */
36     #endif
37    
38     #define GAMMA 1.4 /* default gamma correction */
39    
40     #define MOVPCT 7 /* percent distance to move /frame */
41     #define MOVDIR(b) ((b)==Button1 ? 1 : (b)==Button2 ? 0 : -1)
42     #define MOVDEG (-5) /* degrees to orbit CW/down /frame */
43     #define MOVORB(s) ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
44    
45     #define MINWIDTH 480 /* minimum graphics window width */
46     #define MINHEIGHT 400 /* minimum graphics window height */
47    
48     #define VIEWDIST 356 /* assumed viewing distance (mm) */
49    
50     #define BORWIDTH 5 /* border width */
51    
52     #define ourscreen DefaultScreen(ourdisplay)
53     #define ourroot RootWindow(ourdisplay,ourscreen)
54     #define ourmask (StructureNotifyMask|ExposureMask|KeyPressMask|\
55     ButtonPressMask|ButtonReleaseMask)
56    
57     #define levptr(etype) ((etype *)&currentevent)
58    
59     struct driver odev; /* global device driver structure */
60    
61     char odev_args[64]; /* command arguments */
62    
63     static XEvent currentevent; /* current event */
64    
65     static int mapped = 0; /* window is mapped? */
66     static unsigned long ourblack=0, ourwhite=~0;
67    
68     static Display *ourdisplay = NULL; /* our display */
69     static XVisualInfo *ourvinf; /* our visual information */
70     static Window gwind = 0; /* our graphics window */
71     static GLXContext gctx; /* our GLX context */
72    
73     static double pwidth, pheight; /* pixel dimensions (mm) */
74    
75     static double curzmax = 1e4; /* current depth upper limit */
76     static double nxtzmax = 0.; /* maximum (finite) depth so far */
77    
78     static struct {
79     double rad; /* cone radius */
80     int nverts; /* number of vertices */
81     FVECT *va; /* allocated vertex array */
82     } cone[MAXCONE]; /* precomputed cones for drawing */
83    
84     static int inpresflags; /* input result flags */
85    
86     static int headlocked = 0; /* lock vertical motion */
87    
88     static int resizewindow(), getevent(), getkey(), moveview(),
89     initcones(), freecones(),
90     getmove(), fixwindow(), mytmflags();
91    
92    
93     dev_open(id) /* initialize X11 driver */
94     char *id;
95     {
96     extern char *getenv();
97     static RGBPRIMS myprims = STDPRIMS;
98     static int atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
99     GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
100     GLX_DEPTH_SIZE,15, None};
101     char *ev;
102     double gamval = GAMMA;
103     RGBPRIMP dpri = stdprims;
104     XSetWindowAttributes ourwinattr;
105     XWMHints ourxwmhints;
106     XSizeHints oursizhints;
107     /* set quadtree globals */
108     qtMinNodesiz = 3;
109     qtDepthEps = 0.07;
110     /* open display server */
111     ourdisplay = XOpenDisplay(NULL);
112     if (ourdisplay == NULL)
113     error(USER, "cannot open X-windows; DISPLAY variable set?\n");
114     /* find a usable visual */
115     ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
116     if (ourvinf == NULL)
117     error(USER, "no suitable visuals available");
118     /* get a context */
119     gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
120     /* set gamma and tone mapping */
121     if ((ev = XGetDefault(ourdisplay, "radiance", "gamma")) != NULL
122     || (ev = getenv("DISPLAY_GAMMA")) != NULL)
123     gamval = atof(ev);
124     if ((ev = getenv("DISPLAY_PRIMARIES")) != NULL &&
125     sscanf(ev, "%f %f %f %f %f %f %f %f",
126     &myprims[RED][CIEX],&myprims[RED][CIEY],
127     &myprims[GRN][CIEX],&myprims[GRN][CIEY],
128     &myprims[BLU][CIEX],&myprims[BLU][CIEY],
129     &myprims[WHT][CIEX],&myprims[WHT][CIEY]) >= 6)
130     dpri = myprims;
131     if (tmInit(mytmflags(), dpri, gamval) == NULL)
132     error(SYSTEM, "not enough memory in dev_open");
133     /* open window */
134     ourwinattr.background_pixel = ourblack;
135     ourwinattr.border_pixel = ourblack;
136     ourwinattr.event_mask = ourmask;
137     /* this is stupid */
138     ourwinattr.colormap = XCreateColormap(ourdisplay, ourroot,
139     ourvinf->visual, AllocNone);
140     gwind = XCreateWindow(ourdisplay, ourroot, 0, 0,
141     DisplayWidth(ourdisplay,ourscreen)-2*BORWIDTH,
142     DisplayHeight(ourdisplay,ourscreen)-2*BORWIDTH,
143     BORWIDTH, ourvinf->depth, InputOutput, ourvinf->visual,
144     CWBackPixel|CWBorderPixel|CWColormap|CWEventMask, &ourwinattr);
145     if (gwind == 0)
146     error(SYSTEM, "cannot create window\n");
147     XStoreName(ourdisplay, gwind, id);
148     /* set window manager hints */
149     ourxwmhints.flags = InputHint|IconPixmapHint;
150     ourxwmhints.input = True;
151     ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay,
152     gwind, x11icon_bits, x11icon_width, x11icon_height);
153     XSetWMHints(ourdisplay, gwind, &ourxwmhints);
154     oursizhints.min_width = MINWIDTH;
155     oursizhints.min_height = MINHEIGHT;
156     oursizhints.flags = PMinSize;
157     XSetNormalHints(ourdisplay, gwind, &oursizhints);
158     /* set GLX context */
159     glXMakeCurrent(ourdisplay, gwind, gctx);
160     glEnable(GL_DEPTH_TEST);
161     glDepthFunc(GL_LEQUAL);
162     glShadeModel(GL_FLAT);
163     glDisable(GL_DITHER);
164     glDisable(GL_CULL_FACE);
165     glMatrixMode(GL_PROJECTION);
166     glOrtho(0., 1., 0., 1., -.01, 1.01);
167     glTranslated(0., 0., -1.01);
168     /* figure out sensible view */
169     pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
170     DisplayWidth(ourdisplay, ourscreen);
171     pheight = (double)DisplayHeightMM(ourdisplay, ourscreen) /
172     DisplayHeight(ourdisplay, ourscreen);
173 schorsch 3.2 odev.v = stdview;
174 greg 3.1 odev.v.type = VT_PER;
175     /* map the window */
176     XMapWindow(ourdisplay, gwind);
177     dev_input(); /* sets size and view angles */
178     /* allocate our leaf pile */
179     if (!qtAllocLeaves(DisplayWidth(ourdisplay,ourscreen) *
180     DisplayHeight(ourdisplay,ourscreen) * 3 /
181     (qtMinNodesiz*qtMinNodesiz*2)))
182     error(SYSTEM, "insufficient memory for value storage");
183     odev.name = id;
184     odev.ifd = ConnectionNumber(ourdisplay);
185     /* initialize cone array */
186     initcones();
187     }
188    
189    
190     dev_close() /* close our display and free resources */
191     {
192     glXMakeCurrent(ourdisplay, None, NULL);
193     glXDestroyContext(ourdisplay, gctx);
194     XDestroyWindow(ourdisplay, gwind);
195     gwind = 0;
196     XCloseDisplay(ourdisplay);
197     ourdisplay = NULL;
198     qtFreeLeaves();
199     tmDone(NULL);
200     freecones();
201     odev.v.type = 0;
202     odev.hres = odev.vres = 0;
203     odev.ifd = -1;
204     }
205    
206    
207     dev_clear() /* clear our quadtree */
208     {
209     qtCompost(100);
210     glClear(GL_DEPTH_BUFFER_BIT);
211     rayqleft = 0; /* hold off update */
212     }
213    
214    
215     int
216     dev_view(nv) /* assign new driver view */
217     register VIEW *nv;
218     {
219     if (nv->type == VT_PAR || /* check view legality */
220     nv->horiz > 160. || nv->vert > 160.) {
221     error(COMMAND, "illegal view type/angle");
222     nv->type = odev.v.type;
223     nv->horiz = odev.v.horiz;
224     nv->vert = odev.v.vert;
225     return(0);
226     }
227     if (nv->vfore > FTINY) {
228     error(COMMAND, "cannot handle fore clipping");
229     nv->vfore = 0.;
230     return(0);
231     }
232     if (nv != &odev.v) {
233     if (!FEQ(nv->horiz,odev.v.horiz) || /* resize window? */
234     !FEQ(nv->vert,odev.v.vert)) {
235     int dw = DisplayWidth(ourdisplay,ourscreen);
236     int dh = DisplayHeight(ourdisplay,ourscreen);
237    
238     dw -= 25; /* for window frame */
239     dh -= 50;
240     odev.hres = 2.*VIEWDIST/pwidth *
241     tan(PI/180./2.*nv->horiz);
242     odev.vres = 2.*VIEWDIST/pheight *
243     tan(PI/180./2.*nv->vert);
244     if (odev.hres > dw) {
245     odev.vres = dw * odev.vres / odev.hres;
246     odev.hres = dw;
247     }
248     if (odev.vres > dh) {
249     odev.hres = dh * odev.hres / odev.vres;
250     odev.vres = dh;
251     }
252     XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
253     dev_input(); /* get resize event */
254     }
255 schorsch 3.2 odev.v = *nv;
256 greg 3.1 }
257     if (nxtzmax > FTINY) {
258     curzmax = nxtzmax;
259     nxtzmax = 0.;
260     }
261     glClear(GL_DEPTH_BUFFER_BIT);
262     qtReplant();
263     return(1);
264     }
265    
266    
267     dev_section(ofn) /* add octree for geometry rendering */
268     char *ofn;
269     {
270     /* unimplemented */
271     }
272    
273    
274     dev_auxcom(cmd, args) /* process an auxiliary command */
275     char *cmd, *args;
276     {
277     sprintf(errmsg, "%s: unknown command", cmd);
278     error(COMMAND, errmsg);
279     }
280    
281    
282     VIEW *
283     dev_auxview(n, hvres) /* return nth auxiliary view */
284     int n;
285     int hvres[2];
286     {
287     if (n)
288     return(NULL);
289     hvres[0] = odev.hres; hvres[1] = odev.vres;
290     return(&odev.v);
291     }
292    
293    
294     int
295     dev_input() /* get X11 input */
296     {
297     inpresflags = 0;
298    
299     do
300     getevent();
301    
302     while (XQLength(ourdisplay) > 0);
303    
304     return(inpresflags);
305     }
306    
307    
308     int
309     dev_flush() /* flush output */
310     {
311     qtUpdate();
312     glFlush();
313     rayqleft = RAYQLEN;
314     return(XPending(ourdisplay));
315     }
316    
317    
318     dev_cone(rgb, ip, rad) /* render a cone in view coordinates */
319     BYTE rgb[3];
320     FVECT ip;
321     double rad;
322     {
323     register int ci, j;
324     double apexh, basez;
325     /* is window mapped? */
326     if (!mapped)
327     return;
328     /* compute apex height (0. to 1.) */
329     if (ip[2] > 1e6)
330     apexh = 1. - 1./DEPTHFACT;
331     else {
332     if (ip[2] > nxtzmax)
333     nxtzmax = ip[2];
334     if (ip[2] >= curzmax)
335     apexh = 1. - 1./DEPTHFACT;
336     else
337     apexh = 1. - ip[2]/(curzmax*DEPTHFACT);
338     }
339     rad *= 1.25; /* find conservative cone match */
340     for (ci = 0; ci < MAXCONE-1; ci++)
341     if (cone[ci].rad >= rad)
342     break;
343     /* draw it */
344     glColor3ub(rgb[0], rgb[1], rgb[2]);
345     glBegin(GL_TRIANGLE_FAN);
346     glVertex3d(ip[0], ip[1], apexh); /* start with apex */
347     basez = apexh*cone[ci].va[0][2]; /* base z's all the same */
348     for (j = 0; j < cone[ci].nverts; j++) /* draw each face */
349     glVertex3d(ip[0]+cone[ci].va[j][0], ip[1]+cone[ci].va[j][1],
350     basez);
351     /* connect last to first */
352     glVertex3d(ip[0]+cone[ci].va[0][0], ip[1]+cone[ci].va[0][1], basez);
353     glEnd(); /* all done */
354     }
355    
356    
357     static int
358     mytmflags() /* figure out tone mapping flags */
359     {
360     extern char *progname;
361     register char *cp, *tail;
362     /* find basic name */
363     for (cp = tail = progname; *cp; cp++)
364     if (*cp == '/')
365     tail = cp+1;
366     for (cp = tail; *cp && *cp != '.'; cp++)
367     ;
368     if (cp-tail == 4 && !strncmp(tail, "glx1", 4))
369     return(TM_F_CAMERA|TM_F_NOSTDERR);
370     if (cp-tail == 5 && !strncmp(tail, "glx1h", 5))
371     return(TM_F_HUMAN|TM_F_NOSTDERR);
372     error(USER, "illegal driver name");
373     }
374    
375    
376     static
377     initcones() /* initialize cone vertices */
378     {
379     register int i, j;
380     double minrad, d;
381    
382     if (cone[0].nverts)
383     freecones();
384     minrad = 2.*qtMinNodesiz/(double)(DisplayWidth(ourdisplay,ourscreen) +
385     DisplayHeight(ourdisplay,ourscreen));
386     for (i = 0; i < MAXCONE; i++) {
387     d = (double)i/(MAXCONE-1); d *= d; /* x^2 distribution */
388     cone[i].rad = minrad + (1.-minrad)*d;
389     cone[i].nverts = MINVERT + 0.5 + (MAXVERT-MINVERT)*d;
390     cone[i].va = (FVECT *)malloc(cone[i].nverts*sizeof(FVECT));
391     if (cone[i].va == NULL)
392     error(SYSTEM, "out of memory in initcones");
393     for (j = cone[i].nverts; j--; ) {
394     d = 2.*PI * (j+.5) / (cone[i].nverts);
395     cone[i].va[j][0] = cos(d) * cone[i].rad;
396     cone[i].va[j][1] = sin(d) * cone[i].rad;
397     cone[i].va[j][2] = 1. - cone[i].rad;
398     }
399     }
400     }
401    
402    
403     static
404     freecones() /* free cone vertices */
405     {
406     register int i;
407    
408     for (i = MAXCONE; i--; )
409     if (cone[i].nverts) {
410     free((void *)cone[i].va);
411     cone[i].va = NULL;
412     cone[i].nverts = 0;
413     }
414     }
415    
416    
417     static
418     getevent() /* get next event */
419     {
420     XNextEvent(ourdisplay, levptr(XEvent));
421     switch (levptr(XEvent)->type) {
422     case ConfigureNotify:
423     resizewindow(levptr(XConfigureEvent));
424     break;
425     case UnmapNotify:
426     mapped = 0;
427     break;
428     case MapNotify:
429     mapped = 1;
430     break;
431     case Expose:
432     fixwindow(levptr(XExposeEvent));
433     break;
434     case KeyPress:
435     getkey(levptr(XKeyPressedEvent));
436     break;
437     case ButtonPress:
438     getmove(levptr(XButtonPressedEvent));
439     break;
440     }
441     }
442    
443    
444     static
445     draw3dline(wp) /* draw 3d line in world coordinates */
446     register FVECT wp[2];
447     {
448     glVertex3d(wp[0][0], wp[0][1], wp[0][2]);
449     glVertex3d(wp[1][0], wp[1][1], wp[1][2]);
450     }
451    
452    
453     static
454     draw_grids() /* draw holodeck section grids */
455     {
456     static BYTE gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
457     double xmin, xmax, ymin, ymax, zmin, zmax;
458     double d, cx, sx, crad;
459     FVECT vx, vy;
460     register int i, j;
461     /* can we even do it? */
462     if (!mapped || odev.v.type != VT_PER)
463     return;
464     /* compute view frustum */
465     if (normalize(odev.v.vdir) == 0.0)
466     return;
467     zmin = 0.01;
468     zmax = 10000.;
469     if (odev.v.vfore > FTINY)
470     zmin = odev.v.vfore;
471     if (odev.v.vaft > FTINY)
472     zmax = odev.v.vaft;
473     xmax = zmin * tan(PI/180./2. * odev.v.horiz);
474     xmin = -xmax;
475     d = odev.v.hoff * (xmax - xmin);
476     xmin += d; xmax += d;
477     ymax = zmin * tan(PI/180./2. * odev.v.vert);
478     ymin = -ymax;
479     d = odev.v.voff * (ymax - ymin);
480     ymin += d; ymax += d;
481     /* set view matrix */
482     glMatrixMode(GL_PROJECTION);
483     glPushMatrix();
484     glLoadIdentity();
485     glFrustum(xmin, xmax, ymin, ymax, zmin, zmax);
486     gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
487     odev.v.vp[0] + odev.v.vdir[0],
488     odev.v.vp[1] + odev.v.vdir[1],
489     odev.v.vp[2] + odev.v.vdir[2],
490     odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
491     glDisable(GL_DEPTH_TEST); /* write no depth values */
492     glColor4ub(gridrgba[0], gridrgba[1], gridrgba[2], gridrgba[3]);
493     glBegin(GL_LINES); /* draw each grid line */
494     gridlines(draw3dline);
495     glEnd();
496     glEnable(GL_DEPTH_TEST); /* restore rendering params */
497     glPopMatrix();
498     }
499    
500    
501     static
502     moveview(dx, dy, mov, orb) /* move our view */
503     int dx, dy, mov, orb;
504     {
505     VIEW nv;
506     FVECT odir, v1;
507     double d;
508     register int li;
509     /* start with old view */
510 schorsch 3.2 nv = odev.v;
511 greg 3.1 /* change view direction */
512     if (mov | orb) {
513     if ((li = qtFindLeaf(dx, dy)) < 0)
514     return(0); /* not on window */
515     VSUM(odir, qtL.wp[li], nv.vp, -1.);
516     } else {
517     if (viewray(nv.vp, nv.vdir, &odev.v,
518     (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
519     return(0); /* outside view */
520     }
521     if (orb && mov) { /* orbit left/right */
522     spinvector(odir, odir, nv.vup, d=MOVDEG*PI/180.*mov);
523     VSUM(nv.vp, qtL.wp[li], odir, -1.);
524     spinvector(nv.vdir, nv.vdir, nv.vup, d);
525     } else if (orb) { /* orbit up/down */
526     fcross(v1, odir, nv.vup);
527     if (normalize(v1) == 0.)
528     return(0);
529     spinvector(odir, odir, v1, d=MOVDEG*PI/180.*orb);
530     VSUM(nv.vp, qtL.wp[li], odir, -1.);
531     spinvector(nv.vdir, nv.vdir, v1, d);
532     } else if (mov) { /* move forward/backward */
533     d = MOVPCT/100. * mov;
534     VSUM(nv.vp, nv.vp, odir, d);
535     }
536     if (!mov ^ !orb && headlocked) { /* restore head height */
537     VSUM(v1, odev.v.vp, nv.vp, -1.);
538     d = DOT(v1, odev.v.vup);
539     VSUM(nv.vp, nv.vp, odev.v.vup, d);
540     }
541     if (setview(&nv) != NULL)
542     return(0); /* illegal view */
543     dev_view(&nv);
544     inpresflags |= DFL(DC_SETVIEW);
545     return(1);
546     }
547    
548    
549     static
550     getmove(ebut) /* get view change */
551     XButtonPressedEvent *ebut;
552     {
553     int movdir = MOVDIR(ebut->button);
554     int movorb = MOVORB(ebut->state);
555     int oldnodesiz = qtMinNodesiz;
556     Window rootw, childw;
557     int rootx, rooty, wx, wy;
558     unsigned int statemask;
559    
560     qtMinNodesiz = 24; /* accelerate update rate */
561     XNoOp(ourdisplay);
562    
563     while (!XCheckMaskEvent(ourdisplay,
564     ButtonReleaseMask, levptr(XEvent))) {
565    
566     if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
567     &rootx, &rooty, &wx, &wy, &statemask))
568     break; /* on another screen */
569    
570     if (!moveview(wx, odev.vres-1-wy, movdir, movorb)) {
571     sleep(1);
572     continue;
573     }
574     glClear(GL_COLOR_BUFFER_BIT);
575     qtUpdate();
576     draw_grids();
577     glFlush();
578     }
579     if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
580     movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
581     wx = levptr(XButtonReleasedEvent)->x;
582     wy = levptr(XButtonReleasedEvent)->y;
583     moveview(wx, odev.vres-1-wy, movdir, movorb);
584     }
585     dev_flush();
586    
587     qtMinNodesiz = oldnodesiz; /* restore quadtree resolution */
588     }
589    
590    
591     static
592     getkey(ekey) /* get input key */
593     register XKeyPressedEvent *ekey;
594     {
595     int n;
596     char buf[8];
597    
598     n = XLookupString(ekey, buf, sizeof(buf), NULL, NULL);
599     if (n != 1)
600     return;
601     switch (buf[0]) {
602     case 'h': /* turn on height motion lock */
603     headlocked = 1;
604     return;
605     case 'H': /* turn off height motion lock */
606     headlocked = 0;
607     return;
608     case 'l': /* retrieve last view */
609     inpresflags |= DFL(DC_LASTVIEW);
610     return;
611     case 'p': /* pause computation */
612     inpresflags |= DFL(DC_PAUSE);
613     return;
614     case 'v': /* spit out view */
615     inpresflags |= DFL(DC_GETVIEW);
616     return;
617     case '\n':
618     case '\r': /* resume computation */
619     inpresflags |= DFL(DC_RESUME);
620     return;
621     case CTRL('R'): /* redraw screen */
622     if (nxtzmax > FTINY) {
623     curzmax = nxtzmax;
624     nxtzmax = 0.;
625     }
626     glClear(GL_DEPTH_BUFFER_BIT);
627     qtRedraw(0, 0, odev.hres, odev.vres);
628     return;
629     case CTRL('L'): /* refresh from server */
630     if (inpresflags & DFL(DC_REDRAW))
631     return;
632     if (nxtzmax > FTINY) {
633     curzmax = nxtzmax;
634     nxtzmax = 0.;
635     }
636     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
637     draw_grids();
638     glFlush();
639     qtCompost(100); /* get rid of old values */
640     inpresflags |= DFL(DC_REDRAW); /* resend values from server */
641     rayqleft = 0; /* hold off update */
642     return;
643     case 'K': /* kill rtrace process(es) */
644     inpresflags |= DFL(DC_KILL);
645     break;
646     case 'R': /* restart rtrace */
647     inpresflags |= DFL(DC_RESTART);
648     break;
649     case 'C': /* clobber holodeck */
650     inpresflags |= DFL(DC_CLOBBER);
651     break;
652     case 'q': /* quit the program */
653     inpresflags |= DFL(DC_QUIT);
654     return;
655     default:
656     XBell(ourdisplay, 0);
657     return;
658     }
659     }
660    
661    
662     static
663     fixwindow(eexp) /* repair damage to window */
664     register XExposeEvent *eexp;
665     {
666     int xmin, xmax, ymin, ymax;
667    
668     if (odev.hres == 0 || odev.vres == 0) /* first exposure */
669     resizewindow((XConfigureEvent *)eexp);
670     xmin = eexp->x; xmax = eexp->x + eexp->width;
671     ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
672     /* clear portion of depth */
673     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
674     glDepthFunc(GL_ALWAYS);
675     glBegin(GL_POLYGON);
676     glVertex3d((double)xmin/odev.hres, (double)ymin/odev.vres, 0.);
677     glVertex3d((double)xmax/odev.hres, (double)ymin/odev.vres, 0.);
678     glVertex3d((double)xmax/odev.hres, (double)ymax/odev.vres, 0.);
679     glVertex3d((double)xmin/odev.hres, (double)ymax/odev.vres, 0.);
680     glEnd();
681     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
682     glDepthFunc(GL_LEQUAL);
683     qtRedraw(xmin, ymin, xmax, ymax);
684     }
685    
686    
687     static
688     resizewindow(ersz) /* resize window */
689     register XConfigureEvent *ersz;
690     {
691     glViewport(0, 0, ersz->width, ersz->height);
692    
693     if (ersz->width == odev.hres && ersz->height == odev.vres)
694     return;
695    
696     odev.hres = ersz->width;
697     odev.vres = ersz->height;
698    
699     odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
700     odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
701    
702     inpresflags |= DFL(DC_SETVIEW);
703     }