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.1 by gwlarson, Fri Dec 18 11:55:19 1998 UTC vs.
Revision 3.4 by gwlarson, Mon Dec 21 14:05:43 1998 UTC

# Line 38 | Line 38 | static char SCCSid[] = "$SunId$ SGI";
38  
39   #define NEWMAP          01              /* need to recompute mapping */
40   #define NEWRGB          02              /* need to remap RGB values */
41 + #define NEWHIST         04              /* clear histogram as well */
42  
43   struct ODview   *odView;        /* our view list */
44   int     odNViews;               /* number of views in our list */
# Line 57 | Line 58 | int    n;
58          int     nbytes, i, j, k, nextsamp, count, blockdiv;
59          int     res[2];
60  
61 <        if (odNViews) {                 /* deallocate view structures */
62 <                for (i = 0; i < odNViews; i++) {
61 >        if (odNViews > 0) {             /* deallocate view structures */
62 >                for (i = odNViews; i--; ) {
63                          free((char *)odView[i].bmap);
64 +                        free((char *)odView[i].pmap);
65                          if (odView[i].emap != NULL)
66                                  free((char *)odView[i].emap);
67                  }
# Line 73 | Line 75 | int    n;
75                  for (i = 1024; nbytes > i-8; i <<= 1)
76                          ;
77                  n = (i-8)/SAMP32 * 32;
78 <                needmapping = NEWMAP;
78 >                needmapping = NEWHIST;
79          }
80          if (n != odS.nsamp) {   /* (re)allocate sample array */
81                  if (odS.nsamp)
# Line 108 | Line 110 | int    n;
110          if (blockdiv < 8) blockdiv = 8;
111          nextsamp = 0; count /= blockdiv*blockdiv;       /* # blocks */
112          while (i--) {                   /* initialize each view */
111 –                odView[i].emap = NULL;
112 –                odView[i].dmap = NULL;
113                  dev_auxview(i, res);
114                  odView[i].hhi = res[0];
115                  odView[i].hlow = (res[0] + blockdiv/2) / blockdiv;
# Line 117 | Line 117 | int    n;
117                  odView[i].vhi = res[1];
118                  odView[i].vlow = (res[1] + blockdiv/2) / blockdiv;
119                  if (odView[i].vlow < 1) odView[i].vlow = 1;
120 +                odView[i].emap = NULL;
121 +                odView[i].dmap = NULL;
122 +                odView[i].pmap = (int4 *)calloc(FL4NELS(res[0]*res[1]),
123 +                                sizeof(int4));
124 +                if (odView[i].pmap == NULL)
125 +                        return(0);
126                  j = odView[i].hlow*odView[i].vlow;
127                  odView[i].bmap = (struct ODblock *)malloc(
128                                  j * sizeof(struct ODblock));
# Line 125 | Line 131 | int    n;
131                  DCHECK(count<=0 | nextsamp>=n,
132                                  CONSISTENCY, "counter botch in odInit");
133                  if (!i) count = j;
134 <                while (j--) {
134 >                while (j--) {           /* initialize blocks & free lists */
135 >                        odView[i].bmap[j].pthresh = FHUGE;
136                          odView[i].bmap[j].first = k = nextsamp;
137                          nextsamp += odView[i].bmap[j].nsamp =
138                                  (n - nextsamp)/count--;
# Line 137 | Line 144 | int    n;
144                  }
145          }
146          CLR4ALL(odS.redraw, odS.nsamp);         /* clear redraw flags */
147 <        for (i = odS.nsamp; i--; )              /* clear values */
147 >        for (i = odS.nsamp; i--; ) {            /* clear values */
148                  odS.ip[i][0] = odS.ip[i][1] = -1;
149 +                odS.brt[i] = TM_NOBRT;
150 +        }
151 +        needmapping |= NEWMAP;                  /* compute new map on update */
152          return(odS.nsamp);                      /* return number of samples */
153   }
154  
# Line 156 | Line 166 | int    *s0, *s1;
166  
167  
168   int
169 < odAllocBlockSamp(vn, hl, vl)            /* allocate sample from block */
170 < int     vn, hl, vl;
169 > odAllocBlockSamp(vn, hh, vh, prox)      /* allocate sample from block */
170 > int     vn, hh, vh;
171 > double  prox;
172   {
173          int     si[SAMPSPERBLOCK+SAMPSPERBLOCK/4];
174 +        int     hl, vl;
175          VIEW    *vw;
176          FVECT   ro, rd;
177          int     res[2];
178          register struct ODblock *bp;
179 <        register int    i;
180 <
179 >        register int    i, j;
180 >                                        /* get block */
181 >        hl = hh*odView[vn].hlow/odView[vn].hhi;
182 >        vl = vh*odView[vn].vlow/odView[vn].vhi;
183          bp = odView[vn].bmap + vl*odView[vn].hlow + hl;
184 <        if (bp->free != ENDFREE) {      /* check free list first */
184 >        if (prox > bp->pthresh)
185 >                return(-1);             /* worse than free list occupants */
186 >                                        /* check for duplicate pixel */
187 >        if (CHK4(odView[vn].pmap, vh*odView[vn].hhi + hh))
188 >                i = bp->first + bp->nsamp;
189 >        else
190 >                i = -1;
191 >        while (i-- > bp->first)
192 >                if (hh == odS.ip[i][0] && vh == odS.ip[i][1]) { /* found it! */
193 >                                                /* search free list for it */
194 >                        if (i == bp->free)
195 >                                break;          /* special case */
196 >                        if (bp->free != ENDFREE)
197 >                                for (j = bp->free; odS.nextfree(j) != ENDFREE;
198 >                                                j = odS.nextfree(j))
199 >                                        if (odS.nextfree(j) == i) {
200 >                                                odS.nextfree(j) =
201 >                                                        odS.nextfree(i);
202 >                                                bp->nused++;
203 >                                                goto gotit;
204 >                                        }
205 >                        if (prox >= 0.999*odS.closeness(i))
206 >                                return(-1);     /* previous sample is fine */
207 >                        goto gotit;
208 >                }
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)
213 +                        CLR4(odView[vn].pmap, odS.ip[i][1]*odView[vn].hhi +
214 +                                                        odS.ip[i][0]);
215                  bp->free = odS.nextfree(i);
216                  bp->nused++;
217 <                return(i);
217 >                goto gotit;
218          }
219          DCHECK(bp->nsamp<=0, CONSISTENCY,
220                          "no available samples in odAllocBlockSamp");
# Line 183 | Line 226 | int    vn, hl, vl;
226          for (i = bp->nsamp; i--; )      /* figure out which are worse */
227                  si[i] = bp->first + i;
228          qsort((char *)si, bp->nsamp, sizeof(int), sampcmp);
229 <        i = bp->nsamp*SFREEFRAC + .5;   /* put them in a list */
229 >        i = bp->nsamp*SFREEFRAC + .5;   /* put them into free list */
230 >        if (i >= bp->nsamp) i = bp->nsamp-1;    /* paranoia */
231 >        bp->pthresh = odS.closeness(si[i]);     /* new proximity threshold */
232          while (--i > 0) {
233                  odS.nextfree(si[i]) = bp->free;
234                  bp->free = si[i];
235                  bp->nused--;
236          }
237 <        return(si[0]);                  /* return first free sample */
237 >        i = si[0];                      /* use worst sample */
238 >        CLR4(odView[vn].pmap, odS.ip[i][1]*odView[vn].hhi + odS.ip[i][0]);
239 > gotit:
240 >        odS.ip[i][0] = hh;
241 >        odS.ip[i][1] = vh;
242 >        odS.closeness(i) = prox;
243 >        SET4(odView[vn].pmap, vh*odView[vn].hhi + hh);
244 >        return(i);
245   }
246  
247  
# Line 198 | Line 250 | COLR   c;
250   FVECT   d, p;
251   {
252          FVECT   disp;
253 <        double  d0, d1, h, v;
253 >        double  d0, d1, h, v, prox;
254          register VIEW   *vw;
255 <        int     hl, vl, hh, vh;
255 >        int     hh, vh;
256          int     res[2];
257          register int    i, id;
258  
# Line 235 | Line 287 | FVECT  d, p;
287                                                  (1.+DEPTHEPS)*d0 < d1))
288                          continue;                       /* occlusion error */
289                  }
238 –                hl = hh*odView[i].hlow/res[0];
239 –                vl = vh*odView[i].vlow/res[1];
240 –                                                /* may duplicate samples */
241 –                id = odAllocBlockSamp(i, hl, vl);
242 –                odS.ip[id][0] = hh;
243 –                odS.ip[id][1] = vh;
290                  if (p != NULL) {                /* compute closeness (sin^2) */
291                          d1 = DOT(disp, d);
292 <                        odS.closeness(id) = 1. - d1*d1/DOT(disp,disp);
292 >                        prox = 1. - d1*d1/DOT(disp,disp);
293                  } else
294 <                        odS.closeness(id) = 0.;
294 >                        prox = 0.;
295 >                                                /* allocate sample */
296 >                id = odAllocBlockSamp(i, hh, vh, prox);
297 >                if (id < 0)
298 >                        continue;               /* not good enough */
299                                                          /* convert color */
300                  tmCvColrs(&odS.brt[id], odS.chr[id], c, 1);
301                  if (imm_mode | needmapping)             /* if immediate mode */
# Line 257 | Line 307 | FVECT  d, p;
307   }
308  
309  
310 < odRemap()                               /* recompute tone mapping */
310 > odRemap(newhist)                        /* recompute tone mapping */
311 > int     newhist;
312   {
313          needmapping |= NEWMAP|NEWRGB;
314 +        if (newhist)
315 +                needmapping |= NEWHIST;
316   }
317  
318  
# Line 303 | Line 356 | GLfloat        *dm;
356          int     i, j, hmin, hmax, vmin, vmax;
357          register int    k, l;
358  
306 –        DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
307 –                        "bad view number in odDepthMap");
359          if (dm == NULL) {                       /* free edge map */
360 +                if (vn<0 | vn>=odNViews)
361 +                        return;                 /* too late -- they're gone! */
362                  if (odView[vn].emap != NULL)
363                          free((char *)odView[vn].emap);
364                  odView[vn].emap = NULL;
365                  odView[vn].dmap = NULL;
366                  return;
367          }
368 +        DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
369 +                        "bad view number in odDepthMap");
370          odView[vn].dmap = dm;                   /* initialize edge map */
371          if (odView[vn].emap == NULL) {
372                  odView[vn].emap = (int4 *)malloc(
# Line 369 | Line 424 | GLfloat        *dm;
424   odUpdate(vn)                            /* update this view */
425   int     vn;
426   {
427 <        int     i, j;
373 <        register struct ODblock *bp;
374 <        register int    k;
427 >        register int    i, j;
428  
429          DCHECK(vn<0 | vn>=odNViews, CONSISTENCY,
430                          "bad view number in odUpdate");
431                                          /* need to do some tone mapping? */
432          if (needmapping & NEWRGB) {
433                  if (needmapping & NEWMAP) {
434 <                        tmClearHisto();
434 >                        if (needmapping & NEWHIST)
435 >                                tmClearHisto();
436                          if (tmAddHisto(odS.brt,odS.nsamp,1) != TM_E_OK)
437                                  return;
438                          if (tmComputeMapping(0.,0.,0.) != TM_E_OK)
439                                  return;
440 <                        for (k = odS.nsamp; k--; )      /* redraw all */
441 <                                if (odS.ip[k][0] >= 0)
442 <                                        SET4(odS.redraw, k);
440 >                        for (i = odS.nsamp; i--; )      /* redraw all */
441 >                                if (odS.ip[i][0] >= 0)
442 >                                        SET4(odS.redraw, i);
443                  }
444                  if (tmMapPixels(odS.rgb,odS.brt,odS.chr,odS.nsamp) != TM_E_OK)
445                          return;
446                  needmapping = 0;                /* reset flag */
447          }
448 <                                        /* draw each block in view */
449 <        for (i = odView[vn].hlow; i--; )
450 <                for (j = odView[vn].vlow; j--; ) {
451 <                                        /* get block */
452 <                        bp = odView[vn].bmap + j*odView[vn].hlow + i;
453 <                                        /* do quick, conservative flag check */
454 <                        for (k = (bp->first+bp->nsamp+31)>>5;
401 <                                        k-- > bp->first>>5; )
402 <                                if (odS.redraw[k])
403 <                                        break;          /* non-zero flag */
404 <                        if (k < bp->first>>5)
405 <                                continue;               /* no flags set */
406 <                        for (k = bp->nsamp; k--; )      /* sample by sample */
407 <                                if (CHK4(odS.redraw, bp->first+k)) {
408 <                                        odDrawBlockSamp(vn, i, j, bp->first+k);
409 <                                        CLR4(odS.redraw, bp->first+k);
410 <                                }
411 <                }
448 >                                        /* draw samples flagged for redraw */
449 >        for (j = FL4NELS(odS.nsamp); j--; )
450 >                for (i = 0; odS.redraw[j]; i++)         /* skips faster */
451 >                        if (odS.redraw[j] & 1L<<i) {
452 >                                odDrawSamp(vn, (j<<5)+i);
453 >                                odS.redraw[j] &= ~(1L<<i);
454 >                        }
455   }
456  
457  
# Line 547 | Line 590 | register int   h, v;
590   }
591  
592  
593 < odDrawBlockSamp(vn, h, v, id)           /* draw sample in view block */
594 < int     vn, h, v;
593 > odDrawSamp(vn, id)                      /* draw view sample */
594 > int     vn;
595   register int    id;
596   {
597          GLshort arm[MAXFAN][3];
# Line 559 | Line 602 | register int   id;
602          register int    i;
603  
604          vp = odView + vn;
605 <        blockindex = v*vp->hlow + h;
606 <        DCHECK(odS.ip[id][0]*vp->hlow/vp->hhi != h |
564 <                        odS.ip[id][1]*vp->vlow/vp->vhi != v,
565 <                        CONSISTENCY, "bad sample position in odDrawBlockSamp");
605 >        blockindex = getblock(vp, odS.ip[id][0], odS.ip[id][1]);
606 >        DCHECK(blockindex<0, CONSISTENCY, "bad sample handed to odDrawSamp");
607          DCHECK(vp->bmap[blockindex].nused <= 0,
608 <                        CONSISTENCY, "bad in-use count in odDrawBlockSamp");
608 >                        CONSISTENCY, "bad in-use count in odDrawSamp");
609                                          /* create triangle fan */
610          size = 1./sqrt((double)vp->bmap[blockindex].nused);
611          narms = make_arms(arm, odS.ip[id], vp, size);

Diff Legend

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