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.1 by gregl, Tue Dec 23 18:31:00 1997 UTC vs.
Revision 3.3 by gregl, Wed Dec 24 15:55:43 1997 UTC

# Line 6 | Line 6 | static char SCCSid[] = "$SunId$ SGI";
6  
7   /*
8   * OpenGL GLX driver for holodeck display.
9 < * Based on rview driver.
9 > * Based on x11 driver.
10   */
11  
12   #include "standard.h"
# Line 26 | Line 26 | static char SCCSid[] = "$SunId$ SGI";
26   #endif
27  
28   #ifndef FREEPCT
29 < #define FREEPCT         25              /* percentage of values to free */
29 > #define FREEPCT         10              /* percentage of values to free */
30   #endif
31  
32   #ifndef NCONEV
33   #define NCONEV          7               /* number of cone base vertices */
34   #endif
35   #ifndef CONEH
36 < #define CONEH           0.25            /* cone height (fraction of depth) */
36 > #define CONEH           3.              /* cone height (fraction of depth) */
37   #endif
38   #ifndef CONEW
39 < #define CONEW           0.035           /* cone width (fraction of screen) */
39 > #define CONEW           0.05            /* cone width (fraction of screen) */
40   #endif
41 + #ifndef DIRPEN
42 + #define DIRPEN          0.001           /* direction penalty factor */
43 + #endif
44 + #ifndef VALUA
45 + #define VALUA           16              /* target value area (pixels) */
46 + #endif
47  
48 < #define GAMMA           2.2             /* default gamma correction */
48 > #define GAMMA           1.4             /* default gamma correction */
49  
50   #define MOVPCT          7               /* percent distance to move /frame */
51   #define MOVDIR(b)       ((b)==Button1 ? 1 : (b)==Button2 ? 0 : -1)
# Line 65 | Line 71 | struct driver  odev;                   /* global device driver structur
71   static XEvent  currentevent;            /* current event */
72  
73   static int  mapped = 0;                 /* window is mapped? */
68 – static unsigned long  *pixval = NULL;   /* allocated pixels */
74   static unsigned long  ourblack=0, ourwhite=~0;
75  
76   static Display  *ourdisplay = NULL;     /* our display */
# Line 74 | Line 79 | static Window  gwind = 0;              /* our graphics window */
79   static GLXContext       gctx;           /* our GLX context */
80  
81   static double   mindepth = FHUGE;       /* minimum depth value so far */
82 < static double   maxdepth = 0.;          /* maximum depth value */
82 > static double   maxdepth = 0.;          /* maximum depth value so far */
83  
84   static double   pwidth, pheight;        /* pixel dimensions (mm) */
85  
# Line 85 | Line 90 | static int     inpresflags;            /* input result flags */
90  
91   static int      headlocked = 0;         /* lock vertical motion */
92  
93 + static int      quicken = 0;            /* quicker, sloppier update rate? */
94 +
95   static struct {
96          float           (*wp)[3];       /* world intersection point array */
97          int4            *wd;            /* world direction array */
# Line 99 | Line 106 | static struct {
106          char            *base;          /* base of allocated memory */
107   }       rV;                     /* our collection of values */
108  
109 + static int      *valmap = NULL;         /* sorted map of screen values */
110 + static int      vmaplen = 0;            /* value map length */
111 +
112   #define redraw()        (rV.drl = rV.bl)
113  
114   static int  resizewindow(), getevent(), getkey(), moveview(),
115                  setGLview(), getmove(), fixwindow(), mytmflags(),
116 <                newvalue(), drawvalue(), Compost(),
117 <                FindValue(), AllocValues(), TMapValues(), FreeValues();
116 >                drawvalue(), valcmp(), clralphas(), setalphas(), mergalphas(),
117 >                IndexValue(), Compost(), FindValue(), TMapValues(),
118 >                AllocValues(), FreeValues();
119  
120 + extern int4     encodedir();
121 + extern double   fdir2diff(), dir2diff();
122  
123 +
124   dev_open(id)                    /* initialize X11 driver */
125   char  *id;
126   {
127          extern char     *getenv();
128          static int      atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
129                                  GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
130 <                                GLX_ALPHA_SIZE,8, GLX_DEPTH_SIZE,23,
131 <                                /*GLX_DOUBLEBUFFER,*/ None};
118 <        static int      atlOK[] = {GLX_RGBA, GLX_RED_SIZE,4,
119 <                                GLX_GREEN_SIZE,4, GLX_BLUE_SIZE,4,
120 <                                GLX_ALPHA_SIZE,4, GLX_DEPTH_SIZE,15,
121 <                                /*GLX_DOUBLEBUFFER,*/ None};
130 >                                GLX_ALPHA_SIZE,8, GLX_DEPTH_SIZE,15,
131 >                                None};
132          char    *gv;
133          double  gamval = GAMMA;
134          XSetWindowAttributes    ourwinattr;
# Line 131 | Line 141 | char  *id;
141                                          /* find a usable visual */
142          ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
143          if (ourvinf == NULL)
134 –                ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlOK);
135 –        if (ourvinf == NULL)
144                  error(USER, "no suitable visuals available");
145                                          /* get a context */
146          gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
# Line 167 | Line 175 | char  *id;
175          oursizhints.min_height = MINHEIGHT;
176          oursizhints.flags = PMinSize;
177          XSetNormalHints(ourdisplay, gwind, &oursizhints);
178 <                                        /* map the window and get its size */
179 <        XMapWindow(ourdisplay, gwind);
180 <        dev_input();
181 <                                        /* allocate our value list */
182 <        if (!AllocValues(DisplayWidth(ourdisplay,ourscreen) *
183 <                        DisplayHeight(ourdisplay,ourscreen) / 4))
176 <                error(SYSTEM, "insufficient memory for value storage");
178 >                                        /* set GLX context */
179 >        glXMakeCurrent(ourdisplay, gwind, gctx);
180 >        glEnable(GL_DEPTH_TEST);
181 >        glDepthFunc(GL_LEQUAL);
182 >        glShadeModel(GL_FLAT);
183 >        glDisable(GL_DITHER);
184                                          /* figure out sensible view */
185          pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
186                          DisplayWidth(ourdisplay, ourscreen);
# Line 181 | Line 188 | char  *id;
188                          DisplayHeight(ourdisplay, ourscreen);
189          copystruct(&odev.v, &stdview);
190          odev.v.type = VT_PER;
191 <        odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
192 <        odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
191 >                                        /* map the window */
192 >        XMapWindow(ourdisplay, gwind);
193 >        dev_input();                    /* sets size and view angles */
194 >        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
195 >                                        /* allocate our value list */
196 >        if (!AllocValues(DisplayWidth(ourdisplay,ourscreen) *
197 >                        DisplayHeight(ourdisplay,ourscreen) / VALUA))
198 >                error(SYSTEM, "insufficient memory for value storage");
199          odev.name = id;
200          odev.ifd = ConnectionNumber(ourdisplay);
188 –                                        /* set GLX context and clear buffers */
189 –        glXMakeCurrent(ourdisplay, gwind, gctx);
190 –        glEnable(GL_DEPTH_TEST);
191 –        glDepthFunc(GL_LEQUAL);
192 –        glShadeModel(GL_FLAT);
193 –        glDisable(GL_DITHER);
194 –        glDrawBuffer(GL_FRONT_AND_BACK);
195 –        glReadBuffer(GL_BACK);
196 –        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
197 –        setGLview();                    /* initialize view */
201   }
202  
203  
# Line 247 | Line 250 | register VIEW  *nv;
250                                  odev.vres = dh;
251                          }
252                          XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
253 +                        dev_input();    /* get resize event */
254                  }
255                  copystruct(&odev.v, nv);
256                  setGLview();
257 +                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
258 +                redraw();
259          }
254 –        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
255 –        redraw();
260          return(1);
261   }
262  
# Line 277 | Line 281 | FVECT  p, v;
281   {
282          register int    li;
283  
284 <        li = newvalue();
284 >        li = rV.tl++;
285 >        if (rV.tl >= rV.nl)     /* get next leaf in ring */
286 >                rV.tl = 0;
287 >        if (rV.tl == rV.bl)     /* need to shake some free */
288 >                Compost(FREEPCT);
289          VCOPY(rV.wp[li], p);
290          rV.wd[li] = encodedir(v);
291          tmCvColrs(&rV.brt[li], rV.chr[li], c, 1);
# Line 331 | Line 339 | setGLview()                    /* set our GL view */
339                  return;
340          if (mindepth < maxdepth) {
341                  zmin = 0.25*mindepth;
342 <                zmax = 8.0*maxdepth;
342 >                zmax = 4.0*(1.+CONEH)*maxdepth;
343          } else {
344                  zmin = 0.01;
345                  zmax = 1000.;
# Line 379 | Line 387 | setGLview()                    /* set our GL view */
387   }
388  
389  
390 < static int
391 < newvalue()                      /* allocate a leaf from our pile */
384 < {
385 <        int     li;
386 <        
387 <        li = rV.tl++;
388 <        if (rV.tl >= rV.nl)     /* get next leaf in ring */
389 <                rV.tl = 0;
390 <        if (rV.tl == rV.bl)     /* need to shake some free */
391 <                Compost(FREEPCT);
392 <        return(li);
393 < }
390 > #define SUCCSTEP        8       /* skip step when successful */
391 > #define MAXSTEP         64
392  
395 –
393   static
394   drawvalue(li)                   /* draw a pixel value as a cone */
395   register int    li;
396   {
397 <        static FVECT    apex, disp;
398 <        double  d, h, v;
397 >        static int      skipstep = 1;
398 >        static FVECT    disp;
399 >        FVECT   apex;
400 >        double  d, dorg, dnew, h, v;
401          register int    i;
402 <                                        /* compute cone's base displacement */
403 <        VCOPY(apex, rV.wp[li]);
404 <        disp[0] = apex[0] - odev.v.vp[0];
406 <        disp[1] = apex[1] - odev.v.vp[1];
407 <        disp[2] = apex[2] - odev.v.vp[2];
408 <        if ((d = DOT(disp,odev.v.vdir)) <= odev.v.vfore || d <= FTINY)
409 <                return;
410 <        if (d > 1e5) {          /* background region */
411 <                if (odev.v.vaft > FTINY)
402 >                                /* check for quicker update */
403 >        if (quicken) {
404 >                if (li % skipstep)
405                          return;
406 <                h = maxdepth/d;
407 <                disp[0] *= h; disp[1] *= h; disp[2] *= h;
408 <                apex[0] = odev.v.vp[0] + disp[0];
409 <                apex[1] = odev.v.vp[1] + disp[1];
410 <                apex[2] = odev.v.vp[2] + disp[2];
411 <                d = maxdepth;
412 <        } else if (d > maxdepth)
413 <                maxdepth = d;
414 <        h = DOT(disp,odev.v.hvec)/(d*odev.v.hn2);
415 <        v = DOT(disp,odev.v.vvec)/(d*odev.v.vn2);
416 <        if (fabs(h - odev.v.hoff) < 0.5 && fabs(v - odev.v.voff) < 0.5 &&
417 <                        d < mindepth)
418 < {
419 < fprintf(stderr, "min depth now %lf (%lf,%lf,%lf)\n", d, apex[0], apex[1], apex[2]);
420 <                mindepth = d;
421 < }
406 >                if (skipstep < MAXSTEP)
407 >                        skipstep++;
408 >        }
409 >                                /* compute cone coordinates */
410 >        disp[0] = rV.wp[li][0] - odev.v.vp[0];
411 >        disp[1] = rV.wp[li][1] - odev.v.vp[1];
412 >        disp[2] = rV.wp[li][2] - odev.v.vp[2];
413 >        dorg = DOT(disp,odev.v.vdir);
414 >        if (dorg <= odev.v.vfore)
415 >                return;         /* clipped too near */
416 >        if (odev.v.vaft > FTINY && dorg > odev.v.vaft)
417 >                return;         /* clipped too far */
418 >        if (dorg > 1e5) {       /* background pixel */
419 >                dnew = maxdepth;
420 >                d = dnew/dorg;
421 >                dorg = maxdepth;
422 >        } else {                /* foreground pixel, compute penalty */
423 >                normalize(disp);
424 >                d = dnew = dorg + coneh*fdir2diff(rV.wd[li],disp)*DIRPEN;
425 >        }
426 >                                /* compute adjusted apex position */
427 >        disp[0] *= d; disp[1] *= d; disp[2] *= d;
428 >        apex[0] = odev.v.vp[0] + disp[0];
429 >        apex[1] = odev.v.vp[1] + disp[1];
430 >        apex[2] = odev.v.vp[2] + disp[2];
431 >                                /* compute view position and base offset */
432 >        h = DOT(disp,odev.v.hvec)/(dnew*odev.v.hn2);
433 >        v = DOT(disp,odev.v.vvec)/(dnew*odev.v.vn2);
434 >        if (fabs(h - odev.v.hoff) > 0.5 || fabs(v - odev.v.voff) > 0.5)
435 >                return;         /* clipped off screen */
436 >        if (dorg < mindepth)
437 >                mindepth = dorg;
438 >        if (dorg > maxdepth)
439 >                maxdepth = dorg;
440          for (i = 0; i < 3; i++)
441                  disp[i] = apex[i] + coneh*(h*odev.v.hvec[i] + v*odev.v.vvec[i]);
442 <                                        /* draw pyramid (cone approx.) */
442 >                                /* draw cone (pyramid approx.) */
443          glColor4ub(rV.rgb[li][0], rV.rgb[li][1], rV.rgb[li][2], rV.alpha[li]);
444          glBegin(GL_TRIANGLE_FAN);
445          glVertex3f(apex[0], apex[1], apex[2]);
446          for (i = 0; i < NCONEV; i++)
447                  glVertex3d(conev[i][0] + disp[0], conev[i][1] + disp[1],
448                                  conev[i][2] + disp[2]);
449 <                                        /* connect last side to first */
449 >                                /* connect last face to first */
450          glVertex3d(conev[0][0] + disp[0], conev[0][1] + disp[1],
451                          conev[0][2] + disp[2]);
452 <        glEnd();                        /* done */
452 >        glEnd();                /* done */
453 >        skipstep = SUCCSTEP;
454   }
455  
456 + #undef SUCCSTEP
457 + #undef MAXSTEP
458  
459 +
460   #define LEAFSIZ         (3*sizeof(float)+sizeof(int4)+\
461                          sizeof(TMbright)+7*sizeof(BYTE))
462  
# Line 493 | Line 508 | FreeValues()                   /* free our allocated values */
508  
509  
510   static
511 + clralphas()                     /* prepare for new alpha values */
512 + {
513 +        if (!vmaplen)
514 +                return;
515 +        free((char *)valmap);
516 +        valmap = NULL;
517 +        vmaplen = 0;
518 + }
519 +
520 +
521 + static int
522 + valcmp(v1p, v2p)                /* compare two pixel values */
523 + int     *v1p, *v2p;
524 + {
525 +        register int    v1 = *v1p, v2 = *v2p;
526 +        register int    c;
527 +
528 +        if ((c = rV.rgb[v1][0] - rV.rgb[v2][0])) return(c);
529 +        if ((c = rV.rgb[v1][1] - rV.rgb[v2][1])) return(c);
530 +        if ((c = rV.rgb[v1][2] - rV.rgb[v2][2])) return(c);
531 +        return(rV.alpha[v1] - rV.alpha[v2]);
532 + }
533 +
534 +
535 + static
536 + mergalphas(adest, al1, n1, al2, n2)     /* merge two sorted alpha lists */
537 + register int    *adest, *al1, *al2;
538 + int     n1, n2;
539 + {
540 +        register int    cmp;
541 +
542 +        while (n1 | n2) {
543 +                if (!n1) cmp = 1;
544 +                else if (!n2) cmp = -1;
545 +                else cmp = valcmp(al1, al2);
546 +                if (cmp > 0) {
547 +                        *adest++ = *al2++;
548 +                        n2--;
549 +                } else {
550 +                        *adest++ = *al1++;
551 +                        n1--;
552 +                }
553 +        }
554 + }
555 +
556 +
557 + static
558 + setalphas(vbeg, nvals)          /* add values to our map and set alphas */
559 + int     vbeg, nvals;
560 + {
561 +        register int    *newmap;
562 +        short   ccmp[3], lastalpha;
563 +        int     newmaplen;
564 +
565 +        if (nvals <= 0)
566 +                return;
567 +        newmaplen = vmaplen + nvals;    /* allocate new map */
568 +        newmap = (int *)malloc(newmaplen*sizeof(int));
569 +        if (newmap == NULL)
570 +                error(SYSTEM, "out of memory in setalphas");
571 +        while (nvals--) {               /* add new values to end */
572 +                rV.alpha[vbeg] = 255;
573 +                newmap[vmaplen+nvals] = vbeg++;
574 +        }
575 +        if (nvals >= 3*vmaplen) {       /* resort the combined array */
576 +                while (vmaplen--)
577 +                        newmap[vmaplen] = valmap[vmaplen];
578 +                qsort((char *)newmap, newmaplen, sizeof(int), valcmp);
579 +        } else {                        /* perform merge sort */
580 +                qsort((char *)(newmap+vmaplen), newmaplen-vmaplen,
581 +                                sizeof(int), valcmp);
582 +                mergalphas(newmap, valmap, vmaplen,
583 +                                newmap+vmaplen, newmaplen-vmaplen);
584 +        }
585 +        if (valmap != NULL)             /* free old map and assign new one */
586 +                free((char *)valmap);
587 +        valmap = newmap;
588 +        vmaplen = newmaplen;
589 +        lastalpha = 0;                  /* set new alpha values */
590 +        ccmp[0] = ccmp[1] = ccmp[2] = 256;
591 +        while (newmaplen--)
592 +                if (rV.rgb[*newmap][0] == ccmp[0] &&
593 +                                rV.rgb[*newmap][1] == ccmp[1] &&
594 +                                rV.rgb[*newmap][2] == ccmp[2]) {
595 +                        if (lastalpha >= 255)
596 +                                newmap++;
597 +                        else if (rV.alpha[*newmap] < 255)
598 +                                lastalpha = rV.alpha[*newmap++];
599 +                        else
600 +                                rV.alpha[*newmap++] = ++lastalpha;
601 +                } else {
602 +                        ccmp[0] = rV.rgb[*newmap][0];
603 +                        ccmp[1] = rV.rgb[*newmap][1];
604 +                        ccmp[2] = rV.rgb[*newmap][2];
605 +                        if (rV.alpha[*newmap] < 255)
606 +                                lastalpha = rV.alpha[*newmap++];
607 +                        else
608 +                                rV.alpha[*newmap++] = lastalpha = 1;
609 +                }
610 + }
611 +
612 +
613 + static
614   TMapValues(redo)                /* map our values to RGB */
615   int     redo;
616   {
# Line 521 | Line 639 | int    redo;
639                          tmAddHisto(rV.brt+borg, blen, 1);
640                  if (tmComputeMapping(0., 0., 0.) != TM_E_OK)
641                          return(0);
642 <                rV.drl = rV.bl;
642 >                clralphas();            /* restart value list */
643 >                rV.drl = rV.bl;         /* need to redraw */
644          }
645          if (tmMapPixels(rV.rgb+aorg, rV.brt+aorg,
646                          rV.chr+aorg, alen) != TM_E_OK)
# Line 529 | Line 648 | int    redo;
648          if (blen > 0)
649                  tmMapPixels(rV.rgb+borg, rV.brt+borg,
650                                  rV.chr+borg, blen);
651 <                                        /* compute unique alpha values */
652 <        rV.tml = rV.tl;
651 >        setalphas(aorg, alen);          /* compute add'l alpha values */
652 >        if (blen > 0)
653 >                setalphas(borg, blen);
654 >        rV.tml = rV.tl;                 /* we're all up to date */
655          return(1);
656   }
657  
# Line 547 | Line 668 | int    pct;
668          nclear -= rV.nl - nused;
669          if (nclear <= 0)
670                  return(0);
671 <        if (nclear >= nused) {  /* clear them all */
671 >        if (nclear >= nused) {  /* clear them all? */
672                  rV.drl = rV.tml = rV.bl = rV.tl = 0;
673                  return(nused);
674          }
# Line 603 | Line 724 | register FVECT wp[2];
724   static
725   draw_grids()                    /* draw holodeck section grids */
726   {
727 <        static GLubyte  gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
727 >        static BYTE     gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
728  
729          if (!mapped)
730                  return;
# Line 616 | Line 737 | draw_grids()                   /* draw holodeck section grids */
737  
738  
739   static int
740 + IndexValue(rgba)                /* locate a pixel by it's framebuffer value */
741 + register BYTE   rgba[4];
742 + {
743 +        register int    *vp;
744 +                                        /* check legality */
745 +        if (rgba[3] == 0 || rgba[3] == 255)
746 +                return(-1);
747 +                                        /* borrow a value slot */
748 +        rV.rgb[rV.tl][0] = rgba[0];
749 +        rV.rgb[rV.tl][1] = rgba[1];
750 +        rV.rgb[rV.tl][2] = rgba[2];
751 +        rV.alpha[rV.tl] = rgba[3];
752 +                                        /* find it */
753 +        vp = (int *)bsearch((char *)&rV.tl, (char *)valmap, vmaplen,
754 +                        sizeof(int), valcmp);
755 +        if (vp == NULL)
756 +                return(-1);
757 +        return(*vp);
758 + }
759 +
760 +
761 + static int
762   FindValue(dx, dy)               /* find a value on the display */
763   int     dx, dy;
764   {
765 <        return(-1);             /* not found */
765 >        BYTE    rgba[4];
766 >
767 >        if (dx < 0 || dy < 0 || dx >= odev.hres || dy >= odev.vres)
768 >                return(-1);
769 >        glReadPixels(dx, dy, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, rgba);
770 >        return(IndexValue(rgba));
771   }
772  
773  
# Line 681 | Line 829 | XButtonPressedEvent    *ebut;
829          int     rootx, rooty, wx, wy;
830          unsigned int    statemask;
831  
832 +        quicken = 1;                    /* accelerate update rate */
833          XNoOp(ourdisplay);
834  
835          while (!XCheckMaskEvent(ourdisplay,
# Line 702 | Line 851 | XButtonPressedEvent    *ebut;
851                  wx = levptr(XButtonReleasedEvent)->x;
852                  wy = levptr(XButtonReleasedEvent)->y;
853                  moveview(wx, odev.vres-1-wy, movdir, movorb);
854 +        } else {
855 +                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
856 +                redraw();
857          }
858 +        quicken = 0;
859          dev_flush();
860   }
861  
# Line 739 | Line 892 | register XKeyPressedEvent  *ekey;
892                  return;
893          case CTRL('R'):                 /* redraw screen */
894                  TMapValues(1);
895 +                glClear(GL_DEPTH_BUFFER_BIT);
896                  redraw();
897                  return;
898          case CTRL('L'):                 /* refresh from server */
899                  if (inpresflags & DFL(DC_REDRAW))
900                          return;
901                  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
748 –                glDrawBuffer(GL_FRONT);
902                  glDisable(GL_DEPTH_TEST);
903                  draw_grids();
904                  glEnable(GL_DEPTH_TEST);
752 –                glDrawBuffer(GL_FRONT_AND_BACK);
905                  glFlush();
906                  Compost(100);                   /* get rid of old values */
907                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
# Line 777 | Line 929 | static
929   fixwindow(eexp)                         /* repair damage to window */
930   register XExposeEvent  *eexp;
931   {
932 <        if (odev.hres == 0 || odev.vres == 0) { /* first exposure */
933 <                odev.hres = eexp->width;
782 <                odev.vres = eexp->height;
783 <        }
932 >        if (odev.hres == 0 || odev.vres == 0)   /* first exposure */
933 >                resizewindow((XConfigureEvent *)eexp);
934          if (eexp->width == odev.hres && eexp->height == odev.vres)
935                  TMapValues(1);
936 <        if (!eexp->count)
936 >        if (!eexp->count) {
937 >                glClear(GL_DEPTH_BUFFER_BIT);
938                  redraw();
939 +        }
940   }
941  
942  

Diff Legend

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