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

Comparing ray/src/hd/rhd_qtree.c (file contents):
Revision 3.16 by gregl, Wed Dec 31 09:06:54 1997 UTC vs.
Revision 3.24 by schorsch, Mon Jul 21 22:30:18 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1997 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Quadtree driver support routines.
6   */
7  
8 + #include <string.h>
9 +
10   #include "standard.h"
11   #include "rhd_qtree.h"
12                                  /* quantity of leaves to free at a time */
# Line 29 | Line 28 | double qtDepthEps = .05;       /* epsilon to compare depths
28   int     qtMinNodesiz = 2;       /* minimum node dimension (pixels) */
29   struct rleaves  qtL;            /* our pile of leaves */
30  
31 < static int4     falleaves;      /* our list of fallen leaves */
31 > int     rayqleft = 0;           /* rays left to queue before flush */
32  
33 + static int32    falleaves;      /* our list of fallen leaves */
34 +
35   #define composted(li)   (qtL.bl <= qtL.tl ? \
36                                          ((li) < qtL.bl || (li) >= qtL.tl) : \
37                                          ((li) < qtL.bl && (li) >= qtL.tl))
# Line 54 | Line 55 | newtwig()                      /* allocate a twig */
55          }
56          bi = nexttwig / TBUNDLESIZ;
57          if (twigbundle[bi] == NULL) {   /* new block */
58 <                twigbundle = (RTREE **)realloc((char *)twigbundle,
58 >                twigbundle = (RTREE **)realloc((void *)twigbundle,
59                                          (bi+2)*sizeof(RTREE *));
60                  if (twigbundle == NULL)
61                          goto memerr;
# Line 82 | Line 83 | int    really;
83          nexttwig = 0;
84          if (!really) {          /* just clear allocated blocks */
85                  while (i--)
86 <                        bzero((char *)twigbundle[i], TBUNDLESIZ*sizeof(RTREE));
86 >                        memset((char *)twigbundle[i], '\0', TBUNDLESIZ*sizeof(RTREE));
87                  return;
88          }
89                                  /* else "really" means free up memory */
90          for (i = 0; twigbundle[i] != NULL; i++)
91 <                free((char *)twigbundle[i]);
92 <        free((char *)twigbundle);
91 >                free((void *)twigbundle[i]);
92 >        free((void *)twigbundle);
93          twigbundle = NULL;
94   }
95  
96  
97 < #define LEAFSIZ         (3*sizeof(float)+sizeof(int4)+\
97 > #define LEAFSIZ         (3*sizeof(float)+sizeof(int32)+\
98                          sizeof(TMbright)+6*sizeof(BYTE))
99  
100   int
# Line 120 | Line 121 | register int   n;
121                  return(0);
122                                  /* assign larger alignment types earlier */
123          qtL.wp = (float (*)[3])qtL.base;
124 <        qtL.wd = (int4 *)(qtL.wp + n);
124 >        qtL.wd = (int32 *)(qtL.wp + n);
125          qtL.brt = (TMbright *)(qtL.wd + n);
126          qtL.chr = (BYTE (*)[3])(qtL.brt + n);
127          qtL.rgb = (BYTE (*)[3])(qtL.chr + n);
# Line 167 | Line 168 | int
168   qtCompost(pct)                  /* free up some leaves */
169   int     pct;
170   {
171 <        register int4   *fl;
171 >        register int32  *fl;
172          int     nused, nclear, nmapped;
173                                  /* figure out how many leaves to clear */
174          nclear = qtL.nl * pct / 100;
# Line 318 | Line 319 | int    drop;
319                  tp->k[q].li = lo;
320          }
321   dropit:
322 <        if (drop)
322 >        if (drop) {
323                  if (li+1 == (qtL.tl ? qtL.tl : qtL.nl))
324                          qtL.tl = li;            /* special case */
325                  else {
# Line 326 | Line 327 | dropit:
327                          qtL.wd[li] = falleaves;
328                          falleaves = li;
329                  }
330 +        }
331          return(li == lo);
332   }
333  
334  
335 < dev_value(c, p, v)              /* add a pixel value to our quadtree */
335 > dev_value(c, d, p)              /* add a pixel value to our quadtree */
336   COLR    c;
337 < FVECT   p, v;
337 > FVECT   d, p;
338   {
339          register int    li;
340          int     mapit;
# Line 351 | Line 353 | FVECT  p, v;
353                          qtCompost(LFREEPCT);
354                  mapit = 0;                      /* we'll map it later */
355          }
356 <        VCOPY(qtL.wp[li], p);
357 <        qtL.wd[li] = encodedir(v);
358 <        tmCvColrs(&qtL.brt[li], qtL.chr[li], c, 1);
359 <        if (putleaf(li, 1) && mapit)
360 <                tmMapPixels(qtL.rgb+li, qtL.brt+li, qtL.chr+li, 1);
356 >        if (p == NULL)
357 >                VSUM(qtL.wp[li], odev.v.vp, d, FHUGE);
358 >        else
359 >                VCOPY(qtL.wp[li], p);
360 >        qtL.wd[li] = encodedir(d);
361 >        tmCvColrs(&qtL.brt[li], qtL.chr[li], (COLR *)c, 1);
362 >        if (putleaf(li, 1)) {
363 >                if (mapit)
364 >                        tmMapPixels((BYTE *)(qtL.rgb+li), qtL.brt+li,
365 >                                        (BYTE *)(qtL.chr+li), 1);
366 >                if (--rayqleft == 0)
367 >                        dev_flush();            /* flush output */
368 >        }
369   }
370  
371  
# Line 403 | Line 413 | int    redo;
413                  if (tmComputeMapping(0., 0., 0.) != TM_E_OK)
414                          return(0);
415          }
416 <        if (tmMapPixels(qtL.rgb+aorg, qtL.brt+aorg,
417 <                        qtL.chr+aorg, alen) != TM_E_OK)
416 >        if (tmMapPixels((BYTE *)(qtL.rgb+aorg), qtL.brt+aorg,
417 >                        (BYTE *)(qtL.chr+aorg), alen) != TM_E_OK)
418                  return(0);
419          if (blen > 0)
420 <                tmMapPixels(qtL.rgb+borg, qtL.brt+borg,
421 <                                qtL.chr+borg, blen);
420 >                tmMapPixels((BYTE *)(qtL.rgb+borg), qtL.brt+borg,
421 >                                (BYTE *)(qtL.chr+borg), blen);
422          qtL.tml = qtL.tl;
423          return(1);
424   }

Diff Legend

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