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.2 by gwlarson, Sun Dec 20 20:37:53 1998 UTC vs.
Revision 3.10 by gwlarson, Thu Dec 24 16:18:45 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 58 | Line 57 | int    n;
57          int     nbytes, i, j, k, nextsamp, count, blockdiv;
58          int     res[2];
59  
60 <        if (odNViews) {                 /* deallocate view structures */
61 <                for (i = 0; i < odNViews; i++) {
60 >        if (odNViews > 0) {             /* deallocate view structures */
61 >                for (i = odNViews; i--; ) {
62                          free((char *)odView[i].bmap);
63 +                        free((char *)odView[i].pmap);
64                          if (odView[i].emap != NULL)
65                                  free((char *)odView[i].emap);
66                  }
# Line 109 | Line 109 | int    n;
109          if (blockdiv < 8) blockdiv = 8;
110          nextsamp = 0; count /= blockdiv*blockdiv;       /* # blocks */
111          while (i--) {                   /* initialize each view */
112 –                odView[i].emap = NULL;
113 –                odView[i].dmap = NULL;
112                  dev_auxview(i, res);
113                  odView[i].hhi = res[0];
114                  odView[i].hlow = (res[0] + blockdiv/2) / blockdiv;
# Line 118 | Line 116 | int    n;
116                  odView[i].vhi = res[1];
117                  odView[i].vlow = (res[1] + blockdiv/2) / blockdiv;
118                  if (odView[i].vlow < 1) odView[i].vlow = 1;
119 +                odView[i].emap = NULL;
120 +                odView[i].dmap = NULL;
121 +                odView[i].pmap = (int4 *)calloc(FL4NELS(res[0]*res[1]),
122 +                                sizeof(int4));
123 +                if (odView[i].pmap == NULL)
124 +                        return(0);
125                  j = odView[i].hlow*odView[i].vlow;
126                  odView[i].bmap = (struct ODblock *)malloc(
127                                  j * sizeof(struct ODblock));
# Line 126 | Line 130 | int    n;
130                  DCHECK(count<=0 | nextsamp>=n,
131                                  CONSISTENCY, "counter botch in odInit");
132                  if (!i) count = j;
133 +                odView[i].sfirst = nextsamp;
134                  while (j--) {           /* initialize blocks & free lists */
135                          odView[i].bmap[j].pthresh = FHUGE;
136                          odView[i].bmap[j].first = k = nextsamp;
# Line 137 | Line 142 | int    n;
142                          odS.nextfree(k-1) = ENDFREE;
143                          odView[i].bmap[j].nused = 0;
144                  }
145 +                odView[i].snext = nextsamp;
146          }
147          CLR4ALL(odS.redraw, odS.nsamp);         /* clear redraw flags */
148          for (i = odS.nsamp; i--; ) {            /* clear values */
# Line 179 | Line 185 | double prox;
185          if (prox > bp->pthresh)
186                  return(-1);             /* worse than free list occupants */
187                                          /* check for duplicate pixel */
188 <        for (i = bp->first+bp->nsamp; i-- > bp->first; )
188 >        if (CHK4(odView[vn].pmap, vh*odView[vn].hhi + hh))
189 >                i = bp->first + bp->nsamp;
190 >        else
191 >                i = -1;
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 */
195                          if (i == bp->free)
# Line 197 | Line 207 | double prox;
207                                  return(-1);     /* previous sample is fine */
208                          goto gotit;
209                  }
210 +        DCHECK(i>=-1, WARNING, "pixel in presence map not found in block");
211          if (bp->free != ENDFREE) {      /* allocate from free list */
212                  i = bp->free;
213 +                if (odS.ip[i][0] >= 0 & odS.ip[i][1] >= 0)
214 +                        CLR4(odView[vn].pmap, odS.ip[i][1]*odView[vn].hhi +
215 +                                                        odS.ip[i][0]);
216                  bp->free = odS.nextfree(i);
217                  bp->nused++;
218                  goto gotit;
# Line 222 | Line 236 | double prox;
236                  bp->nused--;
237          }
238          i = si[0];                      /* use worst sample */
239 +        CLR4(odView[vn].pmap, odS.ip[i][1]*odView[vn].hhi + odS.ip[i][0]);
240   gotit:
241          odS.ip[i][0] = hh;
242          odS.ip[i][1] = vh;
243          odS.closeness(i) = prox;
244 +        SET4(odView[vn].pmap, vh*odView[vn].hhi + hh);
245          return(i);
246   }
247  
# Line 301 | 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 + }
330 +
331 +
332   odRedraw(vn, hmin, vmin, hmax, vmax)    /* redraw view region */
333   int     vn, hmin, vmin, hmax, vmax;
334   {
# Line 409 | Line 437 | GLfloat        *dm;
437   odUpdate(vn)                            /* update this view */
438   int     vn;
439   {
440 <        int     i, j;
413 <        register struct ODblock *bp;
414 <        register int    k;
440 >        register int    i, j;
441  
442          DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
443                          "bad view number in odUpdate");
# Line 420 | Line 446 | int    vn;
446                  if (needmapping & NEWMAP) {
447                          if (needmapping & NEWHIST)
448                                  tmClearHisto();
449 +                        needmapping &= ~NEWHIST;
450                          if (tmAddHisto(odS.brt,odS.nsamp,1) != TM_E_OK)
451                                  return;
452                          if (tmComputeMapping(0.,0.,0.) != TM_E_OK)
453                                  return;
454 <                        for (k = odS.nsamp; k--; )      /* redraw all */
455 <                                if (odS.ip[k][0] >= 0)
429 <                                        SET4(odS.redraw, k);
454 >                        needmapping &= ~NEWMAP;
455 >                        odRedrawAll();                  /* redraw everything */
456                  }
457                  if (tmMapPixels(odS.rgb,odS.brt,odS.chr,odS.nsamp) != TM_E_OK)
458                          return;
459 <                needmapping = 0;                /* reset flag */
459 >                needmapping &= ~NEWRGB;
460          }
461 <                                        /* draw each block in view */
462 <        for (j = odView[vn].vlow; j--; )
463 <                for (i = 0; i < odView[vn].hlow; i++) {
464 <                                        /* get block */
465 <                        bp = odView[vn].bmap + j*odView[vn].hlow + i;
466 <                                        /* do quick, conservative flag check */
441 <                        for (k = (bp->first+bp->nsamp+31)>>5;
442 <                                        k-- > bp->first>>5; )
443 <                                if (odS.redraw[k])
444 <                                        break;          /* non-zero flag */
445 <                        if (k < bp->first>>5)
446 <                                continue;               /* no flags set */
447 <                        for (k = bp->nsamp; k--; )      /* sample by sample */
448 <                                if (CHK4(odS.redraw, bp->first+k)) {
449 <                                        odDrawBlockSamp(vn, i, j, bp->first+k);
450 <                                        CLR4(odS.redraw, bp->first+k);
451 <                                }
461 >                                        /* this code segment was too slow */
462 > #if 0
463 >        for (i = odView[vn].sfirst; i < odView[vn].snext; i++)
464 >                if (CHK4(odS.redraw, i)) {
465 >                        odDrawSamp(vn, i);
466 >                        CLR4(odS.redraw, i);
467                  }
468 + #else
469 +                                        /* redraw samples at end */
470 +        for (i = odView[vn].snext-31; i < odView[vn].snext; i++)
471 +                if (CHK4(odS.redraw, i)) {
472 +                        odDrawSamp(vn, i);
473 +                        CLR4(odS.redraw, i);
474 +                }
475 +                                        /* faster flag checks in middle */
476 +        for (j = odView[vn].snext>>5; j-- > (odView[vn].sfirst+0x1f)>>5; )
477 +                for (i = 0; odS.redraw[j]; i++)         /* skips faster */
478 +                        if (odS.redraw[j] & 1L<<i) {
479 +                                odDrawSamp(vn, (j<<5)+i);
480 +                                odS.redraw[j] &= ~(1L<<i);
481 +                        }
482 +                                        /* redraw samples at beginning */
483 +        for (i = odView[vn].sfirst; i < odView[vn].sfirst+31; i++)
484 +                if (CHK4(odS.redraw, i)) {
485 +                        odDrawSamp(vn, i);
486 +                        CLR4(odS.redraw, i);
487 +                }
488 + #endif
489   }
490  
491  
492 +                                        /* this turned out to be unnecessary */
493   #if 0
494   static
495   clip_end(p, o, vp)                      /* clip line segment to view */
# Line 490 | Line 527 | register struct ODview *vp;
527   double  sz;
528   {
529          int     na, dv;
530 <        double  hrad, vrad, phi0, phi;
530 >        double  hrad, vrad, phi;
531          register int    i;
532  
533          DCHECK(sz > 1, CONSISTENCY, "super-unary size in make_arms");
534 <        na = MAXFAN*sz*sz + 0.5;                /* keep area constant */
534 >        na = MAXFAN*sz + 0.5;                   /* keep arc length constant */
535          if (na < MINFAN) na = MINFAN;
536          hrad = FANSIZE*sz*vp->hhi/vp->hlow;
537          vrad = FANSIZE*sz*vp->vhi/vp->vlow;
538          if (hrad*vrad < 2.25)
539                  hrad = vrad = 1.5;
503 –        phi0 = (2.*PI) * frandom();
540          dv = OMAXDEPTH*sz + 0.5;
541          for (i = 0; i < na; i++) {
542 <                phi = phi0 + (2.*PI)*i/na;
542 >                phi = (2.*PI)*i/na;
543                  ar[i][0] = cp[0] + tcos(phi)*hrad + 0.5;
544                  ar[i][1] = cp[1] + tsin(phi)*vrad + 0.5;
545                  ar[i][2] = dv;
# Line 556 | Line 592 | register struct ODview *vp;
592          n = rise + run;
593          while (n--)                     /* run out arm, checking depth */
594                  if (run2 > rise2) {
559 –                        if (depthchange(vp, x, y, x+xstep, y))
560 –                                break;
595                          x += xstep;
596                          rise2 += rise;
597 <                } else {
564 <                        if (depthchange(vp, x, y, x, y+ystep))
597 >                        if (depthchange(vp, x-xstep, y, x, y))
598                                  break;
599 +                } else {
600                          y += ystep;
601                          run2 += run;
602 +                        if (depthchange(vp, x, y-ystep, x, y))
603 +                                break;
604                  }
605          if (n < 0)                      /* found something? */
606                  return;
# Line 588 | Line 624 | register int   h, v;
624   }
625  
626  
627 < odDrawBlockSamp(vn, h, v, id)           /* draw sample in view block */
628 < int     vn, h, v;
627 > static int
628 > blockedge(vp, bi0, bi1)                 /* check for edge between blocks? */
629 > register struct ODview  *vp;
630 > register int    bi0, bi1;
631 > {
632 >        if (bi1 == bi0)
633 >                return(0);              /* same block */
634 >        if (bi1 < 0)
635 >                return(1);              /* end off view */
636 >        if (CHK4(vp->emap, bi1))
637 >                return(1);              /* end block has edges */
638 >        if (bi1 == bi0+1 || bi1 == bi0-1 ||
639 >                        bi1 == bi0+vp->hlow || bi1 == bi0-vp->hlow)
640 >                return(0);              /* end in adjacent block -- no edges */
641 >        return(1);                      /* conservative for rarer case */
642 > }
643 >
644 >
645 > odDrawSamp(vn, id)                      /* draw view sample */
646 > int     vn;
647   register int    id;
648   {
649          GLshort arm[MAXFAN][3];
650 <        int     narms, blockindex, bi1;
650 >        int     narms, blockindex;
651          register struct ODview  *vp;
652          double  size;
653          int     home_edges;
654          register int    i;
655  
656          vp = odView + vn;
657 <        blockindex = v*vp->hlow + h;
658 <        DCHECK(odS.ip[id][0]*vp->hlow/vp->hhi != h |
605 <                        odS.ip[id][1]*vp->vlow/vp->vhi != v,
606 <                        CONSISTENCY, "bad sample position in odDrawBlockSamp");
657 >        blockindex = getblock(vp, odS.ip[id][0], odS.ip[id][1]);
658 >        DCHECK(blockindex<0, CONSISTENCY, "bad sample handed to odDrawSamp");
659          DCHECK(vp->bmap[blockindex].nused <= 0,
660 <                        CONSISTENCY, "bad in-use count in odDrawBlockSamp");
660 >                        CONSISTENCY, "bad in-use count in odDrawSamp");
661                                          /* create triangle fan */
662          size = 1./sqrt((double)vp->bmap[blockindex].nused);
663          narms = make_arms(arm, odS.ip[id], vp, size);
664          if (vp->emap != NULL) {         /* check for edge collisions */
665                  home_edges = CHK4(vp->emap, blockindex);
666                  for (i = 0; i < narms; i++)
667 <                        /* the following test is flawed, because we could
668 <                         * 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)) ))
667 >                        if (home_edges || blockedge(vp, blockindex,
668 >                                        getblock(vp, arm[i][0], arm[i][1])))
669                                  clip_edge(arm[i], odS.ip[id], vp);
670          }
671                                          /* draw triangle fan */

Diff Legend

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