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.12 by gregl, Thu Jan 1 16:28:44 1998 UTC vs.
Revision 3.27 by gwlarson, Sun Jan 3 13:40:25 1999 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1997 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1998 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 <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  "x11icon.h"
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         50000           /* max. rays to queue before flush */
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  
27 – #ifndef MAXCONE
28 – #define MAXCONE         16              /* number of different cone sizes */
29 – #endif
30 – #ifndef MAXVERT
31 – #define MAXVERT         32              /* maximum number of cone vertices */
32 – #endif
33 – #ifndef MINVERT
34 – #define MINVERT         4               /* minimum number of cone vertices */
35 – #endif
36 – #ifndef DEPTHFACT
37 – #define DEPTHFACT       16.             /* multiplier for depth tests */
38 – #endif
39 –
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  
# Line 51 | Line 64 | static char SCCSid[] = "$SunId$ SGI";
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|\
# Line 60 | Line 77 | static char SCCSid[] = "$SunId$ SGI";
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? */
# Line 72 | Line 97 | static GLXContext      gctx;           /* our GLX context */
97  
98   static double   pwidth, pheight;        /* pixel dimensions (mm) */
99  
100 < static double   curzmax = 1e4;          /* current depth upper limit */
76 < static double   nxtzmax = 0.;           /* maximum (finite) depth so far */
100 > static double   mindpth, maxdpth;       /* min. and max. depth */
101  
102 < 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 */
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(),
109 <                initcones(), freecones(),
90 <                getmove(), fixwindow(), mytmflags();
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 < dev_open(id)                    /* initialize X11 driver */
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    *gv;
126 >        char    *ev;
127          double  gamval = GAMMA;
128 +        RGBPRIMP        dpri = stdprims;
129          XSetWindowAttributes    ourwinattr;
130          XWMHints        ourxwmhints;
131          XSizeHints      oursizhints;
132 <                                        /* set quadtree globals */
133 <        qtMinNodesiz = 3;
134 <        qtDepthEps = 0.07;
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)
# Line 116 | Line 158 | char  *id;
158                                          /* get a context */
159          gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
160                                          /* set gamma and tone mapping */
161 <        if ((gv = XGetDefault(ourdisplay, "radiance", "gamma")) != NULL
162 <                        || (gv = getenv("DISPLAY_GAMMA")) != NULL)
163 <                gamval = atof(gv);
164 <        if (tmInit(mytmflags(), stdprims, gamval) == NULL)
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;
# Line 130 | Line 179 | char  *id;
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)
# Line 143 | Line 196 | char  *id;
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_FLAT);
214 >        glShadeModel(GL_SMOOTH);
215          glDisable(GL_DITHER);
216          glDisable(GL_CULL_FACE);
156 –        glMatrixMode(GL_PROJECTION);
157 –        glOrtho(0., 1., 0., 1., -.01, 1.01);
158 –        glTranslated(0., 0., -1.01);
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 leaf pile */
233 <        if (!qtAllocLeaves(DisplayWidth(ourdisplay,ourscreen) *
234 <                        DisplayHeight(ourdisplay,ourscreen) * 3 /
172 <                        (qtMinNodesiz*qtMinNodesiz*2)))
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);
176 –                                        /* initialize cone array */
177 –        initcones();
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;
189 –        qtFreeLeaves();
254          tmDone(NULL);
191 –        freecones();
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 <        if (nv->type == VT_PAR ||               /* check view legality */
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;
# Line 207 | Line 280 | register VIEW  *nv;
280                  nv->vert = odev.v.vert;
281                  return(0);
282          }
210 –        if (nv->vfore > FTINY) {
211 –                error(COMMAND, "cannot handle fore clipping");
212 –                nv->vfore = 0.;
213 –                return(0);
214 –        }
283          if (nv != &odev.v) {
284 <                if (!FEQ(nv->horiz,odev.v.horiz) ||     /* resize window? */
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 *
# Line 235 | Line 307 | register VIEW  *nv;
307                          XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
308                          dev_input();    /* get resize event */
309                  }
310 <                copystruct(&odev.v, nv);
310 >                copystruct(&odev.v, nv);        /* setview() already called */
311          }
312 <        if (nxtzmax > FTINY) {
313 <                curzmax = nxtzmax;
314 <                nxtzmax = 0.;
315 <        }
316 <        glClear(GL_DEPTH_BUFFER_BIT);
317 <        qtReplant();
312 > #ifdef STEREO
313 >        copystruct(&vwright, nv);
314 >        d = eyesepdist / sqrt(nv->hn2);
315 >        VSUM(vwright.vp, nv->vp, nv->hvec, d);
316 >        /* setview(&vwright);   -- Unnecessary */
317 > #endif
318 >        wipeclean();
319          return(1);
320   }
321  
322  
323 + dev_section(gfn, pfn)           /* add octree for geometry rendering */
324 + char    *gfn, *pfn;
325 + {
326 +        /* unimplemented */
327 + }
328 +
329 +
330 + dev_auxcom(cmd, args)           /* process an auxiliary command */
331 + char    *cmd, *args;
332 + {
333 + #ifdef DOBJ
334 +        if (dobj_command(cmd, args) >= 0)
335 +                return;
336 + #endif
337 +        sprintf(errmsg, "%s: unknown command", cmd);
338 +        error(COMMAND, errmsg);
339 + }
340 +
341 +
342 + VIEW *
343 + dev_auxview(n, hvres)           /* return nth auxiliary view */
344 + int     n;
345 + int     hvres[2];
346 + {
347 +        hvres[0] = odev.hres; hvres[1] = odev.vres;
348 +        if (n == 0)
349 +                return(&odev.v);
350 + #ifdef STEREO
351 +        if (n == 1)
352 +                return(&vwright);
353 + #endif
354 +        return(NULL);
355 + }
356 +
357 +
358   int
359   dev_input()                     /* get X11 input */
360   {
# Line 255 | Line 363 | dev_input()                    /* get X11 input */
363          do
364                  getevent();
365  
366 <        while (XQLength(ourdisplay) > 0);
366 >        while (XPending(ourdisplay) > 0);
367  
368 +        odev.inpready = 0;
369 +
370          return(inpresflags);
371   }
372  
373  
374 + dev_value(c, d, p)              /* add a pixel value to our mesh */
375 + COLR    c;
376 + FVECT   d, p;
377 + {
378 +        double  depth;
379 + #ifdef DOBJ
380 +        if (dobj_lightsamp != NULL) {   /* in light source sampling */
381 +                (*dobj_lightsamp)(c, d, p);
382 +                return;
383 +        }
384 + #endif
385 +        if (p != NULL) {                /* add depth to our range */
386 +                depth = (p[0] - odev.v.vp[0])*d[0] +
387 +                        (p[1] - odev.v.vp[1])*d[1] +
388 +                        (p[2] - odev.v.vp[2])*d[2];
389 +                if (depth > FTINY) {
390 +                        if (depth < mindpth)
391 +                                mindpth = depth;
392 +                        if (depth > maxdpth)
393 +                                maxdpth = depth;
394 +                }
395 +        }
396 +        smNewSamp(c, d, p);             /* add to display representation */
397 +        if (!--rayqleft)
398 +                dev_flush();            /* flush output */
399 + }
400 +
401 +
402   int
403   dev_flush()                     /* flush output */
404   {
405 <        qtUpdate();
406 <        glFlush();
405 >        if (mapped) {
406 > #ifdef STEREO
407 >                pushright();                    /* update right eye */
408 >                smUpdate(&vwright, 100);
409 > #ifdef DOBJ
410 >                dobj_render();                  /* usually in foreground */
411 > #endif
412 >                popright();                     /* update left eye */
413 > #endif
414 >                smUpdate(&odev.v, 100);
415 >                checkglerr("rendering mesh");
416 > #ifdef DOBJ
417 >                dobj_render();
418 > #endif
419 >                glFlush();                      /* flush OGL */
420 >        }
421          rayqleft = RAYQLEN;
422 <        return(XPending(ourdisplay));
422 >                                        /* flush X11 and return # pending */
423 >        return(odev.inpready = XPending(ourdisplay));
424   }
425  
426  
427 < dev_cone(rgb, ip, rad)          /* render a cone in view coordinates */
428 < BYTE    rgb[3];
276 < FVECT   ip;
277 < double  rad;
427 > checkglerr(where)               /* check for GL or GLU error */
428 > char    *where;
429   {
430 <        register int    ci, j;
431 <        double  apexh, basez;
432 <                                        /* is window mapped? */
433 <        if (!mapped)
434 <                return;
435 <                                        /* compute apex height (0. to 1.) */
285 <        if (ip[2] > 1e6)
286 <                apexh = 1. - 1./DEPTHFACT;
287 <        else {
288 <                if (ip[2] > nxtzmax)
289 <                        nxtzmax = ip[2];
290 <                if (ip[2] >= curzmax)
291 <                        apexh = 1. - 1./DEPTHFACT;
292 <                else
293 <                        apexh = 1. - ip[2]/(curzmax*DEPTHFACT);
430 >        register GLenum errcode;
431 >
432 >        while ((errcode = glGetError()) != GL_NO_ERROR) {
433 >                sprintf(errmsg, "OpenGL error %s: %s",
434 >                                where, gluErrorString(errcode));
435 >                error(WARNING, errmsg);
436          }
295 –        rad *= 1.25;                    /* find conservative cone match */
296 –        for (ci = 0; ci < MAXCONE-1; ci++)
297 –                if (cone[ci].rad >= rad)
298 –                        break;
299 –                                        /* draw it */
300 –        glColor3ub(rgb[0], rgb[1], rgb[2]);
301 –        glBegin(GL_TRIANGLE_FAN);
302 –        glVertex3d(ip[0], ip[1], apexh);        /* start with apex */
303 –        basez = apexh*cone[ci].va[0][2];        /* base z's all the same */
304 –        for (j = 0; j < cone[ci].nverts; j++)   /* draw each face */
305 –                glVertex3d(ip[0]+cone[ci].va[j][0], ip[1]+cone[ci].va[j][1],
306 –                                basez);
307 –                                                /* connect last to first */
308 –        glVertex3d(ip[0]+cone[ci].va[0][0], ip[1]+cone[ci].va[0][1], basez);
309 –        glEnd();                                /* all done */
437   }
438  
439  
440 + #ifdef STEREO
441 + static
442 + pushright()                     /* push on right view */
443 + {
444 +        double  d;
445 +
446 +        setstereobuf(STEREO_BUFFER_RIGHT);
447 +        glMatrixMode(GL_MODELVIEW);
448 +        glPushMatrix();
449 +        d = -eyesepdist / sqrt(odev.v.hn2);
450 +        glTranslated(d*odev.v.hvec[0], d*odev.v.hvec[1], d*odev.v.hvec[2]);
451 +        checkglerr("setting right view");
452 + }
453 +
454 +
455 + static
456 + popright()                      /* pop off right view */
457 + {
458 +        glMatrixMode(GL_MODELVIEW);
459 +        glPopMatrix();
460 +        setstereobuf(STEREO_BUFFER_LEFT);
461 + }
462 + #endif
463 +
464 +
465   static int
466   mytmflags()                     /* figure out tone mapping flags */
467   {
# Line 321 | Line 473 | mytmflags()                    /* figure out tone mapping flags */
473                          tail = cp+1;
474          for (cp = tail; *cp && *cp != '.'; cp++)
475                  ;
476 <        if (cp-tail == 3 && !strncmp(tail, "glx", 3))
325 <                return(TM_F_CAMERA|TM_F_NOSTDERR);
326 <        if (cp-tail == 4 && !strncmp(tail, "glxh", 4))
476 >        if (cp > tail && cp[-1] == 'h')
477                  return(TM_F_HUMAN|TM_F_NOSTDERR);
478 <        error(USER, "illegal driver name");
478 >        else
479 >                return(TM_F_CAMERA|TM_F_NOSTDERR);
480   }
481  
482  
483   static
333 – initcones()                     /* initialize cone vertices */
334 – {
335 –        register int    i, j;
336 –        double  minrad, d;
337 –
338 –        if (cone[0].nverts)
339 –                freecones();
340 –        minrad = 2.*qtMinNodesiz/(double)(DisplayWidth(ourdisplay,ourscreen) +
341 –                                        DisplayHeight(ourdisplay,ourscreen));
342 –        for (i = 0; i < MAXCONE; i++) {
343 –                d = (double)i/(MAXCONE-1); d *= d;      /* x^2 distribution */
344 –                cone[i].rad = minrad + (1.-minrad)*d;
345 –                cone[i].nverts = MINVERT + (MAXVERT-MINVERT)*d;
346 –                cone[i].va = (FVECT *)malloc(cone[i].nverts*sizeof(FVECT));
347 –                if (cone[i].va == NULL)
348 –                        error(SYSTEM, "out of memory in initcones");
349 –                for (j = cone[i].nverts; j--; ) {
350 –                        d = 2.*PI * (j+.5) / (cone[i].nverts);
351 –                        cone[i].va[j][0] = cos(d) * cone[i].rad;
352 –                        cone[i].va[j][1] = sin(d) * cone[i].rad;
353 –                        cone[i].va[j][2] = 1. - cone[i].rad;
354 –                }
355 –        }
356 – }
357 –
358 –
359 – static
360 – freecones()                     /* free cone vertices */
361 – {
362 –        register int    i;
363 –
364 –        for (i = MAXCONE; i--; )
365 –                if (cone[i].nverts) {
366 –                        free((char *)cone[i].va);
367 –                        cone[i].va = NULL;
368 –                        cone[i].nverts = 0;
369 –                }
370 – }
371 –
372 –
373 – static
484   getevent()                      /* get next event */
485   {
486          XNextEvent(ourdisplay, levptr(XEvent));
# Line 391 | Line 501 | getevent()                     /* get next event */
501                  getkey(levptr(XKeyPressedEvent));
502                  break;
503          case ButtonPress:
504 <                getmove(levptr(XButtonPressedEvent));
504 >                if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
505 >                        getframe(levptr(XButtonPressedEvent));
506 >                else
507 >                        getmove(levptr(XButtonPressedEvent));
508                  break;
509          }
510   }
# Line 407 | Line 520 | register FVECT wp[2];
520  
521  
522   static
523 < draw_grids()                    /* draw holodeck section grids */
523 > draw_grids(fore)                /* draw holodeck section grids */
524 > int     fore;
525   {
526 <        static BYTE     gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
527 <        double  xmin, xmax, ymin, ymax, zmin, zmax;
528 <        double  d, cx, sx, crad;
529 <        FVECT   vx, vy;
416 <        register int    i, j;
417 <                                        /* can we even do it? */
418 <        if (!mapped || odev.v.type != VT_PER)
419 <                return;
420 <                                        /* compute view frustum */
421 <        if (normalize(odev.v.vdir) == 0.0)
422 <                return;
423 <        zmin = 0.01;
424 <        zmax = 10000.;
425 <        if (odev.v.vfore > FTINY)
426 <                zmin = odev.v.vfore;
427 <        if (odev.v.vaft > FTINY)
428 <                zmax = odev.v.vaft;
429 <        xmax = zmin * tan(PI/180./2. * odev.v.horiz);
430 <        xmin = -xmax;
431 <        d = odev.v.hoff * (xmax - xmin);
432 <        xmin += d; xmax += d;
433 <        ymax = zmin * tan(PI/180./2. * odev.v.vert);
434 <        ymin = -ymax;
435 <        d = odev.v.voff * (ymax - ymin);
436 <        ymin += d; ymax += d;
437 <                                        /* set view matrix */
438 <        glMatrixMode(GL_PROJECTION);
439 <        glPushMatrix();
440 <        glLoadIdentity();
441 <        glFrustum(xmin, xmax, ymin, ymax, zmin, zmax);
442 <        gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
443 <                odev.v.vp[0] + odev.v.vdir[0],
444 <                odev.v.vp[1] + odev.v.vdir[1],
445 <                odev.v.vp[2] + odev.v.vdir[2],
446 <                odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
447 <        glDisable(GL_DEPTH_TEST);       /* write no depth values */
448 <        glColor4ub(gridrgba[0], gridrgba[1], gridrgba[2], gridrgba[3]);
526 >        if (fore)
527 >                glColor4ub(0, 255, 255, 0);
528 >        else
529 >                glColor4ub(0, 0, 0, 0);
530          glBegin(GL_LINES);              /* draw each grid line */
531          gridlines(draw3dline);
532          glEnd();
533 <        glEnable(GL_DEPTH_TEST);        /* restore rendering params */
453 <        glPopMatrix();
533 >        checkglerr("drawing grid lines");
534   }
535  
536  
# Line 459 | Line 539 | moveview(dx, dy, mov, orb)     /* move our view */
539   int     dx, dy, mov, orb;
540   {
541          VIEW    nv;
542 <        FVECT   odir, v1;
542 >        FVECT   odir, v1, wip;
543          double  d;
544          register int    li;
545                                  /* start with old view */
546          copystruct(&nv, &odev.v);
547 <                                /* change view direction */
548 <        if (mov | orb) {
549 <                if ((li = qtFindLeaf(dx, dy)) < 0)
547 >                                /* orient our motion */
548 >        if (viewray(v1, odir, &odev.v,
549 >                        (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
550 >                return(0);              /* outside view */
551 >        if (mov | orb) {        /* moving relative to geometry */
552 > #ifdef DOBJ
553 >                d = dobj_trace(NULL, v1, odir); /* check objects */
554 >                                                /* check holodeck */
555 >                if ((li = smFindSamp(v1, odir)) >= 0) {
556 >                        VCOPY(wip, rsL.wp[li]);
557 >                        if (d < .99*FHUGE && d*d <= dist2(v1, wip))
558 >                                li = -1;        /* object is closer */
559 >                } else if (d >= .99*FHUGE)
560 >                        return(0);              /* nothing visible */
561 >                if (li < 0)
562 >                        VSUM(wip, v1, odir, d); /* else get object point */
563 > #else
564 >                if ((li = smFindSamp(v1, odir)) < 0)
565                          return(0);      /* not on window */
566 <                VSUM(odir, qtL.wp[li], nv.vp, -1.);
567 <        } else {
568 <                if (viewray(nv.vp, nv.vdir, &odev.v,
569 <                                (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
570 <                        return(0);      /* outside view */
571 <        }
566 >                VCOPY(wip, rsL.wp[li]);
567 > #endif
568 > #ifdef DEBUG
569 >                fprintf(stderr, "moveview: hit %s at (%f,%f,%f) (t=%f)\n",
570 >                                li < 0 ? "object" : "mesh",
571 >                                wip[0], wip[1], wip[2],
572 >                                (wip[0]-odev.v.vp[0])*odir[0] +
573 >                                (wip[1]-odev.v.vp[1])*odir[1] +
574 >                                (wip[2]-odev.v.vp[2])*odir[2]);
575 > #endif
576 >                VSUM(odir, wip, odev.v.vp, -1.);
577 >        } else                  /* panning with constant viewpoint */
578 >                VCOPY(nv.vdir, odir);
579          if (orb && mov) {               /* orbit left/right */
580                  spinvector(odir, odir, nv.vup, d=MOVDEG*PI/180.*mov);
581 <                VSUM(nv.vp, qtL.wp[li], odir, -1.);
581 >                VSUM(nv.vp, wip, odir, -1.);
582                  spinvector(nv.vdir, nv.vdir, nv.vup, d);
583          } else if (orb) {               /* orbit up/down */
584                  fcross(v1, odir, nv.vup);
585                  if (normalize(v1) == 0.)
586                          return(0);
587                  spinvector(odir, odir, v1, d=MOVDEG*PI/180.*orb);
588 <                VSUM(nv.vp, qtL.wp[li], odir, -1.);
588 >                VSUM(nv.vp, wip, odir, -1.);
589                  spinvector(nv.vdir, nv.vdir, v1, d);
590          } else if (mov) {               /* move forward/backward */
591                  d = MOVPCT/100. * mov;
# Line 491 | Line 593 | int    dx, dy, mov, orb;
593          }
594          if (!mov ^ !orb && headlocked) {        /* restore head height */
595                  VSUM(v1, odev.v.vp, nv.vp, -1.);
596 <                d = DOT(v1, odev.v.vup);
596 >                d = DOT(v1, nv.vup);
597                  VSUM(nv.vp, nv.vp, odev.v.vup, d);
598          }
599          if (setview(&nv) != NULL)
# Line 503 | Line 605 | int    dx, dy, mov, orb;
605  
606  
607   static
608 + getframe(ebut)                          /* get focus frame */
609 + XButtonPressedEvent     *ebut;
610 + {
611 +        int     startx = ebut->x, starty = ebut->y;
612 +        int     endx, endy;
613 +
614 +        XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
615 +        endx = levptr(XButtonReleasedEvent)->x;
616 +        endy = levptr(XButtonReleasedEvent)->y;
617 +        if (endx == startx | endy == starty) {
618 +                XBell(ourdisplay, 0);
619 +                return;
620 +        }
621 +        if (endx < startx) {register int c = endx; endx = startx; startx = c;}
622 +        if (endy < starty) {register int c = endy; endy = starty; starty = c;}
623 +        sprintf(odev_args, "%.3f %.3f %.3f %.3f",
624 +                        (startx+.5)/odev.hres, 1.-(endy+.5)/odev.vres,
625 +                        (endx+.5)/odev.hres, 1.-(starty+.5)/odev.vres);
626 +        inpresflags |= DFL(DC_FOCUS);
627 + }
628 +
629 +
630 + static
631   getmove(ebut)                           /* get view change */
632   XButtonPressedEvent     *ebut;
633   {
634          int     movdir = MOVDIR(ebut->button);
635          int     movorb = MOVORB(ebut->state);
636 <        int     oldnodesiz = qtMinNodesiz;
636 >        int     qlevel = 99;
637 >        time_t  lasttime, thistime;
638 >        int     nframes;
639          Window  rootw, childw;
640          int     rootx, rooty, wx, wy;
641          unsigned int    statemask;
642  
643 <        qtMinNodesiz = 24;              /* accelerate update rate */
517 <        XNoOp(ourdisplay);
643 >        XNoOp(ourdisplay);              /* makes sure we're not idle */
644  
645 +        lasttime = time(0); nframes = 0;
646          while (!XCheckMaskEvent(ourdisplay,
647                          ButtonReleaseMask, levptr(XEvent))) {
648 <
648 >                                        /* get cursor position */
649                  if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
650                                  &rootx, &rooty, &wx, &wy, &statemask))
651                          break;          /* on another screen */
652  
653 +                draw_grids(0);          /* clear old grid lines */
654 + #ifdef STEREO
655 +                pushright(); draw_grids(0); popright();
656 + #endif
657 +                                        /* compute view motion */
658                  if (!moveview(wx, odev.vres-1-wy, movdir, movorb)) {
659                          sleep(1);
660 <                        continue;
660 >                        lasttime++;
661 >                        continue;       /* cursor in bad place */
662                  }
663 <                glClear(GL_COLOR_BUFFER_BIT);
664 <                qtUpdate();
665 <                draw_grids();
663 >                draw_grids(1);          /* redraw grid */
664 > #ifdef STEREO
665 >                pushright();
666 >                draw_grids(1);
667 >                smUpdate(&vwright, qlevel);
668 > #ifdef DOBJ
669 >                dobj_render();
670 > #endif
671 >                popright();
672 > #endif
673 >                                        /* redraw mesh */
674 >                smUpdate(&odev.v, qlevel);
675 > #ifdef DOBJ
676 >                dobj_render();          /* redraw object */
677 > #endif
678                  glFlush();
679 +                nframes++;              /* figure out good quality level */
680 +                thistime = time(0);
681 +                if (thistime - lasttime >= 3 ||
682 +                                nframes > (int)(3*3*TARGETFPS)) {
683 +                        qlevel = thistime<=lasttime ? 1000 :
684 +                                (int)((double)nframes/(thistime-lasttime)
685 +                                        / TARGETFPS * qlevel + 0.5);
686 +                        lasttime = thistime; nframes = 0;
687 +                        if (qlevel > 99) {
688 +                                if (qlevel > 300) {     /* put on the brakes */
689 +                                        sleep(1);
690 +                                        lasttime++;
691 +                                }
692 +                                qlevel = 99;
693 +                        } else if (qlevel < 1)
694 +                                qlevel = 1;
695 +                }
696          }
697          if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
698                  movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
# Line 538 | Line 700 | XButtonPressedEvent    *ebut;
700                  wy = levptr(XButtonReleasedEvent)->y;
701                  moveview(wx, odev.vres-1-wy, movdir, movorb);
702          }
703 <        dev_flush();
703 > }
704  
705 <        qtMinNodesiz = oldnodesiz;      /* restore quadtree resolution */
705 >
706 > static
707 > setglpersp(vp)                  /* set perspective view in GL */
708 > register VIEW   *vp;
709 > {
710 >        double  d, xmin, xmax, ymin, ymax;
711 >
712 >        if (mindpth >= maxdpth) {
713 >                dev_zmin = 1.;
714 >                dev_zmax = 100.;
715 >        } else {
716 >                dev_zmin = 0.5*mindpth;
717 >                dev_zmax = 5.0*maxdpth;
718 >        }
719 >        if (odev.v.vfore > FTINY)
720 >                dev_zmin = odev.v.vfore;
721 >        if (odev.v.vaft > FTINY)
722 >                dev_zmax = odev.v.vaft;
723 >        if (dev_zmin < dev_zmax/100.)
724 >                dev_zmin = dev_zmax/100.;
725 >        xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
726 >        xmin = -xmax;
727 >        d = odev.v.hoff * (xmax - xmin);
728 >        xmin += d; xmax += d;
729 >        ymax = dev_zmin * tan(PI/180./2. * odev.v.vert);
730 >        ymin = -ymax;
731 >        d = odev.v.voff * (ymax - ymin);
732 >        ymin += d; ymax += d;
733 >                                        /* set view matrix */
734 >        glMatrixMode(GL_PROJECTION);
735 >        glLoadIdentity();
736 >        glFrustum(xmin, xmax, ymin, ymax, dev_zmin, dev_zmax);
737 >        gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
738 >                odev.v.vp[0] + odev.v.vdir[0],
739 >                odev.v.vp[1] + odev.v.vdir[1],
740 >                odev.v.vp[2] + odev.v.vdir[2],
741 >                odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
742 >        checkglerr("setting perspective view");
743   }
744  
745  
746   static
747 + wipeclean()                     /* prepare for redraw */
748 + {
749 +                                        /* clear depth buffer */
750 + #ifdef STEREO
751 +        setstereobuf(STEREO_BUFFER_RIGHT);
752 +        glClear(GL_DEPTH_BUFFER_BIT);
753 +        setstereobuf(STEREO_BUFFER_LEFT);
754 + #endif
755 +        glClear(GL_DEPTH_BUFFER_BIT);
756 +        smClean();                      /* reset drawing routines */
757 +        setglpersp(&odev.v);            /* reset view & clipping planes */
758 + }
759 +
760 +
761 + static
762   getkey(ekey)                            /* get input key */
763   register XKeyPressedEvent  *ekey;
764   {
765 +        Window  rootw, childw;
766 +        int     rootx, rooty, wx, wy;
767 +        unsigned int    statemask;
768          int  n;
769          char    buf[8];
770  
# Line 570 | Line 787 | register XKeyPressedEvent  *ekey;
787          case 'v':                       /* spit out view */
788                  inpresflags |= DFL(DC_GETVIEW);
789                  return;
790 +        case 'f':                       /* frame view position */
791 +                if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
792 +                                &rootx, &rooty, &wx, &wy, &statemask))
793 +                        return;         /* on another screen */
794 +                sprintf(odev_args, "%.4f %.4f", (wx+.5)/odev.hres,
795 +                                1.-(wy+.5)/odev.vres);
796 +                inpresflags |= DFL(DC_FOCUS);
797 +                return;
798 +        case 'F':                       /* unfocus */
799 +                odev_args[0] = '\0';
800 +                inpresflags |= DFL(DC_FOCUS);
801 +                return;
802          case '\n':
803          case '\r':                      /* resume computation */
804                  inpresflags |= DFL(DC_RESUME);
805                  return;
806          case CTRL('R'):                 /* redraw screen */
807 <                if (nxtzmax > FTINY) {
579 <                        curzmax = nxtzmax;
580 <                        nxtzmax = 0.;
581 <                }
582 <                glClear(GL_DEPTH_BUFFER_BIT);
583 <                qtRedraw(0, 0, odev.hres, odev.vres);
807 >                wipeclean();
808                  return;
809          case CTRL('L'):                 /* refresh from server */
810                  if (inpresflags & DFL(DC_REDRAW))
811                          return;
812 <                if (nxtzmax > FTINY) {
589 <                        curzmax = nxtzmax;
590 <                        nxtzmax = 0.;
591 <                }
812 >                setglpersp(&odev.v);            /* reset clipping planes */
813                  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
814 <                draw_grids();
814 >                glDisable(GL_DEPTH_TEST);       /* so grids will clear */
815 >                draw_grids(1);
816 > #ifdef STEREO
817 >                pushright();
818 >                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
819 >                draw_grids(1);
820 >                popright();
821 > #endif
822 >                glEnable(GL_DEPTH_TEST);
823                  glFlush();
824 <                qtCompost(100);                 /* get rid of old values */
824 >                smInit(rsL.max_samp);           /* get rid of old values */
825                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
826 +                rayqleft = 0;                   /* hold off update */
827                  return;
828          case 'K':                       /* kill rtrace process(es) */
829                  inpresflags |= DFL(DC_KILL);
# Line 618 | Line 848 | static
848   fixwindow(eexp)                         /* repair damage to window */
849   register XExposeEvent  *eexp;
850   {
851 <        int     xmin, xmax, ymin, ymax;
622 <
623 <        if (odev.hres == 0 || odev.vres == 0)   /* first exposure */
851 >        if (odev.hres == 0 | odev.vres == 0) {  /* first exposure */
852                  resizewindow((XConfigureEvent *)eexp);
853 <        xmin = eexp->x; xmax = eexp->x + eexp->width;
854 <        ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
855 <                                                /* clear portion of depth */
856 <        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
857 <        glDepthFunc(GL_ALWAYS);
630 <        glBegin(GL_POLYGON);
631 <        glVertex3d((double)xmin/odev.hres, (double)ymin/odev.vres, 0.);
632 <        glVertex3d((double)xmax/odev.hres, (double)ymin/odev.vres, 0.);
633 <        glVertex3d((double)xmax/odev.hres, (double)ymax/odev.vres, 0.);
634 <        glVertex3d((double)xmin/odev.hres, (double)ymax/odev.vres, 0.);
635 <        glEnd();
636 <        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
637 <        glDepthFunc(GL_LEQUAL);
638 <        qtRedraw(xmin, ymin, xmax, ymax);
853 >                return;
854 >        }
855 >        if (eexp->count)                /* wait for final exposure */
856 >                return;
857 >        wipeclean();                    /* clear depth */
858   }
859  
860  

Diff Legend

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