ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rhd_glx.c
Revision: 3.24
Committed: Thu Dec 10 10:45:54 1998 UTC (25 years, 3 months ago) by gwlarson
Content type: text/plain
Branch: MAIN
Changes since 3.23: +58 -4 lines
Log Message:
created "frame" command to focus calculation

File Contents

# Content
1 /* Copyright (c) 1998 Silicon Graphics, Inc. */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ SGI";
5 #endif
6
7 /*
8 * OpenGL GLX driver for holodeck display.
9 * Based on old GLX driver using cones.
10 *
11 * Define symbol STEREO for stereo viewing.
12 * Define symbol DOBJ for display object viewing.
13 */
14
15 #ifdef NOSTEREO
16 #ifdef STEREO
17 #undef STEREO
18 #else
19 #undef NOSTEREO
20 #endif
21 #endif
22
23 #include "standard.h"
24
25 #include <sys/types.h>
26 #include <GL/glx.h>
27 #include <GL/glu.h>
28 #ifdef STEREO
29 #include <X11/extensions/SGIStereo.h>
30 #endif
31
32 #include "rhd_sample.h"
33 #ifdef DOBJ
34 #include "rhdobj.h"
35 #endif
36
37 #include "x11icon.h"
38
39 #ifndef RAYQLEN
40 #define RAYQLEN 1024 /* max. rays to queue before flush */
41 #endif
42
43 #ifndef FEQ
44 #define FEQ(a,b) ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
45 #endif
46
47 #define GAMMA 1.4 /* default gamma correction */
48
49 #define FRAMESTATE(s) (((s)&(ShiftMask|ControlMask))==(ShiftMask|ControlMask))
50
51 #define MOVPCT 7 /* percent distance to move /frame */
52 #define MOVDIR(b) ((b)==Button1 ? 1 : (b)==Button2 ? 0 : -1)
53 #define MOVDEG (-5) /* degrees to orbit CW/down /frame */
54 #define MOVORB(s) ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
55
56 #ifndef TARGETFPS
57 #define TARGETFPS 4.0 /* target frames/sec during motion */
58 #endif
59
60 #define MINWIDTH 480 /* minimum graphics window width */
61 #define MINHEIGHT 400 /* minimum graphics window height */
62
63 #define VIEWDIST 356 /* assumed viewing distance (mm) */
64
65 #define BORWIDTH 5 /* border width */
66
67 #define setstereobuf(bid) (glXWaitGL(), \
68 XSGISetStereoBuffer(ourdisplay, gwind, bid), \
69 glXWaitX())
70
71 #define ourscreen DefaultScreen(ourdisplay)
72 #define ourroot RootWindow(ourdisplay,ourscreen)
73 #define ourmask (StructureNotifyMask|ExposureMask|KeyPressMask|\
74 ButtonPressMask|ButtonReleaseMask)
75
76 #define levptr(etype) ((etype *)&currentevent)
77
78 struct driver odev; /* global device driver structure */
79
80 char odev_args[64]; /* command arguments */
81
82 #ifdef STEREO
83 static VIEW vwright; /* right eye view */
84 #endif
85
86 static int rayqleft = 0; /* rays left to queue before flush */
87
88 static XEvent currentevent; /* current event */
89
90 static int mapped = 0; /* window is mapped? */
91 static unsigned long ourblack=0, ourwhite=~0;
92
93 static Display *ourdisplay = NULL; /* our display */
94 static XVisualInfo *ourvinf; /* our visual information */
95 static Window gwind = 0; /* our graphics window */
96 static GLXContext gctx; /* our GLX context */
97
98 static double pwidth, pheight; /* pixel dimensions (mm) */
99
100 static double mindpth, maxdpth; /* min. and max. depth */
101
102 double dev_zmin, dev_zmax; /* fore and aft clipping plane dist. */
103
104 static int inpresflags; /* input result flags */
105
106 static int headlocked = 0; /* lock vertical motion */
107
108 static int resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
109 setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
110
111 #ifdef STEREO
112 static int pushright(), popright();
113 #endif
114
115 extern time_t time();
116
117
118 dev_open(id) /* initialize GLX driver */
119 char *id;
120 {
121 extern char *getenv();
122 static RGBPRIMS myprims = STDPRIMS;
123 static int atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
124 GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
125 GLX_DEPTH_SIZE,15, None};
126 char *ev;
127 double gamval = GAMMA;
128 RGBPRIMP dpri = stdprims;
129 XSetWindowAttributes ourwinattr;
130 XWMHints ourxwmhints;
131 XSizeHints oursizhints;
132 /* check for unsupported stereo */
133 #ifdef NOSTEREO
134 error(INTERNAL, "stereo display driver unavailable");
135 #endif
136 /* open display server */
137 ourdisplay = XOpenDisplay(NULL);
138 if (ourdisplay == NULL)
139 error(USER, "cannot open X-windows; DISPLAY variable set?\n");
140 #ifdef STEREO
141 switch (XSGIQueryStereoMode(ourdisplay, ourroot)) {
142 case STEREO_TOP:
143 case STEREO_BOTTOM:
144 break;
145 case STEREO_OFF:
146 error(USER,
147 "wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
148 case X_STEREO_UNSUPPORTED:
149 error(USER, "stereo mode not supported on this screen");
150 default:
151 error(INTERNAL, "unknown stereo mode");
152 }
153 #endif
154 /* find a usable visual */
155 ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
156 if (ourvinf == NULL)
157 error(USER, "no suitable visuals available");
158 /* get a context */
159 gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
160 /* set gamma and tone mapping */
161 if ((ev = XGetDefault(ourdisplay, "radiance", "gamma")) != NULL
162 || (ev = getenv("DISPLAY_GAMMA")) != NULL)
163 gamval = atof(ev);
164 if ((ev = getenv("DISPLAY_PRIMARIES")) != NULL &&
165 sscanf(ev, "%f %f %f %f %f %f %f %f",
166 &myprims[RED][CIEX],&myprims[RED][CIEY],
167 &myprims[GRN][CIEX],&myprims[GRN][CIEY],
168 &myprims[BLU][CIEX],&myprims[BLU][CIEY],
169 &myprims[WHT][CIEX],&myprims[WHT][CIEY]) >= 6)
170 dpri = myprims;
171 if (tmInit(mytmflags(), dpri, gamval) == NULL)
172 error(SYSTEM, "not enough memory in dev_open");
173 /* open window */
174 ourwinattr.background_pixel = ourblack;
175 ourwinattr.border_pixel = ourblack;
176 ourwinattr.event_mask = ourmask;
177 /* this is stupid */
178 ourwinattr.colormap = XCreateColormap(ourdisplay, ourroot,
179 ourvinf->visual, AllocNone);
180 gwind = XCreateWindow(ourdisplay, ourroot, 0, 0,
181 DisplayWidth(ourdisplay,ourscreen)-2*BORWIDTH,
182 #ifdef STEREO
183 (DisplayHeight(ourdisplay,ourscreen)-2*BORWIDTH)/2,
184 #else
185 DisplayHeight(ourdisplay,ourscreen)-2*BORWIDTH,
186 #endif
187 BORWIDTH, ourvinf->depth, InputOutput, ourvinf->visual,
188 CWBackPixel|CWBorderPixel|CWColormap|CWEventMask, &ourwinattr);
189 if (gwind == 0)
190 error(SYSTEM, "cannot create window\n");
191 XStoreName(ourdisplay, gwind, id);
192 /* set window manager hints */
193 ourxwmhints.flags = InputHint|IconPixmapHint;
194 ourxwmhints.input = True;
195 ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay,
196 gwind, x11icon_bits, x11icon_width, x11icon_height);
197 XSetWMHints(ourdisplay, gwind, &ourxwmhints);
198 oursizhints.min_width = MINWIDTH;
199 #ifdef STEREO
200 oursizhints.min_height = MINHEIGHT/2;
201 oursizhints.max_width = DisplayWidth(ourdisplay,ourscreen)-2*BORWIDTH;
202 oursizhints.max_height = (DisplayHeight(ourdisplay,ourscreen) -
203 2*BORWIDTH)/2;
204 oursizhints.flags = PMinSize|PMaxSize;
205 #else
206 oursizhints.min_height = MINHEIGHT;
207 oursizhints.flags = PMinSize;
208 #endif
209 XSetNormalHints(ourdisplay, gwind, &oursizhints);
210 /* set GLX context */
211 glXMakeCurrent(ourdisplay, gwind, gctx);
212 glEnable(GL_DEPTH_TEST);
213 glDepthFunc(GL_LEQUAL);
214 glShadeModel(GL_SMOOTH);
215 glDisable(GL_DITHER);
216 glDisable(GL_CULL_FACE);
217 /* figure out sensible view */
218 pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
219 DisplayWidth(ourdisplay, ourscreen);
220 pheight = (double)DisplayHeightMM(ourdisplay, ourscreen) /
221 DisplayHeight(ourdisplay, ourscreen);
222 #ifdef STEREO
223 pheight *= 2.;
224 setstereobuf(STEREO_BUFFER_LEFT);
225 #endif
226 checkglerr("setting rendering parameters");
227 copystruct(&odev.v, &stdview);
228 odev.v.type = VT_PER;
229 /* map the window */
230 XMapWindow(ourdisplay, gwind);
231 dev_input(); /* sets size and view angles */
232 /* allocate our samples */
233 if (!smInit(DisplayWidth(ourdisplay,ourscreen) *
234 DisplayHeight(ourdisplay,ourscreen) / 10))
235 error(SYSTEM, "insufficient memory for value storage");
236 mindpth = FHUGE; maxdpth = FTINY;
237 odev.name = id;
238 odev.ifd = ConnectionNumber(ourdisplay);
239 }
240
241
242 dev_close() /* close our display and free resources */
243 {
244 smInit(0);
245 #ifdef DOBJ
246 dobj_cleanup();
247 #endif
248 glXMakeCurrent(ourdisplay, None, NULL);
249 glXDestroyContext(ourdisplay, gctx);
250 XDestroyWindow(ourdisplay, gwind);
251 gwind = 0;
252 XCloseDisplay(ourdisplay);
253 ourdisplay = NULL;
254 tmDone(NULL);
255 odev.v.type = 0;
256 odev.hres = odev.vres = 0;
257 odev.ifd = -1;
258 }
259
260
261 dev_clear() /* clear our representation */
262 {
263 smInit(rsL.max_samp);
264 wipeclean();
265 rayqleft = 0; /* hold off update */
266 }
267
268
269 int
270 dev_view(nv) /* assign new driver view */
271 register VIEW *nv;
272 {
273 double d;
274
275 if (nv->type != VT_PER || /* check view legality */
276 nv->horiz > 160. || nv->vert > 160.) {
277 error(COMMAND, "illegal view type/angle");
278 nv->type = odev.v.type;
279 nv->horiz = odev.v.horiz;
280 nv->vert = odev.v.vert;
281 return(0);
282 }
283 if (nv != &odev.v) {
284 /* resize window? */
285 if (!FEQ(nv->horiz,odev.v.horiz) ||
286 !FEQ(nv->vert,odev.v.vert)) {
287 int dw = DisplayWidth(ourdisplay,ourscreen);
288 int dh = DisplayHeight(ourdisplay,ourscreen);
289
290 dw -= 25; /* for window frame */
291 dh -= 50;
292 #ifdef STEREO
293 dh /= 2;
294 #endif
295 odev.hres = 2.*VIEWDIST/pwidth *
296 tan(PI/180./2.*nv->horiz);
297 odev.vres = 2.*VIEWDIST/pheight *
298 tan(PI/180./2.*nv->vert);
299 if (odev.hres > dw) {
300 odev.vres = dw * odev.vres / odev.hres;
301 odev.hres = dw;
302 }
303 if (odev.vres > dh) {
304 odev.hres = dh * odev.hres / odev.vres;
305 odev.vres = dh;
306 }
307 XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
308 dev_input(); /* get resize event */
309 }
310 copystruct(&odev.v, nv); /* setview() already called */
311 #ifdef STEREO
312 copystruct(&vwright, nv);
313 d = eyesepdist / sqrt(nv->hn2);
314 VSUM(vwright.vp, nv->vp, nv->hvec, d);
315 /* setview(&vwright); -- Unnecessary */
316 #endif
317 }
318 wipeclean();
319 return(1);
320 }
321
322
323 dev_auxcom(cmd, args) /* process an auxiliary command */
324 char *cmd, *args;
325 {
326 #ifdef DOBJ
327 if (dobj_command(cmd, args) >= 0)
328 return;
329 #endif
330 sprintf(errmsg, "%s: unknown command", cmd);
331 error(COMMAND, errmsg);
332 }
333
334
335 VIEW *
336 dev_auxview(n, hvres) /* return nth auxiliary view */
337 int n;
338 int hvres[2];
339 {
340 hvres[0] = odev.hres; hvres[1] = odev.vres;
341 if (n == 0)
342 return(&odev.v);
343 #ifdef STEREO
344 if (n == 1)
345 return(&vwright);
346 #endif
347 return(NULL);
348 }
349
350
351 int
352 dev_input() /* get X11 input */
353 {
354 inpresflags = 0;
355
356 do
357 getevent();
358
359 while (XPending(ourdisplay) > 0);
360
361 odev.inpready = 0;
362
363 return(inpresflags);
364 }
365
366
367 dev_value(c, d, p) /* add a pixel value to our mesh */
368 COLR c;
369 FVECT d, p;
370 {
371 double depth;
372 #ifdef DOBJ
373 if (dobj_lightsamp != NULL) { /* in light source sampling */
374 (*dobj_lightsamp)(c, d, p);
375 return;
376 }
377 #endif
378 if (p != NULL) { /* add depth to our range */
379 depth = (p[0] - odev.v.vp[0])*d[0] +
380 (p[1] - odev.v.vp[1])*d[1] +
381 (p[2] - odev.v.vp[2])*d[2];
382 if (depth > FTINY) {
383 if (depth < mindpth)
384 mindpth = depth;
385 if (depth > maxdpth)
386 maxdpth = depth;
387 }
388 }
389 smNewSamp(c, d, p); /* add to display representation */
390 if (!--rayqleft)
391 dev_flush(); /* flush output */
392 }
393
394
395 int
396 dev_flush() /* flush output */
397 {
398 if (mapped) {
399 #ifdef STEREO
400 pushright(); /* update right eye */
401 smUpdate(&vwright, 100);
402 #ifdef DOBJ
403 dobj_render(); /* usually in foreground */
404 #endif
405 popright(); /* update left eye */
406 #endif
407 smUpdate(&odev.v, 100);
408 checkglerr("rendering mesh");
409 #ifdef DOBJ
410 dobj_render();
411 #endif
412 glFlush(); /* flush OGL */
413 }
414 rayqleft = RAYQLEN;
415 /* flush X11 and return # pending */
416 return(odev.inpready = XPending(ourdisplay));
417 }
418
419
420 checkglerr(where) /* check for GL or GLU error */
421 char *where;
422 {
423 register GLenum errcode;
424
425 while ((errcode = glGetError()) != GL_NO_ERROR) {
426 sprintf(errmsg, "OpenGL error %s: %s",
427 where, gluErrorString(errcode));
428 error(WARNING, errmsg);
429 }
430 }
431
432
433 #ifdef STEREO
434 static
435 pushright() /* push on right view */
436 {
437 double d;
438
439 setstereobuf(STEREO_BUFFER_RIGHT);
440 glMatrixMode(GL_MODELVIEW);
441 glPushMatrix();
442 d = -eyesepdist / sqrt(odev.v.hn2);
443 glTranslated(d*odev.v.hvec[0], d*odev.v.hvec[1], d*odev.v.hvec[2]);
444 checkglerr("setting right view");
445 }
446
447
448 static
449 popright() /* pop off right view */
450 {
451 glMatrixMode(GL_MODELVIEW);
452 glPopMatrix();
453 setstereobuf(STEREO_BUFFER_LEFT);
454 }
455 #endif
456
457
458 static int
459 mytmflags() /* figure out tone mapping flags */
460 {
461 extern char *progname;
462 register char *cp, *tail;
463 /* find basic name */
464 for (cp = tail = progname; *cp; cp++)
465 if (*cp == '/')
466 tail = cp+1;
467 for (cp = tail; *cp && *cp != '.'; cp++)
468 ;
469 if (cp > tail && cp[-1] == 'h')
470 return(TM_F_HUMAN|TM_F_NOSTDERR);
471 else
472 return(TM_F_CAMERA|TM_F_NOSTDERR);
473 }
474
475
476 static
477 getevent() /* get next event */
478 {
479 XNextEvent(ourdisplay, levptr(XEvent));
480 switch (levptr(XEvent)->type) {
481 case ConfigureNotify:
482 resizewindow(levptr(XConfigureEvent));
483 break;
484 case UnmapNotify:
485 mapped = 0;
486 break;
487 case MapNotify:
488 mapped = 1;
489 break;
490 case Expose:
491 fixwindow(levptr(XExposeEvent));
492 break;
493 case KeyPress:
494 getkey(levptr(XKeyPressedEvent));
495 break;
496 case ButtonPress:
497 if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
498 getframe(levptr(XButtonPressedEvent));
499 else
500 getmove(levptr(XButtonPressedEvent));
501 break;
502 }
503 }
504
505
506 static
507 draw3dline(wp) /* draw 3d line in world coordinates */
508 register FVECT wp[2];
509 {
510 glVertex3d(wp[0][0], wp[0][1], wp[0][2]);
511 glVertex3d(wp[1][0], wp[1][1], wp[1][2]);
512 }
513
514
515 static
516 draw_grids(fore) /* draw holodeck section grids */
517 int fore;
518 {
519 if (fore)
520 glColor4ub(0, 255, 255, 0);
521 else
522 glColor4ub(0, 0, 0, 0);
523 glBegin(GL_LINES); /* draw each grid line */
524 gridlines(draw3dline);
525 glEnd();
526 checkglerr("drawing grid lines");
527 }
528
529
530 static
531 moveview(dx, dy, mov, orb) /* move our view */
532 int dx, dy, mov, orb;
533 {
534 VIEW nv;
535 FVECT odir, v1, wip;
536 double d;
537 register int li;
538 /* start with old view */
539 copystruct(&nv, &odev.v);
540 /* orient our motion */
541 if (viewray(v1, odir, &odev.v,
542 (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
543 return(0); /* outside view */
544 if (mov | orb) { /* moving relative to geometry */
545 #ifdef DOBJ
546 d = dobj_trace(NULL, v1, odir); /* check objects */
547 /* check holodeck */
548 if ((li = smFindSamp(v1, odir)) >= 0) {
549 VCOPY(wip, rsL.wp[li]);
550 if (d < .99*FHUGE && d*d <= dist2(v1, wip))
551 li = -1; /* object is closer */
552 } else if (d >= .99*FHUGE)
553 return(0); /* nothing visible */
554 if (li < 0)
555 VSUM(wip, v1, odir, d); /* else get object point */
556 #else
557 if ((li = smFindSamp(v1, odir)) < 0)
558 return(0); /* not on window */
559 VCOPY(wip, rsL.wp[li]);
560 #endif
561 #ifdef DEBUG
562 fprintf(stderr, "moveview: hit %s at (%f,%f,%f) (t=%f)\n",
563 li < 0 ? "object" : "mesh",
564 wip[0], wip[1], wip[2],
565 (wip[0]-odev.v.vp[0])*odir[0] +
566 (wip[1]-odev.v.vp[1])*odir[1] +
567 (wip[2]-odev.v.vp[2])*odir[2]);
568 #endif
569 VSUM(odir, wip, odev.v.vp, -1.);
570 } else /* panning with constant viewpoint */
571 VCOPY(nv.vdir, odir);
572 if (orb && mov) { /* orbit left/right */
573 spinvector(odir, odir, nv.vup, d=MOVDEG*PI/180.*mov);
574 VSUM(nv.vp, wip, odir, -1.);
575 spinvector(nv.vdir, nv.vdir, nv.vup, d);
576 } else if (orb) { /* orbit up/down */
577 fcross(v1, odir, nv.vup);
578 if (normalize(v1) == 0.)
579 return(0);
580 spinvector(odir, odir, v1, d=MOVDEG*PI/180.*orb);
581 VSUM(nv.vp, wip, odir, -1.);
582 spinvector(nv.vdir, nv.vdir, v1, d);
583 } else if (mov) { /* move forward/backward */
584 d = MOVPCT/100. * mov;
585 VSUM(nv.vp, nv.vp, odir, d);
586 }
587 if (!mov ^ !orb && headlocked) { /* restore head height */
588 VSUM(v1, odev.v.vp, nv.vp, -1.);
589 d = DOT(v1, nv.vup);
590 VSUM(nv.vp, nv.vp, odev.v.vup, d);
591 }
592 if (setview(&nv) != NULL)
593 return(0); /* illegal view */
594 dev_view(&nv);
595 inpresflags |= DFL(DC_SETVIEW);
596 return(1);
597 }
598
599
600 static
601 getframe(ebut) /* get focus frame */
602 XButtonPressedEvent *ebut;
603 {
604 int startx = ebut->x, starty = ebut->y;
605 int endx, endy;
606
607 XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
608 endx = levptr(XButtonReleasedEvent)->x;
609 endy = levptr(XButtonReleasedEvent)->y;
610 if (endx == startx | endy == starty) {
611 XBell(ourdisplay, 0);
612 return;
613 }
614 if (endx < startx) {register int c = endx; endx = startx; startx = c;}
615 if (endy < starty) {register int c = endy; endy = starty; starty = c;}
616 sprintf(odev_args, "%.3f %.3f %.3f %.3f",
617 (startx+.5)/odev.hres, 1.-(endy+.5)/odev.vres,
618 (endx+.5)/odev.hres, 1.-(starty+.5)/odev.vres);
619 inpresflags |= DFL(DC_FOCUS);
620 }
621
622
623 static
624 getmove(ebut) /* get view change */
625 XButtonPressedEvent *ebut;
626 {
627 int movdir = MOVDIR(ebut->button);
628 int movorb = MOVORB(ebut->state);
629 int qlevel = 99;
630 time_t lasttime, thistime;
631 int nframes;
632 Window rootw, childw;
633 int rootx, rooty, wx, wy;
634 unsigned int statemask;
635
636 XNoOp(ourdisplay); /* makes sure we're not idle */
637
638 lasttime = time(0); nframes = 0;
639 while (!XCheckMaskEvent(ourdisplay,
640 ButtonReleaseMask, levptr(XEvent))) {
641 /* get cursor position */
642 if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
643 &rootx, &rooty, &wx, &wy, &statemask))
644 break; /* on another screen */
645
646 draw_grids(0); /* clear old grid lines */
647 #ifdef STEREO
648 pushright(); draw_grids(0); popright();
649 #endif
650 /* compute view motion */
651 if (!moveview(wx, odev.vres-1-wy, movdir, movorb)) {
652 sleep(1);
653 lasttime++;
654 continue; /* cursor in bad place */
655 }
656 draw_grids(1); /* redraw grid */
657 #ifdef STEREO
658 pushright();
659 draw_grids(1);
660 smUpdate(&vwright, qlevel);
661 #ifdef DOBJ
662 dobj_render();
663 #endif
664 popright();
665 #endif
666 /* redraw mesh */
667 smUpdate(&odev.v, qlevel);
668 #ifdef DOBJ
669 dobj_render(); /* redraw object */
670 #endif
671 glFlush();
672 nframes++; /* figure out good quality level */
673 thistime = time(0);
674 if (thistime - lasttime >= 3 ||
675 nframes > (int)(3*3*TARGETFPS)) {
676 qlevel = thistime<=lasttime ? 1000 :
677 (int)((double)nframes/(thistime-lasttime)
678 / TARGETFPS * qlevel + 0.5);
679 lasttime = thistime; nframes = 0;
680 if (qlevel > 99) {
681 if (qlevel > 300) { /* put on the brakes */
682 sleep(1);
683 lasttime++;
684 }
685 qlevel = 99;
686 } else if (qlevel < 1)
687 qlevel = 1;
688 }
689 }
690 if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
691 movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
692 wx = levptr(XButtonReleasedEvent)->x;
693 wy = levptr(XButtonReleasedEvent)->y;
694 moveview(wx, odev.vres-1-wy, movdir, movorb);
695 }
696 }
697
698
699 static
700 setglpersp(vp) /* set perspective view in GL */
701 register VIEW *vp;
702 {
703 double d, xmin, xmax, ymin, ymax;
704
705 if (mindpth >= maxdpth) {
706 dev_zmin = 0.1;
707 dev_zmax = 100.;
708 } else {
709 dev_zmin = 0.5*mindpth;
710 dev_zmax = 1.5*maxdpth;
711 if (dev_zmin > dev_zmax/100.)
712 dev_zmin = dev_zmax/100.;
713 }
714 if (odev.v.vfore > FTINY)
715 dev_zmin = odev.v.vfore;
716 if (odev.v.vaft > FTINY)
717 dev_zmax = odev.v.vaft;
718 if (dev_zmin < dev_zmax/5000.)
719 dev_zmin = dev_zmax/5000.;
720 xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
721 xmin = -xmax;
722 d = odev.v.hoff * (xmax - xmin);
723 xmin += d; xmax += d;
724 ymax = dev_zmin * tan(PI/180./2. * odev.v.vert);
725 ymin = -ymax;
726 d = odev.v.voff * (ymax - ymin);
727 ymin += d; ymax += d;
728 /* set view matrix */
729 glMatrixMode(GL_PROJECTION);
730 glLoadIdentity();
731 glFrustum(xmin, xmax, ymin, ymax, dev_zmin, dev_zmax);
732 gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
733 odev.v.vp[0] + odev.v.vdir[0],
734 odev.v.vp[1] + odev.v.vdir[1],
735 odev.v.vp[2] + odev.v.vdir[2],
736 odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
737 checkglerr("setting perspective view");
738 }
739
740
741 static
742 wipeclean() /* prepare for redraw */
743 {
744 /* clear depth buffer */
745 #ifdef STEREO
746 setstereobuf(STEREO_BUFFER_RIGHT);
747 glClear(GL_DEPTH_BUFFER_BIT);
748 setstereobuf(STEREO_BUFFER_LEFT);
749 #endif
750 glClear(GL_DEPTH_BUFFER_BIT);
751 smClean(); /* reset drawing routines */
752 setglpersp(&odev.v); /* reset view & clipping planes */
753 }
754
755
756 static
757 getkey(ekey) /* get input key */
758 register XKeyPressedEvent *ekey;
759 {
760 Window rootw, childw;
761 int rootx, rooty, wx, wy;
762 unsigned int statemask;
763 int n;
764 char buf[8];
765
766 n = XLookupString(ekey, buf, sizeof(buf), NULL, NULL);
767 if (n != 1)
768 return;
769 switch (buf[0]) {
770 case 'h': /* turn on height motion lock */
771 headlocked = 1;
772 return;
773 case 'H': /* turn off height motion lock */
774 headlocked = 0;
775 return;
776 case 'l': /* retrieve last view */
777 inpresflags |= DFL(DC_LASTVIEW);
778 return;
779 case 'p': /* pause computation */
780 inpresflags |= DFL(DC_PAUSE);
781 return;
782 case 'v': /* spit out view */
783 inpresflags |= DFL(DC_GETVIEW);
784 return;
785 case 'f': /* frame view position */
786 if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
787 &rootx, &rooty, &wx, &wy, &statemask))
788 return; /* on another screen */
789 sprintf(odev_args, "%.4f %.4f", (wx+.5)/odev.hres,
790 1.-(wy+.5)/odev.vres);
791 inpresflags |= DFL(DC_FOCUS);
792 return;
793 case 'F': /* unfocus */
794 odev_args[0] = '\0';
795 inpresflags |= DFL(DC_FOCUS);
796 return;
797 case '\n':
798 case '\r': /* resume computation */
799 inpresflags |= DFL(DC_RESUME);
800 return;
801 case CTRL('R'): /* redraw screen */
802 wipeclean();
803 return;
804 case CTRL('L'): /* refresh from server */
805 if (inpresflags & DFL(DC_REDRAW))
806 return;
807 setglpersp(&odev.v); /* reset clipping planes */
808 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
809 glDisable(GL_DEPTH_TEST); /* so grids will clear */
810 draw_grids(1);
811 #ifdef STEREO
812 pushright();
813 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
814 draw_grids(1);
815 popright();
816 #endif
817 glEnable(GL_DEPTH_TEST);
818 glFlush();
819 smInit(rsL.max_samp); /* get rid of old values */
820 inpresflags |= DFL(DC_REDRAW); /* resend values from server */
821 rayqleft = 0; /* hold off update */
822 return;
823 case 'K': /* kill rtrace process(es) */
824 inpresflags |= DFL(DC_KILL);
825 break;
826 case 'R': /* restart rtrace */
827 inpresflags |= DFL(DC_RESTART);
828 break;
829 case 'C': /* clobber holodeck */
830 inpresflags |= DFL(DC_CLOBBER);
831 break;
832 case 'q': /* quit the program */
833 inpresflags |= DFL(DC_QUIT);
834 return;
835 default:
836 XBell(ourdisplay, 0);
837 return;
838 }
839 }
840
841
842 static
843 fixwindow(eexp) /* repair damage to window */
844 register XExposeEvent *eexp;
845 {
846 if (odev.hres == 0 | odev.vres == 0) { /* first exposure */
847 resizewindow((XConfigureEvent *)eexp);
848 return;
849 }
850 if (eexp->count) /* wait for final exposure */
851 return;
852 wipeclean(); /* clear depth */
853 }
854
855
856 static
857 resizewindow(ersz) /* resize window */
858 register XConfigureEvent *ersz;
859 {
860 glViewport(0, 0, ersz->width, ersz->height);
861
862 if (ersz->width == odev.hres && ersz->height == odev.vres)
863 return;
864
865 odev.hres = ersz->width;
866 odev.vres = ersz->height;
867
868 odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
869 odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
870
871 inpresflags |= DFL(DC_SETVIEW);
872 }