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

Comparing ray/src/hd/rhd_x11.c (file contents):
Revision 3.26 by gwlarson, Wed Jun 17 15:44:07 1998 UTC vs.
Revision 3.47 by greg, Fri Feb 12 00:53:56 2021 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   * X11 driver for holodeck display.
6   * Based on rview driver.
7   */
8  
9 < #include "standard.h"
10 < #include "rhd_qtree.h"
14 <
9 > #include  <stdlib.h>
10 > #include  <stdio.h>
11   #include  <X11/Xlib.h>
12   #include  <X11/cursorfont.h>
13   #include  <X11/Xutil.h>
14 + #include  <time.h>
15  
16 < #include  "x11icon.h"
16 > #include "platform.h"
17 > #include "rtmath.h"
18 > #include "rterror.h"
19 > #include "plocate.h"
20 > #include "rhdisp.h"
21 > #include "rhd_qtree.h"
22 > #include "x11icon.h"
23  
24   #ifndef RAYQLEN
25   #define RAYQLEN         50000           /* max. rays to queue before flush */
26   #endif
27  
25 – #ifndef FEQ
26 – #define FEQ(a,b)        ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
27 – #endif
28 –
28   #define GAMMA           2.2             /* default gamma correction */
29  
30 + #define FRAMESTATE(s)   (((s)&(ShiftMask|ControlMask))==(ShiftMask|ControlMask))
31 +
32   #define MOVPCT          7               /* percent distance to move /frame */
33   #define MOVDIR(b)       ((b)==Button1 ? 1 : (b)==Button2 ? 0 : -1)
34   #define MOVDEG          (-5)            /* degrees to orbit CW/down /frame */
# Line 49 | Line 50 | static char SCCSid[] = "$SunId$ SGI";
50  
51   struct driver   odev;                   /* global device driver structure */
52  
53 + TMstruct        *tmGlobal;              /* global tone-mapping structure */
54 +
55 + char odev_args[64];                     /* command arguments */
56 +
57   static XEvent  currentevent;            /* current event */
58  
59   static int  ncolors = 0;                /* color table size */
# Line 68 | Line 73 | static int     inpresflags;            /* input result flags */
73  
74   static int      headlocked = 0;         /* lock vertical motion */
75  
71 – static int  getpixels(), xnewcolr(), freepixels(), resizewindow(),
72 –                getevent(), getkey(), moveview(), getmove(), fixwindow();
73 – static unsigned long  true_pixel();
76  
77 + static int mytmflags(void);
78 + static void xnewcolr(int  ndx, int r, int g, int b);
79 + static int getpixels(void);
80 + static void freepixels(void);
81 + static unsigned long true_pixel(uby8 rgb[3]);
82 + static void getevent(void);
83 + static int ilclip(int dp[2][2], FVECT wp[2]);
84 + static void draw3dline(FVECT wp[2]);
85 + static void draw_grids(void);
86 + static int moveview(int dx, int dy, int mov, int orb);
87 + static void getframe(XButtonPressedEvent *ebut);
88 + static void waitabit(void);
89 + static void getmove(XButtonPressedEvent *ebut);
90 + static void getkey(XKeyPressedEvent *ekey);
91 + static void fixwindow(XExposeEvent *eexp);
92 + static void resizewindow(XConfigureEvent *ersz);
93  
94 +
95   static int
96 < mytmflags()                     /* figure out tone mapping flags */
96 > mytmflags(void)                 /* figure out tone mapping flags */
97   {
98          extern char     *progname;
99 <        register char   *cp, *tail;
99 >        char    *cp, *tail;
100                                          /* find basic name */
101          for (cp = tail = progname; *cp; cp++)
102                  if (*cp == '/')
# Line 89 | Line 108 | mytmflags()                    /* figure out tone mapping flags */
108          if (cp-tail == 4 && !strncmp(tail, "x11h", 4))
109                  return(TM_F_HUMAN|TM_F_NOSTDERR);
110          error(USER, "illegal driver name");
111 +        return 0; /* pro forma return */
112   }
113  
114  
115 < dev_open(id)                    /* initialize X11 driver */
116 < char  *id;
115 > void
116 > dev_open(                       /* initialize X11 driver */
117 >        char  *id
118 > )
119   {
98 –        extern char  *getenv();
120          static RGBPRIMS myprims = STDPRIMS;
121          char  *ev;
122          double  gamval = GAMMA;
# Line 142 | Line 163 | char  *id;
163                                  &myprims[BLU][CIEX],&myprims[BLU][CIEY],
164                                  &myprims[WHT][CIEX],&myprims[WHT][CIEY]) >= 6)
165                  dpri = myprims;
166 <        if (tmInit(mytmflags(), dpri, gamval) == NULL)
166 >        tmGlobal = tmInit(mytmflags(), dpri, gamval);
167 >        if (tmGlobal == NULL)
168                  error(SYSTEM, "not enough memory in dev_open");
169                                          /* open window */
170          ourwinattr.background_pixel = ourblack;
# Line 164 | Line 186 | char  *id;
186                                          /* set window manager hints */
187          ourxwmhints.flags = InputHint|IconPixmapHint;
188          ourxwmhints.input = True;
189 <        ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay,
190 <                        gwind, x11icon_bits, x11icon_width, x11icon_height);
189 >        ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay, gwind,
190 >                        (char *)x11icon_bits, x11icon_width, x11icon_height);
191          XSetWMHints(ourdisplay, gwind, &ourxwmhints);
192          oursizhints.min_width = MINWIDTH;
193          oursizhints.min_height = MINHEIGHT;
# Line 176 | Line 198 | char  *id;
198                          DisplayWidth(ourdisplay, ourscreen);
199          pheight = (double)DisplayHeightMM(ourdisplay, ourscreen) /
200                          DisplayHeight(ourdisplay, ourscreen);
201 <        copystruct(&odev.v, &stdview);
201 >        odev.v = stdview;
202          odev.v.type = VT_PER;
203                                          /* map the window and get its size */
204          XMapWindow(ourdisplay, gwind);
# Line 191 | Line 213 | char  *id;
213   }
214  
215  
216 < dev_close()                     /* close our display */
216 > void
217 > dev_close(void)                 /* close our display */
218   {
219          freepixels();
220          XFreeGC(ourdisplay, ourgc);
# Line 201 | Line 224 | dev_close()                    /* close our display */
224          XCloseDisplay(ourdisplay);
225          ourdisplay = NULL;
226          qtFreeLeaves();
227 <        tmDone(NULL);
227 >        tmDone(tmGlobal);
228          odev.v.type = 0;
229          odev.hres = odev.vres = 0;
230          odev.ifd = -1;
231   }
232  
233  
234 <
235 < dev_clear()                     /* clear our quadtree */
234 > void
235 > dev_clear(void)                 /* clear our quadtree */
236   {
237          qtCompost(100);
238          if (ncolors > 0)
# Line 219 | Line 242 | dev_clear()                    /* clear our quadtree */
242  
243  
244   int
245 < dev_view(nv)                    /* assign new driver view */
246 < VIEW    *nv;
245 > dev_view(                       /* assign new driver view */
246 >        VIEW    *nv
247 > )
248   {
249          if (nv->type == VT_PAR ||               /* check view legality */
250                          nv->horiz > 160. || nv->vert > 160.) {
# Line 236 | Line 260 | VIEW   *nv;
260                  return(0);
261          }
262          if (nv != &odev.v) {
263 <                if (!FEQ(nv->horiz,odev.v.horiz) ||     /* resize window? */
264 <                                !FEQ(nv->vert,odev.v.vert)) {
263 >                if (!FABSEQ(nv->horiz,odev.v.horiz) ||  /* resize window? */
264 >                                !FABSEQ(nv->vert,odev.v.vert)) {
265                          int     dw = DisplayWidth(ourdisplay,ourscreen);
266                          int     dh = DisplayHeight(ourdisplay,ourscreen);
267  
# Line 258 | Line 282 | VIEW   *nv;
282                          XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
283                          dev_input();    /* wait for resize event */
284                  }
285 <                copystruct(&odev.v, nv);
285 >                odev.v = *nv;
286          }
287          qtReplant();
288          return(1);
289   }
290  
291  
292 < dev_auxcom(cmd, args)           /* process an auxiliary command */
293 < char    *cmd, *args;
292 > void
293 > dev_section(            /* add octree for geometry rendering */
294 >        char    *gfn,
295 >        char    *pfn
296 > )
297   {
298 +        /* unimplemented */
299 + }
300 +
301 +
302 + void
303 + dev_auxcom(             /* process an auxiliary command */
304 +        char    *cmd,
305 +        char    *args
306 + )
307 + {
308          sprintf(errmsg, "%s: unknown command", cmd);
309          error(COMMAND, errmsg);
310   }
311  
312  
313   VIEW *
314 < dev_auxview(n, hvres)           /* return nth auxiliary view */
315 < int     n;
316 < int     hvres[2];
314 > dev_auxview(            /* return nth auxiliary view */
315 >        int     n,
316 >        int     hvres[2]
317 > )
318   {
319          if (n)
320                  return(NULL);
# Line 286 | Line 324 | int    hvres[2];
324  
325  
326   int
327 < dev_input()                     /* get X11 input */
327 > dev_input(void)                 /* get X11 input */
328   {
329          inpresflags = 0;
330  
331          do
332                  getevent();
333  
334 <        while (XQLength(ourdisplay) > 0);
334 >        while (XPending(ourdisplay) > 0);
335  
336 +        odev.inpready = 0;
337 +
338          return(inpresflags);
339   }
340  
341  
342 < dev_paintr(rgb, xmin, ymin, xmax, ymax)         /* fill a rectangle */
343 < BYTE    rgb[3];
344 < int  xmin, ymin, xmax, ymax;
342 > void
343 > dev_paintr(             /* fill a rectangle */
344 >        uby8    rgb[3],
345 >        int  xmin,
346 >        int  ymin,
347 >        int  xmax,
348 >        int  ymax
349 > )
350   {
351          unsigned long  pixel;
352  
# Line 318 | Line 363 | int  xmin, ymin, xmax, ymax;
363  
364  
365   int
366 < dev_flush()                     /* flush output */
366 > dev_flush(void)                 /* flush output */
367   {
368          qtUpdate();
369          rayqleft = RAYQLEN;
370 <        return(XPending(ourdisplay));
370 >        return(odev.inpready = XPending(ourdisplay));
371   }
372  
373  
374 < static
375 < xnewcolr(ndx, r, g, b)          /* enter a color into hardware table */
376 < int  ndx;
377 < int  r, g, b;
374 > static void
375 > xnewcolr(               /* enter a color into hardware table */
376 >        int  ndx,
377 >        int r,
378 >        int g,
379 >        int b
380 > )
381   {
382          XColor  xcolor;
383  
# Line 344 | Line 392 | int  r, g, b;
392  
393  
394   static int
395 < getpixels()                             /* get the color map */
395 > getpixels(void)                         /* get the color map */
396   {
397          XColor  thiscolor;
398 <        register int  i, j;
398 >        int  i, j;
399  
400          if (ncolors > 0)
401                  return(ncolors);
# Line 366 | Line 414 | loop:
414                          return(ncolors = 0);
415                  if (XAllocColorCells(ourdisplay,ourmap,0,NULL,0,pixval,ncolors))
416                          break;
417 <                free((char *)pixval);
417 >                free((void *)pixval);
418                  pixval = NULL;
419          }
420          if (pixval == NULL) {
# Line 395 | Line 443 | loop:
443   }
444  
445  
446 < static
447 < freepixels()                            /* free our pixels */
446 > static void
447 > freepixels(void)                                /* free our pixels */
448   {
449          if (ncolors == 0)
450                  return;
451          XFreeColors(ourdisplay,ourmap,pixval,ncolors,0L);
452 <        free((char *)pixval);
452 >        free((void *)pixval);
453          pixval = NULL;
454          ncolors = 0;
455          if (ourmap != DefaultColormap(ourdisplay,ourscreen))
# Line 411 | Line 459 | freepixels()                           /* free our pixels */
459  
460  
461   static unsigned long
462 < true_pixel(rgb)                 /* return true pixel value for color */
463 < register BYTE   rgb[3];
462 > true_pixel(                     /* return true pixel value for color */
463 >        uby8    rgb[3]
464 > )
465   {
466 <        register unsigned long  rval;
466 >        unsigned long  rval;
467  
468          rval = ourvinfo.red_mask*rgb[RED]/255 & ourvinfo.red_mask;
469          rval |= ourvinfo.green_mask*rgb[GRN]/255 & ourvinfo.green_mask;
# Line 423 | Line 472 | register BYTE  rgb[3];
472   }
473  
474  
475 < static
476 < getevent()                      /* get next event */
475 > static void
476 > getevent(void)                  /* get next event */
477   {
478          XNextEvent(ourdisplay, levptr(XEvent));
479          switch (levptr(XEvent)->type) {
# Line 451 | Line 500 | getevent()                     /* get next event */
500                  getkey(levptr(XKeyPressedEvent));
501                  break;
502          case ButtonPress:
503 <                getmove(levptr(XButtonPressedEvent));
503 >                if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
504 >                        getframe(levptr(XButtonPressedEvent));
505 >                else
506 >                        switch (levptr(XButtonPressedEvent)->button) {
507 >                        case Button4:           /* wheel up */
508 >                        case Button5:           /* wheel down */
509 >                                break;
510 >                        default:
511 >                                getmove(levptr(XButtonPressedEvent));
512 >                                break;
513 >                        }
514                  break;
515          }
516   }
517  
518  
519 < static
520 < ilclip(dp, wp)                  /* clip world coordinates to device */
521 < int     dp[2][2];
522 < FVECT   wp[2];
519 > static int
520 > ilclip(                 /* clip world coordinates to device */
521 >        int     dp[2][2],
522 >        FVECT   wp[2]
523 > )
524   {
525 <        static FVECT    vmin = {0.,0.,0.}, vmax = {1.,1.,FHUGE};
526 <        FVECT   ip[2];
527 <                                /* not exactly right, but who cares? */
528 <        viewloc(ip[0], &odev.v, wp[0]);
529 <        viewloc(ip[1], &odev.v, wp[1]);
525 >        static FVECT    vmin = {0.,0.,0.}, vmax = {1.-FTINY,1.-FTINY,FHUGE};
526 >        FVECT   wpc[2], ip[2];
527 >        double  d, d0, d1;
528 >                                /* check for points behind view */
529 >        d = DOT(odev.v.vp, odev.v.vdir);
530 >        d0 = DOT(wp[0], odev.v.vdir) - d;
531 >        d1 = DOT(wp[1], odev.v.vdir) - d;
532 >                                /* work on copy of world points */
533 >        if (d0 <= d1) {
534 >                VCOPY(wpc[0], wp[0]); VCOPY(wpc[1], wp[1]);
535 >        } else {
536 >                d = d0; d0 = d1; d1 = d;
537 >                VCOPY(wpc[1], wp[0]); VCOPY(wpc[0], wp[1]);
538 >        }
539 >        if (d0 <= FTINY) {
540 >                if (d1 <= FTINY) return(0);
541 >                VSUB(wpc[0], wpc[0], wpc[1]);
542 >                d = .99*d1/(d1-d0);
543 >                VSUM(wpc[0], wpc[1], wpc[0], d);
544 >        }
545 >                                /* get view coordinates and clip to window */
546 >        viewloc(ip[0], &odev.v, wpc[0]);
547 >        viewloc(ip[1], &odev.v, wpc[1]);
548          if (!clip(ip[0], ip[1], vmin, vmax))
549                  return(0);
550          dp[0][0] = ip[0][0]*odev.hres;
# Line 477 | Line 555 | FVECT  wp[2];
555   }
556  
557  
558 < static
559 < draw3dline(wp)                  /* draw 3d line in world coordinates */
560 < FVECT   wp[2];
558 > static void
559 > draw3dline(                     /* draw 3d line in world coordinates */
560 >        FVECT   wp[2]
561 > )
562   {
563          int     dp[2][2];
564  
# Line 491 | Line 570 | FVECT  wp[2];
570   }
571  
572  
573 < static
574 < draw_grids()                    /* draw holodeck section grids */
573 > static void
574 > draw_grids(void)                        /* draw holodeck section grids */
575   {
576 <        static BYTE     gridrgb[3] = {0x0, 0xff, 0xff};
576 >        static uby8     gridrgb[3] = {0x0, 0xff, 0xff};
577          unsigned long  pixel;
578  
500 –        if (!mapped)
501 –                return;
579          if (ncolors > 0)
580                  pixel = pixval[get_pixel(gridrgb, xnewcolr)];
581          else
# Line 509 | Line 586 | draw_grids()                   /* draw holodeck section grids */
586   }
587  
588  
589 < static
590 < moveview(dx, dy, mov, orb)      /* move our view */
591 < int     dx, dy, mov, orb;
589 > static int
590 > moveview(       /* move our view */
591 >        int     dx,
592 >        int     dy,
593 >        int     mov,
594 >        int     orb
595 > )
596   {
597          VIEW    nv;
598          FVECT   odir, v1;
599          double  d;
600 <        register int    li;
600 >        int     li;
601                                  /* start with old view */
602 <        copystruct(&nv, &odev.v);
602 >        nv = odev.v;
603                                  /* change view direction */
604          if (mov | orb) {
605                  if ((li = qtFindLeaf(dx, dy)) < 0)
# Line 534 | Line 615 | int    dx, dy, mov, orb;
615                  VSUM(nv.vp, qtL.wp[li], odir, -1.);
616                  spinvector(nv.vdir, nv.vdir, nv.vup, d);
617          } else if (orb) {               /* orbit up/down */
618 <                fcross(v1, odir, nv.vup);
619 <                if (normalize(v1) == 0.)
618 >                if (geodesic(odir, odir, nv.vup,
619 >                                d=MOVDEG*PI/180.*orb, GEOD_RAD) == 0.0)
620                          return(0);
540 –                spinvector(odir, odir, v1, d=MOVDEG*PI/180.*orb);
621                  VSUM(nv.vp, qtL.wp[li], odir, -1.);
622 <                spinvector(nv.vdir, nv.vdir, v1, d);
622 >                geodesic(nv.vdir, nv.vdir, nv.vup, d, GEOD_RAD);
623          } else if (mov) {               /* move forward/backward */
624                  d = MOVPCT/100. * mov;
625                  VSUM(nv.vp, nv.vp, odir, d);
# Line 557 | Line 637 | int    dx, dy, mov, orb;
637   }
638  
639  
640 < static
641 < getmove(ebut)                           /* get view change */
642 < XButtonPressedEvent     *ebut;
640 > static void
641 > getframe(                               /* get focus frame */
642 >        XButtonPressedEvent     *ebut
643 > )
644   {
645 +        int     startx = ebut->x, starty = ebut->y;
646 +        int     endx, endy, midx, midy;
647 +        FVECT   v1;
648 +        int     li;
649 +                                        /* get mouse drag */
650 +        XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
651 +        endx = levptr(XButtonReleasedEvent)->x;
652 +        endy = levptr(XButtonReleasedEvent)->y;
653 +        midx = (startx + endx) >> 1;
654 +        midy = (starty + endy) >> 1;
655 +                                        /* set focus distance */
656 +        if ((li = qtFindLeaf(midx, midy)) < 0)
657 +                return;                 /* not on window */
658 +        VCOPY(v1, qtL.wp[li]);
659 +        odev.v.vdist = sqrt(dist2(odev.v.vp, v1));
660 +                                        /* set frame for rendering */
661 +        if ((endx == startx) | (endy == starty))
662 +                return;
663 +        if (endx < startx) {int c = endx; endx = startx; startx = c;}
664 +        if (endy < starty) {int c = endy; endy = starty; starty = c;}
665 +        sprintf(odev_args, "%.3f %.3f %.3f %.3f",
666 +                        (startx+.5)/odev.hres, 1.-(endy+.5)/odev.vres,
667 +                        (endx+.5)/odev.hres, 1.-(starty+.5)/odev.vres);
668 +        inpresflags |= DFL(DC_FOCUS);
669 + }
670 +
671 +
672 + static void
673 + waitabit(void)                          /* pause a moment */
674 + {
675 +        struct timespec ts;
676 +        ts.tv_sec = 0;
677 +        ts.tv_nsec = 100000000;
678 +        nanosleep(&ts, NULL);
679 + }
680 +
681 +
682 + static void
683 + getmove(                                /* get view change */
684 +        XButtonPressedEvent     *ebut
685 + )
686 + {
687          int     movdir = MOVDIR(ebut->button);
688          int     movorb = MOVORB(ebut->state);
689          int     oldnodesiz = qtMinNodesiz;
# Line 573 | Line 696 | XButtonPressedEvent    *ebut;
696  
697          while (!XCheckMaskEvent(ourdisplay,
698                          ButtonReleaseMask, levptr(XEvent))) {
699 <
699 >                waitabit();
700                  if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
701                                  &rootx, &rooty, &wx, &wy, &statemask))
702                          break;          /* on another screen */
# Line 598 | Line 721 | XButtonPressedEvent    *ebut;
721   }
722  
723  
724 < static
725 < getkey(ekey)                            /* get input key */
726 < register XKeyPressedEvent  *ekey;
724 > static void
725 > getkey(                         /* get input key */
726 >        XKeyPressedEvent  *ekey
727 > )
728   {
729 +        Window  rootw, childw;
730 +        int     rootx, rooty, wx, wy;
731 +        unsigned int    statemask;
732          int  n;
733          char    buf[8];
734  
# Line 618 | Line 745 | register XKeyPressedEvent  *ekey;
745          case 'l':                       /* retrieve last view */
746                  inpresflags |= DFL(DC_LASTVIEW);
747                  return;
748 +        case 'f':                       /* frame view position */
749 +                if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
750 +                                &rootx, &rooty, &wx, &wy, &statemask))
751 +                        return;         /* on another screen */
752 +                sprintf(odev_args, "%.4f %.4f", (wx+.5)/odev.hres,
753 +                                1.-(wy+.5)/odev.vres);
754 +                inpresflags |= DFL(DC_FOCUS);
755 +                return;
756 +        case 'F':                       /* unfocus */
757 +                odev_args[0] = '\0';
758 +                inpresflags |= DFL(DC_FOCUS);
759 +                return;
760          case 'p':                       /* pause computation */
761                  inpresflags |= DFL(DC_PAUSE);
762                  return;
# Line 664 | Line 803 | register XKeyPressedEvent  *ekey;
803   }
804  
805  
806 < static
807 < fixwindow(eexp)                         /* repair damage to window */
808 < register XExposeEvent  *eexp;
806 > static void
807 > fixwindow(                              /* repair damage to window */
808 >        XExposeEvent  *eexp
809 > )
810   {
811          if (odev.hres == 0 || odev.vres == 0) { /* first exposure */
812                  odev.hres = eexp->width;
# Line 677 | Line 817 | register XExposeEvent  *eexp;
817   }
818  
819  
820 < static
821 < resizewindow(ersz)                      /* resize window */
822 < register XConfigureEvent  *ersz;
820 > static void
821 > resizewindow(                   /* resize window */
822 >        XConfigureEvent  *ersz
823 > )
824   {
825          if (ersz->width == odev.hres && ersz->height == odev.vres)
826                  return;

Diff Legend

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