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.15 by gwlarson, Tue Jan 5 18:16:17 1999 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1998 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1999 Silicon Graphics, Inc. */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ SGI";
# Line 37 | Line 37 | static char SCCSid[] = "$SunId$ SGI";
37   #include "x11icon.h"
38  
39   #ifndef RAYQLEN
40 < #define RAYQLEN         10240           /* max. rays to queue before flush */
40 > #define RAYQLEN         0               /* max. rays to queue before flush */
41   #endif
42 + #ifndef MINWIDTH
43 + #define MINWIDTH        480             /* minimum graphics window width */
44 + #define MINHEIGHT       400             /* minimum graphics window height */
45 + #endif
46 + #ifndef VIEWDIST
47 + #define VIEWDIST        356             /* assumed viewing distance (mm) */
48 + #endif
49 + #ifndef BORWIDTH
50 + #define BORWIDTH        5               /* border width */
51 + #endif
52  
53   #ifndef FEQ
54   #define FEQ(a,b)        ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
55   #endif
56  
57 + #define VWHEADLOCK      01              /* head position is locked flag */
58 + #define VWPERSP         02              /* perspective view is set */
59 + #define VWORTHO         04              /* orthographic view is set */
60 + #define VWCHANGE        010             /* view has changed */
61 + #define VWSTEADY        020             /* view is now steady */
62 + #define VWMAPPED        040             /* window is mapped */
63 +
64   #define GAMMA           1.4             /* default gamma correction */
65  
66   #define FRAMESTATE(s)   (((s)&(ShiftMask|ControlMask))==(ShiftMask|ControlMask))
# Line 53 | Line 70 | static char SCCSid[] = "$SunId$ SGI";
70   #define MOVDEG          (-5)            /* degrees to orbit CW/down /frame */
71   #define MOVORB(s)       ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
72  
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 –
73   #define setstereobuf(bid)       (glXWaitGL(), \
74                                  XSGISetStereoBuffer(ourdisplay, gwind, bid), \
75                                  glXWaitX())
# Line 86 | Line 96 | static int     rayqleft = 0;           /* rays left to queue before
96  
97   static XEvent  currentevent;            /* current event */
98  
89 – static int  mapped = 0;                 /* window is mapped? */
99   static unsigned long  ourblack=0, ourwhite=~0;
100  
101   static Display  *ourdisplay = NULL;     /* our display */
# Line 104 | Line 113 | static double  dev_zrat;               /* (1. - dev_zmin/dev_zmax) *
113  
114   static int      inpresflags;            /* input result flags */
115  
116 < static int      headlocked;             /* lock vertical motion */
116 > static int      viewflags;              /* what's happening with view */
117  
109 – static int      isperspective;          /* perspective/ortho view */
110 –
111 – static int      viewsteady;             /* is view steady? */
112 –
118   static int  resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
119 <                xferdepth(), setglortho(),
119 >                xferdepth(), freedepth(), setglortho(),
120                  setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
121  
122   static double   getdistance();
# Line 120 | Line 125 | static double  getdistance();
125   static int  pushright(), popright();
126   #endif
127  
128 + extern int      gmPortals;      /* GL portal list id */
129 +
130   extern time_t   time();
131  
132  
# Line 128 | Line 135 | char  *id;
135   {
136          extern char     *getenv();
137          static RGBPRIMS myprims = STDPRIMS;
138 <        static int      atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
139 <                                GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
140 <                                GLX_DEPTH_SIZE,15, None};
138 >        static int      atlBest[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
139 >                                GLX_RED_SIZE,8, GLX_GREEN_SIZE,8,
140 >                                GLX_BLUE_SIZE,8, GLX_DEPTH_SIZE,15, None};
141 >        static int      atlOK[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
142 >                                GLX_RED_SIZE,4, GLX_GREEN_SIZE,4,
143 >                                GLX_BLUE_SIZE,4, GLX_DEPTH_SIZE,15, None};
144          char    *ev;
145          double  gamval = GAMMA;
146          RGBPRIMP        dpri = stdprims;
# Line 143 | Line 153 | char  *id;
153   #endif
154                                          /* open display server */
155          ourdisplay = XOpenDisplay(NULL);
156 <        if (ourdisplay == NULL)
157 <                error(USER, "cannot open X-windows; DISPLAY variable set?\n");
156 >        CHECK(ourdisplay==NULL, USER,
157 >                        "cannot open X-windows; DISPLAY variable set?");
158   #ifdef STEREO
159          switch (XSGIQueryStereoMode(ourdisplay, ourroot)) {
160          case STEREO_TOP:
# Line 152 | Line 162 | char  *id;
162                  break;
163          case STEREO_OFF:
164                  error(USER,
165 <        "wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
165 >                "wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
166          case X_STEREO_UNSUPPORTED:
167                  error(USER, "stereo mode not supported on this screen");
168          default:
# Line 162 | Line 172 | char  *id;
172                                          /* find a usable visual */
173          ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
174          if (ourvinf == NULL)
175 <                error(USER, "no suitable visuals available");
175 >                ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlOK);
176 >        CHECK(ourvinf==NULL, USER, "no suitable visuals available");
177                                          /* get a context */
178          gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
179                                          /* set gamma and tone mapping */
# Line 194 | Line 205 | char  *id;
205   #endif
206                  BORWIDTH, ourvinf->depth, InputOutput, ourvinf->visual,
207                  CWBackPixel|CWBorderPixel|CWColormap|CWEventMask, &ourwinattr);
208 <        if (gwind == 0)
198 <                error(SYSTEM, "cannot create window\n");
208 >        CHECK(gwind==0, SYSTEM, "cannot create window");
209          XStoreName(ourdisplay, gwind, id);
210                                          /* set window manager hints */
211          ourxwmhints.flags = InputHint|IconPixmapHint;
# Line 219 | Line 229 | char  *id;
229          glXMakeCurrent(ourdisplay, gwind, gctx);
230          glEnable(GL_DEPTH_TEST);
231          glDepthFunc(GL_LEQUAL);
232 <        glDisable(GL_DITHER);
232 >        glClearColor(0, 0, 0, 0);
233          glFrontFace(GL_CCW);
234          glDisable(GL_CULL_FACE);
235          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
236          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
237 +        glPixelStorei(GL_PACK_ALIGNMENT, 1);
238 +        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
239                                          /* figure out sensible view */
240          pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
241                          DisplayWidth(ourdisplay, ourscreen);
# Line 236 | Line 248 | char  *id;
248          checkglerr("setting rendering parameters");
249          copystruct(&odev.v, &stdview);
250          odev.v.type = VT_PER;
251 <        headlocked = 0;                 /* free up head movement */
240 <        viewsteady = 1;                 /* view starts static */
241 <        isperspective = -1;             /* but no view set, yet */
251 >        viewflags = VWSTEADY;           /* view starts static */
252                                          /* map the window */
253          XMapWindow(ourdisplay, gwind);
254          dev_input();                    /* sets size and view angles */
255          if (!odInit(DisplayWidth(ourdisplay,ourscreen) *
256 <                        DisplayHeight(ourdisplay,ourscreen) / 10))
256 >                        DisplayHeight(ourdisplay,ourscreen) / 3))
257                  error(SYSTEM, "insufficient memory for value storage");
258          odev.name = id;
259          odev.firstuse = 1;              /* can't recycle samples */
# Line 256 | Line 266 | dev_close()                    /* close our display and free resources
266   #ifdef DOBJ
267          dobj_cleanup();
268   #endif
269 +        freedepth();
270 +        gmEndGeom();
271 +        gmEndPortal();
272          odDone();
273          glXMakeCurrent(ourdisplay, None, NULL);
274          glXDestroyContext(ourdisplay, gctx);
# Line 272 | Line 285 | dev_close()                    /* close our display and free resources
285  
286   dev_clear()                     /* clear our representation */
287   {
288 <        wipeclean();
288 >        viewflags |= VWCHANGE;          /* pretend our view has changed */
289 >        wipeclean();                    /* clean off display and samples */
290 >        dev_flush();                    /* redraw geometry & get depth */
291          rayqleft = 0;                   /* hold off update */
292   }
293  
# Line 319 | Line 334 | register VIEW  *nv;
334                          dev_input();    /* get resize event */
335                  }
336                  copystruct(&odev.v, nv);        /* setview() already called */
337 +                viewflags |= VWCHANGE;
338 +        }
339   #ifdef STEREO
340 <                copystruct(&vwright, nv);
341 <                d = eyesepdist / sqrt(nv->hn2);
342 <                VSUM(vwright.vp, nv->vp, nv->hvec, d);
343 <                /* setview(&vwright);   -- Unnecessary */
340 >        copystruct(&vwright, nv);
341 >        d = eyesepdist / sqrt(nv->hn2);
342 >        VSUM(vwright.vp, nv->vp, nv->hvec, d);
343 >        /* setview(&vwright);   -- Unnecessary */
344   #endif
328 –        } else
329 –                viewsteady = 1;
345          wipeclean();
346          return(1);
347   }
348  
349  
350 < dev_section(ofn)                /* add octree for geometry rendering */
351 < char    *ofn;
350 > dev_section(gfn, pfn)           /* add octree for geometry rendering */
351 > char    *gfn, *pfn;
352   {
353          extern char     *index();
354          char    *cp;
355  
356 <        if (ofn == NULL)
357 <                otEndOctree();
358 <        else if (access(ofn, R_OK) == 0)
359 <                otNewOctree(ofn);
356 >        if (gfn == NULL) {
357 >                gmEndGeom();
358 >                gmEndPortal();
359 >                wipeclean();            /* new geometry, so redraw it */
360 >                return;
361 >        }
362 >        if (access(gfn, R_OK) == 0)
363 >                gmNewGeom(gfn);
364   #ifdef DEBUG
365          else {
366 <                sprintf(errmsg, "cannot load octree \"%s\"", ofn);
366 >                sprintf(errmsg, "cannot load octree \"%s\"", gfn);
367                  error(WARNING, errmsg);
368          }
369   #endif
370 +        if (pfn != NULL)
371 +                gmNewPortal(pfn);
372   }
373  
374  
# Line 355 | Line 376 | dev_auxcom(cmd, args)          /* process an auxiliary command
376   char    *cmd, *args;
377   {
378   #ifdef DOBJ
379 <        if (dobj_command(cmd, args) >= 0)
379 >        int     vischange;
380 >
381 >        if ((vischange = dobj_command(cmd, args)) >= 0) {
382 >                if (vischange) {
383 >                        imm_mode = beam_sync(1) > 0;
384 >                        dev_clear();
385 >                }
386                  return;
387 +        }
388   #endif
389          sprintf(errmsg, "%s: unknown command", cmd);
390          error(COMMAND, errmsg);
# Line 416 | Line 444 | dev_flush()                    /* flush output as appropriate */
444   {
445          int     ndrawn;
446  
447 <        if (mapped && isperspective > 0) {
447 >        if ((viewflags&(VWMAPPED|VWPERSP)) == (VWMAPPED|VWPERSP)) {
448   #ifdef STEREO
449                  pushright();                    /* draw right eye */
450 <                otDrawOctrees();
450 >                ndrawn = gmDrawGeom();
451   #ifdef DOBJ
452 <                dobj_render();
452 >                ndrawn += dobj_render();
453   #endif
454                  checkglerr("rendering right eye");
455                  popright();                     /* draw left eye */
456   #endif
457 <                ndrawn = otDrawOctrees();
457 >                ndrawn = gmDrawGeom();
458   #ifdef DOBJ
459                  ndrawn += dobj_render();
460   #endif
461 +                glXSwapBuffers(ourdisplay, gwind);
462                  checkglerr("rendering base view");
463          }
464 <        if (mapped && viewsteady) {
465 <                if (isperspective) {            /* first time after steady */
464 >        if ((viewflags&(VWMAPPED|VWSTEADY|VWPERSP|VWORTHO)) ==
465 >                        (VWMAPPED|VWSTEADY|VWPERSP)) {
466 >                                        /* first time after steady */
467 >                if (ndrawn)
468 >                        xferdepth();    /* transfer and clear depth */
469 >                setglortho();           /* set orthographic view */
470 >
471 >        }
472 >        if ((viewflags&(VWMAPPED|VWSTEADY|VWPERSP|VWORTHO)) ==
473 >                        (VWMAPPED|VWSTEADY|VWORTHO)) {
474 >                                        /* else update cones */
475   #ifdef STEREO
476 <                        pushright();
477 <                        popright();
476 >                pushright();
477 >                odUpdate(1);            /* draw right eye */
478 >                popright();
479   #endif
480 <                        if (ndrawn)
481 <                                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 <                }
480 >                odUpdate(0);            /* draw left eye */
481 >                glFlush();              /* flush OpenGL */
482          }
453 –        glFlush();                              /* flush OpenGL */
483          rayqleft = RAYQLEN;
484                                          /* flush X11 and return # pending */
485          return(odev.inpready = XPending(ourdisplay));
# Line 474 | Line 503 | static
503   xferdepth()                     /* load and clear depth buffer */
504   {
505          register GLfloat        *dbp;
506 +        register GLubyte        *pbuf;
507  
508 <        if (depthbuffer == NULL) {
508 >        if (depthbuffer == NULL) {      /* allocate private depth buffer */
509   #ifdef STEREO
510                  depthright = (GLfloat *)malloc(
511                                  odev.hres*odev.vres*sizeof(GLfloat));
512   #endif
513                  depthbuffer = (GLfloat *)malloc(
514                                  odev.hres*odev.vres*sizeof(GLfloat));
515 <                if (depthbuffer == NULL)
486 <                        error(SYSTEM, "out of memory in xferdepth");
515 >                CHECK(depthbuffer==NULL, SYSTEM, "out of memory in xferdepth");
516          }
517 +                                /* allocate alpha buffer for portals */
518 +        if (gmPortals)
519 +                pbuf = (GLubyte *)malloc(odev.hres*odev.vres*sizeof(GLubyte));
520 +        else
521 +                pbuf = NULL;
522   #ifdef STEREO
523 <        setstereobuf(STEREO_BUFFER_RIGHT);
523 >        pushright();
524          glReadPixels(0, 0, odev.hres, odev.vres,
525                          GL_DEPTH_COMPONENT, GL_FLOAT, depthright);
526 <        setstereobuf(STEREO_BUFFER_LEFT);
526 >        if (pbuf != NULL) {
527 >                glClear(GL_COLOR_BUFFER_BIT);
528 >                gmDrawPortals(0xff, -1, -1, -1);
529 >                glReadPixels(0, 0, odev.hres, odev.vres,
530 >                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
531 >        }
532          for (dbp = depthright + odev.hres*odev.vres; dbp-- > depthright; )
533 <                *dbp = mapdepth(*dbp);
534 <        odDepthMap(1, depthright);
533 >                if (pbuf != NULL && pbuf[dbp-depthright]&0x40)
534 >                        *dbp = FHUGE;
535 >                else
536 >                        *dbp = mapdepth(*dbp);
537          glClear(GL_DEPTH_BUFFER_BIT);
538 +        odDepthMap(1, depthright);
539 +        popright();
540   #endif
541 +                                /* read back depth buffer */
542          glReadPixels(0, 0, odev.hres, odev.vres,
543                          GL_DEPTH_COMPONENT, GL_FLOAT, depthbuffer);
544 +        if (pbuf != NULL) {
545 +                glClear(GL_COLOR_BUFFER_BIT);           /* find portals */
546 +                gmDrawPortals(0xff, -1, -1, -1);
547 +                glReadPixels(0, 0, odev.hres, odev.vres,
548 +                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
549 + #ifdef DEBUG
550 +                glXSwapBuffers(ourdisplay, gwind);
551 + #endif
552 +        }
553          for (dbp = depthbuffer + odev.hres*odev.vres; dbp-- > depthbuffer; )
554 <                *dbp = mapdepth(*dbp);
554 >                if (pbuf != NULL && pbuf[dbp-depthbuffer]&0x40)
555 >                        *dbp = FHUGE;
556 >                else
557 >                        *dbp = mapdepth(*dbp);
558 >        glClear(GL_DEPTH_BUFFER_BIT);           /* clear system depth buffer */
559          odDepthMap(0, depthbuffer);             /* transfer depth data */
560 <        glClear(GL_DEPTH_BUFFER_BIT);           /* clear system buffer */
560 >        if (pbuf != NULL)
561 >                free((char *)pbuf);             /* free our portal buffer */
562   }
563  
564  
565 + static
566 + freedepth()                             /* free recorded depth buffer */
567 + {
568 +        if (depthbuffer == NULL)
569 +                return;
570 + #ifdef STEREO
571 +        odDepthMap(1, NULL);
572 +        free((char *)depthright);
573 +        depthright = NULL;
574 + #endif
575 +        odDepthMap(0, NULL);
576 +        free((char *)depthbuffer);
577 +        depthbuffer = NULL;
578 + }
579 +
580 +
581   static double
582   getdistance(dx, dy, direc)      /* distance from fore plane along view ray */
583   int     dx, dy;
# Line 534 | Line 608 | pushright()                    /* push on right view & buffer */
608          double  d;
609  
610          setstereobuf(STEREO_BUFFER_RIGHT);
611 <        if (isperspective > 0) {
611 >        if (viewflags & VWPERSP) {
612                  glMatrixMode(GL_MODELVIEW);
613                  glPushMatrix();
614                  d = -eyesepdist / sqrt(odev.v.hn2);
# Line 548 | Line 622 | pushright()                    /* push on right view & buffer */
622   static
623   popright()                      /* pop off right view & buffer */
624   {
625 <        if (isperspective > 0) {
625 >        if (viewflags & VWPERSP) {
626                  glMatrixMode(GL_MODELVIEW);
627                  glPopMatrix();
628          }
# Line 591 | Line 665 | getevent()                     /* get next event */
665                  resizewindow(levptr(XConfigureEvent));
666                  break;
667          case UnmapNotify:
668 <                mapped = 0;
668 >                viewflags &= ~VWMAPPED;
669                  break;
670          case MapNotify:
671 <                mapped = 1;
671 >                odRemap(0);
672 >                viewflags |= VWMAPPED;
673                  break;
674          case Expose:
675                  fixwindow(levptr(XExposeEvent));
# Line 628 | Line 703 | int    fore;
703          glPushAttrib(GL_LIGHTING_BIT|GL_ENABLE_BIT);
704          glDisable(GL_LIGHTING);
705          if (fore)
706 <                glColor3ub(0, 255, 255);
706 >                glColor3ub(4, 250, 250);
707          else
708                  glColor3ub(0, 0, 0);
709          glBegin(GL_LINES);              /* draw each grid line */
# Line 681 | Line 756 | int    dx, dy, mov, orb;
756                  d = MOVPCT/100. * mov;
757                  VSUM(nv.vp, nv.vp, odir, d);
758          }
759 <        if (!mov ^ !orb && headlocked) {        /* restore head height */
759 >        if (!mov ^ !orb && viewflags&VWHEADLOCK) {      /* restore height */
760                  VSUM(v1, odev.v.vp, nv.vp, -1.);
761                  d = DOT(v1, nv.vup);
762                  VSUM(nv.vp, nv.vp, odev.v.vup, d);
# Line 689 | Line 764 | int    dx, dy, mov, orb;
764          if (setview(&nv) != NULL)
765                  return(0);      /* illegal view */
766          dev_view(&nv);
767 <        inpresflags |= DFL(DC_SETVIEW)|DFL(DC_REDRAW);
767 >        inpresflags |= DFL(DC_SETVIEW);
768          return(1);
769   }
770  
# Line 723 | Line 798 | XButtonPressedEvent    *ebut;
798   {
799          int     movdir = MOVDIR(ebut->button);
800          int     movorb = MOVORB(ebut->state);
801 +        int     ndrawn;
802          Window  rootw, childw;
803          int     rootx, rooty, wx, wy;
804          unsigned int    statemask;
805  
806          XNoOp(ourdisplay);              /* makes sure we're not idle */
807  
808 <        viewsteady = 0;                 /* flag moving view */
809 <        setglpersp(&odev.v);            /* start us off in perspective */
808 >        viewflags &= ~VWSTEADY;         /* flag moving view */
809 >        setglpersp();                   /* start us off in perspective */
810          while (!XCheckMaskEvent(ourdisplay,
811                          ButtonReleaseMask, levptr(XEvent))) {
812                                          /* get cursor position */
# Line 746 | Line 822 | XButtonPressedEvent    *ebut;
822   #ifdef STEREO
823                  pushright();
824                  draw_grids(1);
825 <                otDrawOctrees();
825 >                ndrawn = gmDrawGeom();
826   #ifdef DOBJ
827 <                dobj_render();
827 >                ndrawn += dobj_render();
828   #endif
829                  popright();
830   #endif
831                                          /* redraw octrees */
832 <                otDrawOctrees();
832 >                ndrawn = gmDrawGeom();
833   #ifdef DOBJ
834 <                dobj_render();          /* redraw objects */
834 >                ndrawn += dobj_render();        /* redraw objects */
835   #endif
836 <                glFlush();
836 >                glXSwapBuffers(ourdisplay, gwind);
837 >                if (!ndrawn)
838 >                        sleep(1);       /* for reasonable interaction */
839          }
840          if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
841                  movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
# Line 765 | Line 843 | XButtonPressedEvent    *ebut;
843                  wy = levptr(XButtonReleasedEvent)->y;
844                  moveview(wx, odev.vres-1-wy, movdir, movorb);
845          }
846 +        viewflags |= VWSTEADY;          /* done goofing around */
847   }
848  
849  
850   static
851 < setglpersp(vp)                  /* set perspective view in GL */
773 < register VIEW   *vp;
851 > setglpersp()                    /* set perspective view in GL */
852   {
853          double  d, xmin, xmax, ymin, ymax;
854          GLfloat vec[4];
855          double  depthlim[2];
856                                          /* set depth limits */
857 <        otDepthLimit(depthlim, odev.v.vp, odev.v.vdir);
857 >        gmDepthLimit(depthlim, odev.v.vp, odev.v.vdir);
858          if (depthlim[0] >= depthlim[1]) {
859                  dev_zmin = 1.;
860                  dev_zmax = 100.;
861          } else {
862                  dev_zmin = 0.5*depthlim[0];
863 <                dev_zmax = 1.5*depthlim[1];
863 >                dev_zmax = 1.25*depthlim[1];
864                  if (dev_zmin > dev_zmax/5.)
865                          dev_zmin = dev_zmax/5.;
866          }
# Line 811 | Line 889 | register VIEW  *vp;
889                  odev.v.vp[2] + odev.v.vdir[2],
890                  odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
891          checkglerr("setting perspective view");
814 –        isperspective = 1;
892          vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
893          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
894          vec[0] = -odev.v.vdir[0];
# Line 827 | Line 904 | register VIEW  *vp;
904          glEnable(GL_LIGHT0);
905          glEnable(GL_LIGHTING);          /* light our GL objects */
906          glShadeModel(GL_SMOOTH);
907 +        viewflags &= ~VWORTHO;
908 +        viewflags |= VWPERSP;
909   }
910  
911  
912   static
913   setglortho()                    /* set up orthographic view for cone drawing */
914   {
915 +        glDrawBuffer(GL_FRONT);         /* use single-buffer mode */
916                                          /* set view matrix */
917          glMatrixMode(GL_PROJECTION);
918          glLoadIdentity();
919          glOrtho(0., (double)odev.hres, 0., (double)odev.vres,
920                          0.001*OMAXDEPTH, 1.001*(-OMAXDEPTH));
921          checkglerr("setting orthographic view");
842 –        isperspective = 0;
922          glDisable(GL_LIGHTING);         /* cones are constant color */
923          glShadeModel(GL_FLAT);
924 +        viewflags &= ~VWPERSP;
925 +        viewflags |= VWORTHO;
926   }
927  
928  
929   static
930   wipeclean()                     /* prepare for redraw */
931   {
932 <                                        /* clear depth buffer */
932 >        glDrawBuffer(GL_BACK);          /* use double-buffer mode */
933 >        glReadBuffer(GL_BACK);
934 >                                        /* clear buffers */
935   #ifdef STEREO
936          setstereobuf(STEREO_BUFFER_RIGHT);
937 <        glClear(GL_DEPTH_BUFFER_BIT);
937 >        glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
938          setstereobuf(STEREO_BUFFER_LEFT);
939   #endif
940 <        glClear(GL_DEPTH_BUFFER_BIT);
941 <        if (viewsteady)                 /* clear samples if steady */
940 >        glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
941 >        freedepth();
942 >        if ((viewflags&(VWCHANGE|VWSTEADY)) ==
943 >                        (VWCHANGE|VWSTEADY)) {  /* clear samples if new */
944                  odClean();
945 <        if (depthbuffer != NULL) {      /* free recorded depth buffer */
946 < #ifdef STEREO
947 <                odDepthMap(1, NULL);
863 <                free((char *)depthright);
864 <                depthright = NULL;
865 < #endif
866 <                odDepthMap(0, NULL);
867 <                free((char *)depthbuffer);
868 <                depthbuffer = NULL;
869 <        }
945 >                viewflags &= ~VWCHANGE;         /* change noted */
946 >        } else if (viewflags & VWSTEADY)
947 >                odRedrawAll();
948          setglpersp(&odev.v);            /* reset view & clipping planes */
949   }
950  
# Line 886 | Line 964 | register XKeyPressedEvent  *ekey;
964                  return;
965          switch (buf[0]) {
966          case 'h':                       /* turn on height motion lock */
967 <                headlocked = 1;
967 >                viewflags |= VWHEADLOCK;
968                  return;
969          case 'H':                       /* turn off height motion lock */
970 <                headlocked = 0;
970 >                viewflags &= ~VWHEADLOCK;
971                  return;
972          case 'l':                       /* retrieve last view */
973                  inpresflags |= DFL(DC_LASTVIEW);
# Line 917 | Line 995 | register XKeyPressedEvent  *ekey;
995                  inpresflags |= DFL(DC_RESUME);
996                  return;
997          case CTRL('R'):                 /* redraw screen */
998 <                odRemap();
999 <                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
998 >                odRemap(0);                     /* new tone mapping */
999 >                glClear(GL_DEPTH_BUFFER_BIT);
1000   #ifdef STEREO
1001                  setstereobuf(STEREO_BUFFER_RIGHT);
1002 <                glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
1002 >                glClear(GL_DEPTH_BUFFER_BIT);
1003                  setstereobuf(STEREO_BUFFER_LEFT);
1004   #endif
1005                  return;
1006          case CTRL('L'):                 /* refresh from server */
1007                  if (inpresflags & DFL(DC_REDRAW))
1008 <                        return;
1008 >                        return;                 /* already called */
1009                  XRaiseWindow(ourdisplay, gwind);
1010 <                XFlush(ourdisplay);
1011 <                sleep(1);
1012 <                wipeclean();                    /* fresh display */
1013 <                odRemap();                      /* new tone mapping */
936 <                dev_flush();                    /* draw octrees */
1010 >                XFlush(ourdisplay);             /* raise up window */
1011 >                sleep(1);                       /* wait for restacking */
1012 >                dev_clear();                    /* clear buffer and samples */
1013 >                odRemap(1);                     /* start fresh histogram */
1014                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
938 –                rayqleft = 0;                   /* hold off update */
1015                  return;
1016          case 'K':                       /* kill rtrace process(es) */
1017                  inpresflags |= DFL(DC_KILL);
# Line 968 | Line 1044 | register XExposeEvent  *eexp;
1044          }
1045          xmin = eexp->x; xmax = eexp->x + eexp->width;
1046          ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
1047 +
1048 +        if (xmin <= 0 && xmax >= odev.hres-1 &&
1049 +                        ymin <= 0 && ymax >= odev.vres) {
1050 +                DCHECK(eexp->count, WARNING, "multiple clear in fixwindow");
1051 +                wipeclean();                    /* make sure we're go */
1052 +                return;
1053 +        }
1054                                                  /* clear portion of depth */
1055 +        glPushAttrib(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
1056          glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1057          glDepthFunc(GL_ALWAYS);
1058          glBegin(GL_POLYGON);
# Line 988 | Line 1072 | register XExposeEvent  *eexp;
1072          odRedraw(1, xmin, ymin, xmax, ymax);
1073          setstereobuf(STEREO_BUFFER_LEFT);
1074   #endif
1075 <        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
992 <        glDepthFunc(GL_LEQUAL);
1075 >        glPopAttrib();
1076          odRedraw(0, xmin, ymin, xmax, ymax);
1077   }
1078  
# Line 1009 | Line 1092 | register XConfigureEvent  *ersz;
1092          odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
1093          odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
1094  
1095 <        inpresflags |= DFL(DC_SETVIEW)|DFL(DC_REDRAW);
1095 >        inpresflags |= DFL(DC_SETVIEW);
1096 >        viewflags |= VWCHANGE;
1097   }

Diff Legend

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