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.8 by gwlarson, Tue Dec 22 10:18:44 1998 UTC vs.
Revision 3.29 by greg, Tue May 23 13:01:07 2006 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 + #include "paths.h"
32   #ifdef DOBJ
33   #include "rhdobj.h"
34   #endif
# Line 37 | Line 36 | static char SCCSid[] = "$SunId$ SGI";
36   #include "x11icon.h"
37  
38   #ifndef RAYQLEN
39 < #define RAYQLEN         50000           /* max. rays to queue before flush */
39 > #define RAYQLEN         0               /* max. rays to queue before flush */
40   #endif
41 <
42 <                        /* values other than 0 or 255 do not map reliably */
43 < #ifndef PORTALP
45 < #define PORTRED         0               /* -1, 0 or 255 */
46 < #define PORTGRN         -1              /* -1, 0 or 255 */
47 < #define PORTBLU         255             /* -1, 0 or 255 */
48 < #define PORTALP         -1              /* -1 or 255 */
41 > #ifndef MINWIDTH
42 > #define MINWIDTH        480             /* minimum graphics window width */
43 > #define MINHEIGHT       400             /* minimum graphics window height */
44   #endif
45 < #define isportal(c)     ((PORTRED<0 || (c)[0]==PORTRED) && \
46 <                                (PORTGRN<0 || (c)[1]==PORTGRN) && \
47 <                                (PORTBLU<0 || (c)[2]==PORTBLU) && \
48 <                                (PORTALP<0 || (c)[3]==PORTALP))
49 < #define doportals()     if (gmPortals) \
50 <                        gmDrawPortals(PORTRED,PORTGRN,PORTBLU,PORTALP); else
45 > #ifndef VIEWDIST
46 > #define VIEWDIST        356             /* assumed viewing distance (mm) */
47 > #endif
48 > #ifndef BORWIDTH
49 > #define BORWIDTH        5               /* border width */
50 > #endif
51  
52   #ifndef FEQ
53   #define FEQ(a,b)        ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
# Line 74 | Line 69 | static char SCCSid[] = "$SunId$ SGI";
69   #define MOVDEG          (-5)            /* degrees to orbit CW/down /frame */
70   #define MOVORB(s)       ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
71  
77 – #define MINWIDTH        480             /* minimum graphics window width */
78 – #define MINHEIGHT       400             /* minimum graphics window height */
79 –
80 – #define VIEWDIST        356             /* assumed viewing distance (mm) */
81 –
82 – #define BORWIDTH        5               /* border width */
83 –
72   #define setstereobuf(bid)       (glXWaitGL(), \
73                                  XSGISetStereoBuffer(ourdisplay, gwind, bid), \
74                                  glXWaitX())
# Line 94 | Line 82 | static char SCCSid[] = "$SunId$ SGI";
82  
83   struct driver   odev;                   /* global device driver structure */
84  
85 + TMstruct        *tmGlobal;              /* global tone-mapping structure */
86 +
87   char odev_args[64];                     /* command arguments */
88  
89   static GLfloat  *depthbuffer = NULL;    /* depth buffer */
# Line 126 | Line 116 | static int     inpresflags;            /* input result flags */
116  
117   static int      viewflags;              /* what's happening with view */
118  
119 + /*
120   static int  resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
121                  xferdepth(), freedepth(), setglortho(),
122                  setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
123  
124   static double   getdistance();
125 + */
126 + static void checkglerr(char *where);
127 + static void xferdepth(void);
128 + static void freedepth(void);
129 + static double getdistance(int dx, int dy, FVECT direc);
130 + static int mytmflags(void);
131 + static void getevent(void);
132 + static void draw3dline(register FVECT wp[2]);
133 + static void draw_grids(int fore);
134 + static int moveview(int dx, int dy, int mov, int orb);
135 + static void getframe(XButtonPressedEvent *ebut);
136 + static void getmove(XButtonPressedEvent *ebut);
137 + static void getkey(register XKeyPressedEvent *ekey);
138 + static void fixwindow(register XExposeEvent *eexp);
139 + static void resizewindow(register XConfigureEvent *ersz);
140 + static void waitabit(void);
141 + static void setglpersp(void);
142 + static void setglortho(void);
143 + static void wipeclean(void);
144  
145 +
146   #ifdef STEREO
147 < static int  pushright(), popright();
147 > static void pushright(void);
148 > static void popright(void);
149   #endif
150  
151   extern int      gmPortals;      /* GL portal list id */
# Line 141 | Line 153 | extern int     gmPortals;      /* GL portal list id */
153   extern time_t   time();
154  
155  
156 + extern void
157   dev_open(id)                    /* initialize GLX driver */
158   char  *id;
159   {
160          extern char     *getenv();
161          static RGBPRIMS myprims = STDPRIMS;
149 – #if (PORTALP<0)
162          static int      atlBest[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
163                                  GLX_RED_SIZE,8, GLX_GREEN_SIZE,8,
164                                  GLX_BLUE_SIZE,8, GLX_DEPTH_SIZE,15, None};
165          static int      atlOK[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
166                                  GLX_RED_SIZE,4, GLX_GREEN_SIZE,4,
167                                  GLX_BLUE_SIZE,4, GLX_DEPTH_SIZE,15, None};
156 – #else
157 –        static int      atlBest[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
158 –                                GLX_RED_SIZE,8, GLX_GREEN_SIZE,8,
159 –                                GLX_BLUE_SIZE,8, GLX_ALPHA_SIZE,1,
160 –                                GLX_DEPTH_SIZE,15, None};
161 –        static int      atlOK[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
162 –                                GLX_RED_SIZE,5, GLX_GREEN_SIZE,5,
163 –                                GLX_BLUE_SIZE,5, GLX_ALPHA_SIZE,1,
164 –                                GLX_DEPTH_SIZE,15, None};
165 – #endif
168          char    *ev;
169          double  gamval = GAMMA;
170          RGBPRIMP        dpri = stdprims;
# Line 209 | Line 211 | char  *id;
211                                  &myprims[BLU][CIEX],&myprims[BLU][CIEY],
212                                  &myprims[WHT][CIEX],&myprims[WHT][CIEY]) >= 6)
213                  dpri = myprims;
214 <        if (tmInit(mytmflags(), dpri, gamval) == NULL)
214 >        tmGlobal = tmInit(mytmflags(), dpri, gamval);
215 >        if (tmGlobal == NULL)
216                  error(SYSTEM, "not enough memory in dev_open");
217                                          /* open window */
218          ourwinattr.background_pixel = ourblack;
# Line 232 | Line 235 | char  *id;
235                                          /* set window manager hints */
236          ourxwmhints.flags = InputHint|IconPixmapHint;
237          ourxwmhints.input = True;
238 <        ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay,
239 <                        gwind, x11icon_bits, x11icon_width, x11icon_height);
238 >        ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay, gwind,
239 >                        (char *)x11icon_bits, x11icon_width, x11icon_height);
240          XSetWMHints(ourdisplay, gwind, &ourxwmhints);
241          oursizhints.min_width = MINWIDTH;
242   #ifdef STEREO
# Line 251 | Line 254 | char  *id;
254          glXMakeCurrent(ourdisplay, gwind, gctx);
255          glEnable(GL_DEPTH_TEST);
256          glDepthFunc(GL_LEQUAL);
257 <        glEnable(GL_DITHER);
257 >        glClearColor(0, 0, 0, 0);
258          glFrontFace(GL_CCW);
259          glDisable(GL_CULL_FACE);
260          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
261          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
262 +        glPixelStorei(GL_PACK_ALIGNMENT, 1);
263 +        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
264                                          /* figure out sensible view */
265          pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
266                          DisplayWidth(ourdisplay, ourscreen);
# Line 266 | Line 271 | char  *id;
271          setstereobuf(STEREO_BUFFER_LEFT);
272   #endif
273          checkglerr("setting rendering parameters");
274 <        copystruct(&odev.v, &stdview);
274 >        odev.v = stdview;
275          odev.v.type = VT_PER;
276          viewflags = VWSTEADY;           /* view starts static */
277                                          /* map the window */
278          XMapWindow(ourdisplay, gwind);
279          dev_input();                    /* sets size and view angles */
280          if (!odInit(DisplayWidth(ourdisplay,ourscreen) *
281 <                        DisplayHeight(ourdisplay,ourscreen) / 4))
281 >                        DisplayHeight(ourdisplay,ourscreen) / 3))
282                  error(SYSTEM, "insufficient memory for value storage");
283          odev.name = id;
284          odev.firstuse = 1;              /* can't recycle samples */
# Line 281 | Line 286 | char  *id;
286   }
287  
288  
289 < dev_close()                     /* close our display and free resources */
289 > extern void
290 > dev_close(void)                 /* close our display and free resources */
291   {
292   #ifdef DOBJ
293          dobj_cleanup();
# Line 296 | Line 302 | dev_close()                    /* close our display and free resources
302          gwind = 0;
303          XCloseDisplay(ourdisplay);
304          ourdisplay = NULL;
305 <        tmDone(NULL);
305 >        tmDone(tmGlobal);
306          odev.v.type = 0;
307          odev.hres = odev.vres = 0;
308          odev.ifd = -1;
309   }
310  
311  
312 < dev_clear()                     /* clear our representation */
312 > extern void
313 > dev_clear(void)                 /* clear our representation */
314   {
315 <        wipeclean();
315 >        viewflags |= VWCHANGE;          /* pretend our view has changed */
316 >        wipeclean();                    /* clean off display and samples */
317 >        dev_flush();                    /* redraw geometry & get depth */
318          rayqleft = 0;                   /* hold off update */
319   }
320  
321  
322 < int
323 < dev_view(nv)                    /* assign new driver view */
324 < register VIEW   *nv;
322 > extern int
323 > dev_view(                       /* assign new driver view */
324 >        register VIEW   *nv
325 > )
326   {
327 + #ifdef STEREO
328          double  d;
329 <
329 > #endif
330          if (nv->type != VT_PER ||               /* check view legality */
331                          nv->horiz > 160. || nv->vert > 160.) {
332                  error(COMMAND, "illegal view type/angle");
# Line 351 | Line 362 | register VIEW  *nv;
362                          XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
363                          dev_input();    /* get resize event */
364                  }
365 <                copystruct(&odev.v, nv);        /* setview() already called */
355 < #ifdef STEREO
356 <                copystruct(&vwright, nv);
357 <                d = eyesepdist / sqrt(nv->hn2);
358 <                VSUM(vwright.vp, nv->vp, nv->hvec, d);
359 <                /* setview(&vwright);   -- Unnecessary */
360 < #endif
365 >                odev.v = *nv;   /* setview() already called */
366                  viewflags |= VWCHANGE;
367          }
368 + #ifdef STEREO
369 +        vwright = *nv;
370 +        d = eyesepdist / sqrt(nv->hn2);
371 +        VSUM(vwright.vp, nv->vp, nv->hvec, d);
372 +        /* setview(&vwright);   -- Unnecessary */
373 + #endif
374          wipeclean();
375          return(1);
376   }
377  
378  
379 < dev_section(gfn, pfn)           /* add octree for geometry rendering */
380 < char    *gfn, *pfn;
379 > extern void
380 > dev_section(            /* add octree for geometry rendering */
381 >        char    *gfn,
382 >        char    *pfn
383 > )
384   {
371 –        extern char     *index();
372 –        char    *cp;
373 –
385          if (gfn == NULL) {
386                  gmEndGeom();
387                  gmEndPortal();
# Line 390 | Line 401 | char   *gfn, *pfn;
401   }
402  
403  
404 < dev_auxcom(cmd, args)           /* process an auxiliary command */
405 < char    *cmd, *args;
404 > extern void
405 > dev_auxcom(             /* process an auxiliary command */
406 >        char    *cmd,
407 >        char    *args
408 > )
409   {
410   #ifdef DOBJ
411 <        if (dobj_command(cmd, args) >= 0)
411 >        int     vischange;
412 >
413 >        if ((vischange = dobj_command(cmd, args)) >= 0) {
414 >                if (vischange) {
415 >                        imm_mode = beam_sync(1) > 0;
416 >                        dev_clear();
417 >                }
418                  return;
419 +        }
420   #endif
421          sprintf(errmsg, "%s: unknown command", cmd);
422          error(COMMAND, errmsg);
423   }
424  
425  
426 < VIEW *
427 < dev_auxview(n, hvres)           /* return nth auxiliary view */
428 < int     n;
429 < int     hvres[2];
426 > extern VIEW *
427 > dev_auxview(            /* return nth auxiliary view */
428 >        int     n,
429 >        int     hvres[2]
430 > )
431   {
432          hvres[0] = odev.hres; hvres[1] = odev.vres;
433          if (n == 0)
# Line 418 | Line 440 | int    hvres[2];
440   }
441  
442  
443 < int
444 < dev_input()                     /* get X11 input */
443 > extern int
444 > dev_input(void)                 /* get X11 input */
445   {
446          inpresflags = 0;
447  
# Line 434 | Line 456 | dev_input()                    /* get X11 input */
456   }
457  
458  
459 < dev_value(c, d, p)              /* add a pixel value to our texture */
460 < COLR    c;
461 < FVECT   d, p;
459 > extern void
460 > dev_value(              /* add a pixel value to our texture */
461 >        COLR    c,
462 >        FVECT   d,
463 >        FVECT   p
464 > )
465   {
466   #ifdef DOBJ
467          if (dobj_lightsamp != NULL) {   /* in light source sampling */
# Line 450 | Line 475 | FVECT  d, p;
475   }
476  
477  
478 < int
479 < dev_flush()                     /* flush output as appropriate */
478 > extern int
479 > dev_flush(void)                 /* flush output as appropriate */
480   {
481          int     ndrawn;
482  
# Line 462 | Line 487 | dev_flush()                    /* flush output as appropriate */
487   #ifdef DOBJ
488                  ndrawn += dobj_render();
489   #endif
465 –                if (ndrawn)
466 –                        doportals();
490                  checkglerr("rendering right eye");
491                  popright();                     /* draw left eye */
492   #endif
# Line 471 | Line 494 | dev_flush()                    /* flush output as appropriate */
494   #ifdef DOBJ
495                  ndrawn += dobj_render();
496   #endif
474 –                if (ndrawn)
475 –                        doportals();
497                  glXSwapBuffers(ourdisplay, gwind);
498                  checkglerr("rendering base view");
499          }
# Line 501 | Line 522 | dev_flush()                    /* flush output as appropriate */
522   }
523  
524  
525 < checkglerr(where)               /* check for GL or GLU error */
526 < char    *where;
525 > static void
526 > checkglerr(             /* check for GL or GLU error */
527 >        char    *where
528 > )
529   {
530          register GLenum errcode;
531  
# Line 514 | Line 537 | char   *where;
537   }
538  
539  
540 < static
541 < xferdepth()                     /* load and clear depth buffer */
540 > static void
541 > xferdepth(void)                 /* load and clear depth buffer */
542   {
543          register GLfloat        *dbp;
544 <        register GLubyte        *cbuf;
544 >        register GLubyte        *pbuf;
545  
546          if (depthbuffer == NULL) {      /* allocate private depth buffer */
547   #ifdef STEREO
# Line 531 | Line 554 | xferdepth()                    /* load and clear depth buffer */
554          }
555                                  /* allocate alpha buffer for portals */
556          if (gmPortals)
557 <                cbuf = (GLubyte *)malloc(odev.hres*odev.vres *
535 <                                                        (4*sizeof(GLubyte)));
557 >                pbuf = (GLubyte *)malloc(odev.hres*odev.vres*sizeof(GLubyte));
558          else
559 <                cbuf = NULL;
559 >                pbuf = NULL;
560   #ifdef STEREO
561 <        setstereobuf(STEREO_BUFFER_RIGHT);
561 >        pushright();
562          glReadPixels(0, 0, odev.hres, odev.vres,
563                          GL_DEPTH_COMPONENT, GL_FLOAT, depthright);
564 <        if (cbuf != NULL)
564 >        if (pbuf != NULL) {
565 >                glClear(GL_COLOR_BUFFER_BIT);
566 >                gmDrawPortals(0xff, -1, -1, -1);
567                  glReadPixels(0, 0, odev.hres, odev.vres,
568 <                                GL_RGBA, GL_UNSIGNED_BYTE, cbuf);
568 >                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
569 >        }
570          for (dbp = depthright + odev.hres*odev.vres; dbp-- > depthright; )
571 <                if (cbuf != NULL && isportal(cbuf+4*(dbp-depthright)))
571 >                if (pbuf != NULL && pbuf[dbp-depthright]&0x40)
572                          *dbp = FHUGE;
573                  else
574                          *dbp = mapdepth(*dbp);
575          glClear(GL_DEPTH_BUFFER_BIT);
551 –        setstereobuf(STEREO_BUFFER_LEFT);
576          odDepthMap(1, depthright);
577 +        popright();
578   #endif
579                                  /* read back depth buffer */
580          glReadPixels(0, 0, odev.hres, odev.vres,
581                          GL_DEPTH_COMPONENT, GL_FLOAT, depthbuffer);
582 <        if (cbuf != NULL)
582 >        if (pbuf != NULL) {
583 >                glClear(GL_COLOR_BUFFER_BIT);           /* find portals */
584 >                gmDrawPortals(0xff, -1, -1, -1);
585                  glReadPixels(0, 0, odev.hres, odev.vres,
586 <                                GL_RGBA, GL_UNSIGNED_BYTE, cbuf);
586 >                                GL_RED, GL_UNSIGNED_BYTE, pbuf);
587 > #ifdef DEBUG
588 >                glXSwapBuffers(ourdisplay, gwind);
589 > #endif
590 >        }
591          for (dbp = depthbuffer + odev.hres*odev.vres; dbp-- > depthbuffer; )
592 <                if (cbuf != NULL && isportal(cbuf+4*(dbp-depthbuffer)))
592 >                if (pbuf != NULL && pbuf[dbp-depthbuffer]&0x40)
593                          *dbp = FHUGE;
594                  else
595                          *dbp = mapdepth(*dbp);
596          glClear(GL_DEPTH_BUFFER_BIT);           /* clear system depth buffer */
566 –        if (cbuf != NULL)
567 –                free((char *)cbuf);             /* free our color buffer */
597          odDepthMap(0, depthbuffer);             /* transfer depth data */
598 +        if (pbuf != NULL)
599 +                free((void *)pbuf);             /* free our portal buffer */
600   }
601  
602  
603 < static
604 < freedepth()                             /* free recorded depth buffer */
603 > static void
604 > freedepth(void)                         /* free recorded depth buffer */
605   {
606          if (depthbuffer == NULL)
607                  return;
608   #ifdef STEREO
609          odDepthMap(1, NULL);
610 <        free((char *)depthright);
610 >        free((void *)depthright);
611          depthright = NULL;
612   #endif
613          odDepthMap(0, NULL);
614 <        free((char *)depthbuffer);
614 >        free((void *)depthbuffer);
615          depthbuffer = NULL;
616   }
617  
618  
619   static double
620 < getdistance(dx, dy, direc)      /* distance from fore plane along view ray */
621 < int     dx, dy;
622 < FVECT   direc;
620 > getdistance(    /* distance from fore plane along view ray */
621 >        int     dx,
622 >        int     dy,
623 >        FVECT   direc
624 > )
625   {
626          GLfloat gldepth;
594 –        GLubyte glcolor[4];
627          double  dist;
628  
629 <        if (dx<0 | dx>=odev.hres | dy<0 | dy>=odev.vres)
629 >        if ((dx<0) | (dx>=odev.hres) | (dy<0) | (dy>=odev.vres))
630                  return(FHUGE);
631          if (depthbuffer != NULL)
632                  dist = depthbuffer[dy*odev.hres + dx];
633          else {
634                  glReadPixels(dx,dy, 1,1, GL_DEPTH_COMPONENT,
635                                  GL_FLOAT, &gldepth);
636 <                if (gmPortals) {
637 <                        glReadPixels(dx,dy, 1,1, GL_RGBA,
606 <                                        GL_UNSIGNED_BYTE, glcolor);
607 <                        if (isportal(glcolor))
608 <                                return(FHUGE);
609 <                }
636 >                if (gldepth <= FTINY)
637 >                        return (FHUGE); /* call failed */
638                  dist = mapdepth(gldepth);
639          }
640          if (dist >= .99*FHUGE)
# Line 616 | Line 644 | FVECT  direc;
644  
645  
646   #ifdef STEREO
647 < static
648 < pushright()                     /* push on right view & buffer */
647 > static void
648 > pushright(void)                 /* push on right view & buffer */
649   {
650          double  d;
651  
# Line 633 | Line 661 | pushright()                    /* push on right view & buffer */
661   }
662  
663  
664 < static
665 < popright()                      /* pop off right view & buffer */
664 > static void
665 > popright(void)                  /* pop off right view & buffer */
666   {
667          if (viewflags & VWPERSP) {
668                  glMatrixMode(GL_MODELVIEW);
# Line 646 | Line 674 | popright()                     /* pop off right view & buffer */
674  
675  
676   static int
677 < mytmflags()                     /* figure out tone mapping flags */
677 > mytmflags(void)                 /* figure out tone mapping flags */
678   {
679          extern char     *progname;
680          register char   *cp, *tail;
# Line 670 | Line 698 | mytmflags()                    /* figure out tone mapping flags */
698   }
699  
700  
701 < static
702 < getevent()                      /* get next event */
701 > static void
702 > getevent(void)                  /* get next event */
703   {
704          XNextEvent(ourdisplay, levptr(XEvent));
705          switch (levptr(XEvent)->type) {
# Line 701 | Line 729 | getevent()                     /* get next event */
729   }
730  
731  
732 < static
733 < draw3dline(wp)                  /* draw 3d line in world coordinates */
734 < register FVECT  wp[2];
732 > static void
733 > draw3dline(                     /* draw 3d line in world coordinates */
734 >        register FVECT  wp[2]
735 > )
736   {
737          glVertex3d(wp[0][0], wp[0][1], wp[0][2]);
738          glVertex3d(wp[1][0], wp[1][1], wp[1][2]);
739   }
740  
741  
742 < static
743 < draw_grids(fore)                /* draw holodeck section grids */
744 < int     fore;
742 > static void
743 > draw_grids(             /* draw holodeck section grids */
744 >        int     fore
745 > )
746   {
747          glPushAttrib(GL_LIGHTING_BIT|GL_ENABLE_BIT);
748          glDisable(GL_LIGHTING);
# Line 728 | Line 758 | int    fore;
758   }
759  
760  
761 < static
762 < moveview(dx, dy, mov, orb)      /* move our view */
763 < int     dx, dy, mov, orb;
761 > static int
762 > moveview(       /* move our view */
763 >        int     dx,
764 >        int     dy,
765 >        int     mov,
766 >        int     orb
767 > )
768   {
769          VIEW    nv;
770          FVECT   odir, v1, wip;
771          double  d, d1;
738 –        register int    li;
772                                  /* start with old view */
773 <        copystruct(&nv, &odev.v);
773 >        nv = odev.v;
774                                  /* orient our motion */
775          if (viewray(v1, odir, &odev.v,
776                          (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
# Line 783 | Line 816 | int    dx, dy, mov, orb;
816   }
817  
818  
819 < static
820 < getframe(ebut)                          /* get focus frame */
821 < XButtonPressedEvent     *ebut;
819 > static void
820 > getframe(                               /* get focus frame */
821 >        XButtonPressedEvent     *ebut
822 > )
823   {
824          int     startx = ebut->x, starty = ebut->y;
825 <        int     endx, endy;
826 <
825 >        int     endx, endy, midx, midy;
826 >        FVECT   odir, v1;
827 >        double  d, d1;
828 >                                                /* get mouse drag */
829          XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
830          endx = levptr(XButtonReleasedEvent)->x;
831          endy = levptr(XButtonReleasedEvent)->y;
832 <        if (endx == startx | endy == starty) {
833 <                XBell(ourdisplay, 0);
832 >        midx = (startx + endx) >> 1;
833 >        midy = (starty + endy) >> 1;
834 >                                                /* set focus distance */
835 >        if (viewray(v1, odir, &odev.v,
836 >                        (midx+.5)/odev.hres, (midy+.5)/odev.vres) < -FTINY)
837                  return;
838 <        }
838 >        d = getdistance(midx, midy, odir);      /* distance from front plane */
839 > #ifdef DOBJ
840 >        d1 = dobj_trace(NULL, v1, odir);
841 >        if (d1 < d)
842 >                d = d1;
843 > #endif
844 >        if (d < .99*FHUGE)
845 >                odev.v.vdist = d + sqrt(dist2(v1, odev.v.vp));
846 >                                                /* set frame for rendering */
847 >        if ((endx == startx) | (endy == starty))
848 >                return;
849          if (endx < startx) {register int c = endx; endx = startx; startx = c;}
850          if (endy < starty) {register int c = endy; endy = starty; starty = c;}
851          sprintf(odev_args, "%.3f %.3f %.3f %.3f",
# Line 806 | Line 855 | XButtonPressedEvent    *ebut;
855   }
856  
857  
858 < static
859 < getmove(ebut)                           /* get view change */
811 < XButtonPressedEvent     *ebut;
858 > static void
859 > waitabit(void)                          /* pause a moment */
860   {
861 +        struct timespec ts;
862 +        ts.tv_sec = 0;
863 +        ts.tv_nsec = 100000000L;
864 +        nanosleep(&ts, NULL);
865 + }
866 +
867 +
868 + static void
869 + getmove(                                /* get view change */
870 +        XButtonPressedEvent     *ebut
871 + )
872 + {
873          int     movdir = MOVDIR(ebut->button);
874          int     movorb = MOVORB(ebut->state);
875          int     ndrawn;
# Line 820 | Line 880 | XButtonPressedEvent    *ebut;
880          XNoOp(ourdisplay);              /* makes sure we're not idle */
881  
882          viewflags &= ~VWSTEADY;         /* flag moving view */
883 <        setglpersp(&odev.v);            /* start us off in perspective */
883 >        setglpersp();                   /* start us off in perspective */
884          while (!XCheckMaskEvent(ourdisplay,
885                          ButtonReleaseMask, levptr(XEvent))) {
886 +                                        /* pause so as not to move too fast */
887 +                waitabit();
888                                          /* get cursor position */
889                  if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
890                                  &rootx, &rooty, &wx, &wy, &statemask))
# Line 840 | Line 902 | XButtonPressedEvent    *ebut;
902   #ifdef DOBJ
903                  ndrawn += dobj_render();
904   #endif
843 –                if (ndrawn)
844 –                        doportals();
905                  popright();
906   #endif
907                                          /* redraw octrees */
# Line 849 | Line 909 | XButtonPressedEvent    *ebut;
909   #ifdef DOBJ
910                  ndrawn += dobj_render();        /* redraw objects */
911   #endif
852 –                if (ndrawn)
853 –                        doportals();
912                  glXSwapBuffers(ourdisplay, gwind);
913                  if (!ndrawn)
914                          sleep(1);       /* for reasonable interaction */
# Line 865 | Line 923 | XButtonPressedEvent    *ebut;
923   }
924  
925  
926 < static
927 < setglpersp(vp)                  /* set perspective view in GL */
870 < register VIEW   *vp;
926 > static void
927 > setglpersp(void)                        /* set perspective view in GL */
928   {
929          double  d, xmin, xmax, ymin, ymax;
930          GLfloat vec[4];
# Line 879 | Line 936 | register VIEW  *vp;
936                  dev_zmax = 100.;
937          } else {
938                  dev_zmin = 0.5*depthlim[0];
939 <                dev_zmax = 1.75*depthlim[1];
939 >                dev_zmax = 1.25*depthlim[1];
940                  if (dev_zmin > dev_zmax/5.)
941                          dev_zmin = dev_zmax/5.;
942          }
# Line 887 | Line 944 | register VIEW  *vp;
944                  dev_zmin = odev.v.vfore;
945          if (odev.v.vaft > FTINY)
946                  dev_zmax = odev.v.vaft;
947 <        if (dev_zmin < dev_zmax/100.)
948 <                dev_zmin = dev_zmax/100.;
947 >        if (dev_zmin*500. < dev_zmax)
948 >                dev_zmin = dev_zmax/500.;
949          setzrat();
950          xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
951          xmin = -xmax;
# Line 928 | Line 985 | register VIEW  *vp;
985   }
986  
987  
988 < static
989 < setglortho()                    /* set up orthographic view for cone drawing */
988 > static void
989 > setglortho(void)                        /* set up orthographic view for cone drawing */
990   {
991          glDrawBuffer(GL_FRONT);         /* use single-buffer mode */
992                                          /* set view matrix */
# Line 945 | Line 1002 | setglortho()                   /* set up orthographic view for cone dr
1002   }
1003  
1004  
1005 < static
1006 < wipeclean()                     /* prepare for redraw */
1005 > static void
1006 > wipeclean(void)                 /* prepare for redraw */
1007   {
1008          glDrawBuffer(GL_BACK);          /* use double-buffer mode */
1009 <        glReadBuffer(GL_FRONT);         /* read back visible contents */
953 <        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1009 >        glReadBuffer(GL_BACK);
1010                                          /* clear buffers */
1011   #ifdef STEREO
1012          setstereobuf(STEREO_BUFFER_RIGHT);
# Line 958 | Line 1014 | wipeclean()                    /* prepare for redraw */
1014          setstereobuf(STEREO_BUFFER_LEFT);
1015   #endif
1016          glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
961 –        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
1017          freedepth();
1018          if ((viewflags&(VWCHANGE|VWSTEADY)) ==
1019                          (VWCHANGE|VWSTEADY)) {  /* clear samples if new */
1020                  odClean();
1021                  viewflags &= ~VWCHANGE;         /* change noted */
1022 <        }
1023 <        setglpersp(&odev.v);            /* reset view & clipping planes */
1022 >        } else if (viewflags & VWSTEADY)
1023 >                odRedrawAll();
1024 >        setglpersp();                   /* reset view & clipping planes */
1025   }
1026  
1027  
1028 < static
1029 < getkey(ekey)                            /* get input key */
1030 < register XKeyPressedEvent  *ekey;
1028 > static void
1029 > getkey(                         /* get input key */
1030 >        register XKeyPressedEvent  *ekey
1031 > )
1032   {
1033          Window  rootw, childw;
1034          int     rootx, rooty, wx, wy;
# Line 1015 | Line 1072 | register XKeyPressedEvent  *ekey;
1072                  inpresflags |= DFL(DC_RESUME);
1073                  return;
1074          case CTRL('R'):                 /* redraw screen */
1075 <                odRemap(0);
1075 >                odRemap(0);                     /* new tone mapping */
1076                  glClear(GL_DEPTH_BUFFER_BIT);
1077   #ifdef STEREO
1078                  setstereobuf(STEREO_BUFFER_RIGHT);
# Line 1025 | Line 1082 | register XKeyPressedEvent  *ekey;
1082                  return;
1083          case CTRL('L'):                 /* refresh from server */
1084                  if (inpresflags & DFL(DC_REDRAW))
1085 <                        return;
1085 >                        return;                 /* already called */
1086                  XRaiseWindow(ourdisplay, gwind);
1087 <                XFlush(ourdisplay);
1088 <                sleep(1);
1089 <                wipeclean();                    /* fresh display */
1090 <                odRemap(1);                     /* fresh tone mapping */
1034 <                dev_flush();                    /* draw octrees */
1087 >                XFlush(ourdisplay);             /* raise up window */
1088 >                sleep(1);                       /* wait for restacking */
1089 >                dev_clear();                    /* clear buffer and samples */
1090 >                odRemap(1);                     /* start fresh histogram */
1091                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
1036 –                rayqleft = 0;                   /* hold off update */
1092                  return;
1093          case 'K':                       /* kill rtrace process(es) */
1094                  inpresflags |= DFL(DC_KILL);
# Line 1054 | Line 1109 | register XKeyPressedEvent  *ekey;
1109   }
1110  
1111  
1112 < static
1113 < fixwindow(eexp)                         /* repair damage to window */
1114 < register XExposeEvent  *eexp;
1112 > static void
1113 > fixwindow(                              /* repair damage to window */
1114 >        register XExposeEvent  *eexp
1115 > )
1116   {
1117          int     xmin, ymin, xmax, ymax;
1118  
1119 <        if (odev.hres == 0 | odev.vres == 0) {  /* first exposure */
1119 >        if ((odev.hres == 0) | (odev.vres == 0)) {      /* first exposure */
1120                  resizewindow((XConfigureEvent *)eexp);
1121                  return;
1122          }
1123          xmin = eexp->x; xmax = eexp->x + eexp->width;
1124          ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
1125 +
1126 +        if (xmin <= 0 && xmax >= odev.hres-1 &&
1127 +                        ymin <= 0 && ymax >= odev.vres) {
1128 +                DCHECK(eexp->count, WARNING, "multiple clear in fixwindow");
1129 +                wipeclean();                    /* make sure we're go */
1130 +                return;
1131 +        }
1132                                                  /* clear portion of depth */
1133          glPushAttrib(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
1134          glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
# Line 1092 | Line 1155 | register XExposeEvent  *eexp;
1155   }
1156  
1157  
1158 < static
1159 < resizewindow(ersz)                      /* resize window */
1160 < register XConfigureEvent  *ersz;
1158 > static void
1159 > resizewindow(                   /* resize window */
1160 >        register XConfigureEvent  *ersz
1161 > )
1162   {
1163          glViewport(0, 0, ersz->width, ersz->height);
1164  

Diff Legend

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