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

Comparing ray/src/rt/rv3.c (file contents):
Revision 2.25 by greg, Thu Aug 28 23:50:39 2008 UTC vs.
Revision 2.33 by greg, Fri Oct 8 20:41:04 2010 UTC

# Line 16 | Line 16 | static const char      RCSid[] = "$Id$";
16   #include  "random.h"
17  
18   #ifndef WFLUSH
19 < #define WFLUSH          64              /* flush after this many rays */
19 > #define WFLUSH          64              /* flush after this many primary rays */
20   #endif
21 + #ifndef WFLUSH1
22 + #define WFLUSH1         512             /* or this many total rays */
23 + #endif
24  
25 +
26   #ifdef  SMLFLT
27   #define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
28   #else
29   #define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
30   #endif
31  
32 < static unsigned long  niflush;          /* flushes since newimage() */
32 > static RNUMBER  niflush;                /* flushes since newimage() */
33  
34   int
35   getrect(                                /* get a box */
# Line 146 | Line 150 | greyof(                                /* convert color to greyscale */
150          return(gcol);
151   }
152  
153 + static void
154 + recolor(                                        /* recolor the given node */
155 +        PNODE *p
156 + )
157 + {
158 +        while (p->kid != NULL) {                /* need to propogate down */
159 +                int  mx = (p->xmin + p->xmax) >> 1;
160 +                int  my = (p->ymin + p->ymax) >> 1;
161 +                int  ki;
162 +                if (p->x >= mx)
163 +                        ki = (p->y >= my) ? UR : DR;
164 +                else
165 +                        ki = (p->y >= my) ? UL : DL;
166 +                pcopy(p, p->kid+ki);
167 +                p = p->kid + ki;
168 +        }
169  
170 +        (*dev->paintr)(greyscale?greyof(p->v):p->v,
171 +                        p->xmin, p->ymin, p->xmax, p->ymax);
172 + }
173 +
174   int
175   paint(                  /* compute and paint a rectangle */
176          PNODE  *p
177   )
178   {
155 –        extern int  ray_pnprocs;
156 –        static unsigned long  lastflush = 0;
179          static RAY  thisray;
158 –        int     flushintvl;
180          double  h, v;
181  
182 <        if (p->xmax - p->xmin <= 0 || p->ymax - p->ymin <= 0) { /* empty */
182 >        if ((p->xmax <= p->xmin) | (p->ymax <= p->ymin)) {      /* empty */
183                  p->x = p->xmin;
184                  p->y = p->ymin;
185                  setcolor(p->v, 0.0, 0.0, 0.0);
# Line 171 | Line 192 | paint(                 /* compute and paint a rectangle */
192          if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir, &ourview,
193                          h/hresolu, v/vresolu)) < -FTINY) {
194                  setcolor(thisray.rcol, 0.0, 0.0, 0.0);
195 <        } else {
196 <                int  rval;
195 >        } else if (nproc == 1) {                /* immediate mode */
196 >                ray_trace(&thisray);
197 >        } else {                                /* queuing mode */
198 >                int     rval;
199                  rayorigin(&thisray, PRIMARY, NULL, NULL);
200 <                thisray.rno = (unsigned long)p;
200 >                thisray.rno = (RNUMBER)p;
201                  rval = ray_pqueue(&thisray);
202                  if (!rval)
203                          return(0);
204                  if (rval < 0)
205                          return(-1);
206 +                                                /* random color place holder */
207 +                setcolor(p->v, frandom(), frandom(), frandom());
208 +                                                /* get node for returned ray */
209                  p = (PNODE *)thisray.rno;
210          }
211  
212          copycolor(p->v, thisray.rcol);
213          scalecolor(p->v, exposure);
214  
215 <        while (p->kid != NULL) {                /* need to propogate down */
216 <                int  mx = (p->xmin + p->xmax) >> 1;
217 <                int  my = (p->ymin + p->ymax) >> 1;
218 <                int  ki;
219 <                if (p->x >= mx)
220 <                        ki = (p->y >= my) ? UR : DR;
215 >        recolor(p);                             /* paint it */
216 >
217 >        if (dev->flush != NULL) {               /* shall we check for input? */
218 >                static RNUMBER  lastflush = 0;
219 >                RNUMBER         counter = raynum;
220 >                int             flushintvl;
221 >                if (nproc == 1) {
222 >                        counter = nrays;
223 >                        flushintvl = WFLUSH1;
224 >                } else if (ambounce == 0)
225 >                        flushintvl = nproc*WFLUSH;
226 >                else if (niflush < WFLUSH)
227 >                        flushintvl = nproc*niflush/(ambounce+1);
228                  else
229 <                        ki = (p->y >= my) ? UL : DL;
230 <                pcopy(p, p->kid+ki);
231 <                p = p->kid + ki;
199 <        }
229 >                        flushintvl = nproc*WFLUSH/(ambounce+1);
230 >                if (lastflush > counter)
231 >                        lastflush = 0;          /* counter wrapped */
232  
233 <        (*dev->paintr)(greyscale?greyof(p->v):p->v,
234 <                        p->xmin, p->ymin, p->xmax, p->ymax);
235 <
236 <        if (ambounce <= 0)                      /* shall we check for input? */
237 <                flushintvl = ray_pnprocs*WFLUSH;
206 <        else if (niflush < WFLUSH)
207 <                flushintvl = ray_pnprocs*niflush/(ambounce+1);
208 <        else
209 <                flushintvl = ray_pnprocs*WFLUSH/(ambounce+1);
210 <
211 <        if (dev->flush != NULL && raynum - lastflush >= flushintvl) {
212 <                lastflush = raynum;
213 <                (*dev->flush)();
214 <                niflush++;
233 >                if (counter - lastflush >= flushintvl) {
234 >                        lastflush = counter;
235 >                        (*dev->flush)();
236 >                        niflush++;
237 >                }
238          }
239          return(1);
240   }
# Line 223 | Line 246 | waitrays(void)                                 /* finish up pending rays */
246          int     nwaited = 0;
247          int     rval;
248          RAY     raydone;
249 <        
249 >
250 >        if (nproc <= 1)                         /* immediate mode? */
251 >                return(0);
252          while ((rval = ray_presult(&raydone, 0)) > 0) {
253                  PNODE  *p = (PNODE *)raydone.rno;
254                  copycolor(p->v, raydone.rcol);
255                  scalecolor(p->v, exposure);
256 <                (*dev->paintr)(greyscale?greyof(p->v):p->v,
232 <                                p->xmin, p->ymin, p->xmax, p->ymax);
256 >                recolor(p);
257                  nwaited++;
258          }
259          if (rval < 0)
# Line 243 | Line 267 | newimage(                                      /* start a new image */
267          char *s
268   )
269   {
270 <        int     newnp;
270 >        extern int      ray_pnprocs;
271 >        int             newnp;
272                                                  /* change in nproc? */
273 <        if (s != NULL && sscanf(s, "%d", &newnp) == 1 && newnp > 0) {
273 >        if (s != NULL && sscanf(s, "%d", &newnp) == 1 &&
274 >                        (newnp > 0) & (newnp != nproc)) {
275                  if (!newparam) {
276 <                        if (newnp < nproc)
277 <                                ray_pclose(nproc - newnp);
276 >                        if (newnp == 1)
277 >                                ray_pclose(0);
278 >                        else if (newnp < ray_pnprocs)
279 >                                ray_pclose(ray_pnprocs - newnp);
280                          else
281 <                                ray_popen(newnp - nproc);
281 >                                ray_popen(newnp - ray_pnprocs);
282                  }
283                  nproc = newnp;
284          }
# Line 268 | Line 296 | newimage(                                      /* start a new image */
296          (*dev->clear)(hresolu, vresolu);
297  
298          if (newparam) {                         /* (re)start rendering procs */
299 <                ray_pclose(0);
300 <                ray_popen(nproc);
299 >                if (ray_pnprocs > 0)
300 >                        ray_pclose(0);
301 >                if (nproc > 1)
302 >                        ray_popen(nproc);
303                  newparam = 0;
304          }
305          niflush = 0;                            /* get first value */
# Line 367 | Line 397 | findrect(                              /* find a rectangle */
397                  }
398          }
399          return(p);
400 + }
401 +
402 +
403 + void
404 + compavg(                                /* recompute averages */
405 +        PNODE   *p
406 + )
407 + {
408 +        int     i, navg;
409 +        
410 +        if (p->kid == NULL)
411 +                return;
412 +
413 +        setcolor(p->v, .0, .0, .0);
414 +        navg = 0;
415 +        for (i = 0; i < 4; i++) {
416 +                if (p->kid[i].xmin >= p->kid[i].xmax) continue;
417 +                if (p->kid[i].ymin >= p->kid[i].ymax) continue;
418 +                compavg(p->kid+i);
419 +                addcolor(p->v, p->kid[i].v);
420 +                navg++;
421 +        }
422 +        if (navg > 1)
423 +                scalecolor(p->v, 1./navg);
424   }
425  
426  

Diff Legend

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