ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rhd_glx.c
(Generate patch)

Comparing ray/src/hd/rhd_glx.c (file contents):
Revision 3.5 by gregl, Fri Dec 26 14:46:21 1997 UTC vs.
Revision 3.28 by gwlarson, Thu Jun 10 15:22:21 1999 UTC

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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines