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

Comparing ray/src/hd/rhd_ogl.c (file contents):
Revision 3.1 by gwlarson, Fri Dec 18 11:55:19 1998 UTC vs.
Revision 3.24 by schorsch, Thu Jan 1 11:21:55 2004 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * OpenGL driver for holodeck display.
6   * Based on GLX driver using T-mesh.
# Line 20 | Line 17 | static char SCCSid[] = "$SunId$ SGI";
17   #endif
18   #endif
19  
23 – #include "standard.h"
20  
21 < #include <sys/types.h>
21 > #include <time.h>
22   #include <GL/glx.h>
23   #include <GL/glu.h>
24   #ifdef STEREO
25   #include <X11/extensions/SGIStereo.h>
26   #endif
27  
28 + #include "standard.h"
29   #include "rhd_odraw.h"
30 + #include "rhdisp.h"
31   #ifdef DOBJ
32   #include "rhdobj.h"
33   #endif
# Line 37 | Line 35 | static char SCCSid[] = "$SunId$ SGI";
35   #include "x11icon.h"
36  
37   #ifndef RAYQLEN
38 < #define RAYQLEN         10240           /* max. rays to queue before flush */
38 > #define RAYQLEN         0               /* max. rays to queue before flush */
39   #endif
40 + #ifndef MINWIDTH
41 + #define MINWIDTH        480             /* minimum graphics window width */
42 + #define MINHEIGHT       400             /* minimum graphics window height */
43 + #endif
44 + #ifndef VIEWDIST
45 + #define VIEWDIST        356             /* assumed viewing distance (mm) */
46 + #endif
47 + #ifndef BORWIDTH
48 + #define BORWIDTH        5               /* border width */
49 + #endif
50  
51   #ifndef FEQ
52   #define FEQ(a,b)        ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
53   #endif
54  
55 + #define VWHEADLOCK      01              /* head position is locked flag */
56 + #define VWPERSP         02              /* perspective view is set */
57 + #define VWORTHO         04              /* orthographic view is set */
58 + #define VWCHANGE        010             /* view has changed */
59 + #define VWSTEADY        020             /* view is now steady */
60 + #define VWMAPPED        040             /* window is mapped */
61 +
62   #define GAMMA           1.4             /* default gamma correction */
63  
64   #define FRAMESTATE(s)   (((s)&(ShiftMask|ControlMask))==(ShiftMask|ControlMask))
# Line 53 | Line 68 | static char SCCSid[] = "$SunId$ SGI";
68   #define MOVDEG          (-5)            /* degrees to orbit CW/down /frame */
69   #define MOVORB(s)       ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
70  
56 – #define MINWIDTH        480             /* minimum graphics window width */
57 – #define MINHEIGHT       400             /* minimum graphics window height */
58 –
59 – #define VIEWDIST        356             /* assumed viewing distance (mm) */
60 –
61 – #define BORWIDTH        5               /* border width */
62 –
71   #define setstereobuf(bid)       (glXWaitGL(), \
72                                  XSGISetStereoBuffer(ourdisplay, gwind, bid), \
73                                  glXWaitX())
# Line 86 | Line 94 | static int     rayqleft = 0;           /* rays left to queue before
94  
95   static XEvent  currentevent;            /* current event */
96  
89 – static int  mapped = 0;                 /* window is mapped? */
97   static unsigned long  ourblack=0, ourwhite=~0;
98  
99   static Display  *ourdisplay = NULL;     /* our display */
# Line 104 | Line 111 | static double  dev_zrat;               /* (1. - dev_zmin/dev_zmax) *
111  
112   static int      inpresflags;            /* input result flags */
113  
114 < static int      headlocked;             /* lock vertical motion */
114 > static int      viewflags;              /* what's happening with view */
115  
116 < static int      isperspective;          /* perspective/ortho view */
110 <
111 < static int      viewsteady;             /* is view steady? */
112 <
116 > /*
117   static int  resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
118 <                xferdepth(), setglortho(),
118 >                xferdepth(), freedepth(), setglortho(),
119                  setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
120  
121   static double   getdistance();
122 + */
123 + static void checkglerr(char *where);
124 + static void xferdepth(void);
125 + static void freedepth(void);
126 + static double getdistance(int dx, int dy, FVECT direc);
127 + static int mytmflags(void);
128 + static void getevent(void);
129 + static void draw3dline(register FVECT wp[2]);
130 + static void draw_grids(int fore);
131 + static int moveview(int dx, int dy, int mov, int orb);
132 + static void getframe(XButtonPressedEvent *ebut);
133 + static void getmove(XButtonPressedEvent *ebut);
134 + static void getkey(register XKeyPressedEvent *ekey);
135 + static void fixwindow(register XExposeEvent *eexp);
136 + static void resizewindow(register XConfigureEvent *ersz);
137 + static void waitabit(void);
138 + static void setglpersp(void);
139 + static void setglortho(void);
140 + static void wipeclean(void);
141  
142 +
143   #ifdef STEREO
144 < static int  pushright(), popright();
144 > static void pushright(void);
145 > static void popright(void);
146   #endif
147  
148 + extern int      gmPortals;      /* GL portal list id */
149 +
150   extern time_t   time();
151  
152  
153 + extern void
154   dev_open(id)                    /* initialize GLX driver */
155   char  *id;
156   {
157          extern char     *getenv();
158          static RGBPRIMS myprims = STDPRIMS;
159 <        static int      atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
160 <                                GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
161 <                                GLX_DEPTH_SIZE,15, None};
159 >        static int      atlBest[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
160 >                                GLX_RED_SIZE,8, GLX_GREEN_SIZE,8,
161 >                                GLX_BLUE_SIZE,8, GLX_DEPTH_SIZE,15, None};
162 >        static int      atlOK[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
163 >                                GLX_RED_SIZE,4, GLX_GREEN_SIZE,4,
164 >                                GLX_BLUE_SIZE,4, GLX_DEPTH_SIZE,15, None};
165          char    *ev;
166          double  gamval = GAMMA;
167          RGBPRIMP        dpri = stdprims;
# Line 143 | Line 174 | char  *id;
174   #endif
175                                          /* open display server */
176          ourdisplay = XOpenDisplay(NULL);
177 <        if (ourdisplay == NULL)
178 <                error(USER, "cannot open X-windows; DISPLAY variable set?\n");
177 >        CHECK(ourdisplay==NULL, USER,
178 >                        "cannot open X-windows; DISPLAY variable set?");
179   #ifdef STEREO
180          switch (XSGIQueryStereoMode(ourdisplay, ourroot)) {
181          case STEREO_TOP:
# Line 152 | Line 183 | char  *id;
183                  break;
184          case STEREO_OFF:
185                  error(USER,
186 <        "wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
186 >                "wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
187          case X_STEREO_UNSUPPORTED:
188                  error(USER, "stereo mode not supported on this screen");
189          default:
# Line 162 | Line 193 | char  *id;
193                                          /* find a usable visual */
194          ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
195          if (ourvinf == NULL)
196 <                error(USER, "no suitable visuals available");
196 >                ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlOK);
197 >        CHECK(ourvinf==NULL, USER, "no suitable visuals available");
198                                          /* get a context */
199          gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
200                                          /* set gamma and tone mapping */
# Line 194 | Line 226 | char  *id;
226   #endif
227                  BORWIDTH, ourvinf->depth, InputOutput, ourvinf->visual,
228                  CWBackPixel|CWBorderPixel|CWColormap|CWEventMask, &ourwinattr);
229 <        if (gwind == 0)
198 <                error(SYSTEM, "cannot create window\n");
229 >        CHECK(gwind==0, SYSTEM, "cannot create window");
230          XStoreName(ourdisplay, gwind, id);
231                                          /* set window manager hints */
232          ourxwmhints.flags = InputHint|IconPixmapHint;
# Line 219 | Line 250 | char  *id;
250          glXMakeCurrent(ourdisplay, gwind, gctx);
251          glEnable(GL_DEPTH_TEST);
252          glDepthFunc(GL_LEQUAL);
253 <        glDisable(GL_DITHER);
253 >        glClearColor(0, 0, 0, 0);
254          glFrontFace(GL_CCW);
255          glDisable(GL_CULL_FACE);
256          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
257          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
258 +        glPixelStorei(GL_PACK_ALIGNMENT, 1);
259 +        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
260                                          /* figure out sensible view */
261          pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
262                          DisplayWidth(ourdisplay, ourscreen);
# Line 234 | Line 267 | char  *id;
267          setstereobuf(STEREO_BUFFER_LEFT);
268   #endif
269          checkglerr("setting rendering parameters");
270 <        copystruct(&odev.v, &stdview);
270 >        odev.v = stdview;
271          odev.v.type = VT_PER;
272 <        headlocked = 0;                 /* free up head movement */
240 <        viewsteady = 1;                 /* view starts static */
241 <        isperspective = -1;             /* but no view set, yet */
272 >        viewflags = VWSTEADY;           /* view starts static */
273                                          /* map the window */
274          XMapWindow(ourdisplay, gwind);
275          dev_input();                    /* sets size and view angles */
276          if (!odInit(DisplayWidth(ourdisplay,ourscreen) *
277 <                        DisplayHeight(ourdisplay,ourscreen) / 10))
277 >                        DisplayHeight(ourdisplay,ourscreen) / 3))
278                  error(SYSTEM, "insufficient memory for value storage");
279          odev.name = id;
280          odev.firstuse = 1;              /* can't recycle samples */
# Line 251 | Line 282 | char  *id;
282   }
283  
284  
285 < dev_close()                     /* close our display and free resources */
285 > extern void
286 > dev_close(void)                 /* close our display and free resources */
287   {
288   #ifdef DOBJ
289          dobj_cleanup();
290   #endif
291 +        freedepth();
292 +        gmEndGeom();
293 +        gmEndPortal();
294          odDone();
295          glXMakeCurrent(ourdisplay, None, NULL);
296          glXDestroyContext(ourdisplay, gctx);
# Line 270 | Line 305 | dev_close()                    /* close our display and free resources
305   }
306  
307  
308 < dev_clear()                     /* clear our representation */
308 > extern void
309 > dev_clear(void)                 /* clear our representation */
310   {
311 <        wipeclean();
311 >        viewflags |= VWCHANGE;          /* pretend our view has changed */
312 >        wipeclean();                    /* clean off display and samples */
313 >        dev_flush();                    /* redraw geometry & get depth */
314          rayqleft = 0;                   /* hold off update */
315   }
316  
317  
318 < int
319 < dev_view(nv)                    /* assign new driver view */
320 < register VIEW   *nv;
318 > extern int
319 > dev_view(                       /* assign new driver view */
320 >        register VIEW   *nv
321 > )
322   {
284 –        double  d;
285 –
323          if (nv->type != VT_PER ||               /* check view legality */
324                          nv->horiz > 160. || nv->vert > 160.) {
325                  error(COMMAND, "illegal view type/angle");
# Line 318 | Line 355 | register VIEW  *nv;
355                          XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
356                          dev_input();    /* get resize event */
357                  }
358 <                copystruct(&odev.v, nv);        /* setview() already called */
358 >                odev.v = *nv;   /* setview() already called */
359 >                viewflags |= VWCHANGE;
360 >        }
361   #ifdef STEREO
362 <                copystruct(&vwright, nv);
363 <                d = eyesepdist / sqrt(nv->hn2);
364 <                VSUM(vwright.vp, nv->vp, nv->hvec, d);
365 <                /* setview(&vwright);   -- Unnecessary */
362 >        vwright = *nv;
363 >        d = eyesepdist / sqrt(nv->hn2);
364 >        VSUM(vwright.vp, nv->vp, nv->hvec, d);
365 >        /* setview(&vwright);   -- Unnecessary */
366   #endif
328 –        } else
329 –                viewsteady = 1;
367          wipeclean();
368          return(1);
369   }
370  
371  
372 < dev_section(ofn)                /* add octree for geometry rendering */
373 < char    *ofn;
372 > extern void
373 > dev_section(            /* add octree for geometry rendering */
374 >        char    *gfn,
375 >        char    *pfn
376 > )
377   {
378 <        extern char     *index();
379 <        char    *cp;
380 <
381 <        if (ofn == NULL)
382 <                otEndOctree();
383 <        else if (access(ofn, R_OK) == 0)
384 <                otNewOctree(ofn);
378 >        if (gfn == NULL) {
379 >                gmEndGeom();
380 >                gmEndPortal();
381 >                wipeclean();            /* new geometry, so redraw it */
382 >                return;
383 >        }
384 >        if (access(gfn, R_OK) == 0)
385 >                gmNewGeom(gfn);
386   #ifdef DEBUG
387          else {
388 <                sprintf(errmsg, "cannot load octree \"%s\"", ofn);
388 >                sprintf(errmsg, "cannot load octree \"%s\"", gfn);
389                  error(WARNING, errmsg);
390          }
391   #endif
392 +        if (pfn != NULL)
393 +                gmNewPortal(pfn);
394   }
395  
396  
397 < dev_auxcom(cmd, args)           /* process an auxiliary command */
398 < char    *cmd, *args;
397 > extern void
398 > dev_auxcom(             /* process an auxiliary command */
399 >        char    *cmd,
400 >        char    *args
401 > )
402   {
403   #ifdef DOBJ
404 <        if (dobj_command(cmd, args) >= 0)
404 >        int     vischange;
405 >
406 >        if ((vischange = dobj_command(cmd, args)) >= 0) {
407 >                if (vischange) {
408 >                        imm_mode = beam_sync(1) > 0;
409 >                        dev_clear();
410 >                }
411                  return;
412 +        }
413   #endif
414          sprintf(errmsg, "%s: unknown command", cmd);
415          error(COMMAND, errmsg);
416   }
417  
418  
419 < VIEW *
420 < dev_auxview(n, hvres)           /* return nth auxiliary view */
421 < int     n;
422 < int     hvres[2];
419 > extern VIEW *
420 > dev_auxview(            /* return nth auxiliary view */
421 >        int     n,
422 >        int     hvres[2]
423 > )
424   {
425          hvres[0] = odev.hres; hvres[1] = odev.vres;
426          if (n == 0)
# Line 379 | Line 433 | int    hvres[2];
433   }
434  
435  
436 < int
437 < dev_input()                     /* get X11 input */
436 > extern int
437 > dev_input(void)                 /* get X11 input */
438   {
439          inpresflags = 0;
440  
# Line 395 | Line 449 | dev_input()                    /* get X11 input */
449   }
450  
451  
452 < dev_value(c, d, p)              /* add a pixel value to our texture */
453 < COLR    c;
454 < FVECT   d, p;
452 > extern void
453 > dev_value(              /* add a pixel value to our texture */
454 >        COLR    c,
455 >        FVECT   d,
456 >        FVECT   p
457 > )
458   {
459   #ifdef DOBJ
460          if (dobj_lightsamp != NULL) {   /* in light source sampling */
# Line 411 | Line 468 | FVECT  d, p;
468   }
469  
470  
471 < int
472 < dev_flush()                     /* flush output as appropriate */
471 > extern int
472 > dev_flush(void)                 /* flush output as appropriate */
473   {
474          int     ndrawn;
475  
476 <        if (mapped && isperspective > 0) {
476 >        if ((viewflags&(VWMAPPED|VWPERSP)) == (VWMAPPED|VWPERSP)) {
477   #ifdef STEREO
478                  pushright();                    /* draw right eye */
479 <                otDrawOctrees();
479 >                ndrawn = gmDrawGeom();
480   #ifdef DOBJ
481 <                dobj_render();
481 >                ndrawn += dobj_render();
482   #endif
483                  checkglerr("rendering right eye");
484                  popright();                     /* draw left eye */
485   #endif
486 <                ndrawn = otDrawOctrees();
486 >                ndrawn = gmDrawGeom();
487   #ifdef DOBJ
488                  ndrawn += dobj_render();
489   #endif
490 +                glXSwapBuffers(ourdisplay, gwind);
491                  checkglerr("rendering base view");
492          }
493 <        if (mapped && viewsteady) {
494 <                if (isperspective) {            /* first time after steady */
493 >        if ((viewflags&(VWMAPPED|VWSTEADY|VWPERSP|VWORTHO)) ==
494 >                        (VWMAPPED|VWSTEADY|VWPERSP)) {
495 >                                        /* first time after steady */
496 >                if (ndrawn)
497 >                        xferdepth();    /* transfer and clear depth */
498 >                setglortho();           /* set orthographic view */
499 >
500 >        }
501 >        if ((viewflags&(VWMAPPED|VWSTEADY|VWPERSP|VWORTHO)) ==
502 >                        (VWMAPPED|VWSTEADY|VWORTHO)) {
503 >                                        /* else update cones */
504   #ifdef STEREO
505 <                        pushright();
506 <                        popright();
505 >                pushright();
506 >                odUpdate(1);            /* draw right eye */
507 >                popright();
508   #endif
509 <                        if (ndrawn)
510 <                                xferdepth();    /* transfer and clear depth */
443 <                        setglortho();           /* set orthographic view */
444 <                } else {
445 < #ifdef STEREO
446 <                        pushright();
447 <                        odUpdate(1);            /* draw right eye */
448 <                        popright();
449 < #endif
450 <                        odUpdate(0);            /* draw left eye */
451 <                }
509 >                odUpdate(0);            /* draw left eye */
510 >                glFlush();              /* flush OpenGL */
511          }
453 –        glFlush();                              /* flush OpenGL */
512          rayqleft = RAYQLEN;
513                                          /* flush X11 and return # pending */
514          return(odev.inpready = XPending(ourdisplay));
515   }
516  
517  
518 < checkglerr(where)               /* check for GL or GLU error */
519 < char    *where;
518 > static void
519 > checkglerr(             /* check for GL or GLU error */
520 >        char    *where
521 > )
522   {
523          register GLenum errcode;
524  
# Line 470 | Line 530 | char   *where;
530   }
531  
532  
533 < static
534 < xferdepth()                     /* load and clear depth buffer */
533 > static void
534 > xferdepth(void)                 /* load and clear depth buffer */
535   {
536          register GLfloat        *dbp;
537 +        register GLubyte        *pbuf;
538  
539 <        if (depthbuffer == NULL) {
539 >        if (depthbuffer == NULL) {      /* allocate private depth buffer */
540   #ifdef STEREO
541                  depthright = (GLfloat *)malloc(
542                                  odev.hres*odev.vres*sizeof(GLfloat));
543   #endif
544                  depthbuffer = (GLfloat *)malloc(
545                                  odev.hres*odev.vres*sizeof(GLfloat));
546 <                if (depthbuffer == NULL)
486 <                        error(SYSTEM, "out of memory in xferdepth");
546 >                CHECK(depthbuffer==NULL, SYSTEM, "out of memory in xferdepth");
547          }
548 +                                /* allocate alpha buffer for portals */
549 +        if (gmPortals)
550 +                pbuf = (GLubyte *)malloc(odev.hres*odev.vres*sizeof(GLubyte));
551 +        else
552 +                pbuf = NULL;
553   #ifdef STEREO
554 <        setstereobuf(STEREO_BUFFER_RIGHT);
554 >        pushright();
555          glReadPixels(0, 0, odev.hres, odev.vres,
556                          GL_DEPTH_COMPONENT, GL_FLOAT, depthright);
557 <        setstereobuf(STEREO_BUFFER_LEFT);
557 >        if (pbuf != NULL) {
558 >                glClear(GL_COLOR_BUFFER_BIT);
559 >                gmDrawPortals(0xff, -1, -1, -1);
560 >                glReadPixels(0, 0, odev.hres, odev.vres,
561 >                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
562 >        }
563          for (dbp = depthright + odev.hres*odev.vres; dbp-- > depthright; )
564 <                *dbp = mapdepth(*dbp);
565 <        odDepthMap(1, depthright);
564 >                if (pbuf != NULL && pbuf[dbp-depthright]&0x40)
565 >                        *dbp = FHUGE;
566 >                else
567 >                        *dbp = mapdepth(*dbp);
568          glClear(GL_DEPTH_BUFFER_BIT);
569 +        odDepthMap(1, depthright);
570 +        popright();
571   #endif
572 +                                /* read back depth buffer */
573          glReadPixels(0, 0, odev.hres, odev.vres,
574                          GL_DEPTH_COMPONENT, GL_FLOAT, depthbuffer);
575 +        if (pbuf != NULL) {
576 +                glClear(GL_COLOR_BUFFER_BIT);           /* find portals */
577 +                gmDrawPortals(0xff, -1, -1, -1);
578 +                glReadPixels(0, 0, odev.hres, odev.vres,
579 +                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
580 + #ifdef DEBUG
581 +                glXSwapBuffers(ourdisplay, gwind);
582 + #endif
583 +        }
584          for (dbp = depthbuffer + odev.hres*odev.vres; dbp-- > depthbuffer; )
585 <                *dbp = mapdepth(*dbp);
585 >                if (pbuf != NULL && pbuf[dbp-depthbuffer]&0x40)
586 >                        *dbp = FHUGE;
587 >                else
588 >                        *dbp = mapdepth(*dbp);
589 >        glClear(GL_DEPTH_BUFFER_BIT);           /* clear system depth buffer */
590          odDepthMap(0, depthbuffer);             /* transfer depth data */
591 <        glClear(GL_DEPTH_BUFFER_BIT);           /* clear system buffer */
591 >        if (pbuf != NULL)
592 >                free((void *)pbuf);             /* free our portal buffer */
593   }
594  
595  
596 + static void
597 + freedepth(void)                         /* free recorded depth buffer */
598 + {
599 +        if (depthbuffer == NULL)
600 +                return;
601 + #ifdef STEREO
602 +        odDepthMap(1, NULL);
603 +        free((void *)depthright);
604 +        depthright = NULL;
605 + #endif
606 +        odDepthMap(0, NULL);
607 +        free((void *)depthbuffer);
608 +        depthbuffer = NULL;
609 + }
610 +
611 +
612   static double
613 < getdistance(dx, dy, direc)      /* distance from fore plane along view ray */
614 < int     dx, dy;
615 < FVECT   direc;
613 > getdistance(    /* distance from fore plane along view ray */
614 >        int     dx,
615 >        int     dy,
616 >        FVECT   direc
617 > )
618   {
619          GLfloat gldepth;
620          double  dist;
621  
622 <        if (dx<0 | dx>=odev.hres | dy<0 | dy>=odev.vres)
622 >        if ((dx<0) | (dx>=odev.hres) | (dy<0) | (dy>=odev.vres))
623                  return(FHUGE);
624          if (depthbuffer != NULL)
625                  dist = depthbuffer[dy*odev.hres + dx];
626          else {
627                  glReadPixels(dx,dy, 1,1, GL_DEPTH_COMPONENT,
628                                  GL_FLOAT, &gldepth);
629 +                if (gldepth <= FTINY)
630 +                        return (FHUGE); /* call failed */
631                  dist = mapdepth(gldepth);
632          }
633          if (dist >= .99*FHUGE)
# Line 528 | Line 637 | FVECT  direc;
637  
638  
639   #ifdef STEREO
640 < static
641 < pushright()                     /* push on right view & buffer */
640 > static void
641 > pushright(void)                 /* push on right view & buffer */
642   {
643          double  d;
644  
645          setstereobuf(STEREO_BUFFER_RIGHT);
646 <        if (isperspective > 0) {
646 >        if (viewflags & VWPERSP) {
647                  glMatrixMode(GL_MODELVIEW);
648                  glPushMatrix();
649                  d = -eyesepdist / sqrt(odev.v.hn2);
# Line 545 | Line 654 | pushright()                    /* push on right view & buffer */
654   }
655  
656  
657 < static
658 < popright()                      /* pop off right view & buffer */
657 > static void
658 > popright(void)                  /* pop off right view & buffer */
659   {
660 <        if (isperspective > 0) {
660 >        if (viewflags & VWPERSP) {
661                  glMatrixMode(GL_MODELVIEW);
662                  glPopMatrix();
663          }
# Line 558 | Line 667 | popright()                     /* pop off right view & buffer */
667  
668  
669   static int
670 < mytmflags()                     /* figure out tone mapping flags */
670 > mytmflags(void)                 /* figure out tone mapping flags */
671   {
672          extern char     *progname;
673          register char   *cp, *tail;
# Line 582 | Line 691 | mytmflags()                    /* figure out tone mapping flags */
691   }
692  
693  
694 < static
695 < getevent()                      /* get next event */
694 > static void
695 > getevent(void)                  /* get next event */
696   {
697          XNextEvent(ourdisplay, levptr(XEvent));
698          switch (levptr(XEvent)->type) {
# Line 591 | Line 700 | getevent()                     /* get next event */
700                  resizewindow(levptr(XConfigureEvent));
701                  break;
702          case UnmapNotify:
703 <                mapped = 0;
703 >                viewflags &= ~VWMAPPED;
704                  break;
705          case MapNotify:
706 <                mapped = 1;
706 >                odRemap(0);
707 >                viewflags |= VWMAPPED;
708                  break;
709          case Expose:
710                  fixwindow(levptr(XExposeEvent));
# Line 612 | Line 722 | getevent()                     /* get next event */
722   }
723  
724  
725 < static
726 < draw3dline(wp)                  /* draw 3d line in world coordinates */
727 < register FVECT  wp[2];
725 > static void
726 > draw3dline(                     /* draw 3d line in world coordinates */
727 >        register FVECT  wp[2]
728 > )
729   {
730          glVertex3d(wp[0][0], wp[0][1], wp[0][2]);
731          glVertex3d(wp[1][0], wp[1][1], wp[1][2]);
732   }
733  
734  
735 < static
736 < draw_grids(fore)                /* draw holodeck section grids */
737 < int     fore;
735 > static void
736 > draw_grids(             /* draw holodeck section grids */
737 >        int     fore
738 > )
739   {
740          glPushAttrib(GL_LIGHTING_BIT|GL_ENABLE_BIT);
741          glDisable(GL_LIGHTING);
742          if (fore)
743 <                glColor3ub(0, 255, 255);
743 >                glColor3ub(4, 250, 250);
744          else
745                  glColor3ub(0, 0, 0);
746          glBegin(GL_LINES);              /* draw each grid line */
# Line 639 | Line 751 | int    fore;
751   }
752  
753  
754 < static
755 < moveview(dx, dy, mov, orb)      /* move our view */
756 < int     dx, dy, mov, orb;
754 > static int
755 > moveview(       /* move our view */
756 >        int     dx,
757 >        int     dy,
758 >        int     mov,
759 >        int     orb
760 > )
761   {
762          VIEW    nv;
763          FVECT   odir, v1, wip;
764          double  d, d1;
649 –        register int    li;
765                                  /* start with old view */
766 <        copystruct(&nv, &odev.v);
766 >        nv = odev.v;
767                                  /* orient our motion */
768          if (viewray(v1, odir, &odev.v,
769                          (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
# Line 681 | Line 796 | int    dx, dy, mov, orb;
796                  d = MOVPCT/100. * mov;
797                  VSUM(nv.vp, nv.vp, odir, d);
798          }
799 <        if (!mov ^ !orb && headlocked) {        /* restore head height */
799 >        if (!mov ^ !orb && viewflags&VWHEADLOCK) {      /* restore height */
800                  VSUM(v1, odev.v.vp, nv.vp, -1.);
801                  d = DOT(v1, nv.vup);
802                  VSUM(nv.vp, nv.vp, odev.v.vup, d);
# Line 689 | Line 804 | int    dx, dy, mov, orb;
804          if (setview(&nv) != NULL)
805                  return(0);      /* illegal view */
806          dev_view(&nv);
807 <        inpresflags |= DFL(DC_SETVIEW)|DFL(DC_REDRAW);
807 >        inpresflags |= DFL(DC_SETVIEW);
808          return(1);
809   }
810  
811  
812 < static
813 < getframe(ebut)                          /* get focus frame */
814 < XButtonPressedEvent     *ebut;
812 > static void
813 > getframe(                               /* get focus frame */
814 >        XButtonPressedEvent     *ebut
815 > )
816   {
817          int     startx = ebut->x, starty = ebut->y;
818          int     endx, endy;
# Line 704 | Line 820 | XButtonPressedEvent    *ebut;
820          XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
821          endx = levptr(XButtonReleasedEvent)->x;
822          endy = levptr(XButtonReleasedEvent)->y;
823 <        if (endx == startx | endy == starty) {
823 >        if ((endx == startx) | (endy == starty)) {
824                  XBell(ourdisplay, 0);
825                  return;
826          }
# Line 717 | Line 833 | XButtonPressedEvent    *ebut;
833   }
834  
835  
836 < static
837 < getmove(ebut)                           /* get view change */
722 < XButtonPressedEvent     *ebut;
836 > static void
837 > waitabit(void)                          /* pause a moment */
838   {
839 +        struct timespec ts;
840 +        ts.tv_sec = 0;
841 +        ts.tv_nsec = 100000000L;
842 +        nanosleep(&ts, NULL);
843 + }
844 +
845 +
846 + static void
847 + getmove(                                /* get view change */
848 +        XButtonPressedEvent     *ebut
849 + )
850 + {
851          int     movdir = MOVDIR(ebut->button);
852          int     movorb = MOVORB(ebut->state);
853 +        int     ndrawn;
854          Window  rootw, childw;
855          int     rootx, rooty, wx, wy;
856          unsigned int    statemask;
857  
858          XNoOp(ourdisplay);              /* makes sure we're not idle */
859  
860 <        viewsteady = 0;                 /* flag moving view */
861 <        setglpersp(&odev.v);            /* start us off in perspective */
860 >        viewflags &= ~VWSTEADY;         /* flag moving view */
861 >        setglpersp();                   /* start us off in perspective */
862          while (!XCheckMaskEvent(ourdisplay,
863                          ButtonReleaseMask, levptr(XEvent))) {
864 +                                        /* pause so as not to move too fast */
865 +                waitabit();
866                                          /* get cursor position */
867                  if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
868                                  &rootx, &rooty, &wx, &wy, &statemask))
# Line 746 | Line 876 | XButtonPressedEvent    *ebut;
876   #ifdef STEREO
877                  pushright();
878                  draw_grids(1);
879 <                otDrawOctrees();
879 >                ndrawn = gmDrawGeom();
880   #ifdef DOBJ
881 <                dobj_render();
881 >                ndrawn += dobj_render();
882   #endif
883                  popright();
884   #endif
885                                          /* redraw octrees */
886 <                otDrawOctrees();
886 >                ndrawn = gmDrawGeom();
887   #ifdef DOBJ
888 <                dobj_render();          /* redraw objects */
888 >                ndrawn += dobj_render();        /* redraw objects */
889   #endif
890 <                glFlush();
890 >                glXSwapBuffers(ourdisplay, gwind);
891 >                if (!ndrawn)
892 >                        sleep(1);       /* for reasonable interaction */
893          }
894          if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
895                  movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
# Line 765 | Line 897 | XButtonPressedEvent    *ebut;
897                  wy = levptr(XButtonReleasedEvent)->y;
898                  moveview(wx, odev.vres-1-wy, movdir, movorb);
899          }
900 +        viewflags |= VWSTEADY;          /* done goofing around */
901   }
902  
903  
904 < static
905 < setglpersp(vp)                  /* set perspective view in GL */
773 < register VIEW   *vp;
904 > static void
905 > setglpersp(void)                        /* set perspective view in GL */
906   {
907          double  d, xmin, xmax, ymin, ymax;
908          GLfloat vec[4];
909          double  depthlim[2];
910                                          /* set depth limits */
911 <        otDepthLimit(depthlim, odev.v.vp, odev.v.vdir);
911 >        gmDepthLimit(depthlim, odev.v.vp, odev.v.vdir);
912          if (depthlim[0] >= depthlim[1]) {
913                  dev_zmin = 1.;
914                  dev_zmax = 100.;
915          } else {
916                  dev_zmin = 0.5*depthlim[0];
917 <                dev_zmax = 1.5*depthlim[1];
917 >                dev_zmax = 1.25*depthlim[1];
918                  if (dev_zmin > dev_zmax/5.)
919                          dev_zmin = dev_zmax/5.;
920          }
# Line 790 | Line 922 | register VIEW  *vp;
922                  dev_zmin = odev.v.vfore;
923          if (odev.v.vaft > FTINY)
924                  dev_zmax = odev.v.vaft;
925 <        if (dev_zmin < dev_zmax/100.)
926 <                dev_zmin = dev_zmax/100.;
925 >        if (dev_zmin*500. < dev_zmax)
926 >                dev_zmin = dev_zmax/500.;
927          setzrat();
928          xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
929          xmin = -xmax;
# Line 811 | Line 943 | register VIEW  *vp;
943                  odev.v.vp[2] + odev.v.vdir[2],
944                  odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
945          checkglerr("setting perspective view");
814 –        isperspective = 1;
946          vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
947          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
948          vec[0] = -odev.v.vdir[0];
# Line 827 | Line 958 | register VIEW  *vp;
958          glEnable(GL_LIGHT0);
959          glEnable(GL_LIGHTING);          /* light our GL objects */
960          glShadeModel(GL_SMOOTH);
961 +        viewflags &= ~VWORTHO;
962 +        viewflags |= VWPERSP;
963   }
964  
965  
966 < static
967 < setglortho()                    /* set up orthographic view for cone drawing */
966 > static void
967 > setglortho(void)                        /* set up orthographic view for cone drawing */
968   {
969 +        glDrawBuffer(GL_FRONT);         /* use single-buffer mode */
970                                          /* set view matrix */
971          glMatrixMode(GL_PROJECTION);
972          glLoadIdentity();
973          glOrtho(0., (double)odev.hres, 0., (double)odev.vres,
974                          0.001*OMAXDEPTH, 1.001*(-OMAXDEPTH));
975          checkglerr("setting orthographic view");
842 –        isperspective = 0;
976          glDisable(GL_LIGHTING);         /* cones are constant color */
977          glShadeModel(GL_FLAT);
978 +        viewflags &= ~VWPERSP;
979 +        viewflags |= VWORTHO;
980   }
981  
982  
983 < static
984 < wipeclean()                     /* prepare for redraw */
983 > static void
984 > wipeclean(void)                 /* prepare for redraw */
985   {
986 <                                        /* clear depth buffer */
986 >        glDrawBuffer(GL_BACK);          /* use double-buffer mode */
987 >        glReadBuffer(GL_BACK);
988 >                                        /* clear buffers */
989   #ifdef STEREO
990          setstereobuf(STEREO_BUFFER_RIGHT);
991 <        glClear(GL_DEPTH_BUFFER_BIT);
991 >        glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
992          setstereobuf(STEREO_BUFFER_LEFT);
993   #endif
994 <        glClear(GL_DEPTH_BUFFER_BIT);
995 <        if (viewsteady)                 /* clear samples if steady */
994 >        glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
995 >        freedepth();
996 >        if ((viewflags&(VWCHANGE|VWSTEADY)) ==
997 >                        (VWCHANGE|VWSTEADY)) {  /* clear samples if new */
998                  odClean();
999 <        if (depthbuffer != NULL) {      /* free recorded depth buffer */
1000 < #ifdef STEREO
1001 <                odDepthMap(1, NULL);
1002 <                free((char *)depthright);
864 <                depthright = NULL;
865 < #endif
866 <                odDepthMap(0, NULL);
867 <                free((char *)depthbuffer);
868 <                depthbuffer = NULL;
869 <        }
870 <        setglpersp(&odev.v);            /* reset view & clipping planes */
999 >                viewflags &= ~VWCHANGE;         /* change noted */
1000 >        } else if (viewflags & VWSTEADY)
1001 >                odRedrawAll();
1002 >        setglpersp();                   /* reset view & clipping planes */
1003   }
1004  
1005  
1006 < static
1007 < getkey(ekey)                            /* get input key */
1008 < register XKeyPressedEvent  *ekey;
1006 > static void
1007 > getkey(                         /* get input key */
1008 >        register XKeyPressedEvent  *ekey
1009 > )
1010   {
1011          Window  rootw, childw;
1012          int     rootx, rooty, wx, wy;
# Line 886 | Line 1019 | register XKeyPressedEvent  *ekey;
1019                  return;
1020          switch (buf[0]) {
1021          case 'h':                       /* turn on height motion lock */
1022 <                headlocked = 1;
1022 >                viewflags |= VWHEADLOCK;
1023                  return;
1024          case 'H':                       /* turn off height motion lock */
1025 <                headlocked = 0;
1025 >                viewflags &= ~VWHEADLOCK;
1026                  return;
1027          case 'l':                       /* retrieve last view */
1028                  inpresflags |= DFL(DC_LASTVIEW);
# Line 917 | Line 1050 | register XKeyPressedEvent  *ekey;
1050                  inpresflags |= DFL(DC_RESUME);
1051                  return;
1052          case CTRL('R'):                 /* redraw screen */
1053 <                odRemap();
1054 <                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
1053 >                odRemap(0);                     /* new tone mapping */
1054 >                glClear(GL_DEPTH_BUFFER_BIT);
1055   #ifdef STEREO
1056                  setstereobuf(STEREO_BUFFER_RIGHT);
1057 <                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
1057 >                glClear(GL_DEPTH_BUFFER_BIT);
1058                  setstereobuf(STEREO_BUFFER_LEFT);
1059   #endif
1060                  return;
1061          case CTRL('L'):                 /* refresh from server */
1062                  if (inpresflags & DFL(DC_REDRAW))
1063 <                        return;
1063 >                        return;                 /* already called */
1064                  XRaiseWindow(ourdisplay, gwind);
1065 <                XFlush(ourdisplay);
1066 <                sleep(1);
1067 <                wipeclean();                    /* fresh display */
1068 <                odRemap();                      /* new tone mapping */
936 <                dev_flush();                    /* draw octrees */
1065 >                XFlush(ourdisplay);             /* raise up window */
1066 >                sleep(1);                       /* wait for restacking */
1067 >                dev_clear();                    /* clear buffer and samples */
1068 >                odRemap(1);                     /* start fresh histogram */
1069                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
938 –                rayqleft = 0;                   /* hold off update */
1070                  return;
1071          case 'K':                       /* kill rtrace process(es) */
1072                  inpresflags |= DFL(DC_KILL);
# Line 956 | Line 1087 | register XKeyPressedEvent  *ekey;
1087   }
1088  
1089  
1090 < static
1091 < fixwindow(eexp)                         /* repair damage to window */
1092 < register XExposeEvent  *eexp;
1090 > static void
1091 > fixwindow(                              /* repair damage to window */
1092 >        register XExposeEvent  *eexp
1093 > )
1094   {
1095          int     xmin, ymin, xmax, ymax;
1096  
1097 <        if (odev.hres == 0 | odev.vres == 0) {  /* first exposure */
1097 >        if ((odev.hres == 0) | (odev.vres == 0)) {      /* first exposure */
1098                  resizewindow((XConfigureEvent *)eexp);
1099                  return;
1100          }
1101          xmin = eexp->x; xmax = eexp->x + eexp->width;
1102          ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
1103 +
1104 +        if (xmin <= 0 && xmax >= odev.hres-1 &&
1105 +                        ymin <= 0 && ymax >= odev.vres) {
1106 +                DCHECK(eexp->count, WARNING, "multiple clear in fixwindow");
1107 +                wipeclean();                    /* make sure we're go */
1108 +                return;
1109 +        }
1110                                                  /* clear portion of depth */
1111 +        glPushAttrib(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
1112          glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1113          glDepthFunc(GL_ALWAYS);
1114          glBegin(GL_POLYGON);
# Line 988 | Line 1128 | register XExposeEvent  *eexp;
1128          odRedraw(1, xmin, ymin, xmax, ymax);
1129          setstereobuf(STEREO_BUFFER_LEFT);
1130   #endif
1131 <        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
992 <        glDepthFunc(GL_LEQUAL);
1131 >        glPopAttrib();
1132          odRedraw(0, xmin, ymin, xmax, ymax);
1133   }
1134  
1135  
1136 < static
1137 < resizewindow(ersz)                      /* resize window */
1138 < register XConfigureEvent  *ersz;
1136 > static void
1137 > resizewindow(                   /* resize window */
1138 >        register XConfigureEvent  *ersz
1139 > )
1140   {
1141          glViewport(0, 0, ersz->width, ersz->height);
1142  
# Line 1009 | Line 1149 | register XConfigureEvent  *ersz;
1149          odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
1150          odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
1151  
1152 <        inpresflags |= DFL(DC_SETVIEW)|DFL(DC_REDRAW);
1152 >        inpresflags |= DFL(DC_SETVIEW);
1153 >        viewflags |= VWCHANGE;
1154   }

Diff Legend

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