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.20 by gwlarson, Thu Aug 20 09:32:52 1998 UTC vs.
Revision 3.28 by gwlarson, Thu Jun 10 15:22:21 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 21 | Line 21 | static char SCCSid[] = "$SunId$ SGI";
21   #endif
22  
23   #include "standard.h"
24 – #include "rhd_sample.h"
24  
26 – #include <sys/types.h>
25   #include <GL/glx.h>
26   #include <GL/glu.h>
27   #ifdef STEREO
28   #include <X11/extensions/SGIStereo.h>
29   #endif
30 +
31 + #include "rhd_sample.h"
32   #ifdef DOBJ
33   #include "rhdobj.h"
34   #endif
# Line 36 | Line 36 | static char SCCSid[] = "$SunId$ SGI";
36   #include "x11icon.h"
37  
38   #ifndef RAYQLEN
39 < #define RAYQLEN         250             /* max. rays to queue before flush */
39 > #define RAYQLEN         1024            /* max. rays to queue before flush */
40   #endif
41  
42   #ifndef FEQ
# Line 45 | Line 45 | static char SCCSid[] = "$SunId$ SGI";
45  
46   #define GAMMA           1.4             /* default gamma correction */
47  
48 + #define FRAMESTATE(s)   (((s)&(ShiftMask|ControlMask))==(ShiftMask|ControlMask))
49 +
50   #define MOVPCT          7               /* percent distance to move /frame */
51   #define MOVDIR(b)       ((b)==Button1 ? 1 : (b)==Button2 ? 0 : -1)
52   #define MOVDEG          (-5)            /* degrees to orbit CW/down /frame */
53   #define MOVORB(s)       ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
54  
55   #ifndef TARGETFPS
56 < #define TARGETFPS       4.0             /* target frames/sec during motion */
56 > #define TARGETFPS       2.0             /* target frames/sec during motion */
57   #endif
58  
59   #define MINWIDTH        480             /* minimum graphics window width */
# Line 74 | Line 76 | static char SCCSid[] = "$SunId$ SGI";
76  
77   struct driver   odev;                   /* global device driver structure */
78  
79 + char odev_args[64];                     /* command arguments */
80 +
81 + #ifdef STEREO
82   static VIEW     vwright;                /* right eye view */
83 + #endif
84  
85   static int      rayqleft = 0;           /* rays left to queue before flush */
86  
# Line 99 | Line 105 | static int     inpresflags;            /* input result flags */
105   static int      headlocked = 0;         /* lock vertical motion */
106  
107   static int  resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
108 <                setglpersp(), getmove(), fixwindow(), mytmflags();
108 >                setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
109  
110   #ifdef STEREO
111   static int  pushright(), popright();
112   #endif
113 + static double   getdistance();
114 + #define mapdepth(d) ((d)> 0.9995 ? FHUGE: dev_zmin/ \
115 +                     (1.-(d)*(1.-dev_zmin/dev_zmax)))
116  
117   extern time_t   time();
118  
# Line 124 | Line 133 | char  *id;
133          XSizeHints      oursizhints;
134                                          /* check for unsupported stereo */
135   #ifdef NOSTEREO
136 <        error(USER, "stereo display driver unavailable");
136 >        error(INTERNAL, "stereo display driver unavailable");
137   #endif
138                                          /* open display server */
139          ourdisplay = XOpenDisplay(NULL);
# Line 216 | Line 225 | char  *id;
225          pheight *= 2.;
226          setstereobuf(STEREO_BUFFER_LEFT);
227   #endif
228 +        checkglerr("setting rendering parameters");
229          copystruct(&odev.v, &stdview);
230          odev.v.type = VT_PER;
231                                          /* map the window */
# Line 253 | Line 263 | dev_close()                    /* close our display and free resources
263   dev_clear()                     /* clear our representation */
264   {
265          smInit(rsL.max_samp);
266 <        wipeclean();
266 >        wipeclean(1);
267          rayqleft = 0;                   /* hold off update */
268   }
269  
# Line 272 | Line 282 | register VIEW  *nv;
282                  nv->vert = odev.v.vert;
283                  return(0);
284          }
285 <        if (nv != &odev.v &&                    /* resize window? */
286 <                        (!FEQ(nv->horiz,odev.v.horiz) ||
287 <                                !FEQ(nv->vert,odev.v.vert))) {
288 <                int     dw = DisplayWidth(ourdisplay,ourscreen);
289 <                int     dh = DisplayHeight(ourdisplay,ourscreen);
285 >        if (nv != &odev.v) {
286 >                                                /* resize window? */
287 >                if (!FEQ(nv->horiz,odev.v.horiz) ||
288 >                                !FEQ(nv->vert,odev.v.vert)) {
289 >                        int     dw = DisplayWidth(ourdisplay,ourscreen);
290 >                        int     dh = DisplayHeight(ourdisplay,ourscreen);
291  
292 <                dw -= 25;       /* for window frame */
293 <                dh -= 50;
292 >                        dw -= 25;       /* for window frame */
293 >                        dh -= 50;
294   #ifdef STEREO
295 <                dh /= 2;
295 >                        dh /= 2;
296   #endif
297 <                odev.hres = 2.*VIEWDIST/pwidth *
298 <                                tan(PI/180./2.*nv->horiz);
299 <                odev.vres = 2.*VIEWDIST/pheight *
300 <                                tan(PI/180./2.*nv->vert);
301 <                if (odev.hres > dw) {
302 <                        odev.vres = dw * odev.vres / odev.hres;
303 <                        odev.hres = dw;
297 >                        odev.hres = 2.*VIEWDIST/pwidth *
298 >                                        tan(PI/180./2.*nv->horiz);
299 >                        odev.vres = 2.*VIEWDIST/pheight *
300 >                                        tan(PI/180./2.*nv->vert);
301 >                        if (odev.hres > dw) {
302 >                                odev.vres = dw * odev.vres / odev.hres;
303 >                                odev.hres = dw;
304 >                        }
305 >                        if (odev.vres > dh) {
306 >                                odev.hres = dh * odev.hres / odev.vres;
307 >                                odev.vres = dh;
308 >                        }
309 >                        XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
310 >                        dev_input();    /* get resize event */
311                  }
312 <                if (odev.vres > dh) {
295 <                        odev.hres = dh * odev.hres / odev.vres;
296 <                        odev.vres = dh;
297 <                }
298 <                XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
299 <                dev_input();    /* get resize event */
312 >                copystruct(&odev.v, nv);        /* setview() already called */
313          }
301 –        copystruct(&odev.v, nv);        /* setview() already called */
302 –        setglpersp(&odev.v);
314   #ifdef STEREO
315          copystruct(&vwright, nv);
316          d = eyesepdist / sqrt(nv->hn2);
317          VSUM(vwright.vp, nv->vp, nv->hvec, d);
318          /* setview(&vwright);   -- Unnecessary */
319   #endif
320 <        checkglerr("setting view");
310 <        wipeclean();
320 >        wipeclean(0);
321          return(1);
322   }
323  
324  
325 + dev_section(gfn, pfn)           /* add octree for geometry rendering */
326 + char    *gfn, *pfn;
327 + {
328 +        /* unimplemented */
329 + }
330 +
331 +
332   dev_auxcom(cmd, args)           /* process an auxiliary command */
333   char    *cmd, *args;
334   {
# Line 367 | Line 384 | FVECT  d, p;
384                  return;
385          }
386   #endif
387 <        smNewSamp(c, d, p);             /* add to display representation */
371 <        if (p != NULL) {
387 >        if (p != NULL) {                /* add depth to our range */
388                  depth = (p[0] - odev.v.vp[0])*d[0] +
389                          (p[1] - odev.v.vp[1])*d[1] +
390                          (p[2] - odev.v.vp[2])*d[2];
# Line 379 | Line 395 | FVECT  d, p;
395                                  maxdpth = depth;
396                  }
397          }
398 +        smNewSamp(c, d, p);             /* add to display representation */
399          if (!--rayqleft)
400                  dev_flush();            /* flush output */
401   }
# Line 387 | Line 404 | FVECT  d, p;
404   int
405   dev_flush()                     /* flush output */
406   {
407 +        if (mapped) {
408   #ifdef STEREO
409 <        pushright();                    /* update right eye */
410 <        glClear(GL_DEPTH_BUFFER_BIT);
393 <        smUpdate(&vwright, 100);
409 >                pushright();                    /* update right eye */
410 >                smUpdate(&vwright, MAXQUALITY);
411   #ifdef DOBJ
412 <        dobj_render();                  /* usually in foreground */
412 >                dobj_render();                  /* usually in foreground */
413   #endif
414 <        popright();                     /* update left eye */
398 <        glClear(GL_DEPTH_BUFFER_BIT);
414 >                popright();                     /* update left eye */
415   #endif
416 <        smUpdate(&odev.v, 100);
416 >                smUpdate(&odev.v, MAXQUALITY);
417 >                checkglerr("rendering mesh");
418   #ifdef DOBJ
419 <        dobj_render();
419 >                dobj_render();
420   #endif
421 <        glFlush();                      /* flush OGL */
422 <        checkglerr("flushing display");
421 >                glFlush();                      /* flush OGL */
422 >        }
423          rayqleft = RAYQLEN;
424                                          /* flush X11 and return # pending */
425          return(odev.inpready = XPending(ourdisplay));
# Line 433 | Line 450 | pushright()                    /* push on right view */
450          glPushMatrix();
451          d = -eyesepdist / sqrt(odev.v.hn2);
452          glTranslated(d*odev.v.hvec[0], d*odev.v.hvec[1], d*odev.v.hvec[2]);
453 +        checkglerr("setting right view");
454   }
455  
456  
# Line 485 | Line 503 | getevent()                     /* get next event */
503                  getkey(levptr(XKeyPressedEvent));
504                  break;
505          case ButtonPress:
506 <                getmove(levptr(XButtonPressedEvent));
506 >                if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
507 >                        getframe(levptr(XButtonPressedEvent));
508 >                else
509 >                        getmove(levptr(XButtonPressedEvent));
510                  break;
511          }
512   }
# Line 501 | Line 522 | register FVECT wp[2];
522  
523  
524   static
525 < draw_grids()                    /* draw holodeck section grids */
525 > draw_grids(fore)                /* draw holodeck section grids */
526 > int     fore;
527   {
528 <        static BYTE     gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
529 <
530 <        if (!mapped)
531 <                return;
510 <        glColor4ub(gridrgba[0], gridrgba[1], gridrgba[2], gridrgba[3]);
528 >        if (fore)
529 >                glColor4ub(0, 255, 255, 0);
530 >        else
531 >                glColor4ub(0, 0, 0, 0);
532          glBegin(GL_LINES);              /* draw each grid line */
533          gridlines(draw3dline);
534          glEnd();
535 +        checkglerr("drawing grid lines");
536   }
537  
538 + static double
539 + getdistance(dx, dy, direc)      /* distance from fore plane along view ray */
540 + int     dx, dy;
541 + FVECT   direc;
542 + {
543 +        GLfloat gldepth;
544 +        double  dist;
545  
546 +        if (dx<0 | dx>=odev.hres | dy<0 | dy>=odev.vres)
547 +                return(FHUGE);
548 +        glReadPixels(dx,dy, 1,1, GL_DEPTH_COMPONENT,GL_FLOAT, &gldepth);
549 +        dist = mapdepth(gldepth);
550 +        if (dist >= .99*FHUGE)
551 +                return(FHUGE);
552 +        return((dist-odev.v.vfore)/DOT(direc,odev.v.vdir));
553 + }
554 +
555 +
556   static
557   moveview(dx, dy, mov, orb)      /* move our view */
558   int     dx, dy, mov, orb;
559   {
560          VIEW    nv;
561          FVECT   odir, v1, wip;
562 <        double  d;
562 >        double  d,d1;
563          register int    li;
564                                  /* start with old view */
565          copystruct(&nv, &odev.v);
566 <                                /* change view direction */
566 >                                /* orient our motion */
567          if (viewray(v1, odir, &odev.v,
568                          (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
569                  return(0);              /* outside view */
570 <        if (mov | orb) {
570 >        if (mov | orb) {        /* moving relative to geometry */
571 >                d = getdistance(dx, dy, odir);/*distance from front plane */
572   #ifdef DOBJ
573 <                d = dobj_trace(v1, odir);       /* check objects */
574 <                                                /* is holodeck in front? */
575 <                if ((li = smFindSamp(v1, odir)) >= 0 &&
576 <                                (rsL.wp[li][0] - nv.vp[0])*odir[0] +
537 <                                (rsL.wp[li][1] - nv.vp[1])*odir[1] +
538 <                                (rsL.wp[li][2] - nv.vp[2])*odir[2] < d)
539 <                        VCOPY(wip, rsL.wp[li]);
540 <                else if (d < .99*FHUGE)         /* object is closer */
541 <                        VSUM(wip, nv.vp, odir, d);
542 <                else                            /* nothing visible */
543 <                        return(0);
544 < #else
545 <                if ((li = smFindSamp(v1, odir)) < 0)
546 <                        return(0);      /* not on window */
547 <                VCOPY(wip, rsL.wp[li]);
573 >                d1 = dobj_trace(NULL, v1, odir);        /* check objects */
574 >                                                /* check holodeck */
575 >                if (d1 < d)
576 >                        d = d1;
577   #endif
578 <                VSUM(odir, wip, nv.vp, -1.);
579 <        } else
578 >                if (d >= .99*FHUGE)
579 >                        d = 0.5*(dev_zmax+dev_zmin);    /* just guess */
580 >                VSUM(wip, v1, odir, d);
581 >                VSUB(odir, wip, odev.v.vp);
582 > #if 0
583 >                fprintf(stderr, "moveview: hit %s at (%f,%f,%f) (t=%f)\n",
584 >                                li < 0 ? "object" : "mesh",
585 >                                wip[0], wip[1], wip[2],
586 >                                (wip[0]-odev.v.vp[0])*odir[0] +
587 >                                (wip[1]-odev.v.vp[1])*odir[1] +
588 >                                (wip[2]-odev.v.vp[2])*odir[2]);
589 > #endif
590 >        } else                  /* panning with constant viewpoint */
591                  VCOPY(nv.vdir, odir);
592          if (orb && mov) {               /* orbit left/right */
593                  spinvector(odir, odir, nv.vup, d=MOVDEG*PI/180.*mov);
# Line 566 | Line 606 | int    dx, dy, mov, orb;
606          }
607          if (!mov ^ !orb && headlocked) {        /* restore head height */
608                  VSUM(v1, odev.v.vp, nv.vp, -1.);
609 <                d = DOT(v1, odev.v.vup);
609 >                d = DOT(v1, nv.vup);
610                  VSUM(nv.vp, nv.vp, odev.v.vup, d);
611          }
612          if (setview(&nv) != NULL)
# Line 578 | Line 618 | int    dx, dy, mov, orb;
618  
619  
620   static
621 + getframe(ebut)                          /* get focus frame */
622 + XButtonPressedEvent     *ebut;
623 + {
624 +        int     startx = ebut->x, starty = ebut->y;
625 +        int     endx, endy;
626 +
627 +        XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
628 +        endx = levptr(XButtonReleasedEvent)->x;
629 +        endy = levptr(XButtonReleasedEvent)->y;
630 +        if (endx == startx | endy == starty) {
631 +                XBell(ourdisplay, 0);
632 +                return;
633 +        }
634 +        if (endx < startx) {register int c = endx; endx = startx; startx = c;}
635 +        if (endy < starty) {register int c = endy; endy = starty; starty = c;}
636 +        sprintf(odev_args, "%.3f %.3f %.3f %.3f",
637 +                        (startx+.5)/odev.hres, 1.-(endy+.5)/odev.vres,
638 +                        (endx+.5)/odev.hres, 1.-(starty+.5)/odev.vres);
639 +        inpresflags |= DFL(DC_FOCUS);
640 + }
641 +
642 +
643 + static
644   getmove(ebut)                           /* get view change */
645   XButtonPressedEvent     *ebut;
646   {
647          int     movdir = MOVDIR(ebut->button);
648          int     movorb = MOVORB(ebut->state);
649 <        int     qlevel = 99;
649 >        int     qlevel = MAXQUALITY-1;
650          time_t  lasttime, thistime;
651          int     nframes;
652          Window  rootw, childw;
653          int     rootx, rooty, wx, wy;
654          unsigned int    statemask;
655  
656 <        XNoOp(ourdisplay);
656 >        XNoOp(ourdisplay);              /* makes sure we're not idle */
657  
658 <        lasttime = time(0); nframes = 0;
658 >        nframes = 0;
659          while (!XCheckMaskEvent(ourdisplay,
660                          ButtonReleaseMask, levptr(XEvent))) {
661 <
661 >                                        /* get cursor position */
662                  if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
663                                  &rootx, &rooty, &wx, &wy, &statemask))
664                          break;          /* on another screen */
665  
666 +                draw_grids(0);          /* clear old grid lines */
667 + #ifdef STEREO
668 +                pushright(); draw_grids(0); popright();
669 + #endif
670 +                                        /* compute view motion */
671                  if (!moveview(wx, odev.vres-1-wy, movdir, movorb)) {
672                          sleep(1);
673                          lasttime++;
674 <                        continue;
674 >                        continue;       /* cursor in bad place */
675                  }
676 +                draw_grids(1);          /* redraw grid */
677   #ifdef STEREO
678                  pushright();
679 <                glClear(GL_COLOR_BUFFER_BIT);
611 <                draw_grids();
679 >                draw_grids(1);
680                  smUpdate(&vwright, qlevel);
681   #ifdef DOBJ
682                  dobj_render();
683   #endif
684                  popright();
685   #endif
686 <                glClear(GL_COLOR_BUFFER_BIT);
619 <                draw_grids();
686 >                                        /* redraw mesh */
687                  smUpdate(&odev.v, qlevel);
688   #ifdef DOBJ
689 <                dobj_render();
689 >                dobj_render();          /* redraw object */
690   #endif
691                  glFlush();
692 <                checkglerr("moving view");
693 <                nframes++;
692 >                                        /* figure out good quality level */
693 >                if (!nframes++) {               /* ignore first frame */
694 >                        lasttime = time(0);
695 >                        continue;
696 >                }
697                  thistime = time(0);
698 <                if (thistime - lasttime >= 3 ||
698 >                if (thistime - lasttime >= 6 ||
699                                  nframes > (int)(3*3*TARGETFPS)) {
700 <                        qlevel = thistime<=lasttime ? 1000 :
700 >                        qlevel = thistime<=lasttime ? 3*MAXQUALITY :
701                                  (int)((double)nframes/(thistime-lasttime)
702                                          / TARGETFPS * qlevel + 0.5);
703 <                        lasttime = thistime; nframes = 0;
704 <                        if (qlevel > 99) {
705 <                                if (qlevel > 300) {     /* put on the brakes */
703 >                        nframes = 0;
704 >                        if (qlevel >= MAXQUALITY) {
705 >                                if (qlevel >= 3*MAXQUALITY) {   /* brakes!! */
706                                          sleep(1);
707                                          lasttime++;
708                                  }
709 <                                qlevel = 99;
709 >                                qlevel = MAXQUALITY-1;
710                          } else if (qlevel < 1)
711                                  qlevel = 1;
712                  }
# Line 657 | Line 727 | register VIEW  *vp;
727          double  d, xmin, xmax, ymin, ymax;
728  
729          if (mindpth >= maxdpth) {
730 <                dev_zmin = 0.1;
730 >                dev_zmin = 1.;
731                  dev_zmax = 100.;
732          } else {
733 <                dev_zmin = 0.5*mindpth;
734 <                dev_zmax = 1.5*maxdpth;
665 <                if (dev_zmin > dev_zmax/100.)
666 <                        dev_zmin = dev_zmax/100.;
733 >                dev_zmin = 0.1*mindpth;
734 >                dev_zmax = 5.0*maxdpth;
735          }
736          if (odev.v.vfore > FTINY)
737                  dev_zmin = odev.v.vfore;
738          if (odev.v.vaft > FTINY)
739                  dev_zmax = odev.v.vaft;
740 <        if (dev_zmin < dev_zmax/5000.)
741 <                dev_zmin = dev_zmax/5000.;
740 >        if (dev_zmin < dev_zmax/500.)
741 >                dev_zmin = dev_zmax/500.;
742          xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
743          xmin = -xmax;
744          d = odev.v.hoff * (xmax - xmin);
# Line 688 | Line 756 | register VIEW  *vp;
756                  odev.v.vp[1] + odev.v.vdir[1],
757                  odev.v.vp[2] + odev.v.vdir[2],
758                  odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
759 +        checkglerr("setting perspective view");
760   }
761  
762  
763   static
764 < wipeclean()                     /* prepare for redraw */
764 > wipeclean(tmflag)                       /* prepare for redraw */
765 > int     tmflag;
766   {
767 +                                        /* clear depth buffer */
768   #ifdef STEREO
769          setstereobuf(STEREO_BUFFER_RIGHT);
770          glClear(GL_DEPTH_BUFFER_BIT);
771          setstereobuf(STEREO_BUFFER_LEFT);
772   #endif
773          glClear(GL_DEPTH_BUFFER_BIT);
774 <        smClean();
774 >        smClean(tmflag);                /* reset drawing routines */
775 >        setglpersp(&odev.v);            /* reset view & clipping planes */
776   }
777  
778  
# Line 708 | Line 780 | static
780   getkey(ekey)                            /* get input key */
781   register XKeyPressedEvent  *ekey;
782   {
783 +        Window  rootw, childw;
784 +        int     rootx, rooty, wx, wy;
785 +        unsigned int    statemask;
786          int  n;
787          char    buf[8];
788  
# Line 730 | Line 805 | register XKeyPressedEvent  *ekey;
805          case 'v':                       /* spit out view */
806                  inpresflags |= DFL(DC_GETVIEW);
807                  return;
808 +        case 'f':                       /* frame view position */
809 +                if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
810 +                                &rootx, &rooty, &wx, &wy, &statemask))
811 +                        return;         /* on another screen */
812 +                sprintf(odev_args, "%.4f %.4f", (wx+.5)/odev.hres,
813 +                                1.-(wy+.5)/odev.vres);
814 +                inpresflags |= DFL(DC_FOCUS);
815 +                return;
816 +        case 'F':                       /* unfocus */
817 +                odev_args[0] = '\0';
818 +                inpresflags |= DFL(DC_FOCUS);
819 +                return;
820          case '\n':
821          case '\r':                      /* resume computation */
822                  inpresflags |= DFL(DC_RESUME);
823                  return;
824          case CTRL('R'):                 /* redraw screen */
825 <                wipeclean();
825 >                wipeclean(1);
826                  return;
827          case CTRL('L'):                 /* refresh from server */
828                  if (inpresflags & DFL(DC_REDRAW))
829                          return;
830 +                setglpersp(&odev.v);            /* reset clipping planes */
831                  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
832 <                glDisable(GL_DEPTH_TEST);
833 <                draw_grids();
832 >                glDisable(GL_DEPTH_TEST);       /* so grids will clear */
833 >                draw_grids(1);
834   #ifdef STEREO
835                  pushright();
836                  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
837 <                draw_grids();
837 >                draw_grids(1);
838                  popright();
839   #endif
840                  glEnable(GL_DEPTH_TEST);
# Line 784 | Line 872 | register XExposeEvent  *eexp;
872          }
873          if (eexp->count)                /* wait for final exposure */
874                  return;
875 <        wipeclean();                    /* clear depth */
875 >        wipeclean(0);                   /* clear depth */
876   }
877  
878  

Diff Legend

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