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

Comparing ray/src/hd/rhd_odraw.c (file contents):
Revision 3.4 by gwlarson, Mon Dec 21 14:05:43 1998 UTC vs.
Revision 3.15 by greg, Fri Jun 20 00:25:49 2003 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   * Routines for drawing samples using depth buffer checks.
6   */
7  
8   #include "standard.h"
9  
13 – #include <sys/types.h>
10   #include <GL/glx.h>
11   #include <GL/glu.h>
12  
17 – #include "random.h"
13   #include "rhd_odraw.h"
14  
15   #ifndef DEPTHEPS
# Line 26 | Line 21 | static char SCCSid[] = "$SunId$ SGI";
21   #ifndef SFREEFRAC
22   #define SFREEFRAC       0.2             /* fraction to free at a time */
23   #endif
24 + #ifndef REDRAWTHRESH
25 + #define REDRAWTHRESH    10240           /* number of samples for dissolve */
26 + #endif
27   #ifndef MAXFAN
28   #define MAXFAN          32              /* maximum arms in a triangle fan */
29   #endif
# Line 49 | Line 47 | static int     needmapping;    /* what needs doing with tone
47  
48  
49   #define SAMP32  (32*(2*sizeof(short)+sizeof(union ODfunion)+sizeof(TMbright)+\
50 <                        6*sizeof(BYTE))+sizeof(int4))
50 >                        6*sizeof(BYTE))+sizeof(int32))
51  
52   int
53   odInit(n)                               /* initialize drawing routines */
# Line 60 | Line 58 | int    n;
58  
59          if (odNViews > 0) {             /* deallocate view structures */
60                  for (i = odNViews; i--; ) {
61 <                        free((char *)odView[i].bmap);
62 <                        free((char *)odView[i].pmap);
61 >                        free((void *)odView[i].bmap);
62 >                        free((void *)odView[i].pmap);
63                          if (odView[i].emap != NULL)
64 <                                free((char *)odView[i].emap);
64 >                                free((void *)odView[i].emap);
65                  }
66 <                free((char *)odView);
66 >                free((void *)odView);
67                  odView = NULL;
68                  odNViews = 0;
69          }
# Line 89 | Line 87 | int    n;
87                          return(0);
88                                  /* assign larger alignment types earlier */
89                  odS.f = (union ODfunion *)odS.base;
90 <                odS.redraw = (int4 *)(odS.f + n);
90 >                odS.redraw = (int32 *)(odS.f + n);
91                  odS.ip = (short (*)[2])(odS.redraw + n/32);
92                  odS.brt = (TMbright *)(odS.ip + n);
93                  odS.chr = (BYTE (*)[3])(odS.brt + n);
# Line 119 | Line 117 | int    n;
117                  if (odView[i].vlow < 1) odView[i].vlow = 1;
118                  odView[i].emap = NULL;
119                  odView[i].dmap = NULL;
120 <                odView[i].pmap = (int4 *)calloc(FL4NELS(res[0]*res[1]),
121 <                                sizeof(int4));
120 >                odView[i].pmap = (int32 *)calloc(FL4NELS(res[0]*res[1]),
121 >                                sizeof(int32));
122                  if (odView[i].pmap == NULL)
123                          return(0);
124                  j = odView[i].hlow*odView[i].vlow;
# Line 131 | Line 129 | int    n;
129                  DCHECK(count<=0 | nextsamp>=n,
130                                  CONSISTENCY, "counter botch in odInit");
131                  if (!i) count = j;
132 +                odView[i].sfirst = nextsamp;
133                  while (j--) {           /* initialize blocks & free lists */
134                          odView[i].bmap[j].pthresh = FHUGE;
135                          odView[i].bmap[j].first = k = nextsamp;
# Line 142 | Line 141 | int    n;
141                          odS.nextfree(k-1) = ENDFREE;
142                          odView[i].bmap[j].nused = 0;
143                  }
144 +                odView[i].snext = nextsamp;
145 +                odView[i].n2redraw = 0;
146          }
147          CLR4ALL(odS.redraw, odS.nsamp);         /* clear redraw flags */
148          for (i = odS.nsamp; i--; ) {            /* clear values */
# Line 187 | Line 188 | double prox;
188          if (CHK4(odView[vn].pmap, vh*odView[vn].hhi + hh))
189                  i = bp->first + bp->nsamp;
190          else
191 <                i = -1;
191 >                i = 0;
192          while (i-- > bp->first)
193                  if (hh == odS.ip[i][0] && vh == odS.ip[i][1]) { /* found it! */
194                                                  /* search free list for it */
# Line 202 | Line 203 | double prox;
203                                                  bp->nused++;
204                                                  goto gotit;
205                                          }
206 <                        if (prox >= 0.999*odS.closeness(i))
206 >                        if (prox >= 0.99*odS.closeness(i))
207                                  return(-1);     /* previous sample is fine */
208                          goto gotit;
209                  }
209 –        DCHECK(i>=-1, WARNING, "pixel in presence map not found in block");
210          if (bp->free != ENDFREE) {      /* allocate from free list */
211                  i = bp->free;
212                  if (odS.ip[i][0] >= 0 & odS.ip[i][1] >= 0)
# Line 297 | Line 297 | FVECT  d, p;
297                  if (id < 0)
298                          continue;               /* not good enough */
299                                                          /* convert color */
300 <                tmCvColrs(&odS.brt[id], odS.chr[id], c, 1);
300 >                tmCvColrs(&odS.brt[id], odS.chr[id], (COLR *)c, 1);
301                  if (imm_mode | needmapping)             /* if immediate mode */
302                          needmapping |= NEWRGB;          /* map it later */
303                  else                                    /* else map it now */
304                          tmMapPixels(odS.rgb[id], &odS.brt[id], odS.chr[id], 1);
305                  SET4(odS.redraw, id);                   /* mark for redraw */
306 +                odView[i].n2redraw++;
307          }
308   }
309  
# Line 316 | Line 317 | int    newhist;
317   }
318  
319  
320 + odRedrawAll()                           /* mark all samples for redraw */
321 + {
322 +        register int    i;
323 +
324 +        if ((needmapping&(NEWMAP|NEWRGB)) == (NEWMAP|NEWRGB))
325 +                return;                 /* will be called later, anyway */
326 +        for (i = odS.nsamp; i--; )
327 +                if (odS.ip[i][0] >= 0)
328 +                        SET4(odS.redraw, i);
329 +                                        /* not right, but not important */
330 +        for (i = 0; i < odNViews; i++)
331 +                odView[i].n2redraw = odView[i].snext - odView[i].sfirst;
332 + }
333 +
334 +
335   odRedraw(vn, hmin, vmin, hmax, vmax)    /* redraw view region */
336   int     vn, hmin, vmin, hmax, vmax;
337   {
# Line 342 | Line 358 | int    vn, hmin, vmin, hmax, vmax;
358                  for (j = vmin; j <= vmax; j++) {
359                          bp = odView[vn].bmap + j*odView[vn].hlow + i;
360                          for (k = bp->nsamp; k--; )
361 <                                if (odS.ip[bp->first+k][0] >= 0)
361 >                                if (odS.ip[bp->first+k][0] >= 0) {
362                                          SET4(odS.redraw, bp->first+k);
363 +                                        odView[vn].n2redraw++;
364 +                                }
365                  }
366   }
367  
# Line 360 | Line 378 | GLfloat        *dm;
378                  if (vn<0 | vn>=odNViews)
379                          return;                 /* too late -- they're gone! */
380                  if (odView[vn].emap != NULL)
381 <                        free((char *)odView[vn].emap);
381 >                        free((void *)odView[vn].emap);
382                  odView[vn].emap = NULL;
383                  odView[vn].dmap = NULL;
384                  return;
# Line 369 | Line 387 | GLfloat        *dm;
387                          "bad view number in odDepthMap");
388          odView[vn].dmap = dm;                   /* initialize edge map */
389          if (odView[vn].emap == NULL) {
390 <                odView[vn].emap = (int4 *)malloc(
391 <                        FL4NELS(odView[vn].hlow*odView[vn].vlow)*sizeof(int4));
390 >                odView[vn].emap = (int32 *)malloc(
391 >                        FL4NELS(odView[vn].hlow*odView[vn].vlow)*sizeof(int32));
392                  if (odView[vn].emap == NULL)
393                          error(SYSTEM, "out of memory in odDepthMap");
394          }
# Line 424 | Line 442 | GLfloat        *dm;
442   odUpdate(vn)                            /* update this view */
443   int     vn;
444   {
445 <        register int    i, j;
445 >        static short    primes[] = {9431,6803,4177,2659,1609,887,587,251,47,1};
446 >        int     myprime;
447 >        register int    i, n;
448  
449          DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
450                          "bad view number in odUpdate");
# Line 433 | Line 453 | int    vn;
453                  if (needmapping & NEWMAP) {
454                          if (needmapping & NEWHIST)
455                                  tmClearHisto();
456 +                        needmapping &= ~NEWHIST;
457                          if (tmAddHisto(odS.brt,odS.nsamp,1) != TM_E_OK)
458                                  return;
459                          if (tmComputeMapping(0.,0.,0.) != TM_E_OK)
460                                  return;
461 <                        for (i = odS.nsamp; i--; )      /* redraw all */
462 <                                if (odS.ip[i][0] >= 0)
442 <                                        SET4(odS.redraw, i);
461 >                        needmapping &= ~NEWMAP;
462 >                        odRedrawAll();                  /* redraw everything */
463                  }
464 <                if (tmMapPixels(odS.rgb,odS.brt,odS.chr,odS.nsamp) != TM_E_OK)
464 >                if (tmMapPixels((BYTE *)(odS.rgb), odS.brt,
465 >                                (BYTE *)(odS.chr), odS.nsamp) != TM_E_OK)
466                          return;
467 <                needmapping = 0;                /* reset flag */
467 >                needmapping &= ~NEWRGB;
468          }
469 <                                        /* draw samples flagged for redraw */
470 <        for (j = FL4NELS(odS.nsamp); j--; )
471 <                for (i = 0; odS.redraw[j]; i++)         /* skips faster */
472 <                        if (odS.redraw[j] & 1L<<i) {
473 <                                odDrawSamp(vn, (j<<5)+i);
474 <                                odS.redraw[j] &= ~(1L<<i);
469 >        if (odView[vn].n2redraw <= 0)
470 >                return;
471 > #if REDRAWTHRESH
472 >        if (odView[vn].n2redraw < REDRAWTHRESH)
473 >                goto quickdraw;
474 >                                        /* pick a good prime step size */
475 >        n = odView[vn].snext - odView[vn].sfirst;
476 >        for (i = 0; primes[i]<<5 >= n; i++)
477 >                ;
478 >        while ((myprime = primes[i++]) > 1)
479 >                if (n % myprime)
480 >                        break;
481 >                                        /* dissolve in new samples */
482 >        for (i = odView[vn].sfirst; n-- > 0; i += myprime) {
483 >                if (i >= odView[vn].snext)
484 >                        i -= odView[vn].snext - odView[vn].sfirst;
485 >                if (CHK4(odS.redraw, i)) {
486 >                        odDrawSamp(vn, i);
487 >                        CLR4(odS.redraw, i);
488 >                }
489 >        }
490 >        odView[vn].n2redraw = 0;
491 >        return;
492 > quickdraw:                              /* quicker sparse flag checking */
493 > #endif
494 >                                        /* redraw samples at end */
495 >        for (i = odView[vn].snext-31; i < odView[vn].snext; i++)
496 >                if (CHK4(odS.redraw, i)) {
497 >                        odDrawSamp(vn, i);
498 >                        CLR4(odS.redraw, i);
499 >                }
500 >                                        /* faster flag checks in middle */
501 >        for (n = odView[vn].snext>>5; n-- > (odView[vn].sfirst+0x1f)>>5; )
502 >                for (i = 0; odS.redraw[n]; i++)         /* skips faster */
503 >                        if (odS.redraw[n] & 1L<<i) {
504 >                                odDrawSamp(vn, (n<<5)+i);
505 >                                odS.redraw[n] &= ~(1L<<i);
506                          }
507 +                                        /* redraw samples at beginning */
508 +        for (i = odView[vn].sfirst; i < odView[vn].sfirst+31; i++)
509 +                if (CHK4(odS.redraw, i)) {
510 +                        odDrawSamp(vn, i);
511 +                        CLR4(odS.redraw, i);
512 +                }
513 +        odView[vn].n2redraw = 0;
514   }
515  
516  
517 +                                        /* this turned out to be unnecessary */
518   #if 0
519   static
520   clip_end(p, o, vp)                      /* clip line segment to view */
# Line 492 | Line 552 | register struct ODview *vp;
552   double  sz;
553   {
554          int     na, dv;
555 <        double  hrad, vrad, phi0, phi;
555 >        double  hrad, vrad, phi;
556          register int    i;
557  
558          DCHECK(sz > 1, CONSISTENCY, "super-unary size in make_arms");
559 <        na = MAXFAN*sz*sz + 0.5;                /* keep area constant */
559 >        na = MAXFAN*sz + 0.5;                   /* keep arc length constant */
560          if (na < MINFAN) na = MINFAN;
561          hrad = FANSIZE*sz*vp->hhi/vp->hlow;
562          vrad = FANSIZE*sz*vp->vhi/vp->vlow;
563          if (hrad*vrad < 2.25)
564                  hrad = vrad = 1.5;
505 –        phi0 = (2.*PI) * frandom();
565          dv = OMAXDEPTH*sz + 0.5;
566          for (i = 0; i < na; i++) {
567 <                phi = phi0 + (2.*PI)*i/na;
567 >                phi = (2.*PI)*i/na;
568                  ar[i][0] = cp[0] + tcos(phi)*hrad + 0.5;
569                  ar[i][1] = cp[1] + tsin(phi)*vrad + 0.5;
570                  ar[i][2] = dv;
# Line 558 | Line 617 | register struct ODview *vp;
617          n = rise + run;
618          while (n--)                     /* run out arm, checking depth */
619                  if (run2 > rise2) {
561 –                        if (depthchange(vp, x, y, x+xstep, y))
562 –                                break;
620                          x += xstep;
621                          rise2 += rise;
622 <                } else {
566 <                        if (depthchange(vp, x, y, x, y+ystep))
622 >                        if (depthchange(vp, x-xstep, y, x, y))
623                                  break;
624 +                } else {
625                          y += ystep;
626                          run2 += run;
627 +                        if (depthchange(vp, x, y-ystep, x, y))
628 +                                break;
629                  }
630          if (n < 0)                      /* found something? */
631                  return;
# Line 590 | Line 649 | register int   h, v;
649   }
650  
651  
652 + static int
653 + blockedge(vp, bi0, bi1)                 /* check for edge between blocks? */
654 + register struct ODview  *vp;
655 + register int    bi0, bi1;
656 + {
657 +        if (bi1 == bi0)
658 +                return(0);              /* same block */
659 +        if (bi1 < 0)
660 +                return(1);              /* end off view */
661 +        if (CHK4(vp->emap, bi1))
662 +                return(1);              /* end block has edges */
663 +        if (bi1 == bi0+1 || bi1 == bi0-1 ||
664 +                        bi1 == bi0+vp->hlow || bi1 == bi0-vp->hlow)
665 +                return(0);              /* end in adjacent block -- no edges */
666 +        return(1);                      /* conservative for rarer case */
667 + }
668 +
669 +
670   odDrawSamp(vn, id)                      /* draw view sample */
671   int     vn;
672   register int    id;
673   {
674          GLshort arm[MAXFAN][3];
675 <        int     narms, blockindex, bi1;
675 >        int     narms, blockindex;
676          register struct ODview  *vp;
677          double  size;
678          int     home_edges;
# Line 612 | Line 689 | register int   id;
689          if (vp->emap != NULL) {         /* check for edge collisions */
690                  home_edges = CHK4(vp->emap, blockindex);
691                  for (i = 0; i < narms; i++)
692 <                        /* the following test is flawed, because we could
693 <                         * be passing through a block on a diagonal run */
617 <                        if (home_edges ||
618 <                                ( (bi1 = getblock(vp, arm[i][0], arm[i][1]))
619 <                                                != blockindex &&
620 <                                        (bi1 < 0 || CHK4(vp->emap, bi1)) ))
692 >                        if (home_edges || blockedge(vp, blockindex,
693 >                                        getblock(vp, arm[i][0], arm[i][1])))
694                                  clip_edge(arm[i], odS.ip[id], vp);
695          }
696                                          /* draw triangle fan */

Diff Legend

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