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.3 by gregl, Wed Dec 24 15:55:43 1997 UTC vs.
Revision 3.12 by gregl, Thu Jan 1 16:28:44 1998 UTC

# Line 10 | Line 10 | static char SCCSid[] = "$SunId$ SGI";
10   */
11  
12   #include "standard.h"
13 < #include "tonemap.h"
14 < #include "rhdriver.h"
13 > #include "rhd_qtree.h"
14  
15   #include  <GL/glx.h>
16  
17   #include  "x11icon.h"
18  
19 + #ifndef RAYQLEN
20 + #define RAYQLEN         50000           /* max. rays to queue before flush */
21 + #endif
22 +
23   #ifndef FEQ
24   #define FEQ(a,b)        ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
25   #endif
26  
27 < #ifndef int4
28 < #define int4    int
27 > #ifndef MAXCONE
28 > #define MAXCONE         16              /* number of different cone sizes */
29   #endif
30 <
31 < #ifndef FREEPCT
29 < #define FREEPCT         10              /* percentage of values to free */
30 > #ifndef MAXVERT
31 > #define MAXVERT         32              /* maximum number of cone vertices */
32   #endif
33 <
34 < #ifndef NCONEV
33 < #define NCONEV          7               /* number of cone base vertices */
33 > #ifndef MINVERT
34 > #define MINVERT         4               /* minimum number of cone vertices */
35   #endif
36 < #ifndef CONEH
37 < #define CONEH           3.              /* cone height (fraction of depth) */
36 > #ifndef DEPTHFACT
37 > #define DEPTHFACT       16.             /* multiplier for depth tests */
38   #endif
38 #ifndef CONEW
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
39  
40   #define GAMMA           1.4             /* default gamma correction */
41  
# Line 78 | Line 70 | static XVisualInfo  *ourvinf;          /* our visual informati
70   static Window  gwind = 0;               /* our graphics window */
71   static GLXContext       gctx;           /* our GLX context */
72  
81 static double   mindepth = FHUGE;       /* minimum depth value so far */
82 static double   maxdepth = 0.;          /* maximum depth value so far */
83
73   static double   pwidth, pheight;        /* pixel dimensions (mm) */
74  
75 < static FVECT    conev[NCONEV];          /* drawing cone */
76 < static double   coneh;                  /* cone height */
75 > static double   curzmax = 1e4;          /* current depth upper limit */
76 > static double   nxtzmax = 0.;           /* maximum (finite) depth so far */
77  
78 + static struct {
79 +        double  rad;            /* cone radius */
80 +        int     nverts;         /* number of vertices */
81 +        FVECT   *va;            /* allocated vertex array */
82 + } cone[MAXCONE];        /* precomputed cones for drawing */
83 +
84   static int      inpresflags;            /* input result flags */
85  
86   static int      headlocked = 0;         /* lock vertical motion */
87  
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 */
98        TMbright        *brt;           /* encoded brightness array */
99        BYTE            (*chr)[3];      /* encoded chrominance array */
100        BYTE            (*rgb)[3];      /* tone-mapped color array */
101        BYTE            *alpha;         /* alpha values */
102        int             nl;             /* count of values */
103        int             bl, tl;         /* bottom and top (next) value index */
104        int             tml;            /* next value needing tone-mapping */
105        int             drl;            /* next value in need of drawing */
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
88   static int  resizewindow(), getevent(), getkey(), moveview(),
89 <                setGLview(), getmove(), fixwindow(), mytmflags(),
90 <                drawvalue(), valcmp(), clralphas(), setalphas(), mergalphas(),
117 <                IndexValue(), Compost(), FindValue(), TMapValues(),
118 <                AllocValues(), FreeValues();
89 >                initcones(), freecones(),
90 >                getmove(), fixwindow(), mytmflags();
91  
120 extern int4     encodedir();
121 extern double   fdir2diff(), dir2diff();
92  
123
93   dev_open(id)                    /* initialize X11 driver */
94   char  *id;
95   {
96          extern char     *getenv();
97          static int      atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
98                                  GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
99 <                                GLX_ALPHA_SIZE,8, GLX_DEPTH_SIZE,15,
131 <                                None};
99 >                                GLX_DEPTH_SIZE,15, None};
100          char    *gv;
101          double  gamval = GAMMA;
102          XSetWindowAttributes    ourwinattr;
103          XWMHints        ourxwmhints;
104          XSizeHints      oursizhints;
105 +                                        /* set quadtree globals */
106 +        qtMinNodesiz = 3;
107 +        qtDepthEps = 0.07;
108                                          /* open display server */
109          ourdisplay = XOpenDisplay(NULL);
110          if (ourdisplay == NULL)
# Line 181 | Line 152 | char  *id;
152          glDepthFunc(GL_LEQUAL);
153          glShadeModel(GL_FLAT);
154          glDisable(GL_DITHER);
155 +        glDisable(GL_CULL_FACE);
156 +        glMatrixMode(GL_PROJECTION);
157 +        glOrtho(0., 1., 0., 1., -.01, 1.01);
158 +        glTranslated(0., 0., -1.01);
159                                          /* figure out sensible view */
160          pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
161                          DisplayWidth(ourdisplay, ourscreen);
# Line 191 | Line 166 | char  *id;
166                                          /* map the window */
167          XMapWindow(ourdisplay, gwind);
168          dev_input();                    /* sets size and view angles */
169 <        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
170 <                                        /* allocate our value list */
171 <        if (!AllocValues(DisplayWidth(ourdisplay,ourscreen) *
172 <                        DisplayHeight(ourdisplay,ourscreen) / VALUA))
169 >                                        /* allocate our leaf pile */
170 >        if (!qtAllocLeaves(DisplayWidth(ourdisplay,ourscreen) *
171 >                        DisplayHeight(ourdisplay,ourscreen) * 3 /
172 >                        (qtMinNodesiz*qtMinNodesiz*2)))
173                  error(SYSTEM, "insufficient memory for value storage");
174          odev.name = id;
175          odev.ifd = ConnectionNumber(ourdisplay);
176 +                                        /* initialize cone array */
177 +        initcones();
178   }
179  
180  
# Line 209 | Line 186 | dev_close()                    /* close our display and free resources
186          gwind = 0;
187          XCloseDisplay(ourdisplay);
188          ourdisplay = NULL;
189 +        qtFreeLeaves();
190          tmDone(NULL);
191 <        FreeValues();
191 >        freecones();
192          odev.v.type = 0;
193          odev.hres = odev.vres = 0;
194          odev.ifd = -1;
# Line 221 | Line 199 | int
199   dev_view(nv)                    /* assign new driver view */
200   register VIEW   *nv;
201   {
202 <        if (nv->type != VT_PER ||               /* check view legality */
203 <                        nv->horiz > 120. || nv->vert > 120.) {
202 >        if (nv->type == VT_PAR ||               /* check view legality */
203 >                        nv->horiz > 160. || nv->vert > 160.) {
204                  error(COMMAND, "illegal view type/angle");
205 <                nv->type = VT_PER;
205 >                nv->type = odev.v.type;
206                  nv->horiz = odev.v.horiz;
207                  nv->vert = odev.v.vert;
208                  return(0);
209          }
210 +        if (nv->vfore > FTINY) {
211 +                error(COMMAND, "cannot handle fore clipping");
212 +                nv->vfore = 0.;
213 +                return(0);
214 +        }
215          if (nv != &odev.v) {
216                  if (!FEQ(nv->horiz,odev.v.horiz) ||     /* resize window? */
217                                  !FEQ(nv->vert,odev.v.vert)) {
# Line 253 | Line 236 | register VIEW  *nv;
236                          dev_input();    /* get resize event */
237                  }
238                  copystruct(&odev.v, nv);
256                setGLview();
257                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
258                redraw();
239          }
240 +        if (nxtzmax > FTINY) {
241 +                curzmax = nxtzmax;
242 +                nxtzmax = 0.;
243 +        }
244 +        glClear(GL_DEPTH_BUFFER_BIT);
245 +        qtReplant();
246          return(1);
247   }
248  
# Line 275 | Line 261 | dev_input()                    /* get X11 input */
261   }
262  
263  
264 < dev_value(c, p, v)              /* add a pixel value to our list */
265 < COLR    c;
280 < FVECT   p, v;
264 > int
265 > dev_flush()                     /* flush output */
266   {
267 <        register int    li;
268 <
269 <        li = rV.tl++;
270 <        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);
267 >        qtUpdate();
268 >        glFlush();
269 >        rayqleft = RAYQLEN;
270 >        return(XPending(ourdisplay));
271   }
272  
273  
274 < int
275 < dev_flush()                     /* flush output */
274 > dev_cone(rgb, ip, rad)          /* render a cone in view coordinates */
275 > BYTE    rgb[3];
276 > FVECT   ip;
277 > double  rad;
278   {
279 <        if (mapped) {
280 <                TMapValues(0);
281 <                while (rV.drl != rV.tl) {
282 <                        drawvalue(rV.drl);
283 <                        if (++rV.drl >= rV.nl)
284 <                                rV.drl = 0;
285 <                }
286 <                glFlush();
279 >        register int    ci, j;
280 >        double  apexh, basez;
281 >                                        /* is window mapped? */
282 >        if (!mapped)
283 >                return;
284 >                                        /* compute apex height (0. to 1.) */
285 >        if (ip[2] > 1e6)
286 >                apexh = 1. - 1./DEPTHFACT;
287 >        else {
288 >                if (ip[2] > nxtzmax)
289 >                        nxtzmax = ip[2];
290 >                if (ip[2] >= curzmax)
291 >                        apexh = 1. - 1./DEPTHFACT;
292 >                else
293 >                        apexh = 1. - ip[2]/(curzmax*DEPTHFACT);
294          }
295 <        return(XPending(ourdisplay));
295 >        rad *= 1.25;                    /* find conservative cone match */
296 >        for (ci = 0; ci < MAXCONE-1; ci++)
297 >                if (cone[ci].rad >= rad)
298 >                        break;
299 >                                        /* draw it */
300 >        glColor3ub(rgb[0], rgb[1], rgb[2]);
301 >        glBegin(GL_TRIANGLE_FAN);
302 >        glVertex3d(ip[0], ip[1], apexh);        /* start with apex */
303 >        basez = apexh*cone[ci].va[0][2];        /* base z's all the same */
304 >        for (j = 0; j < cone[ci].nverts; j++)   /* draw each face */
305 >                glVertex3d(ip[0]+cone[ci].va[j][0], ip[1]+cone[ci].va[j][1],
306 >                                basez);
307 >                                                /* connect last to first */
308 >        glVertex3d(ip[0]+cone[ci].va[0][0], ip[1]+cone[ci].va[0][1], basez);
309 >        glEnd();                                /* all done */
310   }
311  
312  
# Line 320 | Line 322 | mytmflags()                    /* figure out tone mapping flags */
322          for (cp = tail; *cp && *cp != '.'; cp++)
323                  ;
324          if (cp-tail == 3 && !strncmp(tail, "glx", 3))
325 <                return(TM_F_CAMERA);
325 >                return(TM_F_CAMERA|TM_F_NOSTDERR);
326          if (cp-tail == 4 && !strncmp(tail, "glxh", 4))
327 <                return(TM_F_HUMAN);
327 >                return(TM_F_HUMAN|TM_F_NOSTDERR);
328          error(USER, "illegal driver name");
329   }
330  
331  
332   static
333 < setGLview()                     /* set our GL view */
333 > initcones()                     /* initialize cone vertices */
334   {
333        double  xmin, xmax, ymin, ymax, zmin, zmax;
334        double  d, cx, sx, crad;
335        FVECT   vx, vy;
335          register int    i, j;
336 <                                        /* compute view frustum */
338 <        if (normalize(odev.v.vdir) == 0.0)
339 <                return;
340 <        if (mindepth < maxdepth) {
341 <                zmin = 0.25*mindepth;
342 <                zmax = 4.0*(1.+CONEH)*maxdepth;
343 <        } else {
344 <                zmin = 0.01;
345 <                zmax = 1000.;
346 <        }
347 <        if (odev.v.vfore > FTINY)
348 <                zmin = odev.v.vfore;
349 <        if (odev.v.vaft > FTINY)
350 <                zmax = odev.v.vaft;
351 <        xmax = zmin * tan(PI/180./2. * odev.v.horiz);
352 <        xmin = -xmax;
353 <        d = odev.v.hoff * (xmax - xmin);
354 <        xmin += d; xmax += d;
355 <        ymax = zmin * tan(PI/180./2. * odev.v.vert);
356 <        ymin = -ymax;
357 <        d = odev.v.voff * (ymax - ymin);
358 <        ymin += d; ymax += d;
359 <                                        /* set view matrix */
360 <        glMatrixMode(GL_PROJECTION);
361 <        glLoadIdentity();
362 <        glFrustum(xmin, xmax, ymin, ymax, zmin, zmax);
363 <        gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
364 <                odev.v.vp[0] + odev.v.vdir[0],
365 <                odev.v.vp[1] + odev.v.vdir[1],
366 <                odev.v.vp[2] + odev.v.vdir[2],
367 <                odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
368 <                                        /* set viewport */
369 <        glViewport(0, 0, odev.hres, odev.vres);
370 <                                        /* initialize cone for Vornoi polys */
371 <        coneh = CONEH*(zmax - zmin);
372 <        crad = 0.5 * CONEW * 0.5*(xmax-xmin + ymax-ymin) * (zmin+coneh)/zmin;
373 <        vy[0] = vy[1] = vy[2] = 0.;
374 <        for (i = 0; i < 3; i++)
375 <                if (odev.v.vdir[i] < 0.6 && odev.v.vdir[i] > -0.6)
376 <                        break;
377 <        vy[i] = 1.;
378 <        fcross(vx, vy, odev.v.vdir);
379 <        normalize(vx);
380 <        fcross(vy, odev.v.vdir, vx);
381 <        for (j = 0, d = 0.; j < NCONEV; j++, d += 2.*PI/NCONEV) {
382 <                cx = crad*cos(d); sx = crad*sin(d);
383 <                for (i = 0; i < 3; i++)
384 <                        conev[j][i] = coneh*odev.v.vdir[i] +
385 <                                        cx*vx[i] + sx*vy[i];
386 <        }
387 < }
336 >        double  minrad, d;
337  
338 <
339 < #define SUCCSTEP        8       /* skip step when successful */
340 < #define MAXSTEP         64
341 <
342 < static
343 < drawvalue(li)                   /* draw a pixel value as a cone */
344 < register int    li;
345 < {
346 <        static int      skipstep = 1;
347 <        static FVECT    disp;
348 <        FVECT   apex;
349 <        double  d, dorg, dnew, h, v;
350 <        register int    i;
351 <                                /* check for quicker update */
352 <        if (quicken) {
353 <                if (li % skipstep)
405 <                        return;
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 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 face to first */
450 <        glVertex3d(conev[0][0] + disp[0], conev[0][1] + disp[1],
451 <                        conev[0][2] + disp[2]);
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 <
463 < static
464 < AllocValues(n)                  /* allocate space for n values */
465 < register int    n;
466 < {
467 <        unsigned        nbytes;
468 <        register unsigned       i;
469 <
470 <        if (n <= 0)
471 <                return(0);
472 <        if (rV.nl >= n)
473 <                return(rV.nl);
474 <        else if (rV.nl > 0)
475 <                free(rV.base);
476 <                                /* round space up to nearest power of 2 */
477 <        nbytes = n*LEAFSIZ + 8;
478 <        for (i = 1024; nbytes > i; i <<= 1)
479 <                ;
480 <        n = (i - 8) / LEAFSIZ;  /* should we make sure n is even? */
481 <        rV.base = (char *)malloc(n*LEAFSIZ);
482 <        if (rV.base == NULL)
483 <                return(0);
484 <                                /* assign larger alignment types earlier */
485 <        rV.wp = (float (*)[3])rV.base;
486 <        rV.wd = (int4 *)(rV.wp + n);
487 <        rV.brt = (TMbright *)(rV.wd + n);
488 <        rV.chr = (BYTE (*)[3])(rV.brt + n);
489 <        rV.rgb = (BYTE (*)[3])(rV.chr + n);
490 <        rV.alpha = (BYTE *)(rV.rgb + n);
491 <        rV.nl = n;
492 <        rV.drl = rV.tml = rV.bl = rV.tl = 0;
493 <        return(n);
494 < }
495 <
496 < #undef  LEAFSIZ
497 <
498 <
499 < static
500 < FreeValues()                    /* free our allocated values */
501 < {
502 <        if (rV.nl <= 0)
503 <                return;
504 <        free(rV.base);
505 <        rV.base = NULL;
506 <        rV.nl = 0;
507 < }
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--;
338 >        if (cone[0].nverts)
339 >                freecones();
340 >        minrad = 2.*qtMinNodesiz/(double)(DisplayWidth(ourdisplay,ourscreen) +
341 >                                        DisplayHeight(ourdisplay,ourscreen));
342 >        for (i = 0; i < MAXCONE; i++) {
343 >                d = (double)i/(MAXCONE-1); d *= d;      /* x^2 distribution */
344 >                cone[i].rad = minrad + (1.-minrad)*d;
345 >                cone[i].nverts = MINVERT + (MAXVERT-MINVERT)*d;
346 >                cone[i].va = (FVECT *)malloc(cone[i].nverts*sizeof(FVECT));
347 >                if (cone[i].va == NULL)
348 >                        error(SYSTEM, "out of memory in initcones");
349 >                for (j = cone[i].nverts; j--; ) {
350 >                        d = 2.*PI * (j+.5) / (cone[i].nverts);
351 >                        cone[i].va[j][0] = cos(d) * cone[i].rad;
352 >                        cone[i].va[j][1] = sin(d) * cone[i].rad;
353 >                        cone[i].va[j][2] = 1. - cone[i].rad;
354                  }
355          }
356   }
357  
358  
359   static
360 < setalphas(vbeg, nvals)          /* add values to our map and set alphas */
559 < int     vbeg, nvals;
360 > freecones()                     /* free cone vertices */
361   {
362 <        register int    *newmap;
562 <        short   ccmp[3], lastalpha;
563 <        int     newmaplen;
362 >        register int    i;
363  
364 <        if (nvals <= 0)
365 <                return;
366 <        newmaplen = vmaplen + nvals;    /* allocate new map */
367 <        newmap = (int *)malloc(newmaplen*sizeof(int));
368 <        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;
364 >        for (i = MAXCONE; i--; )
365 >                if (cone[i].nverts) {
366 >                        free((char *)cone[i].va);
367 >                        cone[i].va = NULL;
368 >                        cone[i].nverts = 0;
369                  }
370   }
371  
372  
373   static
614 TMapValues(redo)                /* map our values to RGB */
615 int     redo;
616 {
617        int     aorg, alen, borg, blen;
618                                        /* recompute mapping? */
619        if (redo)
620                rV.tml = rV.bl;
621                                        /* already done? */
622        if (rV.tml == rV.tl)
623                return(1);
624                                        /* compute segments */
625        aorg = rV.tml;
626        if (rV.tl >= aorg) {
627                alen = rV.tl - aorg;
628                blen = 0;
629        } else {
630                alen = rV.nl - aorg;
631                borg = 0;
632                blen = rV.tl;
633        }
634                                        /* (re)compute tone mapping? */
635        if (rV.tml == rV.bl) {
636                tmClearHisto();
637                tmAddHisto(rV.brt+aorg, alen, 1);
638                if (blen > 0)
639                        tmAddHisto(rV.brt+borg, blen, 1);
640                if (tmComputeMapping(0., 0., 0.) != TM_E_OK)
641                        return(0);
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)
647                return(0);
648        if (blen > 0)
649                tmMapPixels(rV.rgb+borg, rV.brt+borg,
650                                rV.chr+borg, blen);
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
658
659 static int
660 Compost(pct)                    /* free up some values */
661 int     pct;
662 {
663        int     nused, nclear, nmapped, ndrawn;
664                                /* figure out how many values to clear */
665        nclear = rV.nl * pct / 100;
666        nused = rV.tl - rV.bl;
667        if (nused <= 0) nused += rV.nl;
668        nclear -= rV.nl - nused;
669        if (nclear <= 0)
670                return(0);
671        if (nclear >= nused) {  /* clear them all? */
672                rV.drl = rV.tml = rV.bl = rV.tl = 0;
673                return(nused);
674        }
675                                /* else clear values from bottom */
676        ndrawn = rV.drl - rV.bl;
677        if (ndrawn < 0) ndrawn += rV.nl;
678        nmapped = rV.tml - rV.bl;
679        if (nmapped < 0) nmapped += rV.nl;
680        rV.bl += nclear;
681        if (rV.bl >= rV.nl) rV.bl -= rV.nl;
682        if (ndrawn < nclear) rV.drl = rV.bl;
683        if (nmapped < nclear) rV.tml = rV.bl;
684        return(nclear);
685 }
686
687
688 static
374   getevent()                      /* get next event */
375   {
376          XNextEvent(ourdisplay, levptr(XEvent));
# Line 725 | Line 410 | static
410   draw_grids()                    /* draw holodeck section grids */
411   {
412          static BYTE     gridrgba[4] = {0x0, 0xff, 0xff, 0x00};
413 <
414 <        if (!mapped)
413 >        double  xmin, xmax, ymin, ymax, zmin, zmax;
414 >        double  d, cx, sx, crad;
415 >        FVECT   vx, vy;
416 >        register int    i, j;
417 >                                        /* can we even do it? */
418 >        if (!mapped || odev.v.type != VT_PER)
419                  return;
420 +                                        /* compute view frustum */
421 +        if (normalize(odev.v.vdir) == 0.0)
422 +                return;
423 +        zmin = 0.01;
424 +        zmax = 10000.;
425 +        if (odev.v.vfore > FTINY)
426 +                zmin = odev.v.vfore;
427 +        if (odev.v.vaft > FTINY)
428 +                zmax = odev.v.vaft;
429 +        xmax = zmin * tan(PI/180./2. * odev.v.horiz);
430 +        xmin = -xmax;
431 +        d = odev.v.hoff * (xmax - xmin);
432 +        xmin += d; xmax += d;
433 +        ymax = zmin * tan(PI/180./2. * odev.v.vert);
434 +        ymin = -ymax;
435 +        d = odev.v.voff * (ymax - ymin);
436 +        ymin += d; ymax += d;
437 +                                        /* set view matrix */
438 +        glMatrixMode(GL_PROJECTION);
439 +        glPushMatrix();
440 +        glLoadIdentity();
441 +        glFrustum(xmin, xmax, ymin, ymax, zmin, zmax);
442 +        gluLookAt(odev.v.vp[0], odev.v.vp[1], odev.v.vp[2],
443 +                odev.v.vp[0] + odev.v.vdir[0],
444 +                odev.v.vp[1] + odev.v.vdir[1],
445 +                odev.v.vp[2] + odev.v.vdir[2],
446 +                odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
447 +        glDisable(GL_DEPTH_TEST);       /* write no depth values */
448          glColor4ub(gridrgba[0], gridrgba[1], gridrgba[2], gridrgba[3]);
449 <                                        /* draw each grid line */
733 <        glBegin(GL_LINES);
449 >        glBegin(GL_LINES);              /* draw each grid line */
450          gridlines(draw3dline);
451          glEnd();
452 +        glEnable(GL_DEPTH_TEST);        /* restore rendering params */
453 +        glPopMatrix();
454   }
455  
456  
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        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
457   static
458   moveview(dx, dy, mov, orb)      /* move our view */
459   int     dx, dy, mov, orb;
# Line 783 | Line 466 | int    dx, dy, mov, orb;
466          copystruct(&nv, &odev.v);
467                                  /* change view direction */
468          if (mov | orb) {
469 <                if ((li = FindValue(dx, dy)) < 0)
469 >                if ((li = qtFindLeaf(dx, dy)) < 0)
470                          return(0);      /* not on window */
471 <                VSUM(odir, rV.wp[li], nv.vp, -1.);
471 >                VSUM(odir, qtL.wp[li], nv.vp, -1.);
472          } else {
473                  if (viewray(nv.vp, nv.vdir, &odev.v,
474                                  (dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
# Line 793 | Line 476 | int    dx, dy, mov, orb;
476          }
477          if (orb && mov) {               /* orbit left/right */
478                  spinvector(odir, odir, nv.vup, d=MOVDEG*PI/180.*mov);
479 <                VSUM(nv.vp, rV.wp[li], odir, -1.);
479 >                VSUM(nv.vp, qtL.wp[li], odir, -1.);
480                  spinvector(nv.vdir, nv.vdir, nv.vup, d);
481          } else if (orb) {               /* orbit up/down */
482                  fcross(v1, odir, nv.vup);
483                  if (normalize(v1) == 0.)
484                          return(0);
485                  spinvector(odir, odir, v1, d=MOVDEG*PI/180.*orb);
486 <                VSUM(nv.vp, rV.wp[li], odir, -1.);
486 >                VSUM(nv.vp, qtL.wp[li], odir, -1.);
487                  spinvector(nv.vdir, nv.vdir, v1, d);
488          } else if (mov) {               /* move forward/backward */
489                  d = MOVPCT/100. * mov;
# Line 825 | Line 508 | XButtonPressedEvent    *ebut;
508   {
509          int     movdir = MOVDIR(ebut->button);
510          int     movorb = MOVORB(ebut->state);
511 +        int     oldnodesiz = qtMinNodesiz;
512          Window  rootw, childw;
513          int     rootx, rooty, wx, wy;
514          unsigned int    statemask;
515  
516 <        quicken = 1;                    /* accelerate update rate */
516 >        qtMinNodesiz = 24;              /* accelerate update rate */
517          XNoOp(ourdisplay);
518  
519          while (!XCheckMaskEvent(ourdisplay,
# Line 843 | Line 527 | XButtonPressedEvent    *ebut;
527                          sleep(1);
528                          continue;
529                  }
530 +                glClear(GL_COLOR_BUFFER_BIT);
531 +                qtUpdate();
532                  draw_grids();
533 <                dev_flush();
533 >                glFlush();
534          }
535          if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
536                  movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
537                  wx = levptr(XButtonReleasedEvent)->x;
538                  wy = levptr(XButtonReleasedEvent)->y;
539                  moveview(wx, odev.vres-1-wy, movdir, movorb);
854        } else {
855                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
856                redraw();
540          }
858        quicken = 0;
541          dev_flush();
542 +
543 +        qtMinNodesiz = oldnodesiz;      /* restore quadtree resolution */
544   }
545  
546  
# Line 891 | Line 575 | register XKeyPressedEvent  *ekey;
575                  inpresflags |= DFL(DC_RESUME);
576                  return;
577          case CTRL('R'):                 /* redraw screen */
578 <                TMapValues(1);
578 >                if (nxtzmax > FTINY) {
579 >                        curzmax = nxtzmax;
580 >                        nxtzmax = 0.;
581 >                }
582                  glClear(GL_DEPTH_BUFFER_BIT);
583 <                redraw();
583 >                qtRedraw(0, 0, odev.hres, odev.vres);
584                  return;
585          case CTRL('L'):                 /* refresh from server */
586                  if (inpresflags & DFL(DC_REDRAW))
587                          return;
588 +                if (nxtzmax > FTINY) {
589 +                        curzmax = nxtzmax;
590 +                        nxtzmax = 0.;
591 +                }
592                  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
902                glDisable(GL_DEPTH_TEST);
593                  draw_grids();
904                glEnable(GL_DEPTH_TEST);
594                  glFlush();
595 <                Compost(100);                   /* get rid of old values */
595 >                qtCompost(100);                 /* get rid of old values */
596                  inpresflags |= DFL(DC_REDRAW);  /* resend values from server */
597                  return;
598          case 'K':                       /* kill rtrace process(es) */
# Line 929 | Line 618 | static
618   fixwindow(eexp)                         /* repair damage to window */
619   register XExposeEvent  *eexp;
620   {
621 +        int     xmin, xmax, ymin, ymax;
622 +
623          if (odev.hres == 0 || odev.vres == 0)   /* first exposure */
624                  resizewindow((XConfigureEvent *)eexp);
625 <        if (eexp->width == odev.hres && eexp->height == odev.vres)
626 <                TMapValues(1);
627 <        if (!eexp->count) {
628 <                glClear(GL_DEPTH_BUFFER_BIT);
629 <                redraw();
630 <        }
625 >        xmin = eexp->x; xmax = eexp->x + eexp->width;
626 >        ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
627 >                                                /* clear portion of depth */
628 >        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
629 >        glDepthFunc(GL_ALWAYS);
630 >        glBegin(GL_POLYGON);
631 >        glVertex3d((double)xmin/odev.hres, (double)ymin/odev.vres, 0.);
632 >        glVertex3d((double)xmax/odev.hres, (double)ymin/odev.vres, 0.);
633 >        glVertex3d((double)xmax/odev.hres, (double)ymax/odev.vres, 0.);
634 >        glVertex3d((double)xmin/odev.hres, (double)ymax/odev.vres, 0.);
635 >        glEnd();
636 >        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
637 >        glDepthFunc(GL_LEQUAL);
638 >        qtRedraw(xmin, ymin, xmax, ymax);
639   }
640  
641  
# Line 944 | Line 643 | static
643   resizewindow(ersz)                      /* resize window */
644   register XConfigureEvent  *ersz;
645   {
646 +        glViewport(0, 0, ersz->width, ersz->height);
647 +
648          if (ersz->width == odev.hres && ersz->height == odev.vres)
649                  return;
650  
# Line 952 | Line 653 | register XConfigureEvent  *ersz;
653  
654          odev.v.horiz = 2.*180./PI * atan(0.5/VIEWDIST*pwidth*odev.hres);
655          odev.v.vert = 2.*180./PI * atan(0.5/VIEWDIST*pheight*odev.vres);
955
956        setGLview();
656  
657          inpresflags |= DFL(DC_SETVIEW);
658   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines