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.11 by gwlarson, Tue Dec 29 09:51:07 1998 UTC

# Line 14 | Line 14 | static char SCCSid[] = "$SunId$ SGI";
14   #include <GL/glx.h>
15   #include <GL/glu.h>
16  
17 – #include "random.h"
17   #include "rhd_odraw.h"
18  
19   #ifndef DEPTHEPS
# Line 26 | Line 25 | static char SCCSid[] = "$SunId$ SGI";
25   #ifndef SFREEFRAC
26   #define SFREEFRAC       0.2             /* fraction to free at a time */
27   #endif
28 + #ifndef REDRAWTHRESH
29 + #define REDRAWTHRESH    10240           /* number of samples for dissolve */
30 + #endif
31   #ifndef MAXFAN
32   #define MAXFAN          32              /* maximum arms in a triangle fan */
33   #endif
# Line 131 | Line 133 | int    n;
133                  DCHECK(count<=0 | nextsamp>=n,
134                                  CONSISTENCY, "counter botch in odInit");
135                  if (!i) count = j;
136 +                odView[i].sfirst = nextsamp;
137                  while (j--) {           /* initialize blocks & free lists */
138                          odView[i].bmap[j].pthresh = FHUGE;
139                          odView[i].bmap[j].first = k = nextsamp;
# Line 142 | Line 145 | int    n;
145                          odS.nextfree(k-1) = ENDFREE;
146                          odView[i].bmap[j].nused = 0;
147                  }
148 +                odView[i].snext = nextsamp;
149 +                odView[i].n2redraw = 0;
150          }
151          CLR4ALL(odS.redraw, odS.nsamp);         /* clear redraw flags */
152          for (i = odS.nsamp; i--; ) {            /* clear values */
# Line 187 | Line 192 | double prox;
192          if (CHK4(odView[vn].pmap, vh*odView[vn].hhi + hh))
193                  i = bp->first + bp->nsamp;
194          else
195 <                i = -1;
195 >                i = 0;
196          while (i-- > bp->first)
197                  if (hh == odS.ip[i][0] && vh == odS.ip[i][1]) { /* found it! */
198                                                  /* search free list for it */
# Line 202 | Line 207 | double prox;
207                                                  bp->nused++;
208                                                  goto gotit;
209                                          }
210 <                        if (prox >= 0.999*odS.closeness(i))
210 >                        if (prox >= 0.99*odS.closeness(i))
211                                  return(-1);     /* previous sample is fine */
212                          goto gotit;
213                  }
209 –        DCHECK(i>=-1, WARNING, "pixel in presence map not found in block");
214          if (bp->free != ENDFREE) {      /* allocate from free list */
215                  i = bp->free;
216                  if (odS.ip[i][0] >= 0 & odS.ip[i][1] >= 0)
# Line 303 | Line 307 | FVECT  d, p;
307                  else                                    /* else map it now */
308                          tmMapPixels(odS.rgb[id], &odS.brt[id], odS.chr[id], 1);
309                  SET4(odS.redraw, id);                   /* mark for redraw */
310 +                odView[i].n2redraw++;
311          }
312   }
313  
# Line 316 | Line 321 | int    newhist;
321   }
322  
323  
324 + odRedrawAll()                           /* mark all samples for redraw */
325 + {
326 +        register int    i;
327 +
328 +        if ((needmapping&(NEWMAP|NEWRGB)) == (NEWMAP|NEWRGB))
329 +                return;                 /* will be called later, anyway */
330 +        for (i = odS.nsamp; i--; )
331 +                if (odS.ip[i][0] >= 0)
332 +                        SET4(odS.redraw, i);
333 +                                        /* not right, but not important */
334 +        for (i = 0; i < odNViews; i++)
335 +                odView[i].n2redraw = odView[i].snext - odView[i].sfirst;
336 + }
337 +
338 +
339   odRedraw(vn, hmin, vmin, hmax, vmax)    /* redraw view region */
340   int     vn, hmin, vmin, hmax, vmax;
341   {
# Line 342 | Line 362 | int    vn, hmin, vmin, hmax, vmax;
362                  for (j = vmin; j <= vmax; j++) {
363                          bp = odView[vn].bmap + j*odView[vn].hlow + i;
364                          for (k = bp->nsamp; k--; )
365 <                                if (odS.ip[bp->first+k][0] >= 0)
365 >                                if (odS.ip[bp->first+k][0] >= 0) {
366                                          SET4(odS.redraw, bp->first+k);
367 +                                        odView[vn].n2redraw++;
368 +                                }
369                  }
370   }
371  
# Line 424 | Line 446 | GLfloat        *dm;
446   odUpdate(vn)                            /* update this view */
447   int     vn;
448   {
449 <        register int    i, j;
449 >        static short    primes[] = {9431,6803,4177,2659,1609,887,587,251,47,1};
450 >        int     myprime;
451 >        register int    i, n;
452  
453          DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
454                          "bad view number in odUpdate");
# Line 433 | Line 457 | int    vn;
457                  if (needmapping & NEWMAP) {
458                          if (needmapping & NEWHIST)
459                                  tmClearHisto();
460 +                        needmapping &= ~NEWHIST;
461                          if (tmAddHisto(odS.brt,odS.nsamp,1) != TM_E_OK)
462                                  return;
463                          if (tmComputeMapping(0.,0.,0.) != TM_E_OK)
464                                  return;
465 <                        for (i = odS.nsamp; i--; )      /* redraw all */
466 <                                if (odS.ip[i][0] >= 0)
442 <                                        SET4(odS.redraw, i);
465 >                        needmapping &= ~NEWMAP;
466 >                        odRedrawAll();                  /* redraw everything */
467                  }
468                  if (tmMapPixels(odS.rgb,odS.brt,odS.chr,odS.nsamp) != TM_E_OK)
469                          return;
470 <                needmapping = 0;                /* reset flag */
470 >                needmapping &= ~NEWRGB;
471          }
472 <                                        /* draw samples flagged for redraw */
473 <        for (j = FL4NELS(odS.nsamp); j--; )
474 <                for (i = 0; odS.redraw[j]; i++)         /* skips faster */
475 <                        if (odS.redraw[j] & 1L<<i) {
476 <                                odDrawSamp(vn, (j<<5)+i);
477 <                                odS.redraw[j] &= ~(1L<<i);
472 >        if (odView[vn].n2redraw <= 0)
473 >                return;
474 > #if REDRAWTHRESH
475 >        if (odView[vn].n2redraw < REDRAWTHRESH)
476 >                goto quickdraw;
477 >                                        /* pick a good prime step size */
478 >        n = odView[vn].snext - odView[vn].sfirst;
479 >        for (i = 0; primes[i]<<5 >= n; i++)
480 >                ;
481 >        while ((myprime = primes[i++]) > 1)
482 >                if (n % myprime)
483 >                        break;
484 >                                        /* dissolve in new samples */
485 >        for (i = odView[vn].sfirst; n-- > 0; i += myprime) {
486 >                if (i >= odView[vn].snext)
487 >                        i -= odView[vn].snext - odView[vn].sfirst;
488 >                if (CHK4(odS.redraw, i)) {
489 >                        odDrawSamp(vn, i);
490 >                        CLR4(odS.redraw, i);
491 >                }
492 >        }
493 >        odView[vn].n2redraw = 0;
494 >        return;
495 > quickdraw:                              /* quicker sparse flag checking */
496 > #endif
497 >                                        /* redraw samples at end */
498 >        for (i = odView[vn].snext-31; i < odView[vn].snext; i++)
499 >                if (CHK4(odS.redraw, i)) {
500 >                        odDrawSamp(vn, i);
501 >                        CLR4(odS.redraw, i);
502 >                }
503 >                                        /* faster flag checks in middle */
504 >        for (n = odView[vn].snext>>5; n-- > (odView[vn].sfirst+0x1f)>>5; )
505 >                for (i = 0; odS.redraw[n]; i++)         /* skips faster */
506 >                        if (odS.redraw[n] & 1L<<i) {
507 >                                odDrawSamp(vn, (n<<5)+i);
508 >                                odS.redraw[n] &= ~(1L<<i);
509                          }
510 +                                        /* redraw samples at beginning */
511 +        for (i = odView[vn].sfirst; i < odView[vn].sfirst+31; i++)
512 +                if (CHK4(odS.redraw, i)) {
513 +                        odDrawSamp(vn, i);
514 +                        CLR4(odS.redraw, i);
515 +                }
516 +        odView[vn].n2redraw = 0;
517   }
518  
519  
520 +                                        /* this turned out to be unnecessary */
521   #if 0
522   static
523   clip_end(p, o, vp)                      /* clip line segment to view */
# Line 492 | Line 555 | register struct ODview *vp;
555   double  sz;
556   {
557          int     na, dv;
558 <        double  hrad, vrad, phi0, phi;
558 >        double  hrad, vrad, phi;
559          register int    i;
560  
561          DCHECK(sz > 1, CONSISTENCY, "super-unary size in make_arms");
562 <        na = MAXFAN*sz*sz + 0.5;                /* keep area constant */
562 >        na = MAXFAN*sz + 0.5;                   /* keep arc length constant */
563          if (na < MINFAN) na = MINFAN;
564          hrad = FANSIZE*sz*vp->hhi/vp->hlow;
565          vrad = FANSIZE*sz*vp->vhi/vp->vlow;
566          if (hrad*vrad < 2.25)
567                  hrad = vrad = 1.5;
505 –        phi0 = (2.*PI) * frandom();
568          dv = OMAXDEPTH*sz + 0.5;
569          for (i = 0; i < na; i++) {
570 <                phi = phi0 + (2.*PI)*i/na;
570 >                phi = (2.*PI)*i/na;
571                  ar[i][0] = cp[0] + tcos(phi)*hrad + 0.5;
572                  ar[i][1] = cp[1] + tsin(phi)*vrad + 0.5;
573                  ar[i][2] = dv;
# Line 558 | Line 620 | register struct ODview *vp;
620          n = rise + run;
621          while (n--)                     /* run out arm, checking depth */
622                  if (run2 > rise2) {
561 –                        if (depthchange(vp, x, y, x+xstep, y))
562 –                                break;
623                          x += xstep;
624                          rise2 += rise;
625 <                } else {
566 <                        if (depthchange(vp, x, y, x, y+ystep))
625 >                        if (depthchange(vp, x-xstep, y, x, y))
626                                  break;
627 +                } else {
628                          y += ystep;
629                          run2 += run;
630 +                        if (depthchange(vp, x, y-ystep, x, y))
631 +                                break;
632                  }
633          if (n < 0)                      /* found something? */
634                  return;
# Line 590 | Line 652 | register int   h, v;
652   }
653  
654  
655 + static int
656 + blockedge(vp, bi0, bi1)                 /* check for edge between blocks? */
657 + register struct ODview  *vp;
658 + register int    bi0, bi1;
659 + {
660 +        if (bi1 == bi0)
661 +                return(0);              /* same block */
662 +        if (bi1 < 0)
663 +                return(1);              /* end off view */
664 +        if (CHK4(vp->emap, bi1))
665 +                return(1);              /* end block has edges */
666 +        if (bi1 == bi0+1 || bi1 == bi0-1 ||
667 +                        bi1 == bi0+vp->hlow || bi1 == bi0-vp->hlow)
668 +                return(0);              /* end in adjacent block -- no edges */
669 +        return(1);                      /* conservative for rarer case */
670 + }
671 +
672 +
673   odDrawSamp(vn, id)                      /* draw view sample */
674   int     vn;
675   register int    id;
676   {
677          GLshort arm[MAXFAN][3];
678 <        int     narms, blockindex, bi1;
678 >        int     narms, blockindex;
679          register struct ODview  *vp;
680          double  size;
681          int     home_edges;
# Line 612 | Line 692 | register int   id;
692          if (vp->emap != NULL) {         /* check for edge collisions */
693                  home_edges = CHK4(vp->emap, blockindex);
694                  for (i = 0; i < narms; i++)
695 <                        /* the following test is flawed, because we could
696 <                         * 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)) ))
695 >                        if (home_edges || blockedge(vp, blockindex,
696 >                                        getblock(vp, arm[i][0], arm[i][1])))
697                                  clip_edge(arm[i], odS.ip[id], vp);
698          }
699                                          /* draw triangle fan */

Diff Legend

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